Configure production environment variables for Vercel deployment

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Layer 1: Install dependencies (Cached)
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Layer 2: Pre-download model (Cached permanently)
+RUN python -c "\
+from sentence_transformers import SentenceTransformer; \
+model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2'); \
+print('✓ Model cached at build time — zero runtime download needed')"
+
+# Layer 3: Copy application code (Updates instantly on code changes)
+COPY . .
+
+EXPOSE 7860
+CMD ["uvicorn", "api:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,8 @@
+---
+title: GovBridge India API
+emoji: 🏛️
+colorFrom: red
+colorTo: green
+sdk: docker
+pinned: false
+---

api.py

@@ -1,104 +1,220 @@
 import os
-import requests
-import httpx
-from fastapi import FastAPI
+import hashlib
+import re
+from datetime import datetime
+from typing import Optional
+from fastapi import FastAPI, Request
 from fastapi.responses import StreamingResponse
-from pydantic import BaseModel
+from pydantic import BaseModel, Field, field_validator
 from supabase import create_client, Client
 from groq import Groq
 from fastapi.middleware.cors import CORSMiddleware
+from sentence_transformers import SentenceTransformer
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from slowapi.util import get_remote_address
+from slowapi.errors import RateLimitExceeded
 
+# --- SECURE KEYS ---
 SUPABASE_URL = os.environ.get("SUPABASE_URL")
-SUPABASE_KEY = os.environ.get("SUPABASE_KEY")
+SUPABASE_KEY = os.environ.get("SUPABASE_KEY") 
 GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
-HF_TOKEN = os.environ.get("HF_TOKEN") # New Free API Key
+ADMIN_SECRET = os.environ.get("ADMIN_SECRET", "change-this-in-production")
 
 supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
 groq_client = Groq(api_key=GROQ_API_KEY)
 
 app = FastAPI()
 
-# Allow React to talk to this API securely
+# --- RATE LIMITER CONFIG ---
+limiter = Limiter(key_func=get_remote_address)
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
+# --- CORS MIDDLEWARE (Gotcha 2 Fix: expose_headers applied) ---
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"], 
-    allow_credentials=False,  # <-- This is the magic CORS fix!
+    allow_credentials=False,
     allow_methods=["*"],
     allow_headers=["*"],
+    expose_headers=["X-Sources"],
 )
 
+# --- MODELS ---
 class SearchQuery(BaseModel):
