Add sample code of RAG API

README.md

@@ -1,14 +1,338 @@
 ---
 title: Example App Hackathon Gustave Eiffel 2026
-emoji: 💻
-colorFrom: red
-colorTo: red
+emoji: �
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 6.14.0
-python_version: '3.13'
+sdk_version: 4.44.0
+python_version: '3.11'
 app_file: app.py
 pinned: false
 license: apache-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🗼 RAG Chat API — Gustave Eiffel Hackathon 2026
+
+A complete **Retrieval-Augmented Generation (RAG)** system deployed as a Hugging Face Space, with a `/query` API endpoint designed for the RAG evaluation system.
+
+---
+
+## Table of Contents
+
+1. [Overview](#overview)
+2. [Architecture](#architecture)
+3. [Step-by-Step Explanation](#step-by-step-explanation)
+4. [API Endpoints](#api-endpoints)
+5. [Setup & Deployment](#setup--deployment)
+6. [Configuration](#configuration)
+7. [How It Works (Detailed)](#how-it-works-detailed)
+
+---
+
+## Overview
+
+This application demonstrates how to build a production-ready RAG system within the Hugging Face ecosystem. It covers:
+
+| Requirement | Solution |
+|---|---|
+| LLM API calls | Hugging Face Inference API (`InferenceClient`) |
+| Text → Embeddings | `sentence-transformers/all-MiniLM-L6-v2` (runs locally) |
+| Vector Store | ChromaDB (persistent, runs in-process) |
+| API Endpoint | FastAPI with `POST /query` |
+| UI | Gradio Blocks (chat + document ingestion) |
+
+---
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Hugging Face Space                         │
+│                                                              │
+│  ┌──────────┐     ┌──────────────┐     ┌───────────────┐   │
+│  │  Gradio  │     │   FastAPI    │     │   ChromaDB    │   │
+│  │   UI     │────▶│  /query      │────▶│  Vector Store │   │
+│  │          │     │  /ingest     │     │  (persistent) │   │
+│  └──────────┘     └──────┬───────┘     └───────────────┘   │
+│                          │                      ▲            │
+│                          ▼                      │            │
+│               ┌──────────────────┐    ┌─────────────────┐   │
+│               │  HF Inference    │    │  Sentence       │   │
+│               │  API (LLM)       │    │  Transformers   │   │
+│               │  Zephyr-7B       │    │  (Embeddings)   │   │
+│               └──────────────────┘    └─────────────────┘   │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Step-by-Step Explanation
+
+### Step 1: Document Ingestion & Chunking
+
+Before we can answer questions, we need to prepare our knowledge base.
+
+1. **Load documents** — Read text files from `sample_documents/` directory
+2. **Chunk text** — Split documents into smaller overlapping chunks (512 tokens, 50 token overlap) using `RecursiveCharacterTextSplitter`. This ensures each chunk fits within the embedding model's context window while maintaining semantic coherence.
+
+```python
+splitter = RecursiveCharacterTextSplitter(
+    chunk_size=512,
+    chunk_overlap=50,
+    separators=["\n\n", "\n", ". ", " ", ""],
+)
+chunks = splitter.split_text(document_text)
+```
+
+### Step 2: Generate Embeddings
+
+Convert text chunks into dense vector representations that capture semantic meaning.
+
+1. **Load model** — We use `sentence-transformers/all-MiniLM-L6-v2`, a lightweight model that produces 384-dimensional vectors
+2. **Encode text** — Each chunk is transformed into a fixed-size vector where semantically similar texts are closer together in vector space
+
+```python
+from sentence_transformers import SentenceTransformer
+
+model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
+embeddings = model.encode(["chunk 1 text", "chunk 2 text"])
+# Result: numpy array of shape (2, 384)
+```
+
+### Step 3: Store in Vector Database (ChromaDB)
+
+Persist embeddings in a vector store optimized for similarity search.
+
+1. **Initialize ChromaDB** — Create a persistent client that stores data on disk (survives Space restarts)
+2. **Create collection** — A named collection with cosine similarity metric
+3. **Add documents** — Store embeddings alongside the original text and metadata
+
+```python
+import chromadb
+
+client = chromadb.PersistentClient(path="./chroma_db")
+collection = client.get_or_create_collection(
+    name="rag_documents",
+    metadata={"hnsw:space": "cosine"},
+)
+collection.add(
+    ids=["doc_0", "doc_1"],
+    embeddings=embeddings.tolist(),
+    documents=["chunk 1 text", "chunk 2 text"],
+    metadatas=[{"source": "file.txt"}, {"source": "file.txt"}],
+)
+```
+
+### Step 4: Query & Retrieval
+
+When a user asks a question, find the most relevant context.
+
+1. **Embed the query** — Use the same embedding model to convert the question to a vector
+2. **Similarity search** — Find the top-K nearest vectors in ChromaDB (cosine similarity)
+3. **Return context** — Extract the original text chunks for the closest matches
+
+```python
+query_embedding = model.encode(["What is the Eiffel Tower?"])
+results = collection.query(
+    query_embeddings=query_embedding.tolist(),
+    n_results=3,
+)
+```
+
+### Step 5: LLM Generation (Augmented Response)
+
+Combine retrieved context with the user's question and generate an answer.
+
+1. **Build prompt** — Create a structured prompt with system instructions, retrieved context, and the user's question
+2. **Call LLM API** — Send the prompt to the Hugging Face Inference API (Zephyr-7B)
+3. **Return response** — The LLM generates an answer grounded in the provided context
+
+```python
+from huggingface_hub import InferenceClient
+
+client = InferenceClient(model="HuggingFaceH4/zephyr-7b-beta", token=HF_TOKEN)
+response = client.text_generation(prompt, max_new_tokens=512)
+```
+
+### Step 6: API Endpoint (`/query`)
+
+The FastAPI endpoint ties everything together for the evaluation system.
+
+```python
+@app.post("/query")
+async def query_endpoint(request: QueryRequest):
+    # 1. Retrieve relevant context
+    # 2. Build augmented prompt
+    # 3. Generate LLM response
+    # 4. Return answer + sources
+    result = rag_query(request.query, top_k=request.top_k)
+    return JSONResponse(content=result)
+```
+
+---
+
+## API Endpoints
+
+### `POST /query`
+
+The primary endpoint for the RAG evaluation system.
+
+**Request:**
+```json
+{
+    "query": "What materials is the Eiffel Tower made of?",
+    "top_k": 3
+}
+```
+
+**Response:**
+```json
+{
+    "answer": "The Eiffel Tower is made of wrought iron (puddled iron)...",
+    "sources": [
+        {"source": "eiffel_tower.txt", "score": 0.87},
+        {"source": "paris_landmarks.txt", "score": 0.72}
+    ],
+    "query": "What materials is the Eiffel Tower made of?"
+}
+```
+
+### `POST /ingest`
+
+Add new documents to the knowledge base.
+
+**Request:**
+```json
+{
+    "text": "The Eiffel Tower was built in 1889...",
+    "source": "my_document.txt"
+}
+```
+
+**Response:**
+```json
+{
+    "status": "success",
+    "chunks_added": 5,
+    "total_chunks": 42
+}
+```
+
+### `GET /health`
+
+System health check.
+
+**Response:**
+```json
+{
+    "status": "healthy",
+    "documents_in_store": 42,
+    "embedding_model": "sentence-transformers/all-MiniLM-L6-v2",
+    "llm_model": "HuggingFaceH4/zephyr-7b-beta"
+}
+```
+
+---
+
+## Setup & Deployment
+
+### Prerequisites
+
+- Python 3.11+
+- A Hugging Face account with an API token
+
+### Local Development
+
+```bash
+# Clone the repository
+git clone https://huggingface.co/spaces/YOUR_USERNAME/Example-App-Hackathon-Gustave-Eiffel-2026
+cd Example-App-Hackathon-Gustave-Eiffel-2026
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Set your HF token
+export HF_TOKEN="hf_your_token_here"
+
+# Run the application
+python app.py
+# Server starts at http://localhost:7860
+```
+
+### Deploy to Hugging Face Spaces
+
+1. Create a new Space on huggingface.co (select Gradio SDK)
+2. Add `HF_TOKEN` as a Space Secret (Settings → Secrets)
+3. Push this code to the Space repository
+4. The Space automatically installs dependencies and starts the app
+
+### Testing the API
+
+```bash
+# Health check
+curl http://localhost:7860/health
+
+# Query the RAG system
+curl -X POST http://localhost:7860/query \
+  -H "Content-Type: application/json" \
+  -d '{"query": "What is the Eiffel Tower?", "top_k": 3}'
+
+# Ingest a new document
+curl -X POST http://localhost:7860/ingest \
+  -H "Content-Type: application/json" \
+  -d '{"text": "Your document text here...", "source": "new_doc.txt"}'
+```
+
+---
+
+## Configuration
+
+| Variable | Default | Description |
+|---|---|---|
+| `HF_TOKEN` | (Space Secret) | Hugging Face API token for Inference API |
+| `EMBEDDING_MODEL_NAME` | `sentence-transformers/all-MiniLM-L6-v2` | Model for text embeddings |
+| `LLM_MODEL_NAME` | `HuggingFaceH4/zephyr-7b-beta` | LLM for answer generation |
+| `CHROMA_PERSIST_DIR` | `./chroma_db` | ChromaDB storage path |
+| `CHUNK_SIZE` | `512` | Text chunk size in characters |
+| `CHUNK_OVERLAP` | `50` | Overlap between chunks |
+| `TOP_K_RESULTS` | `3` | Number of context chunks to retrieve |
+
+---
+
+## How It Works (Detailed)
+
+### Why RAG?
+
+Large Language Models have a knowledge cutoff and can hallucinate. RAG solves this by:
+- **Grounding** responses in actual documents
+- **Updating** knowledge without retraining
+- **Providing** source attribution for answers
+
+### Why ChromaDB in HF Spaces?
+
+ChromaDB is ideal for Hugging Face Spaces because:
+- Runs **in-process** (no external database needed)
+- Supports **persistent storage** (survives Space restarts)
+- Uses **HNSW index** for fast approximate nearest neighbor search
+- Zero configuration required
+
+### Why Sentence Transformers?
+
+- Runs **locally** within the Space (no API cost for embeddings)
+- `all-MiniLM-L6-v2` is small (~80MB) but effective
+- Produces **384-dimensional** vectors (good balance of quality vs. storage)
+- Trained on 1B+ sentence pairs for semantic similarity
+
+### Evaluation Integration
+
+The `/query` endpoint is designed to be called by external RAG evaluation frameworks. It returns:
+- The generated `answer` for correctness evaluation
+- Source `documents` for faithfulness/groundedness checks
+- Similarity `scores` for retrieval quality assessment
+
+---
+
+## License
+
+Apache 2.0
+

app.py

@@ -1,7 +1,474 @@
+"""
+RAG Chat API - Gustave Eiffel Hackathon 2026
+=============================================
+
+This application demonstrates a complete Retrieval-Augmented Generation (RAG) system
+deployed as a Hugging Face Space. It includes:
+
+1. /query endpoint - Called by the RAG evaluation system
+2. LLM API integration via Hugging Face Inference API
+3. Document embedding using sentence-transformers
+4. ChromaDB as the vector store (runs locally within HF Spaces)
+5. End-to-end RAG pipeline: ingest → embed → retrieve → generate
+
+Architecture:
+    User Query → Embedding → Vector Search → Context Retrieval → LLM Generation → Response
+"""
+
+import os
+import logging
+from pathlib import Path
+from typing import Optional
+
 import gradio as gr
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+import chromadb
+from chromadb.config import Settings
+from sentence_transformers import SentenceTransformer
+from huggingface_hub import InferenceClient
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Configuration
+# ---------------------------------------------------------------------------
+
+EMBEDDING_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
+LLM_MODEL_NAME = "HuggingFaceH4/zephyr-7b-beta"
+CHROMA_PERSIST_DIR = "./chroma_db"
+COLLECTION_NAME = "rag_documents"
+CHUNK_SIZE = 512
+CHUNK_OVERLAP = 50
+TOP_K_RESULTS = 3
+
+# HF_TOKEN is set as a Space secret for authenticated Inference API calls
+HF_TOKEN = os.environ.get("HF_TOKEN")
+
+# ---------------------------------------------------------------------------
+# Step 1: Initialize the Embedding Model
+# ---------------------------------------------------------------------------
+# We use sentence-transformers to convert text chunks into dense vector embeddings.
+# The model runs locally inside the Space — no external API call needed.
+
+logger.info(f"Loading embedding model: {EMBEDDING_MODEL_NAME}")
+embedding_model = SentenceTransformer(EMBEDDING_MODEL_NAME)
+logger.info("Embedding model loaded successfully.")
+
+# ---------------------------------------------------------------------------
+# Step 2: Initialize the Vector Store (ChromaDB)
+# ---------------------------------------------------------------------------
+# ChromaDB runs in-process with persistent storage. This is ideal for HF Spaces
+# because it requires no external database service.
+
+logger.info(f"Initializing ChromaDB at: {CHROMA_PERSIST_DIR}")
+chroma_client = chromadb.PersistentClient(path=CHROMA_PERSIST_DIR)
+collection = chroma_client.get_or_create_collection(
+    name=COLLECTION_NAME,
+    metadata={"hnsw:space": "cosine"},
+)
+logger.info(f"ChromaDB collection '{COLLECTION_NAME}' ready. Documents: {collection.count()}")
+
+# ---------------------------------------------------------------------------
+# Step 3: Initialize the LLM Client (Hugging Face Inference API)
+# ---------------------------------------------------------------------------
+# We use the Hugging Face Inference API to call a hosted LLM model.
+# This avoids loading large models into the Space's limited memory.
+
+llm_client = InferenceClient(model=LLM_MODEL_NAME, token=HF_TOKEN)
+logger.info(f"LLM client initialized for model: {LLM_MODEL_NAME}")
+
+
+# ---------------------------------------------------------------------------
+# Helper Functions
+# ---------------------------------------------------------------------------
+
+def chunk_text(text: str, source: str = "unknown") -> list[dict]:
+    """
+    Split a document into smaller chunks for embedding.
+
+    We use LangChain's RecursiveCharacterTextSplitter which intelligently
+    splits on paragraph/sentence boundaries to preserve semantic meaning.
+    """
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=CHUNK_SIZE,
+        chunk_overlap=CHUNK_OVERLAP,
+        separators=["\n\n", "\n", ". ", " ", ""],
+    )
+    chunks = splitter.split_text(text)
+    return [{"text": chunk, "source": source, "chunk_index": i} for i, chunk in enumerate(chunks)]
+
+
+def generate_embeddings(texts: list[str]) -> list[list[float]]:
+    """
+    Transform text chunks into vector embeddings using sentence-transformers.
+
+    This demonstrates Step 2a: How to convert documents into embeddings.
+    The model maps each text string to a 384-dimensional dense vector.
+    """
+    embeddings = embedding_model.encode(texts, show_progress_bar=False)
+    return embeddings.tolist()
+
+
+def add_documents_to_vectorstore(documents: list[dict]) -> int:
+    """
+    Save document embeddings to the ChromaDB vector store.
+
+    This demonstrates Step 2c: How to persist embeddings for retrieval.
+    Each document gets a unique ID, its embedding vector, the raw text,
+    and metadata (source file, chunk index).
+    """
+    if not documents:
+        return 0
+
+    texts = [doc["text"] for doc in documents]
+    embeddings = generate_embeddings(texts)
+
+    existing_count = collection.count()
+    ids = [f"doc_{existing_count + i}" for i in range(len(documents))]
+    metadatas = [{"source": doc["source"], "chunk_index": doc["chunk_index"]} for doc in documents]
+
+    collection.add(
+        ids=ids,
+        embeddings=embeddings,
+        documents=texts,
+        metadatas=metadatas,
+    )
+
+    logger.info(f"Added {len(documents)} chunks to vector store. Total: {collection.count()}")
+    return len(documents)
+
+
+def retrieve_relevant_context(query: str, top_k: int = TOP_K_RESULTS) -> list[dict]:
+    """
+    Retrieve the most relevant document chunks for a given query.
+
+    This is the "Retrieval" step in RAG:
+    1. Embed the user's query using the same embedding model
+    2. Search the vector store for the nearest neighbors
+    3. Return the top-k most similar chunks as context
+    """
+    if collection.count() == 0:
+        return []
+
+    query_embedding = generate_embeddings([query])[0]
+
+    results = collection.query(
+        query_embeddings=[query_embedding],
+        n_results=min(top_k, collection.count()),
+        include=["documents", "metadatas", "distances"],
+    )
+
+    contexts = []
+    for i in range(len(results["documents"][0])):
+        contexts.append({
+            "text": results["documents"][0][i],
+            "source": results["metadatas"][0][i]["source"],
+            "similarity_score": 1 - results["distances"][0][i],
+        })
+
+    return contexts
+
+
+def call_llm(prompt: str) -> str:
+    """
+    Make a call to the LLM via Hugging Face Inference API.
+
+    This demonstrates Step 2a: How to call a given LLM model API.
+    We use the text_generation endpoint with a structured prompt
+    that includes the retrieved context and the user's question.
+    """
+    try:
+        response = llm_client.text_generation(
+            prompt,
+            max_new_tokens=512,
+            temperature=0.7,
+            top_p=0.95,
+            repetition_penalty=1.1,
+            do_sample=True,
+        )
+        return response.strip()
+    except Exception as e:
+        logger.error(f"LLM API call failed: {e}")
+        raise HTTPException(status_code=503, detail=f"LLM service unavailable: {str(e)}")
+
+
+def build_rag_prompt(query: str, contexts: list[dict]) -> str:
+    """
+    Construct the RAG prompt by combining retrieved context with the user question.
+
+    The prompt template instructs the LLM to:
+    - Answer based ONLY on the provided context
+    - Acknowledge when information is insufficient
+    - Cite sources when possible
+    """
+    context_text = "\n\n".join(
+        f"[Source: {ctx['source']}]\n{ctx['text']}" for ctx in contexts
+    )
+
+    prompt = f"""<|system|>
+You are a helpful assistant. Answer the user's question based ONLY on the provided context.
+If the context does not contain enough information to answer, say "I don't have enough information to answer this question."
+Always be concise and factual.</s>
+<|user|>
+Context:
+{context_text}
+
+Question: {query}</s>
+<|assistant|>
+"""
+    return prompt
+
+
+def rag_query(query: str, top_k: int = TOP_K_RESULTS) -> dict:
+    """
+    End-to-end RAG pipeline: Query → Retrieve → Generate.
+
+    This demonstrates Step 2d: How to make a RAG system end-to-end.
+
+    Pipeline steps:
+    1. Receive user query
+    2. Retrieve relevant context from vector store
+    3. Build augmented prompt with context
+    4. Call LLM to generate answer
+    5. Return answer with source metadata
+    """
+    # Step 1: Retrieve relevant document chunks
+    contexts = retrieve_relevant_context(query, top_k=top_k)
+
+    if not contexts:
+        return {
+            "answer": "No documents have been ingested yet. Please upload documents first.",
+            "sources": [],
+            "query": query,
+        }
+
+    # Step 2: Build the augmented prompt
+    prompt = build_rag_prompt(query, contexts)
+
+    # Step 3: Generate answer from LLM
+    answer = call_llm(prompt)
+
+    # Step 4: Return structured response
+    return {
+        "answer": answer,
+        "sources": [{"source": ctx["source"], "score": ctx["similarity_score"]} for ctx in contexts],
+        "query": query,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Step 4: Ingest Sample Documents on Startup
+# ---------------------------------------------------------------------------
+# Load sample documents so the demo works out of the box.
+
+SAMPLE_DOCS_DIR = Path("./sample_documents")
+
+
+def ingest_sample_documents():
+    """Load and embed sample documents into the vector store on first run."""
+    if collection.count() > 0:
+        logger.info("Vector store already has documents, skipping ingestion.")
+        return
+
+    if not SAMPLE_DOCS_DIR.exists():
+        logger.warning("No sample_documents directory found.")
+        return
+
+    for file_path in SAMPLE_DOCS_DIR.glob("*.txt"):
+        logger.info(f"Ingesting: {file_path.name}")
+        text = file_path.read_text(encoding="utf-8")
+        chunks = chunk_text(text, source=file_path.name)
+        add_documents_to_vectorstore(chunks)
+
+    logger.info(f"Sample document ingestion complete. Total chunks: {collection.count()}")
+
+
+ingest_sample_documents()
+
+
+# ---------------------------------------------------------------------------
+# Step 5: FastAPI Application with /query Endpoint
+# ---------------------------------------------------------------------------
+
+app = FastAPI(
+    title="RAG Chat API - Gustave Eiffel Hackathon 2026",
+    description="A RAG system with /query endpoint for evaluation",
+    version="1.0.0",
+)
+
+
+class QueryRequest(BaseModel):
+    """Request schema for the /query endpoint."""
+    query: str
+    top_k: Optional[int] = TOP_K_RESULTS
+
+
+class IngestRequest(BaseModel):
+    """Request schema for the /ingest endpoint."""
+    text: str
+    source: str = "user_upload"
+
+
+@app.post("/query")
+async def query_endpoint(request: QueryRequest):
+    """
+    RAG Query Endpoint - Called by the evaluation system.
+
+    Accepts a user query, retrieves relevant context from the vector store,
+    and generates an answer using the LLM.
+
+    Request body:
+        - query (str): The user's question
+        - top_k (int, optional): Number of context chunks to retrieve (default: 3)
+
+    Returns:
+        - answer (str): The generated answer
+        - sources (list): Source documents used for context
+        - query (str): The original query
+    """
+    logger.info(f"Query received: {request.query}")
+    result = rag_query(request.query, top_k=request.top_k)
+    return JSONResponse(content=result)
+
+
+@app.post("/ingest")
+async def ingest_endpoint(request: IngestRequest):
+    """
+    Document Ingestion Endpoint.
+
+    Accepts raw text, chunks it, generates embeddings, and stores in the vector store.
+
+    Request body:
+        - text (str): The document text to ingest
+        - source (str, optional): Source identifier for the document
+    """
+    chunks = chunk_text(request.text, source=request.source)
+    count = add_documents_to_vectorstore(chunks)
+    return JSONResponse(content={
+        "status": "success",
+        "chunks_added": count,
+        "total_chunks": collection.count(),
+    })
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint for monitoring."""
+    return {
+        "status": "healthy",
+        "documents_in_store": collection.count(),
+        "embedding_model": EMBEDDING_MODEL_NAME,
+        "llm_model": LLM_MODEL_NAME,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Step 6: Gradio UI for Interactive Demo
+# ---------------------------------------------------------------------------
+
+def gradio_query(question: str) -> str:
+    """Handle queries from the Gradio chat interface."""
+    if not question.strip():
+        return "Please enter a question."
+    result = rag_query(question)
+    sources_text = "\n".join(
+        f"  - {s['source']} (relevance: {s['score']:.2f})" for s in result["sources"]
+    )
+    return f"{result['answer']}\n\n📚 Sources:\n{sources_text}" if result["sources"] else result["answer"]
+
+
+def gradio_ingest(text: str, source_name: str) -> str:
+    """Handle document ingestion from the Gradio UI."""
+    if not text.strip():
+        return "Please provide text to ingest."
+    chunks = chunk_text(text, source=source_name or "user_upload")
+    count = add_documents_to_vectorstore(chunks)
+    return f"✅ Ingested {count} chunks. Total documents in store: {collection.count()}"
+
+
+with gr.Blocks(title="RAG Chat API - Gustave Eiffel Hackathon") as demo:
+    gr.Markdown("""
+    # 🗼 RAG Chat API - Gustave Eiffel Hackathon 2026
+
+    This application demonstrates a complete **Retrieval-Augmented Generation (RAG)** system.
+
+    **API Endpoint:** Use `POST /query` with `{"query": "your question"}` for programmatic access.
+
+    ---
+    """)
+
+    with gr.Tab("💬 Chat"):
+        gr.Markdown("Ask questions about the ingested documents.")
+        with gr.Row():
+            query_input = gr.Textbox(
+                label="Your Question",
+                placeholder="e.g., What is the Eiffel Tower made of?",
+                lines=2,
+            )
+        query_button = gr.Button("Ask", variant="primary")
+        query_output = gr.Textbox(label="Answer", lines=8, interactive=False)
+        query_button.click(fn=gradio_query, inputs=query_input, outputs=query_output)
+
+    with gr.Tab("📄 Ingest Documents"):
+        gr.Markdown("Add new documents to the knowledge base.")
+        doc_text = gr.Textbox(
+            label="Document Text",
+            placeholder="Paste your document text here...",
+            lines=10,
+        )
+        doc_source = gr.Textbox(
+            label="Source Name",
+            placeholder="e.g., my_document.txt",
+            value="user_upload",
+        )
+        ingest_button = gr.Button("Ingest Document", variant="primary")
+        ingest_output = gr.Textbox(label="Status", interactive=False)
+        ingest_button.click(fn=gradio_ingest, inputs=[doc_text, doc_source], outputs=ingest_output)
+
+    with gr.Tab("ℹ️ API Info"):
+        gr.Markdown("""
+        ## API Endpoints
+
+        ### POST /query
+        ```json
+        {
+            "query": "What is the Eiffel Tower?",
+            "top_k": 3
+        }
+        ```
+
+        **Response:**
+        ```json
+        {
+            "answer": "The Eiffel Tower is...",
+            "sources": [{"source": "eiffel_tower.txt", "score": 0.85}],
+            "query": "What is the Eiffel Tower?"
+        }
+        ```
+
+        ### POST /ingest
+        ```json
+        {
+            "text": "Your document text here...",
+            "source": "document_name.txt"
+        }
+        ```
+
+        ### GET /health
+        Returns system health and document count.
+        """)
+
+# Mount Gradio onto FastAPI so both the UI and API endpoints are served
+app = gr.mount_gradio_app(app, demo, path="/")
 
-def greet(name):
-    return "Hello " + name + "!!"
+# ---------------------------------------------------------------------------
+# Entry Point
+# ---------------------------------------------------------------------------
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,14 @@
+fastapi==0.115.0
+uvicorn==0.30.0
+gradio==4.44.0
+chromadb==0.5.0
+sentence-transformers==3.0.0
+huggingface-hub==0.25.0
+langchain==0.3.0
+langchain-community==0.3.0
+langchain-huggingface==0.1.0
+langchain-chroma==0.2.0
+langchain-text-splitters==0.3.0
+pypdf==4.3.0
+python-multipart==0.0.9
+pydantic==2.9.0