Space deploy: orphan commit with Docker config + LFS pointers

.gitattributes

@@ -0,0 +1,8 @@
+screenshots/*.png filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.jar filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text

.github/workflows/deploy-to-hf-space.yml

@@ -0,0 +1,113 @@
+name: Deploy to Hugging Face Space (Docker)
+
+on:
+  push:
+    branches: [ master ]          # change if your default branch differs
+  workflow_dispatch:
+
+jobs:
+  deploy:
+    name: Create Docker Space + push orphan LFS deploy
+    runs-on: ubuntu-latest
+
+    defaults:
+      run:
+        shell: bash
+
+    env:
+      HF_TOKEN: ${{ secrets.HF_TOKEN }}   # HF token with write access
+      HF_USERNAME: Phoenix21              # your HF username/org
+      HF_SPACE: SpringGeminiChat          # Space name
+
+    steps:
+      # 0) Checkout repo (full history; not shallow)
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          lfs: false
+
+      # 1) Install hub client + Git LFS
+      - name: Install hub client + git-lfs
+        run: |
+          set -euo pipefail
+          python -m pip install --upgrade pip
+          python -m pip install "huggingface_hub>=0.23"
+          sudo apt-get update
+          sudo apt-get install -y git-lfs
+          git lfs install
+
+      # 2) Create Space if missing (SDK = docker)
+      - name: Create Space if missing (SDK = docker)
+        shell: python
+        env:
+          HF_TOKEN: ${{ env.HF_TOKEN }}
+          HF_USERNAME: ${{ env.HF_USERNAME }}
+          HF_SPACE: ${{ env.HF_SPACE }}
+        run: |
+          import os
+          from huggingface_hub import HfApi
+          api = HfApi(token=os.environ["HF_TOKEN"])
+          repo_id = f"{os.environ['HF_USERNAME']}/{os.environ['HF_SPACE']}"
+          try:
+            api.repo_info(repo_id, repo_type="space")
+            print(f"Space exists: {repo_id}")
+          except Exception:
+            api.create_repo(
+              repo_id=repo_id,
+              repo_type="space",
+              space_sdk="docker",   # ensure a Docker Space
+              private=False
+            )
+            print(f"Space created: {repo_id}")
+
+      # 3) Build an orphan deploy snapshot with Docker README + LFS
+      - name: Prepare orphan deploy commit (no heredoc; Docker README + LFS)
+        run: |
+          set -euo pipefail
+
+          # Orphan branch so Space won't inherit non-LFS history
+          git checkout --orphan space-deploy
+
+          # Ensure README has Docker Space YAML (sdk + port) WITHOUT heredoc
+          if ! grep -qE '^sdk:\s*docker' README.md 2>/dev/null; then
+            tmp="$(mktemp)"
+            printf '%s\n' '---' 'title: Spring Gemini Chat (Docker)' 'sdk: docker' 'app_port: 7860' '---' '' > "$tmp"
+            [ -f README.md ] && cat README.md >> "$tmp" || true
+            mv "$tmp" README.md
+          fi
+
+          # Track images/binaries with LFS (HF requires LFS for binaries)
+          git lfs track "screenshots/*.png"
+          git lfs track "*.png" "*.jpg" "*.jpeg" "*.gif" "*.webp" "*.zip" "*.jar"
+          git add .gitattributes
+
+          # Stage EVERYTHING so the Space receives your full repo snapshot
+          git add -A .
+
+          # Optional diagnostics
+          echo "---- git status ----"; git status -s || true
+          echo "---- sample files ----"; git ls-files | head -n 50 || true
+          echo "---- LFS pointers ----"; git lfs ls-files || true
+
+          # Ignore build outputs
+          printf '%s\n' "target/" "*.log" >> .gitignore
+          git add .gitignore
+
+          # Commit the deploy snapshot
+          git config user.name  "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git commit -m "Space deploy: orphan commit with Docker config + LFS pointers"
+          git log --oneline -1
+
+      # 4) Push to Space (force first sync) and verify remote SHA
+      - name: Push to Space (force first sync + verify)
+        run: |
+          set -euo pipefail
+          SPACE_PATH="${HF_USERNAME}/${HF_SPACE}"
+          git remote remove space 2>/dev/null || true
+          git remote add    space "https://${HF_USERNAME}:${HF_TOKEN}@huggingface.co/spaces/${SPACE_PATH}"
+
+          echo "Local HEAD before push:"; git rev-parse HEAD
+          git push --force space space-deploy:main
+          echo "Remote main after push (new SHA expected):"
+          git ls-remote --heads space refs/heads/main || true

.gitignore

@@ -0,0 +1,35 @@
+HELP.md
+target/
+.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+!**/src/main/resources/application.properties
+### VS Code ###
+.vscode/
+target/
+*.log

Dockerfile

