Initial clean commit

.dockerignore

@@ -0,0 +1,32 @@
+# Python artefacts
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+.Python
+*.egg-info/
+
+# Virtual environments
+myenv/
+venv/
+env/
+
+# Node
+frontend-react/node_modules/
+frontend-react/dist/
+
+# Git
+.git/
+.gitignore
+
+# Local data (mounted as Docker volumes)
+backend/qdrant_storage/
+qdrant_storage/
+backend/app/data/
+
+# Dev / IDE
+*.log
+.pytest_cache/
+.mypy_cache/
+scratch/
+README.md

.env.example

@@ -0,0 +1,58 @@
+# =========================================================================
+# Legal Case Law RAG - Environment Variables Template
+# =========================================================================
+# Copy this file to a new file named '.env' and fill in your values.
+# Do NOT commit your actual '.env' file with secrets to Git.
+
+# LLM Providers Configuration
+# Supported Options: "gemini", "groq"
+ACTIVE_LLM="groq"
+
+# --- 1. Google Gemini ---
+# Get your API key from Google AI Studio: https://aistudio.google.com/
+GEMINI_API_KEY="your-gemini-api-key-here"
+LLM_MODEL_NAME="gemini-2.5-flash"
+
+LLM_TEMPERATURE=0.5
+LLM_MAX_RETRIES=5
+
+# --- 2. Groq ---
+# Get your API key from Groq Console: https://console.groq.com/
+GROQ_API_KEY="your-groq-api-key-here"
+GROQ_MODEL_NAME="meta-llama/llama-4-scout-17b-16e-instruct"
+
+# RAG & Legal Embeddings Configuration
+# law-ai/InLegalBERT is optimized for Indian legal texts
+EMBEDDING_MODEL_NAME="law-ai/InLegalBERT"
+RERANKER_MODEL_NAME="BAAI/bge-reranker-v2-m3"
+
+# Chunking & Retrieval Parameters
+PARENT_CHUNK_SIZE=1500
+PARENT_CHUNK_OVERLAP=200
+CHILD_CHUNK_SIZE=400
+CHILD_CHUNK_OVERLAP=100
+SEARCH_K=10
+FETCH_K=40
+RERANK_TOP_K=5
+
+# Database Configuration (PostgreSQL or SQLite)
+USE_POSTGRES=false
+POSTGRES_USER=postgres
+POSTGRES_PASSWORD=your_db_password
+POSTGRES_SERVER=localhost
+POSTGRES_PORT=5432
+POSTGRES_DB=legal_rag
+
+# Security Options (FastAPI session tokens)
+SECRET_KEY="generate-a-secure-random-string-here"
+
+# Webhooks & External Services (Optional)
+N8N_WEBHOOK_URL=""
+PINECONE_API_KEY=""
+PINECONE_INDEX_NAME="legal-rag"
+
+# LangSmith Tracing & Observability (Optional)
+LANGSMITH_TRACING=false
+LANGSMITH_ENDPOINT="https://api.smith.langchain.com"
+LANGSMITH_API_KEY=""
+LANGSMITH_PROJECT="legal-case-law-rag"

.gitattributes

