Deploy Space with optional ASR mode

.dockerignore

@@ -0,0 +1,30 @@
+# VCS
+.git
+.gitignore
+
+# Python cache and local environments
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.so
+venv/
+.venv/
+
+# Local env files
+.env
+.env.*
+
+# Editor and notebook
+.vscode/
+*.ipynb
+
+# Build and test caches
+.pytest_cache/
+.mypy_cache/
+ruff_cache/
+
+# Large local assets not required in container build context
+models/
+final_model/
+rag_data/faiss_index/

.env.example

@@ -0,0 +1,3 @@
+# Gemini API Key
+# Get your API key from: https://makersuite.google.com/app/apikey
+GEMINI_API_KEY=AIzaSyC7tkb3uFgmh8YSuOVHYgIDywyL2lzICBA

.gitignore

@@ -0,0 +1,85 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Project specific
+*.wav
+*.mp3
+*.webm
+temp/
+logs/
+
+# Model cache (can be large)
+models/
+final_model/
+.cache/
+
+# RAG binary artifacts (not required at deploy time)
+rag_data/*.pdf
+rag_data/faiss_index/

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.10-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PORT=7860
+
+WORKDIR /app
+
+# System libs for audio and ML dependencies.
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    ffmpeg \
+    libsndfile1 \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt ./
+RUN pip install --no-cache-dir --upgrade pip setuptools wheel && \
+    pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["sh", "-c", "uvicorn app.hf_space:app --host 0.0.0.0 --port ${PORT:-7860}"]

README.md

@@ -0,0 +1,173 @@
+---
+title: Sinhala Chatbot
+emoji: "🎙️"
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# Sinhala Chatbot
+
+A voice-enabled Sinhala/English chatbot that uses speech recognition, translation, RAG, and text-to-speech.
+
+## Features
+
+- Voice recording in Sinhala or English
+- Speech-to-text using Whisper ASR (`seniruk/whisper-small-si`)
+- Translation to English before querying RAG
+- RAG from uploaded PDFs (FAISS + embeddings)
+- AI fallback (Gemini or Hugging Face)
+- Text-to-speech with Google TTS
+
+## Project Structure
+
+```
+chatbot-project-python/
+  app/
+    __init__.py
+    main.py
+    admin.py
+    rag.py
+    static/
+      css/style.css
+      js/script.js
+    templates/
+      index.html
+      admin.html
+  rag_data/
+  .env
+  .env.example
+  requirements.txt
+  README.md
+```
+
+## Prerequisites
+
+- Python 3.9+
+- A modern browser (Chrome, Edge, Firefox)
+- Microphone access
+- Gemini API key (optional but recommended)
+- Hugging Face API token (optional fallback)
+
+## Installation
+
+### 1. Create a virtual environment
+
+```bash
+# Windows
+python -m venv venv
+venv\Scripts\activate
+
+# macOS/Linux
+python3 -m venv venv
+source venv/bin/activate
+```
+
+### 2. Install dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 3. Configure environment variables
+
+Copy the example environment file and add your API keys:
+
+```bash
+# Windows
+copy .env.example .env
+
+# macOS/Linux
+cp .env.example .env
+```
+
+Edit `.env` and add:
+
+```
+GEMINI_API_KEY=your_gemini_key_here
+HF_API_TOKEN=your_huggingface_token_here
+```
+
+If you do not provide a Gemini key, the app will fall back to the free Hugging Face API.
+
+## Running the Application
+
+### Start the main chatbot (port 8000)
+
+```bash
+# From the project root
+python -m app.main
+uvicorn app.main:app --reload --host 0.0.0.0 --port 8000
+```
+
+Or using uvicorn directly:
+
+```bash
+swas
+```
+
+### Start the admin panel (port 9000)
+
+In a separate terminal:
+
+```bash
+python -m app.admin
+```
+
+Or using uvicorn directly:
+
+```bash
+uvicorn app.admin:admin_app --reload --host 0.0.0.0 --port 9000
+```
+
+### Access the applications
+
+- Chatbot UI: http://localhost:8000
+- Admin panel (PDF upload): http://localhost:9000
+
+## Usage
+
+1. Upload PDFs using the admin panel (port 9000)
+2. Open the chatbot UI (port 8000)
+3. Click the microphone and speak in Sinhala or English
+4. The app transcribes, translates to English, then queries RAG
+5. The response is shown in text and can be played via TTS
+
+## Troubleshooting
+
+- If RAG answers are always from AI, upload at least one PDF and verify RAG status.
+- If you see a missing API key error, check `.env` and restart the server.
+- If model loading is slow, the first run downloads Whisper and embeddings.
+- If PDFs already exist under `rag_data/`, the app now rebuilds/loads RAG at startup automatically.
+- You can manually rebuild from all PDFs with `POST /api/rag/rebuild`.
+
+## Deploy on Hugging Face Spaces (Docker)
+
+This project can be deployed with UI on Hugging Face Spaces using Docker.
+
+### 1. Create a new Space
+
+- Go to Hugging Face Spaces and create a new Space.
+- Set `SDK` to `Docker`.
+- Upload/push this project files to that Space repository.
+
+### 2. Add Space secrets
+
+In Space settings, add these secrets:
+
+- `GEMINI_API_KEY` (optional)
+- `HF_API_TOKEN` (optional fallback)
+
+### 3. Build and run
+
+The provided `Dockerfile` starts:
+
+- Main UI at `/`
+- Admin UI at `/admin`
+
+When Space build completes, open:
+
+- `https://<your-space>.hf.space/`
+- `https://<your-space>.hf.space/admin`

app/__init__.py

@@ -0,0 +1 @@
+# App package marker.

app/admin.py

@@ -0,0 +1,141 @@
+# RAG Admin Panel - PDF Upload Management (Port 9000)
+import os
+from pathlib import Path
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from fastapi.requests import Request
+from fastapi.responses import JSONResponse, HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
+
+# Import RAG module
+from app import rag
+
+IS_HF_SPACE = bool(os.getenv("SPACE_ID"))
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Ensure RAG index is ready when admin panel starts."""
+    if not IS_HF_SPACE:
+        loaded = rag.load_vector_store()
+        if not loaded:
+            rag.rebuild_vector_store_from_pdfs()
+    yield
+
+
+# Initialize FastAPI app for admin
+admin_app = FastAPI(title="RAG Admin Panel", version="1.0.0", lifespan=lifespan)
+
+# Add CORS middleware
+admin_app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Mount static files and templates
+BASE_DIR = Path(__file__).resolve().parent
+admin_app.mount("/static", StaticFiles(directory=BASE_DIR / "static"), name="static")
+templates = Jinja2Templates(directory=BASE_DIR / "templates")
+
+
+@admin_app.get("/", response_class=HTMLResponse)
+async def admin_home(request: Request):
+    """Render the admin panel for PDF upload"""
+    return templates.TemplateResponse("admin.html", {"request": request})
+
+
+@admin_app.post("/api/upload")
+async def upload_pdf(file: UploadFile = File(...)):
+    """Upload a PDF file for RAG processing"""
+    if not file.filename.lower().endswith('.pdf'):
+        raise HTTPException(status_code=400, detail="Only PDF files are allowed")
+    
+    try:
+        # Initialize embeddings if not already done
+        rag.initialize_embeddings()
+        
+        # Save uploaded file
+        RAG_DATA_DIR = Path(__file__).resolve().parent.parent / "rag_data"
+        RAG_DATA_DIR.mkdir(parents=True, exist_ok=True)
+        
+        pdf_path = RAG_DATA_DIR / file.filename
+        
+        content = await file.read()
+        with open(pdf_path, "wb") as f:
+            f.write(content)
+        
+        # Process the PDF
+        chunks = rag.load_and_process_pdf(str(pdf_path))
+        
+        if not chunks:
+            raise HTTPException(status_code=400, detail="Could not extract text from PDF")
+        
+        # Create/update vector store
+        success = rag.create_vector_store(chunks)
+        
+        if success:
+            rag.get_rag_status()
+            return JSONResponse({
+                "success": True,
+                "message": f"PDF '{file.filename}' uploaded and processed successfully",
+                "chunks_created": len(chunks),
+                "total_documents": len(rag.uploaded_documents)
+            })
+        else:
+            raise HTTPException(status_code=500, detail="Failed to create vector store")
+            
+    except Exception as e:
+        print(f"RAG Upload Error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to process PDF: {str(e)}")
+
+
+@admin_app.get("/api/status")
+async def get_status():
+    """Get RAG system status"""
+    return JSONResponse(rag.get_rag_status())
+
+
+@admin_app.post("/api/clear")
+async def clear_data():
+    """Clear all RAG data"""
+    rag.clear_rag_data()
+    return JSONResponse({"success": True, "message": "RAG data cleared"})
+
+
+@admin_app.delete("/api/document/{filename}")
+async def delete_document(filename: str):
+    """Delete a specific document"""
+    try:
+        RAG_DATA_DIR = Path(__file__).resolve().parent.parent / "rag_data"
+        pdf_path = RAG_DATA_DIR / filename
+        
+        if pdf_path.exists():
+            os.remove(pdf_path)
+        
+        if list(RAG_DATA_DIR.glob("*.pdf")):
+            rag.rebuild_vector_store_from_pdfs()
+        else:
+            rag.clear_rag_data()
+        
+        return JSONResponse({"success": True, "message": f"Document '{filename}' deleted"})
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to delete: {str(e)}")
+
+
+@admin_app.post("/api/rebuild")
+async def rebuild_data():
+    """Rebuild vector store from all PDFs in rag_data."""
+    success = rag.rebuild_vector_store_from_pdfs()
+    if success:
+        return JSONResponse({"success": True, "message": "RAG rebuilt successfully from all PDFs"})
+    return JSONResponse({"success": False, "message": "No valid PDFs found to rebuild RAG"})
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(admin_app, host="0.0.0.0", port=9000)

app/hf_space.py

@@ -0,0 +1,10 @@
+from fastapi import FastAPI
+
+from app.main import app as chatbot_app
+from app.admin import admin_app
+
+app = FastAPI(title="Sinhala Chatbot Space", version="1.0.0")
+
+# Hugging Face Spaces exposes a single port, so mount both apps under one server.
+app.mount("/admin", admin_app)
+app.mount("/", chatbot_app)

app/main.py

@@ -0,0 +1,470 @@
+import os
+import io
+import tempfile
+from pathlib import Path
+from contextlib import asynccontextmanager
+
+from dotenv import load_dotenv
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from fastapi.requests import Request
+from fastapi.responses import JSONResponse, StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+import google.generativeai as genai
+from gtts import gTTS
+from deep_translator import GoogleTranslator
+
+from app import rag
+
+load_dotenv()
+
+asr_model = None
+model_loaded = False
+model_loading = False
+
+conversation_history = []
+
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+if GEMINI_API_KEY:
+    genai.configure(api_key=GEMINI_API_KEY)
+
+LOCAL_MODEL_PATH = Path(__file__).resolve().parent.parent / "final_model"
+HUGGINGFACE_MODEL_ID = "seniruk/whisper-small-si"
+IS_HF_SPACE = bool(os.getenv("SPACE_ID"))
+
+
+def load_asr_model():
+    """Load the ASR model - tries local model first, falls back to Hugging Face."""
+    global asr_model, model_loaded, model_loading
+
+    if model_loaded:
+        return asr_model
+
+    model_loading = True
+
+    try:
+        from transformers import WhisperProcessor, WhisperForConditionalGeneration
+        import torch
+    except Exception as import_error:
+        model_loading = False
+        raise RuntimeError(
+            "ASR dependencies are not installed. Install transformers and torch to enable speech input."
+        ) from import_error
+
+    processor = None
+    model = None
+    model_source = None
+
+    if LOCAL_MODEL_PATH.exists():
+        print("=" * 50)
+        print(f"Loading ASR model from local path: {LOCAL_MODEL_PATH}")
+        print("=" * 50)
+        try:
+            processor = WhisperProcessor.from_pretrained(str(LOCAL_MODEL_PATH))
+            model = WhisperForConditionalGeneration.from_pretrained(
+                str(LOCAL_MODEL_PATH), torch_dtype=torch.float32
+            )
+            model_source = "local"
+            print("Local model loaded successfully.")
+        except Exception as e:
+            print(f"Failed to load local model: {str(e)}")
+            print("Falling back to Hugging Face model...")
+            processor = None
+            model = None
+    else:
+        print(f"Local model not found at: {LOCAL_MODEL_PATH}")
+        print("Falling back to Hugging Face model...")
+
+    if model is None:
+        print("=" * 50)
+        print(f"Loading ASR model from Hugging Face: {HUGGINGFACE_MODEL_ID}")
+        print("This may take a minute on first run...")
+        print("=" * 50)
+        processor = WhisperProcessor.from_pretrained(HUGGINGFACE_MODEL_ID)
+        model = WhisperForConditionalGeneration.from_pretrained(
+            HUGGINGFACE_MODEL_ID, torch_dtype=torch.float32
+        )
+        model_source = "huggingface"
+        print("Hugging Face model loaded successfully.")
+
+    model.eval()
+
+    device = "cpu"
+    if torch.cuda.is_available():
+        device = "cuda"
+        model = model.half()
+        model = model.to("cuda")
+        print("Using GPU with float16 for faster inference.")
+    else:
+        print("Running on CPU.")
+
+    asr_model = {
+        "processor": processor,
+        "model": model,
+        "device": device,
+        "source": model_source,
+    }
+
+    model_loaded = True
+    model_loading = False
+    print(f"Model ready. (Source: {model_source})")
+    return asr_model
+
+
+def transcribe_audio(audio_path: str) -> str:
+    """Transcribe audio file to text - optimized."""
+    global asr_model
+
+    try:
+        import soundfile as sf
+        import numpy as np
+        from scipy import signal
+        import torch
+    except Exception as import_error:
+        raise RuntimeError(
+            "Audio dependencies are not installed. Install soundfile, numpy, and scipy."
+        ) from import_error
+
+    processor = asr_model["processor"]
+    model = asr_model["model"]
+    device = asr_model["device"]
+
+    audio_array, sample_rate = sf.read(audio_path)
+
+    if len(audio_array.shape) > 1:
+        audio_array = audio_array.mean(axis=1)
+
+    if sample_rate != 16000:
+        num_samples = int(len(audio_array) * 16000 / sample_rate)
+        audio_array = signal.resample(audio_array, num_samples)
+
+    audio_array = audio_array.astype(np.float32)
+
+    inputs = processor(audio_array, sampling_rate=16000, return_tensors="pt").input_features
+
+    if device == "cuda":
+        inputs = inputs.half().to("cuda")
+
+    with torch.no_grad():
+        predicted_ids = model.generate(
+            inputs,
+            max_length=225,
+            num_beams=1,
+            do_sample=False,
+            use_cache=True,
+        )
+
+    return processor.batch_decode(predicted_ids, skip_special_tokens=True)[0].strip()
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Load model at startup."""
+    print("\nStarting Sinhala Chatbot Server...")
+    if IS_HF_SPACE:
+        print("Hugging Face Space detected. Skipping heavy startup preloads.")
+    else:
+        load_asr_model()
+        loaded = rag.load_vector_store()
+        if not loaded:
+            rag.rebuild_vector_store_from_pdfs()
+    print("Server ready.\n")
+    yield
+    print("\nShutting down...")
+
+
+app = FastAPI(title="Sinhala Chatbot", version="1.0.0", lifespan=lifespan)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+BASE_DIR = Path(__file__).resolve().parent
+app.mount("/static", StaticFiles(directory=BASE_DIR / "static"), name="static")
+templates = Jinja2Templates(directory=BASE_DIR / "templates")
+
+
+@app.get("/")
+async def home(request: Request):
+    """Render the main chatbot interface."""
+    return templates.TemplateResponse("index.html", {"request": request})
+
+
+@app.get("/api/model-status")
+async def get_model_status():
+    """Check if ASR model is loaded."""
+    source = asr_model.get("source", None) if asr_model else None
+    return JSONResponse({"loaded": model_loaded, "loading": model_loading, "source": source})
+
+
+@app.post("/api/speech-to-text")
+async def speech_to_text(audio: UploadFile = File(...)):
+    """Convert speech to text using Whisper ASR model."""
+    if not model_loaded:
+        try:
+            load_asr_model()
+        except Exception as load_error:
+            raise HTTPException(status_code=503, detail=str(load_error)) from load_error
+
+    try:
+        audio_bytes = await audio.read()
+
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
+            tmp_file.write(audio_bytes)
+            tmp_path = tmp_file.name
+
+        try:
+            transcription = transcribe_audio(tmp_path)
+            return JSONResponse({"success": True, "text": transcription})
+        finally:
+            os.unlink(tmp_path)
+
+    except Exception as e:
+        print(f"ASR Error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Speech recognition failed: {str(e)}")
+
+
+@app.post("/api/chat")
+async def chat(request: Request):
+    """
+    Send text to RAG system (retrieves from documents first, then falls back to Gemini/HF).
+    Automatically translates non-English questions to English before RAG processing.
+    """
+    global conversation_history
+
+    try:
+        data = await request.json()
+        user_message = data.get("message", "")
+
+        if not user_message:
+            raise HTTPException(status_code=400, detail="Message is required")
+
+        english_question = user_message
+        try:
+            translator = GoogleTranslator(source="auto", target="en")
+            english_question = translator.translate(user_message)
+            print(f"Original Question: {user_message}")
+            print(f"English Question: {english_question}")
+        except Exception as trans_error:
+            print(f"Translation failed, using original: {trans_error}")
+            english_question = user_message
+
+        rag_result = rag.rag_answer(english_question)
+        assistant_message = rag_result.get("answer", "")
+
+        conversation_history.append({
+            "role": "user",
+            "parts": [user_message],
+        })
+
+        conversation_history.append({
+            "role": "model",
+            "parts": [assistant_message],
+        })
+
+        if len(conversation_history) > 20:
+            conversation_history = conversation_history[-20:]
+
+        return JSONResponse({
+            "success": True,
+            "response": assistant_message,
+            "source": rag_result.get("source", "none"),
+            "context_found": rag_result.get("context_found", False),
+        })
+
+    except Exception as e:
+        print(f"Chat Error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Chat failed: {str(e)}")
+
+
+@app.post("/api/text-to-speech")
+async def text_to_speech(request: Request):
+    """Convert text to speech using Google TTS."""
+    try:
+        data = await request.json()
+        text = data.get("text", "")
+        lang = data.get("lang", "si")
+
+        if not text:
+            raise HTTPException(status_code=400, detail="Text is required")
+
+        tts = gTTS(text=text, lang=lang, slow=False)
+
+        audio_buffer = io.BytesIO()
+        tts.write_to_fp(audio_buffer)
+        audio_buffer.seek(0)
+
+        return StreamingResponse(
+            audio_buffer,
+            media_type="audio/mpeg",
+            headers={"Content-Disposition": "inline; filename=speech.mp3"},
+        )
+
+    except Exception as e:
+        print(f"TTS Error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Text-to-speech failed: {str(e)}")
+
+
+@app.post("/api/clear-history")
+async def clear_history():
+    """Clear conversation history."""
+    global conversation_history
+    conversation_history = []
+    return JSONResponse({"success": True, "message": "Conversation history cleared"})
+
+
+@app.get("/api/health")
+async def health_check():
+    """Health check endpoint."""
+    return JSONResponse({
+        "status": "healthy",
+        "gemini_configured": GEMINI_API_KEY is not None,
+    })
+
+
+@app.post("/api/translate-to-english")
+async def translate_to_english(request: Request):
+    """Translate Sinhala/mixed language question to full English using Google Translate."""
+    try:
+        data = await request.json()
+        question = data.get("question", "")
+        if not question:
+            raise HTTPException(status_code=400, detail="Question is required")
+
+        translator = GoogleTranslator(source="auto", target="en")
+        english_question = translator.translate(question)
+
+        print(f"Original: {question}")
+        print(f"Translated: {english_question}")
+
+        return JSONResponse({"success": True, "english_question": english_question, "translated": True})
+    except Exception as e:
+        print(f"Translation Error: {str(e)}")
+        error_msg = str(e)
+        return JSONResponse({
+            "success": False,
+            "english_question": question,
+            "translated": False,
+            "error": error_msg,
+        })
+
+
+@app.post("/api/rag/upload")
+async def upload_pdf(file: UploadFile = File(...)):
+    """Upload a PDF file for RAG processing."""
+    if not file.filename.lower().endswith(".pdf"):
+        raise HTTPException(status_code=400, detail="Only PDF files are allowed")
+
+    try:
+        rag_data_dir = Path(__file__).resolve().parent.parent / "rag_data"
+        rag_data_dir.mkdir(parents=True, exist_ok=True)
+
+        pdf_path = rag_data_dir / file.filename
+
+        content = await file.read()
+        with open(pdf_path, "wb") as f:
+            f.write(content)
+
+        chunks = rag.load_and_process_pdf(str(pdf_path))
+
+        if not chunks:
+            raise HTTPException(status_code=400, detail="Could not extract text from PDF")
+
+        success = rag.create_vector_store(chunks)
+
+        if success:
+            status = rag.get_rag_status()
+            return JSONResponse({
+                "success": True,
+                "message": f"PDF '{file.filename}' uploaded and processed successfully",
+                "chunks_created": len(chunks),
+                "total_documents": status.get("documents_count", 0),
+            })
+        raise HTTPException(status_code=500, detail="Failed to create vector store")
+
+    except Exception as e:
+        print(f"RAG Upload Error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to process PDF: {str(e)}")
+
+
+@app.post("/api/rag/ask")
+async def rag_ask(request: Request):
+    """Ask a question using RAG - first checks database, then falls back to Gemini/HF."""
+    try:
+        data = await request.json()
+        question = data.get("question", "")
+        response_lang = data.get("response_lang", "en")
+
+        print(f"Question: {question}")
+        print(f"Response language: {response_lang}")
+
+        if not question:
+            raise HTTPException(status_code=400, detail="Question is required")
+
+        result = rag.rag_answer(question)
+        answer = result["answer"]
+
+        print(f"Original answer length: {len(answer) if answer else 0}")
+
+        if response_lang == "si-en" and answer:
+            print("Translating to Sinhala+English...")
+            try:
+                translator = GoogleTranslator(source="en", target="si")
+                sinhala_answer = translator.translate(answer)
+                answer = f"**Sinhala:**\n{sinhala_answer}\n\n---\n\n**English:**\n{answer}"
+                print("Translated successfully.")
+            except Exception as trans_err:
+                print(f"Translation to Sinhala failed: {trans_err}")
+                answer = f"Translation failed: {trans_err}\n\n**English:** {answer}"
+
+        return JSONResponse({
+            "success": True,
+            "question": question,
+            "answer": answer,
+            "source": result["source"],
+            "context_found": result["context_found"],
+            "relevance_score": result["relevance_score"],
+            "response_lang": response_lang,
+        })
+
+    except Exception as e:
+        print(f"RAG Ask Error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"RAG query failed: {str(e)}")
+
+
+@app.get("/api/rag/status")
+async def rag_status():
+    """Get RAG system status."""
+    return JSONResponse(rag.get_rag_status())
+
+
+@app.post("/api/rag/clear")
+async def clear_rag():
+    """Clear all RAG data."""
+    rag.clear_rag_data()
+    return JSONResponse({"success": True, "message": "RAG data cleared"})
+
+
+@app.post("/api/rag/rebuild")
+async def rebuild_rag():
+    """Rebuild vector store from all PDFs in rag_data directory."""
+    success = rag.rebuild_vector_store_from_pdfs()
+    if not success:
+        return JSONResponse(
+            {
+                "success": False,
+                "message": "No valid PDFs found to rebuild vector store.",
+            }
+        )
+    return JSONResponse({"success": True, "message": "RAG vector store rebuilt successfully."})
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000, reload=True)

app/rag.py

@@ -0,0 +1,429 @@
+import os
+import re
+import unicodedata
+from pathlib import Path
+from typing import List
+
+from dotenv import load_dotenv
+import google.generativeai as genai
+from huggingface_hub import InferenceClient
+
+load_dotenv()
+
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+if GEMINI_API_KEY:
+    genai.configure(api_key=GEMINI_API_KEY)
+
+vectordb = None
+retriever = None
+embeddings = None
+rag_initialized = False
+uploaded_documents = []
+last_index_mtime = None
+
+RAG_DATA_DIR = Path(__file__).resolve().parent.parent / "rag_data"
+FAISS_INDEX_PATH = RAG_DATA_DIR / "faiss_index"
+INSUFFICIENT_CONTEXT_MARKER = "i don't have enough information in the documents"
+
+
+def initialize_embeddings():
+    """Initialize the multilingual embedding model."""
+    global embeddings
+
+    if embeddings is not None:
+        return embeddings
+
+    print("Loading multilingual embedding model...")
+    from langchain_huggingface import HuggingFaceEmbeddings
+
+    embeddings = HuggingFaceEmbeddings(
+        model_name="sentence-transformers/paraphrase-multilingual-mpnet-base-v2",
+        encode_kwargs={"normalize_embeddings": True},
+    )
+    print("Embedding model loaded.")
+    return embeddings
+
+
+def clean_text(text: str) -> str:
+    """Clean and normalize text for embedding."""
+    if not isinstance(text, str) or not text.strip():
+        return ""
+
+    normalized_text = unicodedata.normalize("NFKC", text)
+
+    cleaned_chars = [
+        char for char in normalized_text
+        if unicodedata.category(char) not in ["So", "Cn", "Cc", "Cf", "Cs"]
+    ]
+    cleaned_text = "".join(cleaned_chars)
+
+    cleaned_text = re.sub(r"\s+", " ", cleaned_text).strip()
+
+    return cleaned_text
+
+
+def load_and_process_pdf(pdf_path: str) -> List[dict]:
+    """Load a PDF and split it into chunks."""
+    from langchain_community.document_loaders import PyPDFLoader
+    from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+    print(f"Loading PDF: {pdf_path}")
+
+    loader = PyPDFLoader(pdf_path)
+    docs = loader.load()
+
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=300,
+        chunk_overlap=80,
+    )
+    chunks = splitter.split_documents(docs)
+
+    print(f"Loaded {len(docs)} pages, created {len(chunks)} chunks.")
+    return chunks
+
+
+def create_vector_store(chunks: List) -> bool:
+    """Create or update the FAISS vector store with document chunks."""
+    global vectordb, retriever, rag_initialized
+
+    from langchain_community.vectorstores import FAISS
+
+    initialize_embeddings()
+
+    texts = [doc.page_content for doc in chunks]
+    metadatas = [doc.metadata for doc in chunks]
+
+    processed_texts = []
+    processed_metadatas = []
+
+    for i, text in enumerate(texts):
+        cleaned_text = clean_text(text)
+        if cleaned_text:
+            processed_texts.append(cleaned_text)
+            processed_metadatas.append(metadatas[i])
+
+    if not processed_texts:
+        print("No valid texts after cleaning.")
+        return False
+
+    print(f"Processing {len(processed_texts)} text chunks for embedding...")
+
+    if vectordb is None:
+        vectordb = FAISS.from_texts(processed_texts, embeddings, metadatas=processed_metadatas)
+    else:
+        new_vectordb = FAISS.from_texts(processed_texts, embeddings, metadatas=processed_metadatas)
+        vectordb.merge_from(new_vectordb)
+
+    retriever = vectordb.as_retriever(search_kwargs={"k": 4})
+    rag_initialized = True
+
+    save_vector_store()
+    _sync_uploaded_documents()
+
+    print("Vector store created/updated successfully.")
+    return True
+
+
+def save_vector_store():
+    """Save the FAISS index to disk."""
+    global vectordb, last_index_mtime
+
+    if vectordb is None:
+        return
+
+    RAG_DATA_DIR.mkdir(parents=True, exist_ok=True)
+    vectordb.save_local(str(FAISS_INDEX_PATH))
+    last_index_mtime = _get_index_mtime()
+    print(f"Vector store saved to {FAISS_INDEX_PATH}.")
+
+
+def load_vector_store() -> bool:
+    """Load the FAISS index from disk if it exists."""
+    global vectordb, retriever, rag_initialized, last_index_mtime
+
+    if not FAISS_INDEX_PATH.exists():
+        return False
+
+    try:
+        from langchain_community.vectorstores import FAISS
+
+        initialize_embeddings()
+        vectordb = FAISS.load_local(
+            str(FAISS_INDEX_PATH),
+            embeddings,
+            allow_dangerous_deserialization=True,
+        )
+        retriever = vectordb.as_retriever(search_kwargs={"k": 4})
+        rag_initialized = True
+        last_index_mtime = _get_index_mtime()
+        _sync_uploaded_documents()
+        print("Loaded existing vector store from disk.")
+        return True
+    except Exception as e:
+        print(f"Failed to load vector store: {e}")
+        return False
+
+
+def rag_answer(question: str) -> dict:
+    """Answer a question using RAG - first check database, then fallback to Gemini/HF."""
+    global retriever, vectordb, last_index_mtime
+
+    result = {
+        "answer": "",
+        "source": "none",
+        "context_found": False,
+        "relevance_score": 0.0,
+    }
+
+    if FAISS_INDEX_PATH.exists():
+        current_mtime = _get_index_mtime()
+        if (not rag_initialized or retriever is None) or (
+            current_mtime and last_index_mtime and current_mtime > last_index_mtime
+        ):
+            load_vector_store()
+
+    if not rag_initialized or retriever is None:
+        result["source"] = "gemini"
+        result["answer"] = _ask_gemini_directly(question)
+        return result
+
+    docs_with_scores = vectordb.similarity_search_with_score(question, k=4)
+
+    if not docs_with_scores:
+        print(f"No documents found for question: {question}")
+        result["source"] = "gemini"
+        result["answer"] = _ask_gemini_directly(question)
+        return result
+
+    best_score = docs_with_scores[0][1] if docs_with_scores else float("inf")
+    result["relevance_score"] = float(best_score)
+
+    print(f"\nQuestion: {question}")
+    print(f"Retrieved {len(docs_with_scores)} documents:")
+    for i, (doc, score) in enumerate(docs_with_scores):
+        preview = doc.page_content[:100].replace("\n", " ")
+        print(f"  [{i + 1}] Score: {score:.3f} - {preview}...")
+
+    print(f"Using RAG with relevance score: {best_score}")
+
+    docs = [doc for doc, score in docs_with_scores]
+    context = "\n\n".join([d.page_content for d in docs])
+    result["context_found"] = True
+
+    prompt = (
+        "You are a helpful assistant. Answer the question based ONLY on the following "
+        "context from the PDF document. If the context doesn't contain enough information "
+        "to answer the question, say \"I don't have enough information in the documents to "
+        "answer this question.\"\n\n"
+        "Context from PDF:\n"
+        f"{context}\n\n"
+        f"Question: {question}\n\n"
+        "Answer (in English):"
+    )
+
+    try:
+        gemini_key = os.getenv("GEMINI_API_KEY")
+        if gemini_key:
+            try:
+                model = genai.GenerativeModel("models/gemini-2.5-flash")
+                response = model.generate_content(prompt)
+                rag_answer_text = (response.text or "").strip()
+                if _is_insufficient_context_answer(rag_answer_text):
+                    print("RAG context not sufficient. Falling back to direct AI answer.")
+                    result["answer"] = _ask_gemini_directly(question)
+                    result["source"] = "gemini"
+                    return result
+                result["answer"] = rag_answer_text
+                result["source"] = "rag"
+                return result
+            except Exception as gemini_error:
+                error_msg = str(gemini_error)
+                print(f"Gemini error in RAG: {error_msg[:200]}...")
+                if "429" in error_msg or "quota" in error_msg.lower():
+                    print("Gemini quota exceeded. Using Hugging Face for RAG.")
+
+        print("Using Hugging Face for RAG answer...")
+        rag_answer_text = _ask_huggingface_free(prompt).strip()
+        if _is_insufficient_context_answer(rag_answer_text):
+            print("RAG context not sufficient. Falling back to direct AI answer.")
+            result["answer"] = _ask_gemini_directly(question)
+            result["source"] = "gemini"
+            return result
+        result["answer"] = rag_answer_text
+        result["source"] = "rag"
+
+    except Exception as e:
+        print(f"All RAG generation failed: {e}")
+        result["answer"] = "Sorry, unable to generate answer. Please try again later."
+        result["source"] = "error"
+
+    return result
+
+
+def _ask_huggingface_free(prompt: str) -> str:
+    """Use free Hugging Face Inference API with token if available."""
+    hf_token = os.getenv("HF_API_TOKEN")
+
+    try:
+        client = InferenceClient(token=hf_token)
+    except Exception as e:
+        raise Exception(f"Failed to create Hugging Face client: {e}")
+
+    messages = [{"role": "user", "content": prompt}]
+
+    try:
+        print("Calling Hugging Face API (Qwen2.5-72B-Instruct)...")
+        response = client.chat_completion(
+            messages=messages,
+            model="Qwen/Qwen2.5-72B-Instruct",
+            max_tokens=500,
+            temperature=0.7,
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        error_str = str(e)
+        print(f"Hugging Face primary model error: {e}")
+
+        try:
+            print("Trying backup model (Microsoft Phi-3)...")
+            response = client.chat_completion(
+                messages=messages,
+                model="microsoft/Phi-3-mini-4k-instruct",
+                max_tokens=500,
+                temperature=0.7,
+            )
+            return response.choices[0].message.content
+        except Exception as e2:
+            print(f"Backup model also failed: {e2}")
+            raise Exception(f"All HF models failed: {error_str}")
+
+
+def _ask_gemini_directly(question: str) -> str:
+    """Fallback: Ask Gemini directly without RAG context, with Hugging Face fallback."""
+    prompt = (
+        "Answer the following question helpfully and accurately:\n\n"
+        f"Question: {question}\n\n"
+        "Answer:"
+    )
+
+    gemini_key = os.getenv("GEMINI_API_KEY")
+
+    if gemini_key:
+        try:
+            model = genai.GenerativeModel("models/gemini-2.5-flash")
+            response = model.generate_content(prompt)
+            return response.text
+        except Exception as gemini_error:
+            error_msg = str(gemini_error)
+            print(f"Gemini API error: {error_msg[:200]}...")
+
+            if "429" in error_msg or "quota" in error_msg.lower():
+                print("Gemini quota exceeded. Switching to Hugging Face.")
+            else:
+                print("Gemini error. Switching to Hugging Face.")
+    else:
+        print("No Gemini API key, using Hugging Face.")
+
+    try:
+        print("Using Hugging Face for direct answer...")
+        return _ask_huggingface_free(prompt)
+    except Exception as hf_error:
+        print(f"Hugging Face error: {hf_error}")
+        return (
+            "Sorry, both AI services are unavailable. "
+            f"Gemini quota exceeded, and Hugging Face error: {str(hf_error)}"
+        )
+
+
+def get_rag_status() -> dict:
+    """Get the current status of the RAG system."""
+    if not rag_initialized and FAISS_INDEX_PATH.exists():
+        load_vector_store()
+
+    _sync_uploaded_documents()
+    return {
+        "initialized": rag_initialized,
+        "documents_count": len(uploaded_documents),
+        "documents": uploaded_documents,
+        "has_embeddings": embeddings is not None,
+        "has_vector_store": vectordb is not None,
+    }
+
+
+def clear_rag_data():
+    """Clear all RAG data."""
+    global vectordb, retriever, rag_initialized, uploaded_documents, last_index_mtime
+
+    vectordb = None
+    retriever = None
+    rag_initialized = False
+    uploaded_documents = []
+    last_index_mtime = None
+
+    if FAISS_INDEX_PATH.exists():
+        import shutil
+
+        shutil.rmtree(FAISS_INDEX_PATH)
+
+    print("RAG data cleared.")
+    return True
+
+
+def _get_index_mtime():
+    index_file = FAISS_INDEX_PATH / "index.faiss"
+    if index_file.exists():
+        return index_file.stat().st_mtime
+    return None
+
+
+def _is_insufficient_context_answer(answer_text: str) -> bool:
+    if not answer_text:
+        return True
+    normalized = answer_text.strip().lower()
+    return INSUFFICIENT_CONTEXT_MARKER in normalized
+
+
+def _sync_uploaded_documents():
+    global uploaded_documents
+
+    if not RAG_DATA_DIR.exists():
+        uploaded_documents = []
+        return
+
+    uploaded_documents = sorted(
+        [pdf.name for pdf in RAG_DATA_DIR.glob("*.pdf") if pdf.is_file()]
+    )
+
+
+def rebuild_vector_store_from_pdfs() -> bool:
+    """Rebuild vector store from all PDFs in rag_data directory."""
+    global vectordb, retriever, rag_initialized
+
+    _sync_uploaded_documents()
+    if not uploaded_documents:
+        print("No PDFs found in rag_data to rebuild vector store.")
+        return False
+
+    initialize_embeddings()
+
+    vectordb = None
+    retriever = None
+    rag_initialized = False
+
+    all_chunks = []
+    for filename in uploaded_documents:
+        pdf_path = RAG_DATA_DIR / filename
+        try:
+            chunks = load_and_process_pdf(str(pdf_path))
+            all_chunks.extend(chunks)
+        except Exception as e:
+            print(f"Skipping PDF '{filename}' due to processing error: {e}")
+
+    if not all_chunks:
+        print("No chunks generated from PDFs. Rebuild aborted.")
+        return False
+
+    success = create_vector_store(all_chunks)
+    if success:
+        print(f"Rebuilt vector store from {len(uploaded_documents)} PDF(s).")
+    return success

app/static/css/style.css

@@ -0,0 +1,1054 @@
+/* CSS Variables */
+:root {
+  --primary: #6d5ce7;
+  --primary-light: #a29bfe;
+  --primary-dark: #4a3db0;
+  --primary-glow: rgba(109, 92, 231, 0.35);
+  --accent: #5f72f3;
+  --accent-light: #7c8cf8;
+  --success: #00cec9;
+  --danger: #ff6b6b;
+  --warning: #feca57;
+  --bg-dark: #080816;
+  --bg-card: rgba(15, 15, 35, 0.65);
+  --bg-card-solid: #0f0f23;
+  --bg-surface: rgba(20, 20, 50, 0.5);
+  --border-color: rgba(109, 92, 231, 0.12);
+  --border-hover: rgba(109, 92, 231, 0.35);
+  --text-white: #eef0ff;
+  --text-secondary: #a0a8c8;
+  --text-muted: #5c6280;
+  --font-main: "Inter", "Noto Sans Sinhala", system-ui, sans-serif;
+  --radius-sm: 10px;
+  --radius-md: 16px;
+  --radius-lg: 24px;
+  --radius-full: 9999px;
+}
+
+/* Reset & Base */
+*,
+*::before,
+*::after {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+html {
+  scroll-behavior: smooth;
+}
+
+body {
+  font-family: var(--font-main);
+  background: var(--bg-dark);
+  min-height: 100vh;
+  color: var(--text-white);
+  overflow-x: hidden;
+}
+
+/* Three.js Background Canvas */
+#bgCanvas {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  z-index: 0;
+  pointer-events: none;
+}
+
+/* App Wrapper */
+.app-wrapper {
+  position: relative;
+  z-index: 1;
+  max-width: 1000px;
+  margin: 0 auto;
+  padding: 8px 24px 20px;
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+/* ========== TOP BAR ========== */
+.top-bar {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 14px 24px;
+  background: var(--bg-card);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-lg);
+  backdrop-filter: blur(20px);
+}
+
+.top-bar-left {
+  display: flex;
+  align-items: center;
+}
+
+.status-indicator {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 8px 18px;
+  background: rgba(34, 197, 94, 0.08);
+  border: 1px solid rgba(34, 197, 94, 0.25);
+  border-radius: var(--radius-full);
+}
+
+.status-dot {
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+  background: var(--success);
+  box-shadow: 0 0 8px rgba(34, 197, 94, 0.6);
+  animation: pulse-glow 2s ease-in-out infinite;
+}
+
+.status-dot.recording {
+  background: var(--danger);
+  box-shadow: 0 0 8px rgba(239, 68, 68, 0.6);
+  animation: pulse-glow 0.5s ease-in-out infinite;
+}
+
+.status-dot.processing {
+  background: var(--warning);
+  box-shadow: 0 0 8px rgba(245, 158, 11, 0.6);
+  animation: pulse-glow 0.8s ease-in-out infinite;
+}
+
+.status-text {
+  font-size: 0.9rem;
+  font-weight: 600;
+  color: var(--success);
+}
+
+.top-bar-right {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.top-btn {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 10px 20px;
+  border-radius: var(--radius-full);
+  font-size: 0.88rem;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.25s ease;
+  font-family: var(--font-main);
+  border: 1px solid var(--border-color);
+}
+
+.lang-toggle-btn {
+  background: var(--primary);
+  color: white;
+  border-color: var(--primary);
+}
+
+.lang-toggle-btn:hover {
+  background: var(--primary-dark);
+  box-shadow: 0 0 20px var(--primary-glow);
+}
+
+.lang-toggle-btn.si-mode {
+  background: var(--accent);
+  border-color: var(--accent);
+}
+
+.clear-btn {
+  background: transparent;
+  color: var(--text-secondary);
+  border: 1px solid var(--border-color);
+}
+
+.clear-btn:hover {
+  color: var(--danger);
+  border-color: rgba(239, 68, 68, 0.4);
+  background: rgba(239, 68, 68, 0.08);
+}
+
+/* ========== HERO ========== */
+.hero {
+  text-align: center;
+  padding: 10px 20px 0;
+}
+
+.hero.compact {
+  padding: 30px 20px 20px;
+}
+
+.hero.compact .hero-top-row {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 20px;
+  margin-bottom: 4px;
+}
+
+.hero.compact .hero-badge {
+  margin-bottom: 0;
+}
+
+.hero.compact .hero-title {
+  font-size: 2.6rem;
+  margin-bottom: 0;
+}
+
+.hero.compact .hero-desc {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 10px;
+}
+
+.hero.compact .hero-desc i {
+  color: var(--primary-light);
+  font-size: 1rem;
+}
+
+.hero-badge {
+  display: inline-block;
+  padding: 6px 20px;
+  background: var(--primary);
+  color: white;
+  font-size: 0.82rem;
+  font-weight: 700;
+  border-radius: var(--radius-full);
+  letter-spacing: 0.5px;
+  margin-bottom: 18px;
+  box-shadow: 0 4px 20px var(--primary-glow);
+}
+
+.hero-title {
+  font-size: 3.5rem;
+  font-weight: 800;
+  background: linear-gradient(
+    135deg,
+    var(--primary-light),
+    var(--primary),
+    var(--accent-light)
+  );
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
+  letter-spacing: -1.5px;
+  line-height: 1.1;
+  margin-bottom: 8px;
+}
+
+.hero-desc {
+  font-size: 0.95rem;
+  color: var(--text-secondary);
+  font-weight: 400;
+}
+
+/* ========== INFO BANNER ========== */
+.info-banner {
+  display: flex;
+  align-items: center;
+  gap: 14px;
+  padding: 18px 28px;
+  background: var(--bg-card);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-md);
+  backdrop-filter: blur(20px);
+}
+
+.info-banner i {
+  font-size: 1.3rem;
+  color: var(--primary-light);
+}
+
+.info-banner span {
+  font-size: 0.95rem;
+  color: var(--text-secondary);
+  font-weight: 500;
+}
+
+/* ========== MAIN CONTENT ========== */
+.main-content {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+/* ========== MIC AREA ========== */
+.mic-area {
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: 6px 20px 4px;
+}
+
+.mic-area.no-box {
+  background: none;
+  border: none;
+  border-radius: 0;
+  backdrop-filter: none;
+  overflow: visible;
+}
+
+.mic-area.no-box::before {
+  display: none;
+}
+
+/* Recording Timer */
+.recording-timer {
+  display: none;
+  align-items: center;
+  gap: 8px;
+  padding: 8px 18px;
+  background: rgba(239, 68, 68, 0.1);
+  border-radius: var(--radius-full);
+  border: 1px solid rgba(239, 68, 68, 0.3);
+  margin-bottom: 20px;
+  z-index: 2;
+}
+
+.recording-timer.active {
+  display: flex;
+}
+
+.timer-dot {
+  width: 8px;
+  height: 8px;
+  background: var(--danger);
+  border-radius: 50%;
+  animation: blink 1s infinite;
+}
+
+.timer-text {
+  font-family: "JetBrains Mono", monospace;
+  font-size: 1rem;
+  font-weight: 600;
+  color: var(--danger);
+}
+
+/* Mic Row - inline mic + reset */
+.mic-row {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 24px;
+  z-index: 2;
+}
+
+/* Reset Row - right aligned above chat */
+.reset-row {
+  display: flex;
+  justify-content: flex-end;
+}
+
+/* Mic Wrapper & Glow Rings */
+.mic-wrapper {
+  position: relative;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 140px;
+  height: 140px;
+  z-index: 2;
+}
+
+.mic-glow-ring {
+  position: absolute;
+  border-radius: 50%;
+  border: 1.5px solid rgba(109, 92, 231, 0.2);
+  pointer-events: none;
+}
+
+.mic-glow-ring.ring-1 {
+  width: 90px;
+  height: 90px;
+  border-color: rgba(109, 92, 231, 0.25);
+  box-shadow: 0 0 15px rgba(109, 92, 231, 0.08);
+}
+
+.mic-glow-ring.ring-2 {
+  width: 115px;
+  height: 115px;
+  border-color: rgba(109, 92, 231, 0.15);
+  box-shadow: 0 0 25px rgba(109, 92, 231, 0.05);
+}
+
+.mic-glow-ring.ring-3 {
+  width: 140px;
+  height: 140px;
+  border-color: rgba(109, 92, 231, 0.08);
+}
+
+.mic-btn {
+  width: 64px;
+  height: 64px;
+  border-radius: 50%;
+  border: none;
+  background: linear-gradient(135deg, var(--primary), var(--accent));
+  color: white;
+  font-size: 1.6rem;
+  cursor: pointer;
+  position: relative;
+  z-index: 3;
+  transition: all 0.3s ease;
+  box-shadow:
+    0 8px 32px var(--primary-glow),
+    0 0 60px rgba(109, 92, 231, 0.15);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.mic-btn:hover {
+  transform: scale(1.08);
+  box-shadow:
+    0 12px 40px var(--primary-glow),
+    0 0 80px rgba(109, 92, 231, 0.2);
+}
+
+.mic-btn:active {
+  transform: scale(0.98);
+}
+
+.mic-btn.recording {
+  background: linear-gradient(135deg, var(--danger), #e55050);
+  box-shadow: 0 8px 32px rgba(255, 107, 107, 0.4);
+  animation: pulse-btn 1s infinite;
+}
+
+.mic-btn.recording ~ .mic-glow-ring {
+  border-color: rgba(255, 107, 107, 0.2);
+  animation: ring-pulse 1.5s ease-in-out infinite;
+}
+
+.mic-btn.recording i::before {
+  content: "\f04d";
+}
+
+/* Audio Visualizer */
+.visualizer {
+  display: none;
+  align-items: flex-end;
+  gap: 5px;
+  height: 40px;
+  margin-top: 20px;
+  z-index: 2;
+}
+
+.visualizer.active {
+  display: flex;
+}
+
+.visualizer .bar {
+  width: 6px;
+  background: linear-gradient(to top, var(--primary), var(--accent-light));
+  border-radius: 3px;
+  animation: visualize 0.5s ease infinite;
+}
+
+.visualizer .bar:nth-child(1) {
+  animation-delay: 0s;
+  height: 15px;
+}
+.visualizer .bar:nth-child(2) {
+  animation-delay: 0.1s;
+  height: 25px;
+}
+.visualizer .bar:nth-child(3) {
+  animation-delay: 0.2s;
+  height: 35px;
+}
+.visualizer .bar:nth-child(4) {
+  animation-delay: 0.3s;
+  height: 20px;
+}
+.visualizer .bar:nth-child(5) {
+  animation-delay: 0.4s;
+  height: 30px;
+}
+
+/* Reset Button */
+.reset-btn {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 10px 18px;
+  background: rgba(255, 255, 255, 0.05);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-full);
+  color: var(--text-secondary);
+  font-size: 0.88rem;
+  font-weight: 500;
+  cursor: pointer;
+  transition: all 0.25s ease;
+  font-family: var(--font-main);
+  z-index: 2;
+}
+
+.reset-btn:hover {
+  background: rgba(255, 255, 255, 0.1);
+  color: var(--text-white);
+  border-color: var(--border-hover);
+}
+
+/* ========== CHAT MESSAGES ========== */
+.chat-messages {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.message-card {
+  display: flex;
+  align-items: flex-start;
+  gap: 16px;
+  padding: 22px 24px;
+  background: var(--bg-card);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-lg);
+  backdrop-filter: blur(20px);
+  transition: border-color 0.3s ease;
+}
+
+.message-card:hover {
+  border-color: var(--border-hover);
+}
+
+.message-avatar {
+  width: 48px;
+  height: 48px;
+  border-radius: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 1.5rem;
+  flex-shrink: 0;
+}
+
+.user-avatar {
+  background: linear-gradient(
+    135deg,
+    rgba(109, 92, 231, 0.2),
+    rgba(95, 114, 243, 0.2)
+  );
+  color: var(--primary-light);
+  border: 1px solid rgba(109, 92, 231, 0.3);
+}
+
+.bot-avatar {
+  background: linear-gradient(
+    135deg,
+    rgba(0, 206, 201, 0.15),
+    rgba(95, 114, 243, 0.15)
+  );
+  color: var(--accent-light);
+  border: 1px solid rgba(95, 114, 243, 0.3);
+}
+
+.message-body {
+  flex: 1;
+  min-width: 0;
+}
+
+.message-label {
+  font-size: 0.88rem;
+  font-weight: 700;
+  color: var(--text-white);
+  margin-bottom: 8px;
+  letter-spacing: 0.3px;
+}
+
+.message-text {
+  line-height: 1.7;
+  font-size: 0.95rem;
+  color: var(--text-secondary);
+}
+
+.message-text p {
+  color: var(--text-secondary);
+}
+
+.message-text .placeholder {
+  color: var(--text-muted);
+  font-style: italic;
+}
+
+/* Message Actions (Speak / Pause) - Top Right inside bot card */
+.bot-card {
+  position: relative;
+}
+
+.message-actions-top {
+  position: absolute;
+  top: 12px;
+  right: 14px;
+  display: flex;
+  gap: 6px;
+  z-index: 2;
+}
+
+.action-btn-sm {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 34px;
+  height: 34px;
+  border-radius: 50%;
+  border: 1px solid var(--border-color);
+  background: rgba(255, 255, 255, 0.04);
+  color: var(--text-secondary);
+  font-size: 0.85rem;
+  cursor: pointer;
+  transition: all 0.25s ease;
+  font-family: var(--font-main);
+}
+
+.action-btn-sm:hover:not(:disabled) {
+  background: rgba(109, 92, 231, 0.15);
+  color: var(--primary-light);
+  border-color: var(--border-hover);
+}
+
+.action-btn-sm:disabled {
+  opacity: 0.3;
+  cursor: not-allowed;
+}
+
+.action-btn-sm.playing {
+  background: var(--primary);
+  color: white;
+  border-color: var(--primary);
+}
+
+/* Legacy action-btn (keep for compatibility) */
+.message-actions {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  flex-shrink: 0;
+  align-self: center;
+}
+
+.action-btn {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 4px;
+  width: 60px;
+  padding: 12px 8px;
+  border-radius: var(--radius-sm);
+  border: 1px solid var(--border-color);
+  background: rgba(255, 255, 255, 0.04);
+  color: var(--text-secondary);
+  font-size: 0.72rem;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.25s ease;
+  font-family: var(--font-main);
+}
+
+.action-btn i {
+  font-size: 1.1rem;
+}
+
+.action-btn:hover:not(:disabled) {
+  background: rgba(109, 92, 231, 0.15);
+  color: var(--primary-light);
+  border-color: var(--border-hover);
+}
+
+.action-btn:disabled {
+  opacity: 0.3;
+  cursor: not-allowed;
+}
+
+.action-btn.playing {
+  background: var(--primary);
+  color: white;
+  border-color: var(--primary);
+}
+
+/* ========== SOURCE BADGES ========== */
+.source-badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 5px 12px;
+  border-radius: var(--radius-full);
+  font-size: 0.78rem;
+  font-weight: 600;
+  margin-bottom: 10px;
+}
+
+.source-rag {
+  background: rgba(0, 206, 201, 0.15);
+  color: #00cec9;
+  border: 1px solid rgba(0, 206, 201, 0.3);
+}
+
+.source-gemini {
+  background: rgba(109, 92, 231, 0.15);
+  color: var(--primary-light);
+  border: 1px solid rgba(109, 92, 231, 0.3);
+}
+
+/* ========== TRANSLATED TEXT ========== */
+.translated-text {
+  font-size: 1rem;
+  margin-bottom: 8px;
+  color: var(--text-white) !important;
+}
+
+.original-text {
+  color: var(--text-muted) !important;
+  font-size: 0.85rem;
+  padding-top: 8px;
+  border-top: 1px solid var(--border-color);
+}
+
+.original-text i {
+  margin-right: 4px;
+  color: var(--primary-light);
+}
+
+/* ========== LOADING OVERLAY ========== */
+.loading-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background: rgba(8, 8, 22, 0.88);
+  display: none;
+  align-items: center;
+  justify-content: center;
+  z-index: 1000;
+  backdrop-filter: blur(12px);
+}
+
+.loading-overlay.active {
+  display: flex;
+}
+
+.loader {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 28px;
+}
+
+/* Loader Visual - Triple ring spinner */
+.loader-visual {
+  position: relative;
+  width: 100px;
+  height: 100px;
+}
+
+.loader-ring {
+  position: absolute;
+  border-radius: 50%;
+  border: 2px solid transparent;
+}
+
+.loader-ring:nth-child(1) {
+  width: 100px;
+  height: 100px;
+  top: 0;
+  left: 0;
+  border-top-color: var(--primary);
+  border-right-color: var(--primary);
+  animation: loader-spin 1.2s cubic-bezier(0.5, 0, 0.5, 1) infinite;
+  filter: drop-shadow(0 0 6px var(--primary-glow));
+}
+
+.loader-ring:nth-child(2) {
+  width: 76px;
+  height: 76px;
+  top: 12px;
+  left: 12px;
+  border-bottom-color: var(--accent);
+  border-left-color: var(--accent);
+  animation: loader-spin-reverse 1s cubic-bezier(0.5, 0, 0.5, 1) infinite;
+  filter: drop-shadow(0 0 6px rgba(95, 114, 243, 0.35));
+}
+
+.loader-ring:nth-child(3) {
+  width: 52px;
+  height: 52px;
+  top: 24px;
+  left: 24px;
+  border-top-color: var(--primary-light);
+  border-right-color: var(--accent-light);
+  animation: loader-spin 0.8s cubic-bezier(0.5, 0, 0.5, 1) infinite;
+  filter: drop-shadow(0 0 4px rgba(162, 155, 254, 0.3));
+}
+
+.loader-core {
+  position: absolute;
+  width: 36px;
+  height: 36px;
+  top: 32px;
+  left: 32px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 1.1rem;
+  color: var(--primary-light);
+  animation: loader-pulse 1.5s ease-in-out infinite;
+}
+
+/* Loader Text */
+.loader-text-area {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 10px;
+}
+
+.loader-text-area p {
+  color: var(--text-white);
+  font-size: 1.05rem;
+  font-weight: 600;
+  letter-spacing: 0.3px;
+}
+
+.loader-dots {
+  display: flex;
+  gap: 6px;
+}
+
+.loader-dots span {
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: var(--primary-light);
+  animation: loader-dot-bounce 1.2s ease-in-out infinite;
+}
+
+.loader-dots span:nth-child(2) {
+  animation-delay: 0.15s;
+}
+
+.loader-dots span:nth-child(3) {
+  animation-delay: 0.3s;
+}
+
+@keyframes loader-spin {
+  0% {
+    transform: rotate(0deg);
+  }
+  100% {
+    transform: rotate(360deg);
+  }
+}
+
+@keyframes loader-spin-reverse {
+  0% {
+    transform: rotate(0deg);
+  }
+  100% {
+    transform: rotate(-360deg);
+  }
+}
+
+@keyframes loader-pulse {
+  0%,
+  100% {
+    opacity: 0.6;
+    transform: scale(1);
+  }
+  50% {
+    opacity: 1;
+    transform: scale(1.15);
+  }
+}
+
+@keyframes loader-dot-bounce {
+  0%,
+  80%,
+  100% {
+    opacity: 0.3;
+    transform: scale(0.8);
+  }
+  40% {
+    opacity: 1;
+    transform: scale(1.2);
+  }
+}
+
+/* ========== ANIMATIONS ========== */
+@keyframes pulse-glow {
+  0%,
+  100% {
+    opacity: 1;
+  }
+  50% {
+    opacity: 0.5;
+  }
+}
+
+@keyframes blink {
+  0%,
+  100% {
+    opacity: 1;
+  }
+  50% {
+    opacity: 0;
+  }
+}
+
+@keyframes pulse-btn {
+  0%,
+  100% {
+    transform: scale(1);
+  }
+  50% {
+    transform: scale(1.06);
+  }
+}
+
+@keyframes ring-pulse {
+  0%,
+  100% {
+    transform: scale(1);
+    opacity: 0.6;
+  }
+  50% {
+    transform: scale(1.05);
+    opacity: 1;
+  }
+}
+
+@keyframes visualize {
+  0%,
+  100% {
+    transform: scaleY(0.5);
+  }
+  50% {
+    transform: scaleY(1.3);
+  }
+}
+
+@keyframes spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+/* ========== RESPONSIVE ========== */
+@media (max-width: 768px) {
+  .app-wrapper {
+    padding: 14px 16px 30px;
+    gap: 20px;
+  }
+
+  .top-bar {
+    padding: 12px 16px;
+    border-radius: var(--radius-md);
+  }
+
+  .top-btn span {
+    display: none;
+  }
+
+  .top-btn {
+    padding: 10px 14px;
+  }
+
+  .hero.compact .hero-title {
+    font-size: 1.6rem;
+  }
+
+  .hero-desc {
+    font-size: 0.88rem;
+  }
+
+  .mic-btn {
+    width: 58px;
+    height: 58px;
+    font-size: 1.4rem;
+  }
+
+  .mic-glow-ring.ring-1 {
+    width: 80px;
+    height: 80px;
+  }
+  .mic-glow-ring.ring-2 {
+    width: 100px;
+    height: 100px;
+  }
+  .mic-glow-ring.ring-3 {
+    width: 120px;
+    height: 120px;
+  }
+
+  .mic-area {
+    padding: 24px 16px 20px;
+  }
+
+  .message-card {
+    padding: 16px 18px;
+  }
+
+  .message-actions {
+    flex-direction: row;
+  }
+
+  .action-btn {
+    width: 50px;
+    padding: 10px 6px;
+    font-size: 0.68rem;
+  }
+}
+
+@media (max-width: 480px) {
+  .hero.compact .hero-title {
+    font-size: 1.4rem;
+  }
+
+  .mic-btn {
+    width: 68px;
+    height: 68px;
+    font-size: 1.7rem;
+  }
+
+  .status-indicator {
+    padding: 6px 14px;
+  }
+
+  .status-text {
+    font-size: 0.82rem;
+  }
+
+  .info-banner {
+    padding: 14px 18px;
+  }
+}
+
+/* ========== SCROLLBAR ========== */
+::-webkit-scrollbar {
+  width: 6px;
+}
+
+::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+::-webkit-scrollbar-thumb {
+  background: rgba(109, 92, 231, 0.3);
+  border-radius: 3px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: rgba(109, 92, 231, 0.5);
+}
+
+::selection {
+  background: var(--primary);
+  color: white;
+}

