Update app.py

app.py

@@ -1,16 +1,22 @@
 import os
+import logging
+import asyncio
+from typing import Optional, Dict, Any, List
+from datetime import datetime
+import json
 import time
-import gradio as gr
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException, File, UploadFile, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse, JSONResponse
+from pydantic import BaseModel, Field
 import uvicorn
-from fastapi import FastAPI, HTTPException, Depends, File, UploadFile
-from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
-from pydantic import BaseModel
-from typing import Optional, Dict, Any
-import threading
-import logging
-from langchain._community.document_loaders import TextLoader
+
+from langchain.document_loaders import TextLoader
 from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain_community.vectorstores import FAISS
+from langchain.vectorstores import FAISS
 from langchain.chains import RetrievalQA
 from langchain.prompts import PromptTemplate
 from langchain.callbacks.base import BaseCallbackHandler
@@ -18,39 +24,99 @@ from langchain_google_genai import ChatGoogleGenerativeAI, GoogleGenerativeAIEmb
 import tiktoken
 
 # Configure logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
 logger = logging.getLogger(__name__)
 
-# --- Configuration ---
-CHUNK_SIZE = 800
-CHUNK_OVERLAP = 100
-MAX_TOKENS = 512
-TEMPERATURE = 0.5
-RETRIEVAL_K = 5
+# Initialize FastAPI app
+app = FastAPI(
+    title="Maize Crop RAG System",
+    description="AI-powered Q&A system for maize agriculture",
+    version="1.0.0"
+)
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-# --- Token Counting Setup ---
+# Global variables for the RAG system
+vector_store = None
+qa_chain = None
+token_callback_handler = None
+is_initialized = False
+
+# Configuration
+class Config:
+    GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY", "")
+    CHUNK_SIZE = 800
+    CHUNK_OVERLAP = 100
+    MAX_RETRIES = 3
+    RATE_LIMIT_DELAY = 1.0
+    MODEL_NAME = "gemini-1.5-flash"
+    EMBEDDING_MODEL = "models/embedding-001"
+    TEMPERATURE = 0.5
+    MAX_OUTPUT_TOKENS = 512
+    RETRIEVER_K = 5
+    INDEX_PATH = "faiss_maize_index"
+    DATA_PATH = "data/maize_data.txt"
+
+config = Config()
+
+# Request/Response Models
+class QueryRequest(BaseModel):
+    query: str = Field(..., min_length=1, max_length=500)
+    
+class QueryResponse(BaseModel):
+    answer: str
+    sources: List[str] = []
+    token_usage: Dict[str, int] = {}
+    processing_time: float
+    timestamp: str
+
+class SystemStatus(BaseModel):
+    status: str
+    is_initialized: bool
+    model_name: str
+    embedding_model: str
+    vector_store_ready: bool
+    total_chunks: int = 0
+    api_key_configured: bool
+
+class InitializeRequest(BaseModel):
+    api_key: str = Field(..., min_length=1)
+
+# Token counting utilities
 try:
     tokenizer = tiktoken.get_encoding("cl100k_base")
 except:
-    print("Tiktoken encoder 'cl100k_base' not found. Using basic split().")
+    logger.warning("Tiktoken encoder not found. Using basic split().")
     tokenizer = type('obj', (object,), {'encode': lambda x: x.split()})()
 
-def estimate_tokens(text):
+def estimate_tokens(text: str) -> int:
     """Estimates token count for a given text."""
     return len(tokenizer.encode(text))
 
-# Custom Callback Handler to track LLM token usage
+# Custom Callback Handler
 class TokenUsageCallbackHandler(BaseCallbackHandler):
     """Callback handler to track token usage in LLM calls."""
+    
     def __init__(self):
         super().__init__()
-        self.reset_counters()
-
-    def reset_counters(self):
+        self.reset()
+    
+    def reset(self):
         self.total_prompt_tokens = 0
         self.total_completion_tokens = 0
         self.total_llm_calls = 0
