Changes Pro max

.env.example

@@ -1,11 +1,24 @@
-UPLOAD_FOLDER=uploads
+# ── App Config ───────────────────────────────────────
+SECRET_KEY=change-me-in-production
+DATABASE_URL=sqlite:///./data/app.db
 
-OAUTHLIB_INSECURE_TRANSPORT=1
-OAUTHLIB_RELAX_TOKEN_SCOPE=1
+# ── HuggingFace (Required for LLM) ──────────────────
+HF_TOKEN=your_huggingface_token_here
 
-SECRET_KEY=
-ENCRYPTION_KEY=
-MONGO_URI=
+# ── LLM Model (Optional — defaults shown) ───────────
+# LLM_MODEL=mistralai/Mistral-7B-Instruct-v0.3
+# LLM_TEMPERATURE=0.3
+# LLM_MAX_NEW_TOKENS=1024
 
-GOOGLE_CLIENT_ID=
-GOOGLE_CLIENT_SECRET=
+# ── Embeddings (Optional — defaults shown) ───────────
+# EMBEDDING_MODEL=sentence-transformers/all-MiniLM-L6-v2
+
+# ── RAG Config (Optional — defaults shown) ───────────
+# CHUNK_SIZE=1000
+# CHUNK_OVERLAP=200
+# TOP_K_RETRIEVAL=10
+# TOP_K_RERANK=5
+
+# ── Upload (Optional) ───────────────────────────────
+# UPLOAD_DIR=./data/uploads
+# MAX_FILE_SIZE_MB=50

.gitignore

@@ -1,8 +1,30 @@
-.env
-uploads/
-vectorstore/
+# Dependencies
+node_modules/
 __pycache__/
 *.pyc
 .venv/
+*.egg-info/
+
+# Data (runtime generated)
+data/
+*.db
+
+# Environment
+.env
+backend/.env
+
+# Build outputs
+frontend/out/
+frontend/.next/
+.next/
+
+# OS
+.DS_Store
+Thumbs.db
 
+# IDE
+.vscode/
+.idea/
 
+# Misc
+*.log

Dockerfile

@@ -1,4 +1,22 @@
-FROM python:3.10-slim
+# ════════════════════════════════════════════════════════
+# Stage 1: Build Next.js Frontend
+# ════════════════════════════════════════════════════════
+FROM node:20-alpine AS frontend-builder
+
+WORKDIR /app/frontend
+
+# Install dependencies
+COPY frontend/package.json frontend/package-lock.json ./
+RUN npm ci --no-audit
+
+# Copy frontend source and build
+COPY frontend/ ./
+RUN npm run build
+
+# ════════════════════════════════════════════════════════
+# Stage 2: Python Backend + Serve Frontend
+# ════════════════════════════════════════════════════════
+FROM python:3.11-slim
 
 WORKDIR /app
 