-    question: str
+    question: str = Field(..., min_length=3, max_length=500)
+
+    @field_validator('question')
+    @classmethod
+    def clean_input(cls, v):
+        v = re.sub(r'<[^>]+>', '', v)        # strip HTML tags
+        v = re.sub(r'\s+', ' ', v).strip()   # normalize whitespace
+        if not v:
+            raise ValueError('Question is empty after cleaning')
+        return v
+
+class IngestRequest(BaseModel):
+    title: str
+    text: str
+    ministry: Optional[str] = None
+    state: Optional[str] = None
+    source_url: Optional[str] = None
+    doc_type: Optional[str] = "scheme"
+
+# --- INITIALIZE AI ---
+print("Loading heavy PyTorch AI Model...")
+embedding_model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
+
+def chunk_text(text: str, chunk_size: int = 500, overlap: int = 50) -> list[str]:
+    paragraphs = [p.strip() for p in text.split('\n\n') if p.strip()]
+    chunks = []
+    current = ""
+    for para in paragraphs:
+        if len(current) + len(para) < chunk_size:
+            current += " " + para
+        else:
+            if current.strip():
+                chunks.append(current.strip())
+            current = para
+    if current.strip():
+        chunks.append(current.strip())
+    if len(chunks) <= 1:
+        return chunks
+    overlapped = [chunks[0]]
+    for i in range(1, len(chunks)):
+        tail = chunks[i-1][-overlap:] if len(chunks[i-1]) > overlap else chunks[i-1]
+        overlapped.append(tail + " " + chunks[i])
+    return overlapped
+
+# --- ENDPOINTS ---
+
+@app.get("/health")
+async def health_check():
+    checks = {}
+    try:
+        test_vec = embedding_model.encode("test", normalize_embeddings=True)
+        checks["embedding_model"] = {"status": "ok", "dims": len(test_vec)}
+    except Exception as e:
+        checks["embedding_model"] = {"status": "error", "detail": str(e)}
+    try:
+        supabase.table("document_chunks").select("id").limit(1).execute()
+        checks["supabase"] = {"status": "ok"}
+    except Exception as e:
+        checks["supabase"] = {"status": "error", "detail": str(e)}
+    checks["groq"] = {
+        "status": "ok" if os.environ.get("GROQ_API_KEY") else "missing"
+    }
+    all_ok = all(v["status"] == "ok" for v in checks.values())
+    return {
+        "status": "healthy" if all_ok else "degraded",
+        "timestamp": datetime.utcnow().isoformat(),
+        "checks": checks
+    }
+
+@app.post("/api/admin/ingest")
+async def ingest_document(request: IngestRequest, admin_key: str = ""):
+    if admin_key != ADMIN_SECRET:
+        async def denied():
+            yield "Unauthorized"
+        return StreamingResponse(denied(), status_code=401, media_type="text/plain")
+
+    print(f"Ingesting: '{request.title}' ({len(request.text)} chars)")
+    doc_hash = hashlib.sha256(request.text.encode()).hexdigest()[:16]
+    chunks = chunk_text(request.text)
+    print(f"Created {len(chunks)} chunks")
+
+    embeddings = embedding_model.encode(
+        chunks,
+        normalize_embeddings=True,
+        batch_size=32,
+        show_progress_bar=False
+    ).tolist()
+
+    rows = []
+    for i, (chunk, embedding) in enumerate(zip(chunks, embeddings)):
+        rows.append({
+            "chunk_index": i,
+            "chunk_text": chunk,
+            "scheme_title": request.title,
+            "ministry": request.ministry,
+            "state": request.state,
+            "source_url": request.source_url,
+            "doc_type": request.doc_type,
+            "embedding": embedding,
+            "content_hash": doc_hash
+        })
+
+    result = supabase.table("document_chunks").upsert(
+        rows,
+        on_conflict="content_hash,chunk_index"
+    ).execute()
+
+    return {
+        "status": "success",
+        "title": request.title,
+        "chunks_created": len(chunks),
+        "doc_hash": doc_hash
+    }
 
 @app.post("/api/rag/query")
-async def rag_query(query: SearchQuery):
+@limiter.limit("10/minute")
+async def rag_query(request: Request, query: SearchQuery):
     print(f"Citizen asked: {query.question}")
     
-    # NEW: Hugging Face API Fallback (Zero RAM Usage)
-    hf_url = "https://api-inference.huggingface.co/models/sentence-transformers/all-MiniLM-L6-v2"
-    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
-    
-    print("Pinging Hugging Face...")
     try:
-        hf_response = requests.post(
-            hf_url, 
-            headers=headers, 
-            json={
-                "inputs": [query.question],
-                "options": {"wait_for_model": True} # Forces HF to wake up automatically
-            },
-            timeout=120.0 # Gives the model plenty of time to boot up
-        )
-        hf_data = hf_response.json()
+        query_numbers = embedding_model.encode(query.question, normalize_embeddings=True).tolist()
         
-        # Safety check if HF is completely overloaded
-        if isinstance(hf_data, dict) and "error" in hf_data:
-            print(f"HuggingFace Error: {hf_data}")
-            async def error_msg():
-                yield "The AI Brain is experiencing heavy traffic. Please try asking again in 15 seconds!"
-            return StreamingResponse(error_msg(), media_type="text/plain")
-            
-        query_numbers = hf_data[0]
+        result = supabase.rpc("match_documents", {
+            "query_embedding": query_numbers,
+            "match_count": 5
+        }).execute()
         