-
+        self.last_call_tokens = {}
+    
     def on_llm_end(self, response, **kwargs):
         """Collect token usage from the LLM response."""
         self.total_llm_calls += 1
@@ -63,120 +129,92 @@ class TokenUsageCallbackHandler(BaseCallbackHandler):
             
             self.total_prompt_tokens += prompt_tokens
             self.total_completion_tokens += completion_tokens
-
-    def get_total_tokens(self):
-        """Returns the total prompt and completion tokens."""
+            
+            self.last_call_tokens = {
+                "prompt_tokens": prompt_tokens,
+                "completion_tokens": completion_tokens,
+                "total_tokens": prompt_tokens + completion_tokens
+            }
+            
+            logger.info(f"Token usage - Prompt: {prompt_tokens}, Completion: {completion_tokens}")
+    
+    def get_last_call_usage(self):
+        return self.last_call_tokens
+    
+    def get_total_usage(self):
         return {
             "total_prompt_tokens": self.total_prompt_tokens,
             "total_completion_tokens": self.total_completion_tokens,
-            "total_llm_tokens": self.total_prompt_tokens + self.total_completion_tokens,
-            "total_llm_calls": self.total_llm_calls
+            "total_tokens": self.total_prompt_tokens + self.total_completion_tokens,
+            "total_calls": self.total_llm_calls
         }
 
-# --- Pydantic Models for API ---
-class InitializeRequest(BaseModel):
-    api_key: str
-    document_content: Optional[str] = None
-
-class QueryRequest(BaseModel):
-    query: str
-    api_key: str
-
-class InitializeResponse(BaseModel):
-    success: bool
-    message: str
-    chunks: Optional[int] = None
-    estimated_tokens: Optional[int] = None
-
-class QueryResponse(BaseModel):
-    success: bool
-    answer: str
-    response_time: float
-    query_tokens: int
-    llm_tokens: Dict[str, int]
-    session_stats: Dict[str, int]
-
-class StatsResponse(BaseModel):
-    total_queries: int
-    total_embedding_tokens: int
-    total_llm_tokens: int
-    total_llm_calls: int
-    initialization_complete: bool
-
-# --- Global Variables ---
-class RAGSystem:
-    def __init__(self):
-        self.vector_store = None
-        self.qa_chain = None
-        self.token_callback_handler = TokenUsageCallbackHandler()
-        self.session_stats = {
-            "total_queries": 0,
-            "total_embedding_tokens": 0,
-            "initialization_complete": False
-        }
-        self.current_api_key = None
-
-# Global RAG system instance
-rag_system = RAGSystem()
-
-def initialize_rag_system(api_key, file_content=None):
-    """Initialize the RAG system with API key and optional file content."""
-    global rag_system
+# RAG System Functions
+async def initialize_rag_system(api_key: str = None):
+    """Initialize or reinitialize the RAG system."""
+    global vector_store, qa_chain, token_callback_handler, is_initialized, config
     
     try:
-        # Set API key
-        os.environ["GOOGLE_API_KEY"] = api_key
-        rag_system.current_api_key = api_key
-        
-        # Initialize embeddings
-        embeddings = GoogleGenerativeAIEmbeddings(
-            model="models/embedding-001",
-            google_api_key=api_key
-        )
+        # Use provided API key or environment variable
+        if api_key:
+            config.GOOGLE_API_KEY = api_key
+            os.environ["GOOGLE_API_KEY"] = api_key
+        elif not config.GOOGLE_API_KEY:
+            raise ValueError("Google API key not provided")
         
-        # Initialize LLM
-        llm = ChatGoogleGenerativeAI(
-            model="gemini-1.5-flash",
-            google_api_key=api_key,
-            temperature=TEMPERATURE,
-            max_tokens=MAX_TOKENS,
-            callbacks=[rag_system.token_callback_handler],
-            verbose=False
-        )
+        logger.info("Initializing RAG system...")
         
