Switch to Gradio SDK for ZeroGPU support

Dockerfile

@@ -1,22 +0,0 @@
-FROM python:3.9-slim
-
-WORKDIR /app
-
-# Install system dependencies for FAISS and PyMuPDF
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    libgl1 \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-COPY . .
-
-# Create necessary directories and set permissions
-RUN mkdir -p data/uploads data/vector_store && chmod -R 777 data
-
-# Set PYTHONPATH to ensure 'app' module is found
-ENV PYTHONPATH=/app
-
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -3,23 +3,27 @@ title: RAG QA System
 emoji: 📚
 colorFrom: blue
 colorTo: indigo
-sdk: docker
-app_port: 7860
+sdk: gradio
+sdk_version: 4.12.0
+app_file: app.py
 pinned: false
 ---
 
 # RAG-Based Question Answering System
 
-This is a Retrieval-Augmented Generation (RAG) system built with FastAPI, FAISS, and Google's Gemini LLM. It allows uploading PDF/TXT documents and asking questions based on their content.
+This system uses **FastAPI** for its API and **Gradio** for its user interface, running on **ZeroGPU**.
 
-## Features
+## 🚀 How it works
 
-- **FastAPI**: Modern, fast web framework for APIs.
-- **FAISS**: Efficient similarity search for document chunks.
-- **Gemini 1.5 Flash**: High-performance LLM for generating accurate answers.
-- **Background Jobs**: Asynchronous document processing to prevent API blocking.
-- **ZeroGPU Support**: Configured for Hugging Face Spaces.
+1. **Upload**: Send PDF or TXT files.
+2. **Retrieve**: FAISS finds the most relevant chunks.
+3. **Generate**: Gemini 1.5 Flash synthesizes an answer using **ZeroGPU**.
 
-## Setup & Configuration
+## 🛠️ API Access
 
-Add `GOOGLE_API_KEY` to your Hugging Face Space Secrets.
+The FastAPI endpoints are available at:
+
+- `POST /upload`: Upload documents.
+- `POST /ask`: Query the documents.
+
+Make sure to set `GOOGLE_API_KEY` in your Space Secrets.

app.py