@@ -0,0 +1,40 @@
+# syntax=docker/dockerfile:1
+
+############################
+# 1) Build stage (Maven)
+############################
+FROM maven:3.9-eclipse-temurin-17 AS build
+WORKDIR /workspace
+
+# Copy only pom first to warm dependency cache
+COPY pom.xml .
+RUN mvn -B -q -DskipTests dependency:go-offline
+
+# Now copy sources and build
+COPY src ./src
+RUN mvn -B -DskipTests package
+
+############################
+# 2) Runtime stage (JRE)
+############################
+FROM eclipse-temurin:17-jre-jammy
+
+# Hugging Face Spaces containers run with UID 1000; create matching user to avoid permission issues
+# (Recommended in Docker Spaces docs)
+RUN useradd -m -u 1000 appuser
+USER appuser
+WORKDIR /home/appuser
+
+# Bring in built jar
+COPY --from=build /workspace/target/*.jar app.jar
+
+# Default port Spaces expose is 7860; the README's app_port can change it.
+# We'll respect $PORT if Spaces set it; otherwise default to 7860.
+ENV PORT=7860
+ENV JAVA_OPTS=""
+
+# Optional: Expose for local runs
+EXPOSE 7860
+
+# Run Spring on the Space port, bind to 0.0.0.0 so the Space can reach it
+ENTRYPOINT ["sh","-c","java $JAVA_OPTS -jar /home/appuser/app.jar --server.port=${PORT} --server.address=0.0.0.0"]

README.md

@@ -0,0 +1,337 @@
+---
+title: SpringGeminiChat
+emoji: 🏢
+colorFrom: purple
+colorTo: yellow
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# 🤖 Spring Gemini Chat
+
+A modern, reactive Spring Boot application that integrates with Google's Gemini AI to provide intelligent chat capabilities. Built with Spring WebFlux for high-performance, non-blocking operations and featuring a clean, responsive web interface.
+
+## 📸 Screenshots
+
+### Chat Interface
+![Chat Interface](screenshots/chat-interface.png)
+*Modern, responsive chat UI with real-time messaging*
+
+### API Response Example
+![API Response](screenshots/api-response.png)
+*JSON response structure from the Gemini integration*
+
+### Health Check Dashboard
+![Health Check](screenshots/health-check.png)
+*Backend status and monitoring*
+
+---
+
+## ✨ Features
+
+- 🚀 **Reactive Programming** - Built with Spring WebFlux for non-blocking operations
+- 🤖 **Gemini AI Integration** - Powered by Google's latest Gemini AI model
+- 💬 **Real-time Chat** - Instant responses with typing indicators
+- 🎨 **Modern UI** - Clean, responsive web interface
+- 📱 **Mobile Friendly** - Works seamlessly on all devices
+- 🔄 **Health Monitoring** - Built-in health checks and status indicators
+- 🛡️ **Error Handling** - Comprehensive error handling and validation
+- ⚡ **High Performance** - Optimized for speed and scalability
+- 🔧 **Easy Configuration** - Environment-based configuration
+- 📊 **Conversation Context** - Support for contextual conversations
+
+## 🛠️ Technology Stack
+
+### Backend
+- **Java 17** - Programming language
+- **Spring Boot 3.1.5** - Application framework
+- **Spring WebFlux** - Reactive programming
+- **Spring Validation** - Input validation
+- **Maven** - Dependency management
+- **Google Gemini AI** - AI language model
+
+### Frontend
+- **HTML5** - Structure
+- **CSS3** - Styling with modern animations
+- **Vanilla JavaScript** - Interactive functionality
+- **Fetch API** - HTTP requests
+
+## 📋 Prerequisites
+
+Before you begin, ensure you have the following installed:
+
+- ☑️ **Java 17 or higher**
+- ☑️ **Maven 3.6+**
+- ☑️ **Git**
+- ☑️ **Google Gemini API Key** ([Get it here](https://makersuite.google.com/app/apikey))
+
+## 🚀 Quick Start
+
+### 1. Clone the Repository
+```bash
+git clone https://github.com/yourusername/spring-gemini-chat.git
+cd spring-gemini-chat
+```
+
+### 2. Set Environment Variables
+```bash
+# Windows
+set GEMINI_API_KEY=your_actual_gemini_api_key_here
+
+# macOS/Linux
+export GEMINI_API_KEY=your_actual_gemini_api_key_here
+```
+
+### 3. Build and Run
+```bash
+# Clean and install dependencies
+mvn clean install
+
+# Run the application
+mvn spring-boot:run
+```
+
+### 4. Access the Application
+- **Backend API**: http://localhost:8080
+- **Health Check**: http://localhost:8080/api/chat/health
+- **Frontend UI**: Open `chat-ui.html` in your browser
+
+## 📚 API Documentation
+
+### Base URL
+```
+http://localhost:8080/api/chat
+```
+
+### Endpoints
+
+#### 💬 Send Message
+```http
+POST /message
+Content-Type: application/json
+
+{
+  "message": "Hello, how are you?"
+}
+```
+
+**Response:**
+```json
+{
+  "response": "I'm doing well, thank you for asking! How can I help you today?",
+  "success": true,
+  "error": null,
+  "timestamp": 1692994488297
+}
+```
+
+#### 🗣️ Conversation with Context
+```http
+POST /conversation
+Content-Type: application/json
+
+{
+  "messages": [
+    {
+      "role": "user",
+      "content": "What is Spring Boot?"
+    },
+    {
+      "role": "assistant", 
+      "content": "Spring Boot is a Java framework..."
+    },
+    {
+      "role": "user",
+      "content": "Can you give me an example?"
+    }
+  ]
+}
+```
+
+#### 📡 Streaming Response
+```http
+POST /stream
+Content-Type: application/json
+
+{
+  "message": "Tell me a story"
+}
+```
+
+#### 🔍 Health Check
+```http
+GET /health
+```
+
+**Response:**
+```json
+{
+  "status": "UP",
+  "service": "Chat Service", 
+  "timestamp": 1692994488297
+}
+```
+
+## ⚙️ Configuration
+
+### Application Properties
+```properties
+# Server Configuration
+server.port=8080
+
+# Gemini AI Configuration
+gemini.api.key=${GEMINI_API_KEY:your-api-key-here}
+gemini.api.base-url=https://generativelanguage.googleapis.com/v1beta/models
+gemini.api.model=gemini-1.5-flash
+gemini.api.timeout=30000
+
+# CORS Configuration
+cors.allowed-origins=http://localhost:3000,http://localhost:8080
+```
+
+### Environment Variables
+| Variable | Description | Required | Default |
+|----------|-------------|----------|---------|
+| `GEMINI_API_KEY` | Your Google Gemini API key | ✅ Yes | - |
+| `SERVER_PORT` | Server port | ❌ No | 8080 |
+| `GEMINI_MODEL` | Gemini model to use | ❌ No | gemini-1.5-flash |
+
+## 🧪 Testing
+
+### Run Unit Tests
+```bash
+mvn test
+```
+
+### Run Integration Tests
+```bash
+mvn verify
+```
+
+### Manual Testing with cURL
+
+**Windows Command Prompt:**
+```cmd
+curl -X POST http://localhost:8080/api/chat/message -H "Content-Type: application/json" -d "{\"message\": \"Hello!\"}"
+```
+
+**PowerShell/Linux/macOS:**
+```bash
+curl -X POST http://localhost:8080/api/chat/message \
+  -H "Content-Type: application/json" \
+  -d '{"message": "Hello!"}'
+```
+
+## 🏗️ Project Structure
+
+```
+spring-gemini-chat/
+├── src/
+│   ├── main/
+│   │   ├── java/com/example/p1/
+│   │   │   ├── P1Application.java           # Main application
+│   │   │   ├── config/
+│   │   │   │   └── AiConfiguration.java     # Configuration
+│   │   │   ├── controller/
+│   │   │   │   └── ChatController.java      # REST endpoints
+│   │   │   └── service/
+│   │   │       └── ChatService.java         # Business logic
+│   │   └── resources/
+│   │       └── application.properties       # Configuration
+│   └── test/
+│       └── java/com/example/p1/
+│               └── P1ApplicationTests.java 
+├── index.html                            # Frontend interface
+├── screenshots/                            # UI screenshots
+├── pom.xml                                 # Maven configuration
+└── README.md                              # This file
+```
+
+## 🚀 Deployment
+
+### Using Docker
+```dockerfile
+FROM openjdk:17-jdk-slim
+COPY target/*.jar app.jar
+EXPOSE 8080
+ENTRYPOINT ["java","-jar","/app.jar"]
+```
+
+```bash
+# Build the application
+mvn clean package
+
+# Build Docker image
+docker build -t spring-gemini-chat .
+
+# Run container
+docker run -p 8080:8080 -e GEMINI_API_KEY=your_key spring-gemini-chat
+```
+
+### Using JAR
+```bash
+# Build JAR
+mvn clean package
+
+# Run JAR
+java -jar target/p1-0.0.1-SNAPSHOT.jar
+```
+
+## 🤝 Contributing
+
+We welcome contributions! Please follow these steps:
+
+1. **Fork the repository**
+2. **Create a feature branch** (`git checkout -b feature/amazing-feature`)
+3. **Commit your changes** (`git commit -m 'Add some amazing feature'`)
+4. **Push to the branch** (`git push origin feature/amazing-feature`)
+5. **Open a Pull Request**
+
+### Development Guidelines
+- Follow Java coding conventions
+- Write unit tests for new features
+- Update documentation for API changes
+- Use meaningful commit messages
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+**❌ "Connection failed" in UI**
+- Ensure backend is running on port 8080
+- Check CORS configuration
+- Verify network connectivity
+
+**❌ "API key not found" error**
+- Set GEMINI_API_KEY environment variable
+- Restart the application after setting the key
+- Verify the API key is valid
+
+**❌ Maven build fails**
+- Check Java version (requires Java 17+)
+- Clear Maven cache: `mvn clean`
+- Update dependencies: `mvn dependency:resolve -U`
+
+**❌ CORS errors**
+- Check allowed origins in `AiConfiguration.java`
+- Verify frontend URL matches CORS settings
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- **Google Gemini AI** - For providing the AI capabilities
+- **Spring Team** - For the excellent Spring Boot framework
+- **Contributors** - Thanks to all who contribute to this project
+
+## 📞 Support
+
+- 📧 **Email**: aniket21stcentury@gmail.com
+- 🐛 **Issues**: [GitHub Issues](https://github.com/aniketqw/spring-gemini-chat/issues)
+- 💬 **Discussions**: [GitHub Discussions](https://github.com/aniketqw/spring-gemini-chat/discussions)
+
+---
+

pom.xml

@@ -0,0 +1,167 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
+         https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>3.1.5</version>
+        <relativePath/>
+    </parent>
+
+    <groupId>com.example</groupId>
+    <artifactId>p1</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>p1</name>
+    <description>Chat application with Gemini AI</description>
+
+    <properties>
+        <java.version>17</java.version>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <dependencies>
+        <!-- Spring Boot Web Starter -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+
+        <!-- Spring Boot WebFlux for reactive programming -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-webflux</artifactId>
+        </dependency>
+
+        <!-- Spring Boot Validation -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+        </dependency>
+
+        <!-- Configuration Processor -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-configuration-processor</artifactId>
+            <optional>true</optional>
+        </dependency>
+
+        <!-- Jackson for JSON processing -->
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+
+        <!-- Spring Boot Test Starter -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <!-- Reactor Test for reactive testing -->
+        <dependency>
+            <groupId>io.projectreactor</groupId>
+            <artifactId>reactor-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>5.3.1</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testng</groupId>
+            <artifactId>testng</artifactId>
+            <version>RELEASE</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-test-autoconfigure</artifactId>
+            <version>3.1.5</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <version>6.0.13</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-actuator</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.springframework.boot</groupId>
+                            <artifactId>spring-boot-configuration-processor</artifactId>
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.11.0</version>
+                <configuration>
+                    <source>17</source>
+                    <target>17</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <repositories>
+        <repository>
+            <id>spring-milestones</id>
+            <name>Spring Milestones</name>
+            <url>https://repo.spring.io/milestone</url>
+            <snapshots>
+                <enabled>false</enabled>
+            </snapshots>
+        </repository>
+        <repository>
+            <id>spring-snapshots</id>
+            <name>Spring Snapshots</name>
+            <url>https://repo.spring.io/snapshot</url>
+            <releases>
+                <enabled>false</enabled>
+            </releases>
+        </repository>
+    </repositories>
+
+    <pluginRepositories>
+        <pluginRepository>
+            <id>spring-milestones</id>
+            <name>Spring Milestones</name>
+            <url>https://repo.spring.io/milestone</url>
+            <snapshots>
+                <enabled>false</enabled>
+            </snapshots>
+        </pluginRepository>
+        <pluginRepository>
+            <id>spring-snapshots</id>
+            <name>Spring Snapshots</name>
+            <url>https://repo.spring.io/snapshot</url>
+            <releases>
+                <enabled>false</enabled>
+            </releases>
+        </pluginRepository>
+    </pluginRepositories>
+</project>

src/index.html

@@ -0,0 +1,499 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Gemini Chat - Test UI</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            height: 100vh;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+        }
+
+        .chat-container {
+            background: white;
+            border-radius: 20px;
+            box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+            width: 90%;
+            max-width: 800px;
+            height: 600px;
+            display: flex;
+            flex-direction: column;
+            overflow: hidden;
+        }
+
+        .chat-header {
+            background: linear-gradient(45deg, #4CAF50, #45a049);
+            color: white;
+            padding: 20px;
+            text-align: center;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+
+        .header-info {
+            display: flex;
+            flex-direction: column;
+            align-items: flex-start;
+        }
+
+        .status-indicator {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 0.9em;
+            opacity: 0.9;
+        }
+
+        .status-dot {
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            background: #ff4444;
+            animation: pulse 2s infinite;
+        }
+
+        .status-dot.online {
+            background: #44ff44;
+        }
+
+        @keyframes pulse {
+            0% { opacity: 1; }
+            50% { opacity: 0.5; }
+            100% { opacity: 1; }
+        }
+
+        .chat-messages {
+            flex: 1;
+            padding: 20px;
+            overflow-y: auto;
+            background: #f8f9fa;
+            display: flex;
+            flex-direction: column;
+            gap: 15px;
+        }
+
+        .message {
+            display: flex;
+            gap: 10px;
+            animation: slideIn 0.3s ease-out;
+        }
+
+        @keyframes slideIn {
+            from {
+                opacity: 0;
+                transform: translateY(20px);
+            }
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+
+        .message.user {
+            justify-content: flex-end;
+        }
+
+        .message-bubble {
+            max-width: 70%;
+            padding: 12px 18px;
+            border-radius: 18px;
+            word-wrap: break-word;
+            line-height: 1.4;
+        }
+
+        .message.user .message-bubble {
+            background: linear-gradient(45deg, #007bff, #0056b3);
+            color: white;
+            border-bottom-right-radius: 4px;
+        }
+
+        .message.bot .message-bubble {
+            background: white;
+            border: 1px solid #e0e0e0;
+            color: #333;
+            border-bottom-left-radius: 4px;
+            box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+        }
+
+        .message-time {
+            font-size: 0.7em;
+            opacity: 0.7;
+            margin-top: 4px;
+        }
+
+        .typing-indicator {
+            display: none;
+            align-items: center;
+            gap: 10px;
+            padding: 15px 20px;
+            font-style: italic;
+            color: #666;
+        }
+
+        .typing-dots {
+            display: flex;
+            gap: 4px;
+        }
+
+        .typing-dot {
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            background: #4CAF50;
+            animation: typingDot 1.4s infinite ease-in-out;
+        }
+
+        .typing-dot:nth-child(2) { animation-delay: 0.2s; }
+        .typing-dot:nth-child(3) { animation-delay: 0.4s; }
+
+        @keyframes typingDot {
+            0%, 60%, 100% { transform: translateY(0); }
+            30% { transform: translateY(-10px); }
+        }
+
+        .chat-input-container {
+            padding: 20px;
+            background: white;
+            border-top: 1px solid #e0e0e0;
+        }
+
+        .chat-input-form {
+            display: flex;
+            gap: 10px;
+            align-items: center;
+        }
+
+        .chat-input {
+            flex: 1;
+            padding: 12px 18px;
+            border: 2px solid #e0e0e0;
+            border-radius: 25px;
+            outline: none;
+            font-size: 16px;
+            transition: border-color 0.3s;
+        }
+
+        .chat-input:focus {
+            border-color: #4CAF50;
+        }
+
+        .send-button {
+            background: linear-gradient(45deg, #4CAF50, #45a049);
+            color: white;
+            border: none;
+            border-radius: 50%;
+            width: 50px;
+            height: 50px;
+            cursor: pointer;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            transition: transform 0.2s, box-shadow 0.2s;
+            font-size: 20px;
+        }
+
+        .send-button:hover {
+            transform: scale(1.05);
+            box-shadow: 0 5px 15px rgba(76, 175, 80, 0.4);
+        }
+
+        .send-button:disabled {
+            background: #ccc;
+            cursor: not-allowed;
+            transform: none;
+            box-shadow: none;
+        }
+
+        .error-message {
+            background: #ffebee;
+            color: #c62828;
+            padding: 10px;
+            border-radius: 5px;
+            margin: 10px 20px;
+            border-left: 4px solid #f44336;
+            display: none;
+        }
+
+        .health-status {
+            font-size: 0.8em;
+            opacity: 0.8;
+        }
+
+        /* Responsive Design */
+        @media (max-width: 600px) {
+            .chat-container {
+                width: 95%;
+                height: 90vh;
+                margin: 20px;
+            }
+
+            .chat-header {
+                padding: 15px;
+            }
+
+            .chat-messages {
+                padding: 15px;
+            }
+
+            .message-bubble {
+                max-width: 85%;
+            }
+
+            .chat-input-container {
+                padding: 15px;
+            }
+        }
+
+        /* Scrollbar Styling */
+        .chat-messages::-webkit-scrollbar {
+            width: 6px;
+        }
+
+        .chat-messages::-webkit-scrollbar-track {
+            background: #f1f1f1;
+            border-radius: 3px;
+        }
+
+        .chat-messages::-webkit-scrollbar-thumb {
+            background: #c1c1c1;
+            border-radius: 3px;
+        }
+
+        .chat-messages::-webkit-scrollbar-thumb:hover {
+            background: #a8a8a8;
+        }
+    </style>
+</head>
+<body>
+<div class="chat-container">
+    <div class="chat-header">
+        <div class="header-info">
+            <h2>🤖 Gemini Chat Assistant</h2>
+            <div class="status-indicator">
+                <div class="status-dot" id="statusDot"></div>
+                <span id="statusText">Checking connection...</span>
+            </div>
+        </div>
+        <div class="health-status">
+            <button onclick="checkHealth()" style="background: rgba(255,255,255,0.2); border: 1px solid rgba(255,255,255,0.3); color: white; padding: 5px 10px; border-radius: 15px; cursor: pointer; font-size: 0.8em;">
+                🔄 Check Status
+            </button>
+        </div>
+    </div>
+
+    <div class="error-message" id="errorMessage"></div>
+
+    <div class="chat-messages" id="chatMessages">
+        <div class="message bot">
+            <div class="message-bubble">
+                👋 Hello! I'm your Gemini-powered chat assistant. How can I help you today?
+                <div class="message-time" id="welcomeTime"></div>
+            </div>
+        </div>
+    </div>
+
+    <div class="typing-indicator" id="typingIndicator">
+        <span>Gemini is thinking</span>
+        <div class="typing-dots">
+            <div class="typing-dot"></div>
+            <div class="typing-dot"></div>
+            <div class="typing-dot"></div>
+        </div>
+    </div>
+
+    <div class="chat-input-container">
+        <form class="chat-input-form" id="chatForm">
+            <input
+                    type="text"
+                    class="chat-input"
+                    id="messageInput"
+                    placeholder="Type your message here..."
+                    autocomplete="off"
+                    maxlength="1000"
+            >
+            <button type="submit" class="send-button" id="sendButton">
+                ➤
+            </button>
+        </form>
+    </div>
+</div>
+
+<script>
+    // Configuration
+    const API_BASE_URL = 'http://localhost:8080/api/chat';
+
+    // DOM Elements
+    const chatMessages = document.getElementById('chatMessages');
+    const messageInput = document.getElementById('messageInput');
+    const sendButton = document.getElementById('sendButton');
+    const chatForm = document.getElementById('chatForm');
+    const typingIndicator = document.getElementById('typingIndicator');
+    const errorMessage = document.getElementById('errorMessage');
+    const statusDot = document.getElementById('statusDot');
+    const statusText = document.getElementById('statusText');
+
+    // Initialize
+    document.addEventListener('DOMContentLoaded', function() {
+        document.getElementById('welcomeTime').textContent = getCurrentTime();
+        checkHealth();
+        messageInput.focus();
+    });
+
+    // Event Listeners
+    chatForm.addEventListener('submit', function(e) {
+        e.preventDefault();
+        sendMessage();
+    });
+
+    messageInput.addEventListener('keypress', function(e) {
+        if (e.key === 'Enter' && !e.shiftKey) {
+            e.preventDefault();
+            sendMessage();
+        }
+    });
+
+    // Functions
+    function getCurrentTime() {
+        return new Date().toLocaleTimeString('en-US', {
+            hour12: true,
+            hour: 'numeric',
+            minute: '2-digit'
+        });
+    }
+
+    function showError(message) {
+        errorMessage.textContent = message;
+        errorMessage.style.display = 'block';
+        setTimeout(() => {
+            errorMessage.style.display = 'none';
+        }, 5000);
+    }
+
+    function updateStatus(online, message) {
+        statusDot.className = `status-dot ${online ? 'online' : ''}`;
+        statusText.textContent = message;
+    }
+
+    async function checkHealth() {
+        try {
+            const response = await fetch(`${API_BASE_URL}/health`);
+            if (response.ok) {
+                const data = await response.json();
+                updateStatus(true, `Connected • ${data.service}`);
+            } else {
+                updateStatus(false, 'Backend unavailable');
+            }
+        } catch (error) {
+            updateStatus(false, 'Connection failed');
+            console.error('Health check failed:', error);
+        }
+    }
+
+    function addMessage(content, isUser = false) {
+        const messageDiv = document.createElement('div');
+        messageDiv.className = `message ${isUser ? 'user' : 'bot'}`;
+
+        const bubbleDiv = document.createElement('div');
+        bubbleDiv.className = 'message-bubble';
+        bubbleDiv.innerHTML = `
+                ${content}
+                <div class="message-time">${getCurrentTime()}</div>
+            `;
+
+        messageDiv.appendChild(bubbleDiv);
+        chatMessages.appendChild(messageDiv);
+
+        // Scroll to bottom
+        chatMessages.scrollTop = chatMessages.scrollHeight;
+    }
+
+    function showTypingIndicator() {
+        typingIndicator.style.display = 'flex';
+        chatMessages.scrollTop = chatMessages.scrollHeight;
+    }
+
+    function hideTypingIndicator() {
+        typingIndicator.style.display = 'none';
+    }
+
+    function setLoading(loading) {
+        sendButton.disabled = loading;
+        sendButton.textContent = loading ? '⏳' : '➤';
+        messageInput.disabled = loading;
+
+        if (loading) {
+            showTypingIndicator();
+        } else {
+            hideTypingIndicator();
+        }
+    }
+
+    async function sendMessage() {
+        const message = messageInput.value.trim();
+        if (!message) return;
+
+        // Add user message
+        addMessage(message, true);
+        messageInput.value = '';
+        setLoading(true);
+
+        try {
+            const response = await fetch(`${API_BASE_URL}/message`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ message: message })
+            });
+
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+
+            const data = await response.json();
+
+            if (data.success) {
+                // Format the response for better display
+                const formattedResponse = data.response
+                    .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
+                    .replace(/\n/g, '<br>');
+
+                addMessage(formattedResponse, false);
+            } else {
+                throw new Error(data.error || 'Unknown error occurred');
+            }
+
+        } catch (error) {
+            console.error('Error sending message:', error);
+            showError(`Failed to send message: ${error.message}`);
+            addMessage('😔 Sorry, I encountered an error. Please try again or check if the backend is running.', false);
+        } finally {
+            setLoading(false);
+            messageInput.focus();
+        }
+    }
+
+    // Auto-focus input when clicking anywhere in chat area
+    chatMessages.addEventListener('click', () => {
+        if (!messageInput.disabled) {
+            messageInput.focus();
+        }
+    });
+
+    // Check health status periodically
+    setInterval(checkHealth, 30000); // Check every 30 seconds
+</script>
+</body>
+</html>