-        # Load or use default document
-        if file_content:
-            # Save uploaded file content
-            with open("uploaded_document.txt", "w", encoding="utf-8") as f:
-                f.write(file_content)
-            loader = TextLoader("uploaded_document.txt")
-        else:
-            # Check if default maize_data.txt exists
-            if os.path.exists("maize_data.txt"):
-                loader = TextLoader("maize_data.txt")
-            else:
-                return "❌ No document found. Please upload a file or ensure maize_data.txt exists."
+        # Initialize token callback handler
+        token_callback_handler = TokenUsageCallbackHandler()
         
         # Load and split documents
+        if not os.path.exists(config.DATA_PATH):
+            raise FileNotFoundError(f"Data file not found: {config.DATA_PATH}")
+        
+        loader = TextLoader(config.DATA_PATH)
         documents = loader.load()
+        
         text_splitter = RecursiveCharacterTextSplitter(
-            chunk_size=CHUNK_SIZE, 
-            chunk_overlap=CHUNK_OVERLAP
+            chunk_size=config.CHUNK_SIZE,
+            chunk_overlap=config.CHUNK_OVERLAP
         )
         chunks = text_splitter.split_documents(documents)
+        logger.info(f"Document split into {len(chunks)} chunks")
         
-        # Estimate embedding tokens
-        initial_embedding_tokens = sum(estimate_tokens(chunk.page_content) for chunk in chunks)
-        rag_system.session_stats["total_embedding_tokens"] = initial_embedding_tokens
+        # Initialize embeddings
+        embeddings = GoogleGenerativeAIEmbeddings(
+            model=config.EMBEDDING_MODEL,
+            google_api_key=config.GOOGLE_API_KEY
+        )
         
-        # Create vector store
-        rag_system.vector_store = FAISS.from_documents(chunks, embeddings)
+        # Create or load FAISS index
+        if os.path.exists(config.INDEX_PATH):
+            vector_store = FAISS.load_local(
+                config.INDEX_PATH, 
+                embeddings, 
+                allow_dangerous_deserialization=True
+            )
+            logger.info(f"Loaded existing FAISS index from '{config.INDEX_PATH}'")
+        else:
+            vector_store = FAISS.from_documents(chunks, embeddings)
+            vector_store.save_local(config.INDEX_PATH)
+            logger.info(f"Created new FAISS index at '{config.INDEX_PATH}'")
+        
+        # Initialize LLM
+        llm = ChatGoogleGenerativeAI(
+            model=config.MODEL_NAME,
+            google_api_key=config.GOOGLE_API_KEY,
+            temperature=config.TEMPERATURE,
+            max_tokens=config.MAX_OUTPUT_TOKENS,
+            callbacks=[token_callback_handler]
+        )
         
         # Create prompt template
         prompt_template = PromptTemplate(
             input_variables=["context", "question"],
             template="""
-You are an expert in maize agriculture. Use the following context ONLY to answer the question accurately and helpfully. If the context doesn't contain the answer, say "Based on the provided context, I cannot answer this question.".
+You are an expert in maize agriculture. Use the following context ONLY to answer the question accurately and helpfully. 
+If the context doesn't contain the answer, say "Based on the provided context, I cannot answer this question."
 
 Context:
 {context}
@@ -187,415 +225,150 @@ Answer:"""
         )
         
         # Set up QA chain