@@ -9,15 +27,25 @@ RUN apt-get update && apt-get install -y \
     --no-install-recommends && \
     rm -rf /var/lib/apt/lists/*
 
-# Install python dependencies
-COPY requirements.txt .
+# Install Python dependencies
+COPY backend/requirements.txt ./requirements.txt
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy application code
-COPY . .
+# Copy backend code
+COPY backend/ ./backend/
+
+# Copy frontend build from stage 1
+COPY --from=frontend-builder /app/frontend/out ./frontend/out
+
+# Create data directories
+RUN mkdir -p data/uploads data/chroma_db
+
+# Copy entrypoint
+COPY start.sh ./start.sh
+RUN chmod +x start.sh
 
-# Create persistent storage directories
-RUN mkdir -p uploads
+# HuggingFace Spaces requires port 7860
+EXPOSE 7860
 
-# Command to run the application using Gunicorn for production
-CMD ["gunicorn", "--bind", "0.0.0.0:5000", "--workers", "2", "app:app"]
+# Entrypoint
+CMD ["./start.sh"]

README.md

@@ -1,215 +1,66 @@
-# 📄 RAG PDF Assistant
-
-A **Retrieval-Augmented Generation (RAG)** document assistant built with Flask, Pinecone, Gemini Embeddings, Groq API, and Google Gemini. Upload PDFs, DOCX, TXT, or MD files and intuitively chat with them using modern AI models.
-
 ---
-
-## 🚀 Features
-
-- 📂 **Multi-format Uploads**: Support for PDF, DOCX, TXT, and Markdown files.
-- 💬 **Interactive Chat**: Query and chat with your documents using AI.
-- 🔍 **RAG-based Retrieval**: Fast and accurate semantic search using Pinecone vector database.
-- 🧠 **Multiple LLM Support**: Powered by Groq API (Llama 3) and Google Gemini.
-- 🔐 **Robust Authentication**: Supports Google OAuth as well as standard Email/Password login.
-- 🖼️ **User Profiles**: Custom profile picture uploads & Google profile pic sync.
-- 👤 **Data Isolation**: Per-user namespaces in Pinecone for complete privacy.
-- 🛡️ **Admin Dashboard**: Admin panel to monitor users and uploaded files.
-- 🗑️ **Data Management**: Intuitive UI to delete files and clear vector stores.
-- 📱 **Responsive UI**: Minimal and modern front-end for seamless user experience.
-- ☁️ **Lightweight & Cloud-Native**: Zero local ML models — all embeddings and LLM calls are cloud-based API calls, requiring minimal server RAM.
-
+title: Document AI Analyst
+emoji: 🧠
+colorFrom: indigo
+colorTo: purple
+sdk: docker
+app_port: 7860
+pinned: true
+license: mit
+short_description: Enterprise Agentic RAG — upload PDFs and chat with AI
 ---
 
-## 🛠️ Tech Stack
+# 🧠 Document AI Analyst — Enterprise Agentic RAG System
 
-| Layer | Technology |
-|-------|------------|
-| **Backend** | Flask (Python) |
-| **Authentication** | Flask-Login + Flask-Dance (Google OAuth) |
-| **Embeddings** | Google Gemini (`gemini-embedding-001`) |
-| **Vector Store** | Pinecone (Serverless) |
-| **LLMs** | Groq API (Llama 3.3 70B) & Google Gemini |
-| **User Database** | MongoDB Atlas |
-| **Frontend** | HTML, CSS, Vanilla JS |
+Upload complex PDFs, financial reports, legal contracts, or research papers and chat with an AI agent that provides **accurate, cited insights** powered by Retrieval-Augmented Generation.
 
----
+## ✨ Features
 
-## 📁 Project Structure
+- **Multi-Format Upload** — PDF, DOCX, TXT, Markdown with smart chunking
+- **Semantic Search** — Two-stage retrieval with cross-encoder reranking
+- **Streaming Chat** — Real-time AI responses with inline source citations
+- **Data Isolation** — Per-user vector collections for complete privacy
+- **Open-Source LLMs** — Powered by Mistral-7B and HuggingFace ecosystem
 
-```text
-RAG_App/
-├── app.py                  # Main Flask application & routes
-├── models.py               # MongoDB user model & encrypted key storage
-├── config.py               # Configuration & env variables
-├── requirements.txt        # Python dependencies
-├── render.yaml             # Render deployment blueprint
-├── Dockerfile              # Docker containerization
-├── .env.example            # Environment variable template
-├── rag/
-│   ├── chunker.py          # Document parsing & chunking logic
-│   ├── embeddings.py       # Gemini embeddings + Pinecone upsert
-│   ├── retriever.py        # Pinecone semantic search & retrieval
-│   └── generator.py        # LLM integration for answer generation
-├── templates/
-│   ├── index.html          # File management & upload dashboard
-│   ├── chat.html           # RAG chat interface
-│   ├── login.html          # User login page
-│   ├── register.html       # User registration page
-│   ├── admin.html          # Admin dashboard
-│   └── profile.html        # User profile & API key settings
-├── static/                 # Static assets (CSS, JS, profile_pics)
-├── uploads/                # User-uploaded files (isolated per user)
-└── .github/workflows/
-    ├── devsecops.yml       # Security scanning pipeline
-    └── deploy.yml          # Docker build & GHCR push pipeline
-```
-
----
-
-## ⚙️ Setup & Installation
+## 🏗️ Architecture
 
-### 1. Clone the Repository
-```bash
-git clone https://github.com/param20h/PDF-Assistant-RAG.git
-cd PDF-Assistant-RAG
-```
+| Layer | Technology |
+|---|---|
+| **Frontend** | Next.js 16, Tailwind CSS v4, Shadcn UI v2 |
+| **Backend** | FastAPI, SQLAlchemy, JWT Auth |
+| **Embeddings** | sentence-transformers/all-MiniLM-L6-v2 (local) |
+| **Vector Store** | ChromaDB (persistent, per-user collections) |
+| **Reranker** | cross-encoder/ms-marco-MiniLM-L-6-v2 |
+| **LLM** | Mistral-7B-Instruct via HuggingFace Inference API |
+| **Deployment** | Docker multi-stage build on HuggingFace Spaces |
 
-### 2. Create and Activate Virtual Environment
-```bash
-python -m venv .venv
+## 🚀 Quick Start
 
-# Windows
-.venv\Scripts\activate
+1. **Register** an account
+2. **Upload** a PDF document
+3. **Wait** for processing (chunking + embedding)
+4. **Ask** questions and get cited answers!
 
-# Linux/Mac
-source .venv/bin/activate
-```
+## 🔧 Local Development
 
-### 3. Install Dependencies
 ```bash
+# Backend
+cd backend && python3 -m venv .venv && source .venv/bin/activate
 pip install -r requirements.txt
-```
-
-### 4. Configure Environment Variables
-Create a `.env` file using the template:
-```bash
-cp .env.example .env
-```
+uvicorn app.main:app --port 7860
 
-Fill in the required server-side variables:
-```env
-SECRET_KEY=<your-secret-key>
-ENCRYPTION_KEY=<your-fernet-key>
-MONGO_URI=<your-mongodb-atlas-uri>
-GOOGLE_CLIENT_ID=<your-google-client-id>
-GOOGLE_CLIENT_SECRET=<your-google-client-secret>
+# Frontend
+cd frontend && npm install && npm run dev
 ```
 
-> **Generate keys:**
-> ```bash
-> # SECRET_KEY
-> python -c "import secrets; print(secrets.token_hex(32))"
-> # ENCRYPTION_KEY
-> python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"
-> ```
-
-### 5. Run the Application
-```bash
-python app.py
-```
-
-### 6. Access in Browser
-Visit `http://localhost:5000` in your web browser.
-
----
-
-## 🔑 User Setup (Per-User API Keys)
-
-After registering/logging in, each user must add their own API keys on the **Profile** page:
-
-| Service | Required? | Where to Get | Notes |
-|---------|-----------|--------------|-------|
-| **Gemini API Key** | ✅ Required | [aistudio.google.com](https://aistudio.google.com) | Free — used for embeddings & chat |
-| **Pinecone API Key** | ✅ Required | [app.pinecone.io](https://app.pinecone.io) | Free tier available |
-| **Pinecone Index Name** | ✅ Required | Pinecone Dashboard | Create: dim `3072`, metric `cosine` |
-| **Groq API Key** | Optional | [console.groq.com](https://console.groq.com) | For Llama 3 chat generation |
+## 📦 Environment Variables
 
-### 🌲 Pinecone Index Setup
-1. Create a free account at [pinecone.io](https://app.pinecone.io)
-2. Create a **Serverless** index with:
-   - **Dimension**: `3072`
-   - **Metric**: `cosine`
-3. Copy your API key and index name into the Profile page
+| Variable | Required | Description |
+|---|---|---|
+| `HF_TOKEN` | ✅ | HuggingFace API token for LLM inference |
+| `SECRET_KEY` | ✅ | JWT signing secret |
+| `DATABASE_URL` | ❌ | SQLite path (default: `sqlite:///./data/app.db`) |
 
----
-
-## 🌐 Google OAuth Setup
-1. Go to **Google Cloud Console** → [console.cloud.google.com](https://console.cloud.google.com)
-2. Create a new project and navigate to **APIs & Services** → **Credentials**
-3. Click **Create Credentials** → **OAuth Client ID**
-4. Set the Authorized redirect URI to: `http://localhost:5000/login/google/authorized`
-5. Copy your `Client ID` and `Client Secret` into the `.env` file
-
----
-
-## 🔄 How It Works (The RAG Pipeline)
-
-1. **Upload**: User uploads a document (PDF, DOCX, TXT, or MD).
-2. **Chunking**: The document is parsed and split into manageable textual chunks.
-3. **Embedding**: Chunks are converted to 3072-dimensional vectors using `gemini-embedding-001`.
-4. **Vector Storage**: Vectors are stored in the user's Pinecone namespace.
-5. **Querying**: The user submits a question.
-6. **Retrieval**: Pinecone retrieves the most semantically relevant chunks.
-7. **Generation**: The retrieved context is passed to the selected LLM (Groq or Gemini) to generate an accurate, grounded answer.
-
----
-
-## 🚀 Deployment
-
-### Deploy to Render (Recommended — Free)
-1. Push your code to GitHub
-2. Go to [Render](https://dashboard.render.com) → **New** → **Web Service**
-3. Connect your GitHub repository
-4. Render auto-detects `render.yaml` and configures everything
-5. Add environment variables: `SECRET_KEY`, `ENCRYPTION_KEY`, `MONGO_URI`, `GOOGLE_CLIENT_ID`, `GOOGLE_CLIENT_SECRET`
-6. Update Google OAuth redirect URI to: `https://your-app.onrender.com/login/google/authorized`
-7. Deploy!
-
-### Deploy with Docker
-```bash
-docker build -t rag-app .
-docker run -p 5000:5000 --env-file .env rag-app
-```
-
----
-
-## 🔐 DevSecOps Pipeline
-
-| Tool | Purpose |
-|------|---------|
-| `GitHub Actions` | CI/CD Pipeline |
-| `Bandit` | SAST — Python security vulnerability scanning |
-| `Gitleaks` | Hardcoded secret and credential detection |
-| `Trivy` | Container and dependency vulnerability checking |
-| `Snyk` | Advanced dependency vulnerability scanning |
-| `OWASP ZAP` | DAST — Dynamic web security scanning |
-| `SonarCloud` | Overall code quality and security analysis |
-| `GHCR` | Docker image hosting via GitHub Container Registry |
-
----
-
-## 👨‍💻 Author
-
-- **Name:** Paramjit Singh (param20h)
-
----
-
-## 📄 License
-
-This project is licensed under the **MIT License**. Check the `LICENSE` file for more details.
-
----
-
-## ⭐ Show Some Support!
+## 🛠️ Tech Stack
 
-If you found this project helpful or inspiring, please give it a ⭐!
+Built with: **FastAPI** • **LangChain** • **ChromaDB** • **HuggingFace** • **Next.js 16** • **Tailwind CSS** • **Shadcn UI**

backend/app/__init__.py

@@ -0,0 +1 @@
+# Enterprise Agentic RAG System — Backend

backend/app/auth.py

@@ -0,0 +1,89 @@
+"""
+JWT authentication — register, login, and token verification.
+"""
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+import jwt
+import bcrypt
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from sqlalchemy.orm import Session
+
+from app.config import get_settings
+from app.database import get_db
+from app.models import User
+
+settings = get_settings()
+security = HTTPBearer()
+
+
+# ── Password Hashing ─────────────────────────────────
+
+def hash_password(password: str) -> str:
+    return bcrypt.hashpw(password.encode("utf-8"), bcrypt.gensalt()).decode("utf-8")
+
+
+def verify_password(plain: str, hashed: str) -> bool:
+    return bcrypt.checkpw(plain.encode("utf-8"), hashed.encode("utf-8"))
+
+
+# ── JWT Token ────────────────────────────────────────
+
+def create_token(user_id: str) -> str:
+    """Create a JWT token with user_id as the subject."""
+    payload = {
+        "sub": user_id,
+        "exp": datetime.now(timezone.utc) + timedelta(hours=settings.JWT_EXPIRY_HOURS),
+        "iat": datetime.now(timezone.utc),
+    }
+    return jwt.encode(payload, settings.SECRET_KEY, algorithm=settings.JWT_ALGORITHM)
+
+
+def decode_token(token: str) -> Optional[str]:
+    """Decode JWT and return user_id, or None if invalid."""
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.JWT_ALGORITHM])
+        return payload.get("sub")
+    except jwt.ExpiredSignatureError:
+        return None
+    except jwt.InvalidTokenError:
+        return None
+
+
+# ── FastAPI Dependencies ─────────────────────────────
+
+def get_current_user(
+    credentials: HTTPAuthorizationCredentials = Depends(security),
+    db: Session = Depends(get_db),
+) -> User:
+    """Dependency: extract and validate user from JWT bearer token."""
+    token = credentials.credentials
+    user_id = decode_token(token)
+
+    if not user_id:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or expired token",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    user = db.query(User).filter(User.id == user_id).first()
+
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="User not found",
+        )
+
+    return user
+
+
+def get_admin_user(user: User = Depends(get_current_user)) -> User:
+    """Dependency: require admin privileges."""
+    if not user.is_admin:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Admin access required",
+        )
+    return user

backend/app/config.py

@@ -0,0 +1,59 @@
+"""
+Application configuration via pydantic-settings.
+All config is loaded from environment variables with sensible defaults.
+"""
+import os
+from pydantic_settings import BaseSettings
+from functools import lru_cache
+
+
+class Settings(BaseSettings):
+    # ── App ──────────────────────────────────────────────
+    APP_NAME: str = "Document AI Analyst"
+    SECRET_KEY: str = "change-me-in-production-please"
+    DEBUG: bool = False
+
+    # ── Database ─────────────────────────────────────────
+    DATABASE_URL: str = "sqlite:///./data/app.db"
+
+    # ── Auth ─────────────────────────────────────────────
+    JWT_ALGORITHM: str = "HS256"
+    JWT_EXPIRY_HOURS: int = 72
+
+    # ── File Upload ──────────────────────────────────────
+    UPLOAD_DIR: str = "./data/uploads"
+    MAX_FILE_SIZE_MB: int = 50
+    ALLOWED_EXTENSIONS: set = {"pdf", "docx", "txt", "md"}
+
+    # ── RAG Pipeline ─────────────────────────────────────
+    CHUNK_SIZE: int = 1000
+    CHUNK_OVERLAP: int = 200
+    TOP_K_RETRIEVAL: int = 10
+    TOP_K_RERANK: int = 5
+
+    # ── Embeddings (local HuggingFace model) ─────────────
+    EMBEDDING_MODEL: str = "sentence-transformers/all-MiniLM-L6-v2"
+    EMBEDDING_DIMENSION: int = 384
+
+    # ── ChromaDB ─────────────────────────────────────────
+    CHROMA_PERSIST_DIR: str = "./data/chroma_db"
+
+    # ── LLM (HuggingFace Inference API) ──────────────────
+    HF_TOKEN: str = ""
+    LLM_MODEL: str = "mistralai/Mistral-7B-Instruct-v0.2"
+    LLM_MAX_NEW_TOKENS: int = 1024
+    LLM_TEMPERATURE: float = 0.3
+
+    # ── Reranker ─────────────────────────────────────────
+    RERANKER_MODEL: str = "cross-encoder/ms-marco-MiniLM-L-6-v2"
+
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        extra = "ignore"
+
+
+@lru_cache()
+def get_settings() -> Settings:
+    """Cached settings instance — loaded once on startup."""
+    return Settings()

backend/app/database.py

@@ -0,0 +1,40 @@
+"""
+SQLAlchemy database setup with SQLite.
+Uses synchronous SQLAlchemy for simplicity and compatibility.
+"""
+import os
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, declarative_base
+from app.config import get_settings
+
+settings = get_settings()
+
+# ── Ensure data directory exists ─────────────────────
+db_path = settings.DATABASE_URL.replace("sqlite:///", "")
+os.makedirs(os.path.dirname(db_path) if os.path.dirname(db_path) else ".", exist_ok=True)
+
+# ── Engine & Session ─────────────────────────────────
+engine = create_engine(
+    settings.DATABASE_URL,
+    connect_args={"check_same_thread": False},  # Required for SQLite
+    echo=settings.DEBUG,
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+
+def get_db():
+    """FastAPI dependency — yields a DB session per request."""
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+def init_db():
+    """Create all tables on startup."""
+    from app import models  # noqa: F401 — import to register models
+    Base.metadata.create_all(bind=engine)

backend/app/main.py

@@ -0,0 +1,137 @@
+"""
+FastAPI application entry point.
+Mounts all routes, configures CORS, and serves the Next.js frontend build.
+"""
+import os
+import logging
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+
+from app.config import get_settings
+from app.database import init_db
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+settings = get_settings()
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application startup/shutdown lifecycle."""
+    # ── Startup ──────────────────────────────────────
+    logger.info(f"Starting {settings.APP_NAME}")
+
+    # Create tables
+    init_db()
+    logger.info("Database initialized")
+
+    # Ensure upload directory exists
+    os.makedirs(settings.UPLOAD_DIR, exist_ok=True)
+    os.makedirs(settings.CHROMA_PERSIST_DIR, exist_ok=True)
+
+    # Pre-load embedding model (warm up)
+    try:
+        from app.rag.embeddings import get_embedding_model
+        get_embedding_model()
+        logger.info("Embedding model pre-loaded")
+    except Exception as e:
+        logger.warning(f"Failed to pre-load embedding model: {e}")
+
+    yield
+
+    # ── Shutdown ─────────────────────────────────────
+    logger.info("Shutting down")
+
+
+# ── Create App ───────────────────────────────────────
+app = FastAPI(
+    title=settings.APP_NAME,
+    description="Enterprise Agentic RAG System — Upload PDFs and chat with AI",
+    version="2.0.0",
+    lifespan=lifespan,
+)
+
+# ── CORS (allow frontend dev server) ─────────────────
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000", "http://localhost:7860", "*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ── Mount API Routes ─────────────────────────────────
+from app.routes.auth import router as auth_router
+from app.routes.documents import router as documents_router
+from app.routes.chat import router as chat_router
+
+app.include_router(auth_router, prefix="/api/v1")
+app.include_router(documents_router, prefix="/api/v1")
+app.include_router(chat_router, prefix="/api/v1")
+
+
+# ── Health Check ─────────────────────────────────────
+@app.get("/api/health")
+def health_check():
+    return {
+        "status": "healthy",
+        "app": settings.APP_NAME,
+        "version": "2.0.0",
+    }
+
+
+# ── Serve Next.js Frontend (production) ──────────────
+FRONTEND_BUILD_DIR = os.path.join(os.path.dirname(__file__), "..", "..", "frontend", "out")
+
+if os.path.exists(FRONTEND_BUILD_DIR):
+    # Serve static assets (JS, CSS, images)
+    app.mount("/_next", StaticFiles(directory=os.path.join(FRONTEND_BUILD_DIR, "_next")), name="next_static")
+
+    # Serve other static files if they exist
+    static_dir = os.path.join(FRONTEND_BUILD_DIR, "static")
+    if os.path.exists(static_dir):
+        app.mount("/static", StaticFiles(directory=static_dir), name="static")
+
+    @app.get("/{full_path:path}")
+    async def serve_frontend(full_path: str):
+        """Serve Next.js static export — tries exact file, then .html, then index.html."""
+        # Try exact file path
+        file_path = os.path.join(FRONTEND_BUILD_DIR, full_path)
+        if os.path.isfile(file_path):
+            return FileResponse(file_path)
+
+        # Try with .html extension
+        html_path = os.path.join(FRONTEND_BUILD_DIR, f"{full_path}.html")
+        if os.path.isfile(html_path):
+            return FileResponse(html_path)
+
+        # Try as directory index
+        index_path = os.path.join(FRONTEND_BUILD_DIR, full_path, "index.html")
+        if os.path.isfile(index_path):
+            return FileResponse(index_path)
+
+        # Fallback to root index.html (SPA routing)
+        root_index = os.path.join(FRONTEND_BUILD_DIR, "index.html")
+        if os.path.isfile(root_index):
+            return FileResponse(root_index)
+
+        return FileResponse(root_index) if os.path.exists(root_index) else {"error": "Not found"}
+else:
+    logger.info("No frontend build found — running in API-only mode")
+
+    @app.get("/")
+    def root():
+        return {
+            "message": f"Welcome to {settings.APP_NAME} API",
+            "docs": "/docs",
+            "health": "/api/health",
+        }

backend/app/models.py

@@ -0,0 +1,62 @@
+"""
+SQLAlchemy ORM models for users, documents, and chat messages.
+"""
+import uuid
+from datetime import datetime, timezone
+from sqlalchemy import Column, String, Integer, DateTime, ForeignKey, Text, Boolean
+from sqlalchemy.orm import relationship
+from app.database import Base
+
+
+def generate_uuid():
+    return str(uuid.uuid4())
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(String, primary_key=True, default=generate_uuid)
+    username = Column(String(80), unique=True, nullable=False, index=True)
+    email = Column(String(120), unique=True, nullable=False, index=True)
+    hashed_password = Column(String(255), nullable=False)
+    is_admin = Column(Boolean, default=False)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+
+    # Relationships
+    documents = relationship("Document", back_populates="owner", cascade="all, delete-orphan")
+    messages = relationship("ChatMessage", back_populates="user", cascade="all, delete-orphan")
+
+
+class Document(Base):
+    __tablename__ = "documents"
+
+    id = Column(String, primary_key=True, default=generate_uuid)
+    user_id = Column(String, ForeignKey("users.id"), nullable=False, index=True)
+    filename = Column(String(255), nullable=False)        # Stored filename (UUID-based)
+    original_name = Column(String(255), nullable=False)    # User's original filename
+    file_size = Column(Integer, default=0)                 # Size in bytes
+    page_count = Column(Integer, default=0)
+    chunk_count = Column(Integer, default=0)
+    status = Column(String(20), default="pending")         # pending | processing | ready | failed
+    error_message = Column(Text, nullable=True)
+    uploaded_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+
+    # Relationships
+    owner = relationship("User", back_populates="documents")
+    messages = relationship("ChatMessage", back_populates="document", cascade="all, delete-orphan")
+
+
+class ChatMessage(Base):
+    __tablename__ = "chat_messages"
+
+    id = Column(String, primary_key=True, default=generate_uuid)
+    user_id = Column(String, ForeignKey("users.id"), nullable=False, index=True)
+    document_id = Column(String, ForeignKey("documents.id"), nullable=True, index=True)
+    role = Column(String(20), nullable=False)  # "user" | "assistant"
+    content = Column(Text, nullable=False)
+    sources_json = Column(Text, nullable=True)  # JSON string of source citations
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+
+    # Relationships
+    user = relationship("User", back_populates="messages")
+    document = relationship("Document", back_populates="messages")

backend/app/rag/__init__.py

@@ -0,0 +1 @@
+# RAG Pipeline

backend/app/rag/agent.py

@@ -0,0 +1,214 @@
+"""
+RAG Agent — generation with HuggingFace Inference API (chat completion).
+Supports both streaming (SSE) and non-streaming responses.
+"""
+import logging
+import json
+from typing import List, Dict, Any, Optional, Generator
+
+from huggingface_hub import InferenceClient
+from app.config import get_settings
+from app.rag.retriever import retrieve
+from app.rag.prompts import SYSTEM_PROMPT, RAG_PROMPT_TEMPLATE, GREETING_PROMPT
+
+logger = logging.getLogger(__name__)
+settings = get_settings()
+
+# ── Singleton LLM client ─────────────────────────────
+_llm_client = None
+
+
+def get_llm_client() -> InferenceClient:
+    """Get or create HuggingFace InferenceClient (singleton)."""
+    global _llm_client
+
+    if _llm_client is None:
+        _llm_client = InferenceClient(
+            token=settings.HF_TOKEN,
+        )
+        logger.info(f"LLM client initialized for model: {settings.LLM_MODEL}")
+
+    return _llm_client
+
+
+def is_greeting(question: str) -> bool:
+    """Detect if the question is a casual greeting rather than a document query."""
+    greetings = {
+        "hi", "hello", "hey", "how are you", "what's up", "whats up",
+        "good morning", "good evening", "good afternoon", "thanks", "thank you",
+        "bye", "goodbye", "help", "what can you do", "who are you",
+    }
+    return question.lower().strip().rstrip("!?.") in greetings
+
+
+def build_context(chunks: List[Dict[str, Any]]) -> str:
+    """Format retrieved chunks into a context string."""
+    if not chunks:
+        return "No relevant document context was found."
+
+    context_parts = []
+    for i, chunk in enumerate(chunks, 1):
+        confidence = chunk.get("confidence", 0)
+        context_parts.append(
+            f"### Excerpt {i} — {chunk['filename']}, Page {chunk['page']} "
+            f"(Relevance: {confidence}%)\n\n{chunk['text']}"
+        )
+
+    return "\n\n---\n\n".join(context_parts)
+
+
+def _chat_messages(system: str, user_content: str) -> list:
+    """Build messages list for chat completion API."""
+    return [
+        {"role": "system", "content": system},
+        {"role": "user", "content": user_content},
+    ]
+
+
+def generate_answer(
+    question: str,
+    user_id: str,
+    document_id: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Full RAG pipeline: retrieve → build context → generate answer.
+    Returns dict with 'answer' and 'sources'.
+    """
+    client = get_llm_client()
+
+    # ── Handle greetings ─────────────────────────────
+    if is_greeting(question):
+        messages = _chat_messages(
+            "You are Document AI Analyst, a friendly AI assistant for document analysis.",
+            question,
+        )
+        response = client.chat_completion(
+            messages=messages,
+            model=settings.LLM_MODEL,
+            max_tokens=256,
+            temperature=0.7,
+        )
+        answer = response.choices[0].message.content.strip()
+        return {"answer": answer, "sources": []}
+
+    # ── Retrieve relevant chunks ─────────────────────
+    chunks = retrieve(
+        query=question,
+        user_id=user_id,
+        document_id=document_id,
+    )
+
+    # ── Build prompt ─────────────────────────────────
+    context = build_context(chunks)
+    user_content = RAG_PROMPT_TEMPLATE.format(context=context, question=question)
+    messages = _chat_messages(SYSTEM_PROMPT, user_content)
+
+    # ── Generate answer ──────────────────────────────
+    try:
+        response = client.chat_completion(
+            messages=messages,
+            model=settings.LLM_MODEL,
+            max_tokens=settings.LLM_MAX_NEW_TOKENS,
+            temperature=settings.LLM_TEMPERATURE,
+        )
+        answer = response.choices[0].message.content.strip()
+    except Exception as e:
+        logger.error(f"LLM generation error: {e}")
+        answer = f"I encountered an error generating a response. Please try again. Error: {str(e)}"
+
+    # ── Format sources ───────────────────────────────
+    sources = [
+        {
+            "text": chunk["text"][:300] + ("..." if len(chunk["text"]) > 300 else ""),
+            "filename": chunk["filename"],
+            "page": chunk["page"],
+            "score": chunk["score"],
+            "confidence": chunk["confidence"],
+        }
+        for chunk in chunks
+    ]
+
+    return {"answer": answer, "sources": sources}
+
+
+def generate_answer_stream(
+    question: str,
+    user_id: str,
+    document_id: Optional[str] = None,
+) -> Generator[str, None, None]:
+    """
+    Streaming RAG pipeline — yields SSE-formatted chunks.
+    First yields sources, then streams answer tokens.
+    """
+    client = get_llm_client()
+
+    # ── Handle greetings ─────────────────────────────
+    if is_greeting(question):
+        yield f"data: {json.dumps({'type': 'sources', 'data': []})}\n\n"
+
+        try:
+            messages = _chat_messages(
+                "You are Document AI Analyst, a friendly AI assistant for document analysis.",
+                question,
+            )
+            stream = client.chat_completion(
+                messages=messages,
+                model=settings.LLM_MODEL,
+                max_tokens=256,
+                temperature=0.7,
+                stream=True,
+            )
+            for chunk in stream:
+                delta = chunk.choices[0].delta.content
+                if delta:
+                    yield f"data: {json.dumps({'type': 'token', 'data': delta})}\n\n"
+        except Exception as e:
+            yield f"data: {json.dumps({'type': 'error', 'data': str(e)})}\n\n"
+
+        yield f"data: {json.dumps({'type': 'done'})}\n\n"
+        return
+
+    # ── Retrieve relevant chunks ─────────────────────
+    chunks = retrieve(
+        query=question,
+        user_id=user_id,
+        document_id=document_id,
+    )
+
+    # ── Yield sources first ──────────────────────────
+    sources = [
+        {
+            "text": chunk["text"][:300] + ("..." if len(chunk["text"]) > 300 else ""),
+            "filename": chunk["filename"],
+            "page": chunk["page"],
+            "score": chunk["score"],
+            "confidence": chunk["confidence"],
+        }
+        for chunk in chunks
+    ]
+    yield f"data: {json.dumps({'type': 'sources', 'data': sources})}\n\n"
+
+    # ── Build prompt ─────────────────────────────────
+    context = build_context(chunks)
+    user_content = RAG_PROMPT_TEMPLATE.format(context=context, question=question)
+    messages = _chat_messages(SYSTEM_PROMPT, user_content)
+
+    # ── Stream answer tokens ─────────────────────────
+    try:
+        stream = client.chat_completion(
+            messages=messages,
+            model=settings.LLM_MODEL,
+            max_tokens=settings.LLM_MAX_NEW_TOKENS,
+            temperature=settings.LLM_TEMPERATURE,
+            stream=True,
+        )
+        for chunk in stream:
+            delta = chunk.choices[0].delta.content
+            if delta:
+                yield f"data: {json.dumps({'type': 'token', 'data': delta})}\n\n"
+
+    except Exception as e:
+        logger.error(f"LLM streaming error: {e}")
+        yield f"data: {json.dumps({'type': 'error', 'data': str(e)})}\n\n"
+
+    yield f"data: {json.dumps({'type': 'done'})}\n\n"

backend/app/rag/chunker.py

@@ -0,0 +1,107 @@
+"""
+Smart document chunking using LangChain's RecursiveCharacterTextSplitter.
+Supports PDF, DOCX, TXT, and Markdown files with page-level metadata.
+"""
+import fitz  # PyMuPDF
+import docx
+from typing import List, Dict, Any
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from app.config import get_settings
+
+settings = get_settings()
+
+
+def extract_pdf(filepath: str) -> List[Dict[str, Any]]:
+    """Extract text from PDF with page numbers."""
+    doc = fitz.open(filepath)
+    pages = []
+
+    for page_num, page in enumerate(doc):
+        text = page.get_text()
+        if text.strip():
+            pages.append({
+                "text": text,
+                "page": page_num + 1,
+            })
+
+    doc.close()
+    return pages
+
+
+def extract_docx(filepath: str) -> List[Dict[str, Any]]:
+    """Extract text from DOCX files."""
+    doc = docx.Document(filepath)
+    full_text = "\n".join([para.text for para in doc.paragraphs if para.text.strip()])
+
+    return [{"text": full_text, "page": 1}] if full_text else []
+
+
+def extract_txt(filepath: str) -> List[Dict[str, Any]]:
+    """Extract text from TXT/Markdown files."""
+    with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
+        text = f.read()
+
+    return [{"text": text, "page": 1}] if text.strip() else []
+
+
+def chunk_document(filepath: str) -> List[Dict[str, Any]]:
+    """
+    Load a document, extract text per page, and split into semantic chunks.
+    Returns list of dicts with 'text', 'page', and 'chunk_index'.
+    """
+    ext = filepath.rsplit(".", 1)[-1].lower()
+
+    # ── Extract text by file type ────────────────────
+    if ext == "pdf":
+        pages = extract_pdf(filepath)
+    elif ext == "docx":
+        pages = extract_docx(filepath)
+    elif ext in ("txt", "md"):
+        pages = extract_txt(filepath)
+    else:
+        raise ValueError(f"Unsupported file type: {ext}")
+
+    if not pages:
+        return []
+
+    # ── LangChain recursive splitter ─────────────────
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=settings.CHUNK_SIZE,
+        chunk_overlap=settings.CHUNK_OVERLAP,
+        separators=["\n\n", "\n", ". ", " ", ""],
+        length_function=len,
+    )
+
+    all_chunks = []
+    chunk_index = 0
+
+    for page_data in pages:
+        text = page_data["text"]
+        page_num = page_data["page"]
+
+        # Split this page's text
+        splits = splitter.split_text(text)
+
+        for split_text in splits:
+            if split_text.strip():
+                all_chunks.append({
+                    "text": split_text.strip(),
+                    "page": page_num,
+                    "chunk_index": chunk_index,
+                })
+                chunk_index += 1
+
+    return all_chunks
+
+
+def get_page_count(filepath: str) -> int:
+    """Get total page count of a document."""
+    ext = filepath.rsplit(".", 1)[-1].lower()
+
+    if ext == "pdf":
+        doc = fitz.open(filepath)
+        count = len(doc)
+        doc.close()
+        return count
+
+    return 1  # DOCX, TXT, MD are treated as single-page

backend/app/rag/embeddings.py

@@ -0,0 +1,45 @@
+"""
+HuggingFace local embeddings using sentence-transformers.
+Loads the model once via singleton pattern for efficiency.
+"""
+import logging
+from typing import List
+from langchain_huggingface import HuggingFaceEmbeddings
+from app.config import get_settings
+
+logger = logging.getLogger(__name__)
+settings = get_settings()
+
+# ── Singleton embedding model ────────────────────────
+_embedding_model = None
+
+
+def get_embedding_model() -> HuggingFaceEmbeddings:
+    """
+    Get or create the embedding model (singleton).
+    Uses sentence-transformers/all-MiniLM-L6-v2 — lightweight 384-dim model.
+    """
+    global _embedding_model
+
+    if _embedding_model is None:
+        logger.info(f"Loading embedding model: {settings.EMBEDDING_MODEL}")
+        _embedding_model = HuggingFaceEmbeddings(
+            model_name=settings.EMBEDDING_MODEL,
+            model_kwargs={"device": "cpu"},
+            encode_kwargs={"normalize_embeddings": True, "batch_size": 32},
+        )
+        logger.info("Embedding model loaded successfully")
+
+    return _embedding_model
+
+
+def embed_texts(texts: List[str]) -> List[List[float]]:
+    """Embed a batch of texts into vectors."""
+    model = get_embedding_model()
+    return model.embed_documents(texts)
+
+
+def embed_query(query: str) -> List[float]:
+    """Embed a single query string."""
+    model = get_embedding_model()
+    return model.embed_query(query)

backend/app/rag/prompts.py

@@ -0,0 +1,53 @@
+"""
+Prompt templates for the RAG agent.
+Enforces citation format and chain-of-thought reasoning.
+"""
+
+SYSTEM_PROMPT = """You are Document AI Analyst, an expert AI assistant specialized in analyzing documents and providing accurate, well-cited answers.
+
+IMPORTANT RULES:
+1. Answer ONLY based on the provided document context. Do not use external knowledge.
+2. Always cite your sources using this exact format: [Source: filename, Page X]
+3. If the context doesn't contain enough information to answer, say: "I couldn't find sufficient information in the uploaded documents to answer this question."
+4. Be precise, clear, and well-structured in your responses.
+5. Use bullet points and formatting when listing multiple items.
+6. For numerical data or key facts, quote the relevant text directly.
+
+FORMATTING:
+- Use **bold** for key terms and important findings
+- Use bullet points for lists
+- Use > blockquotes for direct quotes from documents
+- Include citations inline with your answer"""
+
+
+RAG_PROMPT_TEMPLATE = """Based on the following document excerpts, answer the user's question accurately and cite your sources.
+
+## Document Context
+
+{context}
+
+## User Question
+
+{question}
+
+## Instructions
+
+Provide a comprehensive answer based strictly on the document context above. Include inline citations using [Source: filename, Page X] format for every claim you make. If the documents don't contain relevant information, clearly state that.
+
+## Answer
+"""
+
+
+GREETING_PROMPT = """You are Document AI Analyst, a friendly and professional AI assistant. The user has greeted you or asked a general question not related to any specific document.
+
+Respond naturally and briefly. Let them know you can help them:
+- Upload and analyze PDF, DOCX, TXT, and Markdown documents
+- Answer questions about their uploaded documents
+- Extract key insights, summaries, and specific data points
+- Provide accurate citations with page numbers
+
+Keep the response concise and friendly.
+
+User: {question}
+
+Response:"""

backend/app/rag/retriever.py

@@ -0,0 +1,96 @@
+"""
+Two-stage retrieval: ChromaDB similarity search + cross-encoder reranking.
+"""
+import logging
+from typing import List, Dict, Any, Optional
+from app.config import get_settings
+from app.rag.embeddings import embed_query
+from app.rag.vectorstore import query_chunks
+
+logger = logging.getLogger(__name__)
+settings = get_settings()
+
+# ── Singleton reranker ───────────────────────────────
+_reranker = None
+
+
+def get_reranker():
+    """Load cross-encoder reranker model (singleton)."""
+    global _reranker
+
+    if _reranker is None:
+        try:
+            from sentence_transformers import CrossEncoder
+            logger.info(f"Loading reranker: {settings.RERANKER_MODEL}")
+            _reranker = CrossEncoder(settings.RERANKER_MODEL, max_length=512)
+            logger.info("Reranker loaded successfully")
+        except Exception as e:
+            logger.warning(f"Failed to load reranker: {e}. Falling back to embedding-only retrieval.")
+            _reranker = "disabled"
+
+    return _reranker if _reranker != "disabled" else None
+
+
+def retrieve(
+    query: str,
+    user_id: str,
+    document_id: Optional[str] = None,
+) -> List[Dict[str, Any]]:
+    """
+    Two-stage retrieval pipeline:
+    1. ChromaDB similarity search (top-K broad)
+    2. Cross-encoder reranking (top-K refined)
+
+    Returns chunks with confidence scores.
+    """
+    # ── Stage 1: Embedding search ────────────────────
+    query_vector = embed_query(query)
+    candidates = query_chunks(
+        query_embedding=query_vector,
+        user_id=user_id,
+        document_id=document_id,
+        top_k=settings.TOP_K_RETRIEVAL,
+    )
+
+    if not candidates:
+        return []
+
+    # ── Stage 2: Cross-encoder reranking ─────────────
+    reranker = get_reranker()
+
+    if reranker is not None and len(candidates) > 1:
+        try:
+            # Build query-document pairs for reranking
+            pairs = [(query, chunk["text"]) for chunk in candidates]
+            rerank_scores = reranker.predict(pairs)
+
+            # Assign rerank scores
+            for i, chunk in enumerate(candidates):
+                chunk["rerank_score"] = float(rerank_scores[i])
+
+            # Sort by rerank score (descending)
+            candidates.sort(key=lambda x: x.get("rerank_score", 0), reverse=True)
+
+        except Exception as e:
+            logger.warning(f"Reranking failed, using embedding scores: {e}")
+
+    # ── Take top-K after reranking ───────────────────
+    top_chunks = candidates[:settings.TOP_K_RERANK]
+
+    # ── Calculate confidence percentages ─────────────
+    if top_chunks:
+        max_score = max(
+            chunk.get("rerank_score", chunk.get("score", 0))
+            for chunk in top_chunks
+        )
+        max_score = max(max_score, 0.001)  # Avoid division by zero
+
+        for chunk in top_chunks:
+            raw = chunk.get("rerank_score", chunk.get("score", 0))
+            chunk["confidence"] = round((raw / max_score) * 100, 1)
+            # Clean up internal score
+            if "rerank_score" in chunk:
+                chunk["score"] = round(chunk["rerank_score"], 4)
+                del chunk["rerank_score"]
+
+    return top_chunks

backend/app/rag/vectorstore.py

@@ -0,0 +1,186 @@
+"""
+ChromaDB vector store operations.
+Per-user collections for data isolation.
+"""
+import logging
+from typing import List, Dict, Any, Optional
+import chromadb
+from chromadb.config import Settings as ChromaSettings
+from app.config import get_settings
+from app.rag.embeddings import get_embedding_model
+
+logger = logging.getLogger(__name__)
+settings = get_settings()
+
+# ── Singleton ChromaDB client ────────────────────────
+_chroma_client = None
+
+
+def get_chroma_client() -> chromadb.ClientAPI:
+    """Get or create persistent ChromaDB client."""
+    global _chroma_client
+
+    if _chroma_client is None:
+        import os
+        os.makedirs(settings.CHROMA_PERSIST_DIR, exist_ok=True)
+
+        _chroma_client = chromadb.PersistentClient(
+            path=settings.CHROMA_PERSIST_DIR,
+            settings=ChromaSettings(anonymized_telemetry=False),
+        )
+        logger.info(f"ChromaDB initialized at {settings.CHROMA_PERSIST_DIR}")
+
+    return _chroma_client
+
+
+def get_collection_name(user_id: str) -> str:
+    """Generate a valid collection name for a user."""
+    # ChromaDB collection names must be 3-63 chars, alphanumeric + underscores
+    clean_id = user_id.replace("-", "_")
+    name = f"user_{clean_id}"
+    # Truncate if too long
+    return name[:63]
+
+
+def store_chunks(
+    chunks: List[Dict[str, Any]],
+    document_id: str,
+    filename: str,
+    user_id: str,
+) -> int:
+    """
+    Embed and store document chunks in ChromaDB.
+    Returns the number of chunks stored.
+    """
+    if not chunks:
+        return 0
+
+    client = get_chroma_client()
+    embedding_model = get_embedding_model()
+
+    collection_name = get_collection_name(user_id)
+    collection = client.get_or_create_collection(
+        name=collection_name,
+        metadata={"hnsw:space": "cosine"},
+    )
+
+    # ── Prepare batch data ───────────────────────────
+    texts = [chunk["text"] for chunk in chunks]
+    ids = [f"{document_id}_{chunk['chunk_index']}" for chunk in chunks]
+    metadatas = [
+        {
+            "text": chunk["text"],
+            "filename": filename,
+            "document_id": document_id,
+            "page": chunk["page"],
+            "chunk_index": chunk["chunk_index"],
+        }
+        for chunk in chunks
+    ]
+
+    # ── Embed and upsert in batches ──────────────────
+    batch_size = 50
+    total_stored = 0
+
+    for i in range(0, len(texts), batch_size):
+        batch_texts = texts[i:i + batch_size]
+        batch_ids = ids[i:i + batch_size]
+        batch_metadatas = metadatas[i:i + batch_size]
+
+        # Generate embeddings
+        embeddings = embedding_model.embed_documents(batch_texts)
+
+        collection.add(
+            ids=batch_ids,
+            embeddings=embeddings,
+            metadatas=batch_metadatas,
+            documents=batch_texts,
+        )
+        total_stored += len(batch_texts)
+
+    logger.info(f"Stored {total_stored} chunks for document {document_id}")
+    return total_stored
+
+
+def query_chunks(
+    query_embedding: List[float],
+    user_id: str,
+    document_id: Optional[str] = None,
+    top_k: int = 10,
+) -> List[Dict[str, Any]]:
+    """
+    Query ChromaDB for relevant chunks.
+    Returns list of dicts with text, metadata, and distance.
+    """
+    client = get_chroma_client()
+    collection_name = get_collection_name(user_id)
+
+    try:
+        collection = client.get_collection(name=collection_name)
+    except Exception:
+        logger.warning(f"Collection {collection_name} not found")
+        return []
+
+    # ── Build filter ─────────────────────────────────
+    where_filter = None
+    if document_id:
+        where_filter = {"document_id": {"$eq": document_id}}
+
+    # ── Query ────────────────────────────────────────
+    results = collection.query(
+        query_embeddings=[query_embedding],
+        n_results=top_k,
+        where=where_filter,
+        include=["documents", "metadatas", "distances"],
+    )
+
+    # ── Format results ───────────────────────────────
+    chunks = []
+    if results and results["documents"] and results["documents"][0]:
+        for i, doc in enumerate(results["documents"][0]):
+            metadata = results["metadatas"][0][i] if results["metadatas"] else {}
+            distance = results["distances"][0][i] if results["distances"] else 0
+
+            # Convert cosine distance to similarity score (0-1)
+            similarity = 1 - distance
+
+            chunks.append({
+                "text": doc,
+                "filename": metadata.get("filename", ""),
+                "document_id": metadata.get("document_id", ""),
+                "page": metadata.get("page", 1),
+                "score": round(similarity, 4),
+            })
+
+    return chunks
+
+
+def delete_document_chunks(document_id: str, user_id: str):
+    """Delete all chunks for a specific document."""
+    client = get_chroma_client()
+    collection_name = get_collection_name(user_id)
+
+    try:
+        collection = client.get_collection(name=collection_name)
+        # Get all IDs for this document
+        results = collection.get(
+            where={"document_id": {"$eq": document_id}},
+            include=[],
+        )
+        if results["ids"]:
+            collection.delete(ids=results["ids"])
+            logger.info(f"Deleted {len(results['ids'])} chunks for document {document_id}")
+    except Exception as e:
+        logger.warning(f"Error deleting chunks: {e}")
+
+
+def delete_user_collection(user_id: str):
+    """Delete entire collection for a user."""
+    client = get_chroma_client()
+    collection_name = get_collection_name(user_id)
+
+    try:
+        client.delete_collection(name=collection_name)
+        logger.info(f"Deleted collection {collection_name}")
+    except Exception as e:
+        logger.warning(f"Error deleting collection: {e}")

backend/app/routes/__init__.py

@@ -0,0 +1 @@
+# API Routes

backend/app/routes/auth.py

@@ -0,0 +1,73 @@
+"""
+Auth API routes — register, login, and user profile.
+"""
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+
+from app.database import get_db
+from app.models import User
+from app.schemas import UserRegister, UserLogin, TokenResponse, UserResponse
+from app.auth import hash_password, verify_password, create_token, get_current_user
+
+router = APIRouter(prefix="/auth", tags=["Authentication"])
+
+
+@router.post("/register", response_model=TokenResponse, status_code=status.HTTP_201_CREATED)
+def register(payload: UserRegister, db: Session = Depends(get_db)):
+    """Register a new user account."""
+    # Check existing username
+    if db.query(User).filter(User.username == payload.username).first():
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail="Username already taken",
+        )
+
+    # Check existing email
+    if db.query(User).filter(User.email == payload.email).first():
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail="Email already registered",
+        )
+
+    # Create user
+    user = User(
+        username=payload.username,
+        email=payload.email,
+        hashed_password=hash_password(payload.password),
+    )
+    db.add(user)
+    db.commit()
+    db.refresh(user)
+
+    # Generate token
+    token = create_token(user.id)
+
+    return TokenResponse(
+        access_token=token,
+        user=UserResponse.model_validate(user),
+    )
+
+
+@router.post("/login", response_model=TokenResponse)
+def login(payload: UserLogin, db: Session = Depends(get_db)):
+    """Login with email and password."""
+    user = db.query(User).filter(User.email == payload.email).first()
+
+    if not user or not verify_password(payload.password, user.hashed_password):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid email or password",
+        )
+
+    token = create_token(user.id)
+
+    return TokenResponse(
+        access_token=token,
+        user=UserResponse.model_validate(user),
+    )
+
+
+@router.get("/me", response_model=UserResponse)
+def get_me(user: User = Depends(get_current_user)):
+    """Get current authenticated user profile."""
+    return UserResponse.model_validate(user)

backend/app/routes/chat.py

@@ -0,0 +1,202 @@
+"""
+Chat routes — ask questions with RAG, stream responses via SSE, manage history.
+"""
+import json
+import logging
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import StreamingResponse
+from sqlalchemy.orm import Session
+
+from app.database import get_db
+from app.models import User, ChatMessage, Document
+from app.schemas import ChatRequest, ChatResponse, ChatMessageResponse, ChatHistoryResponse, SourceChunk
+from app.auth import get_current_user
+from app.rag.agent import generate_answer, generate_answer_stream
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/chat", tags=["Chat"])
+
+
+@router.post("/ask", response_model=ChatResponse)
+def ask_question(
+    payload: ChatRequest,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+    """Ask a question with RAG retrieval (non-streaming)."""
+    # Validate document exists if specified
+    if payload.document_id:
+        doc = db.query(Document).filter(
+            Document.id == payload.document_id,
+            Document.user_id == user.id,
+        ).first()
+
+        if not doc:
+            raise HTTPException(status_code=404, detail="Document not found")
+
+        if doc.status != "ready":
+            raise HTTPException(
+                status_code=400,
+                detail=f"Document is still {doc.status}. Please wait for processing to complete.",
+            )
+
+    # Generate answer
+    result = generate_answer(
+        question=payload.question,
+        user_id=user.id,
+        document_id=payload.document_id,
+    )
+
+    # Save to chat history
+    _save_message(db, user.id, payload.document_id, "user", payload.question)
+    _save_message(db, user.id, payload.document_id, "assistant", result["answer"], result["sources"])
+
+    return ChatResponse(
+        answer=result["answer"],
+        sources=[SourceChunk(**s) for s in result["sources"]],
+        document_id=payload.document_id,
+    )
+
+
+@router.post("/ask/stream")
+def ask_question_stream(
+    payload: ChatRequest,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+    """Ask a question with SSE streaming response."""
+    # Validate document
+    if payload.document_id:
+        doc = db.query(Document).filter(
+            Document.id == payload.document_id,
+            Document.user_id == user.id,
+        ).first()
+
+        if not doc:
+            raise HTTPException(status_code=404, detail="Document not found")
+
+        if doc.status != "ready":
+            raise HTTPException(
+                status_code=400,
+                detail=f"Document is still {doc.status}. Please wait for processing to complete.",
+            )
+
+    # Save user message immediately
+    _save_message(db, user.id, payload.document_id, "user", payload.question)
+
+    # Stream response
+    def event_stream():
+        full_answer = ""
+        sources = []
+
+        for chunk in generate_answer_stream(
+            question=payload.question,
+            user_id=user.id,
+            document_id=payload.document_id,
+        ):
+            yield chunk
+
+            # Parse to accumulate full answer for history
+            try:
+                if chunk.startswith("data: "):
+                    data = json.loads(chunk[6:].strip())
+                    if data.get("type") == "token":
+                        full_answer += data.get("data", "")
+                    elif data.get("type") == "sources":
+                        sources = data.get("data", [])
+            except Exception:
+                pass
+
+        # Save assistant response to history
+        from app.database import SessionLocal
+        save_db = SessionLocal()
+        try:
+            _save_message(save_db, user.id, payload.document_id, "assistant", full_answer, sources)
+        finally:
+            save_db.close()
+
+    return StreamingResponse(
+        event_stream(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+        },
+    )
+
+
+@router.get("/history/{document_id}", response_model=ChatHistoryResponse)
+def get_chat_history(
+    document_id: str,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+    """Get chat history for a specific document."""
+    messages = (
+        db.query(ChatMessage)
+        .filter(
+            ChatMessage.user_id == user.id,
+            ChatMessage.document_id == document_id,
+        )
+        .order_by(ChatMessage.created_at.asc())
+        .all()
+    )
+
+    formatted = []
+    for msg in messages:
+        sources = []
+        if msg.sources_json:
+            try:
+                sources = [SourceChunk(**s) for s in json.loads(msg.sources_json)]
+            except Exception:
+                pass
+
+        formatted.append(ChatMessageResponse(
+            id=msg.id,
+            role=msg.role,
+            content=msg.content,
+            sources=sources,
+            created_at=msg.created_at,
+        ))
+
+    return ChatHistoryResponse(messages=formatted, document_id=document_id)
+
+
+@router.delete("/history/{document_id}")
+def clear_chat_history(
+    document_id: str,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+    """Clear chat history for a specific document."""
+    db.query(ChatMessage).filter(
+        ChatMessage.user_id == user.id,
+        ChatMessage.document_id == document_id,
+    ).delete()
+    db.commit()
+
+    return {"message": "Chat history cleared"}
+
+
+def _save_message(
+    db: Session,
+    user_id: str,
+    document_id: Optional[str],
+    role: str,
+    content: str,
+    sources: list = None,
+):
+    """Helper: save a chat message to the database."""
+    msg = ChatMessage(
+        user_id=user_id,
+        document_id=document_id,
+        role=role,
+        content=content,
+        sources_json=json.dumps(sources) if sources else None,
+    )
+    db.add(msg)
+    db.commit()

backend/app/routes/documents.py

@@ -0,0 +1,245 @@
+"""
+Document management routes — upload, list, delete, and serve PDF files.
+Background ingestion via FastAPI BackgroundTasks.
+"""
+import os
+import uuid
+import logging
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, BackgroundTasks, status
+from fastapi.responses import FileResponse
+from sqlalchemy.orm import Session
+
+from app.database import get_db
+from app.models import User, Document
+from app.schemas import DocumentResponse, DocumentListResponse
+from app.auth import get_current_user
+from app.config import get_settings
+from app.rag.chunker import chunk_document, get_page_count
+from app.rag.vectorstore import store_chunks, delete_document_chunks
+
+logger = logging.getLogger(__name__)
+settings = get_settings()
+
+router = APIRouter(prefix="/documents", tags=["Documents"])
+
+
+def _ingest_document(document_id: str, filepath: str, original_name: str, user_id: str):
+    """
+    Background task: chunk document, generate embeddings, store in ChromaDB.
+    Updates document status in the database.
+    """
+    from app.database import SessionLocal
+
+    db = SessionLocal()
+    try:
+        doc = db.query(Document).filter(Document.id == document_id).first()
+        if not doc:
+            logger.error(f"Document {document_id} not found for ingestion")
+            return
+
+        # Update status to processing
+        doc.status = "processing"
+        db.commit()
+
+        # Get page count
+        page_count = get_page_count(filepath)
+        doc.page_count = page_count
+
+        # Chunk the document
+        chunks = chunk_document(filepath)
+
+        if not chunks:
+            doc.status = "failed"
+            doc.error_message = "No text could be extracted from the document"
+            db.commit()
+            return
+
+        # Store embeddings in ChromaDB
+        chunk_count = store_chunks(
+            chunks=chunks,
+            document_id=document_id,
+            filename=original_name,
+            user_id=user_id,
+        )
+
+        # Update document record
+        doc.chunk_count = chunk_count
+        doc.status = "ready"
+        db.commit()
+
+        logger.info(f"Document {document_id} ingested: {page_count} pages, {chunk_count} chunks")
+
+    except Exception as e:
+        logger.error(f"Ingestion error for {document_id}: {e}")
+        try:
+            doc = db.query(Document).filter(Document.id == document_id).first()
+            if doc:
+                doc.status = "failed"
+                doc.error_message = str(e)[:500]
+                db.commit()
+        except Exception:
+            pass
+    finally:
+        db.close()
+
+
+@router.post("/upload", response_model=DocumentResponse, status_code=status.HTTP_201_CREATED)
+async def upload_document(
+    background_tasks: BackgroundTasks,
+    file: UploadFile = File(...),
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+    """Upload a document for RAG processing."""
+    # ── Validate file type ───────────────────────────
+    if not file.filename:
+        raise HTTPException(status_code=400, detail="No filename provided")
+
+    ext = file.filename.rsplit(".", 1)[-1].lower()
+    if ext not in settings.ALLOWED_EXTENSIONS:
+        raise HTTPException(
+            status_code=400,
+            detail=f"File type '.{ext}' not supported. Allowed: {', '.join(settings.ALLOWED_EXTENSIONS)}",
+        )
+
+    # ── Read and validate size ───────────────────────
+    content = await file.read()
+    file_size = len(content)
+
+    if file_size > settings.MAX_FILE_SIZE_MB * 1024 * 1024:
+        raise HTTPException(
+            status_code=400,
+            detail=f"File too large. Maximum size: {settings.MAX_FILE_SIZE_MB}MB",
+        )
+
+    # ── Save file to disk ────────────────────────────
+    user_dir = os.path.join(settings.UPLOAD_DIR, user.id)
+    os.makedirs(user_dir, exist_ok=True)
+
+    stored_filename = f"{uuid.uuid4().hex}.{ext}"
+    filepath = os.path.join(user_dir, stored_filename)
+
+    with open(filepath, "wb") as f:
+        f.write(content)
+
+    # ── Create database record ───────────────────────
+    document = Document(
+        user_id=user.id,
+        filename=stored_filename,
+        original_name=file.filename,
+        file_size=file_size,
+        status="pending",
+    )
+    db.add(document)
+    db.commit()
+    db.refresh(document)
+
+    # ── Trigger background ingestion ─────────────────
+    background_tasks.add_task(
+        _ingest_document,
+        document_id=document.id,
+        filepath=filepath,
+        original_name=file.filename,
+        user_id=user.id,
+    )
+
+    return DocumentResponse.model_validate(document)
+
+
+@router.get("/", response_model=DocumentListResponse)
+def list_documents(
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+    """List all documents for the authenticated user."""
+    docs = (
+        db.query(Document)
+        .filter(Document.user_id == user.id)
+        .order_by(Document.uploaded_at.desc())
+        .all()
+    )
+
+    return DocumentListResponse(
+        documents=[DocumentResponse.model_validate(d) for d in docs],
+        total=len(docs),
+    )
+
+
+@router.get("/{document_id}", response_model=DocumentResponse)
+def get_document(
+    document_id: str,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+    """Get a specific document's details."""
+    doc = db.query(Document).filter(
+        Document.id == document_id,
+        Document.user_id == user.id,
+    ).first()
+
+    if not doc:
+        raise HTTPException(status_code=404, detail="Document not found")
+
+    return DocumentResponse.model_validate(doc)
+
+
+@router.get("/{document_id}/pdf")
+def serve_pdf(
+    document_id: str,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+    """Serve the PDF file for the document viewer."""
+    doc = db.query(Document).filter(
+        Document.id == document_id,
+        Document.user_id == user.id,
+    ).first()
+
+    if not doc:
+        raise HTTPException(status_code=404, detail="Document not found")
+
+    filepath = os.path.join(settings.UPLOAD_DIR, user.id, doc.filename)
+
+    if not os.path.exists(filepath):
+        raise HTTPException(status_code=404, detail="File not found on disk")
+
+    return FileResponse(
+        filepath,
+        media_type="application/pdf",
+        filename=doc.original_name,
+    )
+
+
+@router.delete("/{document_id}", status_code=status.HTTP_200_OK)
+def delete_document(
+    document_id: str,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+    """Delete a document and its vector embeddings."""
+    doc = db.query(Document).filter(
+        Document.id == document_id,
+        Document.user_id == user.id,
+    ).first()
+
+    if not doc:
+        raise HTTPException(status_code=404, detail="Document not found")
+
+    # Delete file from disk
+    filepath = os.path.join(settings.UPLOAD_DIR, user.id, doc.filename)
+    if os.path.exists(filepath):
+        os.remove(filepath)
+
+    # Delete vectors from ChromaDB
+    try:
+        delete_document_chunks(document_id=document_id, user_id=user.id)
+    except Exception as e:
+        logger.warning(f"Error deleting vectors: {e}")
+
+    # Delete from database (cascades to chat messages)
+    db.delete(doc)
+    db.commit()
+
+    return {"message": f"Document '{doc.original_name}' deleted successfully"}

backend/app/schemas.py

@@ -0,0 +1,98 @@
+"""
+Pydantic schemas for API request/response validation.
+"""
+from pydantic import BaseModel, EmailStr, Field
+from typing import Optional, List
+from datetime import datetime
+
+
+# ── Auth ─────────────────────────────────────────────
+
+class UserRegister(BaseModel):
+    username: str = Field(..., min_length=3, max_length=80)
+    email: EmailStr
+    password: str = Field(..., min_length=6)
+
+
+class UserLogin(BaseModel):
+    email: EmailStr
+    password: str
+
+
+class TokenResponse(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+    user: "UserResponse"
+
+
+class UserResponse(BaseModel):
+    id: str
+    username: str
+    email: str
+    is_admin: bool
+    created_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+# ── Documents ────────────────────────────────────────
+
+class DocumentResponse(BaseModel):
+    id: str
+    original_name: str
+    file_size: int
+    page_count: int
+    chunk_count: int
+    status: str
+    error_message: Optional[str] = None
+    uploaded_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class DocumentListResponse(BaseModel):
+    documents: List[DocumentResponse]
+    total: int
+
+
+# ── Chat ─────────────────────────────────────────────
+
+class ChatRequest(BaseModel):
+    question: str = Field(..., min_length=1, max_length=2000)
+    document_id: Optional[str] = None
+
+
+class SourceChunk(BaseModel):
+    text: str
+    filename: str
+    page: int
+    score: float
+    confidence: float
+
+
+class ChatResponse(BaseModel):
+    answer: str
+    sources: List[SourceChunk] = []
+    document_id: Optional[str] = None
+
+
+class ChatMessageResponse(BaseModel):
+    id: str
+    role: str
+    content: str
+    sources: List[SourceChunk] = []
+    created_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class ChatHistoryResponse(BaseModel):
+    messages: List[ChatMessageResponse]
+    document_id: Optional[str] = None
+
+
+# Rebuild models for forward references
+TokenResponse.model_rebuild()

backend/requirements.txt

@@ -0,0 +1,42 @@
+# ── Enterprise Agentic RAG System — Backend Dependencies ──
+
+# Core Framework
+fastapi
+uvicorn[standard]
+python-multipart
+
+# Database
+sqlalchemy
+aiosqlite
+
+# Auth
+pyjwt
+passlib[bcrypt]
+python-dotenv
+
+# Config
+pydantic-settings
+pydantic[email]
+
+# Document Processing
+PyMuPDF
+python-docx
+
+# LangChain & RAG
+langchain
+langchain-community
+langchain-huggingface
+langchain-text-splitters
+
+# Embeddings & ML
+sentence-transformers
+transformers
+
+# Vector Database
+chromadb
+
+# LLM Inference
+huggingface-hub
+
+# Production
+gunicorn

docker-compose.yml

@@ -1,31 +1,19 @@
 version: '3.8'
 
 services:
-  web:
+  app:
     build: .
     ports:
-      - "5000:5000"
+      - "7860:7860"
     volumes:
-      - ./uploads:/app/uploads
-      - ./vectorstore:/app/vectorstore
+      - app_data:/app/data
     environment:
-      - MONGO_URI=mongodb://mongo:27017/rag_app
-      # Google OAuth Keys should be passed through .env
-      - GOOGLE_CLIENT_ID=${GOOGLE_CLIENT_ID}
-      - GOOGLE_CLIENT_SECRET=${GOOGLE_CLIENT_SECRET}
-      - SECRET_KEY=${SECRET_KEY}
-      - ENCRYPTION_KEY=${ENCRYPTION_KEY}
-    depends_on:
-      - mongo
-    restart: always
-
-  mongo:
-    image: mongo:6.0
-    ports:
-      - "27017:27017"
-    volumes:
-      - mongo_data:/data/db
-    restart: always
+      - SECRET_KEY=${SECRET_KEY:-dev-secret-key-change-me}
+      - HF_TOKEN=${HF_TOKEN}
+      - DATABASE_URL=sqlite:///./data/app.db
+      - UPLOAD_DIR=./data/uploads
+      - CHROMA_PERSIST_DIR=./data/chroma_db
+    restart: unless-stopped
 
 volumes:
-  mongo_data:
+  app_data:

frontend/.gitignore

@@ -0,0 +1,41 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files (can opt-in for committing if needed)
+.env*
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts

frontend/AGENTS.md

@@ -0,0 +1,5 @@
+<!-- BEGIN:nextjs-agent-rules -->
+# This is NOT the Next.js you know
+
+This version has breaking changes — APIs, conventions, and file structure may all differ from your training data. Read the relevant guide in `node_modules/next/dist/docs/` before writing any code. Heed deprecation notices.
+<!-- END:nextjs-agent-rules -->

frontend/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

frontend/README.md

@@ -0,0 +1,36 @@
+This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).
+
+## Getting Started
+
+First, run the development server:
+
+```bash
+npm run dev
+# or
+yarn dev
+# or
+pnpm dev
+# or
+bun dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
+
+You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.
+
+This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load [Geist](https://vercel.com/font), a new font family for Vercel.
+
+## Learn More
+
+To learn more about Next.js, take a look at the following resources:
+
+- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
+- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
+
+You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!
+
+## Deploy on Vercel
+
+The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
+
+Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.

frontend/components.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "base-nova",
+  "rsc": true,
+  "tsx": true,
+  "tailwind": {
+    "config": "",
+    "css": "src/app/globals.css",
+    "baseColor": "neutral",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "iconLibrary": "lucide",
+  "rtl": false,
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  },
+  "menuColor": "default",
+  "menuAccent": "subtle",
+  "registries": {}
+}

frontend/eslint.config.mjs

@@ -0,0 +1,18 @@
+import { defineConfig, globalIgnores } from "eslint/config";
+import nextVitals from "eslint-config-next/core-web-vitals";
+import nextTs from "eslint-config-next/typescript";
+
+const eslintConfig = defineConfig([
+  ...nextVitals,
+  ...nextTs,
+  // Override default ignores of eslint-config-next.
+  globalIgnores([
+    // Default ignores of eslint-config-next:
+    ".next/**",
+    "out/**",
+    "build/**",
+    "next-env.d.ts",
+  ]),
+]);
+
+export default eslintConfig;

frontend/next.config.ts

@@ -0,0 +1,10 @@
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  output: "export",
+  images: { unoptimized: true },
+  // Turbopack config (Next.js 16 default bundler)
+  turbopack: {},
+};
+
+export default nextConfig;

frontend/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "frontend",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "eslint"
+  },
+  "dependencies": {
+    "@base-ui/react": "^1.4.1",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "lucide-react": "^1.8.0",
+    "next": "16.2.4",
+    "pdfjs-dist": "^5.6.205",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "react-dropzone": "^15.0.0",
+    "react-markdown": "^10.1.0",
+    "react-pdf": "^10.4.1",
+    "remark-gfm": "^4.0.1",
+    "shadcn": "^4.3.1",
+    "tailwind-merge": "^3.5.0",
+    "tw-animate-css": "^1.4.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "eslint": "^9",
+    "eslint-config-next": "16.2.4",
+    "tailwindcss": "^4",
+    "typescript": "^5"
+  }
+}

frontend/postcss.config.mjs

@@ -0,0 +1,7 @@
+const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;

frontend/src/app/dashboard/page.tsx

@@ -0,0 +1,121 @@
+"use client";
+
+import { useEffect, useState, useCallback } from "react";
+import { useRouter } from "next/navigation";
+import { useAuth } from "@/lib/auth";
+import { api } from "@/lib/api";
+import Header from "@/components/layout/Header";
+import DocumentSidebar from "@/components/document/DocumentSidebar";
+import ChatPanel from "@/components/chat/ChatPanel";
+import PDFViewer from "@/components/document/PDFViewer";
+
+export interface DocInfo {
+  id: string;
+  original_name: string;
+  file_size: number;
+  page_count: number;
+  chunk_count: number;
+  status: string;
+  error_message: string | null;
+  uploaded_at: string;
+}
+
+export default function DashboardPage() {
+  const { user, loading } = useAuth();
+  const router = useRouter();
+
+  const [documents, setDocuments] = useState<DocInfo[]>([]);
+  const [activeDoc, setActiveDoc] = useState<DocInfo | null>(null);
+  const [pdfPage, setPdfPage] = useState(1);
+  const [sidebarOpen, setSidebarOpen] = useState(true);
+  const [viewerOpen, setViewerOpen] = useState(true);
+
+  // Auth guard
+  useEffect(() => {
+    if (!loading && !user) router.replace("/login");
+  }, [user, loading, router]);
+
+  // Load documents
+  const loadDocuments = useCallback(async () => {
+    try {
+      const data = await api.get<{ documents: DocInfo[] }>("/api/v1/documents/");
+      setDocuments(data.documents);
+    } catch {
+      // silently fail
+    }
+  }, []);
+
+  useEffect(() => {
+    if (user) loadDocuments();
+  }, [user, loadDocuments]);
+
+  // Poll for processing status
+  useEffect(() => {
+    const hasPending = documents.some(
+      (d) => d.status === "pending" || d.status === "processing"
+    );
+    if (!hasPending) return;
+
+    const interval = setInterval(loadDocuments, 3000);
+    return () => clearInterval(interval);
+  }, [documents, loadDocuments]);
+
+  if (loading || !user) {
+    return (
+      <div className="min-h-screen flex items-center justify-center">
+        <div className="animate-pulse-glow w-12 h-12 rounded-full bg-primary/20" />
+      </div>
+    );
+  }
+
+  return (
+    <div className="h-screen flex flex-col overflow-hidden">
+      <Header
+        sidebarOpen={sidebarOpen}
+        onToggleSidebar={() => setSidebarOpen(!sidebarOpen)}
+        viewerOpen={viewerOpen}
+        onToggleViewer={() => setViewerOpen(!viewerOpen)}
+      />
+
+      <div className="flex-1 flex overflow-hidden">
+        {/* ── Left: Document Sidebar ──────────────── */}
+        {sidebarOpen && (
+          <div className="w-72 flex-shrink-0 border-r border-border/50 overflow-hidden animate-fade-in-up">
+            <DocumentSidebar
+              documents={documents}
+              activeDoc={activeDoc}
+              onSelectDoc={(doc) => {
+                setActiveDoc(doc);
+                setPdfPage(1);
+              }}
+              onDocumentsChange={loadDocuments}
+            />
+          </div>
+        )}
+
+        {/* ── Center: Chat Panel ─────────────────── */}
+        <div className="flex-1 min-w-0 flex flex-col">
+          <ChatPanel
+            activeDoc={activeDoc}
+            onCitationClick={(page) => {
+              setPdfPage(page);
+              if (!viewerOpen) setViewerOpen(true);
+            }}
+          />
+        </div>
+
+        {/* ── Right: PDF Viewer ──────────────────── */}
+        {viewerOpen && activeDoc && activeDoc.original_name.endsWith(".pdf") && (
+          <div className="w-[480px] flex-shrink-0 border-l border-border/50 overflow-hidden animate-fade-in-up">
+            <PDFViewer
+              documentId={activeDoc.id}
+              currentPage={pdfPage}
+              onPageChange={setPdfPage}
+              totalPages={activeDoc.page_count}
+            />
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}

frontend/src/app/globals.css

@@ -0,0 +1,215 @@
+@import "tailwindcss";
+@import "tw-animate-css";
+@import "shadcn/tailwind.css";
+
+@custom-variant dark (&:is(.dark *));
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --font-sans: var(--font-sans);
+  --font-mono: var(--font-geist-mono);
+  --font-heading: var(--font-sans);
+  --color-sidebar-ring: var(--sidebar-ring);
+  --color-sidebar-border: var(--sidebar-border);
+  --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+  --color-sidebar-accent: var(--sidebar-accent);
+  --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+  --color-sidebar-primary: var(--sidebar-primary);
+  --color-sidebar-foreground: var(--sidebar-foreground);
+  --color-sidebar: var(--sidebar);
+  --color-chart-5: var(--chart-5);
+  --color-chart-4: var(--chart-4);
+  --color-chart-3: var(--chart-3);
+  --color-chart-2: var(--chart-2);
+  --color-chart-1: var(--chart-1);
+  --color-ring: var(--ring);
+  --color-input: var(--input);
+  --color-border: var(--border);
+  --color-destructive: var(--destructive);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-accent: var(--accent);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-muted: var(--muted);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-secondary: var(--secondary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-primary: var(--primary);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-popover: var(--popover);
+  --color-card-foreground: var(--card-foreground);
+  --color-card: var(--card);
+  --radius-sm: calc(var(--radius) * 0.6);
+  --radius-md: calc(var(--radius) * 0.8);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) * 1.4);
+  --radius-2xl: calc(var(--radius) * 1.8);
+  --radius-3xl: calc(var(--radius) * 2.2);
+  --radius-4xl: calc(var(--radius) * 2.6);
+}
+
+:root {
+  --background: oklch(0.145 0 0);
+  --foreground: oklch(0.985 0 0);
+  --card: oklch(0.178 0 0);
+  --card-foreground: oklch(0.985 0 0);
+  --popover: oklch(0.178 0 0);
+  --popover-foreground: oklch(0.985 0 0);
+  --primary: oklch(0.65 0.2 265);
+  --primary-foreground: oklch(0.985 0 0);
+  --secondary: oklch(0.22 0 0);
+  --secondary-foreground: oklch(0.985 0 0);
+  --muted: oklch(0.22 0 0);
+  --muted-foreground: oklch(0.6 0 0);
+  --accent: oklch(0.55 0.18 265);
+  --accent-foreground: oklch(0.985 0 0);
+  --destructive: oklch(0.704 0.191 22.216);
+  --border: oklch(1 0 0 / 10%);
+  --input: oklch(1 0 0 / 12%);
+  --ring: oklch(0.65 0.2 265);
+  --chart-1: oklch(0.75 0.18 265);
+  --chart-2: oklch(0.65 0.2 160);
+  --chart-3: oklch(0.55 0.23 30);
+  --chart-4: oklch(0.7 0.15 200);
+  --chart-5: oklch(0.6 0.2 300);
+  --radius: 0.625rem;
+  --sidebar: oklch(0.12 0 0);
+  --sidebar-foreground: oklch(0.985 0 0);
+  --sidebar-primary: oklch(0.65 0.2 265);
+  --sidebar-primary-foreground: oklch(0.985 0 0);
+  --sidebar-accent: oklch(0.22 0 0);
+  --sidebar-accent-foreground: oklch(0.985 0 0);
+  --sidebar-border: oklch(1 0 0 / 8%);
+  --sidebar-ring: oklch(0.65 0.2 265);
+}
+
+.light {
+  --background: oklch(0.985 0 0);
+  --foreground: oklch(0.145 0 0);
+  --card: oklch(1 0 0);
+  --card-foreground: oklch(0.145 0 0);
+  --popover: oklch(1 0 0);
+  --popover-foreground: oklch(0.145 0 0);
+  --primary: oklch(0.55 0.23 265);
+  --primary-foreground: oklch(0.985 0 0);
+  --secondary: oklch(0.95 0 0);
+  --secondary-foreground: oklch(0.205 0 0);
+  --muted: oklch(0.95 0 0);
+  --muted-foreground: oklch(0.45 0 0);
+  --accent: oklch(0.95 0.02 265);
+  --accent-foreground: oklch(0.45 0.2 265);
+  --destructive: oklch(0.577 0.245 27.325);
+  --border: oklch(0 0 0 / 10%);
+  --input: oklch(0 0 0 / 8%);
+  --ring: oklch(0.55 0.23 265);
+  --sidebar: oklch(0.97 0 0);
+  --sidebar-foreground: oklch(0.145 0 0);
+  --sidebar-primary: oklch(0.55 0.23 265);
+  --sidebar-primary-foreground: oklch(0.985 0 0);
+  --sidebar-accent: oklch(0.94 0 0);
+  --sidebar-accent-foreground: oklch(0.205 0 0);
+  --sidebar-border: oklch(0 0 0 / 8%);
+  --sidebar-ring: oklch(0.55 0.23 265);
+}
+
+@layer base {
+  * {
+    @apply border-border outline-ring/50;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+  html {
+    @apply font-sans;
+  }
+}
+
+/* ── Custom Scrollbar ──────────────────────────────── */
+::-webkit-scrollbar {
+  width: 6px;
+  height: 6px;
+}
+::-webkit-scrollbar-track {
+  background: transparent;
+}
+::-webkit-scrollbar-thumb {
+  background: oklch(0.4 0 0);
+  border-radius: 999px;
+}
+::-webkit-scrollbar-thumb:hover {
+  background: oklch(0.55 0 0);
+}
+
+/* ── Animations ────────────────────────────────────── */
+@keyframes shimmer {
+  0% { background-position: -200% 0; }
+  100% { background-position: 200% 0; }
+}
+
+@keyframes fadeInUp {
+  from { opacity: 0; transform: translateY(12px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+
+@keyframes pulse-glow {
+  0%, 100% { box-shadow: 0 0 8px oklch(0.65 0.2 265 / 30%); }
+  50% { box-shadow: 0 0 20px oklch(0.65 0.2 265 / 50%); }
+}
+
+.animate-fade-in-up {
+  animation: fadeInUp 0.4s ease-out forwards;
+}
+
+.animate-shimmer {
+  background: linear-gradient(90deg, transparent 33%, oklch(1 0 0 / 5%) 50%, transparent 66%);
+  background-size: 200% 100%;
+  animation: shimmer 1.5s infinite;
+}
+
+.animate-pulse-glow {
+  animation: pulse-glow 2s ease-in-out infinite;
+}
+
+/* ── Markdown Styles in Chat ───────────────────────── */
+.prose-chat h1, .prose-chat h2, .prose-chat h3 {
+  font-weight: 600;
+  margin-top: 1em;
+  margin-bottom: 0.5em;
+}
+.prose-chat h1 { font-size: 1.25rem; }
+.prose-chat h2 { font-size: 1.1rem; }
+.prose-chat h3 { font-size: 1rem; }
+.prose-chat p { margin-bottom: 0.75em; line-height: 1.7; }
+.prose-chat ul, .prose-chat ol { padding-left: 1.5em; margin-bottom: 0.75em; }
+.prose-chat li { margin-bottom: 0.25em; }
+.prose-chat code {
+  background: oklch(1 0 0 / 8%);
+  padding: 0.15em 0.4em;
+  border-radius: 4px;
+  font-size: 0.9em;
+}
+.prose-chat pre {
+  background: oklch(0.12 0 0);
+  padding: 1em;
+  border-radius: 8px;
+  overflow-x: auto;
+  margin-bottom: 0.75em;
+}
+.prose-chat pre code {
+  background: none;
+  padding: 0;
+}
+.prose-chat blockquote {
+  border-left: 3px solid oklch(0.65 0.2 265);
+  padding-left: 1em;
+  margin-left: 0;
+  margin-bottom: 0.75em;
+  color: oklch(0.7 0 0);
+}
+.prose-chat strong { color: oklch(0.9 0 0); }
+.prose-chat a { color: oklch(0.65 0.2 265); text-decoration: underline; }
+
+.light .prose-chat code { background: oklch(0 0 0 / 6%); }
+.light .prose-chat pre { background: oklch(0.96 0 0); }
+.light .prose-chat strong { color: oklch(0.2 0 0); }
+.light .prose-chat blockquote { color: oklch(0.4 0 0); }

frontend/src/app/layout.tsx

@@ -0,0 +1,36 @@
+import type { Metadata } from "next";
+import { Inter } from "next/font/google";
+import "./globals.css";
+import { AuthProvider } from "@/lib/auth";
+import { TooltipProvider } from "@/components/ui/tooltip";
+
+const inter = Inter({
+  variable: "--font-sans",
+  subsets: ["latin"],
+  display: "swap",
+});
+
+export const metadata: Metadata = {
+  title: "Document AI Analyst — Enterprise RAG System",
+  description:
+    "Upload complex PDFs and chat with an AI agent that pulls specific insights, summarizes data, and accurately cites sources using Retrieval-Augmented Generation.",
+  keywords: ["RAG", "Document AI", "PDF Analysis", "LLM", "Vector Search"],
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en" className={`${inter.variable} dark h-full antialiased`}>
+      <body className="min-h-full flex flex-col bg-background text-foreground">
+        <AuthProvider>
+          <TooltipProvider>
+            {children}
+          </TooltipProvider>
+        </AuthProvider>
+      </body>
+    </html>
+  );
+}

frontend/src/app/login/page.tsx

@@ -0,0 +1,118 @@
+"use client";
+
+import { useState } from "react";
+import { useRouter } from "next/navigation";
+import { useAuth } from "@/lib/auth";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Card, CardContent, CardHeader, CardTitle, CardDescription } from "@/components/ui/card";
+import { Brain, Eye, EyeOff } from "lucide-react";
+import Link from "next/link";
+
+export default function LoginPage() {
+  const { login } = useAuth();
+  const router = useRouter();
+  const [email, setEmail] = useState("");
+  const [password, setPassword] = useState("");
+  const [showPw, setShowPw] = useState(false);
+  const [error, setError] = useState("");
+  const [loading, setLoading] = useState(false);
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    setError("");
+    setLoading(true);
+
+    try {
+      await login(email, password);
+      router.replace("/dashboard");
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : "Login failed";
+      setError(message);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return (
+    <div className="min-h-screen flex items-center justify-center px-4">
+      {/* Background glow */}
+      <div className="absolute top-1/3 left-1/2 -translate-x-1/2 w-[500px] h-[300px] bg-primary/8 rounded-full blur-[100px] pointer-events-none" />
+
+      <Card className="w-full max-w-md relative z-10 bg-card/80 backdrop-blur-xl border-border/50 animate-fade-in-up">
+        <CardHeader className="text-center pb-2">
+          <div className="flex justify-center mb-4">
+            <div className="w-12 h-12 rounded-xl bg-primary/15 flex items-center justify-center">
+              <Brain className="w-6 h-6 text-primary" />
+            </div>
+          </div>
+          <CardTitle className="text-2xl font-bold">Welcome back</CardTitle>
+          <CardDescription>Sign in to your Document AI Analyst account</CardDescription>
+        </CardHeader>
+
+        <CardContent>
+          <form onSubmit={handleSubmit} className="space-y-4">
+            {error && (
+              <div className="p-3 rounded-lg bg-destructive/10 border border-destructive/30 text-sm text-destructive">
+                {error}
+              </div>
+            )}
+
+            <div className="space-y-2">
+              <label className="text-sm font-medium">Email</label>
+              <Input
+                id="login-email"
+                type="email"
+                placeholder="you@example.com"
+                value={email}
+                onChange={(e) => setEmail(e.target.value)}
+                required
+                className="h-11"
+              />
+            </div>
+
+            <div className="space-y-2">
+              <label className="text-sm font-medium">Password</label>
+              <div className="relative">
+                <Input
+                  id="login-password"
+                  type={showPw ? "text" : "password"}
+                  placeholder="••••••••"
+                  value={password}
+                  onChange={(e) => setPassword(e.target.value)}
+                  required
+                  className="h-11 pr-10"
+                />
+                <button
+                  type="button"
+                  onClick={() => setShowPw(!showPw)}
+                  className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground transition-colors"
+                >
+                  {showPw ? <EyeOff className="w-4 h-4" /> : <Eye className="w-4 h-4" />}
+                </button>
+              </div>
+            </div>
+
+            <Button type="submit" className="w-full h-11 text-base" disabled={loading}>
+              {loading ? (
+                <span className="flex items-center gap-2">
+                  <span className="w-4 h-4 border-2 border-primary-foreground/30 border-t-primary-foreground rounded-full animate-spin" />
+                  Signing in...
+                </span>
+              ) : (
+                "Sign In"
+              )}
+            </Button>
+          </form>
+
+          <p className="text-center text-sm text-muted-foreground mt-6">
+            Don&apos;t have an account?{" "}
+            <Link href="/register" className="text-primary hover:underline font-medium">
+              Create one
+            </Link>
+          </p>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

frontend/src/app/page.tsx

@@ -0,0 +1,121 @@
+"use client";
+
+import { useEffect } from "react";
+import { useRouter } from "next/navigation";
+import { useAuth } from "@/lib/auth";
+import { FileText, MessageSquare, Brain, Shield, Zap, Search } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import Link from "next/link";
+
+export default function HomePage() {
+  const { user, loading } = useAuth();
+  const router = useRouter();
+
+  useEffect(() => {
+    if (!loading && user) {
+      router.replace("/dashboard");
+    }
+  }, [user, loading, router]);
+
+  if (loading) {
+    return (
+      <div className="min-h-screen flex items-center justify-center">
+        <div className="animate-pulse-glow w-12 h-12 rounded-full bg-primary/20" />
+      </div>
+    );
+  }
+
+  return (
+    <div className="min-h-screen flex flex-col">
+      {/* ── Hero ────────────────────────────────────── */}
+      <div className="flex-1 flex flex-col items-center justify-center px-6 py-20">
+        {/* Glow effect */}
+        <div className="absolute top-1/4 left-1/2 -translate-x-1/2 w-[600px] h-[400px] bg-primary/10 rounded-full blur-[120px] pointer-events-none" />
+
+        <div className="relative z-10 text-center max-w-3xl mx-auto animate-fade-in-up">
+          <div className="inline-flex items-center gap-2 px-4 py-1.5 rounded-full bg-primary/10 border border-primary/20 text-sm text-primary mb-8">
+            <Brain className="w-4 h-4" />
+            Enterprise Agentic RAG System
+          </div>
+
+          <h1 className="text-5xl sm:text-6xl font-bold tracking-tight mb-6 leading-[1.1]">
+            Chat with your{" "}
+            <span className="bg-gradient-to-r from-primary to-[oklch(0.65_0.2_200)] bg-clip-text text-transparent">
+              documents
+            </span>{" "}
+            intelligently
+          </h1>
+
+          <p className="text-lg text-muted-foreground max-w-xl mx-auto mb-10 leading-relaxed">
+            Upload financial reports, legal contracts, or research papers and get
+            accurate, cited insights powered by advanced AI retrieval.
+          </p>
+
+          <div className="flex gap-4 justify-center">
+            <Link href="/register">
+              <Button size="lg" className="px-8 text-base h-12">
+                Get Started Free
+              </Button>
+            </Link>
+            <Link href="/login">
+              <Button size="lg" variant="outline" className="px-8 text-base h-12">
+                Sign In
+              </Button>
+            </Link>
+          </div>
+        </div>
+
+        {/* ── Features Grid ────────────────────────── */}
+        <div className="relative z-10 mt-24 w-full max-w-4xl mx-auto grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-4">
+          {[
+            {
+              icon: FileText,
+              title: "Multi-Format Upload",
+              desc: "PDF, DOCX, TXT, and Markdown with smart chunking",
+            },
+            {
+              icon: Search,
+              title: "Semantic Search",
+              desc: "Two-stage retrieval with cross-encoder reranking",
+            },
+            {
+              icon: MessageSquare,
+              title: "Streaming Chat",
+              desc: "Real-time AI responses with source citations",
+            },
+            {
+              icon: Zap,
+              title: "Instant Insights",
+              desc: "Extract key facts, summaries, and data points",
+            },
+            {
+              icon: Shield,
+              title: "Data Isolation",
+              desc: "Per-user vector collections for complete privacy",
+            },
+            {
+              icon: Brain,
+              title: "Open-Source LLMs",
+              desc: "Powered by Mistral and HuggingFace ecosystem",
+            },
+          ].map((f, i) => (
+            <div
+              key={i}
+              className="group p-5 rounded-xl border border-border/50 bg-card/50 backdrop-blur-sm hover:border-primary/30 hover:bg-card transition-all duration-300"
+              style={{ animationDelay: `${i * 80}ms` }}
+            >
+              <f.icon className="w-5 h-5 text-primary mb-3 group-hover:scale-110 transition-transform" />
+              <h3 className="font-semibold text-sm mb-1">{f.title}</h3>
+              <p className="text-xs text-muted-foreground leading-relaxed">{f.desc}</p>
+            </div>
+          ))}
+        </div>
+      </div>
+
+      {/* ── Footer ──────────────────────────────────── */}
+      <footer className="text-center py-6 text-xs text-muted-foreground border-t border-border/50">
+        Built with FastAPI • LangChain • ChromaDB • HuggingFace • Next.js
+      </footer>
+    </div>
+  );
+}

frontend/src/app/register/page.tsx

@@ -0,0 +1,133 @@
+"use client";
+
+import { useState } from "react";
+import { useRouter } from "next/navigation";
+import { useAuth } from "@/lib/auth";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Card, CardContent, CardHeader, CardTitle, CardDescription } from "@/components/ui/card";
+import { Brain, Eye, EyeOff } from "lucide-react";
+import Link from "next/link";
+
+export default function RegisterPage() {
+  const { register } = useAuth();
+  const router = useRouter();
+  const [username, setUsername] = useState("");
+  const [email, setEmail] = useState("");
+  const [password, setPassword] = useState("");
+  const [showPw, setShowPw] = useState(false);
+  const [error, setError] = useState("");
+  const [loading, setLoading] = useState(false);
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    setError("");
+    setLoading(true);
+
+    try {
+      await register(username, email, password);
+      router.replace("/dashboard");
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : "Registration failed";
+      setError(message);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return (
+    <div className="min-h-screen flex items-center justify-center px-4">
+      <div className="absolute top-1/3 left-1/2 -translate-x-1/2 w-[500px] h-[300px] bg-primary/8 rounded-full blur-[100px] pointer-events-none" />
+
+      <Card className="w-full max-w-md relative z-10 bg-card/80 backdrop-blur-xl border-border/50 animate-fade-in-up">
+        <CardHeader className="text-center pb-2">
+          <div className="flex justify-center mb-4">
+            <div className="w-12 h-12 rounded-xl bg-primary/15 flex items-center justify-center">
+              <Brain className="w-6 h-6 text-primary" />
+            </div>
+          </div>
+          <CardTitle className="text-2xl font-bold">Create Account</CardTitle>
+          <CardDescription>Start analyzing documents with AI</CardDescription>
+        </CardHeader>
+
+        <CardContent>
+          <form onSubmit={handleSubmit} className="space-y-4">
+            {error && (
+              <div className="p-3 rounded-lg bg-destructive/10 border border-destructive/30 text-sm text-destructive">
+                {error}
+              </div>
+            )}
+
+            <div className="space-y-2">
+              <label className="text-sm font-medium">Username</label>
+              <Input
+                id="reg-username"
+                type="text"
+                placeholder="paramjit"
+                value={username}
+                onChange={(e) => setUsername(e.target.value)}
+                required
+                minLength={3}
+                className="h-11"
+              />
+            </div>
+
+            <div className="space-y-2">
+              <label className="text-sm font-medium">Email</label>
+              <Input
+                id="reg-email"
+                type="email"
+                placeholder="you@example.com"
+                value={email}
+                onChange={(e) => setEmail(e.target.value)}
+                required
+                className="h-11"
+              />
+            </div>
+
+            <div className="space-y-2">
+              <label className="text-sm font-medium">Password</label>
+              <div className="relative">
+                <Input
+                  id="reg-password"
+                  type={showPw ? "text" : "password"}
+                  placeholder="Minimum 6 characters"
+                  value={password}
+                  onChange={(e) => setPassword(e.target.value)}
+                  required
+                  minLength={6}
+                  className="h-11 pr-10"
+                />
+                <button
+                  type="button"
+                  onClick={() => setShowPw(!showPw)}
+                  className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground transition-colors"
+                >
+                  {showPw ? <EyeOff className="w-4 h-4" /> : <Eye className="w-4 h-4" />}
+                </button>
+              </div>
+            </div>
+
+            <Button type="submit" className="w-full h-11 text-base" disabled={loading}>
+              {loading ? (
+                <span className="flex items-center gap-2">
+                  <span className="w-4 h-4 border-2 border-primary-foreground/30 border-t-primary-foreground rounded-full animate-spin" />
+                  Creating account...
+                </span>
+              ) : (
+                "Create Account"
+              )}
+            </Button>
+          </form>
+
+          <p className="text-center text-sm text-muted-foreground mt-6">
+            Already have an account?{" "}
+            <Link href="/login" className="text-primary hover:underline font-medium">
+              Sign in
+            </Link>
+          </p>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

frontend/src/components/chat/ChatPanel.tsx

@@ -0,0 +1,250 @@
+"use client";
+
+import { useState, useRef, useEffect } from "react";
+import type { DocInfo } from "@/app/dashboard/page";
+import { api } from "@/lib/api";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { Button } from "@/components/ui/button";
+import { Textarea } from "@/components/ui/textarea";
+import MessageBubble from "./MessageBubble";
+import SourceCard from "./SourceCard";
+import { Send, Loader2, Trash2, MessageSquare } from "lucide-react";
+
+export interface SourceChunk {
+  text: string;
+  filename: string;
+  page: number;
+  score: number;
+  confidence: number;
+}
+
+export interface ChatMsg {
+  id: string;
+  role: "user" | "assistant";
+  content: string;
+  sources: SourceChunk[];
+  isStreaming?: boolean;
+}
+
+interface Props {
+  activeDoc: DocInfo | null;
+  onCitationClick: (page: number) => void;
+}
+
+export default function ChatPanel({ activeDoc, onCitationClick }: Props) {
+  const [messages, setMessages] = useState<ChatMsg[]>([]);
+  const [input, setInput] = useState("");
+  const [streaming, setStreaming] = useState(false);
+  const scrollRef = useRef<HTMLDivElement>(null);
+  const prevDocId = useRef<string | null>(null);
+
+  // Auto-scroll to bottom
+  useEffect(() => {
+    if (scrollRef.current) {
+      scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
+    }
+  }, [messages]);
+
+  // Load history on doc change
+  useEffect(() => {
+    if (!activeDoc || activeDoc.id === prevDocId.current) return;
+    prevDocId.current = activeDoc.id;
+
+    api
+      .get<{ messages: Array<{ id: string; role: string; content: string; sources?: SourceChunk[] }> }>(
+        `/api/v1/chat/history/${activeDoc.id}`
+      )
+      .then((data) => {
+        setMessages(
+          data.messages.map((m) => ({
+            id: m.id,
+            role: m.role as "user" | "assistant",
+            content: m.content,
+            sources: m.sources || [],
+          }))
+        );
+      })
+      .catch(() => setMessages([]));
+  }, [activeDoc]);
+
+  const handleSend = async () => {
+    if (!input.trim() || streaming) return;
+
+    const question = input.trim();
+    setInput("");
+
+    // Add user message
+    const userMsg: ChatMsg = {
+      id: `user-${Date.now()}`,
+      role: "user",
+      content: question,
+      sources: [],
+    };
+    setMessages((prev) => [...prev, userMsg]);
+
+    // Add placeholder assistant message
+    const assistantId = `assistant-${Date.now()}`;
+    const assistantMsg: ChatMsg = {
+      id: assistantId,
+      role: "assistant",
+      content: "",
+      sources: [],
+      isStreaming: true,
+    };
+    setMessages((prev) => [...prev, assistantMsg]);
+    setStreaming(true);
+
+    try {
+      const stream = api.streamPost("/api/v1/chat/ask/stream", {
+        question,
+        document_id: activeDoc?.id || null,
+      });
+
+      for await (const event of stream) {
+        if (event.type === "token") {
+          setMessages((prev) =>
+            prev.map((m) =>
+              m.id === assistantId
+                ? { ...m, content: m.content + (event.data as string) }
+                : m
+            )
+          );
+        } else if (event.type === "sources") {
+          setMessages((prev) =>
+            prev.map((m) =>
+              m.id === assistantId
+                ? { ...m, sources: event.data as SourceChunk[] }
+                : m
+            )
+          );
+        } else if (event.type === "error") {
+          setMessages((prev) =>
+            prev.map((m) =>
+              m.id === assistantId
+                ? { ...m, content: `Error: ${event.data}`, isStreaming: false }
+                : m
+            )
+          );
+        } else if (event.type === "done") {
+          setMessages((prev) =>
+            prev.map((m) =>
+              m.id === assistantId ? { ...m, isStreaming: false } : m
+            )
+          );
+        }
+      }
+    } catch (err) {
+      setMessages((prev) =>
+        prev.map((m) =>
+          m.id === assistantId
+            ? {
+                ...m,
+                content: `Failed to get response: ${err instanceof Error ? err.message : "Unknown error"}`,
+                isStreaming: false,
+              }
+            : m
+        )
+      );
+    } finally {
+      setStreaming(false);
+    }
+  };
+
+  const handleClear = async () => {
+    if (!activeDoc || !confirm("Clear all chat history for this document?")) return;
+    try {
+      await api.delete(`/api/v1/chat/history/${activeDoc.id}`);
+      setMessages([]);
+    } catch {
+      // silently fail
+    }
+  };
+
+  const handleKeyDown = (e: React.KeyboardEvent) => {
+    if (e.key === "Enter" && !e.shiftKey) {
+      e.preventDefault();
+      handleSend();
+    }
+  };
+
+  return (
+    <div className="h-full flex flex-col">
+      {/* ── Chat Messages ──────────────────────────── */}
+      <ScrollArea className="flex-1 px-4" ref={scrollRef}>
+        {messages.length === 0 ? (
+          <div className="h-full flex flex-col items-center justify-center py-20">
+            <div className="w-16 h-16 rounded-2xl bg-primary/10 flex items-center justify-center mb-4">
+              <MessageSquare className="w-8 h-8 text-primary/60" />
+            </div>
+            <h3 className="text-lg font-semibold mb-1">
+              {activeDoc ? "Ask about your document" : "Select a document"}
+            </h3>
+            <p className="text-sm text-muted-foreground text-center max-w-sm">
+              {activeDoc
+                ? `"${activeDoc.original_name}" is ready. Ask any question and get cited answers.`
+                : "Upload and select a document from the sidebar to start chatting."}
+            </p>
+          </div>
+        ) : (
+          <div className="py-4 space-y-1 max-w-3xl mx-auto">
+            {messages.map((msg) => (
+              <div key={msg.id}>
+                <MessageBubble message={msg} />
+                {msg.role === "assistant" && msg.sources.length > 0 && (
+                  <div className="ml-10 mt-1 mb-3">
+                    <SourceCard sources={msg.sources} onPageClick={onCitationClick} />
+                  </div>
+                )}
+              </div>
+            ))}
+          </div>
+        )}
+      </ScrollArea>
+
+      {/* ── Input Area ─────────────────────────────── */}
+      <div className="border-t border-border/50 p-4 bg-card/30 backdrop-blur-sm">
+        <div className="max-w-3xl mx-auto flex gap-2 items-end">
+          <Textarea
+            id="chat-input"
+            value={input}
+            onChange={(e) => setInput(e.target.value)}
+            onKeyDown={handleKeyDown}
+            placeholder={
+              activeDoc
+                ? `Ask about "${activeDoc.original_name}"...`
+                : "Select a document first..."
+            }
+            disabled={streaming}
+            className="min-h-[44px] max-h-32 resize-none bg-background/50 border-border/50"
+            rows={1}
+          />
+          <div className="flex gap-1.5 shrink-0">
+            <Button
+              id="send-btn"
+              size="icon"
+              onClick={handleSend}
+              disabled={!input.trim() || streaming}
+              className="h-[44px] w-[44px]"
+            >
+              {streaming ? (
+                <Loader2 className="w-4 h-4 animate-spin" />
+              ) : (
+                <Send className="w-4 h-4" />
+              )}
+            </Button>
+            {messages.length > 0 && (
+              <Button
+                variant="ghost"
+                size="icon"
+                onClick={handleClear}
+                className="h-[44px] w-[44px] text-muted-foreground hover:text-destructive"
+              >
+                <Trash2 className="w-4 h-4" />
+              </Button>
+            )}
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/components/chat/MessageBubble.tsx

@@ -0,0 +1,61 @@
+"use client";
+
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+import type { ChatMsg } from "./ChatPanel";
+import { Brain, User } from "lucide-react";
+
+interface Props {
+  message: ChatMsg;
+}
+
+export default function MessageBubble({ message }: Props) {
+  const isUser = message.role === "user";
+
+  return (
+    <div
+      className={`flex gap-3 py-3 animate-fade-in-up ${isUser ? "justify-end" : "justify-start"}`}
+    >
+      {!isUser && (
+        <div className="w-8 h-8 rounded-lg bg-primary/15 flex items-center justify-center shrink-0 mt-0.5">
+          <Brain className="w-4 h-4 text-primary" />
+        </div>
+      )}
+
+      <div
+        className={`max-w-[80%] rounded-xl px-4 py-3 ${
+          isUser
+            ? "bg-primary text-primary-foreground rounded-br-sm"
+            : "bg-card border border-border/50 rounded-bl-sm"
+        }`}
+      >
+        {isUser ? (
+          <p className="text-sm leading-relaxed whitespace-pre-wrap">{message.content}</p>
+        ) : (
+          <div className="prose-chat text-sm">
+            {message.content ? (
+              <ReactMarkdown remarkPlugins={[remarkGfm]}>
+                {message.content}
+              </ReactMarkdown>
+            ) : message.isStreaming ? (
+              <div className="flex items-center gap-1.5">
+                <span className="w-1.5 h-1.5 rounded-full bg-primary/60 animate-bounce [animation-delay:0ms]" />
+                <span className="w-1.5 h-1.5 rounded-full bg-primary/60 animate-bounce [animation-delay:150ms]" />
+                <span className="w-1.5 h-1.5 rounded-full bg-primary/60 animate-bounce [animation-delay:300ms]" />
+              </div>
+            ) : null}
+            {message.isStreaming && message.content && (
+              <span className="inline-block w-0.5 h-4 bg-primary/60 animate-pulse ml-0.5 align-text-bottom" />
+            )}
+          </div>
+        )}
+      </div>
+
+      {isUser && (
+        <div className="w-8 h-8 rounded-lg bg-primary/20 flex items-center justify-center shrink-0 mt-0.5">
+          <User className="w-4 h-4 text-primary-foreground" />
+        </div>
+      )}
+    </div>
+  );
+}

frontend/src/components/chat/SourceCard.tsx

@@ -0,0 +1,101 @@
+"use client";
+
+import { useState } from "react";
+import type { SourceChunk } from "./ChatPanel";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { ChevronDown, ChevronUp, FileText, Eye } from "lucide-react";
+
+interface Props {
+  sources: SourceChunk[];
+  onPageClick: (page: number) => void;
+}
+
+export default function SourceCard({ sources, onPageClick }: Props) {
+  const [expanded, setExpanded] = useState(false);
+
+  if (sources.length === 0) return null;
+
+  return (
+    <div className="rounded-lg border border-border/50 bg-card/50 overflow-hidden">
+      {/* ── Header ──────────────────────────────────── */}
+      <button
+        onClick={() => setExpanded(!expanded)}
+        className="w-full flex items-center justify-between px-3 py-2 text-xs hover:bg-accent/30 transition-colors"
+      >
+        <span className="flex items-center gap-1.5 text-muted-foreground">
+          <FileText className="w-3.5 h-3.5" />
+          {sources.length} source{sources.length > 1 ? "s" : ""} cited
+        </span>
+        {expanded ? (
+          <ChevronUp className="w-3.5 h-3.5 text-muted-foreground" />
+        ) : (
+          <ChevronDown className="w-3.5 h-3.5 text-muted-foreground" />
+        )}
+      </button>
+
+      {/* ── Collapsed: Mini badges ──────────────────── */}
+      {!expanded && (
+        <div className="px-3 pb-2 flex flex-wrap gap-1">
+          {sources.map((src, i) => (
+            <Badge
+              key={i}
+              variant="secondary"
+              className="text-[10px] h-5 cursor-pointer hover:bg-primary/20 transition-colors"
+              onClick={() => onPageClick(src.page)}
+            >
+              p.{src.page} • {src.confidence}%
+            </Badge>
+          ))}
+        </div>
+      )}
+
+      {/* ── Expanded: Full source cards ─────────────── */}
+      {expanded && (
+        <div className="border-t border-border/30">
+          {sources.map((src, i) => (
+            <div
+              key={i}
+              className="px-3 py-2.5 border-b border-border/20 last:border-b-0 hover:bg-accent/20 transition-colors"
+            >
+              <div className="flex items-center justify-between mb-1.5">
+                <div className="flex items-center gap-2">
+                  <span className="text-[10px] font-medium text-muted-foreground">
+                    {src.filename}
+                  </span>
+                  <Badge variant="outline" className="text-[9px] h-4 px-1.5">
+                    Page {src.page}
+                  </Badge>
+                  <Badge
+                    variant="secondary"
+                    className={`text-[9px] h-4 px-1.5 ${
+                      src.confidence >= 80
+                        ? "text-emerald-400 bg-emerald-400/10"
+                        : src.confidence >= 50
+                        ? "text-yellow-400 bg-yellow-400/10"
+                        : "text-muted-foreground"
+                    }`}
+                  >
+                    {src.confidence}% match
+                  </Badge>
+                </div>
+                <Button
+                  variant="ghost"
+                  size="sm"
+                  className="h-6 px-2 text-[10px]"
+                  onClick={() => onPageClick(src.page)}
+                >
+                  <Eye className="w-3 h-3 mr-1" />
+                  View
+                </Button>
+              </div>
+              <p className="text-[11px] text-muted-foreground leading-relaxed line-clamp-3">
+                {src.text}
+              </p>
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}

frontend/src/components/document/DocumentSidebar.tsx

@@ -0,0 +1,209 @@
+"use client";
+
+import { useState, useCallback } from "react";
+import type { DocInfo } from "@/app/dashboard/page";
+import { api } from "@/lib/api";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { Progress } from "@/components/ui/progress";
+import {
+  FileText, Upload, Trash2, FileCheck, Clock, AlertCircle, Loader2, FolderOpen,
+} from "lucide-react";
+import { useDropzone } from "react-dropzone";
+
+interface Props {
+  documents: DocInfo[];
+  activeDoc: DocInfo | null;
+  onSelectDoc: (doc: DocInfo) => void;
+  onDocumentsChange: () => void;
+}
+
+export default function DocumentSidebar({ documents, activeDoc, onSelectDoc, onDocumentsChange }: Props) {
+  const [uploading, setUploading] = useState(false);
+  const [uploadProgress, setUploadProgress] = useState(0);
+  const [deleting, setDeleting] = useState<string | null>(null);
+
+  const onDrop = useCallback(
+    async (acceptedFiles: File[]) => {
+      if (acceptedFiles.length === 0) return;
+      setUploading(true);
+      setUploadProgress(0);
+
+      try {
+        for (let i = 0; i < acceptedFiles.length; i++) {
+          const formData = new FormData();
+          formData.append("file", acceptedFiles[i]);
+          await api.postForm("/api/v1/documents/upload", formData);
+          setUploadProgress(((i + 1) / acceptedFiles.length) * 100);
+        }
+        onDocumentsChange();
+      } catch (err) {
+        console.error("Upload failed:", err);
+      } finally {
+        setUploading(false);
+        setUploadProgress(0);
+      }
+    },
+    [onDocumentsChange]
+  );
+
+  const { getRootProps, getInputProps, isDragActive } = useDropzone({
+    onDrop,
+    accept: {
+      "application/pdf": [".pdf"],
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.document": [".docx"],
+      "text/plain": [".txt"],
+      "text/markdown": [".md"],
+    },
+    disabled: uploading,
+  });
+
+  const handleDelete = async (docId: string, e: React.MouseEvent) => {
+    e.stopPropagation();
+    if (!confirm("Delete this document and all its data?")) return;
+    setDeleting(docId);
+    try {
+      await api.delete(`/api/v1/documents/${docId}`);
+      onDocumentsChange();
+    } catch (err) {
+      console.error("Delete failed:", err);
+    } finally {
+      setDeleting(null);
+    }
+  };
+
+  const statusIcon = (status: string) => {
+    switch (status) {
+      case "ready":
+        return <FileCheck className="w-3.5 h-3.5 text-emerald-400" />;
+      case "processing":
+        return <Loader2 className="w-3.5 h-3.5 text-primary animate-spin" />;
+      case "pending":
+        return <Clock className="w-3.5 h-3.5 text-yellow-400" />;
+      case "failed":
+        return <AlertCircle className="w-3.5 h-3.5 text-destructive" />;
+      default:
+        return <FileText className="w-3.5 h-3.5" />;
+    }
+  };
+
+  const formatSize = (bytes: number) => {
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1048576).toFixed(1)} MB`;
+  };
+
+  return (
+    <div className="h-full flex flex-col bg-sidebar">
+      {/* ── Upload Zone ─────────────────────────────── */}
+      <div className="p-3 border-b border-sidebar-border">
+        <div
+          {...getRootProps()}
+          className={`relative rounded-lg border-2 border-dashed p-4 text-center cursor-pointer transition-all duration-200
+            ${isDragActive ? "border-primary bg-primary/10 scale-[1.02]" : "border-sidebar-border hover:border-primary/40 hover:bg-sidebar-accent/50"}
+            ${uploading ? "pointer-events-none opacity-60" : ""}`}
+        >
+          <input {...getInputProps()} />
+          {uploading ? (
+            <div className="space-y-2">
+              <Loader2 className="w-5 h-5 mx-auto animate-spin text-primary" />
+              <p className="text-xs text-muted-foreground">Uploading...</p>
+              <Progress value={uploadProgress} className="h-1" />
+            </div>
+          ) : (
+            <>
+              <Upload className="w-5 h-5 mx-auto text-muted-foreground mb-2" />
+              <p className="text-xs text-muted-foreground">
+                {isDragActive ? "Drop files here" : "Drop files or click to upload"}
+              </p>
+              <p className="text-[10px] text-muted-foreground/60 mt-1">
+                PDF, DOCX, TXT, MD (max 50MB)
+              </p>
+            </>
+          )}
+        </div>
+      </div>
+
+      {/* ── Documents List ──────────────────────────── */}
+      <div className="px-3 pt-3 pb-1">
+        <h3 className="text-[11px] font-semibold uppercase tracking-wider text-muted-foreground mb-2">
+          Documents ({documents.length})
+        </h3>
+      </div>
+
+      <ScrollArea className="flex-1 px-3">
+        {documents.length === 0 ? (
+          <div className="text-center py-12">
+            <FolderOpen className="w-8 h-8 mx-auto text-muted-foreground/40 mb-3" />
+            <p className="text-sm text-muted-foreground">No documents yet</p>
+            <p className="text-xs text-muted-foreground/60 mt-1">Upload a file to get started</p>
+          </div>
+        ) : (
+          <div className="space-y-1 pb-3">
+            {documents.map((doc) => (
+              <button
+                key={doc.id}
+                onClick={() => doc.status === "ready" && onSelectDoc(doc)}
+                className={`w-full text-left p-2.5 rounded-lg transition-all duration-200 group
+                  ${activeDoc?.id === doc.id
+                    ? "bg-primary/15 border border-primary/30"
+                    : "hover:bg-sidebar-accent border border-transparent"}
+                  ${doc.status !== "ready" ? "opacity-60 cursor-default" : "cursor-pointer"}`}
+              >
+                <div className="flex items-start gap-2.5">
+                  {statusIcon(doc.status)}
+                  <div className="flex-1 min-w-0">
+                    <p className="text-sm font-medium truncate leading-tight">
+                      {doc.original_name}
+                    </p>
+                    <div className="flex items-center gap-2 mt-1">
+                      <span className="text-[10px] text-muted-foreground">
+                        {formatSize(doc.file_size)}
+                      </span>
+                      {doc.status === "ready" && (
+                        <>
+                          <span className="text-[10px] text-muted-foreground">•</span>
+                          <span className="text-[10px] text-muted-foreground">
+                            {doc.page_count} pg
+                          </span>
+                          <span className="text-[10px] text-muted-foreground">•</span>
+                          <span className="text-[10px] text-muted-foreground">
+                            {doc.chunk_count} chunks
+                          </span>
+                        </>
+                      )}
+                      {doc.status === "processing" && (
+                        <Badge variant="secondary" className="text-[9px] h-4 px-1.5">
+                          Processing
+                        </Badge>
+                      )}
+                      {doc.status === "failed" && (
+                        <Badge variant="destructive" className="text-[9px] h-4 px-1.5">
+                          Failed
+                        </Badge>
+                      )}
+                    </div>
+                  </div>
+                  <Button
+                    variant="ghost"
+                    size="icon"
+                    className="h-6 w-6 opacity-0 group-hover:opacity-100 transition-opacity shrink-0"
+                    onClick={(e) => handleDelete(doc.id, e)}
+                    disabled={deleting === doc.id}
+                  >
+                    {deleting === doc.id ? (
+                      <Loader2 className="w-3 h-3 animate-spin" />
+                    ) : (
+                      <Trash2 className="w-3 h-3 text-destructive" />
+                    )}
+                  </Button>
+                </div>
+              </button>
+            ))}
+          </div>
+        )}
+      </ScrollArea>
+    </div>
+  );
+}