src/main/java/com/example/p1/P1Application.java

@@ -0,0 +1,12 @@
+package com.example.p1;
+
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class P1Application {
+    public static void main(String[] args) {
+        SpringApplication.run(P1Application.class, args);
+    }
+}

src/main/java/com/example/p1/config/AiConfiguration.java

@@ -0,0 +1,49 @@
+package com.example.p1.config;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.reactive.function.client.WebClient;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@Configuration
+@ConfigurationProperties(prefix = "gemini.api")
+public class AiConfiguration implements WebMvcConfigurer {
+
+    private String key;
+    private String baseUrl;
+    private String model;
+    private int timeout = 30000;
+
+    @Bean
+    public WebClient geminiWebClient() {
+        return WebClient.builder()
+                .baseUrl(baseUrl)
+                .defaultHeader("Content-Type", "application/json")
+                .codecs(configurer -> configurer.defaultCodecs().maxInMemorySize(1024 * 1024))
+                .build();
+    }
+
+    @Override
+    public void addCorsMappings(CorsRegistry registry) {
+        registry.addMapping("/api/**")
+                .allowedOrigins("http://localhost:3000", "http://localhost:8080","http://localhost:63342")
+                .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
+                .allowedHeaders("*")
+                .allowCredentials(true);
+    }
+
+    // Getters and setters
+    public String getKey() { return key; }
+    public void setKey(String key) { this.key = key; }
+
+    public String getBaseUrl() { return baseUrl; }
+    public void setBaseUrl(String baseUrl) { this.baseUrl = baseUrl; }
+
+    public String getModel() { return model; }
+    public void setModel(String model) { this.model = model; }
+
+    public int getTimeout() { return timeout; }
+    public void setTimeout(int timeout) { this.timeout = timeout; }
+}

