Upload folder using huggingface_hub

.dockerignore

@@ -0,0 +1,9 @@
+.venv/
+venv/
+__pycache__/
+*.pyc
+.git/
+.env
+scripts/
+uploads_tmp/
+.DS_Store

.env.example

@@ -0,0 +1,22 @@
+# ===== Qdrant (vector DB) =====
+QDRANT_URL=https://your-cluster-id.region-0.aws.cloud.qdrant.io
+QDRANT_API_KEY=your-qdrant-api-key
+QDRANT_COLLECTION=documents
+
+# ===== MongoDB (metadata store) =====
+MONGODB_URI=mongodb+srv://user:password@cluster0.xxxxx.mongodb.net/?appName=Cluster0
+MONGODB_DB=hemantsatishjadhav06_db_user
+
+# ===== LLM via OpenRouter (OpenAI-compatible) =====
+OPENROUTER_API_KEY=sk-or-v1-xxxxxxxx
+OPENROUTER_BASE_URL=https://openrouter.ai/api/v1
+OPENROUTER_MODEL=anthropic/claude-sonnet-4.6
+
+# ===== Embeddings (local ONNX via fastembed — no torch) =====
+EMBEDDING_MODEL=BAAI/bge-small-en-v1.5
+EMBEDDING_DIM=384
+
+# ===== Retrieval / chunking =====
+CHUNK_SIZE=900
+CHUNK_OVERLAP=150
+TOP_K=5

.gitignore

@@ -0,0 +1,7 @@
+.env
+__pycache__/
+*.pyc
+.venv/
+venv/
+uploads_tmp/
+.DS_Store

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.11-slim
+
+# System deps: Tesseract (OCR) + Poppler (PDF rasterization for scanned PDFs)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        tesseract-ocr \
+        poppler-utils \
+        libgl1 \
+        libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Pre-download the embedding model at build time so the first request is fast.
+RUN python -c "from fastembed import TextEmbedding; TextEmbedding(model_name='BAAI/bge-small-en-v1.5')"
+
+COPY app ./app
+COPY static ./static
+
+# Most PaaS platforms inject $PORT; default to 8000 locally.
+ENV PORT=8000
+EXPOSE 8000
+
+CMD ["sh", "-c", "uvicorn app.main:app --host 0.0.0.0 --port ${PORT}"]

app/config.py

@@ -0,0 +1,36 @@
+"""Application configuration, loaded from environment / .env file."""
+from functools import lru_cache
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore")
+
+    # Qdrant
+    qdrant_url: str
+    qdrant_api_key: str
+    qdrant_collection: str = "documents"
+
+    # MongoDB
+    mongodb_uri: str
+    mongodb_db: str = "doc_intelligence_rag"
+
+    # LLM via OpenRouter (OpenAI-compatible API)
+    openrouter_api_key: str = ""
+    openrouter_base_url: str = "https://openrouter.ai/api/v1"
+    openrouter_model: str = "anthropic/claude-sonnet-4.6"
+
+    # Embeddings (local, ONNX via fastembed — no torch needed)
+    embedding_model: str = "BAAI/bge-small-en-v1.5"
+    embedding_dim: int = 384
+
+    # Retrieval / chunking
+    chunk_size: int = 900
+    chunk_overlap: int = 150
+    top_k: int = 5
+
+
+@lru_cache
+def get_settings() -> Settings:
+    return Settings()

app/db.py

@@ -0,0 +1,99 @@
+"""MongoDB metadata store for uploaded documents.
+
+If MongoDB is unreachable (e.g. Atlas IP allow-list not configured yet), the
+store gracefully falls back to an in-process dictionary so the rest of the app
+keeps working. Fallback data is not persisted across restarts.
+"""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from functools import lru_cache
+from typing import List, Optional
+
+from pymongo import MongoClient, DESCENDING
+
+from .config import get_settings
+
+# In-memory fallback store (used only when Mongo can't be reached).
+_MEM: dict[str, dict] = {}
+_USING_FALLBACK = False
+
+
+@lru_cache
+def _client() -> MongoClient:
+    settings = get_settings()
+    return MongoClient(
+        settings.mongodb_uri,
+        appname="doc-intelligence-rag",
+        serverSelectionTimeoutMS=4000,
+    )
+
+
+def _collection():
+    settings = get_settings()
+    return _client()[settings.mongodb_db]["documents"]
+
+
+def _fallback(reason: str = "") -> None:
+    global _USING_FALLBACK
+    if not _USING_FALLBACK:
+        _USING_FALLBACK = True
+
+
+def using_fallback() -> bool:
+    return _USING_FALLBACK
+
+
+def save_document(
+    document_id: str,
+    filename: str,
+    content_type: str,
+    num_chunks: int,
+    num_chars: int,
+    ocr_used: bool,
+) -> dict:
+    doc = {
+        "_id": document_id,
+        "filename": filename,
+        "content_type": content_type or "application/octet-stream",
+        "num_chunks": num_chunks,
+        "num_chars": num_chars,
+        "ocr_used": ocr_used,
+        "created_at": datetime.now(timezone.utc).isoformat(),
+    }
+    try:
+        _collection().insert_one(dict(doc))
+    except Exception as exc:  # noqa: BLE001
+        _fallback(str(exc))
+        _MEM[document_id] = doc
+    return doc
+
+
+def list_documents() -> List[dict]:
+    try:
+        return list(_collection().find().sort("created_at", DESCENDING))
+    except Exception as exc:  # noqa: BLE001
+        _fallback(str(exc))
+        return sorted(_MEM.values(), key=lambda d: d["created_at"], reverse=True)
+
+
+def get_document(document_id: str) -> Optional[dict]:
+    try:
+        return _collection().find_one({"_id": document_id})
+    except Exception as exc:  # noqa: BLE001
+        _fallback(str(exc))
+        return _MEM.get(document_id)
+
+
+def delete_document(document_id: str) -> int:
+    try:
+        result = _collection().delete_one({"_id": document_id})
+        return result.deleted_count
+    except Exception as exc:  # noqa: BLE001
+        _fallback(str(exc))
+        return 1 if _MEM.pop(document_id, None) else 0
+
+
+def ping() -> bool:
+    _client().admin.command("ping")
+    return True

