Update app.py

app.py

@@ -1,13 +1,11 @@
-import gradio as gr
+from fastapi import FastAPI, Query
+from fastapi.responses import FileResponse, JSONResponse
+import uvicorn
 import fitz  # PyMuPDF for PDF text extraction
 import faiss  # FAISS for vector search
 import numpy as np
-import threading
 from sentence_transformers import SentenceTransformer
 from huggingface_hub import InferenceClient
-from typing import List, Tuple
-from fastapi import FastAPI, Query
-import uvicorn
 
 # Default settings
 class ChatConfig:
@@ -24,37 +22,47 @@ index = faiss.IndexFlatL2(vector_dim)  # FAISS index
 
 documents = []  # Store extracted text
 
-def extract_text_from_pdf(pdf_path):
-    """Extracts text from PDF"""
-    doc = fitz.open(pdf_path)
-    text_chunks = [page.get_text("text") for page in doc]
-    return text_chunks
+app = FastAPI()
 
-def create_vector_db(text_chunks):
-    """Embeds text chunks and adds them to FAISS index"""
-    global documents, index
+@app.get("/")
+def serve_homepage():
+    """Serves the HTML interface."""
+    return FileResponse("index.html")
+
+@app.post("/upload_pdf/")
+async def upload_pdf(file_path: str):
+    """Handles PDF file processing."""
+    global documents
+
+    # Extract text from PDF
+    doc = fitz.open(file_path)
+    text_chunks = [page.get_text("text") for page in doc]
+    
+    # Create vector database
     documents = text_chunks
     embeddings = embed_model.encode(text_chunks)
     index.add(np.array(embeddings, dtype=np.float32))
 
-def search_relevant_text(query):
-    """Finds the most relevant text chunk for the given query"""
-    query_embedding = embed_model.encode([query])
-    _, closest_idx = index.search(np.array(query_embedding, dtype=np.float32), k=3)
-    return "\n".join([documents[i] for i in closest_idx[0]])
+    return JSONResponse({"message": "PDF uploaded and indexed successfully!"})
 
-def generate_response_sync(message: str) -> str:
-    """Generates response synchronously for FastAPI"""
+@app.get("/chat/")
+def chat_with_pdf(msg: str = Query(..., title="User Message")):
+    """Handles user queries and returns AI-generated responses."""
     if not documents:
-        return "Please upload a PDF first."
+        return JSONResponse({"response": "Please upload a PDF first."})
+
+    # Retrieve relevant context
+    query_embedding = embed_model.encode([msg])
+    _, closest_idx = index.search(np.array(query_embedding, dtype=np.float32), k=3)
+    context = "\n".join([documents[i] for i in closest_idx[0]])
 
-    context = search_relevant_text(message)  # Get relevant content from PDF
+    # Generate AI response
     messages = [
         {"role": "system", "content": ChatConfig.DEFAULT_SYSTEM_MSG},
-        {"role": "user", "content": f"Context: {context}\nQuestion: {message}"}
+        {"role": "user", "content": f"Context: {context}\nQuestion: {msg}"}
     ]
 
-    response = ""
+    response_text = ""
     for chunk in client.chat_completion(
         messages,
         max_tokens=ChatConfig.DEFAULT_MAX_TOKENS,
@@ -63,61 +71,9 @@ def generate_response_sync(message: str) -> str:
         top_p=ChatConfig.DEFAULT_TOP_P,
     ):
         token = chunk.choices[0].delta.content or ""
-        response += token
-
-    return response
-
-def handle_upload(pdf_file):
-    """Handles PDF upload and creates vector DB"""
-    text_chunks = extract_text_from_pdf(pdf_file.name)
-    create_vector_db(text_chunks)
-    return "PDF uploaded and indexed successfully!"
-
-def create_interface() -> gr.Blocks:
-    """Creates the Gradio interface"""
-    with gr.Blocks() as interface:
-        gr.Markdown("# PDF-Based Chatbot using Google Gemma")
-        
-        with gr.Row():
-            chatbot = gr.Chatbot(label="Chat with Your PDF", type="messages")
-            pdf_upload = gr.File(label="Upload PDF", type="filepath")
-        
-        with gr.Row():
-            user_input = gr.Textbox(label="Ask a question", placeholder="Type here...")
-            send_button = gr.Button("Send")
-        
-        output = gr.Textbox(label="Response", lines=5)
-
-        # Upload PDF handler
-        pdf_upload.change(handle_upload, inputs=[pdf_upload], outputs=[])
-
-        # Chat function
-        send_button.click(
-            generate_response_sync, 
-            inputs=[user_input], 
-            outputs=[output]
-        )
+        response_text += token
 
-    return interface
-
-# FastAPI Integration
-app = FastAPI()
-
-@app.get("/chat")
-def chat_with_pdf(msg: str = Query(..., title="User Message")):
-    """API endpoint to receive a message and return AI response"""
-    response = generate_response_sync(msg)
-    return {"response": response}
-
-def run_gradio():
-    """Launches Gradio in a separate thread."""
-    gradio_app = create_interface()
-    gradio_app.launch(server_name="0.0.0.0", server_port=7860, share=True, enable_queue=False)
+    return JSONResponse({"response": response_text})
 
 if __name__ == "__main__":
-    # Start Gradio in a separate thread
-    gradio_thread = threading.Thread(target=run_gradio, daemon=True)
-    gradio_thread.start()
-
-    # Run FastAPI with Uvicorn
     uvicorn.run(app, host="0.0.0.0", port=8000)