src/main/java/com/example/p1/controller/ChatController.java

@@ -0,0 +1,130 @@
+package com.example.p1.controller;
+
+import com.example.p1.service.ChatService;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/chat")
+@CrossOrigin(origins = {"http://localhost:3000", "http://localhost:8080"})
+public class ChatController {
+
+    private final ChatService chatService;
+
+    public ChatController(ChatService chatService) {
+        this.chatService = chatService;
+    }
+
+    @PostMapping("/message")
+    public Mono<ResponseEntity<ChatResponse>> sendMessage(@Valid @RequestBody ChatRequest request) {
+        return chatService.generateResponse(request.getMessage())
+                .map(response -> ResponseEntity.ok(new ChatResponse(response, true, null)))
+                .onErrorReturn(ResponseEntity.badRequest()
+                        .body(new ChatResponse(null, false, "Failed to generate response")));
+    }
+
+    @PostMapping("/conversation")
+    public Mono<ResponseEntity<ChatResponse>> sendConversation(@Valid @RequestBody ConversationRequest request) {
+        return chatService.generateConversationResponse(request.getMessages())
+                .map(response -> ResponseEntity.ok(new ChatResponse(response, true, null)))
+                .onErrorReturn(ResponseEntity.badRequest()
+                        .body(new ChatResponse(null, false, "Failed to generate response")));
+    }
+
+    @PostMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
+    public Flux<String> streamMessage(@Valid @RequestBody ChatRequest request) {
+        return chatService.generateStreamingResponse(request.getMessage());
+    }
+
+    @GetMapping("/health")
+    public ResponseEntity<Map<String, Object>> health() {
+        return ResponseEntity.ok(Map.of(
+                "status", "UP",
+                "service", "Chat Service",
+                "timestamp", System.currentTimeMillis()
+        ));
+    }
+
+    // DTOs
+    public static class ChatRequest {
+        @NotBlank(message = "Message cannot be blank")
+        private String message;
+
+        public ChatRequest() {}
+
+        public ChatRequest(String message) {
+            this.message = message;
+        }
+
+        public String getMessage() { return message; }
+        public void setMessage(String message) { this.message = message; }
+    }
+
+    public static class ConversationRequest {
+        @Valid
+        private List<Message> messages;
+
+        public ConversationRequest() {}
+
+        public ConversationRequest(List<Message> messages) {
+            this.messages = messages;
+        }
+
+        public List<Message> getMessages() { return messages; }
+        public void setMessages(List<Message> messages) { this.messages = messages; }
+
+        public static class Message {
+            @NotBlank
+            private String role; // "user" or "assistant"
+            @NotBlank
+            private String content;
+
+            public Message() {}
+
+            public Message(String role, String content) {
+                this.role = role;
+                this.content = content;
+            }
+
+            public String getRole() { return role; }
+            public void setRole(String role) { this.role = role; }
+
+            public String getContent() { return content; }
+            public void setContent(String content) { this.content = content; }
+        }
+    }
+
+    public static class ChatResponse {
+        private String response;
+        private boolean success;
+        private String error;
+        private long timestamp;
+
+        public ChatResponse(String response, boolean success, String error) {
+            this.response = response;
+            this.success = success;
+            this.error = error;
+            this.timestamp = System.currentTimeMillis();
+        }
+
+        public String getResponse() { return response; }
+        public void setResponse(String response) { this.response = response; }
+
+        public boolean isSuccess() { return success; }
+        public void setSuccess(boolean success) { this.success = success; }
+
+        public String getError() { return error; }
+        public void setError(String error) { this.error = error; }
+
+        public long getTimestamp() { return timestamp; }
+        public void setTimestamp(long timestamp) { this.timestamp = timestamp; }
+    }
+}