app/embeddings.py

@@ -0,0 +1,26 @@
+"""Local embedding model wrapper (fastembed / ONNX — no torch dependency)."""
+from __future__ import annotations
+
+from functools import lru_cache
+from typing import List
+
+from .config import get_settings
+
+
+@lru_cache
+def _model():
+    from fastembed import TextEmbedding
+
+    settings = get_settings()
+    return TextEmbedding(model_name=settings.embedding_model)
+
+
+def embed_texts(texts: List[str]) -> List[List[float]]:
+    if not texts:
+        return []
+    # fastembed returns numpy arrays (already L2-normalized for bge models).
+    return [v.tolist() for v in _model().embed(texts)]
+
+
+def embed_query(text: str) -> List[float]:
+    return embed_texts([text])[0]

app/ingestion.py

@@ -0,0 +1,144 @@
+"""Document text extraction (with OCR fallback) and chunking."""
+from __future__ import annotations
+
+import io
+import re
+from dataclasses import dataclass
+from typing import List, Tuple
+
+
+@dataclass
+class ExtractResult:
+    text: str
+    ocr_used: bool
+
+
+def _ocr_image_bytes(data: bytes) -> str:
+    """OCR a single image using pytesseract."""
+    from PIL import Image
+    import pytesseract
+
+    image = Image.open(io.BytesIO(data))
+    return pytesseract.image_to_string(image)
+
+
+def _extract_pdf(data: bytes) -> ExtractResult:
+    """Extract text from a PDF. Falls back to OCR for pages with no text layer."""
+    from pypdf import PdfReader
+
+    reader = PdfReader(io.BytesIO(data))
+    pages_text: List[str] = []
+    ocr_used = False
+
+    for page in reader.pages:
+        text = (page.extract_text() or "").strip()
+        pages_text.append(text)
+
+    # If the PDF has little/no extractable text, it is likely scanned -> OCR.
+    total_chars = sum(len(t) for t in pages_text)
+    if total_chars < 40:
+        try:
+            from pdf2image import convert_from_bytes
+            import pytesseract
+
+            images = convert_from_bytes(data)
+            ocr_pages = [pytesseract.image_to_string(img) for img in images]
+            ocr_used = True
+            return ExtractResult("\n\n".join(ocr_pages), ocr_used)
+        except Exception:
+            # pdf2image needs poppler; if unavailable, return whatever text we had.
+            pass
+
+    return ExtractResult("\n\n".join(pages_text), ocr_used)
+
+
+def _extract_docx(data: bytes) -> ExtractResult:
+    from docx import Document
+
+    doc = Document(io.BytesIO(data))
+    parts = [p.text for p in doc.paragraphs]
+    for table in doc.tables:
+        for row in table.rows:
+            parts.append(" | ".join(cell.text for cell in row.cells))
+    return ExtractResult("\n".join(parts), ocr_used=False)
+
+
+def extract_text(filename: str, content_type: str, data: bytes) -> ExtractResult:
+    """Dispatch extraction based on file type."""
+    name = filename.lower()
+
+    if name.endswith(".pdf") or content_type == "application/pdf":
+        return _extract_pdf(data)
+
+    if name.endswith(".docx") or content_type in (
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ):
+        return _extract_docx(data)
+
+    if name.endswith((".png", ".jpg", ".jpeg", ".tiff", ".bmp", ".gif")) or (
+        content_type or ""
+    ).startswith("image/"):
+        return ExtractResult(_ocr_image_bytes(data), ocr_used=True)
+
+    if name.endswith((".txt", ".md", ".csv")) or (content_type or "").startswith("text/"):
+        return ExtractResult(data.decode("utf-8", errors="ignore"), ocr_used=False)
+
+    # Last resort: try to decode as text.
+    return ExtractResult(data.decode("utf-8", errors="ignore"), ocr_used=False)
+
+
+def _normalize(text: str) -> str:
+    text = text.replace("\r\n", "\n").replace("\r", "\n")
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+def chunk_text(text: str, chunk_size: int, overlap: int) -> List[str]:
+    """Split text into overlapping word-based chunks.
+
+    Word-based windows keep chunks coherent and avoid cutting mid-word.
+    chunk_size / overlap are measured in characters (approximate).
+    """
+    text = _normalize(text)
+    if not text:
+        return []
+
+    words = text.split(" ")
+    chunks: List[str] = []
+    current: List[str] = []
+    current_len = 0
+
+    for word in words:
+        current.append(word)
+        current_len += len(word) + 1
+        if current_len >= chunk_size:
+            chunks.append(" ".join(current).strip())
+            # Build overlap tail by characters.
+            tail: List[str] = []
+            tail_len = 0
+            for w in reversed(current):
+                tail_len += len(w) + 1
+                tail.insert(0, w)
+                if tail_len >= overlap:
+                    break
+            current = tail
+            current_len = sum(len(w) + 1 for w in current)
+
+    if current and " ".join(current).strip():
+        chunks.append(" ".join(current).strip())
+
+    return [c for c in chunks if c]
+
+
+def process_document(
+    filename: str,
+    content_type: str,
+    data: bytes,
+    chunk_size: int,
+    overlap: int,
+) -> Tuple[List[str], bool, int]:
+    """Return (chunks, ocr_used, num_chars)."""
+    result = extract_text(filename, content_type, data)
+    chunks = chunk_text(result.text, chunk_size, overlap)
+    return chunks, result.ocr_used, len(result.text)