-    except Exception as e:
-        print(f"Critical Network Error: {e}")
-        async def crash_msg():
-            yield "The AI Brain is temporarily disconnected from the network. Please try again."
-        return StreamingResponse(crash_msg(), media_type="text/plain")
-    
-    result = supabase.rpc("match_documents", {
-        "query_embedding": query_numbers,
-        "match_count": 5
-    }).execute()
-    
-    chunks = result.data
-    
-    if not chunks:
-        context = "No relevant schemes found in the database."
-    else:
-        context = "\n\n---\n\n".join([
-            f"[Document: {c.get('scheme_title', 'Unknown')}]\n{c.get('chunk_text', '')}"
-            for c in chunks
-        ])
-
-    def stream_answer():
-        response = groq_client.chat.completions.create(
-            model="llama-3.3-70b-versatile",
-            messages=[
-                {"role": "system", "content": 
-                 "You are GovBridge AI, a helpful assistant for Indian citizens. "
-                 "Answer the user's question using ONLY the provided context. "
-                 "Always cite the official scheme names. If the context does not "
-                 "contain the answer, clearly say 'This information is not available in our database.'"},
-                {"role": "user", "content": f"Context:\n{context}\n\nQuestion: {query.question}"}
-            ],
-            temperature=0.1,
-            max_tokens=1024,
-            stream=True
+        chunks = result.data
+        
+        if not chunks:
+            context = "This information is not available in the GovBridge database for this query."
+            source_titles = []
+        else:
+            context = "\n\n---\n\n".join([
+                f"[Document: {c.get('scheme_title', 'Unknown')}]\n{c.get('chunk_text', '')}"
+                for c in chunks
+            ])
+            source_titles = list(set([
+                c.get('scheme_title', 'Unknown')
+                for c in chunks
+                if c.get('scheme_title')
+            ]))
+
+        def stream_answer():
+            response = groq_client.chat.completions.create(
+                model="llama-3.3-70b-versatile",
+                messages=[
+                    {"role": "system", "content": 
+                     "You are GovBridge AI, a helpful assistant for Indian citizens. "
+                     "Answer the user's question using ONLY the provided context. "
+                     "Format benefits as bullet points where applicable."},
+                    {"role": "user", "content": f"Context:\n{context}\n\nQuestion: {query.question}"}
+                ],
+                temperature=0.1,
+                max_tokens=1024,
+                stream=True
+            )
+            for chunk in response:
+                delta = chunk.choices[0].delta.content or ""
+                if delta:
+                    yield delta
+
+        return StreamingResponse(
+            stream_answer(), 
+            media_type="text/plain",
+            headers={
+                "X-Accel-Buffering": "no",
+                "X-Sources": "|".join(source_titles)
+            }
         )
-        for chunk in response:
-            delta = chunk.choices[0].delta.content or ""
-            if delta:
-                yield delta
 
-    return StreamingResponse(stream_answer(), media_type="text/plain")
+    except Exception as e:
+        print(f"System Error: {e}")
+        async def crash_msg():
+            yield "The AI Brain encountered an internal logic error. Please try again."
+        return StreamingResponse(crash_msg(), media_type="text/plain")

requirements.txt

@@ -1,6 +1,6 @@
 fastapi
-uvicorn
-pydantic
-supabase
+uvicorn[standard]
+sentence-transformers
 groq
-httpx
+supabase
+slowapi

test_ingest.py

@@ -0,0 +1,30 @@
+import requests
+import json
+
+# Replace this with your actual Hugging Face Space URL
+HF_API_URL = "https://harshrawat18-govbridge-api.hf.space" 
+
+# Replace this with the ADMIN_SECRET you just created in Hugging Face
+ADMIN_SECRET = "govbridge-1008-1119wfgdfgwfwjhghjwgjhvbwvc" 
+
+# The real data we are sending to the AI
+payload = {
+    "title": "PM-KISAN (Pradhan Mantri Kisan Samman Nidhi)",
+    "text": "Under the PM-KISAN scheme, all landholding farmers' families shall be provided the financial benefit of Rs. 6000 per annum per family payable in three equal installments of Rs. 2000 each, every four months. The scheme aims to supplement the financial needs of the farmers in procuring various inputs to ensure proper crop health and appropriate yields, commensurate with the anticipated farm income.",
+    "ministry": "Ministry of Agriculture and Farmers Welfare",
+    "doc_type": "scheme"
+}
+
+print("Sending data across the bridge to Hugging Face...")
+
+response = requests.post(
+    f"{HF_API_URL}/api/admin/ingest?admin_key={ADMIN_SECRET}",
+    json=payload
+)
+
+if response.status_code == 200:
+    print("✅ SUCCESS!")
+    print(json.dumps(response.json(), indent=2))
+else:
+    print("❌ FAILED!")
+    print(response.text)