src/main/java/com/example/p1/service/ChatService.java

@@ -0,0 +1,166 @@
+package com.example.p1.service;
+
+import com.example.p1.config.AiConfiguration;
+import com.example.p1.controller.ChatController;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import org.springframework.web.reactive.function.client.WebClient;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service
+public class ChatService {
+    private static final Logger logger = LoggerFactory.getLogger(ChatService.class);
+
+    private final WebClient webClient;
+    private final AiConfiguration config;
+
+    public ChatService(WebClient geminiWebClient, AiConfiguration config) {
+        this.webClient = geminiWebClient;
+        this.config = config;
+    }
+
+    public Mono<String> generateResponse(String message) {
+        logger.debug("Generating response for message: {}", message);
+
+        GeminiRequest request = createSimpleRequest(message);
+
+        return callGeminiAPI(request)
+                .map(this::extractTextFromResponse)
+                .doOnSuccess(response -> logger.debug("Generated response: {}", response))
+                .doOnError(error -> logger.error("Error generating response", error));
+    }
+
+    public Mono<String> generateConversationResponse(List<ChatController.ConversationRequest.Message> messages) {
+        logger.debug("Generating conversation response for {} messages", messages.size());
+
+        String conversationContext = buildConversationContext(messages);
+        return generateResponse(conversationContext);
+    }
+
+    public Flux<String> generateStreamingResponse(String message) {
+        // For demonstration - in real implementation, you'd use Gemini's streaming API
+        return generateResponse(message)
+                .flatMapMany(response -> {
+                    String[] words = response.split("\\s+");
+                    return Flux.fromArray(words)
+                            .delayElements(Duration.ofMillis(100))
+                            .map(word -> word + " ");
+                });
+    }
+
+    private Mono<GeminiResponse> callGeminiAPI(GeminiRequest request) {
+        return webClient.post()
+                .uri("/{model}:generateContent?key={apiKey}",
+                        config.getModel(), config.getKey())
+                .bodyValue(request)
+                .retrieve()
+                .bodyToMono(GeminiResponse.class)
+                .timeout(Duration.ofMillis(config.getTimeout()));
+    }
+
+    private GeminiRequest createSimpleRequest(String message) {
+        GeminiRequest.Part part = new GeminiRequest.Part(message);
+        GeminiRequest.Content content = new GeminiRequest.Content(List.of(part));
+        return new GeminiRequest(List.of(content));
+    }
+
+    private String buildConversationContext(List<ChatController.ConversationRequest.Message> messages) {
+        StringBuilder context = new StringBuilder();
+        context.append("Previous conversation:\n");
+
+        for (ChatController.ConversationRequest.Message msg : messages) {
+            context.append(msg.getRole().toUpperCase())
+                    .append(": ")
+                    .append(msg.getContent())
+                    .append("\n");
+        }
+
+        return context.toString();
+    }
+
+    private String extractTextFromResponse(GeminiResponse response) {
+        if (response.getCandidates() != null && !response.getCandidates().isEmpty()) {
+            GeminiResponse.Candidate candidate = response.getCandidates().get(0);
+            if (candidate.getContent() != null &&
+                    candidate.getContent().getParts() != null &&
+                    !candidate.getContent().getParts().isEmpty()) {
+                return candidate.getContent().getParts().get(0).getText();
+            }
+        }
+        return "No response generated";
+    }
+
+    // Gemini API DTOs
+    public static class GeminiRequest {
+        private List<Content> contents;
+
+        public GeminiRequest(List<Content> contents) {
+            this.contents = contents;
+        }
+
+        public List<Content> getContents() { return contents; }
+        public void setContents(List<Content> contents) { this.contents = contents; }
+
+        public static class Content {
+            private List<Part> parts;
+
+            public Content(List<Part> parts) {
+                this.parts = parts;
+            }
+
+            public List<Part> getParts() { return parts; }
+            public void setParts(List<Part> parts) { this.parts = parts; }
+        }
+
+        public static class Part {
+            private String text;
+
+            public Part(String text) {
+                this.text = text;
+            }
+
+            public String getText() { return text; }
+            public void setText(String text) { this.text = text; }
+        }
+    }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    public static class GeminiResponse {
+        private List<Candidate> candidates;
+
+        public List<Candidate> getCandidates() { return candidates; }
+        public void setCandidates(List<Candidate> candidates) { this.candidates = candidates; }
+
+        @JsonIgnoreProperties(ignoreUnknown = true)
+        public static class Candidate {
+            private Content content;
+
+            public Content getContent() { return content; }
+            public void setContent(Content content) { this.content = content; }
+        }
+
+        @JsonIgnoreProperties(ignoreUnknown = true)
+        public static class Content {
+            private List<Part> parts;
+
+            public List<Part> getParts() { return parts; }
+            public void setParts(List<Part> parts) { this.parts = parts; }
+        }
+
+        @JsonIgnoreProperties(ignoreUnknown = true)
+        public static class Part {
+            private String text;
+
+            public String getText() { return text; }
+            public void setText(String text) { this.text = text; }
+        }
+    }
+}

src/main/resources/application.properties.txt

@@ -0,0 +1,20 @@
+spring.application.name=p1
+
+# Server Configuration
+server.port=8080
+
+# Gemini AI Configuration
+gemini.api.key=${GEMINI_API_KEY:YOUR_KEY}
+gemini.api.base-url=https://generativelanguage.googleapis.com/v1beta/models
+gemini.api.model=gemini-2.5-flash
+gemini.api.timeout=30000
+
+# Logging
+logging.level.com.example.p1=DEBUG
+logging.level.org.springframework.web=DEBUG
+
+# CORS Configuration
+cors.allowed-origins=http://localhost:3000,http://localhost:8080
+cors.allowed-methods=GET,POST,PUT,DELETE,OPTIONS
+cors.allowed-headers=*
+*/

src/test/java/com/example/p1/P1ApplicationTests.java

@@ -0,0 +1,13 @@
+package com.example.p1;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class P1ApplicationTests {
+
+    @Test
+    void contextLoads() {
+    }
+
+}