app/main.py

@@ -0,0 +1,144 @@
+"""FastAPI application: upload documents, list/manage them, and chat over them."""
+from __future__ import annotations
+
+import uuid
+from pathlib import Path
+
+from fastapi import FastAPI, File, HTTPException, UploadFile
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from . import db, vector_store
+from .config import get_settings
+from .embeddings import embed_texts
+from .ingestion import process_document
+from .models import ChatRequest, ChatResponse, DocumentSummary, IngestResponse
+
+app = FastAPI(
+    title="Document Intelligence & Chat Assistant",
+    description="RAG over your uploaded documents: OCR + MongoDB + Qdrant + Claude.",
+    version="1.0.0",
+)
+
+STATIC_DIR = Path(__file__).resolve().parent.parent / "static"
+
+
+@app.on_event("startup")
+def _startup() -> None:
+    # Best-effort: create the Qdrant collection up front. Never block startup —
+    # if Qdrant is briefly unreachable the collection is created lazily on the
+    # first upload instead, so the server still binds and the UI loads.
+    try:
+        vector_store.ensure_collection()
+    except Exception as exc:  # noqa: BLE001
+        print(f"[startup] Qdrant not ready yet, will retry on first upload: {exc}")
+
+
+def _to_summary(doc: dict) -> DocumentSummary:
+    return DocumentSummary(
+        id=doc["_id"],
+        filename=doc["filename"],
+        content_type=doc["content_type"],
+        num_chunks=doc["num_chunks"],
+        num_chars=doc["num_chars"],
+        ocr_used=doc["ocr_used"],
+        created_at=doc["created_at"],
+    )
+
+
+@app.get("/health")
+def health() -> dict:
+    status = {"status": "ok"}
+    try:
+        db.ping()
+        status["mongodb"] = "ok"
+    except Exception as exc:  # noqa: BLE001
+        status["mongodb"] = f"error: {exc}"
+    try:
+        vector_store.get_client().get_collections()
+        status["qdrant"] = "ok"
+    except Exception as exc:  # noqa: BLE001
+        status["qdrant"] = f"error: {exc}"
+    status["llm_key_configured"] = bool(get_settings().openrouter_api_key)
+    return status
+
+
+@app.post("/documents/upload", response_model=IngestResponse)
+async def upload_document(file: UploadFile = File(...)) -> IngestResponse:
+    settings = get_settings()
+    data = await file.read()
+    if not data:
+        raise HTTPException(status_code=400, detail="Uploaded file is empty.")
+
+    chunks, ocr_used, num_chars = process_document(
+        file.filename, file.content_type or "", data,
+        settings.chunk_size, settings.chunk_overlap,
+    )
+    if not chunks:
+        raise HTTPException(
+            status_code=422,
+            detail="No text could be extracted from this document.",
+        )
+
+    document_id = str(uuid.uuid4())
+    vectors = embed_texts(chunks)
+    vector_store.ensure_collection()  # lazy create if startup couldn't reach Qdrant
+    vector_store.upsert_chunks(document_id, file.filename, chunks, vectors)
+    doc = db.save_document(
+        document_id=document_id,
+        filename=file.filename,
+        content_type=file.content_type or "",
+        num_chunks=len(chunks),
+        num_chars=num_chars,
+        ocr_used=ocr_used,
+    )
+
+    return IngestResponse(
+        document=_to_summary(doc),
+        message=f"Indexed {len(chunks)} chunks" + (" (OCR used)" if ocr_used else ""),
+    )
+
+
+@app.get("/documents", response_model=list[DocumentSummary])
+def list_documents() -> list[DocumentSummary]:
+    return [_to_summary(d) for d in db.list_documents()]
+
+
+@app.get("/documents/{document_id}", response_model=DocumentSummary)
+def get_document(document_id: str) -> DocumentSummary:
+    doc = db.get_document(document_id)
+    if not doc:
+        raise HTTPException(status_code=404, detail="Document not found.")
+    return _to_summary(doc)
+
+
+@app.delete("/documents/{document_id}")
+def delete_document(document_id: str) -> dict:
+    if not db.get_document(document_id):
+        raise HTTPException(status_code=404, detail="Document not found.")
+    vector_store.delete_document(document_id)
+    db.delete_document(document_id)
+    return {"deleted": document_id}
+
+
+@app.post("/chat", response_model=ChatResponse)
+def chat(request: ChatRequest) -> ChatResponse:
+    from . import rag
+
+    try:
+        return rag.answer_question(
+            question=request.question,
+            document_ids=request.document_ids,
+            top_k=request.top_k,
+        )
+    except RuntimeError as exc:
+        raise HTTPException(status_code=503, detail=str(exc))
+
+
+# --- Minimal web UI (served at /) ---
+if STATIC_DIR.exists():
+    app.mount("/ui", StaticFiles(directory=str(STATIC_DIR), html=True), name="ui")
+
+    @app.get("/")
+    def root() -> FileResponse:
+        return FileResponse(str(STATIC_DIR / "index.html"))