@@ -0,0 +1 @@
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,60 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+myenv/
+
+# Node (Frontend)
+frontend-react/node_modules/
+frontend-react/dist/
+frontend-react/dist-ssr/
+frontend-react/.vite/
+frontend-react/*.local
+
+# Environment & Secrets
+.env
+.venv
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Databases and Vector Storage
+backend/app/data/*.db
+data/*.db
+qdrant_storage/
+
+# Temporary Files
+temp_*
+*.log
+
+# OS files
+.DS_Store
+Thumbs.db
+
+inspect_qdrant.py
+Case_Overview_Questions_Answers.csv
+generate_embeddings.py
+brain/
+backend/scratch/
+
+# Case Files
+Vadraj_Cement_Limited_vs_Union_Of_India_on_18_March_2026.PDF
+*.pdf
+*.PDF

Dockerfile

@@ -0,0 +1,33 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# System dependencies: PyAudio, psycopg2, build tools
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    portaudio19-dev \
+    libpq-dev \
+    libpq5 \
+    curl \
+    pkg-config \
+    cmake \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements.txt from the root
+COPY requirements.txt .
+
+RUN pip install --upgrade pip setuptools wheel && \
+    pip install --no-cache-dir --no-build-isolation pyaudio && \
+    pip install --no-cache-dir -r requirements.txt && \
+    pip install --no-cache-dir --no-deps qwen-asr qwen-tts
+
+# Copy backend application source
+COPY backend/app ./app
+
+# Create necessary directories
+RUN mkdir -p /app/app/data /app/qdrant_storage
+
+EXPOSE 8001
+EXPOSE 7860
+
+CMD ["sh", "-c", "uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-8001}"]

README.md

@@ -0,0 +1,70 @@
+# Legal Case Law RAG Assistant ⚖️
+
+A professional, high-performance Retrieval-Augmented Generation (RAG) platform tailored for legal researchers. This application combines state-of-the-art LLMs with a proprietary legal search engine to provide precise, citation-backed analysis of case law.
+
+## 🌟 Key Features
+
+- **Legal-Specific RAG**: High-fidelity retrieval utilizing **Qdrant** and specialized legal embeddings (`InLegalBERT`).
+- **Parent-Child Chunking**: Maintains document context while allowing for granular retrieval of specific legal clauses.
+- **Premium Voice Experience**:
+  - **Seamless TTS Highlighting**: Real-time "karaoke-style" word highlighting synchronized with audio playback.
+  - **Kokoro-82M Engine**: Ultra-natural, low-latency speech generation.
+  - **Citation Filtering**: Audio automatically skips citations and Markdown symbols for a clean listening experience.
+- **Streaming Intelligence**: Multi-document analysis with real-time response streaming and deterministic citations.
+- **Modern Architecture**:
+  - **Backend**: FastAPI with async execution and JWT security.
+  - **Frontend**: React-based Glassmorphism UI with persistent session management.
+
+## 🛠️ Technology Stack
+
+- **Python**: 3.12.10
+- **Vector Store**: Qdrant (Persistent Storage)
+- **Frameworks**: FastAPI, React.js (Vite)
+- **AI Models**: Gemini 2.0/2.5, Groq (Llama 3)
+- **Audio Stack**: Kokoro-82M (TTS), Qwen-ASR (Speech Recognition)
+
+## 🚀 Getting Started
+
+### Prerequisites
+- Python 3.12+
+- Node.js & npm
+- Qdrant Instance (Local or Cloud)
+
+### 1. Backend Setup
+1. Create and activate a virtual environment:
+   ```bash
+   python -m venv myenv
+   myenv\Scripts\activate
+   ```
+2. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+3. Configure your keys:
+   - Copy `.env.example` to `.env`.
+   - Fill in your `GEMINI_API_KEY` or `GROQ_API_KEY`.
+4. Run the server:
+   ```bash
+   cd backend
+   uvicorn app.main:app --reload
+   ```
+
+### 2. Frontend Setup
+1. Navigate to the frontend:
+   ```bash
+   cd frontend-react
+   ```
+2. Install & Start:
+   ```bash
+   npm install
+   npm run dev
+   ```
+
+## 📂 Project Organization
+- `/backend`: FastAPI source code and local data/vector storage.
+- `/frontend-react`: React application source and styling.
+- `/requirements.txt`: Unified dependency list with critical version locks.
+- `/.env.example`: Clean template for environment configuration.
+
+---
+**License**: Internal Project / Proprietary

backend/.dockerignore

@@ -0,0 +1,33 @@
+# Python cache
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+.Python
+
+# Virtual environments
+myenv/
+venv/
+env/
+.env
+
+# Qdrant local storage (mounted as volume)
+qdrant_storage/
+
+# SQLite database (mounted as volume)
+app/data/
+
+# Test / dev artifacts
+*.log
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.mypy_cache/
+
+# Scratch / temp
+scratch/
+
+# Git
+.git/
+.gitignore

backend/Dockerfile

@@ -0,0 +1,33 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# System dependencies: PyAudio, psycopg2, build tools
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    portaudio19-dev \
+    libpq-dev \
+    libpq5 \
+    curl \
+    pkg-config \
+    cmake \
+    && rm -rf /var/lib/apt/lists/*
+
+# requirements.txt is copied from the project root (build context is root)
+COPY requirements.txt .
+
+RUN pip install --upgrade pip setuptools wheel && \
+    pip install --no-cache-dir --no-build-isolation pyaudio && \
+    pip install --no-cache-dir -r ../requirements.txt && \
+    pip install --no-cache-dir --no-deps qwen-asr qwen-tts
+
+# Copy backend application source
+COPY backend/app ./app
+
+# Persistent data directories
+RUN mkdir -p /app/app/data /app/qdrant_storage
+
+EXPOSE 8001
+EXPOSE 7860
+
+CMD ["sh", "-c", "uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-8001}"]

backend/app/api/api_v1/api.py

@@ -0,0 +1,11 @@
+from fastapi import APIRouter
+from .endpoints import auth, documents, chat
+from ...services.voice_service import voice_service
+
+api_router = APIRouter()
+api_router.include_router(auth.router, tags=["auth"])
+api_router.include_router(documents.router, prefix="/documents", tags=["documents"])
+api_router.include_router(chat.router, prefix="/chat", tags=["chat"])
+
+# Voice router (matching legacy structure)
+api_router.include_router(voice_service.create_voice_router() if hasattr(voice_service, 'create_voice_router') else None)

backend/app/api/api_v1/endpoints/auth.py

@@ -0,0 +1,58 @@
+from typing import Any
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordRequestForm
+from sqlalchemy.orm import Session
+from ... import deps
+from ....core import security
+from ....core.config import settings
+from ....db.session import get_db
+from ....models.user import User
+from ....schemas.user import UserCreate, User as UserSchema
+from ....schemas.token import Token
+
+router = APIRouter()
+
+@router.post("/register", response_model=dict)
+def register(user_in: UserCreate, db: Session = Depends(get_db)):
+    # Check if username exists
+    user = db.query(User).filter(User.username == user_in.username).first()
+    if user:
+        raise HTTPException(
+            status_code=400,
+            detail="The user with this username already exists in the system.",
+        )
+    # Check if email exists
+    user = db.query(User).filter(User.email == user_in.email).first()
+    if user:
+        raise HTTPException(
+            status_code=400,
+            detail="The user with this email already exists in the system.",
+        )
+    
+    hashed_password = security.get_password_hash(user_in.password)
+    new_user = User(
+        username=user_in.username, 
+        email=user_in.email,
+        hashed_password=hashed_password
+    )
+    db.add(new_user)
+    db.commit()
+    return {"message": "User registered successfully"}
+
+@router.post("/token", response_model=Token)
+def login_access_token(
+    db: Session = Depends(get_db), form_data: OAuth2PasswordRequestForm = Depends()
+) -> Any:
+    # Treat the username field from the form as email
+    user = db.query(User).filter(User.email == form_data.username).first()
+    if not user or not security.verify_password(form_data.password, user.hashed_password):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect email or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    elif not user.is_active:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Inactive user")
+    
+    access_token = security.create_access_token(subject=user.email)
+    return {"access_token": access_token, "token_type": "bearer"}

backend/app/api/api_v1/endpoints/chat.py

@@ -0,0 +1,231 @@
+import json
+from typing import List, Optional
+from fastapi import APIRouter, Depends, HTTPException, Request
+from fastapi.responses import StreamingResponse
+from sqlalchemy.orm import Session
+from ... import deps
+from ....core.config import settings
+from ....models.user import User
+from ....models.chat import ChatSession, ChatMessage
+from ....schemas.chat import ChatQuery
+from ....services.rag_service import rag_service
+from ....db.init_db import q_client, COLLECTION_NAME, get_vector_store
+from ....db.session import SessionLocal
+from qdrant_client.http import models as rest
+from ....services.tts import get_tts_wav, stream_tts_wav_chunks
+import re
+from pydantic import BaseModel
+
+router = APIRouter()
+
+class SpeakRequest(BaseModel):
+    text: str
+
+async def build_chat_title(query: str) -> str:
+    cleaned = re.sub(r"\s+", " ", query or "").strip()
+    if not cleaned: return "New Chat"
+    try:
+        from langchain_core.messages import HumanMessage
+        prompt = f"Short title (2-5 words) for: {cleaned}"
+        messages = [HumanMessage(content=prompt)]
+        response = await rag_service.llm.ainvoke(messages)
+        return response.content.strip().strip('"').strip("'")[:60]
+    except:
+        return cleaned[:30] + "..."
+
+@router.get("/sessions")
+def list_sessions(db: Session = Depends(deps.get_db), current_user: User = Depends(deps.get_current_active_user)):
+    user_id_str = str(current_user.id)
+    sessions = db.query(ChatSession).filter(ChatSession.user_id == user_id_str).order_by(ChatSession.created_at.desc()).all()
+    return {"sessions": [{"id": s.id, "title": s.title, "date": s.created_at} for s in sessions]}
+
+@router.get("/history/{session_id}")
+def get_history(session_id: str, db: Session = Depends(deps.get_db), current_user: User = Depends(deps.get_current_active_user)):
+    user_id_str = str(current_user.id)
+    messages = db.query(ChatMessage).filter(
+        ChatMessage.user_id == user_id_str,
+        ChatMessage.session_id == session_id
+    ).order_by(ChatMessage.timestamp.asc()).all()
+    
+    # Also fetch linked documents
+    from ....models.document import Document
+    docs = db.query(Document).filter(
+        Document.user_id == user_id_str,
+        Document.session_id == session_id
+    ).all()
+    
+    return {
+        "history": [{"role": m.role, "text": m.content, "sources": json.loads(m.sources) if m.sources else []} for m in messages],
+        "documents": [{"filename": d.filename, "chunks": d.chunk_count} for d in docs]
+    }
+
+class ChatQuery(BaseModel):
+    query: str
+    session_id: str
+    filename: Optional[str] = None
+    filenames: Optional[List[str]] = None
+
+@router.post("/")
+async def query_chat(chat_data: ChatQuery, db: Session = Depends(deps.get_db), current_user: User = Depends(deps.get_current_active_user)):
+    user_id_str = str(current_user.id)
+    vector_store = get_vector_store(rag_service.embeddings)
+    user_id_f = rest.FieldCondition(key="metadata.user_id", match=rest.MatchValue(value=user_id_str))
+    
+    # 1. Broad Session Search (Selection-Aware)
+    must_conditions = [user_id_f, rest.FieldCondition(key="metadata.session_id", match=rest.MatchValue(value=chat_data.session_id))]
+    if chat_data.filenames and len(chat_data.filenames) > 0:
+        must_conditions.append(rest.FieldCondition(key="metadata.filename", match=rest.MatchAny(any=chat_data.filenames)))
+    elif chat_data.filename:
+        must_conditions.append(rest.FieldCondition(key="metadata.filename", match=rest.MatchValue(value=chat_data.filename)))
+
+    search_results = vector_store.search(
+        query=chat_data.query, 
+        search_type="mmr", 
+        k=settings.SEARCH_K, 
+        fetch_k=settings.FETCH_K,
+        filter=rest.Filter(must=must_conditions)
+    )
+    
+    if not search_results:
+        async def empty_gen():
+            yield "I couldn't find any relevant information across your documents to answer this question."
+        return StreamingResponse(empty_gen(), media_type="text/plain")
+
+    # 2. Handle Session & Logging
+    session = db.query(ChatSession).filter(ChatSession.id == chat_data.session_id).first()
+    if not session:
+        title = await build_chat_title(chat_data.query)
+        session = ChatSession(id=chat_data.session_id, user_id=user_id_str, title=title)
+        db.add(session)
+        db.commit()
+
+    db.add(ChatMessage(user_id=user_id_str, session_id=chat_data.session_id, role="user", content=chat_data.query))
+    db.commit()
+
+    # 3. Intelligent Grouping
+    # Rerank first to ensure we are only using top relevant bits across all files
+    candidates = [doc.page_content for doc in search_results]
+    scores = rag_service.rerank_results(chat_data.query, candidates)
+    scored_hits = sorted(zip(search_results, scores), key=lambda x: x[1], reverse=True)[:settings.RERANK_TOP_K]
+
+    # Group the top hits by filename
+    grouped_hits = {}
+    all_sources_data = [] # For DB storage
+    consolidated_citations = {} # For final display
+
+    for hit, score in scored_hits:
+        fname = hit.metadata.get('filename', 'Unknown Document')
+        page = hit.metadata.get('page')
+        
+        all_sources_data.append({"file": fname, "page": page})
+        if fname not in consolidated_citations: consolidated_citations[fname] = set()
+        if page: consolidated_citations[fname].add(page)
+        
+        if fname not in grouped_hits: grouped_hits[fname] = []
+        grouped_hits[fname].append(f"[Page: {page}]\n{hit.page_content}")
+
+    unique_files_found = list(grouped_hits.keys())
+    is_sequential = len(unique_files_found) > 1
+
+    async def response_generator():
+        full_answer = ""
+        
+        for idx, fname in enumerate(unique_files_found):
+            # A. Prepare section header
+            header = f"### [DOCUMENT: {fname}]\n\n" if is_sequential else ""
+            full_answer += header
+            if header: yield header
+            
+            # B. Stream answer for THIS document's context
+            doc_context = grouped_hits[fname]
+            async for chunk in rag_service.generate_answer_stream(
+                chat_data.query, 
+                doc_context, 
+                brief=is_sequential, 
+                trace_metadata={"user_id": user_id_str, "file": fname}
+            ):
+                full_answer += chunk
+                yield chunk
+            
+            # C. Separator
+            if is_sequential and idx < len(unique_files_found) - 1:
+                sep = "\n\n---\n\n"
+                full_answer += sep
+                yield sep
+
+        # 4. Deterministic Python Citations
+        citation_lines = []
+        for f, pages in consolidated_citations.items():
+            sorted_pages = sorted(list(pages))
+            pages_str = ", ".join(map(str, sorted_pages))
+            citation_lines.append(f"[Source: {f}, Pages: {pages_str}]")
+        
+        python_citation_str = "\n\n***\n" + "\n".join(citation_lines) if citation_lines else ""
+        
+        if python_citation_str:
+            full_answer += python_citation_str
+            yield python_citation_str
+
+        # 5. Final Save
+        with SessionLocal() as final_db:
+            final_db.add(ChatMessage(user_id=user_id_str, session_id=chat_data.session_id, role="assistant", content=full_answer, sources=json.dumps(all_sources_data)))
+            final_db.commit()
+
+    return StreamingResponse(response_generator(), media_type="text/plain")
+
+@router.delete("/session/{session_id}")
+def delete_session(session_id: str, db: Session = Depends(deps.get_db), current_user: User = Depends(deps.get_current_active_user)):
+    user_id_str = str(current_user.id)
+    
+    # 1. Cleanup Documents and Embeddings associated with this session
+    from ....models.document import Document
+    db.query(Document).filter(Document.session_id == session_id, Document.user_id == user_id_str).delete()
+    
+    q_client.delete(
+        collection_name=COLLECTION_NAME,
+        points_selector=rest.Filter(
+            must=[
+                rest.FieldCondition(key="metadata.user_id", match=rest.MatchValue(value=user_id_str)),
+                rest.FieldCondition(key="metadata.session_id", match=rest.MatchValue(value=session_id))
+            ]
+        )
+    )
+
+    # 2. Cleanup Messages and Session
+    db.query(ChatMessage).filter(ChatMessage.session_id == session_id, ChatMessage.user_id == user_id_str).delete()
+    db.query(ChatSession).filter(ChatSession.id == session_id, ChatSession.user_id == user_id_str).delete()
+    
+    db.commit()
+    return {"message": "Session and associated documents deleted"}
+
+@router.post("/speak")
+async def speak(request: Request, speak_data: SpeakRequest):
+    # Sanitize text for TTS
+    clean_text = speak_data.text
+    clean_text = re.sub(r'#+\s+', '', clean_text)
+    clean_text = re.sub(r'\*+', '', clean_text)
+    clean_text = re.sub(r'_{3,}', '', clean_text)
+    clean_text = re.sub(r'-{3,}', '', clean_text)
+    clean_text = re.sub(r'\[Source:.*?\]', '', clean_text)
+    
+    # Internal stop signal for THIS specific request
+    import threading
+    disconnect_event = threading.Event()
+
+    # Generator wrapper to monitor disconnection
+    async def disconnect_monitor_gen():
+        generator = stream_tts_wav_chunks(clean_text, disconnect_event)
+        try:
+            for chunk in generator:
+                if await request.is_disconnected():
+                    disconnect_event.set()
+                    break
+                yield chunk
+        except Exception as e:
+            disconnect_event.set()
+            raise e
+
+    return StreamingResponse(
+        disconnect_monitor_gen(),
+        media_type="application/x-ndjson"
+    )

backend/app/api/api_v1/endpoints/documents.py

@@ -0,0 +1,131 @@
+import uuid
+import os
+import time
+from fastapi import APIRouter, Depends, HTTPException, status, File, UploadFile, Form
+from sqlalchemy.orm import Session
+from langchain_core.documents import Document as LCDocument
+from ... import deps
+from ....core.config import settings
+from ....db.init_db import q_client, COLLECTION_NAME, get_vector_store
+from ....models.user import User
+from ....models.document import Document
+from ....services.pdf_processor import process_pdf
+from ....services.rag_service import rag_service
+from qdrant_client.http import models as rest
+
+router = APIRouter()
+
+@router.post("/upload")
+async def upload_document(
+    file: UploadFile = File(...), 
+    session_id: str = Form(None),
+    db: Session = Depends(deps.get_db),
+    current_user: User = Depends(deps.get_current_active_user)
+):
+    query = db.query(Document).filter(
+        Document.user_id == str(current_user.id),
+        Document.filename == file.filename
+    )
+    if session_id:
+        query = query.filter(Document.session_id == session_id)
+    else:
+        query = query.filter(Document.session_id == None)
+        
+    if query.first():
+        raise HTTPException(status_code=409, detail=f"Document '{file.filename}' already indexed.")
+
+    temp_path = f"temp_{uuid.uuid4()}_{file.filename}"
+    with open(temp_path, "wb") as buffer:
+        buffer.write(await file.read())
+    
+    start_time = time.time()
+    try:
+        chunks = process_pdf(temp_path, current_user.id, file.filename, session_id)
+        if not chunks:
+            raise HTTPException(status_code=400, detail="No text extracted")
+        
+        # Legal Audit
+        text_sample = "\n".join([c["text"] for c in chunks[:3]])
+        if not rag_service.validate_is_legal(text_sample):
+            raise HTTPException(status_code=400, detail="Not a legal document")
+        
+        vector_store = get_vector_store(rag_service.embeddings)
+        docs = [LCDocument(page_content=c["text"], metadata=c["metadata"]) for c in chunks]
+        vector_store.add_documents(docs)
+        
+        embed_time = time.time() - start_time
+        new_doc = Document(
+            user_id=str(current_user.id), 
+            filename=file.filename, 
+            session_id=session_id,
+            chunk_count=len(chunks),
+            embed_time_seconds=round(embed_time, 2)
+        )
+        db.add(new_doc)
+        db.commit()
+        return {
+            "message": f"Successfully indexed {file.filename}",
+            "chunks": len(chunks),
+            "time": round(embed_time, 2)
+        }
+    finally:
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+
+@router.get("/")
+def get_user_documents(db: Session = Depends(deps.get_db), current_user: User = Depends(deps.get_current_active_user)):
+    from ....models.chat import ChatSession
+    
+    # Efficiently join Document and ChatSession to avoid N+1 queries (lookup speed-up)
+    query_results = db.query(Document, ChatSession.title).outerjoin(
+        ChatSession, Document.session_id == ChatSession.id
+    ).filter(Document.user_id == str(current_user.id)).all()
+    
+    results = []
+    for doc, chat_title in query_results:
+        results.append({
+            "id": doc.id,
+            "filename": doc.filename,
+            "date": doc.upload_date,
+            "session_id": doc.session_id,
+            "session_title": chat_title or "Direct Upload",
+            "chunks": doc.chunk_count or 0,
+            "embed_time": doc.embed_time_seconds or 0
+        })
+    return {"documents": results}
+
+@router.get("/session/{session_id}")
+def get_session_documents(
+    session_id: str, 
+    db: Session = Depends(deps.get_db), 
+    current_user: User = Depends(deps.get_current_active_user)
+):
+    docs = db.query(Document).filter(
+        Document.user_id == str(current_user.id),
+        Document.session_id == session_id
+    ).all()
+    return {
+        "documents": [{"filename": d.filename, "chunks": d.chunk_count} for d in docs]
+    }
+
+@router.delete("/{filename}")
+def delete_document(filename: str, db: Session = Depends(deps.get_db), current_user: User = Depends(deps.get_current_active_user)):
+    # Find all variants (different sessions) of this filename for this user
+    docs = db.query(Document).filter(Document.user_id == str(current_user.id), Document.filename == filename).all()
+    if not docs:
+        raise HTTPException(status_code=404, detail="Document not found")
+        
+    for doc in docs:
+        db.delete(doc)
+    db.commit()
+    
+    q_client.delete(
+        collection_name=COLLECTION_NAME,
+        points_selector=rest.Filter(
+            must=[
+                rest.FieldCondition(key="metadata.user_id", match=rest.MatchValue(value=str(current_user.id))),
+                rest.FieldCondition(key="metadata.filename", match=rest.MatchValue(value=filename))
+            ]
+        )
+    )
+    return {"message": f"Deleted all instances of {filename}"}

backend/app/api/deps.py

@@ -0,0 +1,49 @@
+from typing import Generator
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jose import jwt, JWTError
+from sqlalchemy.orm import Session
+from ..core import security
+from ..core.config import settings
+from ..db.session import SessionLocal
+from ..models.user import User
+from ..schemas.token import TokenPayload
+# Reference: https://fastapi.tiangolo.com/tutorial/security/
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl=f"/token")
+
+def get_db() -> Generator:
+    try:
+        db = SessionLocal()
+        yield db
+    finally:
+        db.close()
+
+async def get_current_user(
+    db: Session = Depends(get_db), token: str = Depends(oauth2_scheme)
+) -> User:
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(
+            token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM]
+        )
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+        token_data = TokenPayload(sub=username)
+    except JWTError:
+        raise credentials_exception
+    user = db.query(User).filter(User.email == token_data.sub).first()
+    if not user:
+        raise credentials_exception
+    return user
+
+async def get_current_active_user(
+    current_user: User = Depends(get_current_user),
+) -> User:
+    if not current_user.is_active:
+        raise HTTPException(status_code=400, detail="Inactive user")
+    return current_user

backend/app/core/config.py

@@ -0,0 +1,85 @@
+import os
+from pydantic_settings import BaseSettings
+from pydantic import field_validator
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Settings(BaseSettings):
+    PROJECT_NAME: str = "Legal Case Law RAG"
+    
+    # Auth
+    SECRET_KEY: str = os.getenv("SECRET_KEY", "legal-rag-secret-2026")
+    ALGORITHM: str = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 1440 # 24 hours
+    
+    # RAG Search
+    SEARCH_K: int = int(os.getenv("SEARCH_K", 40))
+    FETCH_K: int = int(os.getenv("FETCH_K", 100))
+    RERANK_TOP_K: int = int(os.getenv("RERANK_TOP_K", 15))
+    
+    # Models
+    EMBEDDING_MODEL_NAME: str = os.getenv("EMBEDDING_MODEL_NAME", "law-ai/InLegalBERT")
+    RERANKER_MODEL_NAME: str = os.getenv("RERANKER_MODEL_NAME", "BAAI/bge-reranker-v2-m3")
+    GEMINI_API_KEY: str = os.getenv("GEMINI_API_KEY", "")
+    
+    # LLM Settings
+    ACTIVE_LLM: str = os.getenv("ACTIVE_LLM", "groq").lower()
+    LLM_MODEL_NAME: str = os.getenv("LLM_MODEL_NAME", "gemini-2.5-flash")
+    LLM_TEMPERATURE: float = float(os.getenv("LLM_TEMPERATURE", 0.0))
+    LLM_MAX_RETRIES: int = int(os.getenv("LLM_MAX_RETRIES", 5))
+    
+    # Groq
+    GROQ_API_KEY: str = os.getenv("GROQ_API_KEY", "")
+    GROQ_MODEL_NAME: str = os.getenv("GROQ_MODEL_NAME", "llama-3.1-8b-instant")
+    
+    # Database
+    BASE_DIR: str = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    SQLITE_DB_PATH: str = os.path.join(BASE_DIR, "data", "users.db")
+    
+    USE_POSTGRES: bool = os.getenv("USE_POSTGRES", "false").lower() == "true"
+    POSTGRES_USER: str = os.getenv("POSTGRES_USER", "postgres")
+    POSTGRES_PASSWORD: str = os.getenv("POSTGRES_PASSWORD", "password")
+    POSTGRES_SERVER: str = os.getenv("POSTGRES_SERVER", "localhost")
+    POSTGRES_PORT: str = os.getenv("POSTGRES_PORT", "5432")
+    POSTGRES_DB: str = os.getenv("POSTGRES_DB", "legal_rag")
+
+    @property
+    def DATABASE_URL(self) -> str:
+        direct_url = os.getenv("DATABASE_URL")
+        if direct_url:
+            return direct_url
+        if self.USE_POSTGRES:
+            return f"postgresql://{self.POSTGRES_USER}:{self.POSTGRES_PASSWORD}@{self.POSTGRES_SERVER}:{self.POSTGRES_PORT}/{self.POSTGRES_DB}"
+        return f"sqlite:///{self.SQLITE_DB_PATH}"
+
+    QDRANT_URL: str = os.getenv("QDRANT_URL", "")  # e.g. http://qdrant:6333 for Docker
+    QDRANT_API_KEY: str = os.getenv("QDRANT_API_KEY", "")
+    QDRANT_PATH: str = "qdrant_storage"
+    COLLECTION_NAME: str = "legal_rag"
+    
+    # Chunking
+    PARENT_CHUNK_SIZE: int = int(os.getenv("PARENT_CHUNK_SIZE", 1500))
+    PARENT_CHUNK_OVERLAP: int = int(os.getenv("PARENT_CHUNK_OVERLAP", 200))
+    CHILD_CHUNK_SIZE: int = int(os.getenv("CHILD_CHUNK_SIZE", 400))
+    CHILD_CHUNK_OVERLAP: int = int(os.getenv("CHILD_CHUNK_OVERLAP", 100))
+    
+    @field_validator("SECRET_KEY")
+    @classmethod
+    def check_secret_key(cls, v: str) -> str:
+        if v == "legal-rag-secret-2026" or len(v) < 32:
+            import sys
+            print(
+                "\n⚠️  [SECURITY WARNING] INSECURE SECRET_KEY DETECTED!\n"
+                f"Current SECRET_KEY is either the default template value or too short ({len(v)} chars).\n"
+                "For production, please generate a secure 32-character hex key using:\n"
+                "  python -c \"import secrets; print(secrets.token_hex(32))\"\n"
+                "and set it as SECRET_KEY in your .env file.\n",
+                file=sys.stderr
+            )
+        return v
+    
+    class Config:
+        case_sensitive = True
+
+settings = Settings()

backend/app/core/security.py

@@ -0,0 +1,44 @@
+from datetime import datetime, timedelta, timezone
+# Reference: https://fastapi.tiangolo.com/tutorial/security/
+from typing import Any, Union
+from jose import jwt
+import bcrypt
+from passlib.context import CryptContext
+from .config import settings
+
+# Graceful legacy verifier for pbkdf2_sha256 hashes in database
+legacy_context = CryptContext(schemes=["pbkdf2_sha256"])
+
+def create_access_token(subject: Union[str, Any], expires_delta: timedelta = None) -> str:
+    # Use modern timezone-aware UTC datetime (Python 3.12+ standard)
+    now = datetime.now(timezone.utc)
+    if expires_delta:
+        expire = now + expires_delta
+    else:
+        expire = now + timedelta(
+            minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES
+        )
+    to_encode = {"exp": expire, "sub": str(subject)}
+    encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
+    return encoded_jwt
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    try:
+        # If it's a legacy pbkdf2 hash, verify with passlib legacy context
+        if hashed_password.startswith("$pbkdf2-sha256"):
+            return legacy_context.verify(plain_password, hashed_password)
+        # Otherwise, verify using standard native bcrypt
+        return bcrypt.checkpw(
+            plain_password.encode("utf-8"),
+            hashed_password.encode("utf-8")
+        )
+    except Exception as e:
+        print(f"[-] Password verification error: {e}")
+        return False
+
+def get_password_hash(password: str) -> str:
+    # Hash password using native bcrypt (highly secure and fully compatible with Python 3.12+)
+    pwd_bytes = password.encode("utf-8")
+    salt = bcrypt.gensalt()
+    hashed = bcrypt.hashpw(pwd_bytes, salt)
+    return hashed.decode("utf-8")

backend/app/core/utils.py

@@ -0,0 +1,19 @@
+import re
+
+def clean_filename(filename: str) -> str:
+    """Strips the temp_UUID_ prefix from legacy filenames."""
+    if filename.startswith("temp_") and len(filename) > 42:
+        parts = filename.split("_", 2)
+        if len(parts) > 2:
+            return parts[2]
+    return filename
+
+def build_chat_title_fallback(query: str) -> str:
+    cleaned = re.sub(r"\s+", " ", query or "").strip()
+    cleaned = cleaned.rstrip("?.!,:;")
+    words = cleaned.split(" ")
+    short_words = words[:8]
+    title = " ".join(short_words)
+    if len(words) > 8 or len(cleaned) > len(title):
+        title = f"{title}..."
+    return title[:60]

backend/app/db/base_class.py

@@ -0,0 +1,11 @@
+from typing import Any
+from sqlalchemy.ext.declarative import as_declarative, declared_attr
+
+@as_declarative()
+class Base:
+    id: Any
+    __name__: str
+    # Generate __tablename__ automatically
+    @declared_attr
+    def __tablename__(cls) -> str:
+        return cls.__name__.lower()

backend/app/db/init_db.py

@@ -0,0 +1,122 @@
+from qdrant_client.http import models as rest
+from langchain_qdrant import QdrantVectorStore
+from qdrant_client import QdrantClient
+from .session import engine
+from .base_class import Base
+from ..core.config import settings
+# Import all models to ensure they are registered with Base
+from ..models.user import User
+from ..models.document import Document
+from ..models.chat import ChatSession, ChatMessage
+import sqlalchemy as sa
+import datetime
+
+def safe_migrate():
+    """Add new columns to existing tables without destroying data."""
+    with engine.connect() as conn:
+        inspector = sa.inspect(engine)
+        
+        # Documents migration
+        existing_doc_cols = [c['name'] for c in inspector.get_columns('documents')]
+        if 'chunk_count' not in existing_doc_cols:
+            conn.execute(sa.text("ALTER TABLE documents ADD COLUMN chunk_count INTEGER"))
+        if 'embed_time_seconds' not in existing_doc_cols:
+            conn.execute(sa.text("ALTER TABLE documents ADD COLUMN embed_time_seconds REAL"))
+            
+        # Users migration
+        existing_user_cols = [c['name'] for c in inspector.get_columns('users')]
+        if 'is_active' not in existing_user_cols:
+            # Use 1 for SQLite, TRUE for Postgres
+            default_val = "TRUE" if settings.USE_POSTGRES else "1"
+            conn.execute(sa.text(f"ALTER TABLE users ADD COLUMN is_active BOOLEAN DEFAULT {default_val}"))
+        if 'email' not in existing_user_cols:
+            conn.execute(sa.text("ALTER TABLE users ADD COLUMN email TEXT UNIQUE"))
+            
+        conn.commit()
+
+def init_db():
+    Base.metadata.create_all(bind=engine)
+    try:
+        safe_migrate()
+    except Exception as e:
+        print(f"Migration note: {e}")
+
+def get_qdrant_client():
+    if settings.QDRANT_URL:
+        return QdrantClient(url=settings.QDRANT_URL, api_key=settings.QDRANT_API_KEY or None)
+    if settings.QDRANT_PATH == ":memory:":
+         return QdrantClient(":memory:")
+    return QdrantClient(path=settings.QDRANT_PATH)
+
+q_client = get_qdrant_client()
+
+COLLECTION_NAME = settings.COLLECTION_NAME
+
+def init_qdrant():
+    global q_client
+    if not q_client.collection_exists(COLLECTION_NAME):
+        q_client.create_collection(
+            collection_name=COLLECTION_NAME,
+            vectors_config=rest.VectorParams(size=768, distance=rest.Distance.COSINE),
+        )
+    
+    # Run a lightweight backfill check for older documents
+    try:
+        backfill_missing_metadata()
+    except Exception as e:
+        print(f"Backfill error: {e}")
+
+def backfill_missing_metadata():
+    """Detects documents with missing total_pages/timestamp and repairs them."""
+    global q_client
+    offset = None
+    doc_stats = {} # filename -> max_page
+    points_to_fix = []
+    
+    # 1. Scan for missing data
+    while True:
+        res, offset = q_client.scroll(
+            collection_name=COLLECTION_NAME,
+            limit=100,
+            offset=offset,
+            with_payload=True,
+            with_vectors=False
+        )
+        for p in res:
+            meta = p.payload.get("metadata", {})
+            fname = meta.get("filename")
+            page = meta.get("page")
+            if fname:
+                if fname not in doc_stats: doc_stats[fname] = 0
+                if page and isinstance(page, int) and page > doc_stats[fname]:
+                    doc_stats[fname] = page
+                
+                if "total_pages" not in meta or "ingestion_timestamp" not in meta:
+                    points_to_fix.append(p)
+        if offset is None: break
+
+    if not points_to_fix:
+        return
+
+    print(f"Repairing metadata for {len(points_to_fix)} chunks...")
+    now = datetime.datetime.now().isoformat()
+    for p in points_to_fix:
+        meta = p.payload.get("metadata", {}).copy()
+        fname = meta.get("filename")
+        if "total_pages" not in meta:
+            meta["total_pages"] = doc_stats.get(fname, meta.get("page", 1))
+        if "ingestion_timestamp" not in meta:
+            meta["ingestion_timestamp"] = now
+            
+        q_client.set_payload(
+            collection_name=COLLECTION_NAME,
+            payload={"metadata": meta},
+            points=[p.id]
+        )
+
+def get_vector_store(embeddings):
+    return QdrantVectorStore(
+        client=q_client,
+        collection_name=COLLECTION_NAME,
+        embedding=embeddings,
+    )

backend/app/db/session.py

@@ -0,0 +1,26 @@
+import os
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from ..core.config import settings
+
+SQLALCHEMY_DATABASE_URL = settings.DATABASE_URL
+
+# Ensure data directory exists for SQLite
+if not settings.USE_POSTGRES:
+    os_path = os.path.dirname(settings.SQLITE_DB_PATH)
+    if os_path and not os.path.exists(os_path):
+        os.makedirs(os_path, exist_ok=True)
+
+connect_args = {"check_same_thread": False} if not settings.USE_POSTGRES else {}
+
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL, connect_args=connect_args
+)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

backend/app/main.py

@@ -0,0 +1,30 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from .api.api_v1.api import api_router
+from .core.config import settings
+from .db.init_db import init_db, init_qdrant
+import uvicorn
+import threading
+from .services.voice_service import voice_service
+
+app = FastAPI(title=settings.PROJECT_NAME)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.on_event("startup")
+async def startup_event():
+    init_db()
+    init_qdrant()
+    # Preload ASR/TTS models in a background thread to avoid blocking startup
+    threading.Thread(target=voice_service.preload_models, daemon=True).start()
+
+app.include_router(api_router)
+
+if __name__ == "__main__":
+    uvicorn.run("app.main:app", host="0.0.0.0", port=8001, reload=True)

backend/app/models/chat.py

@@ -0,0 +1,20 @@
+from sqlalchemy import Column, Integer, String, Text, DateTime
+from datetime import datetime
+from ..db.base_class import Base
+
+class ChatSession(Base):
+    __tablename__ = "chat_sessions"
+    id = Column(String, primary_key=True, index=True) # UUID
+    user_id = Column(String, index=True)
+    title = Column(String)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+class ChatMessage(Base):
+    __tablename__ = "chat_messages"
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(String, index=True)
+    session_id = Column(String, index=True)
+    role = Column(String)  # 'user' or 'assistant'
+    content = Column(Text)
+    sources = Column(Text, nullable=True)  # JSON string of sources
+    timestamp = Column(DateTime, default=datetime.utcnow)

backend/app/models/document.py

@@ -0,0 +1,13 @@
+from sqlalchemy import Column, Integer, String, DateTime, Float
+from datetime import datetime
+from ..db.base_class import Base
+
+class Document(Base):
+    __tablename__ = "documents"
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(String, index=True)
+    session_id = Column(String, index=True, nullable=True)
+    filename = Column(String)
+    upload_date = Column(DateTime, default=datetime.utcnow)
+    chunk_count = Column(Integer, nullable=True)
+    embed_time_seconds = Column(Float, nullable=True)

backend/app/models/user.py

@@ -0,0 +1,10 @@
+from sqlalchemy import Column, Integer, String, Boolean
+from ..db.base_class import Base
+
+class User(Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String, unique=True, index=True)
+    email = Column(String, unique=True, index=True)
+    hashed_password = Column(String)
+    is_active = Column(Boolean, default=True)

backend/app/schemas/chat.py

@@ -0,0 +1,33 @@
+from typing import List, Optional
+from pydantic import BaseModel
+from datetime import datetime
+
+class ChatQuery(BaseModel):
+    query: str
+    session_id: str
+    filename: Optional[str] = None
+
+class ChatMessageBase(BaseModel):
+    role: str
+    content: str
+    sources: Optional[str] = None
+
+class ChatMessage(ChatMessageBase):
+    id: int
+    user_id: str
+    session_id: str
+    timestamp: datetime
+
+    class Config:
+        from_attributes = True
+
+class ChatSessionBase(BaseModel):
+    id: str
+    title: str
+
+class ChatSession(ChatSessionBase):
+    user_id: str
+    created_at: datetime
+
+    class Config:
+        from_attributes = True

backend/app/schemas/document.py

@@ -0,0 +1,16 @@
+from typing import Optional
+from pydantic import BaseModel
+from datetime import datetime
+
+class DocumentBase(BaseModel):
+    filename: str
+    session_id: Optional[str] = None
+
+class DocumentCreate(DocumentBase):
+    user_id: str
+
+class Document(DocumentBase):
+    upload_date: datetime
+
+    class Config:
+        from_attributes = True

backend/app/schemas/token.py

@@ -0,0 +1,9 @@
+from typing import Optional
+from pydantic import BaseModel
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+class TokenPayload(BaseModel):
+    sub: Optional[str] = None

backend/app/schemas/user.py

@@ -0,0 +1,40 @@
+import re
+from typing import Optional
+from pydantic import BaseModel, ConfigDict, field_validator
+
+class UserBase(BaseModel):
+    username: Optional[str] = None
+    email: Optional[str] = None
+
+class UserCreate(UserBase):
+    username: str
+    email: str
+    password: str
+
+    @field_validator("password")
+    @classmethod
+    def password_complexity(cls, v: str) -> str:
+        if len(v) < 8:
+            raise ValueError("Password must be at least 8 characters long")
+        if not re.search(r"[A-Z]", v):
+            raise ValueError("Password must contain at least one uppercase letter")
+        if not re.search(r"\d", v):
+            raise ValueError("Password must contain at least one number")
+        if not re.search(r"[@$!%*?&]", v):
+            raise ValueError("Password must contain at least one special character (@$!%*?&)")
+        return v
+
+
+class UserUpdate(UserBase):
+    password: Optional[str] = None
+
+class UserInDBBase(UserBase):
+    id: Optional[int] = None
+    
+    model_config = ConfigDict(from_attributes=True)
+
+class User(UserInDBBase):
+    pass
+
+class UserInDB(UserInDBBase):
+    hashed_password: str

backend/app/services/pdf_processor.py

@@ -0,0 +1,76 @@
+import os
+import fitz  # PyMuPDF
+import datetime
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from ..core.config import settings
+
+def process_pdf(pdf_path: str, user_id: str, original_filename: str, session_id: str = None):
+    """
+    Extracts text from a PDF file, ignoring margins, and returns chunks with metadata.
+    """
+    parent_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=settings.PARENT_CHUNK_SIZE,
+        chunk_overlap=settings.PARENT_CHUNK_OVERLAP,
+        separators=["\n\n", "\n"]
+    )
+    child_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=settings.CHILD_CHUNK_SIZE,
+        chunk_overlap=settings.CHILD_CHUNK_OVERLAP,
+        separators=["\n", ". ", " ", ""]
+    )
+    
+    chunks_with_metadata = []
+    chunk_idx = 0
+    ingestion_time = datetime.datetime.now().isoformat()
+    try:
+        with fitz.open(pdf_path) as pdf:
+            total_pages = len(pdf)
+            for page_num, page in enumerate(pdf, start=1):
+                page_rect = page.rect
+                footer_threshold = page_rect.height * 0.97 
+                header_threshold = page_rect.height * 0.03
+                
+                blocks = page.get_text("blocks")
+                blocks.sort(key=lambda b: (b[1], b[0]))
+                
+                page_text = ""
+                for block in blocks:
+                    if block[1] > header_threshold and block[3] < footer_threshold:
+                        if block[6] == 0:  # text block
+                            page_text += block[4] + "\n"
+
+                if not page_text.strip():
+                    page_text = page.get_text("text")
+                
+                if not page_text.strip():
+                    continue
+                
+                parent_chunks = parent_splitter.split_text(page_text)
+                for p_chunk in parent_chunks:
+                    child_chunks = child_splitter.split_text(p_chunk)
+                    for c_chunk in child_chunks:
+                        chunk_idx += 1
+                        metadata = {
+                            "page": page_num,
+                            "total_pages": total_pages,
+                            "chunk_number": chunk_idx,
+                            "user_id": str(user_id),
+                            "filename": original_filename,
+                            "parent_text": p_chunk,
+                            "ingestion_timestamp": ingestion_time,
+                            "embedding_model": settings.EMBEDDING_MODEL_NAME,
+                            "chunk_size": settings.CHILD_CHUNK_SIZE,
+                            "chunk_overlap": settings.CHILD_CHUNK_OVERLAP,
+                            "file_type": "pdf"
+                        }
+                        if session_id:
+                            metadata["session_id"] = session_id
+                            
+                        chunks_with_metadata.append({
+                            "text": c_chunk,
+                            "metadata": metadata
+                        })
+        return chunks_with_metadata
+    except Exception as e:
+        print(f"Error processing PDF {pdf_path}: {e}")
+        return []

backend/app/services/rag_service.py

@@ -0,0 +1,238 @@
+import os
+import logging
+import torch
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_groq import ChatGroq
+from langchain_core.messages import HumanMessage, SystemMessage
+from sentence_transformers import CrossEncoder
+from ..core.config import settings
+import langsmith as ls
+from langsmith import traceable
+
+# Suppress noisy logs
+logging.getLogger("sentence_transformers").setLevel(logging.ERROR)
+logging.getLogger("transformers").setLevel(logging.ERROR)
+
+class ResilientLLMProxy:
+    """
+    A transparent proxy wrapper for LangChain chat models that provides 
+    resilient runtime failover. If the primary LLM fails (e.g. rate limit, 
+    service down), it automatically switches to the backup LLM.
+    """
+    def __init__(self, primary, backup=None):
+        self.primary = primary
+        self.backup = backup
+
+    def invoke(self, *args, **kwargs):
+        try:
+            return self.primary.invoke(*args, **kwargs)
+        except Exception as e:
+            if self.backup:
+                print(f"\n⚠️ [RUNTIME FAILOVER] Primary LLM ({type(self.primary).__name__}) failed: {e}.\n"
+                      f"🔄 Falling back to Backup LLM ({type(self.backup).__name__})...")
+                return self.backup.invoke(*args, **kwargs)
+            raise e
+
+    async def ainvoke(self, *args, **kwargs):
+        try:
+            return await self.primary.ainvoke(*args, **kwargs)
+        except Exception as e:
+            if self.backup:
+                print(f"\n⚠️ [RUNTIME FAILOVER] Primary LLM ({type(self.primary).__name__}) failed: {e}.\n"
+                      f"🔄 Falling back to Backup LLM ({type(self.backup).__name__})...")
+                return await self.backup.ainvoke(*args, **kwargs)
+            raise e
+
+    async def astream(self, *args, **kwargs):
+        try:
+            async for chunk in self.primary.astream(*args, **kwargs):
+                yield chunk
+        except Exception as e:
+            if self.backup:
+                print(f"\n⚠️ [RUNTIME FAILOVER] Primary LLM ({type(self.primary).__name__}) streaming failed: {e}.\n"
+                      f"🔄 Falling back to Backup LLM ({type(self.backup).__name__})...")
+                async for chunk in self.backup.astream(*args, **kwargs):
+                    yield chunk
+            else:
+                raise e
+
+    def stream(self, *args, **kwargs):
+        try:
+            for chunk in self.primary.stream(*args, **kwargs):
+                yield chunk
+        except Exception as e:
+            if self.backup:
+                print(f"\n⚠️ [RUNTIME FAILOVER] Primary LLM ({type(self.primary).__name__}) streaming failed: {e}.\n"
+                      f"🔄 Falling back to Backup LLM ({type(self.backup).__name__})...")
+                for chunk in self.backup.stream(*args, **kwargs):
+                    yield chunk
+            else:
+                raise e
+
+class RAGService:
+    def __init__(self):
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Loading {settings.EMBEDDING_MODEL_NAME} on {device}...")
+        self.embeddings = HuggingFaceEmbeddings(
+            model_name=settings.EMBEDDING_MODEL_NAME,
+            model_kwargs={"device": device}
+        )
+        
+        print(f"Loading {settings.RERANKER_MODEL_NAME} on {device}...")
+        self.reranker = CrossEncoder(
+            settings.RERANKER_MODEL_NAME, 
+            trust_remote_code=True,
+            device=device,
+            automodel_args={"torch_dtype": torch.float16}
+        )
+        
+        # Initialize Resilient LLMs
+        self.llm = self._setup_llms()
+
+    def _setup_llms(self):
+        # Diagnostics
+        groq_key_len = len(settings.GROQ_API_KEY) if settings.GROQ_API_KEY else 0
+        gemini_key_len = len(settings.GEMINI_API_KEY) if settings.GEMINI_API_KEY else 0
+        print(f"[DIAGNOSTICS] ACTIVE_LLM: {settings.ACTIVE_LLM}")
+        print(f"[DIAGNOSTICS] GROQ_API_KEY length: {groq_key_len}, model: {settings.GROQ_MODEL_NAME}")
+        print(f"[DIAGNOSTICS] GEMINI_API_KEY length: {gemini_key_len}, model: {settings.LLM_MODEL_NAME}")
+
+        # 1. Initialize Groq model if key is present
+        groq_model = None
+        if settings.GROQ_API_KEY:
+            try:
+                groq_model = ChatGroq(
+                    model_name=settings.GROQ_MODEL_NAME,
+                    temperature=settings.LLM_TEMPERATURE,
+                    groq_api_key=settings.GROQ_API_KEY,
+                    max_retries=settings.LLM_MAX_RETRIES
+                )
+                print("[+] Groq model initialized successfully.")
+            except Exception as e:
+                import traceback
+                print(f"[-] Failed to initialize Groq model: {e}")
+                traceback.print_exc()
+
+        # 2. Initialize Gemini model if key is present
+        gemini_model = None
+        if settings.GEMINI_API_KEY:
+            try:
+                gemini_model = ChatGoogleGenerativeAI(
+                    model=settings.LLM_MODEL_NAME, 
+                    google_api_key=settings.GEMINI_API_KEY,
+                    temperature=settings.LLM_TEMPERATURE,
+                    max_retries=settings.LLM_MAX_RETRIES
+                )
+                print("[+] Gemini model initialized successfully.")
+            except Exception as e:
+                import traceback
+                print(f"[-] Failed to initialize Gemini model: {e}")
+                traceback.print_exc()
+
+        # 3. Configure primary and backup models based on active preference
+        primary = None
+        backup = None
+
+        if settings.ACTIVE_LLM == "groq" and groq_model:
+            primary = groq_model
+            backup = gemini_model
+        elif gemini_model:
+            primary = gemini_model
+            backup = groq_model
+        else:
+            primary = groq_model or gemini_model
+            backup = None
+
+        if not primary:
+            raise ValueError(
+                f"CRITICAL: No LLM models could be initialized! Please configure at least "
+                f"one valid API key (GEMINI_API_KEY or GROQ_API_KEY) in your environment. "
+                f"Diagnostics: Groq Key Length={groq_key_len}, Gemini Key Length={gemini_key_len}"
+            )
+
+        print(f"[+] Resilient LLM System loaded successfully.")
+        print(f"    - Primary Provider: {type(primary).__name__} (Model: {getattr(primary, 'model_name', getattr(primary, 'model', 'default'))})")
+        print(f"    - Backup Provider: {type(backup).__name__ if backup else 'None'}")
+        
+        return ResilientLLMProxy(primary=primary, backup=backup)
+
+    @traceable
+    def rerank_results(self, query, candidates):
+        if not candidates:
+            return []
+        try:
+            cross_inp = [[query, c] for c in candidates]
+            scores = self.reranker.predict(cross_inp, batch_size=16, show_progress_bar=False, convert_to_tensor=True)
+            return scores.tolist()
+        except Exception as e:
+            print(f"Reranker Error: {e}. Falling back to default order.")
+            return [1.0 - (i * 0.01) for i in range(len(candidates))]
+
+    def detect_intent(self, query: str) -> str:
+        query = query.lower()
+        if any(word in query for word in ["summary", "summarize", "brief", "overview"]):
+            return "SUMMARY"
+        elif any(word in query for word in ["judgment", "outcome", "verdict", "decision"]):
+            return "JUDGMENT"
+        elif any(word in query for word in ["fact", "evidence", "background"]):
+            return "FACTS"
+        elif any(word in query for word in ["why", "reasoning", "analysis"]):
+            return "REASONING"
+        else:
+            return "GENERAL"
+
+    def get_dynamic_prompt(self, intent: str):
+        base_rules = """
+        CRITICAL RULES:
+        1. Base your answer strictly on context.
+        2. MISSING INFO: Answer naturally based ONLY on context, don't use repetitive disclaimers.
+        3. LEGAL ONLY: If context isn't legal, refuse.
+        4. STYLE: Plain text only. No markdown, no bold, no lists. Follow the requested intent in your tone.
+        """
+        prompts = {
+            "SUMMARY": f"You are a Legal Clerk. Summarize the case background, issue, and outcome. {base_rules}",
+            "JUDGMENT": f"You are a Judge. State the final legal outcome clearly. {base_rules}",
+            "FACTS": f"You are a Legal Researcher. Extract facts and evidence. {base_rules}",
+            "REASONING": f"You are a Constitutional Expert. Explain the reasoning behind the decision. {base_rules}",
+            "GENERAL": f"You are a Legal Assistant. Answer the question based on context. {base_rules}"
+        }
+        return prompts.get(intent, prompts["GENERAL"])
+
+    @traceable
+    async def generate_answer_stream(self, query, context_list, brief=False, trace_metadata=None):
+        intent = self.detect_intent(query)
+        context_str = "\n\n".join(context_list)
+        system_prompt = self.get_dynamic_prompt(intent)
+        
+        if brief:
+            system_prompt += "\nINSTRUCTION: Be extremely concise. Focus strictly on the provided context."
+
+        user_prompt = f"CONTEXT:\n{context_str}\n\nUSER QUESTION: {query}\n\nANSWER BASED ON INTENT ({intent}):"
+        
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=user_prompt)
+        ]
+        
+        async for chunk in self.llm.astream(messages, config={"metadata": trace_metadata}):
+            yield chunk.content
+
+    def validate_is_legal(self, text_sample: str) -> bool:
+        if not text_sample or len(text_sample.strip()) < 50:
+            return True # Conservative default
+        
+        prompt = (
+            "You are a legal document auditor. Is the following text sample from a legal or quasi-legal document? "
+            "Count official court judgments, statutes, case summaries, legal commentaries, contracts, and academic legal articles as YES. "
+            "Reject unrelated technical manuals, personal letters, or general news that doesn't reference specific law. "
+            "Respond with 'YES' or 'NO' only.\n\n"
+            f"TEXT SAMPLE:\n{text_sample[:1200]}"
+        )
+        try:
+            response = self.llm.invoke(prompt)
+            return "YES" in response.content.upper()
+        except:
+            return True
+
+rag_service = RAGService()

backend/app/services/tts.py

@@ -0,0 +1,331 @@
+import warnings
+import threading
+import queue
+import time
+import io
+import numpy as np
+import sounddevice as sd
+import re
+import datetime
+
+warnings.filterwarnings("ignore")
+
+
+_kokoro_pipeline = None
+_qwen_tts_model = None
+SPEECH_SPEED = 1  # Slower than default 1.0
+
+def clean_text_for_speech(text: str) -> str:
+    """Removes citations and other non-spoken markers from text, and formats dates."""
+    if not text:
+        return ""
+    
+    # 1. Format Dates (DD.MM.YYYY -> Month Day, Year)
+    date_pattern = r'\b(\d{1,2})[./-](\d{1,2})[./-](\d{4})\b'
+    
+    def date_replacer(match):
+        d_str, m_str, y_str = match.groups()
+        try:
+            d, m, y = int(d_str), int(m_str), int(y_str)
+            dt = datetime.date(y, m, d)
+            return dt.strftime("%B %d, %Y")
+        except:
+            return match.group(0)
+    
+    text = re.sub(date_pattern, date_replacer, text)
+
+    # 2. Aggressive Source Removal
+    # Matches anything in brackets/parens that looks like a PDF reference or Page citation
+    source_patterns = [
+        r'\[[^\]]*?(?:\.pdf|Pages?:|Source:)[^\]]*?\]',
+        r'\([^)]*?(?:\.pdf|Pages?:|Source:)[^)]*?\)'
+    ]
+    for pattern in source_patterns:
+        text = re.sub(pattern, '', text, flags=re.IGNORECASE | re.DOTALL)
+    
+    # 3. Fix All-Caps Pronunciation (e.g., SUNITA -> Sunita)
+    # TTS engines often spell out ALL CAPS words letter-by-letter. 
+    # Converting words > 2 chars to Title Case fixes this.
+    def to_title_case(match):
+        word = match.group(0)
+        if len(word) > 2:
+            return word.capitalize()
+        return word
+    
+    text = re.sub(r'\b[A-Z]{3,}\b', to_title_case, text)
+
+    # 4. Remove standard citation markers [1], (1)
+    text = re.sub(r'\[\d+\]', '', text)
+    text = re.sub(r'\(\d+\)', '', text)
+    
+    # Cleanup extra whitespace
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+class AudioPlayer:
+    def __init__(self):
+        self.queue = queue.Queue()
+        self.stop_event = threading.Event()
+        self.is_playing = False
+        self._thread = None
+
+    def _play_loop(self):
+        while not self.stop_event.is_set():
+            try:
+                # Use a timeout to occasionally check the stop_event
+                audio, sr = self.queue.get(timeout=0.5)
+                if audio is not None:
+                    try:
+                        
+                        self.is_playing = True
+                        sd.play(audio, sr)
+                        # We need a way to wait for playback OR stop
+                        # sd.wait() blocks everything, so we'll poll sd.get_stream().active
+                        while sd.get_stream().active and not self.stop_event.is_set():
+                            time.sleep(0.1)
+                        
+                        if self.stop_event.is_set():
+                            sd.stop()
+                    except ImportError:
+                        print("sounddevice not installed, local playback skipped")
+                    
+                    self.queue.task_done()
+                    self.is_playing = False
+            except queue.Empty:
+                if self.stop_event.is_set():
+                    break
+                continue
+        
+        self.is_playing = False
+        # Clear the queue
+        while not self.queue.empty():
+            try:
+                self.queue.get_nowait()
+                self.queue.task_done()
+            except queue.Empty:
+                break
+
+    def start(self):
+        self.stop_event.clear()
+        if self._thread is None or not self._thread.is_alive():
+            self._thread = threading.Thread(target=self._play_loop, daemon=True)
+            self._thread.start()
+
+    def stop(self):
+        self.stop_event.set()
+        try:
+            
+            sd.stop()
+        except ImportError:
+            pass
+        if self._thread:
+            self._thread.join(timeout=1)
+        self.is_playing = False
+
+    def add_to_queue(self, audio, sr):
+        self.queue.put((audio, sr))
+
+_player = AudioPlayer()
+
+def get_kokoro_pipeline():
+    global _kokoro_pipeline
+    if _kokoro_pipeline is None:
+        from kokoro import KPipeline
+        try:
+            # In newer kokoro versions, repo_id is not a parameter and it defaults to hexgrad/Kokoro-82M
+            _kokoro_pipeline = KPipeline(lang_code='a')
+        except TypeError:
+            _kokoro_pipeline = KPipeline(repo_id="hexgrad/Kokoro-82M", lang_code='a')
+    return _kokoro_pipeline
+
+def get_qwen_tts_model():
+    global _qwen_tts_model
+    if _qwen_tts_model is None:
+        import torch
+        from qwen_tts import Qwen3TTSModel
+        
+        # Use float16 for better memory efficiency and speed if CUDA is available
+        dtype = torch.float16 if torch.cuda.is_available() else torch.float32
+        
+        print(f"Initializing Qwen3-TTS (dtype={dtype})...")
+        _qwen_tts_model = Qwen3TTSModel.from_pretrained(
+            "Qwen/Qwen3-TTS-12Hz-0.6B-CustomVoice",
+            device_map="auto",  # Let accelerate handle optimal placement
+            dtype=dtype,                      
+            attn_implementation="eager",
+        )
+    return _qwen_tts_model
+
+def generate_audio(text):
+    text = clean_text_for_speech(text)
+    model = get_qwen_tts_model()
+    wavs, sr = model.generate_custom_voice(
+        text=[text],
+        language=["english"],          
+        speaker=["sohee"],    
+        instruct=None    
+    )
+    _player.start()
+    _player.add_to_queue(wavs[0], sr)
+
+def audio_generate(text):
+    text = clean_text_for_speech(text)
+    pipeline = get_kokoro_pipeline()
+    voice = "af_sarah"   
+
+    # Start the player thread
+    _player.start()
+    
+    # 🔊 Generate chunks asynchronously
+    generator = pipeline(text, voice=voice, speed=SPEECH_SPEED)
+
+    for i, (gs, ps, audio) in enumerate(generator):
+        if _player.stop_event.is_set():
+            break
+        print(f"Chunk {i} ready and queued")
+        _player.add_to_queue(audio, 24000)
+
+def get_tts_wav(text):
+    text = clean_text_for_speech(text)
+    pipeline = get_kokoro_pipeline()
+    voice = "af_sarah"   
+    
+    # Generate all chunks
+    generator = pipeline(text, voice=voice, speed=SPEECH_SPEED)
+    all_chunks = []
+    for gs, ps, audio in generator:
+        all_chunks.append(audio)
+    
+    if not all_chunks:
+        return None
+        
+    # Concatenate all chunks
+    full_audio = np.concatenate(all_chunks)
+    
+    # Write to BytesIO buffer as WAV
+    buffer = io.BytesIO()
+    import soundfile as sf
+    sf.write(buffer, full_audio, 24000, format='WAV')
+    buffer.seek(0)
+    return buffer.read()
+
+def stream_tts_wav_chunks(text, cancel_event=None):
+    # Important: Do NOT clean the entire block at once. 
+    # We need to keep the raw sentence for the frontend highlighter.
+    pipeline = get_kokoro_pipeline()
+    voice = "af_sarah"   
+    # 1. Split RAW text into sentences while protecting legal abbreviations
+    # Standard Python 're' doesn't support variable-width lookbehind, 
+    # so we use a 'Protection' strategy.
+    protected_text = text
+    abbreviations = ['No', 'v', 'vs', 'Art', 'Sec', 'para', 'exh', 'cl', 'st', 'adv', 'cr', 'rev', 'app', 'spl', 'petn', 'writ', 'pil', 'scc', 'air', 'scr', 'ilr', 'guj', 'bom', 'del', 'Mr', 'Mrs', 'Ms', 'Dr', 'Justice', 'Hon', 'Honble', 'Honourable', 'Chief']
+    
+    # Temporarily hide the periods in abbreviations
+    for abbr in abbreviations:
+        # Match 'No.' but not 'No' inside a word
+        protected_text = re.sub(rf'\b{abbr}\.', f'{abbr}@@@', protected_text, flags=re.IGNORECASE)
+    
+    # Protect Initials (e.g., D.N. Ray)
+    # This matches a single capital letter followed by a period
+    protected_text = re.sub(r'\b([A-Z])\.', r'\1@@@', protected_text)
+    
+    # Now split safely
+    split_chunks = re.split(r'(?<=[.!?])\s+', protected_text)
+    
+    # Restore the periods and clean up
+    raw_sentences = []
+    for chunk in split_chunks:
+        s = chunk.replace('@@@', '.').strip()
+        if s:
+            raw_sentences.append(s)
+    
+    if not raw_sentences:
+        return
+
+    import soundfile as sf
+    import io
+    import base64
+    import json
+    import threading
+    import queue
+
+    import numpy as np
+    q = queue.Queue(maxsize=10)
+    stop_signal = threading.Event()
+
+    def producer():
+        try:
+            for s_raw in raw_sentences:
+                # Check ALL stop conditions: internal stop, global stop, or client disconnect
+                if stop_signal.is_set() or _player.stop_event.is_set() or (cancel_event and cancel_event.is_set()):
+                    break
+                
+                # 2. Clean ONLY for speech engine
+                s_clean = clean_text_for_speech(s_raw)
+                if not s_clean:
+                    continue
+
+                generator = pipeline(s_clean, voice=voice, speed=SPEECH_SPEED)
+                sentence_audio_chunks = []
+                for gs, ps, audio in generator:
+                    if (cancel_event and cancel_event.is_set()) or _player.stop_event.is_set():
+                        break
+                    sentence_audio_chunks.append(audio)
+                
+                if sentence_audio_chunks:
+                    # Aggregate all grains of the sentence into ONE continuous array
+                    # This eliminates breaks/pauses inside the sentence.
+                    full_audio = np.concatenate(sentence_audio_chunks)
+                    
+                    buffer = io.BytesIO()
+                    sf.write(buffer, full_audio, 24000, format='WAV')
+                    buffer.seek(0)
+                    audio_bytes = buffer.read()
+                    q.put((s_raw, audio_bytes))
+            q.put(None)
+        except Exception as e:
+            print(f"TTS Producer error: {e}")
+            q.put(None)
+
+    worker = threading.Thread(target=producer, daemon=True)
+    worker.start()
+
+    try:
+        while True:
+            item = q.get()
+            if item is None:
+                break
+            
+            s, audio_bytes = item
+            audio_b64 = base64.b64encode(audio_bytes).decode('utf-8')
+            
+            # Yield as NDJSON event with text metadata for highlighting
+            yield json.dumps({"audio": audio_b64, "text": s}) + "\n"
+    finally:
+        stop_signal.set()
+        # Drain the queue if needed
+        while not q.empty():
+            q.get_nowait()
+
+def warm_up_tts():
+    """Initializes the TTS pipeline with a dummy generation to remove cold-start latency."""
+    print("Pre-warming TTS Engine...")
+    try:
+        pipeline = get_kokoro_pipeline()
+        # Single very short generation to trigger model weights loading
+        list(pipeline("Warmup.", voice="af_sarah", speed=1.0))
+        print("TTS Engine warmed up and ready.")
+    except Exception as e:
+        print(f"TTS Warmup failed: {e}")
+
+def stop_audio():
+    _player.stop()
+
+def is_audio_playing():
+    return _player.is_playing or not _player.queue.empty()
+
+
+if __name__ == "__main__":
+    audio_generate("She said she would be here by noon.")
+    # wavs, sr = generate_audio("She said she would be here by noon.")
+    

backend/app/services/voice_service.py

@@ -0,0 +1,159 @@
+import os
+import threading
+import tempfile
+import wave
+import pyaudio
+import torch
+from typing import Optional
+from ..core.config import settings
+
+SAMPLE_RATE = 16000
+CHUNK = 1024
+CHANNELS = 1
+FORMAT = pyaudio.paInt16
+
+class VoiceService:
+    def __init__(self):
+        self.frames = []
+        self.is_recording = False
+        self.thread = None
+        self.stream = None
+        self.pa = None
+        self.lock = threading.Lock()
+        self.thread_started = threading.Event()
+        self._asr_model = None
+
+    def start_recording(self):
+        with self.lock:
+            if self.is_recording:
+                return {"status": "already_recording"}
+            self.frames = []
+            self.is_recording = True
+            self.thread_started.clear()
+            self.pa = pyaudio.PyAudio()
+            self.stream = self.pa.open(
+                format=FORMAT,
+                channels=CHANNELS,
+                rate=SAMPLE_RATE,
+                input=True,
+                frames_per_buffer=CHUNK,
+            )
+
+        def _capture():
+            self.thread_started.set()
+            while self.is_recording:
+                try:
+                    data = self.stream.read(CHUNK, exception_on_overflow=False)
+                    with self.lock:
+                        if self.is_recording:
+                            self.frames.append(data)
+                except:
+                    break
+            self.thread_started.set()
+
+        self.thread = threading.Thread(target=_capture, daemon=False)
+        self.thread.start()
+        self.thread_started.wait(timeout=1)
+        return {"status": "recording_started"}
+
+    def stop_recording(self) -> str:
+        with self.lock:
+            if not self.is_recording:
+                raise RuntimeError("No active recording.")
+            self.is_recording = False
+
+        if self.thread and self.thread.is_alive():
+            self.thread.join(timeout=2)
+
+        with self.lock:
+            if self.stream:
+                self.stream.stop_stream()
+                self.stream.close()
+            if self.pa:
+                self.pa.terminate()
+            frames = list(self.frames)
+            self.thread = None
+            self.stream = None
+            self.pa = None
+
+        if not frames:
+            raise RuntimeError("No audio captured.")
+        
+        tmp = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
+        with wave.open(tmp.name, "wb") as wf:
+            wf.setnchannels(CHANNELS)
+            wf.setsampwidth(pyaudio.PyAudio().get_sample_size(FORMAT))
+            wf.setframerate(SAMPLE_RATE)
+            wf.writeframes(b"".join(frames))
+        return tmp.name
+
+    def preload_models(self):
+        """Preloads ASR and TTS models into memory/GPU."""
+        print(f"Loading Qwen3-ASR...")
+        self._load_asr_model()
+        
+        print(f"Loading Kokoro TTS...")
+        from .tts import warm_up_tts
+        warm_up_tts()
+
+    def _load_asr_model(self):
+        if self._asr_model:
+            return self._asr_model
+        from qwen_asr import Qwen3ASRModel
+        
+        # Use float16 for better memory efficiency and speed if CUDA is available
+        dtype = torch.float16 if torch.cuda.is_available() else torch.float32
+        
+        print(f"Initializing Qwen3-ASR (dtype={dtype})...")
+        self._asr_model = Qwen3ASRModel.from_pretrained(
+            "Qwen/Qwen3-ASR-0.6B", 
+            torch_dtype=dtype,
+            device_map="auto"  # Let accelerate handle optimal placement
+        )
+        return self._asr_model
+
+    def transcribe(self, audio_path: str) -> str:
+        model = self._load_asr_model()
+        result = model.transcribe(audio_path, language="English")
+        if not result: return ""
+        item = result[0] if isinstance(result, list) else result
+        return getattr(item, 'text', str(item))
+
+    def create_voice_router(self):
+        from fastapi import APIRouter, HTTPException, UploadFile, File
+        from pydantic import BaseModel
+        
+        router = APIRouter(prefix="/voice", tags=["voice"])
+        
+        class TranscriptionResponse(BaseModel):
+            query: str
+            status: str
+
+        @router.post("/start")
+        def voice_start():
+            return self.start_recording()
+
+        @router.post("/stop", response_model=TranscriptionResponse)
+        def voice_stop():
+            path = self.stop_recording()
+            try:
+                text = self.transcribe(path)
+                return TranscriptionResponse(query=text, status="ok" if text.strip() else "no_speech")
+            finally:
+                os.unlink(path)
+
+        @router.post("/transcribe", response_model=TranscriptionResponse)
+        async def voice_transcribe(file: UploadFile = File(...)):
+            suffix = os.path.splitext(file.filename or "")[1] or ".webm"
+            with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as tmp:
+                tmp.write(await file.read())
+                tmp_path = tmp.name
+            try:
+                text = self.transcribe(tmp_path)
+                return TranscriptionResponse(query=text, status="ok" if text.strip() else "no_speech")
+            finally:
+                os.unlink(tmp_path)
+        
+        return router
+
+voice_service = VoiceService()

docker-compose.yml

@@ -0,0 +1,84 @@
+services:
+  # ── Qdrant Vector Database ──────────────────────────────────────────────────
+  qdrant:
+    image: qdrant/qdrant:latest
+    container_name: rag_qdrant
+    restart: unless-stopped
+    ports:
+      - "6333:6333"   # HTTP API
+      - "6334:6334"   # gRPC API
+    volumes:
+      - qdrant_data:/qdrant/storage
+    healthcheck:
+      test: ["CMD-SHELL", "bash -c 'echo > /dev/tcp/localhost/6333' 2>/dev/null && exit 0 || exit 1"]
+      interval: 10s
+      timeout: 5s
+      retries: 10
+      start_period: 20s
+
+  # ── PostgreSQL (optional – only used when USE_POSTGRES=true) ────────────────
+  postgres:
+    image: postgres:16-alpine
+    container_name: rag_postgres
+    restart: unless-stopped
+    environment:
+      POSTGRES_USER: ${POSTGRES_USER:-postgres}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-password}
+      POSTGRES_DB: ${POSTGRES_DB:-legal_rag}
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-postgres}"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+  # ── FastAPI Backend ─────────────────────────────────────────────────────────
+  backend:
+    build:
+      context: .               # project root — gives access to requirements.txt
+      dockerfile: backend/Dockerfile
+    container_name: rag_backend
+    restart: unless-stopped
+    env_file:
+      - .env
+    environment:
+      # Override DB host to point to the postgres container
+      POSTGRES_SERVER: postgres
+      # Point Qdrant client to the qdrant container over HTTP
+      QDRANT_URL: http://qdrant:6333
+    ports:
+      - "8001:8001"
+    volumes:
+      # Persist SQLite DB and uploaded documents
+      - backend_data:/app/app/data
+    depends_on:
+      qdrant:
+        condition: service_started
+      postgres:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8001/docs"]
+      interval: 20s
+      timeout: 15s
+      retries: 15
+      start_period: 300s   # InLegalBERT + BGE reranker can take 3-5 min to load
+
+  # ── React Frontend (Nginx) ──────────────────────────────────────────────────
+  frontend:
+    build:
+      context: ./frontend-react
+      dockerfile: Dockerfile
+    container_name: rag_frontend
+    restart: unless-stopped
+    ports:
+      - "8080:80"
+    depends_on:
+      - backend
+
+volumes:
+  qdrant_data:
+  postgres_data:
+  backend_data:

frontend-react/.dockerignore

@@ -0,0 +1,7 @@
+node_modules/
+dist/
+.env
+*.log
+.git/
+.gitignore
+README.md

frontend-react/Dockerfile

@@ -0,0 +1,27 @@
+# ── Stage 1: Build React app ──────────────────────────────────────────────────
+FROM node:20-alpine AS builder
+
+WORKDIR /app
+
+COPY package.json package-lock.json ./
+RUN npm ci --frozen-lockfile
+
+COPY . .
+RUN npm run build
+
+
+# ── Stage 2: Serve with Nginx ─────────────────────────────────────────────────
+FROM nginx:alpine AS runtime
+
+# Remove default nginx config
+RUN rm /etc/nginx/conf.d/default.conf
+
+# Copy custom nginx config
+COPY nginx.conf /etc/nginx/conf.d/app.conf
+
+# Copy built React app
+COPY --from=builder /app/dist /usr/share/nginx/html
+
+EXPOSE 80
+
+CMD ["nginx", "-g", "daemon off;"]

frontend-react/index.html

@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8" />
+  <link rel="icon" type="image/svg+xml" href="favicon.svg" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Legal Case Law RAG</title>
+</head>
+
+<body>
+  <div id="root"></div>
+  <script type="module" src="/src/main.jsx"></script>
+</body>
+
+</html>

frontend-react/nginx.conf

@@ -0,0 +1,32 @@
+server {
+    listen 80;
+    server_name _;
+
+    root /usr/share/nginx/html;
+    index index.html;
+
+    # Proxy API calls to the FastAPI backend
+    location /api/ {
+        proxy_pass         http://backend:8001/;
+        proxy_http_version 1.1;
+        proxy_set_header   Host              $host;
+        proxy_set_header   X-Real-IP         $remote_addr;
+        proxy_set_header   X-Forwarded-For   $proxy_add_x_forwarded_for;
+        proxy_set_header   X-Forwarded-Proto $scheme;
+        proxy_read_timeout 120s;
+        proxy_send_timeout 120s;
+
+        # WebSocket / SSE support
+        proxy_set_header   Upgrade    $http_upgrade;
+        proxy_set_header   Connection "upgrade";
+    }
+
+    # Serve React SPA — fallback to index.html for client-side routing
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+
+    # Gzip compression
+    gzip on;
+    gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;
+}

frontend-react/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "frontend-react",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "lucide-react": "^1.8.0",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "react-markdown": "^10.1.0",
+    "rehype-raw": "^7.0.0",
+    "remark-gfm": "^4.0.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.4",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.0",
+    "eslint": "^9.39.4",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "globals": "^17.4.0",
+    "vite": "^8.0.0"
+  }
+}

frontend-react/src/App.css

@@ -0,0 +1,1459 @@
+@import url('https://fonts.googleapis.com/css2?family=Lora:ital,wght@0,400..700;1,400..700&family=Plus+Jakarta+Sans:ital,wght@0,200..800;1,200..800&display=swap');
+
+:root {
+  /* Premium Rich Dark Palette - Midnight Amethyst Theme */
+  --bg-deep: #05020c;
+  --bg-surface: #0c081f;
+  --bg-surface-elevated: #17113b;
+  --sidebar-bg: #080515;
+
+  /* Jewel Primary & Accents - Royalty Amethyst and Empire Amber/Gold */
+  --primary: #a855f7;
+  --primary-glow: rgba(168, 85, 247, 0.45);
+  --accent: #f59e0b;
+  --accent-glow: rgba(245, 158, 11, 0.35);
+
+  /* Text */
+  --text-primary: #f8fafc;
+  --text-secondary: #cbd5e1;
+  --text-muted: #71717a;
+
+  /* Premium Glassmorphism */
+  --glass-bg: rgba(12, 8, 31, 0.75);
+  --glass-border: rgba(168, 85, 247, 0.16);
+  --glass-blur: blur(16px);
+
+  /* Utility */
+  --border-radius: 14px;
+  --transition-fast: 0.25s cubic-bezier(0.4, 0, 0.2, 1);
+  --transition-slow: 0.45s cubic-bezier(0.4, 0, 0.2, 1);
+  --shadow-sm: 0 4px 8px -1px rgba(0, 0, 0, 0.2);
+  --shadow-lg: 0 12px 24px -3px rgba(0, 0, 0, 0.4);
+}
+
+* {
+  box-sizing: border-box;
+  -webkit-font-smoothing: antialiased;
+}
+
+body {
+  margin: 0;
+  padding: 0;
+  background-color: var(--bg-deep);
+  color: var(--text-primary);
+  font-family: 'Plus Jakarta Sans', system-ui, -apple-system, sans-serif;
+  overflow: hidden;
+  height: 100vh;
+}
+
+h1,
+h2,
+h3,
+.brand-font {
+  font-family: 'Lora', serif;
+}
+
+/* Layout */
+.App {
+  display: flex;
+  height: 100vh;
+  width: 100vw;
+  background: radial-gradient(circle at 50% -20%, rgba(168, 85, 247, 0.15) 0%, rgba(245, 158, 11, 0.04) 40%, var(--bg-deep) 80%);
+}
+
+.App.blurred {
+  filter: blur(8px);
+  pointer-events: none;
+}
+
+/* Sidebar Styling */
+.sidebar {
+  width: 280px;
+  background: var(--sidebar-bg);
+  border-right: 1px solid var(--glass-border);
+  display: flex;
+  flex-direction: column;
+  transition: transform var(--transition-slow), width var(--transition-slow);
+  z-index: 100;
+  position: relative;
+  overflow: hidden;
+}
+
+.sidebar.collapsed {
+  width: 0;
+  border-right: none;
+}
+
+.sidebar-content {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  width: 280px;
+  /* Fixed width for content to prevent squishing */
+  padding: 1.5rem 1rem;
+}
+
+.sidebar-header {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  margin-bottom: 2rem;
+  padding: 0 0.5rem;
+}
+
+.sidebar-header h2 {
+  font-size: 1.25rem;
+  font-weight: 600;
+  margin: 0;
+  background: linear-gradient(135deg, var(--accent) 0%, #d946ef 50%, var(--primary) 100%);
+  -webkit-background-clip: text;
+  background-clip: text;
+  -webkit-text-fill-color: transparent;
+}
+
+.new-chat-btn {
+  width: 100%;
+  padding: 0.875rem;
+  background: var(--primary);
+  color: white;
+  border: none;
+  border-radius: var(--border-radius);
+  font-weight: 600;
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.5rem;
+  transition: all var(--transition-fast);
+  box-shadow: 0 4px 12px var(--primary-glow);
+  margin-bottom: 1.5rem;
+}
+
+.new-chat-btn:hover {
+  transform: translateY(-1px);
+  box-shadow: 0 6px 16px var(--primary-glow);
+  background: #4f46e5;
+}
+
+.document-list-container {
+  flex: 1;
+  overflow-y: auto;
+  scrollbar-width: thin;
+  scrollbar-color: var(--glass-border) transparent;
+}
+
+.document-list-container::-webkit-scrollbar {
+  width: 6px;
+}
+
+.document-list-container::-webkit-scrollbar-thumb {
+  background-color: var(--glass-border);
+  border-radius: 10px;
+}
+
+.list-section {
+  margin-bottom: 2rem;
+}
+
+.list-section h3 {
+  font-size: 0.75rem;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--text-muted);
+  margin-bottom: 0.75rem;
+  padding-left: 0.5rem;
+}
+
+.session-item,
+.doc-item {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  padding: 0.75rem;
+  border-radius: 10px;
+  cursor: pointer;
+  transition: all var(--transition-fast);
+  color: var(--text-secondary);
+  margin-bottom: 0.25rem;
+  position: relative;
+  border: 1px solid transparent;
+}
+
+.session-item:hover,
+.doc-item:hover {
+  background: rgba(255, 255, 255, 0.03);
+  color: var(--text-primary);
+  border-color: var(--glass-border);
+}
+
+.session-item.active {
+  background: rgba(99, 102, 241, 0.1);
+  color: var(--primary);
+  border-color: rgba(99, 102, 241, 0.2);
+}
+
+.session-title,
+.doc-name {
+  flex: 1;
+  font-size: 0.875rem;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.doc-info {
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+  min-width: 0;
+}
+
+.doc-date {
+  font-size: 0.7rem;
+  color: var(--text-muted);
+}
+
+.delete-btn {
+  opacity: 0;
+  transition: opacity var(--transition-fast);
+  padding: 4px;
+  color: var(--text-muted);
+  background: none;
+  border: none;
+  cursor: pointer;
+}
+
+.session-item:hover .delete-btn,
+.doc-item:hover .delete-btn {
+  opacity: 1;
+}
+
+.delete-btn:hover {
+  color: #ef4444;
+}
+
+.sidebar-footer {
+  margin-top: auto;
+  padding-top: 0.75rem;
+  border-top: 1px solid var(--glass-border);
+}
+
+.user-profile {
+  display: flex;
+  flex-direction: column;
+  padding: 0.75rem;
+  border-radius: var(--border-radius);
+  background: transparent;
+  transition: all var(--transition-fast);
+  border: 1px solid transparent;
+}
+
+.user-profile:hover {
+  background: rgba(255, 255, 255, 0.03);
+  border-color: var(--glass-border);
+}
+
+.user-profile.expanded {
+  background: var(--bg-surface-elevated);
+  border-color: var(--primary-glow);
+  box-shadow: 0 4px 15px rgba(0, 0, 0, 0.25);
+}
+
+.user-profile-header {
+  display: flex;
+  align-items: center;
+  width: 100%;
+  gap: 0.75rem;
+}
+
+.user-avatar {
+  width: 36px;
+  height: 36px;
+  background: linear-gradient(135deg, var(--primary), var(--accent));
+  border-radius: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: white;
+  font-weight: 600;
+  font-size: 0.9rem;
+  box-shadow: 0 0 10px rgba(168, 85, 247, 0.3);
+}
+
+.user-info-basic {
+  flex: 1;
+  min-width: 0;
+}
+
+.username-display {
+  font-size: 0.9rem;
+  font-weight: 600;
+  color: var(--text-primary);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.user-profile-details {
+  margin-top: 0.75rem;
+  padding-top: 0.75rem;
+  border-top: 1px solid rgba(255, 255, 255, 0.05);
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  animation: fadeInFast 0.2s ease-out;
+}
+
+@keyframes fadeInFast {
+  from { opacity: 0; transform: translateY(-5px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+
+.user-detail-item {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.detail-label {
+  font-size: 0.7rem;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--text-muted);
+}
+
+.detail-value {
+  font-size: 0.8rem;
+  color: var(--text-secondary);
+  word-break: break-all;
+}
+
+.logout-action-btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.5rem;
+  font-size: 0.85rem;
+  font-weight: 600;
+  border-radius: 8px;
+  background: linear-gradient(135deg, #ef4444 0%, #dc2626 100%) !important;
+  box-shadow: 0 4px 10px rgba(239, 68, 68, 0.2) !important;
+}
+
+.logout-action-btn:hover {
+  background: linear-gradient(135deg, #dc2626 0%, #b91c1c 100%) !important;
+  box-shadow: 0 6px 15px rgba(239, 68, 68, 0.35) !important;
+  transform: translateY(-1px);
+}
+
+/* Main Chat Area */
+.chat-main {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  position: relative;
+  background: transparent;
+  min-width: 0;
+}
+
+.chat-header {
+  height: 4rem;
+  padding: 0 2rem;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  background: rgba(10, 12, 16, 0.4);
+  backdrop-filter: var(--glass-blur);
+  border-bottom: 1px solid var(--glass-border);
+  z-index: 50;
+}
+
+.header-left {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+}
+
+.sidebar-toggle {
+  background: none;
+  border: none;
+  color: var(--text-secondary);
+  cursor: pointer;
+  padding: 8px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: 8px;
+  transition: all var(--transition-fast);
+}
+
+.sidebar-toggle:hover {
+  background: var(--bg-surface-elevated);
+  color: var(--text-primary);
+}
+
+.chat-header h1 {
+  font-size: 1.125rem;
+  font-weight: 600;
+  margin: 0;
+  color: var(--text-primary);
+}
+
+.chat-messages {
+  flex: 1;
+  overflow-y: auto;
+  padding: 2rem;
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+  scrollbar-width: thin;
+}
+
+.chat-messages::-webkit-scrollbar {
+  width: 6px;
+}
+
+.chat-messages::-webkit-scrollbar-thumb {
+  background: var(--glass-border);
+  border-radius: 10px;
+}
+
+/* Message Bubbles */
+.message-bubble {
+  max-width: 80%;
+  display: flex;
+  flex-direction: column;
+  padding: 1.25rem;
+  border-radius: 1.25rem;
+  font-size: 0.95rem;
+  line-height: 1.6;
+  position: relative;
+  animation: messageIn 0.3s ease-out forwards;
+}
+
+@keyframes messageIn {
+  from {
+    opacity: 0;
+    transform: translateY(10px);
+  }
+
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.message-bubble.user {
+  align-self: flex-end;
+  background: var(--primary);
+  color: white;
+  border-bottom-right-radius: 4px;
+  box-shadow: 0 4px 15px var(--primary-glow);
+}
+
+.message-bubble.assistant {
+  align-self: flex-start;
+  background: var(--bg-surface-elevated);
+  color: var(--text-primary);
+  border-bottom-left-radius: 4px;
+  border: 1px solid var(--glass-border);
+  display: flex !important;
+  flex-direction: row !important;
+  align-items: flex-start;
+  gap: 1rem;
+}
+
+.message-content {
+  flex: 1;
+}
+
+.speak-btn {
+  background: rgba(255, 255, 255, 0.03);
+  border: 1px solid var(--glass-border);
+  color: var(--text-muted);
+  width: 32px;
+  height: 32px;
+  border-radius: 8px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+  transition: all var(--transition-fast);
+  flex-shrink: 0;
+  margin-top: 2px;
+}
+
+.speak-btn:hover {
+  background: rgba(255, 255, 255, 0.08);
+  color: var(--text-primary);
+  border-color: var(--glass-border);
+}
+
+.speak-btn.speaking {
+  background: rgba(99, 102, 241, 0.1);
+  color: var(--primary);
+  border-color: var(--primary);
+  animation: pulse 1.5s infinite;
+}
+
+@keyframes pulse {
+  0% {
+    opacity: 1;
+  }
+
+  50% {
+    opacity: 0.6;
+  }
+
+  100% {
+    opacity: 1;
+  }
+}
+
+/* Welcome / Empty state */
+.welcome-screen {
+  max-width: 580px;
+  margin: auto;
+  text-align: center;
+  padding: 2.5rem 2rem;
+  background: rgba(12, 8, 31, 0.4);
+  border: 1px solid rgba(168, 85, 247, 0.12);
+  border-radius: 24px;
+  backdrop-filter: blur(20px);
+  box-shadow: 0 20px 40px rgba(0, 0, 0, 0.4);
+  animation: cardFadeIn 0.6s cubic-bezier(0.4, 0, 0.2, 1);
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 1.25rem;
+}
+
+.welcome-screen h2 {
+  font-size: 2rem;
+  font-weight: 700;
+  margin: 0;
+  background: linear-gradient(135deg, #ffffff 0%, #cbd5e1 100%);
+  -webkit-background-clip: text;
+  background-clip: text;
+  -webkit-text-fill-color: transparent;
+  font-family: 'Lora', serif;
+}
+
+.welcome-subtitle {
+  font-size: 0.9rem;
+  color: var(--text-secondary);
+  max-width: 480px;
+  margin: 0;
+  line-height: 1.5;
+}
+
+/* System Pills Row */
+.system-pills-row {
+  display: flex;
+  justify-content: center;
+  flex-wrap: wrap;
+  gap: 0.75rem;
+  width: 100%;
+  margin: 0.25rem 0;
+}
+
+.system-pill {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  padding: 0.5rem 1rem;
+  background: rgba(168, 85, 247, 0.04);
+  border: 1px solid rgba(168, 85, 247, 0.15);
+  border-radius: 99px;
+  color: var(--text-secondary);
+  font-size: 0.8rem;
+  font-weight: 500;
+  cursor: default;
+  transition: all var(--transition-fast);
+  user-select: none;
+}
+
+.system-pill:hover {
+  border-color: rgba(168, 85, 247, 0.3);
+  background: rgba(168, 85, 247, 0.06);
+  color: var(--text-primary);
+}
+
+.pill-icon {
+  color: var(--primary);
+  flex-shrink: 0;
+}
+
+/* Start Chat Button */
+.start-chat-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0.75rem 2rem;
+  font-size: 0.95rem;
+  font-weight: 600;
+  color: white;
+  background: linear-gradient(135deg, var(--primary) 0%, #7c3aed 100%);
+  border: none;
+  border-radius: 12px;
+  cursor: pointer;
+  transition: all var(--transition-fast);
+  box-shadow: 0 4px 15px rgba(168, 85, 247, 0.25);
+  margin-top: 0.25rem;
+}
+
+.start-chat-btn:hover {
+  background: linear-gradient(135deg, #7c3aed 0%, #6d28d9 100%);
+  box-shadow: 0 6px 20px rgba(168, 85, 247, 0.4);
+  transform: translateY(-1px);
+}
+
+@media (max-width: 768px) {
+  .system-pills-row {
+    flex-direction: column;
+    align-items: center;
+    gap: 0.5rem;
+  }
+}
+
+/* Chat Input Bar */
+.chat-input-area {
+  padding: 1.5rem 2rem 2rem;
+  background: linear-gradient(to bottom, transparent, var(--bg-deep));
+}
+
+.chat-input-wrapper {
+  max-width: 800px;
+  margin: 0 auto;
+  background: var(--bg-surface);
+  border: 1px solid var(--glass-border);
+  border-radius: 1.25rem;
+  padding: 0.5rem;
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  box-shadow: var(--shadow-lg);
+  transition: border-color var(--transition-fast);
+}
+
+.chat-input-wrapper:focus-within {
+  border-color: var(--primary);
+}
+
+.chat-input-wrapper input {
+  flex: 1;
+  background: none;
+  border: none;
+  padding: 0.75rem;
+  color: var(--text-primary);
+  font-size: 1rem;
+  outline: none;
+}
+
+.icon-btn {
+  background: none;
+  border: none;
+  color: var(--text-muted);
+  padding: 0.6rem;
+  cursor: pointer;
+  border-radius: 10px;
+  transition: all var(--transition-fast);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.icon-btn:hover:not(:disabled) {
+  background: var(--bg-surface-elevated);
+  color: var(--text-primary);
+}
+
+.send-btn {
+  background: var(--primary);
+  color: white;
+  width: 40px;
+  height: 40px;
+  border-radius: 10px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border: none;
+  cursor: pointer;
+  transition: all var(--transition-fast);
+  box-shadow: 0 4px 10px var(--primary-glow);
+}
+
+.send-btn:hover:not(:disabled) {
+  transform: scale(1.05);
+  background: #4f46e5;
+}
+
+.send-btn:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+  box-shadow: none;
+}
+
+/* Loading Effects */
+.loading-overlay {
+  position: fixed;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.8);
+  backdrop-filter: blur(8px);
+  z-index: 1000;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 1.5rem;
+}
+
+.loader-ring {
+  width: 60px;
+  height: 60px;
+  border: 3px solid rgba(255, 255, 255, 0.05);
+  border-top: 3px solid var(--primary);
+  border-radius: 50%;
+  animation: spin 1s linear infinite;
+  box-shadow: 0 0 15px var(--primary-glow);
+}
+
+@keyframes spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+.loading-dots:after {
+  content: ' .';
+  animation: dots 1.5s infinite;
+}
+
+@keyframes dots {
+
+  0%,
+  20% {
+    content: ' .';
+  }
+
+  40% {
+    content: ' ..';
+  }
+
+  60% {
+    content: ' ...';
+  }
+
+  80%,
+  100% {
+    content: '';
+  }
+}
+
+/* Unique Split-Screen Auth Page */
+.auth-screen {
+  display: flex;
+  width: 100vw;
+  height: 100vh;
+  background: #04020a;
+  overflow: hidden;
+}
+
+.auth-graphic-side {
+  flex: 1.2;
+  background: radial-gradient(circle at 30% 20%, rgba(168, 85, 247, 0.22) 0%, rgba(245, 158, 11, 0.06) 40%, #04020a 100%);
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  padding: 5rem;
+  position: relative;
+  border-right: 1px solid rgba(168, 85, 247, 0.1);
+  overflow: hidden;
+}
+
+.auth-graphic-side::before {
+  content: '';
+  position: absolute;
+  top: -20%;
+  left: -20%;
+  width: 60%;
+  height: 60%;
+  background: radial-gradient(circle, rgba(168, 85, 247, 0.15) 0%, transparent 60%);
+  filter: blur(80px);
+  animation: floatOrb 8s infinite alternate ease-in-out;
+}
+
+@keyframes floatOrb {
+  0% { transform: translate(0, 0) scale(1); }
+  100% { transform: translate(30px, 20px) scale(1.1); }
+}
+
+.graphic-brand {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  margin-bottom: 3.5rem;
+  z-index: 10;
+}
+
+.graphic-brand-logo {
+  width: 48px;
+  height: 48px;
+  background: linear-gradient(135deg, var(--primary), var(--accent));
+  border-radius: 12px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  box-shadow: 0 0 20px rgba(168, 85, 247, 0.35);
+  flex-shrink: 0;
+}
+
+.graphic-brand-name {
+  font-family: 'Outfit', sans-serif;
+  font-size: 1.5rem;
+  font-weight: 700;
+  background: linear-gradient(135deg, var(--accent) 0%, #d946ef 50%, var(--primary) 100%);
+  -webkit-background-clip: text;
+  background-clip: text;
+  -webkit-text-fill-color: transparent;
+  letter-spacing: -0.02em;
+}
+
+.graphic-content {
+  z-index: 10;
+  max-width: 550px;
+  animation: fadeIn 0.8s ease-out;
+}
+
+.graphic-content h2 {
+  font-size: 2.75rem;
+  font-weight: 800;
+  line-height: 1.25;
+  margin-bottom: 1.5rem;
+  background: linear-gradient(to right, #ffffff, #d8b4fe);
+  -webkit-background-clip: text;
+  background-clip: text;
+  -webkit-text-fill-color: transparent;
+  font-family: 'Outfit', sans-serif;
+}
+
+.graphic-content p {
+  font-size: 1.05rem;
+  color: var(--text-secondary);
+  line-height: 1.7;
+  margin-bottom: 3rem;
+}
+
+.feature-highlights {
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+}
+
+.feature-item {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+}
+
+.feature-icon-wrapper {
+  width: 38px;
+  height: 38px;
+  border-radius: 10px;
+  background: rgba(168, 85, 247, 0.08);
+  border: 1px solid rgba(168, 85, 247, 0.15);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: var(--primary);
+  flex-shrink: 0;
+}
+
+.feature-text {
+  font-size: 0.95rem;
+  color: var(--text-secondary);
+  font-weight: 500;
+}
+
+.auth-form-side {
+  flex: 1;
+  background: #04020a;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 3rem;
+  position: relative;
+}
+
+.auth-form-side::after {
+  content: '';
+  position: absolute;
+  bottom: -20%;
+  right: -20%;
+  width: 50%;
+  height: 50%;
+  background: radial-gradient(circle, rgba(245, 158, 11, 0.06) 0%, transparent 60%);
+  filter: blur(80px);
+}
+
+.auth-card {
+  width: 100%;
+  max-width: 490px;
+  padding: 3rem;
+  background: rgba(12, 8, 31, 0.5);
+  backdrop-filter: blur(20px);
+  border: 1px solid rgba(168, 85, 247, 0.12);
+  border-radius: 24px;
+  box-shadow: 0 20px 50px rgba(0, 0, 0, 0.5);
+  animation: cardFadeIn 0.6s cubic-bezier(0.4, 0, 0.2, 1);
+  z-index: 10;
+}
+
+@keyframes cardFadeIn {
+  from {
+    opacity: 0;
+    transform: translateY(20px) scale(0.98);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0) scale(1);
+  }
+}
+
+.auth-card h1 {
+  font-size: 2rem;
+  font-weight: 700;
+  margin-bottom: 0.5rem;
+  text-align: center;
+  background: linear-gradient(135deg, #ffffff 0%, #cbd5e1 100%);
+  -webkit-background-clip: text;
+  background-clip: text;
+  -webkit-text-fill-color: transparent;
+}
+
+.auth-subtitle {
+  text-align: center;
+  color: var(--text-secondary);
+  margin-bottom: 2rem;
+  font-size: 0.9rem;
+  line-height: 1.5;
+}
+
+.form-group {
+  margin-bottom: 1.25rem;
+}
+
+.form-group label {
+  display: block;
+  font-size: 0.8rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  margin-bottom: 0.5rem;
+  color: var(--text-muted);
+}
+
+.form-group input {
+  width: 100%;
+  padding: 0.875rem 1rem;
+  background: rgba(5, 2, 12, 0.6);
+  border: 1px solid rgba(168, 85, 247, 0.15);
+  border-radius: 12px;
+  color: white;
+  outline: none;
+  transition: all var(--transition-fast);
+}
+
+.form-group input:focus {
+  border-color: var(--primary);
+  box-shadow: 0 0 0 4px rgba(168, 85, 247, 0.15);
+}
+
+.auth-btn {
+  width: 100%;
+  padding: 1rem;
+  background: linear-gradient(135deg, var(--primary) 0%, #7c3aed 100%);
+  color: white;
+  border: none;
+  border-radius: 12px;
+  font-size: 1rem;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all var(--transition-fast);
+  margin-top: 1rem;
+  box-shadow: 0 4px 15px rgba(168, 85, 247, 0.3);
+}
+
+.auth-btn:hover:not(:disabled) {
+  background: linear-gradient(135deg, #7c3aed 0%, #6d28d9 100%);
+  box-shadow: 0 6px 20px rgba(168, 85, 247, 0.45);
+  transform: translateY(-1px);
+}
+
+.auth-btn:disabled {
+  opacity: 0.6;
+  cursor: not-allowed;
+}
+
+.toggle-auth {
+  text-align: center;
+  margin-top: 1.5rem;
+  font-size: 0.875rem;
+  color: var(--text-secondary);
+}
+
+.toggle-auth span {
+  color: var(--primary);
+  cursor: pointer;
+  font-weight: 600;
+  transition: color var(--transition-fast);
+}
+
+.toggle-auth span:hover {
+  color: #c084fc;
+  text-decoration: underline;
+}
+
+/* Responsiveness */
+@media (max-width: 1024px) {
+  .auth-graphic-side {
+    display: none;
+  }
+  .auth-form-side {
+    flex: 1;
+    padding: 2rem;
+  }
+}
+
+/* Voice Button recording animation */
+.voice-btn.recording {
+  background: rgba(239, 68, 68, 0.1);
+  color: #ef4444;
+}
+
+.voice-stop-icon {
+  width: 12px;
+  height: 12px;
+  background: currentColor;
+  border-radius: 2px;
+}
+
+/* Premium Selector Panel (Inspired by ڈیزائن) */
+.selector-panel {
+  background: var(--bg-surface);
+  border: 1px solid var(--glass-border);
+  border-radius: 1.5rem;
+  max-width: 800px;
+  margin: 0 auto 1.5rem;
+  padding: 1.5rem;
+  box-shadow: 0 10px 30px rgba(0, 0, 0, 0.3);
+  animation: slideUp 0.4s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+@keyframes slideUp {
+  from {
+    opacity: 0;
+    transform: translateY(20px);
+  }
+
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.selector-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 1.5rem;
+  padding: 0 0.5rem;
+}
+
+.selector-header h3 {
+  font-size: 1.25rem;
+  font-weight: 600;
+  margin: 0;
+  color: var(--text-primary);
+}
+
+.selector-pagination {
+  font-size: 0.875rem;
+  color: var(--text-muted);
+  font-family: 'Plus Jakarta Sans', sans-serif;
+  letter-spacing: 0.05em;
+}
+
+.selector-list {
+  display: flex;
+  flex-direction: column;
+}
+
+.selector-item {
+  display: flex;
+  align-items: center;
+  gap: 1.25rem;
+  padding: 1.25rem 1.5rem;
+  cursor: pointer;
+  transition: all var(--transition-fast);
+  border-bottom: 1px solid rgba(255, 255, 255, 0.05);
+  position: relative;
+}
+
+.selector-item:last-child {
+  border-bottom: none;
+}
+
+.selector-item:hover {
+  background: rgba(255, 255, 255, 0.03);
+}
+
+.selector-item.active {
+  background: rgba(99, 102, 241, 0.08);
+}
+
+.item-number {
+  width: 32px;
+  height: 32px;
+  background: #1a1d24;
+  border-radius: 8px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 0.875rem;
+  font-weight: 600;
+  color: var(--text-secondary);
+  flex-shrink: 0;
+}
+
+.selector-item.active .item-number {
+  background: var(--primary);
+  color: white;
+  box-shadow: 0 0 10px var(--primary-glow);
+}
+
+.item-info {
+  flex: 1;
+  min-width: 0;
+}
+
+.item-name {
+  font-size: 1rem;
+  font-weight: 500;
+  color: var(--text-secondary);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  transition: color var(--transition-fast);
+}
+
+.selector-item:hover .item-name,
+.selector-item.active .item-name {
+  color: var(--text-primary);
+}
+
+.item-arrow {
+  color: var(--text-muted);
+  opacity: 0.3;
+  transition: all var(--transition-fast);
+}
+
+.selector-item:hover .item-arrow,
+.selector-item.active .item-arrow {
+  opacity: 1;
+  color: var(--primary);
+  transform: translateX(4px);
+}
+
+.selector-footer {
+  padding: 1.5rem 0.5rem 0.5rem;
+  border-top: 1px solid rgba(255, 255, 255, 0.05);
+  display: flex;
+  justify-content: center;
+}
+
+.selector-confirm-btn {
+  width: 100%;
+  padding: 1rem;
+  background: var(--primary);
+  color: white;
+  border: none;
+  border-radius: 12px;
+  font-size: 1rem;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all var(--transition-fast);
+  box-shadow: 0 4px 15px var(--primary-glow);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.75rem;
+}
+
+.selector-confirm-btn:hover {
+  background: #4f46e5;
+  transform: translateY(-2px);
+  box-shadow: 0 8px 25px var(--primary-glow);
+}
+
+.selector-confirm-btn:active {
+  transform: translateY(0);
+}
+
+.library-nav-btn {
+  width: 100%;
+  padding: 0.875rem;
+  background: transparent;
+  color: var(--text-secondary);
+  border: 1px solid var(--glass-border);
+  border-radius: var(--border-radius);
+  font-weight: 500;
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.5rem;
+  transition: all var(--transition-fast);
+  margin-bottom: 1.5rem;
+}
+
+.library-nav-btn:hover {
+  background: rgba(255, 255, 255, 0.05);
+  color: var(--text-primary);
+  border-color: var(--primary-glow);
+}
+
+.library-nav-btn.active {
+  background: var(--bg-surface-elevated);
+  border-color: var(--primary);
+  color: var(--primary);
+  box-shadow: 0 0 15px var(--primary-glow);
+}
+
+.library-main-container {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  background: transparent;
+}
+
+.library-container {
+  padding: 2rem;
+  flex: 1;
+  overflow-y: auto;
+}
+
+.library-header-actions {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 2rem;
+  gap: 1.5rem;
+}
+
+.search-bar {
+  flex: 1;
+  max-width: 500px;
+  background: var(--bg-surface);
+  border: 1px solid var(--glass-border);
+  padding: 0.75rem 1rem;
+  border-radius: 12px;
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  color: var(--text-muted);
+}
+
+.search-bar input {
+  background: none;
+  border: none;
+  color: var(--text-primary);
+  font-size: 0.95rem;
+  flex: 1;
+  outline: none;
+}
+
+.stat-chip {
+  padding: 0.5rem 1rem;
+  background: rgba(16, 185, 129, 0.1);
+  color: var(--accent);
+  border: 1px solid var(--accent-glow);
+  border-radius: 30px;
+  font-size: 0.85rem;
+  font-weight: 600;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.library-table-wrapper {
+  background: var(--bg-surface);
+  border: 1px solid var(--glass-border);
+  border-radius: 1.25rem;
+  overflow: hidden;
+  box-shadow: var(--shadow-lg);
+}
+
+.library-table {
+  width: 100%;
+  border-collapse: collapse;
+  text-align: left;
+}
+
+.library-table th {
+  padding: 1.25rem;
+  background: rgba(255, 255, 255, 0.02);
+  color: var(--text-muted);
+  font-size: 0.75rem;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  font-weight: 600;
+  border-bottom: 1px solid var(--glass-border);
+}
+
+.library-table td {
+  padding: 1.25rem;
+  border-bottom: 1px solid rgba(255, 255, 255, 0.03);
+  font-size: 0.9rem;
+  vertical-align: middle;
+}
+
+.doc-primary-cell {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+}
+
+.doc-icon-small {
+  width: 32px;
+  height: 32px;
+  background: rgba(99, 102, 241, 0.1);
+  color: var(--primary);
+  border-radius: 8px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.doc-name {
+  font-weight: 500;
+  color: var(--text-primary);
+}
+
+.metadata-cell {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  color: var(--text-secondary);
+}
+
+.chat-link-btn {
+  background: rgba(255, 255, 255, 0.03);
+  border: 1px solid var(--glass-border);
+  color: var(--text-secondary);
+  padding: 6px 12px;
+  border-radius: 8px;
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  transition: all var(--transition-fast);
+  font-size: 0.85rem;
+  max-width: 200px;
+}
+
+.chat-link-btn:hover {
+  background: rgba(99, 102, 241, 0.1);
+  color: var(--primary);
+  border-color: var(--primary);
+}
+
+.chat-link-btn span {
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.delete-row-btn {
+  background: rgba(239, 68, 68, 0.05);
+  border: 1px solid transparent;
+  color: var(--text-muted);
+  width: 36px;
+  height: 36px;
+  border-radius: 8px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+  transition: all var(--transition-fast);
+}
+
+.delete-row-btn:hover {
+  background: rgba(239, 68, 68, 0.15);
+  color: #ef4444;
+  border-color: rgba(239, 68, 68, 0.2);
+}
+
+.library-loader {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: 5rem;
+  gap: 1.5rem;
+  color: var(--text-secondary);
+}
+
+.empty-library {
+  text-align: center;
+  padding: 8rem 2rem;
+  color: var(--text-secondary);
+}
+
+.empty-library h3 {
+  color: var(--text-primary);
+  margin-bottom: 0.5rem;
+}
+.message-citation {
+  margin-top: 1rem;
+  padding-top: 0.75rem;
+  border-top: 1px solid var(--glass-border);
+  font-size: 0.8rem;
+  color: var(--text-secondary);
+  font-family: 'Plus Jakarta Sans', sans-serif;
+  font-style: italic;
+  line-height: 1.4;
+  white-space: pre-wrap;
+}
+
+.message-content .highlight-active {
+  background: rgba(147, 51, 234, 0.1);
+  border-radius: 4px;
+}
+
+.message-content .highlight-word {
+  background: rgba(147, 51, 234, 0.4);
+  color: #fff;
+  border-radius: 2px;
+  box-shadow: 0 0 10px rgba(147, 51, 234, 0.5);
+  padding: 0 2px;
+}
+
+mark.highlight-word {
+  background: rgba(147, 51, 234, 0.4) !important;
+  color: #fff !important;
+  border-radius: 2px;
+  box-shadow: 0 0 10px rgba(147, 51, 234, 0.5);
+  padding: 0 2px;
+  text-decoration: none;
+}
+
+mark.highlight-sentence {
+  background: rgba(147, 51, 234, 0.2) !important;
+  color: inherit !important;
+  border-radius: 4px;
+  box-shadow: 0 0 8px rgba(147, 51, 234, 0.3);
+  padding: 0 4px;
+  text-decoration: none;
+  transition: background 0.3s ease;
+}

frontend-react/src/App.jsx

@@ -0,0 +1,124 @@
+import { useState, useEffect } from 'react';
+import Auth from './components/Auth';
+import Sidebar from './components/Sidebar';
+import ChatWindow from './components/ChatWindow';
+import DocsLibrary from './components/DocsLibrary';
+import { PanelLeftOpen, PanelLeftClose } from 'lucide-react';
+import './App.css';
+
+const generateId = () => {
+  try {
+    return (typeof crypto !== 'undefined' && crypto.randomUUID)
+      ? crypto.randomUUID()
+      : Math.random().toString(36).substring(2, 15);
+  } catch (e) {
+    return Math.random().toString(36).substring(2, 15);
+  }
+};
+
+function App() {
+  const [token, setToken] = useState(localStorage.getItem('rag_token') || '');
+  const [email, setEmail] = useState(localStorage.getItem('rag_email') || '');
+  const [messages, setMessages] = useState([]);
+  const [isUploading, setIsUploading] = useState(false);
+  const [currentSessionId, setCurrentSessionId] = useState(generateId());
+  const [currentView, setCurrentView] = useState('chat');
+  const [sessionDocuments, setSessionDocuments] = useState([]);
+  const [refreshSessions, setRefreshSessions] = useState(0);
+  const [isSidebarCollapsed, setIsSidebarCollapsed] = useState(false);
+
+  const handleLoginSuccess = (newToken, newEmail) => {
+    setToken(newToken);
+    setEmail(newEmail);
+    localStorage.setItem('rag_token', newToken);
+    localStorage.setItem('rag_email', newEmail);
+  };
+
+  const handleLogout = () => {
+    setToken('');
+    setEmail('');
+    setMessages([]);
+    setSessionDocuments([]);
+    setCurrentView('chat');
+    localStorage.removeItem('rag_token');
+    localStorage.removeItem('rag_email');
+  };
+
+  const handleNewChat = () => {
+    setCurrentSessionId(generateId());
+    setMessages([]);
+    setSessionDocuments([]);
+    setCurrentView('chat');
+  };
+
+  const handleSelectSession = (sessionId) => {
+    setCurrentSessionId(sessionId);
+    setCurrentView('chat');
+  };
+
+  if (!token) {
+    return <Auth onLoginSuccess={handleLoginSuccess} />;
+  }
+
+  return (
+    <>
+      {isUploading && (
+        <div className="loading-overlay">
+          <div className="loader-ring"></div>
+          <p>Processing and Embedding Documents...</p>
+        </div>
+      )}
+      <div className={`App ${isUploading ? 'blurred' : ''}`}>
+        <Sidebar
+          token={token}
+          email={email}
+          onLogout={handleLogout}
+          onNewChat={handleNewChat}
+          onSelectSession={handleSelectSession}
+          setIsUploading={setIsUploading}
+          currentSessionId={currentSessionId}
+          refreshSessions={refreshSessions}
+          isCollapsed={isSidebarCollapsed}
+          setIsCollapsed={setIsSidebarCollapsed}
+          currentView={currentView}
+          onViewLibrary={() => setCurrentView('library')}
+          sessionDocuments={sessionDocuments}
+        />
+
+        {currentView === 'library' ? (
+          <div className="library-main-container">
+            <header className="chat-header">
+              <div className="header-left">
+                <button className="sidebar-toggle" onClick={() => setIsSidebarCollapsed(!isSidebarCollapsed)}>
+                  {isSidebarCollapsed ? <PanelLeftOpen size={20} /> : <PanelLeftClose size={20} />}
+                </button>
+                <h1>Management Library</h1>
+              </div>
+            </header>
+            <DocsLibrary
+              token={token}
+              onSelectChat={handleSelectSession}
+              onDeleteSuccess={() => setRefreshSessions(prev => prev + 1)}
+            />
+          </div>
+        ) : (
+          <ChatWindow
+            token={token}
+            messages={messages}
+            setMessages={setMessages}
+            sessionId={currentSessionId}
+            onFirstMessage={() => setRefreshSessions(prev => prev + 1)}
+            setIsUploading={setIsUploading}
+            onUploadSuccess={() => setRefreshSessions(prev => prev + 1)}
+            isSidebarCollapsed={isSidebarCollapsed}
+            setIsSidebarCollapsed={setIsSidebarCollapsed}
+            sessionDocuments={sessionDocuments}
+            setSessionDocuments={setSessionDocuments}
+          />
+        )}
+      </div>
+    </>
+  );
+}
+
+export default App;

frontend-react/src/api.js

@@ -0,0 +1,228 @@
+const BASE_URL = import.meta.env.VITE_API_URL || (
+  window.location.port && (window.location.port === '5173' || window.location.port === '3000')
+    ? 'http://localhost:8001'
+    : `${window.location.origin}/api`
+);
+
+export async function login(email, password) {
+  const formData = new URLSearchParams();
+  formData.append('username', email); // OAuth2 expects 'username' field
+  formData.append('password', password);
+
+  const response = await fetch(`${BASE_URL}/token`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+    },
+    body: formData,
+  });
+
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.detail || 'Login failed');
+  }
+
+  return await response.json();
+}
+
+export async function register(username, email, password) {
+  const response = await fetch(`${BASE_URL}/register`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ username, email, password }),
+  });
+
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.detail || 'Registration failed');
+  }
+
+  return await response.json();
+}
+
+export async function fetchDocuments(token) {
+  const response = await fetch(`${BASE_URL}/documents/`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error('Failed to fetch documents');
+  }
+
+  return await response.json();
+}
+
+export async function uploadDocument(token, file, sessionId = null) {
+  const formData = new FormData();
+  formData.append('file', file);
+  if (sessionId) {
+    formData.append('session_id', sessionId);
+  }
+
+  const response = await fetch(`${BASE_URL}/documents/upload`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+    body: formData,
+  });
+
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.detail || 'Upload failed');
+  }
+
+  return await response.json();
+}
+
+export async function deleteDocument(token, filename) {
+  const response = await fetch(`${BASE_URL}/documents/${encodeURIComponent(filename)}`, {
+    method: 'DELETE',
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.detail || 'Delete failed');
+  }
+
+  return await response.json();
+}
+
+export async function chatQuery(token, query, sessionId, filename = null, filenames = null) {
+  const response = await fetch(`${BASE_URL}/chat/`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${token}`,
+    },
+    body: JSON.stringify({
+      query,
+      session_id: sessionId,
+      filename,
+      filenames
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.detail || 'Chat query failed');
+  }
+
+  // Return the raw response so the UI can read the stream
+  return response;
+}
+
+export async function fetchChatSessions(token) {
+  const response = await fetch(`${BASE_URL}/chat/sessions`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error('Failed to fetch chat sessions');
+  }
+
+  return await response.json();
+}
+
+export async function fetchChatHistory(token, sessionId) {
+  const response = await fetch(`${BASE_URL}/chat/history/${sessionId}`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error('Failed to fetch chat history');
+  }
+
+  return await response.json();
+}
+
+export async function fetchSessionDocuments(token, sessionId) {
+  const response = await fetch(`${BASE_URL}/documents/session/${sessionId}`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error('Failed to fetch session documents');
+  }
+
+  return await response.json();
+}
+
+export async function deleteChatSession(token, sessionId) {
+  const response = await fetch(`${BASE_URL}/chat/session/${sessionId}`, {
+    method: 'DELETE',
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error('Failed to delete chat session');
+  }
+
+  return await response.json();
+}
+
+// Voice API functions
+export async function startVoiceRecording(token) {
+  const response = await fetch(`${BASE_URL}/voice/start`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error('Failed to start recording');
+  }
+
+  return await response.json();
+}
+
+export async function stopVoiceRecording(token) {
+  const response = await fetch(`${BASE_URL}/voice/stop`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.detail || 'Failed to stop recording');
+  }
+
+  return await response.json();
+}
+
+export async function getTtsAudio(token, text, signal) {
+  const response = await fetch(`${BASE_URL}/chat/speak`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${token}`,
+    },
+    body: JSON.stringify({ text }),
+    signal
+  });
+
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.detail || 'TTS request failed');
+  }
+
+  return response;
+}