@@ -0,0 +1,94 @@
+import gradio as gr
+from fastapi import FastAPI, UploadFile, File, BackgroundTasks, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+import os
+import shutil
+import uuid
+import spaces
+
+# Import our existing services
+from app.core.config import settings
+from app.services.document_processor import DocumentProcessor
+from app.services.vector_store import vector_store
+from app.services.llm_service import llm_service
+
+# --- FASTAPI SETUP ---
+fastapi_app = FastAPI(title="RAG API")
+fastapi_app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+
+@fastapi_app.post("/upload")
+async def api_upload(background_tasks: BackgroundTasks, file: UploadFile = File(...)):
+    if not file.filename.endswith(('.pdf', '.txt')):
+        raise HTTPException(status_code=400, detail="Only PDF and TXT supported.")
+    file_id = str(uuid.uuid4())
+    temp_path = os.path.join(settings.UPLOADS_DIR, f"{file_id}_{file.filename}")
+    os.makedirs(settings.UPLOADS_DIR, exist_ok=True)
+    with open(temp_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    
+    # Internal function for background processing
+    def process_task(path, name):
+        text = DocumentProcessor.extract_text(path)
+        chunks = DocumentProcessor.chunk_text(text)
+        vector_store.add_documents(chunks, name)
+        if os.path.exists(path): os.remove(path)
+        
+    background_tasks.add_task(process_task, temp_path, file.filename)
+    return {"message": "Processing in background", "filename": file.filename}
+
+@fastapi_app.post("/ask")
+async def api_ask(request: Request):
+    data = await request.json()
+    question = data.get("question")
+    relevant_chunks = vector_store.search(question)
+    if not relevant_chunks:
+        return {"answer": "No relevant info found.", "sources": []}
+    
+    answer = generate_answer_with_gpu(question, relevant_chunks)
+    sources = list(set([c['source'] for c in relevant_chunks]))
+    return {"answer": answer, "sources": sources}
+
+# --- ZERO-GPU DECORATED FUNCTION ---
+@spaces.GPU
+def generate_answer_with_gpu(question, chunks):
+    return llm_service.generate_answer(question, chunks)
+
+# --- GRADIO UI SETUP ---
+def chatbot_response(message, history):
+    relevant_chunks = vector_store.search(message)
+    if not relevant_chunks:
+        return "I couldn't find any relevant information in the uploaded documents."
+    
+    answer = generate_answer_with_gpu(message, relevant_chunks)
+    sources = list(set([c['source'] for c in relevant_chunks]))
+    return f"{answer}\n\n**Sources:** {', '.join(sources)}"
+
+def upload_file(file):
+    if file is None:
+        return "No file selected."
+    
+    # Process immediately for the UI
+    text = DocumentProcessor.extract_text(file.name)
+    chunks = DocumentProcessor.chunk_text(text)
+    vector_store.add_documents(chunks, os.path.basename(file.name))
+    return f"Successfully processed: {os.path.basename(file.name)}"
+
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue")) as demo:
+    gr.Markdown("# 📚 RAG-Based Question Answering System")
+    gr.Markdown("Upload documents (PDF/TXT) and ask questions. Powered by **Gemini 1.5 Flash** and **ZeroGPU**.")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            file_output = gr.Textbox(label="Upload Status")
+            upload_button = gr.UploadButton("Click to Upload PDF/TXT", file_types=[".pdf", ".txt"])
+            upload_button.upload(upload_file, upload_button, file_output)
+            
+        with gr.Column(scale=2):
+            chat = gr.ChatInterface(chatbot_response)
+
+# --- MOUNTING AND LAUNCHING ---
+app = gr.mount_gradio_app(fastapi_app, demo, path="/")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

app/main.py

@@ -1,97 +0,0 @@
-from fastapi import FastAPI, UploadFile, File, BackgroundTasks, HTTPException, Request
-from fastapi.middleware.cors import CORSMiddleware
-from slowapi import Limiter, _rate_limit_exceeded_handler
-from slowapi.util import get_remote_address
-from slowapi.errors import RateLimitExceeded
-from pydantic import BaseModel
-import shutil
-import os
-import uuid
-
-from app.core.config import settings
-from app.services.document_processor import DocumentProcessor
-from app.services.vector_store import vector_store
-from app.services.llm_service import llm_service
-
-# Initialize Limiter
-limiter = Limiter(key_func=get_remote_address)
-app = FastAPI(title="RAG-Based QA System")
-app.state.limiter = limiter
-app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-class QueryRequest(BaseModel):
-    question: str
-
-class QueryResponse(BaseModel):
-    answer: str
-    sources: list[str]
-
-def process_document_task(file_path: str, original_filename: str):
-    try:
-        text = DocumentProcessor.extract_text(file_path)
-        chunks = DocumentProcessor.chunk_text(text)
-        vector_store.add_documents(chunks, original_filename)
-    except Exception as e:
-        print(f"Error processing document: {e}")
-    finally:
-        if os.path.exists(file_path):
-            os.remove(file_path)
-
-@app.post("/upload")
-@limiter.limit(settings.RATE_LIMIT)
-async def upload_document(request: Request, background_tasks: BackgroundTasks, file: UploadFile = File(...)):
-    if not file.filename.endswith(('.pdf', '.txt')):
-        raise HTTPException(status_code=400, detail="Only PDF and TXT files are supported.")
-    
-    file_id = str(uuid.uuid4())
-    temp_path = os.path.join(settings.UPLOADS_DIR, f"{file_id}_{file.filename}")
-    
-    # Ensure directory exists
-    os.makedirs(settings.UPLOADS_DIR, exist_ok=True)
-    
-    with open(temp_path, "wb") as buffer:
-        shutil.copyfileobj(file.file, buffer)
-    
-    background_tasks.add_task(process_document_task, temp_path, file.filename)
-    
-    return {"message": "File uploaded successfully. Processing in background.", "filename": file.filename}
-
-try:
-    import spaces
-    @spaces.GPU
-    def generate_with_gpu(query, context_chunks):
-        return llm_service.generate_answer(query, context_chunks)
-except ImportError:
-    def generate_with_gpu(query, context_chunks):
-        return llm_service.generate_answer(query, context_chunks)
-
-@app.post("/ask", response_model=QueryResponse)
-@limiter.limit(settings.RATE_LIMIT)
-async def ask_question(request: Request, query_req: QueryRequest):
-    relevant_chunks = vector_store.search(query_req.question)
-    
-    if not relevant_chunks:
-        raise HTTPException(status_code=404, detail="No relevant context found in documents.")
-    
-    # Use the GPU decorated function
-    answer = generate_with_gpu(query_req.question, relevant_chunks)
-    sources = list(set([chunk['source'] for chunk in relevant_chunks]))
-    
-    return QueryResponse(answer=answer, sources=sources)
-
-@app.get("/")
-async def root():
-    return {"message": "Welcome to the RAG-Based QA System API"}
-
-if __name__ == "__main__":
-    import uvicorn
-    # Use port assigned by HF or default to 7860
-    port = int(os.environ.get("PORT", 7860))
-    uvicorn.run(app, host="0.0.0.0", port=port)