app/models.py

@@ -0,0 +1,39 @@
+"""Pydantic request/response schemas."""
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class DocumentSummary(BaseModel):
+    id: str
+    filename: str
+    content_type: str
+    num_chunks: int
+    num_chars: int
+    ocr_used: bool
+    created_at: str
+
+
+class IngestResponse(BaseModel):
+    document: DocumentSummary
+    message: str
+
+
+class ChatRequest(BaseModel):
+    question: str = Field(..., min_length=1)
+    # Optionally restrict retrieval to specific uploaded documents.
+    document_ids: Optional[List[str]] = None
+    top_k: Optional[int] = None
+
+
+class Source(BaseModel):
+    document_id: str
+    filename: str
+    chunk_index: int
+    score: float
+    snippet: str
+
+
+class ChatResponse(BaseModel):
+    answer: str
+    sources: List[Source]

app/rag.py

@@ -0,0 +1,91 @@
+"""RAG pipeline: retrieve relevant chunks, then generate a grounded answer."""
+from __future__ import annotations
+
+from functools import lru_cache
+from typing import List, Optional
+
+from .config import get_settings
+from .embeddings import embed_query
+from .models import ChatResponse, Source
+from . import vector_store
+
+SYSTEM_PROMPT = (
+    "You are a document assistant. Answer the user's question using ONLY the provided "
+    "context excerpts from their uploaded documents. Cite the supporting sources inline "
+    "as [1], [2], etc., matching the numbered context blocks. If the answer is not "
+    "contained in the context, say you could not find it in the documents. Be concise "
+    "and accurate."
+)
+
+
+@lru_cache
+def _llm():
+    from openai import OpenAI
+
+    settings = get_settings()
+    if not settings.openrouter_api_key:
+        raise RuntimeError("OPENROUTER_API_KEY is not set in the environment / .env file.")
+    return OpenAI(
+        base_url=settings.openrouter_base_url,
+        api_key=settings.openrouter_api_key,
+    )
+
+
+def _build_context(hits) -> str:
+    blocks = []
+    for i, hit in enumerate(hits, start=1):
+        payload = hit.payload or {}
+        blocks.append(
+            f"[{i}] (source: {payload.get('filename', '?')}, "
+            f"chunk {payload.get('chunk_index', '?')})\n{payload.get('text', '')}"
+        )
+    return "\n\n".join(blocks)
+
+
+def answer_question(
+    question: str,
+    document_ids: Optional[List[str]] = None,
+    top_k: Optional[int] = None,
+) -> ChatResponse:
+    settings = get_settings()
+    k = top_k or settings.top_k
+
+    query_vector = embed_query(question)
+    hits = vector_store.search(query_vector, top_k=k, document_ids=document_ids)
+
+    if not hits:
+        return ChatResponse(
+            answer="I couldn't find anything relevant in your uploaded documents.",
+            sources=[],
+        )
+
+    context = _build_context(hits)
+    user_message = (
+        f"Context excerpts:\n\n{context}\n\n"
+        f"Question: {question}\n\n"
+        "Answer using only the context above and cite sources as [n]."
+    )
+
+    client = _llm()
+    response = client.chat.completions.create(
+        model=settings.openrouter_model,
+        max_tokens=1024,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": user_message},
+        ],
+    )
+    answer_text = (response.choices[0].message.content or "").strip()
+
+    sources = [
+        Source(
+            document_id=(hit.payload or {}).get("document_id", ""),
+            filename=(hit.payload or {}).get("filename", "?"),
+            chunk_index=(hit.payload or {}).get("chunk_index", -1),
+            score=float(hit.score),
+            snippet=((hit.payload or {}).get("text", "")[:280]),
+        )
+        for hit in hits
+    ]
+
+    return ChatResponse(answer=answer_text, sources=sources)

app/vector_store.py