-        rag_system.qa_chain = RetrievalQA.from_chain_type(
+        qa_chain = RetrievalQA.from_chain_type(
             llm=llm,
             chain_type="stuff",
-            retriever=rag_system.vector_store.as_retriever(search_kwargs={"k": RETRIEVAL_K}),
+            retriever=vector_store.as_retriever(search_kwargs={"k": config.RETRIEVER_K}),
             chain_type_kwargs={"prompt": prompt_template},
-            callbacks=[rag_system.token_callback_handler],
+            callbacks=[token_callback_handler],
             return_source_documents=True
         )
         
-        rag_system.session_stats["initialization_complete"] = True
-        
-        return f"✅ RAG system initialized successfully!\n📄 Document processed: {len(chunks)} chunks\n🔢 Estimated embedding tokens: ~{initial_embedding_tokens}"
-        
-    except Exception as e:
-        logger.error(f"Initialization failed: {str(e)}")
-        return f"❌ Initialization failed: {str(e)}"
-
-def process_query(query, api_key):
-    """Process a user query through the RAG system."""
-    global rag_system
-    
-    if not api_key:
-        return "❌ Please provide a Google API key first.", ""
-    
-    if not rag_system.qa_chain:
-        return "❌ RAG system not initialized. Please initialize first.", ""
-    
-    if not query.strip():
-        return "❌ Please enter a question.", ""
-    
-    try:
-        # Estimate query embedding tokens
-        query_tokens = estimate_tokens(query)
-        rag_system.session_stats["total_embedding_tokens"] += query_tokens
-        rag_system.session_stats["total_queries"] += 1
-        
-        # Process query
-        start_time = time.time()
-        result = rag_system.qa_chain({"query": query})
-        end_time = time.time()
-        
-        # Get token usage
-        llm_tokens = rag_system.token_callback_handler.get_total_tokens()
-        
-        # Format response
-        answer = result['result']
-        
-        # Create stats summary
-        stats = f"""
-📊 **Query Statistics:**
-- Response time: {end_time - start_time:.2f} seconds
-- Query tokens (estimated): ~{query_tokens}
-- LLM tokens (this query): Prompt: {llm_tokens['total_prompt_tokens']}, Completion: {llm_tokens['total_completion_tokens']}
-
-📈 **Session Statistics:**
-- Total queries: {rag_system.session_stats['total_queries']}
-- Total embedding tokens: ~{rag_system.session_stats['total_embedding_tokens']}
-- Total LLM calls: {llm_tokens['total_llm_calls']}
-- Total LLM tokens: {llm_tokens['total_llm_tokens']}
-"""
-        
-        return answer, stats
+        is_initialized = True
+        logger.info("RAG system initialized successfully")
+        return True
         
     except Exception as e:
-        logger.error(f"Error processing query: {str(e)}")
-        return f"❌ Error processing query: {str(e)}", ""
-
-def upload_file_and_initialize(api_key, file):
-    """Handle file upload and system initialization."""
-    if not api_key:
-        return "❌ Please provide a Google API key first."
-    
-    if file is None:
-        return initialize_rag_system(api_key)
-    
-    try:
-        # Read uploaded file
-        file_content = file.decode('utf-8')
-        return initialize_rag_system(api_key, file_content)
-    except Exception as e:
-        return f"❌ Error reading uploaded file: {str(e)}"
-
-def reset_session():
-    """Reset the session statistics."""
-    global rag_system
-    rag_system.token_callback_handler.reset_counters()
-    rag_system.session_stats = {
-        "total_queries": 0,
-        "total_embedding_tokens": 0,
-        "initialization_complete": False
-    }
-    return "🔄 Session statistics reset."
-
-# --- FastAPI Setup ---
-app = FastAPI(
-    title="Maize RAG Q&A System API",
-    description="API for the Maize Agriculture RAG Q&A System",
-    version="1.0.0"
-)
-
-# Optional: Add API key authentication for API endpoints
-security = HTTPBearer(auto_error=False)
-
-async def get_api_key(credentials: HTTPAuthorizationCredentials = Depends(security)):
-    """Extract API key from Authorization header (optional)"""
-    if credentials:
-        return credentials.credentials
-    return None
-
-# --- API Endpoints ---
-
-@app.get("/")
+        logger.error(f"Failed to initialize RAG system: {str(e)}")
+        is_initialized = False
+        raise
+
+# API Endpoints
+@app.on_event("startup")
+async def startup_event():
+    """Initialize the system on startup if API key is available."""
+    if config.GOOGLE_API_KEY:
+        try:
+            await initialize_rag_system()
+        except Exception as e:
+            logger.warning(f"Could not initialize on startup: {str(e)}")
+
+@app.get("/", response_class=HTMLResponse)
 async def root():
-    """Root endpoint"""
-    return {"message": "Maize RAG Q&A System API", "status": "running"}
-
-@app.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    return {
-        "status": "healthy",
-        "system_initialized": rag_system.session_stats["initialization_complete"]
-    }
+    """Serve the main HTML page."""
+    with open("static/index.html", "r") as f:
+        return f.read()
+
+@app.get("/api/status", response_model=SystemStatus)
+async def get_status():
+    """Get system status."""
+    return SystemStatus(
+        status="ready" if is_initialized else "not_initialized",
+        is_initialized=is_initialized,
+        model_name=config.MODEL_NAME,
+        embedding_model=config.EMBEDDING_MODEL,
+        vector_store_ready=vector_store is not None,
+        total_chunks=len(vector_store.docstore._dict) if vector_store else 0,
+        api_key_configured=bool(config.GOOGLE_API_KEY)
+    )
 
-@app.post("/initialize", response_model=InitializeResponse)
+@app.post("/api/initialize", response_model=Dict[str, Any])
 async def initialize_system(request: InitializeRequest):
-    """Initialize the RAG system"""
+    """Initialize the RAG system with provided API key."""
     try:
-        result = initialize_rag_system(request.api_key, request.document_content)
-        
-        if "✅" in result:
-            # Parse successful result
-            lines = result.split('\n')
-            chunks = None
-            tokens = None
-            
-            for line in lines:
-                if "chunks" in line:
-                    chunks = int(line.split(': ')[1].split(' ')[0])
-                elif "tokens" in line:
-                    tokens = int(line.split('~')[1])
-            
-            return InitializeResponse(
-                success=True,
-                message=result,
-                chunks=chunks,
-                estimated_tokens=tokens
-            )
-        else:
-            return InitializeResponse(
-                success=False,
-                message=result
-            )
-    
+        await initialize_rag_system(request.api_key)
+        return {
+            "success": True,
+            "message": "System initialized successfully"
+        }
     except Exception as e:
-        logger.error(f"API initialization error: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.post("/query", response_model=QueryResponse)
-async def query_system(request: QueryRequest):
-    """Query the RAG system"""
+@app.post("/api/query", response_model=QueryResponse)
+async def process_query(request: QueryRequest):
+    """Process a query and return the answer."""
+    if not is_initialized:
+        raise HTTPException(
+            status_code=503, 
+            detail="System not initialized. Please provide API key."
+        )
+    
     try:
-        if not rag_system.session_stats["initialization_complete"]:
-            raise HTTPException(status_code=400, detail="System not initialized")
+        start_time = time.time()
         
-        # Estimate query embedding tokens
-        query_tokens = estimate_tokens(request.query)
-        rag_system.session_stats["total_embedding_tokens"] += query_tokens
-        rag_system.session_stats["total_queries"] += 1
+        # Reset token counter for this query
+        if token_callback_handler:
+            token_callback_handler.last_call_tokens = {}
         
-        # Process query
-        start_time = time.time()
-        result = rag_system.qa_chain({"query": request.query})
-        end_time = time.time()
+        # Process query with retry logic
+        for attempt in range(config.MAX_RETRIES):
+            try:
+                result = qa_chain({"query": request.query})
+                break
+            except Exception as e:
+                if attempt == config.MAX_RETRIES - 1:
+                    raise
+                await asyncio.sleep(config.RATE_LIMIT_DELAY * (attempt + 1))
         
-        # Get token usage
-        llm_tokens = rag_system.token_callback_handler.get_total_tokens()
+        processing_time = time.time() - start_time
         
-        response_time = end_time - start_time
+        # Extract sources
+        sources = []
+        if 'source_documents' in result:
+            sources = [doc.page_content[:200] + "..." 
+                      for doc in result['source_documents'][:3]]
+        
+        # Get token usage
+        token_usage = {}
+        if token_callback_handler:
+            token_usage = token_callback_handler.get_last_call_usage()
         
         return QueryResponse(
-            success=True,
             answer=result['result'],
-            response_time=response_time,
-            query_tokens=query_tokens,
-            llm_tokens=llm_tokens,
-            session_stats=rag_system.session_stats
+            sources=sources,
+            token_usage=token_usage,
+            processing_time=round(processing_time, 2),
+            timestamp=datetime.now().isoformat()
         )
-    
+        
     except Exception as e:
-        logger.error(f"API query error: {str(e)}")
+        logger.error(f"Error processing query: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.get("/stats", response_model=StatsResponse)
-async def get_stats():
-    """Get current session statistics"""
-    llm_tokens = rag_system.token_callback_handler.get_total_tokens()
+@app.get("/api/token-stats", response_model=Dict[str, Any])
+async def get_token_stats():
+    """Get token usage statistics."""
+    if not token_callback_handler:
+        return {"message": "No token statistics available"}
     
-    return StatsResponse(
-        total_queries=rag_system.session_stats["total_queries"],
-        total_embedding_tokens=rag_system.session_stats["total_embedding_tokens"],
-        total_llm_tokens=llm_tokens["total_llm_tokens"],
-        total_llm_calls=llm_tokens["total_llm_calls"],
-        initialization_complete=rag_system.session_stats["initialization_complete"]
-    )
+    return token_callback_handler.get_total_usage()
 
-@app.post("/reset")
-async def reset_system():
-    """Reset session statistics"""
-    reset_session()
-    return {"message": "Session reset successfully"}
-
-@app.post("/upload-document")
-async def upload_document(
-    file: UploadFile = File(...),
-    api_key: str = None
-):
-    """Upload a document and initialize the system"""
+@app.post("/api/upload-document")
+async def upload_document(file: UploadFile = File(...)):
+    """Upload a new document to replace the existing one."""
     try:
-        if not api_key:
-            raise HTTPException(status_code=400, detail="API key required")
-        
-        # Read uploaded file
+        # Save uploaded file
         content = await file.read()
-        file_content = content.decode('utf-8')
-        
-        # Initialize system with uploaded content
-        result = initialize_rag_system(api_key, file_content)
-        
-        if "✅" in result:
-            return {"success": True, "message": result}
+        with open(config.DATA_PATH, "wb") as f:
+            f.write(content)
+        
+        # Reinitialize the system with new data
+        if config.GOOGLE_API_KEY:
+            # Remove old index to force recreation
+            if os.path.exists(config.INDEX_PATH):
+                import shutil
+                shutil.rmtree(config.INDEX_PATH)
+            
+            await initialize_rag_system()
+            return {"success": True, "message": "Document uploaded and system reinitialized"}
         else:
-            return {"success": False, "message": result}
-    
+            return {"success": True, "message": "Document uploaded. Please initialize the system."}
+            
     except Exception as e:
-        logger.error(f"Document upload error: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
 
-# Create Gradio interface
-def create_interface():
-    with gr.Blocks(title="Maize RAG Q&A System", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("""
-        # 🌽 Maize Agriculture RAG Q&A System
-        
-        This system uses Retrieval-Augmented Generation (RAG) to answer questions about maize agriculture.
-        Upload your own document or use the default maize dataset.
-        """)
-        
-        with gr.Row():
-            with gr.Column(scale=2):
-                api_key_input = gr.Textbox(
-                    label="🔑 Google API Key",
-                    placeholder="Enter your Google Generative AI API key",
-                    type="password",
-                    info="Get your API key from Google AI Studio"
-                )
-            
-            with gr.Column(scale=1):
-                reset_btn = gr.Button("🔄 Reset Session", variant="secondary")
-        
-        with gr.Row():
-            with gr.Column():
-                file_upload = gr.File(
-                    label="📁 Upload Document (Optional)",
-                    file_types=[".txt"],
-                    info="Upload a text file or use the default maize dataset"
-                )
-                
-                init_btn = gr.Button("🚀 Initialize RAG System", variant="primary")
-                init_output = gr.Textbox(
-                    label="📋 Initialization Status",
-                    lines=3,
-                    interactive=False
-                )
-        
-        gr.Markdown("## 💬 Ask Questions")
-        
-        with gr.Row():
-            with gr.Column(scale=3):
-                query_input = gr.Textbox(
-                    label="❓ Your Question",
-                    placeholder="Ask something about maize agriculture...",
-                    lines=2
-                )
-                
-                # Sample questions
-                sample_questions = [
-                    "What are the main pests affecting maize crops?",
-                    "How should maize be irrigated?",
-                    "What is the ideal soil type for maize?",
-                    "What are the nutritional requirements of maize?",
-                    "When is the best time to harvest maize?"
-                ]
-                
-                gr.Examples(
-                    examples=sample_questions,
-                    inputs=query_input,
-                    label="💡 Sample Questions"
-                )
-            
-            with gr.Column(scale=1):
-                submit_btn = gr.Button("🔍 Ask", variant="primary")
-        
-        with gr.Row():
-            with gr.Column(scale=2):
-                answer_output = gr.Textbox(
-                    label="🤖 Answer",
-                    lines=6,
-                    interactive=False
-                )
-            
-            with gr.Column(scale=1):
-                stats_output = gr.Markdown(
-                    label="📊 Statistics",
-                    value="Statistics will appear here after queries."
-                )
-        
-        # Event handlers
-        init_btn.click(
-            upload_file_and_initialize,
-            inputs=[api_key_input, file_upload],
-            outputs=init_output
-        )
-        
-        submit_btn.click(
-            process_query,
-            inputs=[query_input, api_key_input],
-            outputs=[answer_output, stats_output]
-        )
-        
-        query_input.submit(
-            process_query,
-            inputs=[query_input, api_key_input],
-            outputs=[answer_output, stats_output]
-        )
-        
-        reset_btn.click(
-            reset_session,
-            outputs=init_output
-        )
-        
-        gr.Markdown("""
-        ## 📝 Instructions:
-        1. **Enter your Google API Key** (required)
-        2. **Upload a document** (optional - uses default maize dataset if not provided)
-        3. **Initialize the RAG system** by clicking "Initialize RAG System"
-        4. **Ask questions** about the document content
-        5. **View statistics** to monitor token usage and costs
-        
-        ## 💰 Cost Information:
-        - **Gemini 1.5 Flash**: Input: $0.075/1M tokens, Output: $0.30/1M tokens
-        - **Embedding Model**: $0.025/1M tokens
-        
-        Token usage is estimated and displayed for cost tracking.
-        """)
-    
-    return demo
-
-# Create and launch the interface
-def run_gradio():
-    """Run Gradio interface"""
-    demo = create_interface()
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True,
-        quiet=True  # Reduce Gradio logs in combined mode
-    )
-
-def run_fastapi():
-    """Run FastAPI server"""
-    uvicorn.run(
-        app, 
-        host="0.0.0.0", 
-        port=8000,
-        log_level="info"
-    )
+# Mount static files
+app.mount("/static", StaticFiles(directory="static"), name="static")
 
 if __name__ == "__main__":
-    import sys
-    
-    if len(sys.argv) > 1:
-        mode = sys.argv[1]
-        
-        if mode == "api":
-            # Run only FastAPI
-            print("Starting FastAPI server on port 8000...")
-            run_fastapi()
-        elif mode == "gradio":
-            # Run only Gradio
-            print("Starting Gradio interface on port 7860...")
-            run_gradio()
-        elif mode == "both":
-            # Run both servers
-            print("Starting both FastAPI (port 8000) and Gradio (port 7860)...")
-            
-            # Start FastAPI in a separate thread
-            fastapi_thread = threading.Thread(target=run_fastapi)
-            fastapi_thread.daemon = True
-            fastapi_thread.start()
-            
-            # Start Gradio in main thread
-            time.sleep(2)  # Give FastAPI time to start
-            run_gradio()
-        else:
-            print("Usage: python app.py [api|gradio|both]")
-            print("Default: gradio only")
-            run_gradio()
-    else:
-        # Default: run only Gradio (for Hugging Face Spaces compatibility)
-        print("Starting Gradio interface on port 7860...")
-        run_gradio()
+    uvicorn.run(app, host="0.0.0.0", port=7860)