app/static/js/bg-animation.js

@@ -0,0 +1,223 @@
+(function () {
+  const canvas = document.getElementById('bgCanvas');
+  if (!canvas || typeof THREE === 'undefined') return;
+
+  const renderer = new THREE.WebGLRenderer({
+    canvas,
+    antialias: true,
+    alpha: true,
+  });
+  renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+  renderer.setSize(window.innerWidth, window.innerHeight);
+
+  const scene = new THREE.Scene();
+  const camera = new THREE.PerspectiveCamera(
+    60,
+    window.innerWidth / window.innerHeight,
+    0.1,
+    1000
+  );
+  camera.position.z = 30;
+
+  // ── Floating Particles ──
+  const particleCount = 180;
+  const particleGeometry = new THREE.BufferGeometry();
+  const positions = new Float32Array(particleCount * 3);
+  const velocities = new Float32Array(particleCount * 3);
+  const sizes = new Float32Array(particleCount);
+
+  for (let i = 0; i < particleCount; i++) {
+    const i3 = i * 3;
+    positions[i3] = (Math.random() - 0.5) * 80;
+    positions[i3 + 1] = (Math.random() - 0.5) * 80;
+    positions[i3 + 2] = (Math.random() - 0.5) * 40;
+
+    velocities[i3] = (Math.random() - 0.5) * 0.008;
+    velocities[i3 + 1] = (Math.random() - 0.5) * 0.008;
+    velocities[i3 + 2] = (Math.random() - 0.5) * 0.004;
+
+    sizes[i] = Math.random() * 2.5 + 0.5;
+  }
+
+  particleGeometry.setAttribute(
+    'position',
+    new THREE.BufferAttribute(positions, 3)
+  );
+  particleGeometry.setAttribute('size', new THREE.BufferAttribute(sizes, 1));
+
+  const particleMaterial = new THREE.ShaderMaterial({
+    uniforms: {
+      uTime: { value: 0 },
+      uColor1: { value: new THREE.Color(0x6d5ce7) },
+      uColor2: { value: new THREE.Color(0x5f72f3) },
+    },
+    vertexShader: `
+      attribute float size;
+      uniform float uTime;
+      varying float vAlpha;
+      void main() {
+        vec3 pos = position;
+        pos.x += sin(uTime * 0.3 + position.y * 0.1) * 0.5;
+        pos.y += cos(uTime * 0.2 + position.x * 0.1) * 0.5;
+        vec4 mvPosition = modelViewMatrix * vec4(pos, 1.0);
+        gl_PointSize = size * (20.0 / -mvPosition.z);
+        gl_Position = projectionMatrix * mvPosition;
+        vAlpha = smoothstep(0.0, 1.0, size / 3.0) * 0.6;
+      }
+    `,
+    fragmentShader: `
+      uniform vec3 uColor1;
+      uniform vec3 uColor2;
+      uniform float uTime;
+      varying float vAlpha;
+      void main() {
+        float d = length(gl_PointCoord - vec2(0.5));
+        if (d > 0.5) discard;
+        float alpha = smoothstep(0.5, 0.1, d) * vAlpha;
+        vec3 color = mix(uColor1, uColor2, sin(uTime * 0.5) * 0.5 + 0.5);
+        gl_FragColor = vec4(color, alpha);
+      }
+    `,
+    transparent: true,
+    depthWrite: false,
+    blending: THREE.AdditiveBlending,
+  });
+
+  const particles = new THREE.Points(particleGeometry, particleMaterial);
+  scene.add(particles);
+
+  // ── Subtle Connection Lines ──
+  const lineCount = 60;
+  const linePositions = new Float32Array(lineCount * 6);
+  const lineGeometry = new THREE.BufferGeometry();
+  lineGeometry.setAttribute(
+    'position',
+    new THREE.BufferAttribute(linePositions, 3)
+  );
+
+  const lineMaterial = new THREE.LineBasicMaterial({
+    color: 0x6d5ce7,
+    transparent: true,
+    opacity: 0.06,
+    blending: THREE.AdditiveBlending,
+  });
+
+  const lines = new THREE.LineSegments(lineGeometry, lineMaterial);
+  scene.add(lines);
+
+  // ── Floating Mesh Ring ──
+  const ringGeometry = new THREE.TorusGeometry(12, 0.04, 16, 100);
+  const ringMaterial = new THREE.MeshBasicMaterial({
+    color: 0x5f72f3,
+    transparent: true,
+    opacity: 0.08,
+  });
+  const ring = new THREE.Mesh(ringGeometry, ringMaterial);
+  ring.position.z = -10;
+  scene.add(ring);
+
+  // Second ring
+  const ring2Geometry = new THREE.TorusGeometry(18, 0.03, 16, 120);
+  const ring2Material = new THREE.MeshBasicMaterial({
+    color: 0x6d5ce7,
+    transparent: true,
+    opacity: 0.05,
+  });
+  const ring2 = new THREE.Mesh(ring2Geometry, ring2Material);
+  ring2.position.z = -15;
+  scene.add(ring2);
+
+  // ── Mouse interaction (subtle parallax) ──
+  let mouseX = 0;
+  let mouseY = 0;
+  document.addEventListener('mousemove', (e) => {
+    mouseX = (e.clientX / window.innerWidth - 0.5) * 2;
+    mouseY = (e.clientY / window.innerHeight - 0.5) * 2;
+  });
+
+  // ── Animation Loop ──
+  const clock = new THREE.Clock();
+
+  function updateLines() {
+    const pos = particleGeometry.attributes.position.array;
+    let idx = 0;
+    const maxDist = 12;
+
+    for (let i = 0; i < particleCount && idx < lineCount * 6; i++) {
+      for (let j = i + 1; j < particleCount && idx < lineCount * 6; j++) {
+        const dx = pos[i * 3] - pos[j * 3];
+        const dy = pos[i * 3 + 1] - pos[j * 3 + 1];
+        const dz = pos[i * 3 + 2] - pos[j * 3 + 2];
+        const dist = dx * dx + dy * dy + dz * dz;
+
+        if (dist < maxDist * maxDist) {
+          linePositions[idx++] = pos[i * 3];
+          linePositions[idx++] = pos[i * 3 + 1];
+          linePositions[idx++] = pos[i * 3 + 2];
+          linePositions[idx++] = pos[j * 3];
+          linePositions[idx++] = pos[j * 3 + 1];
+          linePositions[idx++] = pos[j * 3 + 2];
+        }
+      }
+    }
+
+    // Zero out unused
+    for (let i = idx; i < lineCount * 6; i++) {
+      linePositions[i] = 0;
+    }
+
+    lineGeometry.attributes.position.needsUpdate = true;
+  }
+
+  function animate() {
+    requestAnimationFrame(animate);
+
+    const elapsed = clock.getElapsedTime();
+    particleMaterial.uniforms.uTime.value = elapsed;
+
+    // Move particles
+    const pos = particleGeometry.attributes.position.array;
+    for (let i = 0; i < particleCount; i++) {
+      const i3 = i * 3;
+      pos[i3] += velocities[i3];
+      pos[i3 + 1] += velocities[i3 + 1];
+      pos[i3 + 2] += velocities[i3 + 2];
+
+      // Wrap around
+      if (pos[i3] > 40) pos[i3] = -40;
+      if (pos[i3] < -40) pos[i3] = 40;
+      if (pos[i3 + 1] > 40) pos[i3 + 1] = -40;
+      if (pos[i3 + 1] < -40) pos[i3 + 1] = 40;
+      if (pos[i3 + 2] > 20) pos[i3 + 2] = -20;
+      if (pos[i3 + 2] < -20) pos[i3 + 2] = 20;
+    }
+    particleGeometry.attributes.position.needsUpdate = true;
+
+    // Update connection lines every few frames
+    if (Math.floor(elapsed * 10) % 3 === 0) {
+      updateLines();
+    }
+
+    // Rotate rings
+    ring.rotation.x = elapsed * 0.08;
+    ring.rotation.y = elapsed * 0.12;
+    ring2.rotation.x = -elapsed * 0.05;
+    ring2.rotation.y = elapsed * 0.08;
+
+    // Subtle mouse parallax
+    camera.position.x += (mouseX * 1.5 - camera.position.x) * 0.02;
+    camera.position.y += (-mouseY * 1.5 - camera.position.y) * 0.02;
+    camera.lookAt(scene.position);
+
+    renderer.render(scene, camera);
+  }
+
+  animate();
+
+  // ── Resize Handler ──
+  window.addEventListener('resize', () => {
+    camera.aspect = window.innerWidth / window.innerHeight;
+    camera.updateProjectionMatrix();
+    renderer.setSize(window.innerWidth, window.innerHeight);
+  });
+})();