@@ -0,0 +1,101 @@
+"""Qdrant vector store: collection management, upsert, and search."""
+from __future__ import annotations
+
+import uuid
+from functools import lru_cache
+from typing import List, Optional
+
+from qdrant_client import QdrantClient
+from qdrant_client.http import models as qm
+
+from .config import get_settings
+
+
+@lru_cache
+def get_client() -> QdrantClient:
+    settings = get_settings()
+    return QdrantClient(url=settings.qdrant_url, api_key=settings.qdrant_api_key, timeout=60)
+
+
+def ensure_collection() -> None:
+    """Create the collection if it does not exist."""
+    settings = get_settings()
+    client = get_client()
+    existing = {c.name for c in client.get_collections().collections}
+    if settings.qdrant_collection not in existing:
+        client.create_collection(
+            collection_name=settings.qdrant_collection,
+            vectors_config=qm.VectorParams(
+                size=settings.embedding_dim, distance=qm.Distance.COSINE
+            ),
+        )
+        # Index on document_id so we can filter / delete by document.
+        client.create_payload_index(
+            collection_name=settings.qdrant_collection,
+            field_name="document_id",
+            field_schema=qm.PayloadSchemaType.KEYWORD,
+        )
+
+
+def upsert_chunks(
+    document_id: str,
+    filename: str,
+    chunks: List[str],
+    vectors: List[List[float]],
+) -> None:
+    settings = get_settings()
+    client = get_client()
+    points = [
+        qm.PointStruct(
+            id=str(uuid.uuid4()),
+            vector=vector,
+            payload={
+                "document_id": document_id,
+                "filename": filename,
+                "chunk_index": idx,
+                "text": chunk,
+            },
+        )
+        for idx, (chunk, vector) in enumerate(zip(chunks, vectors))
+    ]
+    client.upsert(collection_name=settings.qdrant_collection, points=points)
+
+
+def search(
+    query_vector: List[float],
+    top_k: int,
+    document_ids: Optional[List[str]] = None,
+):
+    settings = get_settings()
+    client = get_client()
+
+    query_filter = None
+    if document_ids:
+        query_filter = qm.Filter(
+            must=[qm.FieldCondition(key="document_id", match=qm.MatchAny(any=document_ids))]
+        )
+
+    return client.search(
+        collection_name=settings.qdrant_collection,
+        query_vector=query_vector,
+        limit=top_k,
+        query_filter=query_filter,
+        with_payload=True,
+    )
+
+
+def delete_document(document_id: str) -> None:
+    settings = get_settings()
+    client = get_client()
+    client.delete(
+        collection_name=settings.qdrant_collection,
+        points_selector=qm.FilterSelector(
+            filter=qm.Filter(
+                must=[
+                    qm.FieldCondition(
+                        key="document_id", match=qm.MatchValue(value=document_id)
+                    )
+                ]
+            )
+        ),
+    )

render.yaml

@@ -0,0 +1,37 @@
+# Render Blueprint — deploys the Dockerfile as a web service.
+# In Render: New + -> Blueprint -> connect this repo. Secrets (sync:false)
+# are entered in the dashboard, never committed.
+services:
+  - type: web
+    name: doc-intelligence-rag
+    runtime: docker
+    plan: free            # 512MB RAM. Bump to "starter" if you hit out-of-memory.
+    healthCheckPath: /health
+    autoDeploy: true
+    envVars:
+      - key: QDRANT_URL
+        sync: false
+      - key: QDRANT_API_KEY
+        sync: false
+      - key: QDRANT_COLLECTION
+        value: documents
+      - key: MONGODB_URI
+        sync: false
+      - key: MONGODB_DB
+        value: doc_intelligence_rag
+      - key: OPENROUTER_API_KEY
+        sync: false
+      - key: OPENROUTER_BASE_URL
+        value: https://openrouter.ai/api/v1
+      - key: OPENROUTER_MODEL
+        value: anthropic/claude-sonnet-4.6
+      - key: EMBEDDING_MODEL
+        value: BAAI/bge-small-en-v1.5
+      - key: EMBEDDING_DIM
+        value: "384"
+      - key: CHUNK_SIZE
+        value: "900"
+      - key: CHUNK_OVERLAP
+        value: "150"
+      - key: TOP_K
+        value: "5"

requirements.txt

@@ -0,0 +1,26 @@
+# Pins are lower-bounds so pip selects the newest wheels available for your
+# Python version (important on very new Pythons like 3.14).
+
+# --- Web framework ---
+fastapi>=0.115
+uvicorn[standard]>=0.34
+python-multipart>=0.0.18
+pydantic>=2.10
+pydantic-settings>=2.7
+
+# --- Databases ---
+pymongo>=4.10
+qdrant-client>=1.12
+
+# --- Embeddings (local, ONNX — no torch) ---
+fastembed>=0.5
+
+# --- LLM (OpenRouter, OpenAI-compatible) ---
+openai>=1.59
+
+# --- Document parsing + OCR ---
+pypdf>=5.1
+python-docx>=1.1
+pytesseract>=0.3.13
+pdf2image>=1.17
+Pillow>=11.0

run.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+# Local run helper for macOS / Linux. Prints clear errors and the URL.
+set -e
+cd "$(dirname "$0")"
+
+# Pick a Python (prefer python3)
+PY="$(command -v python3 || command -v python || true)"
+if [ -z "$PY" ]; then
+  echo "Python 3 not found. Install from https://www.python.org/downloads/ and retry."
+  exit 1
+fi
+echo "Using $($PY --version)"
+
+# Create / reuse venv
+[ -d .venv ] || "$PY" -m venv .venv
+# shellcheck disable=SC1091
+source .venv/bin/activate
+
+echo "Installing dependencies (first run downloads ~200MB, please wait)..."
+python -m pip install --upgrade pip >/dev/null
+python -m pip install -r requirements.txt
+
+# OCR system deps are optional (only needed for scanned files / images)
+command -v tesseract >/dev/null || echo "Note: tesseract not installed (OCR disabled). Optional: brew install tesseract"
+
+echo ""
+echo "Starting server.  Open  ->  http://localhost:8000"
+echo "(the first question downloads the embedding model, ~10s)"
+echo ""
+exec python -m uvicorn app.main:app --host 0.0.0.0 --port 8000

static/index.html