app/static/js/script.js

@@ -0,0 +1,628 @@
+// Global Variables
+let mediaRecorder = null;
+let audioChunks = [];
+let isRecording = false;
+let recordingStartTime = null;
+let timerInterval = null;
+let currentAudio = null;
+let responseLanguage = 'en'; // 'en' for English only, 'si-en' for Sinhala+English
+
+// DOM Elements - Voice Chat
+const micBtn = document.getElementById('micBtn');
+const statusIndicator = document.getElementById('statusIndicator');
+const statusDot = statusIndicator.querySelector('.status-dot');
+const statusText = statusIndicator.querySelector('.status-text');
+const recordingTimer = document.getElementById('recordingTimer');
+const timerText = recordingTimer.querySelector('.timer-text');
+const visualizer = document.getElementById('visualizer');
+const userText = document.getElementById('userText');
+const botText = document.getElementById('botText');
+const speakerBtn = document.getElementById('speakerBtn');
+const pauseBtn = document.getElementById('pauseBtn');
+const loadingOverlay = document.getElementById('loadingOverlay');
+const loadingText = document.getElementById('loadingText');
+const chatContainer = document.getElementById('chatContainer');
+const resetBtn = document.getElementById('resetBtn');
+
+// DOM Elements - Sections
+const voiceChatSection = document.getElementById('voiceChatSection');
+
+// Initialize
+document.addEventListener('DOMContentLoaded', () => {
+    checkBrowserSupport();
+    setupEventListeners();
+});
+
+// Check browser support for audio recording
+function checkBrowserSupport() {
+    if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+        showError('Your browser does not support audio recording. Please use a modern browser like Chrome or Firefox.');
+        micBtn.disabled = true;
+    }
+}
+
+// Setup Event Listeners
+function setupEventListeners() {
+    micBtn.addEventListener('click', toggleRecording);
+    speakerBtn.addEventListener('click', playResponse);
+    
+    // Pause button
+    if (pauseBtn) {
+        pauseBtn.addEventListener('click', pauseAudio);
+    }
+
+    // Reset button - also clears history
+    if (resetBtn) {
+        resetBtn.addEventListener('click', resetRecording);
+    }
+}
+
+// Toggle Recording
+async function toggleRecording() {
+    if (isRecording) {
+        stopRecording();
+    } else {
+        await startRecording();
+    }
+}
+
+// Start Recording
+async function startRecording() {
+    try {
+        const stream = await navigator.mediaDevices.getUserMedia({ 
+            audio: {
+                sampleRate: 16000,
+                channelCount: 1,
+                echoCancellation: true,
+                noiseSuppression: true
+            } 
+        });
+
+        // Determine the best supported MIME type
+        let mimeType = 'audio/webm';
+        if (MediaRecorder.isTypeSupported('audio/webm;codecs=opus')) {
+            mimeType = 'audio/webm;codecs=opus';
+        } else if (MediaRecorder.isTypeSupported('audio/webm')) {
+            mimeType = 'audio/webm';
+        } else if (MediaRecorder.isTypeSupported('audio/mp4')) {
+            mimeType = 'audio/mp4';
+        } else if (MediaRecorder.isTypeSupported('audio/ogg')) {
+            mimeType = 'audio/ogg';
+        }
+
+        mediaRecorder = new MediaRecorder(stream, { mimeType });
+        audioChunks = [];
+
+        mediaRecorder.ondataavailable = (event) => {
+            if (event.data.size > 0) {
+                audioChunks.push(event.data);
+            }
+        };
+
+        mediaRecorder.onstop = async () => {
+            const audioBlob = new Blob(audioChunks, { type: mimeType });
+            stream.getTracks().forEach(track => track.stop());
+            await processAudio(audioBlob);
+        };
+
+        mediaRecorder.start(100); // Collect data every 100ms
+        isRecording = true;
+        recordingStartTime = Date.now();
+
+        // Update UI
+        updateUIForRecording(true);
+        startTimer();
+
+    } catch (error) {
+        console.error('Error starting recording:', error);
+        showError('Could not access microphone. Please allow microphone permission.');
+    }
+}
+
+// Stop Recording
+function stopRecording() {
+    if (mediaRecorder && mediaRecorder.state !== 'inactive') {
+        mediaRecorder.stop();
+        isRecording = false;
+        stopTimer();
+        updateUIForRecording(false);
+    }
+}
+
+// Update UI for Recording State
+function updateUIForRecording(recording) {
+    if (recording) {
+        micBtn.classList.add('recording');
+        statusDot.classList.add('recording');
+        statusText.textContent = 'Recording...';
+        recordingTimer.classList.add('active');
+        visualizer.classList.add('active');
+    } else {
+        micBtn.classList.remove('recording');
+        statusDot.classList.remove('recording');
+        statusText.textContent = 'Processing...';
+        recordingTimer.classList.remove('active');
+        visualizer.classList.remove('active');
+    }
+}
+
+// Timer Functions
+function startTimer() {
+    timerInterval = setInterval(() => {
+        const elapsed = Date.now() - recordingStartTime;
+        const minutes = Math.floor(elapsed / 60000);
+        const seconds = Math.floor((elapsed % 60000) / 1000);
+        timerText.textContent = `${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
+    }, 100);
+}
+
+function stopTimer() {
+    if (timerInterval) {
+        clearInterval(timerInterval);
+        timerInterval = null;
+    }
+    timerText.textContent = '00:00';
+}
+
+// Process Audio - Send to Backend
+async function processAudio(audioBlob) {
+    showLoading('Converting speech to text...');
+
+    try {
+        // Convert to WAV format for better compatibility
+        const wavBlob = await convertToWav(audioBlob);
+        
+        // Create form data
+        const formData = new FormData();
+        formData.append('audio', wavBlob, 'recording.wav');
+
+        // Send to speech-to-text endpoint
+        const sttResponse = await fetch('/api/speech-to-text', {
+            method: 'POST',
+            body: formData
+        });
+
+        if (!sttResponse.ok) {
+            const error = await sttResponse.json();
+            throw new Error(error.detail || 'Speech recognition failed');
+        }
+
+        const sttResult = await sttResponse.json();
+        const transcribedText = sttResult.text;
+
+        // Show original transcription temporarily
+        displayUserText(transcribedText + ' (translating...)');
+
+        // Step 2: Translate to English
+        showLoading('Translating to English...');
+        let englishText = transcribedText;
+        let translationSuccess = false;
+        
+        try {
+            const translateRes = await fetch('/api/translate-to-english', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ question: transcribedText })
+            });
+            
+            if (translateRes.ok) {
+                const translateData = await translateRes.json();
+                if (translateData.translated && translateData.english_question) {
+                    englishText = translateData.english_question;
+                    translationSuccess = true;
+                } else if (translateData.english_question && translateData.english_question !== transcribedText) {
+                    // Even if translated flag is false, check if we got different text
+                    englishText = translateData.english_question;
+                    translationSuccess = true;
+                }
+            }
+        } catch (translateError) {
+            console.error('Translation error:', translateError);
+        }
+
+        // Display both original and English if translation succeeded, otherwise just show original
+        if (translationSuccess && englishText !== transcribedText) {
+            displayUserTextWithOriginal(transcribedText, englishText);
+        } else {
+            displayUserText(transcribedText + ' (translation failed - using original)');
+        }
+
+        // Step 3: Use RAG first, fallback to Gemini API
+        showLoading('Searching knowledge base...');
+        const ragResponse = await fetch('/api/rag/ask', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ 
+                question: englishText,
+                response_lang: responseLanguage  // 'en' or 'si-en'
+            })
+        });
+
+        if (!ragResponse.ok) {
+            const error = await ragResponse.json();
+            throw new Error(error.detail || 'Query failed');
+        }
+
+        const ragResult = await ragResponse.json();
+        const botResponse = ragResult.answer;
+        const source = ragResult.source; // 'rag', 'gemini', or 'none'
+
+        // Display bot response with source indicator
+        displayBotTextWithSource(botResponse, source);
+
+        // Enable speaker button
+        speakerBtn.disabled = false;
+
+        // Update status
+        updateStatus('ready', 'Ready');
+
+    } catch (error) {
+        console.error('Processing error:', error);
+        showError(error.message);
+        updateStatus('ready', 'Ready');
+    } finally {
+        hideLoading();
+    }
+}
+
+// Convert audio blob to WAV format
+async function convertToWav(audioBlob) {
+    return new Promise((resolve, reject) => {
+        const audioContext = new (window.AudioContext || window.webkitAudioContext)();
+        const reader = new FileReader();
+
+        reader.onload = async () => {
+            try {
+                const arrayBuffer = reader.result;
+                const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
+                
+                // Resample to 16kHz for Whisper model
+                const targetSampleRate = 16000;
+                const offlineContext = new OfflineAudioContext(
+                    1, // mono
+                    audioBuffer.duration * targetSampleRate,
+                    targetSampleRate
+                );
+
+                const source = offlineContext.createBufferSource();
+                source.buffer = audioBuffer;
+                source.connect(offlineContext.destination);
+                source.start(0);
+
+                const renderedBuffer = await offlineContext.startRendering();
+                const wavBlob = audioBufferToWav(renderedBuffer);
+                resolve(wavBlob);
+            } catch (error) {
+                // If conversion fails, return original blob
+                console.warn('WAV conversion failed, using original format:', error);
+                resolve(audioBlob);
+            }
+        };
+
+        reader.onerror = () => reject(reader.error);
+        reader.readAsArrayBuffer(audioBlob);
+    });
+}
+
+// Convert AudioBuffer to WAV Blob
+function audioBufferToWav(buffer) {
+    const numChannels = buffer.numberOfChannels;
+    const sampleRate = buffer.sampleRate;
+    const format = 1; // PCM
+    const bitDepth = 16;
+
+    const bytesPerSample = bitDepth / 8;
+    const blockAlign = numChannels * bytesPerSample;
+
+    const dataLength = buffer.length * blockAlign;
+    const bufferLength = 44 + dataLength;
+
+    const arrayBuffer = new ArrayBuffer(bufferLength);
+    const view = new DataView(arrayBuffer);
+
+    // WAV header
+    writeString(view, 0, 'RIFF');
+    view.setUint32(4, 36 + dataLength, true);
+    writeString(view, 8, 'WAVE');
+    writeString(view, 12, 'fmt ');
+    view.setUint32(16, 16, true);
+    view.setUint16(20, format, true);
+    view.setUint16(22, numChannels, true);
+    view.setUint32(24, sampleRate, true);
+    view.setUint32(28, sampleRate * blockAlign, true);
+    view.setUint16(32, blockAlign, true);
+    view.setUint16(34, bitDepth, true);
+    writeString(view, 36, 'data');
+    view.setUint32(40, dataLength, true);
+
+    // Write audio data
+    const channelData = buffer.getChannelData(0);
+    let offset = 44;
+    for (let i = 0; i < channelData.length; i++) {
+        const sample = Math.max(-1, Math.min(1, channelData[i]));
+        view.setInt16(offset, sample < 0 ? sample * 0x8000 : sample * 0x7FFF, true);
+        offset += 2;
+    }
+
+    return new Blob([arrayBuffer], { type: 'audio/wav' });
+}
+
+function writeString(view, offset, string) {
+    for (let i = 0; i < string.length; i++) {
+        view.setUint8(offset + i, string.charCodeAt(i));
+    }
+}
+
+// Display Functions
+function displayUserText(text) {
+    userText.innerHTML = `<p>${escapeHtml(text)}</p>`;
+}
+
+function displayUserTextWithOriginal(originalText, englishText) {
+    userText.innerHTML = `
+        <p>${escapeHtml(originalText)}</p>
+    `;
+}
+
+function displayBotText(text) {
+    // Convert markdown-like formatting to HTML
+    const formattedText = formatText(text);
+    botText.innerHTML = formattedText;
+}
+
+function displayBotTextWithSource(text, source) {
+    // Convert markdown-like formatting to HTML with source badge
+    const formattedText = formatText(text);
+    let sourceLabel = '';
+    if (source === 'rag') {
+        sourceLabel = '<span class="source-badge source-rag"><i class="fas fa-database"></i> From Documents</span>';
+    } else if (source === 'gemini') {
+        sourceLabel = '<span class="source-badge source-gemini"><i class="fas fa-brain"></i> From AI</span>';
+    }
+    botText.innerHTML = sourceLabel + formattedText;
+}
+
+function formatText(text) {
+    // Basic formatting
+    let formatted = escapeHtml(text);
+    
+    // Convert line breaks
+    formatted = formatted.replace(/\n/g, '<br>');
+    
+    // Convert **bold** to <strong>
+    formatted = formatted.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>');
+    
+    // Convert *italic* to <em>
+    formatted = formatted.replace(/\*(.*?)\*/g, '<em>$1</em>');
+    
+    return `<p>${formatted}</p>`;
+}
+
+function escapeHtml(text) {
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+}
+
+// Play Response using TTS
+async function playResponse() {
+    const text = botText.textContent || botText.innerText;
+    
+    if (!text || text.includes('will appear here')) {
+        return;
+    }
+
+    // If paused, resume
+    if (currentAudio && currentAudio.paused) {
+        currentAudio.play();
+        speakerBtn.classList.add('playing');
+        pauseBtn.classList.remove('paused');
+        pauseBtn.querySelector('i').className = 'fas fa-pause';
+        return;
+    }
+
+    // Stop current audio if playing
+    if (currentAudio) {
+        currentAudio.pause();
+        currentAudio = null;
+        speakerBtn.classList.remove('playing');
+    }
+
+    speakerBtn.classList.add('playing');
+    speakerBtn.querySelector('i').className = 'fas fa-spinner fa-spin';
+
+    try {
+        const ttsLang = responseLanguage === 'en' ? 'en' : 'si';
+
+        const response = await fetch('/api/text-to-speech', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ 
+                text: text,
+                lang: ttsLang
+            })
+        });
+
+        if (!response.ok) {
+            throw new Error('Text-to-speech failed');
+        }
+
+        const audioBlob = await response.blob();
+        const audioUrl = URL.createObjectURL(audioBlob);
+        
+        currentAudio = new Audio(audioUrl);
+        
+        currentAudio.onended = () => {
+            speakerBtn.classList.remove('playing');
+            speakerBtn.querySelector('i').className = 'fas fa-volume-up';
+            pauseBtn.classList.remove('paused');
+            pauseBtn.querySelector('i').className = 'fas fa-pause';
+            URL.revokeObjectURL(audioUrl);
+            currentAudio = null;
+        };
+
+        currentAudio.onerror = () => {
+            speakerBtn.classList.remove('playing');
+            speakerBtn.querySelector('i').className = 'fas fa-volume-up';
+            showError('Failed to play audio');
+        };
+
+        await currentAudio.play();
+        speakerBtn.querySelector('i').className = 'fas fa-volume-up';
+
+    } catch (error) {
+        console.error('TTS error:', error);
+        speakerBtn.classList.remove('playing');
+        speakerBtn.querySelector('i').className = 'fas fa-volume-up';
+        showError('Text-to-speech failed');
+    }
+}
+
+// Pause Audio Playback
+function pauseAudio() {
+    if (currentAudio && !currentAudio.paused) {
+        currentAudio.pause();
+        speakerBtn.classList.remove('playing');
+        pauseBtn.classList.add('paused');
+        pauseBtn.querySelector('i').className = 'fas fa-play';
+    } else if (currentAudio && currentAudio.paused) {
+        currentAudio.play();
+        speakerBtn.classList.add('playing');
+        pauseBtn.classList.remove('paused');
+        pauseBtn.querySelector('i').className = 'fas fa-pause';
+    }
+}
+
+// Reset Recording / Stop current action
+function resetRecording() {
+    if (isRecording) {
+        stopRecording();
+    }
+    if (currentAudio) {
+        currentAudio.pause();
+        currentAudio = null;
+        speakerBtn.classList.remove('playing');
+    }
+    updateStatus('ready', 'Ready');
+    clearHistory();
+}
+
+// Clear Conversation History
+async function clearHistory() {
+    try {
+        const response = await fetch('/api/clear-history', {
+            method: 'POST'
+        });
+
+        if (response.ok) {
+            // Reset UI
+            userText.innerHTML = '<p class="placeholder">Your transcribed message will appear here...</p>';
+            botText.innerHTML = '<p class="placeholder">Bot response will appear here...</p>';
+            speakerBtn.disabled = true;
+            
+            // Show confirmation
+            showSuccess('Conversation history cleared');
+        }
+    } catch (error) {
+        console.error('Error clearing history:', error);
+        showError('Failed to clear history');
+    }
+}
+
+// Loading Functions
+function showLoading(message = 'Processing...') {
+    loadingText.textContent = message;
+    loadingOverlay.classList.add('active');
+}
+
+function hideLoading() {
+    loadingOverlay.classList.remove('active');
+}
+
+// Status Update
+function updateStatus(state, text) {
+    statusDot.className = 'status-dot';
+    if (state !== 'ready') {
+        statusDot.classList.add(state);
+    }
+    statusText.textContent = text;
+}
+
+// Notification Functions
+function showError(message) {
+    // Create toast notification
+    showToast(message, 'error');
+    // Clear user and bot input fields after 2 seconds
+    setTimeout(() => {
+        if (userText) {
+            userText.innerHTML = '<p class="placeholder">Your transcribed message will appear here...</p>';
+        }
+        if (botText) {
+            botText.innerHTML = '<p class="placeholder">Bot response will appear here...</p>';
+        }
+    }, 2000);
+}
+
+function showSuccess(message) {
+    showToast(message, 'success');
+}
+
+function showToast(message, type = 'info') {
+    // Remove existing toasts
+    const existingToasts = document.querySelectorAll('.toast');
+    existingToasts.forEach(t => t.remove());
+
+    // Create toast element
+    const toast = document.createElement('div');
+    toast.className = `toast toast-${type}`;
+    toast.innerHTML = `
+        <i class="fas ${type === 'error' ? 'fa-exclamation-circle' : 'fa-check-circle'}"></i>
+        <span>${message}</span>
+    `;
+
+    // Add styles
+    toast.style.cssText = `
+        position: fixed;
+        bottom: 20px;
+        left: 50%;
+        transform: translateX(-50%);
+        padding: 12px 24px;
+        background: ${type === 'error' ? '#ef4444' : '#22c55e'};
+        color: white;
+        border-radius: 8px;
+        display: flex;
+        align-items: center;
+        gap: 10px;
+        z-index: 2000;
+        box-shadow: 0 4px 20px rgba(0,0,0,0.3);
+        animation: slideUp 0.3s ease;
+    `;
+
+    // Add animation keyframes if not exists
+    if (!document.getElementById('toast-styles')) {
+        const style = document.createElement('style');
+        style.id = 'toast-styles';
+        style.textContent = `
+            @keyframes slideUp {
+                from { transform: translateX(-50%) translateY(100%); opacity: 0; }
+                to { transform: translateX(-50%) translateY(0); opacity: 1; }
+            }
+        `;
+        document.head.appendChild(style);
+    }
+
+    document.body.appendChild(toast);
+
+    // Remove after 4 seconds
+    setTimeout(() => {
+        toast.style.opacity = '0';
+        toast.style.transition = 'opacity 0.3s ease';
+        setTimeout(() => toast.remove(), 300);
+    }, 4000);
+}
+
+

app/templates/admin.html

@@ -0,0 +1,769 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>RAG Admin Panel - Document Management</title>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.1/css/all.min.css">
+    <style>
+        :root {
+            --primary-color: #6d5ce7;
+            --primary-hover: #4a3db0;
+            --primary-light: #a29bfe;
+            --primary-glow: rgba(109, 92, 231, 0.35);
+            --accent: #5f72f3;
+            --accent-light: #7c8cf8;
+            --success-color: #00cec9;
+            --danger-color: #ff6b6b;
+            --warning-color: #feca57;
+            --bg-dark: #080816;
+            --bg-card: rgba(15, 15, 35, 0.65);
+            --text-primary: #eef0ff;
+            --text-secondary: #a0a8c8;
+            --border-color: rgba(109, 92, 231, 0.12);
+            --border-hover: rgba(109, 92, 231, 0.35);
+        }
+
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Inter', sans-serif;
+            background: var(--bg-dark);
+            min-height: 100vh;
+            color: var(--text-primary);
+            padding: 20px;
+            overflow-x: hidden;
+        }
+
+        #bgCanvas {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            z-index: 0;
+            pointer-events: none;
+        }
+
+        .container {
+            max-width: 900px;
+            margin: 0 auto;
+            position: relative;
+            z-index: 1;
+        }
+
+        .header {
+            text-align: center;
+            margin-bottom: 40px;
+            padding: 30px;
+            background: var(--bg-card);
+            border-radius: 16px;
+            border: 1px solid var(--border-color);
+            backdrop-filter: blur(20px);
+        }
+
+        .header h1 {
+            font-size: 2rem;
+            margin-bottom: 10px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            gap: 12px;
+        }
+
+        .header h1 i {
+            color: var(--primary-color);
+        }
+
+        .header p {
+            color: var(--text-secondary);
+        }
+
+        .status-card {
+            background: var(--bg-card);
+            border-radius: 12px;
+            padding: 20px;
+            margin-bottom: 20px;
+            border: 1px solid var(--border-color);
+            backdrop-filter: blur(20px);
+        }
+
+        .status-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 15px;
+        }
+
+        .status-header h3 {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+
+        .status-indicator {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            padding: 6px 12px;
+            border-radius: 20px;
+            font-size: 0.85rem;
+        }
+
+        .status-indicator.ready {
+            background: rgba(0, 206, 201, 0.2);
+            color: var(--success-color);
+        }
+
+        .status-indicator.empty {
+            background: rgba(254, 202, 87, 0.2);
+            color: var(--warning-color);
+        }
+
+        .status-dot {
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            background: currentColor;
+        }
+
+        .upload-section {
+            background: var(--bg-card);
+            border-radius: 12px;
+            padding: 30px;
+            margin-bottom: 20px;
+            border: 1px solid var(--border-color);
+            backdrop-filter: blur(20px);
+        }
+
+        .upload-box {
+            border: 2px dashed var(--border-color);
+            border-radius: 12px;
+            padding: 50px 20px;
+            text-align: center;
+            cursor: pointer;
+            transition: all 0.3s ease;
+        }
+
+        .upload-box:hover {
+            border-color: var(--primary-color);
+            background: rgba(109, 92, 231, 0.1);
+        }
+
+        .upload-box.dragover {
+            border-color: var(--primary-color);
+            background: rgba(109, 92, 231, 0.2);
+        }
+
+        .upload-box i {
+            font-size: 3rem;
+            color: var(--primary-color);
+            margin-bottom: 15px;
+        }
+
+        .upload-box h3 {
+            margin-bottom: 8px;
+        }
+
+        .upload-box p {
+            color: var(--text-secondary);
+            font-size: 0.9rem;
+        }
+
+        .documents-section {
+            background: var(--bg-card);
+            border-radius: 12px;
+            padding: 20px;
+            border: 1px solid var(--border-color);
+            backdrop-filter: blur(20px);
+        }
+
+        .documents-section h3 {
+            margin-bottom: 15px;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+
+        .document-list {
+            display: flex;
+            flex-direction: column;
+            gap: 10px;
+        }
+
+        .document-item {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            padding: 15px;
+            background: rgba(8, 8, 22, 0.5);
+            border-radius: 8px;
+            border: 1px solid var(--border-color);
+        }
+
+        .document-info {
+            display: flex;
+            align-items: center;
+            gap: 12px;
+        }
+
+        .document-info i {
+            font-size: 1.5rem;
+            color: var(--danger-color);
+        }
+
+        .document-name {
+            font-weight: 500;
+        }
+
+        .delete-btn {
+            background: rgba(255, 107, 107, 0.2);
+            border: 1px solid var(--danger-color);
+            color: var(--danger-color);
+            padding: 8px 16px;
+            border-radius: 6px;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            display: flex;
+            align-items: center;
+            gap: 6px;
+        }
+
+        .delete-btn:hover {
+            background: var(--danger-color);
+            color: white;
+        }
+
+        .clear-all-btn {
+            background: var(--danger-color);
+            border: none;
+            color: white;
+            padding: 10px 20px;
+            border-radius: 8px;
+            cursor: pointer;
+            font-weight: 500;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            transition: all 0.3s ease;
+        }
+
+        .clear-all-btn:hover {
+            background: #e55050;
+        }
+
+        .rebuild-btn {
+            background: var(--primary-color);
+            border: none;
+            color: white;
+            padding: 10px 20px;
+            border-radius: 8px;
+            cursor: pointer;
+            font-weight: 500;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            transition: all 0.3s ease;
+        }
+
+        .rebuild-btn:hover {
+            background: var(--primary-hover);
+        }
+
+        .empty-state {
+            text-align: center;
+            padding: 40px;
+            color: var(--text-secondary);
+        }
+
+        .empty-state i {
+            font-size: 3rem;
+            margin-bottom: 15px;
+            opacity: 0.5;
+        }
+
+        .toast {
+            position: fixed;
+            bottom: 20px;
+            right: 20px;
+            padding: 15px 25px;
+            border-radius: 8px;
+            color: white;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+            z-index: 1000;
+            animation: slideIn 0.3s ease;
+        }
+
+        .toast.success {
+            background: var(--success-color);
+        }
+
+        .toast.error {
+            background: var(--danger-color);
+        }
+
+        @keyframes slideIn {
+            from {
+                transform: translateX(100%);
+                opacity: 0;
+            }
+            to {
+                transform: translateX(0);
+                opacity: 1;
+            }
+        }
+
+        .loading-overlay {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: rgba(8, 8, 22, 0.88);
+            display: none;
+            justify-content: center;
+            align-items: center;
+            z-index: 999;
+            backdrop-filter: blur(12px);
+        }
+
+        .loading-content {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            gap: 28px;
+        }
+
+        .loader-visual {
+            position: relative;
+            width: 100px;
+            height: 100px;
+        }
+
+        .loader-ring {
+            position: absolute;
+            border-radius: 50%;
+            border: 2px solid transparent;
+        }
+
+        .loader-ring:nth-child(1) {
+            width: 100px;
+            height: 100px;
+            top: 0; left: 0;
+            border-top-color: var(--primary-color);
+            border-right-color: var(--primary-color);
+            animation: lspin 1.2s cubic-bezier(0.5,0,0.5,1) infinite;
+            filter: drop-shadow(0 0 6px var(--primary-glow));
+        }
+
+        .loader-ring:nth-child(2) {
+            width: 76px;
+            height: 76px;
+            top: 12px; left: 12px;
+            border-bottom-color: var(--accent);
+            border-left-color: var(--accent);
+            animation: lspin-r 1s cubic-bezier(0.5,0,0.5,1) infinite;
+            filter: drop-shadow(0 0 6px rgba(95,114,243,0.35));
+        }
+
+        .loader-ring:nth-child(3) {
+            width: 52px;
+            height: 52px;
+            top: 24px; left: 24px;
+            border-top-color: var(--primary-light);
+            border-right-color: var(--accent-light);
+            animation: lspin 0.8s cubic-bezier(0.5,0,0.5,1) infinite;
+            filter: drop-shadow(0 0 4px rgba(162,155,254,0.3));
+        }
+
+        .loader-core {
+            position: absolute;
+            width: 36px; height: 36px;
+            top: 32px; left: 32px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 1.1rem;
+            color: var(--primary-light);
+            animation: lpulse 1.5s ease-in-out infinite;
+        }
+
+        .loader-text-area {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            gap: 10px;
+        }
+
+        .loader-text-area p {
+            color: var(--text-primary);
+            font-size: 1.05rem;
+            font-weight: 600;
+        }
+
+        .loader-dots {
+            display: flex;
+            gap: 6px;
+        }
+
+        .loader-dots span {
+            width: 6px; height: 6px;
+            border-radius: 50%;
+            background: var(--primary-light);
+            animation: ldot 1.2s ease-in-out infinite;
+        }
+
+        .loader-dots span:nth-child(2) { animation-delay: 0.15s; }
+        .loader-dots span:nth-child(3) { animation-delay: 0.3s; }
+
+        @keyframes lspin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+
+        @keyframes lspin-r {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(-360deg); }
+        }
+
+        @keyframes lpulse {
+            0%,100% { opacity: 0.6; transform: scale(1); }
+            50% { opacity: 1; transform: scale(1.15); }
+        }
+
+        @keyframes ldot {
+            0%,80%,100% { opacity: 0.3; transform: scale(0.8); }
+            40% { opacity: 1; transform: scale(1.2); }
+        }
+
+        .spinner {
+            width: 50px;
+            height: 50px;
+            border: 4px solid var(--border-color);
+            border-top-color: var(--primary-color);
+            border-radius: 50%;
+            animation: spin 1s linear infinite;
+            margin: 0 auto 15px;
+        }
+
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+
+        .back-link {
+            display: inline-flex;
+            align-items: center;
+            gap: 8px;
+            color: var(--text-secondary);
+            text-decoration: none;
+            margin-bottom: 20px;
+            transition: color 0.3s;
+        }
+
+        .back-link:hover {
+            color: var(--primary-color);
+        }
+    </style>
+</head>
+<body>
+    <!-- Three.js Background Canvas -->
+    <canvas id="bgCanvas"></canvas>
+
+    <div class="container">
+        <a href="http://localhost:8000" class="back-link" target="_blank">
+            <i class="fas fa-arrow-left"></i> Open Chatbot (Port 8000)
+        </a>
+
+        <div class="header">
+            <h1><i class="fas fa-database"></i> RAG Admin Panel</h1>
+            <p>Upload and manage PDF documents for the RAG knowledge base</p>
+        </div>
+
+        <div class="status-card">
+            <div class="status-header">
+                <h3><i class="fas fa-chart-bar"></i> System Status</h3>
+                <div class="status-indicator empty" id="statusIndicator">
+                    <span class="status-dot"></span>
+                    <span id="statusText">No documents</span>
+                </div>
+            </div>
+            <div id="statsInfo">
+                <p style="color: var(--text-secondary);">Documents: <span id="docCount">0</span></p>
+            </div>
+        </div>
+
+        <div class="upload-section">
+            <div class="upload-box" id="uploadBox">
+                <i class="fas fa-cloud-upload-alt"></i>
+                <h3>Upload PDF Document</h3>
+                <p>Drag & drop your PDF here or click to browse</p>
+                <input type="file" id="fileInput" accept=".pdf" hidden>
+            </div>
+        </div>
+
+        <div class="documents-section">
+            <div class="status-header">
+                <h3><i class="fas fa-folder-open"></i> Uploaded Documents</h3>
+                <div style="display: flex; gap: 10px;">
+                    <button class="rebuild-btn" id="rebuildBtn" style="display: none;">
+                        <i class="fas fa-gears"></i> Rebuild RAG
+                    </button>
+                    <button class="clear-all-btn" id="clearAllBtn" style="display: none;">
+                        <i class="fas fa-trash-alt"></i> Clear All
+                    </button>
+                </div>
+            </div>
+            <div class="document-list" id="documentList">
+                <div class="empty-state">
+                    <i class="fas fa-file-pdf"></i>
+                    <p>No documents uploaded yet</p>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <div class="loading-overlay" id="loadingOverlay">
+        <div class="loading-content">
+            <div class="loader-visual">
+                <div class="loader-ring"></div>
+                <div class="loader-ring"></div>
+                <div class="loader-ring"></div>
+                <div class="loader-core">
+                    <i class="fas fa-brain"></i>
+                </div>
+            </div>
+            <div class="loader-text-area">
+                <p id="loadingText">Processing...</p>
+                <div class="loader-dots">
+                    <span></span><span></span><span></span>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
+    <script src="/static/js/bg-animation.js"></script>
+
+    <script>
+        const uploadBox = document.getElementById('uploadBox');
+        const fileInput = document.getElementById('fileInput');
+        const documentList = document.getElementById('documentList');
+        const statusIndicator = document.getElementById('statusIndicator');
+        const statusText = document.getElementById('statusText');
+        const docCount = document.getElementById('docCount');
+        const clearAllBtn = document.getElementById('clearAllBtn');
+        const rebuildBtn = document.getElementById('rebuildBtn');
+        const loadingOverlay = document.getElementById('loadingOverlay');
+        const loadingText = document.getElementById('loadingText');
+
+        // Initialize
+        document.addEventListener('DOMContentLoaded', loadStatus);
+
+        // Upload box events
+        uploadBox.addEventListener('click', () => fileInput.click());
+        fileInput.addEventListener('change', handleFileSelect);
+
+        // Drag and drop
+        uploadBox.addEventListener('dragover', (e) => {
+            e.preventDefault();
+            uploadBox.classList.add('dragover');
+        });
+        uploadBox.addEventListener('dragleave', () => {
+            uploadBox.classList.remove('dragover');
+        });
+        uploadBox.addEventListener('drop', (e) => {
+            e.preventDefault();
+            uploadBox.classList.remove('dragover');
+            if (e.dataTransfer.files.length > 0) {
+                handleFileUpload(e.dataTransfer.files[0]);
+            }
+        });
+
+        // Clear all
+        clearAllBtn.addEventListener('click', clearAllDocuments);
+        rebuildBtn.addEventListener('click', rebuildRag);
+
+        function handleFileSelect(e) {
+            if (e.target.files.length > 0) {
+                handleFileUpload(e.target.files[0]);
+            }
+        }
+
+        async function handleFileUpload(file) {
+            if (!file.name.toLowerCase().endsWith('.pdf')) {
+                showToast('Please upload a PDF file', 'error');
+                return;
+            }
+
+            showLoading('Uploading and processing PDF...');
+
+            const formData = new FormData();
+            formData.append('file', file);
+
+            try {
+                const response = await fetch('/api/upload', {
+                    method: 'POST',
+                    body: formData
+                });
+
+                if (!response.ok) {
+                    const error = await response.json();
+                    throw new Error(error.detail || 'Upload failed');
+                }
+
+                const result = await response.json();
+                showToast(result.message, 'success');
+                loadStatus();
+
+            } catch (error) {
+                console.error('Upload error:', error);
+                showToast(error.message, 'error');
+            } finally {
+                hideLoading();
+                fileInput.value = '';
+            }
+        }
+
+        async function loadStatus() {
+            try {
+                const response = await fetch('/api/status');
+                const status = await response.json();
+
+                docCount.textContent = status.documents_count;
+
+                if (status.initialized && status.documents_count > 0) {
+                    statusIndicator.className = 'status-indicator ready';
+                    statusText.textContent = 'Ready';
+                    clearAllBtn.style.display = 'flex';
+                    rebuildBtn.style.display = 'flex';
+                    renderDocuments(status.documents);
+                } else {
+                    statusIndicator.className = 'status-indicator empty';
+                    statusText.textContent = 'No documents';
+                    clearAllBtn.style.display = 'none';
+                    rebuildBtn.style.display = 'none';
+                    documentList.innerHTML = `
+                        <div class="empty-state">
+                            <i class="fas fa-file-pdf"></i>
+                            <p>No documents uploaded yet</p>
+                        </div>
+                    `;
+                }
+            } catch (error) {
+                console.error('Failed to load status:', error);
+            }
+        }
+
+        function renderDocuments(documents) {
+            if (!documents || documents.length === 0) {
+                documentList.innerHTML = `
+                    <div class="empty-state">
+                        <i class="fas fa-file-pdf"></i>
+                        <p>No documents uploaded yet</p>
+                    </div>
+                `;
+                return;
+            }
+
+            documentList.innerHTML = documents.map(doc => `
+                <div class="document-item">
+                    <div class="document-info">
+                        <i class="fas fa-file-pdf"></i>
+                        <span class="document-name">${doc}</span>
+                    </div>
+                    <button class="delete-btn" onclick="deleteDocument('${doc}')">
+                        <i class="fas fa-trash"></i> Delete
+                    </button>
+                </div>
+            `).join('');
+        }
+
+        async function deleteDocument(filename) {
+            if (!confirm(`Delete "${filename}"?`)) return;
+
+            try {
+                const response = await fetch(`/api/document/${encodeURIComponent(filename)}`, {
+                    method: 'DELETE'
+                });
+
+                if (response.ok) {
+                    showToast('Document deleted', 'success');
+                    loadStatus();
+                }
+            } catch (error) {
+                showToast('Failed to delete', 'error');
+            }
+        }
+
+        async function clearAllDocuments() {
+            if (!confirm('Clear all documents? This cannot be undone.')) return;
+
+            showLoading('Clearing all data...');
+
+            try {
+                const response = await fetch('/api/clear', { method: 'POST' });
+                if (response.ok) {
+                    showToast('All documents cleared', 'success');
+                    loadStatus();
+                }
+            } catch (error) {
+                showToast('Failed to clear', 'error');
+            } finally {
+                hideLoading();
+            }
+        }
+
+        async function rebuildRag() {
+            showLoading('Rebuilding RAG index from all PDFs...');
+
+            try {
+                const response = await fetch('/api/rebuild', { method: 'POST' });
+                const result = await response.json();
+                if (!response.ok || !result.success) {
+                    throw new Error(result.message || 'RAG rebuild failed');
+                }
+                showToast(result.message, 'success');
+                loadStatus();
+            } catch (error) {
+                showToast(error.message || 'Failed to rebuild RAG', 'error');
+            } finally {
+                hideLoading();
+            }
+        }
+
+        function showLoading(text) {
+            loadingText.textContent = text;
+            loadingOverlay.style.display = 'flex';
+        }
+
+        function hideLoading() {
+            loadingOverlay.style.display = 'none';
+        }
+
+        function showToast(message, type) {
+            const existing = document.querySelector('.toast');
+            if (existing) existing.remove();
+
+            const toast = document.createElement('div');
+            toast.className = `toast ${type}`;
+            toast.innerHTML = `
+                <i class="fas ${type === 'success' ? 'fa-check-circle' : 'fa-exclamation-circle'}"></i>
+                <span>${message}</span>
+            `;
+            document.body.appendChild(toast);
+
+            setTimeout(() => {
+                toast.style.opacity = '0';
+                setTimeout(() => toast.remove(), 300);
+            }, 3000);
+        }
+    </script>
+</body>
+</html>

app/templates/index.html

@@ -0,0 +1,132 @@
+<!DOCTYPE html>
+<html lang="si">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Sinhala Chatbot</title>
+    <link rel="stylesheet" href="/static/css/style.css">
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&family=Noto+Sans+Sinhala:wght@400;500;600;700&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.1/css/all.min.css">
+</head>
+<body>
+    <!-- Three.js Background Canvas -->
+    <canvas id="bgCanvas"></canvas>
+
+    <div class="app-wrapper">
+        <!-- Hidden Status Indicator (used by JS) -->
+        <div class="status-indicator" id="statusIndicator" style="display:none;">
+            <span class="status-dot"></span>
+            <span class="status-text">Ready</span>
+        </div>
+
+        <!-- Compact Header -->
+        <header class="hero compact">
+            <div class="hero-top-row">
+                <div class="hero-badge">AI-Powered</div>
+                <h1 class="hero-title">Sinhala Chatbot</h1>
+            </div>
+            <p class="hero-desc"><i class="fas fa-wand-magic-sparkles"></i> Press the microphone to start &mdash; Supports Sinhala &amp; English voice input</p>
+        </header>
+
+        <!-- Main Content Area -->
+        <main class="main-content" id="voiceChatSection">
+            <!-- Mic Control Area (no box) -->
+            <div class="mic-area no-box">
+                <!-- Recording Timer -->
+                <div class="recording-timer" id="recordingTimer">
+                    <span class="timer-dot"></span>
+                    <span class="timer-text">00:00</span>
+                </div>
+
+                <!-- Mic Button with Glow -->
+                <div class="mic-wrapper">
+                    <div class="mic-glow-ring ring-1"></div>
+                    <div class="mic-glow-ring ring-2"></div>
+                    <div class="mic-glow-ring ring-3"></div>
+                    <button class="mic-btn" id="micBtn" title="Click to record">
+                        <i class="fas fa-microphone"></i>
+                    </button>
+                </div>
+
+                <!-- Audio Visualizer -->
+                <div class="visualizer" id="visualizer">
+                    <div class="bar"></div>
+                    <div class="bar"></div>
+                    <div class="bar"></div>
+                    <div class="bar"></div>
+                    <div class="bar"></div>
+                </div>
+            </div>
+
+            <!-- Reset Button Row -->
+            <div class="reset-row">
+                <button class="reset-btn" id="resetBtn" title="Reset">
+                    <i class="fas fa-rotate-right"></i>
+                    <span>Reset</span>
+                </button>
+            </div>
+
+            <!-- Chat Messages -->
+            <div class="chat-messages" id="chatContainer">
+                <!-- User Message Card -->
+                <div class="message-card user-card" id="inputDisplay">
+                    <div class="message-avatar user-avatar">
+                        <i class="fas fa-user-circle"></i>
+                    </div>
+                    <div class="message-body">
+                        <div class="message-label">Your Message</div>
+                        <div class="message-text" id="userText">
+                            <p class="placeholder">Your transcribed message will appear here...</p>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Bot Response Card -->
+                <div class="message-card bot-card" id="responseDisplay">
+                    <div class="message-actions-top">
+                        <button class="action-btn-sm speak-btn" id="speakerBtn" title="Listen to response" disabled>
+                            <i class="fas fa-volume-up"></i>
+                        </button>
+                        <button class="action-btn-sm pause-btn" id="pauseBtn" title="Pause audio">
+                            <i class="fas fa-pause"></i>
+                        </button>
+                    </div>
+                    <div class="message-avatar bot-avatar">
+                        <i class="fas fa-robot"></i>
+                    </div>
+                    <div class="message-body">
+                        <div class="message-label">Bot Response</div>
+                        <div class="message-text" id="botText">
+                            <p class="placeholder">Bot response will appear here...</p>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </main>
+
+        <!-- Loading Overlay -->
+        <div class="loading-overlay" id="loadingOverlay">
+            <div class="loader">
+                <div class="loader-visual">
+                    <div class="loader-ring"></div>
+                    <div class="loader-ring"></div>
+                    <div class="loader-ring"></div>
+                    <div class="loader-core">
+                        <i class="fas fa-brain"></i>
+                    </div>
+                </div>
+                <div class="loader-text-area">
+                    <p id="loadingText">Processing...</p>
+                    <div class="loader-dots">
+                        <span></span><span></span><span></span>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
+    <script src="/static/js/script.js"></script>
+    <script src="/static/js/bg-animation.js"></script>
+</body>
+</html>

colab_rag_admin_api.ipynb

@@ -0,0 +1,881 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "cf8f37b5",
+   "metadata": {},
+   "source": [
+    "## 1️⃣ Install Required Packages"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "35266b5d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ All packages installed!\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sys\n",
+    "import subprocess\n",
+    "\n",
+    "# Install packages (works in VS Code Jupyter)\n",
+    "packages = [\n",
+    "    'langchain-community',\n",
+    "    'sentence-transformers',\n",
+    "    'transformers',\n",
+    "    'faiss-cpu',\n",
+    "    'pypdf',\n",
+    "    'google-generativeai',\n",
+    "    'langchain-huggingface',\n",
+    "    'langchain-text-splitters',\n",
+    "    'fastapi',\n",
+    "    'uvicorn',\n",
+    "    'nest-asyncio',\n",
+    "    'gradio',\n",
+    "    'deep-translator'\n",
+    "]\n",
+    "\n",
+    "print(\"📦 Installing required packages...\")\n",
+    "subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q'] + packages)\n",
+    "print(\"✅ All packages installed!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b09a84be",
+   "metadata": {},
+   "source": [
+    "## 2️⃣ Setup Local Directories (Windows)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "760088c8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Local directories created!\n",
+      "📁 RAG Data Location: /content/rag_data\n",
+      "📄 PDFs will be stored at: /content/rag_data/pdfs\n",
+      "🗄️ FAISS index at: /content/rag_data/faiss_index\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "\n",
+    "# Use local directories\n",
+    "RAG_DIR = os.path.join(os.getcwd(), 'rag_data')\n",
+    "FAISS_PATH = os.path.join(RAG_DIR, 'faiss_index')\n",
+    "PDFS_PATH = os.path.join(RAG_DIR, 'pdfs')\n",
+    "\n",
+    "os.makedirs(FAISS_PATH, exist_ok=True)\n",
+    "os.makedirs(PDFS_PATH, exist_ok=True)\n",
+    "\n",
+    "print(f\"✅ Local directories created!\")\n",
+    "print(f\"📁 RAG Data Location: {RAG_DIR}\")\n",
+    "print(f\"📄 PDFs will be stored at: {PDFS_PATH}\")\n",
+    "print(f\"🗄️ FAISS index at: {FAISS_PATH}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "888d519c",
+   "metadata": {},
+   "source": [
+    "## 3️⃣ Configure Gemini API Key"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "8902f9ef",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "⚠️ WARNING: Please set your Gemini API key above!\n"
+     ]
+    }
+   ],
+   "source": [
+    "import google.generativeai as genai\n",
+    "\n",
+    "# 🔑 REPLACE WITH YOUR GEMINI API KEY\n",
+    "# Get it from: https://makersuite.google.com/app/apikey\n",
+    "GOOGLE_API_KEY = \"YOUR_GEMINI_API_KEY_HERE\"\n",
+    "\n",
+    "if GOOGLE_API_KEY == \"YOUR_GEMINI_API_KEY_HERE\":\n",
+    "    print(\"⚠️ WARNING: Please set your Gemini API key above!\")\n",
+    "else:\n",
+    "    genai.configure(api_key=GOOGLE_API_KEY)\n",
+    "    print(\"✅ Gemini API configured!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5b250359",
+   "metadata": {},
+   "source": [
+    "## 4️⃣ RAG System Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "d292e154",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:torchao.kernel.intmm:Warning: Detected no triton, on systems without Triton certain kernels will not work\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "🔍 Checking for existing RAG data...\n",
+      "ℹ️ No existing vector store found\n",
+      "\n",
+      "✅ RAG System Ready!\n"
+     ]
+    }
+   ],
+   "source": [
+    "import unicodedata\n",
+    "import re\n",
+    "import shutil\n",
+    "from typing import List, Dict, Optional\n",
+    "from pathlib import Path\n",
+    "from langchain_community.document_loaders.pdf import PyPDFLoader\n",
+    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
+    "from langchain_huggingface import HuggingFaceEmbeddings\n",
+    "from langchain_community.vectorstores import FAISS\n",
+    "from deep_translator import GoogleTranslator\n",
+    "\n",
+    "# Global variables\n",
+    "vectordb = None\n",
+    "retriever = None\n",
+    "embeddings = None\n",
+    "rag_initialized = False\n",
+    "uploaded_documents = []\n",
+    "\n",
+    "\n",
+    "def initialize_embeddings():\n",
+    "    \"\"\"Initialize multilingual embedding model (supports English & Sinhala)\"\"\"\n",
+    "    global embeddings\n",
+    "    \n",
+    "    if embeddings is not None:\n",
+    "        return embeddings\n",
+    "    \n",
+    "    print(\"📥 Loading multilingual embedding model...\")\n",
+    "    embeddings = HuggingFaceEmbeddings(\n",
+    "        model_name=\"sentence-transformers/paraphrase-multilingual-mpnet-base-v2\"\n",
+    "    )\n",
+    "    print(\"✅ Embedding model loaded!\")\n",
+    "    return embeddings\n",
+    "\n",
+    "\n",
+    "def clean_text(text: str) -> str:\n",
+    "    \"\"\"Clean and normalize text for embedding\"\"\"\n",
+    "    if not isinstance(text, str) or not text.strip():\n",
+    "        return \"\"\n",
+    "    \n",
+    "    normalized_text = unicodedata.normalize('NFKC', text)\n",
+    "    cleaned_chars = [\n",
+    "        char for char in normalized_text\n",
+    "        if unicodedata.category(char) not in ['So', 'Cn', 'Cc', 'Cf', 'Cs']\n",
+    "    ]\n",
+    "    cleaned_text = \"\".join(cleaned_chars)\n",
+    "    cleaned_text = re.sub(r'\\s+', ' ', cleaned_text).strip()\n",
+    "    return cleaned_text\n",
+    "\n",
+    "\n",
+    "def load_and_process_pdf(pdf_path: str) -> List:\n",
+    "    \"\"\"Load PDF and split into chunks\"\"\"\n",
+    "    print(f\"📄 Loading PDF: {Path(pdf_path).name}\")\n",
+    "    \n",
+    "    loader = PyPDFLoader(pdf_path)\n",
+    "    docs = loader.load()\n",
+    "    \n",
+    "    splitter = RecursiveCharacterTextSplitter(\n",
+    "        chunk_size=300,\n",
+    "        chunk_overlap=80\n",
+    "    )\n",
+    "    chunks = splitter.split_documents(docs)\n",
+    "    \n",
+    "    print(f\"   ✅ {len(docs)} pages → {len(chunks)} chunks\")\n",
+    "    return chunks\n",
+    "\n",
+    "\n",
+    "def create_vector_store(chunks: List) -> bool:\n",
+    "    \"\"\"Create or update FAISS vector store\"\"\"\n",
+    "    global vectordb, retriever, rag_initialized\n",
+    "    \n",
+    "    initialize_embeddings()\n",
+    "    \n",
+    "    texts = [doc.page_content for doc in chunks]\n",
+    "    metadatas = [doc.metadata for doc in chunks]\n",
+    "    \n",
+    "    processed_texts = []\n",
+    "    processed_metadatas = []\n",
+    "    \n",
+    "    for i, text in enumerate(texts):\n",
+    "        cleaned_text = clean_text(text)\n",
+    "        if cleaned_text:\n",
+    "            processed_texts.append(cleaned_text)\n",
+    "            processed_metadatas.append(metadatas[i])\n",
+    "    \n",
+    "    if not processed_texts:\n",
+    "        print(\"⚠️ No valid texts after cleaning\")\n",
+    "        return False\n",
+    "    \n",
+    "    print(f\"🔄 Creating embeddings for {len(processed_texts)} chunks...\")\n",
+    "    \n",
+    "    if vectordb is None:\n",
+    "        vectordb = FAISS.from_texts(processed_texts, embeddings, metadatas=processed_metadatas)\n",
+    "    else:\n",
+    "        new_vectordb = FAISS.from_texts(processed_texts, embeddings, metadatas=processed_metadatas)\n",
+    "        vectordb.merge_from(new_vectordb)\n",
+    "    \n",
+    "    retriever = vectordb.as_retriever(search_kwargs={\"k\": 4})\n",
+    "    rag_initialized = True\n",
+    "    \n",
+    "    save_vector_store()\n",
+    "    return True\n",
+    "\n",
+    "\n",
+    "def save_vector_store():\n",
+    "    \"\"\"Save FAISS index to local storage\"\"\"\n",
+    "    if vectordb is None:\n",
+    "        return\n",
+    "    \n",
+    "    vectordb.save_local(FAISS_PATH)\n",
+    "    print(f\"💾 Vector store saved locally\")\n",
+    "\n",
+    "\n",
+    "def load_vector_store() -> bool:\n",
+    "    \"\"\"Load FAISS index from local storage\"\"\"\n",
+    "    global vectordb, retriever, rag_initialized, uploaded_documents\n",
+    "    \n",
+    "    index_file = os.path.join(FAISS_PATH, 'index.faiss')\n",
+    "    if not os.path.exists(index_file):\n",
+    "        print(\"ℹ️ No existing vector store found\")\n",
+    "        return False\n",
+    "    \n",
+    "    try:\n",
+    "        initialize_embeddings()\n",
+    "        vectordb = FAISS.load_local(\n",
+    "            FAISS_PATH, \n",
+    "            embeddings,\n",
+    "            allow_dangerous_deserialization=True\n",
+    "        )\n",
+    "        retriever = vectordb.as_retriever(search_kwargs={\"k\": 4})\n",
+    "        rag_initialized = True\n",
+    "        \n",
+    "        # Load document list\n",
+    "        uploaded_documents = [f for f in os.listdir(PDFS_PATH) if f.endswith('.pdf')]\n",
+    "        \n",
+    "        print(f\"✅ Loaded existing vector store\")\n",
+    "        print(f\"📚 {len(uploaded_documents)} documents found\")\n",
+    "        return True\n",
+    "    except Exception as e:\n",
+    "        print(f\"⚠️ Failed to load vector store: {e}\")\n",
+    "        return False\n",
+    "\n",
+    "\n",
+    "def translate_to_english(text: str) -> str:\n",
+    "    \"\"\"Translate any language to English\"\"\"\n",
+    "    try:\n",
+    "        translator = GoogleTranslator(source='auto', target='en')\n",
+    "        return translator.translate(text)\n",
+    "    except:\n",
+    "        return text  # Return original if translation fails\n",
+    "\n",
+    "\n",
+    "def rag_answer(question: str, relevance_threshold: float = 2.0, translate: bool = True) -> Dict:\n",
+    "    \"\"\"Answer question using RAG - check database first, fallback to Gemini\"\"\"\n",
+    "    global retriever, vectordb\n",
+    "    \n",
+    "    # Translate to English if needed\n",
+    "    original_question = question\n",
+    "    if translate:\n",
+    "        question = translate_to_english(question)\n",
+    "    \n",
+    "    result = {\n",
+    "        \"question\": original_question,\n",
+    "        \"question_english\": question,\n",
+    "        \"answer\": \"\",\n",
+    "        \"source\": \"none\",\n",
+    "        \"context_found\": False,\n",
+    "        \"relevance_score\": 0.0\n",
+    "    }\n",
+    "    \n",
+    "    if not rag_initialized or retriever is None:\n",
+    "        print(\"⚠️ RAG not initialized, using Gemini\")\n",
+    "        result[\"source\"] = \"gemini\"\n",
+    "        result[\"answer\"] = ask_gemini_directly(question)\n",
+    "        return result\n",
+    "    \n",
+    "    # Search vector database\n",
+    "    docs_with_scores = vectordb.similarity_search_with_score(question, k=4)\n",
+    "    \n",
+    "    if not docs_with_scores:\n",
+    "        print(\"⚠️ No documents found, using Gemini\")\n",
+    "        result[\"source\"] = \"gemini\"\n",
+    "        result[\"answer\"] = ask_gemini_directly(question)\n",
+    "        return result\n",
+    "    \n",
+    "    best_score = docs_with_scores[0][1]\n",
+    "    result[\"relevance_score\"] = float(best_score)\n",
+    "    \n",
+    "    # Check relevance threshold\n",
+    "    if best_score > relevance_threshold:\n",
+    "        print(f\"⚠️ Low relevance (score: {best_score:.3f}), using Gemini\")\n",
+    "        result[\"source\"] = \"gemini\"\n",
+    "        result[\"answer\"] = ask_gemini_directly(question)\n",
+    "        return result\n",
+    "    \n",
+    "    # Good relevance - use RAG\n",
+    "    print(f\"✅ Good relevance (score: {best_score:.3f}), answering from documents\")\n",
+    "    docs = [doc for doc, score in docs_with_scores]\n",
+    "    context = \"\\n\\n\".join([d.page_content for d in docs])\n",
+    "    result[\"context_found\"] = True\n",
+    "    \n",
+    "    prompt = f\"\"\"Answer the question based on the following context from PDF documents. If the context doesn't contain enough information, say \"I don't have enough information in the documents.\"\n",
+    "\n",
+    "Context:\n",
+    "{context}\n",
+    "\n",
+    "Question: {question}\n",
+    "\n",
+    "Answer:\"\"\"\n",
+    "    \n",
+    "    try:\n",
+    "        model = genai.GenerativeModel(\"models/gemini-1.5-flash\")\n",
+    "        response = model.generate_content(prompt)\n",
+    "        result[\"answer\"] = response.text\n",
+    "        result[\"source\"] = \"rag\"\n",
+    "    except Exception as e:\n",
+    "        print(f\"❌ RAG generation error: {e}\")\n",
+    "        result[\"answer\"] = f\"Error: {str(e)}\"\n",
+    "        result[\"source\"] = \"error\"\n",
+    "    \n",
+    "    return result\n",
+    "\n",
+    "\n",
+    "def ask_gemini_directly(question: str) -> str:\n",
+    "    \"\"\"Fallback: Ask Gemini directly without RAG\"\"\"\n",
+    "    try:\n",
+    "        model = genai.GenerativeModel(\"models/gemini-1.5-flash\")\n",
+    "        response = model.generate_content(f\"Answer this question: {question}\")\n",
+    "        return response.text\n",
+    "    except Exception as e:\n",
+    "        return f\"Error: {str(e)}\"\n",
+    "\n",
+    "\n",
+    "def process_uploaded_pdf(file_path: str, original_filename: str) -> str:\n",
+    "    \"\"\"Process uploaded PDF from admin panel\"\"\"\n",
+    "    try:\n",
+    "        # Copy to local storage\n",
+    "        dest_path = os.path.join(PDFS_PATH, original_filename)\n",
+    "        shutil.copy(file_path, dest_path)\n",
+    "        \n",
+    "        # Process PDF\n",
+    "        chunks = load_and_process_pdf(dest_path)\n",
+    "        \n",
+    "        if not chunks:\n",
+    "            return f\"❌ Failed to extract text from {original_filename}\"\n",
+    "        \n",
+    "        # Create/update vector store\n",
+    "        success = create_vector_store(chunks)\n",
+    "        \n",
+    "        if success:\n",
+    "            if original_filename not in uploaded_documents:\n",
+    "                uploaded_documents.append(original_filename)\n",
+    "            return f\"✅ Successfully processed '{original_filename}'\\n   📊 {len(chunks)} chunks created\\n   📚 Total documents: {len(uploaded_documents)}\"\n",
+    "        else:\n",
+    "            return f\"❌ Failed to process {original_filename}\"\n",
+    "            \n",
+    "    except Exception as e:\n",
+    "        return f\"❌ Error: {str(e)}\"\n",
+    "\n",
+    "\n",
+    "def get_status() -> Dict:\n",
+    "    \"\"\"Get RAG system status\"\"\"\n",
+    "    return {\n",
+    "        \"initialized\": rag_initialized,\n",
+    "        \"documents_count\": len(uploaded_documents),\n",
+    "        \"documents\": uploaded_documents,\n",
+    "        \"has_vector_store\": vectordb is not None,\n",
+    "        \"storage_path\": PDFS_PATH\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "# Try to load existing data\n",
+    "print(\"🔍 Checking for existing RAG data...\")\n",
+    "load_vector_store()\n",
+    "\n",
+    "print(\"\\n✅ RAG System Ready!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bee976ec",
+   "metadata": {},
+   "source": [
+    "## 5️⃣ Admin Panel - Upload PDFs Here! 📤"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "7fad545f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipython-input-3459415953.py:45: DeprecationWarning: The 'theme' parameter in the Blocks constructor will be removed in Gradio 6.0. You will need to pass 'theme' to Blocks.launch() instead.\n",
+      "  with gr.Blocks(title=\"RAG Admin Panel\", theme=gr.themes.Soft()) as admin_panel:\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "🎛️ Launching Admin Panel...\n",
+      "\n",
+      "Colab notebook detected. This cell will run indefinitely so that you can see errors and logs. To turn off, set debug=False in launch().\n",
+      "Note: opening Chrome Inspector may crash demo inside Colab notebooks.\n",
+      "* To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/javascript": "(async (port, path, width, height, cache, element) => {\n                        if (!google.colab.kernel.accessAllowed && !cache) {\n                            return;\n                        }\n                        element.appendChild(document.createTextNode(''));\n                        const url = await google.colab.kernel.proxyPort(port, {cache});\n\n                        const external_link = document.createElement('div');\n                        external_link.innerHTML = `\n                            <div style=\"font-family: monospace; margin-bottom: 0.5rem\">\n                                Running on <a href=${new URL(path, url).toString()} target=\"_blank\">\n                                    https://localhost:${port}${path}\n                                </a>\n                            </div>\n                        `;\n                        element.appendChild(external_link);\n\n                        const iframe = document.createElement('iframe');\n                        iframe.src = new URL(path, url).toString();\n                        iframe.height = height;\n                        iframe.allow = \"autoplay; camera; microphone; clipboard-read; clipboard-write;\"\n                        iframe.width = width;\n                        iframe.style.border = 0;\n                        element.appendChild(iframe);\n                    })(7860, \"/\", \"100%\", 500, false, window.element)",
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Keyboard interruption in main thread... closing server.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import gradio as gr\n",
+    "\n",
+    "def upload_pdf_handler(file):\n",
+    "    \"\"\"Handle PDF upload from Gradio interface\"\"\"\n",
+    "    if file is None:\n",
+    "        return \"⚠️ Please select a PDF file\"\n",
+    "    \n",
+    "    if not file.name.endswith('.pdf'):\n",
+    "        return \"❌ Only PDF files are allowed\"\n",
+    "    \n",
+    "    filename = os.path.basename(file.name)\n",
+    "    result = process_uploaded_pdf(file.name, filename)\n",
+    "    return result\n",
+    "\n",
+    "\n",
+    "def test_query_handler(question, threshold):\n",
+    "    \"\"\"Test RAG query from admin panel\"\"\"\n",
+    "    if not question:\n",
+    "        return \"⚠️ Please enter a question\"\n",
+    "    \n",
+    "    result = rag_answer(question, relevance_threshold=threshold)\n",
+    "    \n",
+    "    output = f\"\"\"**Question:** {result['question']}\n",
+    "**English:** {result['question_english']}\n",
+    "**Source:** {result['source'].upper()} ({result['relevance_score']:.3f})\n",
+    "\n",
+    "**Answer:**\n",
+    "{result['answer']}\n",
+    "\"\"\"\n",
+    "    return output\n",
+    "\n",
+    "\n",
+    "def get_status_handler():\n",
+    "    \"\"\"Get system status\"\"\"\n",
+    "    status = get_status()\n",
+    "    return f\"\"\"**RAG System Status:**\n",
+    "- Initialized: {status['initialized']}\n",
+    "- Documents: {status['documents_count']}\n",
+    "- Files: {', '.join(status['documents']) if status['documents'] else 'None'}\n",
+    "- Storage: {status['storage_path']}\n",
+    "\"\"\"\n",
+    "\n",
+    "\n",
+    "# Create Gradio Interface\n",
+    "with gr.Blocks(title=\"RAG Admin Panel\", theme=gr.themes.Soft()) as admin_panel:\n",
+    "    gr.Markdown(\n",
+    "        \"\"\"\n",
+    "        # 🎛️ RAG Admin Panel\n",
+    "        ### Upload PDFs and manage your RAG database\n",
+    "        \"\"\"\n",
+    "    )\n",
+    "    \n",
+    "    with gr.Tab(\"📤 Upload PDFs\"):\n",
+    "        gr.Markdown(\"### Upload PDF Documents\")\n",
+    "        with gr.Row():\n",
+    "            with gr.Column():\n",
+    "                pdf_input = gr.File(\n",
+    "                    label=\"Select PDF File\",\n",
+    "                    file_types=[\".pdf\"],\n",
+    "                    type=\"filepath\"\n",
+    "                )\n",
+    "                upload_btn = gr.Button(\"📤 Upload & Process\", variant=\"primary\")\n",
+    "            with gr.Column():\n",
+    "                upload_output = gr.Textbox(\n",
+    "                    label=\"Upload Status\",\n",
+    "                    lines=5,\n",
+    "                    interactive=False\n",
+    "                )\n",
+    "        \n",
+    "        upload_btn.click(\n",
+    "            fn=upload_pdf_handler,\n",
+    "            inputs=pdf_input,\n",
+    "            outputs=upload_output\n",
+    "        )\n",
+    "    \n",
+    "    with gr.Tab(\"🧪 Test Queries\"):\n",
+    "        gr.Markdown(\"### Test your RAG system\")\n",
+    "        with gr.Row():\n",
+    "            with gr.Column():\n",
+    "                question_input = gr.Textbox(\n",
+    "                    label=\"Question (English or Sinhala)\",\n",
+    "                    placeholder=\"What is a wired network?\",\n",
+    "                    lines=2\n",
+    "                )\n",
+    "                threshold_slider = gr.Slider(\n",
+    "                    minimum=0.5,\n",
+    "                    maximum=3.0,\n",
+    "                    value=2.0,\n",
+    "                    step=0.1,\n",
+    "                    label=\"Relevance Threshold (lower = stricter)\"\n",
+    "                )\n",
+    "                query_btn = gr.Button(\"🔍 Ask Question\", variant=\"primary\")\n",
+    "            with gr.Column():\n",
+    "                query_output = gr.Markdown(label=\"Answer\")\n",
+    "        \n",
+    "        query_btn.click(\n",
+    "            fn=test_query_handler,\n",
+    "            inputs=[question_input, threshold_slider],\n",
+    "            outputs=query_output\n",
+    "        )\n",
+    "    \n",
+    "    with gr.Tab(\"📊 Status\"):\n",
+    "        gr.Markdown(\"### System Status\")\n",
+    "        status_output = gr.Markdown()\n",
+    "        status_btn = gr.Button(\"🔄 Refresh Status\")\n",
+    "        \n",
+    "        status_btn.click(\n",
+    "            fn=get_status_handler,\n",
+    "            outputs=status_output\n",
+    "        )\n",
+    "        \n",
+    "        # Auto-load status on startup\n",
+    "        admin_panel.load(fn=get_status_handler, outputs=status_output)\n",
+    "\n",
+    "# Launch admin panel\n",
+    "print(\"\\n🎛️ Launching Admin Panel...\\n\")\n",
+    "admin_panel.launch(share=False, server_name=\"127.0.0.1\", server_port=7860, debug=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3b658bf7",
+   "metadata": {},
+   "source": [
+    "## 6️⃣ Public API - Query from Anywhere! 🌐\n",
+    "*Note: This will run on port 8000, make sure Gradio admin panel is already running on port 7860*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5fd82e6d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from fastapi import FastAPI, HTTPException, UploadFile, File\n",
+    "from pydantic import BaseModel\n",
+    "import nest_asyncio\n",
+    "import uvicorn\n",
+    "import threading\n",
+    "import tempfile\n",
+    "\n",
+    "# Allow nested event loops\n",
+    "nest_asyncio.apply()\n",
+    "\n",
+    "# Create FastAPI app\n",
+    "app = FastAPI(\n",
+    "    title=\"RAG API\",\n",
+    "    description=\"Query RAG database or upload PDFs via API\",\n",
+    "    version=\"1.0\"\n",
+    ")\n",
+    "\n",
+    "class QuestionRequest(BaseModel):\n",
+    "    question: str\n",
+    "    threshold: float = 2.0\n",
+    "    translate: bool = True\n",
+    "\n",
+    "class AnswerResponse(BaseModel):\n",
+    "    question: str\n",
+    "    question_english: str\n",
+    "    answer: str\n",
+    "    source: str\n",
+    "    relevance_score: float\n",
+    "    context_found: bool\n",
+    "\n",
+    "\n",
+    "@app.get(\"/\")\n",
+    "async def root():\n",
+    "    return {\n",
+    "        \"message\": \"🚀 RAG API is running!\",\n",
+    "        \"endpoints\": {\n",
+    "            \"POST /ask\": \"Ask a question to RAG system\",\n",
+    "            \"POST /upload\": \"Upload a PDF file\",\n",
+    "            \"GET /status\": \"Check system status\",\n",
+    "            \"GET /documents\": \"List uploaded documents\"\n",
+    "        }\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "@app.post(\"/ask\", response_model=AnswerResponse)\n",
+    "async def ask_question(request: QuestionRequest):\n",
+    "    \"\"\"Ask a question to RAG system\"\"\"\n",
+    "    if not request.question:\n",
+    "        raise HTTPException(status_code=400, detail=\"Question is required\")\n",
+    "    \n",
+    "    result = rag_answer(\n",
+    "        request.question,\n",
+    "        relevance_threshold=request.threshold,\n",
+    "        translate=request.translate\n",
+    "    )\n",
+    "    \n",
+    "    return AnswerResponse(\n",
+    "        question=result[\"question\"],\n",
+    "        question_english=result[\"question_english\"],\n",
+    "        answer=result[\"answer\"],\n",
+    "        source=result[\"source\"],\n",
+    "        relevance_score=result[\"relevance_score\"],\n",
+    "        context_found=result[\"context_found\"]\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "@app.post(\"/upload\")\n",
+    "async def upload_pdf_api(file: UploadFile = File(...)):\n",
+    "    \"\"\"Upload a PDF via API\"\"\"\n",
+    "    if not file.filename.endswith('.pdf'):\n",
+    "        raise HTTPException(status_code=400, detail=\"Only PDF files allowed\")\n",
+    "    \n",
+    "    try:\n",
+    "        # Save temporarily\n",
+    "        with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as temp_file:\n",
+    "            content = await file.read()\n",
+    "            temp_file.write(content)\n",
+    "            temp_path = temp_file.name\n",
+    "        \n",
+    "        # Process\n",
+    "        result = process_uploaded_pdf(temp_path, file.filename)\n",
+    "        \n",
+    "        # Clean up temp file\n",
+    "        try:\n",
+    "            os.unlink(temp_path)\n",
+    "        except:\n",
+    "            pass\n",
+    "        \n",
+    "        return {\n",
+    "            \"success\": \"✅\" in result,\n",
+    "            \"message\": result,\n",
+    "            \"filename\": file.filename\n",
+    "        }\n",
+    "    except Exception as e:\n",
+    "        raise HTTPException(status_code=500, detail=str(e))\n",
+    "\n",
+    "\n",
+    "@app.get(\"/status\")\n",
+    "async def api_status():\n",
+    "    \"\"\"Get RAG system status\"\"\"\n",
+    "    return get_status()\n",
+    "\n",
+    "\n",
+    "@app.get(\"/documents\")\n",
+    "async def list_documents():\n",
+    "    \"\"\"List all uploaded documents\"\"\"\n",
+    "    return {\n",
+    "        \"count\": len(uploaded_documents),\n",
+    "        \"documents\": uploaded_documents\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "def run_server():\n",
+    "    \"\"\"Run the FastAPI server in a thread\"\"\"\n",
+    "    uvicorn.run(app, host=\"127.0.0.1\", port=8000, log_level=\"info\")\n",
+    "\n",
+    "\n",
+    "# Start server in background thread\n",
+    "server_thread = threading.Thread(target=run_server, daemon=True)\n",
+    "server_thread.start()\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*70)\n",
+    "print(\"🌐 LOCAL API SERVER STARTED!\")\n",
+    "print(\"=\"*70)\n",
+    "print(\"\\n📌 API Endpoints:\")\n",
+    "print(\"   POST http://localhost:8000/ask       - Ask a question\")\n",
+    "print(\"   POST http://localhost:8000/upload    - Upload PDF\")\n",
+    "print(\"   GET  http://localhost:8000/status    - System status\")\n",
+    "print(\"   GET  http://localhost:8000/documents - List documents\")\n",
+    "print(\"   GET  http://localhost:8000/docs      - API documentation\")\n",
+    "print(\"\\n💡 Example curl command:\")\n",
+    "print('   curl -X POST \"http://localhost:8000/ask\" ^')\n",
+    "print('        -H \"Content-Type: application/json\" ^')\n",
+    "print('        -d \"{\\\\\"question\\\\\": \\\\\"What is a network?\\\\\", \\\\\"threshold\\\\\": 2.0}\"')\n",
+    "print(\"\\n🔄 API Server is running in background...\")\n",
+    "print(\"   (Server will stop when notebook kernel is restarted)\\n\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a8c7b576",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## 🎉 You're Done! Here's What You Have:\n",
+    "\n",
+    "### ✅ Admin Panel (Cell 5)\n",
+    "- Drag & drop PDF upload interface\n",
+    "- Test queries in real-time\n",
+    "- View system status\n",
+    "- **Access at:** http://localhost:7860\n",
+    "\n",
+    "### ✅ Public API (Cell 6)\n",
+    "- RESTful API endpoints\n",
+    "- Query from any app/website\n",
+    "- Upload PDFs programmatically\n",
+    "- **Access at:** http://localhost:8000\n",
+    "- **API Docs:** http://localhost:8000/docs\n",
+    "\n",
+    "### ✅ Local Storage\n",
+    "- All data saved to `rag_data/` folder in your project\n",
+    "- Survives notebook restarts\n",
+    "- Easy to backup\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## 🔥 Integration Examples:\n",
+    "\n",
+    "### Python:\n",
+    "```python\n",
+    "import requests\n",
+    "\n",
+    "url = \"http://localhost:8000/ask\"\n",
+    "response = requests.post(url, json={\n",
+    "    \"question\": \"What is a wired network?\",\n",
+    "    \"threshold\": 2.0\n",
+    "})\n",
+    "print(response.json()['answer'])\n",
+    "```\n",
+    "\n",
+    "### JavaScript:\n",
+    "```javascript\n",
+    "fetch('http://localhost:8000/ask', {\n",
+    "  method: 'POST',\n",
+    "  headers: { 'Content-Type': 'application/json' },\n",
+    "  body: JSON.stringify({ \n",
+    "    question: 'What is a network?',\n",
+    "    threshold: 2.0 \n",
+    "  })\n",
+    "})\n",
+    ".then(r => r.json())\n",
+    ".then(data => console.log(data.answer));\n",
+    "```\n",
+    "\n",
+    "### Your Chatbot:\n",
+    "Update your chatbot to call `http://localhost:8000/ask` instead of the old endpoint!\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## 📝 Usage Instructions:\n",
+    "\n",
+    "1. **Run Cells 1-4** to setup (one time)\n",
+    "2. **Run Cell 5** to start Admin Panel at http://localhost:7860\n",
+    "3. **Upload PDFs** via the Admin Panel\n",
+    "4. **Run Cell 6** to start API Server at http://localhost:8000\n",
+    "5. **Test queries** via Admin Panel or API\n",
+    "\n",
+    "## 🛠️ Troubleshooting:\n",
+    "\n",
+    "- **Port already in use?** Change `server_port=7860` or `port=8000` to different numbers\n",
+    "- **Can't access?** Make sure Windows Firewall allows local connections\n",
+    "- **Need to access from other devices?** Change `127.0.0.1` to `0.0.0.0` (security risk!)\n",
+    "\n",
+    "## 🚀 Next Steps:\n",
+    "\n",
+    "- Upload PDFs via Admin Panel (drag & drop)\n",
+    "- Test queries in Admin Panel\n",
+    "- Integrate API with your chatbot app\n",
+    "- Adjust relevance threshold as needed\n",
+    "\n",
+    "**Need help?** Re-run any cell to restart that component!"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

colab_rag_api.ipynb

@@ -0,0 +1,792 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "fdfc1b2a",
+   "metadata": {},
+   "source": [
+    "## 1. Install Required Packages"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "e0f621d9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "📦 Installing required packages...\n",
+      "✅ All packages installed!\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sys\n",
+    "import subprocess\n",
+    "\n",
+    "# Install packages (works in VS Code Jupyter)\n",
+    "packages = [\n",
+    "    'langchain-community',\n",
+    "    'sentence-transformers',\n",
+    "    'transformers',\n",
+    "    'faiss-cpu',\n",
+    "    'pypdf',\n",
+    "    'google-generativeai',\n",
+    "    'langchain-huggingface',\n",
+    "    'langchain-text-splitters',\n",
+    "    'fastapi',\n",
+    "    'uvicorn',\n",
+    "    'nest-asyncio'\n",
+    "]\n",
+    "\n",
+    "print(\"📦 Installing required packages...\")\n",
+    "subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q'] + packages)\n",
+    "print(\"✅ All packages installed!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6c5a12c2",
+   "metadata": {},
+   "source": [
+    "## 2. Setup Local Directories (Windows)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "fbe27891",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Local directories created!\n",
+      "📁 RAG data will be stored at: /content/rag_data\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "\n",
+    "# Use local directories instead of Google Drive\n",
+    "RAG_DIR = os.path.join(os.getcwd(), 'rag_data')\n",
+    "FAISS_PATH = os.path.join(RAG_DIR, 'faiss_index')\n",
+    "PDFS_PATH = os.path.join(RAG_DIR, 'pdfs')\n",
+    "\n",
+    "os.makedirs(FAISS_PATH, exist_ok=True)\n",
+    "os.makedirs(PDFS_PATH, exist_ok=True)\n",
+    "\n",
+    "print(f\"✅ Local directories created!\")\n",
+    "print(f\"📁 RAG data will be stored at: {RAG_DIR}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b75dabae",
+   "metadata": {},
+   "source": [
+    "## 3. Configure Gemini API Key"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "330b1f65",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Gemini API configured!\n"
+     ]
+    }
+   ],
+   "source": [
+    "import google.generativeai as genai\n",
+    "\n",
+    "# Replace with your API key\n",
+    "GOOGLE_API_KEY = \"AIzaSyC7tkb3uFgmh8YSuOVHYgIDywyL2lzICBA\"  # Get from https://makersuite.google.com/app/apikey\n",
+    "\n",
+    "genai.configure(api_key=GOOGLE_API_KEY)\n",
+    "print(\"✅ Gemini API configured!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "49f2b49c",
+   "metadata": {},
+   "source": [
+    "## 4. RAG Functions - Load, Process, Query"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "c296fc8b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ RAG functions defined!\n"
+     ]
+    }
+   ],
+   "source": [
+    "import unicodedata\n",
+    "import re\n",
+    "from typing import List, Dict\n",
+    "from langchain_community.document_loaders.pdf import PyPDFLoader\n",
+    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
+    "from langchain_huggingface import HuggingFaceEmbeddings\n",
+    "from langchain_community.vectorstores import FAISS\n",
+    "\n",
+    "# Global variables\n",
+    "vectordb = None\n",
+    "retriever = None\n",
+    "embeddings = None\n",
+    "rag_initialized = False\n",
+    "uploaded_documents = []\n",
+    "\n",
+    "\n",
+    "def initialize_embeddings():\n",
+    "    \"\"\"Initialize multilingual embedding model\"\"\"\n",
+    "    global embeddings\n",
+    "    \n",
+    "    if embeddings is not None:\n",
+    "        return embeddings\n",
+    "    \n",
+    "    print(\"Loading multilingual embedding model...\")\n",
+    "    embeddings = HuggingFaceEmbeddings(\n",
+    "        model_name=\"sentence-transformers/paraphrase-multilingual-mpnet-base-v2\"\n",
+    "    )\n",
+    "    print(\"✅ Embedding model loaded!\")\n",
+    "    return embeddings\n",
+    "\n",
+    "\n",
+    "def clean_text(text: str) -> str:\n",
+    "    \"\"\"Clean and normalize text\"\"\"\n",
+    "    if not isinstance(text, str) or not text.strip():\n",
+    "        return \"\"\n",
+    "    \n",
+    "    normalized_text = unicodedata.normalize('NFKC', text)\n",
+    "    cleaned_chars = [\n",
+    "        char for char in normalized_text\n",
+    "        if unicodedata.category(char) not in ['So', 'Cn', 'Cc', 'Cf', 'Cs']\n",
+    "    ]\n",
+    "    cleaned_text = \"\".join(cleaned_chars)\n",
+    "    cleaned_text = re.sub(r'\\s+', ' ', cleaned_text).strip()\n",
+    "    return cleaned_text\n",
+    "\n",
+    "\n",
+    "def load_and_process_pdf(pdf_path: str) -> List:\n",
+    "    \"\"\"Load PDF and split into chunks\"\"\"\n",
+    "    print(f\"Loading PDF: {pdf_path}\")\n",
+    "    \n",
+    "    loader = PyPDFLoader(pdf_path)\n",
+    "    docs = loader.load()\n",
+    "    \n",
+    "    splitter = RecursiveCharacterTextSplitter(\n",
+    "        chunk_size=300,\n",
+    "        chunk_overlap=80\n",
+    "    )\n",
+    "    chunks = splitter.split_documents(docs)\n",
+    "    \n",
+    "    print(f\"✅ Loaded {len(docs)} pages, created {len(chunks)} chunks\")\n",
+    "    return chunks\n",
+    "\n",
+    "\n",
+    "def create_vector_store(chunks: List) -> bool:\n",
+    "    \"\"\"Create or update FAISS vector store\"\"\"\n",
+    "    global vectordb, retriever, rag_initialized\n",
+    "    \n",
+    "    initialize_embeddings()\n",
+    "    \n",
+    "    texts = [doc.page_content for doc in chunks]\n",
+    "    metadatas = [doc.metadata for doc in chunks]\n",
+    "    \n",
+    "    processed_texts = []\n",
+    "    processed_metadatas = []\n",
+    "    \n",
+    "    for i, text in enumerate(texts):\n",
+    "        cleaned_text = clean_text(text)\n",
+    "        if cleaned_text:\n",
+    "            processed_texts.append(cleaned_text)\n",
+    "            processed_metadatas.append(metadatas[i])\n",
+    "    \n",
+    "    if not processed_texts:\n",
+    "        print(\"⚠ No valid texts after cleaning\")\n",
+    "        return False\n",
+    "    \n",
+    "    print(f\"Creating embeddings for {len(processed_texts)} chunks...\")\n",
+    "    \n",
+    "    if vectordb is None:\n",
+    "        vectordb = FAISS.from_texts(processed_texts, embeddings, metadatas=processed_metadatas)\n",
+    "    else:\n",
+    "        new_vectordb = FAISS.from_texts(processed_texts, embeddings, metadatas=processed_metadatas)\n",
+    "        vectordb.merge_from(new_vectordb)\n",
+    "    \n",
+    "    retriever = vectordb.as_retriever(search_kwargs={\"k\": 4})\n",
+    "    rag_initialized = True\n",
+    "    \n",
+    "    # Save to Google Drive\n",
+    "    save_vector_store()\n",
+    "    \n",
+    "    print(\"✅ Vector store created/updated!\")\n",
+    "    return True\n",
+    "\n",
+    "\n",
+    "def save_vector_store():\n",
+    "    \"\"\"Save FAISS index to Google Drive\"\"\"\n",
+    "    if vectordb is None:\n",
+    "        return\n",
+    "    \n",
+    "    vectordb.save_local(FAISS_PATH)\n",
+    "    print(f\"✅ Vector store saved to Google Drive: {FAISS_PATH}\")\n",
+    "\n",
+    "\n",
+    "def load_vector_store() -> bool:\n",
+    "    \"\"\"Load FAISS index from Google Drive\"\"\"\n",
+    "    global vectordb, retriever, rag_initialized\n",
+    "    \n",
+    "    if not os.path.exists(FAISS_PATH):\n",
+    "        print(\"ℹ No existing vector store found\")\n",
+    "        return False\n",
+    "    \n",
+    "    try:\n",
+    "        initialize_embeddings()\n",
+    "        vectordb = FAISS.load_local(\n",
+    "            FAISS_PATH, \n",
+    "            embeddings,\n",
+    "            allow_dangerous_deserialization=True\n",
+    "        )\n",
+    "        retriever = vectordb.as_retriever(search_kwargs={\"k\": 4})\n",
+    "        rag_initialized = True\n",
+    "        print(\"✅ Loaded existing vector store from Google Drive\")\n",
+    "        return True\n",
+    "    except Exception as e:\n",
+    "        print(f\"⚠ Failed to load vector store: {e}\")\n",
+    "        return False\n",
+    "\n",
+    "\n",
+    "def rag_answer(question: str, relevance_threshold: float = 1.5) -> Dict:\n",
+    "    \"\"\"Answer question using RAG - check database first, fallback to Gemini\"\"\"\n",
+    "    global retriever, vectordb\n",
+    "    \n",
+    "    result = {\n",
+    "        \"answer\": \"\",\n",
+    "        \"source\": \"none\",\n",
+    "        \"context_found\": False,\n",
+    "        \"relevance_score\": 0.0\n",
+    "    }\n",
+    "    \n",
+    "    if not rag_initialized or retriever is None:\n",
+    "        result[\"source\"] = \"gemini\"\n",
+    "        result[\"answer\"] = ask_gemini_directly(question)\n",
+    "        return result\n",
+    "    \n",
+    "    # Search vector database\n",
+    "    docs_with_scores = vectordb.similarity_search_with_score(question, k=4)\n",
+    "    \n",
+    "    if not docs_with_scores:\n",
+    "        result[\"source\"] = \"gemini\"\n",
+    "        result[\"answer\"] = ask_gemini_directly(question)\n",
+    "        return result\n",
+    "    \n",
+    "    best_score = docs_with_scores[0][1]\n",
+    "    result[\"relevance_score\"] = float(best_score)\n",
+    "    \n",
+    "    # Check relevance threshold\n",
+    "    if best_score > relevance_threshold:\n",
+    "        print(f\"⚠ Low relevance (score: {best_score:.3f}), using Gemini\")\n",
+    "        result[\"source\"] = \"gemini\"\n",
+    "        result[\"answer\"] = ask_gemini_directly(question)\n",
+    "        return result\n",
+    "    \n",
+    "    # Good relevance - use RAG\n",
+    "    print(f\"✅ Good relevance (score: {best_score:.3f}), answering from documents\")\n",
+    "    docs = [doc for doc, score in docs_with_scores]\n",
+    "    context = \"\\n\\n\".join([d.page_content for d in docs])\n",
+    "    result[\"context_found\"] = True\n",
+    "    \n",
+    "    prompt = f\"\"\"Answer the question based ONLY on the following context from the PDF documents. If the context doesn't contain enough information, say \"I don't have enough information in the documents to answer this.\"\n",
+    "\n",
+    "Context from PDFs:\n",
+    "{context}\n",
+    "\n",
+    "Question: {question}\n",
+    "\n",
+    "Answer:\"\"\"\n",
+    "    \n",
+    "    try:\n",
+    "        model = genai.GenerativeModel(\"models/gemini-1.5-flash\")\n",
+    "        response = model.generate_content(prompt)\n",
+    "        result[\"answer\"] = response.text\n",
+    "        result[\"source\"] = \"rag\"\n",
+    "    except Exception as e:\n",
+    "        print(f\"❌ RAG generation error: {e}\")\n",
+    "        result[\"answer\"] = f\"Error: {str(e)}\"\n",
+    "        result[\"source\"] = \"error\"\n",
+    "    \n",
+    "    return result\n",
+    "\n",
+    "\n",
+    "def ask_gemini_directly(question: str) -> str:\n",
+    "    \"\"\"Fallback: Ask Gemini directly\"\"\"\n",
+    "    try:\n",
+    "        model = genai.GenerativeModel(\"models/gemini-1.5-flash\")\n",
+    "        response = model.generate_content(f\"Answer this question: {question}\")\n",
+    "        return response.text\n",
+    "    except Exception as e:\n",
+    "        return f\"Error: {str(e)}\"\n",
+    "\n",
+    "\n",
+    "print(\"✅ RAG functions defined!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b98c801",
+   "metadata": {},
+   "source": [
+    "## 5. Load PDFs from Local Directory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "6aecdbe9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading multilingual embedding model...\n",
+      "✅ Embedding model loaded!\n",
+      "⚠ Failed to load vector store: Error in faiss::FileIOReader::FileIOReader(const char*) at /project/third-party/faiss/faiss/impl/io.cpp:69: Error: 'f' failed: could not open /content/rag_data/faiss_index/index.faiss for reading: No such file or directory\n",
+      "📁 Place your PDF files in: /content/rag_data/pdfs\n",
+      "   Current directory: /content\n",
+      "\n",
+      "⚠️ No PDF files found!\n",
+      "   Please add PDF files to: /content/rag_data/pdfs\n"
+     ]
+    }
+   ],
+   "source": [
+    "import glob\n",
+    "\n",
+    "# Try to load existing vector store first\n",
+    "load_vector_store()\n",
+    "\n",
+    "# Option 1: Manually place PDFs in the rag_data/pdfs folder, then run this\n",
+    "print(f\"📁 Place your PDF files in: {PDFS_PATH}\")\n",
+    "print(f\"   Current directory: {os.getcwd()}\")\n",
+    "\n",
+    "# Find all PDFs in the pdfs folder\n",
+    "pdf_files = glob.glob(os.path.join(PDFS_PATH, \"*.pdf\"))\n",
+    "\n",
+    "if not pdf_files:\n",
+    "    print(\"\\n⚠️ No PDF files found!\")\n",
+    "    print(f\"   Please add PDF files to: {PDFS_PATH}\")\n",
+    "else:\n",
+    "    print(f\"\\n📚 Found {len(pdf_files)} PDF file(s):\")\n",
+    "    \n",
+    "    # Process each PDF\n",
+    "    for pdf_path in pdf_files:\n",
+    "        filename = os.path.basename(pdf_path)\n",
+    "        print(f\"\\n   Processing: {filename}\")\n",
+    "        \n",
+    "        # Skip if already processed\n",
+    "        if filename in uploaded_documents:\n",
+    "            print(f\"   ⏭️ Already processed, skipping...\")\n",
+    "            continue\n",
+    "        \n",
+    "        # Process PDF\n",
+    "        chunks = load_and_process_pdf(pdf_path)\n",
+    "        create_vector_store(chunks)\n",
+    "        uploaded_documents.append(filename)\n",
+    "    \n",
+    "    print(f\"\\n✅ Processed {len(uploaded_documents)} PDF(s) total\")\n",
+    "    print(f\"📚 Documents in database: {uploaded_documents}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ff67dfb7",
+   "metadata": {},
+   "source": [
+    "## 6. Test RAG Query (Simple)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "86dc46cd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "❓ Question: What is a wired network?\n",
+      "\n"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+      "\u001b[0;32m/tmp/ipython-input-1251978023.py\u001b[0m in \u001b[0;36m<cell line: 0>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"❓ Question: {test_question}\\n\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrag_answer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_question\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrelevance_threshold\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m2.0\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# Increased threshold\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"📊 Source: {result['source'].upper()}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/tmp/ipython-input-2893062687.py\u001b[0m in \u001b[0;36mrag_answer\u001b[0;34m(question, relevance_threshold)\u001b[0m\n\u001b[1;32m    148\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mrag_initialized\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mretriever\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    149\u001b[0m         \u001b[0mresult\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"source\"\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"gemini\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 150\u001b[0;31m         \u001b[0mresult\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"answer\"\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mask_gemini_directly\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mquestion\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    151\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    152\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/tmp/ipython-input-2893062687.py\u001b[0m in \u001b[0;36mask_gemini_directly\u001b[0;34m(question)\u001b[0m\n\u001b[1;32m    201\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    202\u001b[0m         \u001b[0mmodel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgenai\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGenerativeModel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"models/gemini-1.5-flash\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 203\u001b[0;31m         \u001b[0mresponse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerate_content\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Answer this question: {question}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    204\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mresponse\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    205\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/google/generativeai/generative_models.py\u001b[0m in \u001b[0;36mgenerate_content\u001b[0;34m(self, contents, generation_config, safety_settings, stream, tools, tool_config, request_options)\u001b[0m\n\u001b[1;32m    329\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0mgeneration_types\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGenerateContentResponse\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_iterator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    330\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 331\u001b[0;31m                 response = self._client.generate_content(\n\u001b[0m\u001b[1;32m    332\u001b[0m                     \u001b[0mrequest\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    333\u001b[0m                     \u001b[0;34m**\u001b[0m\u001b[0mrequest_options\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/google/ai/generativelanguage_v1beta/services/generative_service/client.py\u001b[0m in \u001b[0;36mgenerate_content\u001b[0;34m(self, request, model, contents, retry, timeout, metadata)\u001b[0m\n\u001b[1;32m    833\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    834\u001b[0m         \u001b[0;31m# Send the request.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 835\u001b[0;31m         response = rpc(\n\u001b[0m\u001b[1;32m    836\u001b[0m             \u001b[0mrequest\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    837\u001b[0m             \u001b[0mretry\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mretry\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/google/api_core/gapic_v1/method.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, timeout, retry, compression, *args, **kwargs)\u001b[0m\n\u001b[1;32m    129\u001b[0m             \u001b[0mkwargs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"compression\"\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcompression\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    130\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 131\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mwrapped_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    132\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    133\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/google/api_core/retry/retry_unary.py\u001b[0m in \u001b[0;36mretry_wrapped_func\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    292\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_initial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_maximum\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmultiplier\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_multiplier\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    293\u001b[0m             )\n\u001b[0;32m--> 294\u001b[0;31m             return retry_target(\n\u001b[0m\u001b[1;32m    295\u001b[0m                 \u001b[0mtarget\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    296\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_predicate\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/google/api_core/retry/retry_unary.py\u001b[0m in \u001b[0;36mretry_target\u001b[0;34m(target, predicate, sleep_generator, timeout, on_error, exception_factory, **kwargs)\u001b[0m\n\u001b[1;32m    145\u001b[0m     \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    146\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 147\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    148\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0minspect\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misawaitable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    149\u001b[0m                 \u001b[0mwarnings\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwarn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_ASYNC_RETRY_WARNING\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/google/api_core/timeout.py\u001b[0m in \u001b[0;36mfunc_with_timeout\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    128\u001b[0m                 \u001b[0mkwargs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"timeout\"\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mremaining_timeout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    129\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 130\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    131\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    132\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mfunc_with_timeout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/google/api_core/grpc_helpers.py\u001b[0m in \u001b[0;36merror_remapped_callable\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     73\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0merror_remapped_callable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     74\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 75\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mcallable_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     76\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mgrpc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRpcError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mexc\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     77\u001b[0m             \u001b[0;32mraise\u001b[0m \u001b[0mexceptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_grpc_error\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexc\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mexc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/google/ai/generativelanguage_v1beta/services/generative_service/transports/rest.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, request, retry, timeout, metadata)\u001b[0m\n\u001b[1;32m   1146\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1147\u001b[0m             \u001b[0;31m# Send the request\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1148\u001b[0;31m             response = GenerativeServiceRestTransport._GenerateContent._get_response(\n\u001b[0m\u001b[1;32m   1149\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_host\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1150\u001b[0m                 \u001b[0mmetadata\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/google/ai/generativelanguage_v1beta/services/generative_service/transports/rest.py\u001b[0m in \u001b[0;36m_get_response\u001b[0;34m(host, metadata, query_params, session, timeout, transcoded_request, body)\u001b[0m\n\u001b[1;32m   1046\u001b[0m             \u001b[0mheaders\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmetadata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1047\u001b[0m             \u001b[0mheaders\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"Content-Type\"\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"application/json\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1048\u001b[0;31m             response = getattr(session, method)(\n\u001b[0m\u001b[1;32m   1049\u001b[0m                 \u001b[0;34m\"{host}{uri}\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhost\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mhost\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muri\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0muri\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1050\u001b[0m                 \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/requests/sessions.py\u001b[0m in \u001b[0;36mpost\u001b[0;34m(self, url, data, json, **kwargs)\u001b[0m\n\u001b[1;32m    635\u001b[0m         \"\"\"\n\u001b[1;32m    636\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 637\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrequest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"POST\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0murl\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjson\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjson\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    638\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    639\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0murl\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/google/auth/transport/requests.py\u001b[0m in \u001b[0;36mrequest\u001b[0;34m(self, method, url, data, headers, max_allowed_time, timeout, **kwargs)\u001b[0m\n\u001b[1;32m    533\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0mTimeoutGuard\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mremaining_time\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mguard\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    534\u001b[0m             \u001b[0m_helpers\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrequest_log\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_LOGGER\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0murl\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mheaders\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 535\u001b[0;31m             response = super(AuthorizedSession, self).request(\n\u001b[0m\u001b[1;32m    536\u001b[0m                 \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    537\u001b[0m                 \u001b[0murl\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/requests/sessions.py\u001b[0m in \u001b[0;36mrequest\u001b[0;34m(self, method, url, params, data, headers, cookies, files, auth, timeout, allow_redirects, proxies, hooks, stream, verify, cert, json)\u001b[0m\n\u001b[1;32m    587\u001b[0m         }\n\u001b[1;32m    588\u001b[0m         \u001b[0msend_kwargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msettings\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 589\u001b[0;31m         \u001b[0mresp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprep\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0msend_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    590\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    591\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mresp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/requests/sessions.py\u001b[0m in \u001b[0;36msend\u001b[0;34m(self, request, **kwargs)\u001b[0m\n\u001b[1;32m    701\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    702\u001b[0m         \u001b[0;31m# Send the request\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 703\u001b[0;31m         \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0madapter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrequest\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    704\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    705\u001b[0m         \u001b[0;31m# Total elapsed time of the request (approximately)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/requests/adapters.py\u001b[0m in \u001b[0;36msend\u001b[0;34m(self, request, stream, timeout, verify, cert, proxies)\u001b[0m\n\u001b[1;32m    642\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    643\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 644\u001b[0;31m             resp = conn.urlopen(\n\u001b[0m\u001b[1;32m    645\u001b[0m                 \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrequest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    646\u001b[0m                 \u001b[0murl\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0murl\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/urllib3/connectionpool.py\u001b[0m in \u001b[0;36murlopen\u001b[0;34m(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, preload_content, decode_content, **response_kw)\u001b[0m\n\u001b[1;32m    785\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    786\u001b[0m             \u001b[0;31m# Make the request on the HTTPConnection object\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 787\u001b[0;31m             response = self._make_request(\n\u001b[0m\u001b[1;32m    788\u001b[0m                 \u001b[0mconn\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    789\u001b[0m                 \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/urllib3/connectionpool.py\u001b[0m in \u001b[0;36m_make_request\u001b[0;34m(self, conn, method, url, body, headers, retries, timeout, chunked, response_conn, preload_content, decode_content, enforce_content_length)\u001b[0m\n\u001b[1;32m    532\u001b[0m         \u001b[0;31m# Receive the response from the server\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    533\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 534\u001b[0;31m             \u001b[0mresponse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetresponse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    535\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mBaseSSLError\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mOSError\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    536\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_raise_timeout\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0merr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0murl\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0murl\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout_value\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mread_timeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/urllib3/connection.py\u001b[0m in \u001b[0;36mgetresponse\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    563\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    564\u001b[0m         \u001b[0;31m# Get the response from http.client.HTTPConnection\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 565\u001b[0;31m         \u001b[0mhttplib_response\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetresponse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    566\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    567\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/lib/python3.12/http/client.py\u001b[0m in \u001b[0;36mgetresponse\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1428\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1429\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1430\u001b[0;31m                 \u001b[0mresponse\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbegin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1431\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mConnectionError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1432\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/lib/python3.12/http/client.py\u001b[0m in \u001b[0;36mbegin\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    329\u001b[0m         \u001b[0;31m# read until we get a non-100 response\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    330\u001b[0m         \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 331\u001b[0;31m             \u001b[0mversion\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstatus\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreason\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_read_status\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    332\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mstatus\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mCONTINUE\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    333\u001b[0m                 \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/lib/python3.12/http/client.py\u001b[0m in \u001b[0;36m_read_status\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    290\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    291\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_read_status\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 292\u001b[0;31m         \u001b[0mline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreadline\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_MAXLINE\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"iso-8859-1\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    293\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mline\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0m_MAXLINE\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    294\u001b[0m             \u001b[0;32mraise\u001b[0m \u001b[0mLineTooLong\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"status line\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/usr/lib/python3.12/socket.py\u001b[0m in \u001b[0;36mreadinto\u001b[0;34m(self, b)\u001b[0m\n\u001b[1;32m    718\u001b[0m         \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    719\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 720\u001b[0;31m                 \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sock\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrecv_into\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    721\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    722\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_timeout_occurred\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+     ]
+    }
+   ],
+   "source": [
+    "# Test with a question\n",
+    "test_question = \"What is a wired network?\"  # Change this to your question\n",
+    "\n",
+    "print(f\"❓ Question: {test_question}\\n\")\n",
+    "result = rag_answer(test_question, relevance_threshold=2.0)  # Increased threshold\n",
+    "\n",
+    "print(f\"📊 Source: {result['source'].upper()}\")\n",
+    "print(f\"📊 Relevance Score: {result['relevance_score']:.3f}\")\n",
+    "print(f\"\\n💬 Answer:\\n{result['answer']}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "04937fbd",
+   "metadata": {},
+   "source": [
+    "## 7. Create FastAPI Server + ngrok (Public API)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "708b25ca",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ FastAPI app created!\n"
+     ]
+    }
+   ],
+   "source": [
+    "from fastapi import FastAPI, HTTPException\n",
+    "from pydantic import BaseModel\n",
+    "import nest_asyncio\n",
+    "\n",
+    "# Allow nested event loops (for Jupyter)\n",
+    "nest_asyncio.apply()\n",
+    "\n",
+    "# Create FastAPI app\n",
+    "app = FastAPI(title=\"RAG API\", version=\"1.0\")\n",
+    "\n",
+    "class QuestionRequest(BaseModel):\n",
+    "    question: str\n",
+    "    threshold: float = 2.0  # Default threshold\n",
+    "\n",
+    "class AnswerResponse(BaseModel):\n",
+    "    question: str\n",
+    "    answer: str\n",
+    "    source: str\n",
+    "    relevance_score: float\n",
+    "    context_found: bool\n",
+    "\n",
+    "@app.get(\"/\")\n",
+    "async def root():\n",
+    "    return {\n",
+    "        \"message\": \"RAG API is running!\",\n",
+    "        \"endpoints\": {\n",
+    "            \"/ask\": \"POST - Ask a question\",\n",
+    "            \"/status\": \"GET - Check system status\"\n",
+    "        }\n",
+    "    }\n",
+    "\n",
+    "@app.post(\"/ask\", response_model=AnswerResponse)\n",
+    "async def ask_question(request: QuestionRequest):\n",
+    "    \"\"\"Ask a question to RAG system\"\"\"\n",
+    "    if not request.question:\n",
+    "        raise HTTPException(status_code=400, detail=\"Question is required\")\n",
+    "    \n",
+    "    result = rag_answer(request.question, relevance_threshold=request.threshold)\n",
+    "    \n",
+    "    return AnswerResponse(\n",
+    "        question=request.question,\n",
+    "        answer=result[\"answer\"],\n",
+    "        source=result[\"source\"],\n",
+    "        relevance_score=result[\"relevance_score\"],\n",
+    "        context_found=result[\"context_found\"]\n",
+    "    )\n",
+    "\n",
+    "@app.get(\"/status\")\n",
+    "async def get_status():\n",
+    "    \"\"\"Get RAG system status\"\"\"\n",
+    "    return {\n",
+    "        \"initialized\": rag_initialized,\n",
+    "        \"documents_count\": len(uploaded_documents),\n",
+    "        \"documents\": uploaded_documents,\n",
+    "        \"has_vector_store\": vectordb is not None\n",
+    "    }\n",
+    "\n",
+    "print(\"✅ FastAPI app created!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd49f8a1",
+   "metadata": {},
+   "source": [
+    "## 8. Start Server Locally (Access at http://localhost:8000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0e4c8558",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "============================================================\n",
+      "🌐 LOCAL API SERVER STARTED!\n",
+      "============================================================\n",
+      "\n",
+      "📌 API Endpoints:\n",
+      "   POST http://localhost:8000/ask   - Ask a question\n",
+      "   GET  http://localhost:8000/status - Check status\n",
+      "   GET  http://localhost:8000/docs   - API documentation\n",
+      "\n",
+      "💡 Test in browser: http://localhost:8000/docs\n",
+      "\n",
+      "💡 Example curl command:\n",
+      "   curl -X POST \"http://localhost:8000/ask\" ^\n",
+      "        -H \"Content-Type: application/json\" ^\n",
+      "        -d \"{\\\"question\\\": \\\"What is a wired network?\\\", \\\"threshold\\\": 2.0}\"\n",
+      "\n",
+      "🔄 Server is running in background...\n",
+      "   (Server will stop when notebook kernel is restarted)\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.12/dist-packages/uvicorn/server.py:67: RuntimeWarning: coroutine 'Server.serve' was never awaited\n",
+      "  return asyncio_run(self.serve(sockets=sockets), loop_factory=self.config.get_loop_factory())\n",
+      "RuntimeWarning: Enable tracemalloc to get the object allocation traceback\n",
+      "Exception in thread Thread-6 (run_server):\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/usr/lib/python3.12/threading.py\", line 1075, in _bootstrap_inner\n",
+      "    self.run()\n",
+      "  File \"/usr/lib/python3.12/threading.py\", line 1012, in run\n",
+      "    self._target(*self._args, **self._kwargs)\n",
+      "  File \"/tmp/ipython-input-2073060122.py\", line 6, in run_server\n",
+      "  File \"/usr/local/lib/python3.12/dist-packages/uvicorn/main.py\", line 593, in run\n",
+      "    server.run()\n",
+      "  File \"/usr/local/lib/python3.12/dist-packages/uvicorn/server.py\", line 67, in run\n",
+      "    return asyncio_run(self.serve(sockets=sockets), loop_factory=self.config.get_loop_factory())\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "TypeError: _patch_asyncio.<locals>.run() got an unexpected keyword argument 'loop_factory'\n"
+     ]
+    }
+   ],
+   "source": [
+    "import uvicorn\n",
+    "import threading\n",
+    "\n",
+    "def run_server():\n",
+    "    \"\"\"Run the FastAPI server in a thread\"\"\"\n",
+    "    uvicorn.run(app, host=\"127.0.0.1\", port=8000, log_level=\"info\")\n",
+    "\n",
+    "# Start server in background thread\n",
+    "server_thread = threading.Thread(target=run_server, daemon=True)\n",
+    "server_thread.start()\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*60)\n",
+    "print(\"🌐 LOCAL API SERVER STARTED!\")\n",
+    "print(\"=\"*60)\n",
+    "print(\"\\n📌 API Endpoints:\")\n",
+    "print(\"   POST http://localhost:8000/ask   - Ask a question\")\n",
+    "print(\"   GET  http://localhost:8000/status - Check status\")\n",
+    "print(\"   GET  http://localhost:8000/docs   - API documentation\")\n",
+    "print(\"\\n💡 Test in browser: http://localhost:8000/docs\")\n",
+    "print(\"\\n💡 Example curl command:\")\n",
+    "print('   curl -X POST \"http://localhost:8000/ask\" ^')\n",
+    "print('        -H \"Content-Type: application/json\" ^')\n",
+    "print('        -d \"{\\\\\"question\\\\\": \\\\\"What is a wired network?\\\\\", \\\\\"threshold\\\\\": 2.0}\"')\n",
+    "print(\"\\n🔄 Server is running in background...\")\n",
+    "print(\"   (Server will stop when notebook kernel is restarted)\\n\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a025b750",
+   "metadata": {},
+   "source": [
+    "## 9. Test API from Another Cell (While Server is Running)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b368a3ac",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "📡 Testing API at http://localhost:8000/ask\n",
+      "\n",
+      "❌ Connection error: HTTPConnectionPool(host='localhost', port=8000): Max retries exceeded with url: /ask (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x79ffcd92bd40>: Failed to establish a new connection: [Errno 111] Connection refused'))\n",
+      "   Make sure the server is running (cell 8)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import requests\n",
+    "import json\n",
+    "import time\n",
+    "\n",
+    "# Give server a moment to start\n",
+    "time.sleep(2)\n",
+    "\n",
+    "# Local API URL\n",
+    "API_URL = \"http://localhost:8000\"\n",
+    "\n",
+    "# Test question\n",
+    "test_data = {\n",
+    "    \"question\": \"What is a wireless network?\",\n",
+    "    \"threshold\": 2.0\n",
+    "}\n",
+    "\n",
+    "print(f\"📡 Testing API at {API_URL}/ask\\n\")\n",
+    "\n",
+    "try:\n",
+    "    # Make API request\n",
+    "    response = requests.post(\n",
+    "        f\"{API_URL}/ask\",\n",
+    "        json=test_data,\n",
+    "        headers={\"Content-Type\": \"application/json\"}\n",
+    "    )\n",
+    "    \n",
+    "    if response.status_code == 200:\n",
+    "        result = response.json()\n",
+    "        print(f\"❓ Question: {result['question']}\")\n",
+    "        print(f\"📊 Source: {result['source'].upper()}\")\n",
+    "        print(f\"📊 Score: {result['relevance_score']:.3f}\")\n",
+    "        print(f\"\\n💬 Answer:\\n{result['answer']}\")\n",
+    "    else:\n",
+    "        print(f\"❌ Error: {response.status_code}\")\n",
+    "        print(response.text)\n",
+    "except Exception as e:\n",
+    "    print(f\"❌ Connection error: {e}\")\n",
+    "    print(\"   Make sure the server is running (cell 8)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "86a8d4bb",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## ✅ Summary - Local Windows Setup\n",
+    "\n",
+    "Your RAG API is now configured for **local Windows** use:\n",
+    "\n",
+    "### How to Use:\n",
+    "1. ✅ **Run cells 1-4** to install packages and load functions\n",
+    "2. ✅ **Add PDFs** to the `rag_data/pdfs` folder in your project directory\n",
+    "3. ✅ **Run cell 5** to process PDFs and build the vector database\n",
+    "4. ✅ **Run cell 6** to test RAG queries directly\n",
+    "5. ✅ **Run cell 8** to start the local API server\n",
+    "6. ✅ **Access API docs** at http://localhost:8000/docs\n",
+    "\n",
+    "### Key Features:\n",
+    "- 📁 Data stored locally in `rag_data/` folder\n",
+    "- 🔍 Answers from PDF documents first\n",
+    "- 🤖 Falls back to Gemini API when needed\n",
+    "- 🌐 Local API server at http://localhost:8000\n",
+    "- 💾 FAISS index persists between sessions\n",
+    "\n",
+    "### Quick Test:\n",
+    "```python\n",
+    "# Direct RAG query (no API)\n",
+    "result = rag_answer(\"Your question here\", relevance_threshold=2.0)\n",
+    "print(result['answer'])\n",
+    "```\n",
+    "\n",
+    "### Next Steps:\n",
+    "- Add more PDFs to `rag_data/pdfs/` folder\n",
+    "- Rerun cell 5 to add them to the database\n",
+    "- Adjust `relevance_threshold` (lower = stricter, higher = more lenient)\n",
+    "- Access interactive API docs at http://localhost:8000/docs"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

requirements.txt

@@ -0,0 +1,37 @@
+# Sinhala Chatbot - Dependencies
+
+# Web Framework
+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+python-multipart==0.0.6
+jinja2==3.1.3
+
+# Google Gemini AI
+google-generativeai==0.3.2
+
+# Speech Recognition (Whisper)
+# Optional for local ASR: transformers, torch, soundfile, scipy
+
+# Text-to-Speech
+gTTS==2.5.0
+
+# Environment Variables
+python-dotenv==1.0.0
+
+# Utilities
+numpy==1.26.3
+scipy==1.11.4
+
+# Translation
+deep-translator>=1.11.4
+
+# Free LLM API
+huggingface-hub>=0.20.0
+
+# RAG (Retrieval-Augmented Generation)
+langchain-community>=0.0.20
+langchain-huggingface>=0.0.1
+langchain-text-splitters>=0.0.1
+sentence-transformers>=2.2.0
+faiss-cpu==1.8.0.post1
+pypdf>=3.17.0