@@ -0,0 +1,267 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>DocChat · Document Intelligence</title>
+<style>
+  :root {
+    --bg:#0c0e14; --panel:#151823; --panel2:#1c2030; --border:#2a3040;
+    --accent:#7c6cf0; --accent2:#5b8def; --text:#eef0f6; --muted:#98a1b5;
+    --green:#3ecf8e; --red:#f06c7c; --amber:#f0b84c; --radius:12px;
+  }
+  * { box-sizing:border-box; }
+  html,body { height:100%; }
+  body { margin:0; font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;
+         background:radial-gradient(1200px 600px at 80% -10%, #1a1f3a 0%, var(--bg) 55%); color:var(--text); }
+  header { display:flex; align-items:center; gap:12px; padding:14px 22px; border-bottom:1px solid var(--border);
+           backdrop-filter:blur(6px); position:sticky; top:0; z-index:5; }
+  .logo { width:30px;height:30px;border-radius:8px;
+          background:linear-gradient(135deg,var(--accent),var(--accent2)); display:grid;place-items:center;font-size:16px; }
+  header h1 { font-size:16px; font-weight:650; margin:0; letter-spacing:.2px; }
+  header .sub { color:var(--muted); font-size:12px; margin-left:2px; }
+  .health { margin-left:auto; display:flex; gap:14px; font-size:12px; color:var(--muted); align-items:center; }
+  .dot { display:inline-block; width:8px;height:8px;border-radius:50%; margin-right:5px; background:var(--muted); vertical-align:middle; }
+  .dot.ok{background:var(--green);} .dot.bad{background:var(--red);} .dot.warn{background:var(--amber);}
+
+  .wrap { display:grid; grid-template-columns:330px 1fr; height:calc(100vh - 59px); }
+  .side { border-right:1px solid var(--border); padding:18px; overflow-y:auto; display:flex; flex-direction:column; gap:18px; }
+  .card { background:var(--panel); border:1px solid var(--border); border-radius:var(--radius); padding:16px; }
+  h3 { margin:0 0 12px; font-size:12px; text-transform:uppercase; letter-spacing:.08em; color:var(--muted); }
+
+  .drop { border:1.5px dashed var(--border); border-radius:10px; padding:22px 14px; text-align:center; cursor:pointer;
+          transition:.15s; color:var(--muted); font-size:13px; }
+  .drop:hover,.drop.drag { border-color:var(--accent); color:var(--text); background:var(--panel2); }
+  .drop b { color:var(--accent); }
+  .btn { background:linear-gradient(135deg,var(--accent),var(--accent2)); color:#fff; border:0; border-radius:9px;
+         padding:10px 16px; cursor:pointer; font-weight:600; font-size:13px; width:100%; margin-top:10px; }
+  .btn:disabled { opacity:.5; cursor:default; }
+  .btn.ghost { background:transparent; border:1px solid var(--border); color:var(--muted); }
+  .status { font-size:12px; color:var(--muted); margin-top:8px; min-height:16px; }
+
+  .doc { background:var(--panel2); border:1px solid var(--border); border-radius:9px; padding:10px 11px; margin-bottom:8px;
+         display:flex; gap:9px; align-items:flex-start; }
+  .doc input { margin-top:3px; accent-color:var(--accent); }
+  .doc .meta { flex:1; min-width:0; }
+  .doc .name { font-size:13px; font-weight:550; white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }
+  .doc small { color:var(--muted); font-size:11px; }
+  .doc .x { color:var(--muted); cursor:pointer; font-size:14px; padding:0 3px; }
+  .doc .x:hover { color:var(--red); }
+  .tag { display:inline-block; font-size:10px; padding:1px 6px; border-radius:6px; background:#2b3350; color:#aab4ff; margin-left:6px; }
+  .scope { font-size:11px; color:var(--muted); margin-top:6px; }
+
+  .main { display:flex; flex-direction:column; min-width:0; }
+  .chat { flex:1; overflow-y:auto; padding:26px 28px; display:flex; flex-direction:column; gap:20px; }
+  .empty { margin:auto; text-align:center; color:var(--muted); max-width:420px; }
+  .empty h2 { color:var(--text); font-weight:600; margin-bottom:8px; }
+  .suggest { display:flex; flex-wrap:wrap; gap:8px; justify-content:center; margin-top:16px; }
+  .chip { background:var(--panel); border:1px solid var(--border); border-radius:20px; padding:7px 13px; font-size:12px;
+          cursor:pointer; color:var(--muted); } .chip:hover{ border-color:var(--accent); color:var(--text); }
+
+  .msg { display:flex; gap:12px; max-width:860px; }
+  .msg.me { flex-direction:row-reverse; align-self:flex-end; }
+  .av { width:30px;height:30px;border-radius:8px; flex-shrink:0; display:grid;place-items:center; font-size:14px; }
+  .av.ai { background:linear-gradient(135deg,var(--accent),var(--accent2)); }
+  .av.me { background:var(--panel2); border:1px solid var(--border); }
+  .bubble { background:var(--panel); border:1px solid var(--border); border-radius:12px; padding:13px 15px; line-height:1.6;
+            font-size:14.5px; white-space:pre-wrap; word-wrap:break-word; }
+  .me .bubble { background:#222a4a; }
+  .bubble code { background:#0d1018; padding:1px 5px; border-radius:5px; font-size:13px; }
+  .bubble pre { background:#0d1018; padding:10px; border-radius:8px; overflow-x:auto; }
+  .sources { margin-top:10px; font-size:12px; }
+  .sources summary { cursor:pointer; color:var(--muted); }
+  .src { background:var(--panel2); border:1px solid var(--border); border-radius:8px; padding:8px 10px; margin-top:6px; }
+  .src .h { color:#aab4ff; font-size:11px; margin-bottom:3px; }
+  .src .t { color:var(--muted); font-size:12px; }
+  .typing span { display:inline-block; width:6px;height:6px;border-radius:50%; background:var(--muted); margin:0 2px;
+                 animation:b 1.2s infinite; } .typing span:nth-child(2){animation-delay:.2s;} .typing span:nth-child(3){animation-delay:.4s;}
+  @keyframes b { 0%,60%,100%{opacity:.3;transform:translateY(0)} 30%{opacity:1;transform:translateY(-3px)} }
+
+  .composer { border-top:1px solid var(--border); padding:14px 22px; }
+  .composer .row { display:flex; gap:10px; align-items:flex-end; background:var(--panel); border:1px solid var(--border);
+                   border-radius:12px; padding:8px 10px; }
+  textarea#q { flex:1; background:transparent; border:0; color:var(--text); font-size:14.5px; resize:none; outline:none;
+               max-height:140px; font-family:inherit; line-height:1.5; padding:6px; }
+  .send { background:linear-gradient(135deg,var(--accent),var(--accent2)); border:0; border-radius:9px; width:40px;height:40px;
+          cursor:pointer; color:#fff; font-size:17px; flex-shrink:0; } .send:disabled{opacity:.4;cursor:default;}
+  .hint { font-size:11px; color:var(--muted); margin-top:6px; text-align:center; }
+  @media (max-width:780px){ .wrap{grid-template-columns:1fr;} .side{display:none;} }
+</style>
+</head>
+<body>
+<header>
+  <div class="logo">📄</div>
+  <div>
+    <h1>DocChat <span class="sub">Document Intelligence &amp; Chat</span></h1>
+  </div>
+  <div class="health" id="health">
+    <span><span class="dot" id="d-qdrant"></span>Qdrant</span>
+    <span><span class="dot" id="d-mongo"></span>Mongo</span>
+    <span><span class="dot" id="d-llm"></span>LLM</span>
+  </div>
+</header>
+
+<div class="wrap">
+  <aside class="side">
+    <div class="card">
+      <h3>Upload a document</h3>
+      <div class="drop" id="drop">
+        <div>Drop a file here or <b>browse</b></div>
+        <div style="margin-top:6px;font-size:11px;">PDF · DOCX · images · TXT — OCR built in</div>
+      </div>
+      <input type="file" id="file" hidden />
+      <button class="btn" id="uploadBtn" onclick="upload()">Upload &amp; Index</button>
+      <div class="status" id="uploadStatus"></div>
+    </div>
+
+    <div class="card" style="flex:1;">
+      <h3 style="display:flex;justify-content:space-between;align-items:center;">
+        Your documents <span id="count" style="color:var(--accent);">0</span>
+      </h3>
+      <div id="docs"></div>
+      <div class="scope" id="scope">Chatting across all documents.</div>
+    </div>
+  </aside>
+
+  <main class="main">
+    <div class="chat" id="chat">
+      <div class="empty" id="empty">
+        <h2>Ask your documents anything</h2>
+        <p>Upload a file on the left, then ask a question. Answers are grounded in
+           your documents and cite their sources.</p>
+        <div class="suggest">
+          <div class="chip" onclick="useChip(this)">Summarize the key points</div>
+          <div class="chip" onclick="useChip(this)">What are the main risks?</div>
+          <div class="chip" onclick="useChip(this)">List the action items</div>
+        </div>
+      </div>
+    </div>
+    <div class="composer">
+      <div class="row">
+        <textarea id="q" rows="1" placeholder="Ask a question about your documents…"
+                  oninput="autogrow(this)" onkeydown="onKey(event)"></textarea>
+        <button class="send" id="send" onclick="ask()">➤</button>
+      </div>
+      <div class="hint">Enter to send · Shift+Enter for newline</div>
+    </div>
+  </main>
+</div>
+
+<script>
+let DOCS = [];
+const $ = (id) => document.getElementById(id);
+
+/* ---------- health ---------- */
+async function health() {
+  try {
+    const r = await fetch('/health'); const h = await r.json();
+    setDot('d-qdrant', h.qdrant === 'ok');
+    setDot('d-mongo', h.mongodb === 'ok');
+    setDot('d-llm', h.llm_key_configured);
+  } catch { ['d-qdrant','d-mongo','d-llm'].forEach(d=>setDot(d,false)); }
+}
+function setDot(id, ok){ const e=$(id); e.className = 'dot ' + (ok?'ok':'bad'); }
+
+/* ---------- documents ---------- */
+async function loadDocs() {
+  try {
+    const r = await fetch('/documents'); DOCS = await r.json();
+  } catch { DOCS = []; }
+  $('count').textContent = DOCS.length;
+  const el = $('docs');
+  if (!DOCS.length) { el.innerHTML = '<small>No documents yet — upload one above.</small>'; updateScope(); return; }
+  el.innerHTML = DOCS.map(d => `
+    <div class="doc">
+      <input type="checkbox" class="docsel" value="${d.id}" onchange="updateScope()" checked />
+      <div class="meta">
+        <div class="name" title="${esc(d.filename)}">${esc(d.filename)}${d.ocr_used?'<span class="tag">OCR</span>':''}</div>
+        <small>${d.num_chunks} chunks · ${new Date(d.created_at).toLocaleDateString()}</small>
+      </div>
+      <span class="x" title="Delete" onclick="del('${d.id}')">✕</span>
+    </div>`).join('');
+  updateScope();
+}
+function selectedIds(){ return [...document.querySelectorAll('.docsel:checked')].map(c=>c.value); }
+function updateScope(){
+  const sel = selectedIds(), total = DOCS.length;
+  const s = $('scope');
+  if (!total) s.textContent = '';
+  else if (sel.length === total) s.textContent = 'Chatting across all documents.';
+  else if (sel.length === 0) s.textContent = '⚠ No documents selected — select at least one.';
+  else s.textContent = `Chatting across ${sel.length} of ${total} documents.`;
+}
+async function del(id){
+  if (!confirm('Delete this document and its vectors?')) return;
+  await fetch('/documents/'+id, {method:'DELETE'}); await loadDocs();
+}
+
+/* ---------- upload ---------- */
+const drop = $('drop'), fileInput = $('file');
+drop.onclick = () => fileInput.click();
+['dragover','dragenter'].forEach(e=>drop.addEventListener(e,ev=>{ev.preventDefault();drop.classList.add('drag');}));
+['dragleave','drop'].forEach(e=>drop.addEventListener(e,ev=>{ev.preventDefault();drop.classList.remove('drag');}));
+drop.addEventListener('drop', ev=>{ if(ev.dataTransfer.files[0]){ fileInput.files=ev.dataTransfer.files; reflectFile(); }});
+fileInput.onchange = reflectFile;
+function reflectFile(){ const f=fileInput.files[0]; if(f) drop.querySelector('div').innerHTML = '📎 '+esc(f.name); }
+
+async function upload(){
+  const f = fileInput.files[0]; const st = $('uploadStatus');
+  if (!f){ st.textContent='Choose a file first.'; return; }
+  const btn = $('uploadBtn'); btn.disabled = true; st.textContent = '⏳ Extracting, embedding & indexing…';
+  const fd = new FormData(); fd.append('file', f);
+  try {
+    const r = await fetch('/documents/upload',{method:'POST',body:fd});
+    const d = await r.json();
+    st.textContent = r.ok ? ('✓ '+d.message) : ('⚠ '+(d.detail||'Upload failed'));
+    if (r.ok){ fileInput.value=''; drop.querySelector('div').innerHTML='Drop a file here or <b>browse</b>'; await loadDocs(); }
+  } catch(e){ st.textContent = '⚠ '+e; }
+  btn.disabled = false;
+}
+
+/* ---------- chat ---------- */
+function autogrow(t){ t.style.height='auto'; t.style.height=Math.min(t.scrollHeight,140)+'px'; }
+function onKey(e){ if(e.key==='Enter' && !e.shiftKey){ e.preventDefault(); ask(); } }
+function useChip(el){ $('q').value = el.textContent; $('q').focus(); }
+function esc(s){ return (s||'').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;'); }
+function fmt(s){ // tiny markdown: code fences, inline code, bold
+  s = esc(s);
+  s = s.replace(/```([\s\S]*?)```/g,(m,c)=>'<pre>'+c+'</pre>');
+  s = s.replace(/`([^`]+)`/g,'<code>$1</code>');
+  s = s.replace(/\*\*([^*]+)\*\*/g,'<strong>$1</strong>');
+  return s;
+}
+function bubble(role, inner){
+  $('empty')?.remove();
+  const wrap = document.createElement('div'); wrap.className = 'msg '+(role==='me'?'me':'');
+  wrap.innerHTML = `<div class="av ${role==='me'?'me':'ai'}">${role==='me'?'🙂':'📄'}</div>
+                    <div class="bubble">${inner}</div>`;
+  $('chat').appendChild(wrap); $('chat').scrollTop = $('chat').scrollHeight;
+  return wrap.querySelector('.bubble');
+}
+async function ask(){
+  const t = $('q'); const q = t.value.trim(); if(!q) return;
+  const ids = selectedIds();
+  if (DOCS.length && ids.length===0){ alert('Select at least one document to chat with.'); return; }
+  t.value=''; autogrow(t); bubble('me', esc(q));
+  const b = bubble('ai', '<div class="typing"><span></span><span></span><span></span></div>');
+  $('send').disabled = true;
+  try {
+    const body = { question:q };
+    if (DOCS.length && ids.length < DOCS.length) body.document_ids = ids;
+    const r = await fetch('/chat',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)});
+    const d = await r.json();
+    if (!r.ok){ b.innerHTML = '⚠ '+esc(d.detail||'Error'); $('send').disabled=false; return; }
+    let html = fmt(d.answer||'');
+    if (d.sources?.length){
+      const items = d.sources.map((s,i)=>`<div class="src"><div class="h">[${i+1}] ${esc(s.filename)} · chunk ${s.chunk_index} · ${(s.score*100).toFixed(0)}% match</div><div class="t">${esc(s.snippet)}</div></div>`).join('');
+      html += `<details class="sources"><summary>${d.sources.length} source${d.sources.length>1?'s':''}</summary>${items}</details>`;
+    }
+    b.innerHTML = html;
+  } catch(e){ b.innerHTML = '⚠ '+esc(''+e); }
+  $('send').disabled = false; $('chat').scrollTop = $('chat').scrollHeight;
+}
+
+health(); loadDocs(); setInterval(health, 30000);
+</script>
+</body>
+</html>