Update app.py

app.py

@@ -1,29 +1,29 @@
-import os
 import gradio as gr
 import numpy as np
 import google.generativeai as genai
 import faiss
 from sentence_transformers import SentenceTransformer
 from datasets import load_dataset
-from dotenv import load_dotenv
 import warnings
 
 # Suppress warnings
 warnings.filterwarnings("ignore")
 
-# Load environment variables
-load_dotenv()
-
-# Configuration
+# Configuration - PUT YOUR API KEY HERE
+GEMINI_API_KEY = "AIzaSyASrFvE3gFPigihza0JTuALzZmBx0Kc3d0"  # ⚠️ REPLACE WITH YOUR KEY
 MODEL_NAME = "all-MiniLM-L6-v2"
 GENAI_MODEL = "gemini-pro"
 DATASET_NAME = "midrees2806/7K_Dataset"
 CHUNK_SIZE = 500
 TOP_K = 3
 
-# Workaround for huggingface_hub compatibility
-import huggingface_hub
-huggingface_hub.__version__ = "0.13.4"
+# Initialize Gemini
+genai.configure(
+    api_key=GEMINI_API_KEY,
+    client_options={
+        'api_endpoint': "https://generativelanguage.googleapis.com/v1beta"
+    }
+)
 
 class GeminiRAGSystem:
     def __init__(self):
@@ -31,7 +31,6 @@ class GeminiRAGSystem:
         self.chunks = []
         self.dataset_loaded = False
         self.loading_error = None
-        self.gemini_api_key = "AIzaSyASrFvE3gFPigihza0JTuALzZmBx0Kc3d0"
         
         # Initialize embedding model
         try:
@@ -39,26 +38,20 @@ class GeminiRAGSystem:
         except Exception as e:
             raise RuntimeError(f"Failed to initialize embedding model: {str(e)}")
         
-        # Configure Gemini
-        if self.gemini_api_key:
-            genai.configure(api_key=self.gemini_api_key)
-        
         # Load dataset
         self.load_dataset()
     
     def load_dataset(self):
-        """Load dataset synchronously with error handling"""
+        """Load dataset synchronously"""
         try:
-            # Load dataset directly
             dataset = load_dataset(
                 DATASET_NAME,
                 split='train',
                 download_mode="force_redownload"
             )
             
-            # Process dataset
             if 'text' in dataset.features:
-                self.chunks = dataset['text'][:1000]  # Limit to first 1000 entries
+                self.chunks = dataset['text'][:1000]  # Use first 1000 entries
             elif 'context' in dataset.features:
                 self.chunks = dataset['context'][:1000]
             else:
@@ -96,13 +89,11 @@ class GeminiRAGSystem:
             return ""
 
     def generate_response(self, query: str) -> str:
-        """Generate response with robust error handling"""
+        """Generate response with error handling"""
         if not self.dataset_loaded:
             if self.loading_error:
                 return f"⚠️ Dataset loading failed: {self.loading_error}"
-            return "⚠️ System initialization in progress..."
-        if not self.gemini_api_key:
-            return "🔑 API key not configured"
+            return "⚠️ System initializing..."
         
         context = self.get_relevant_context(query)
         if not context:
@@ -116,61 +107,55 @@ class GeminiRAGSystem:
         
         try:
             model = genai.GenerativeModel(GENAI_MODEL)
-            response = model.generate_content(prompt)
-            return response.text
+            response = model.generate_content(
+                prompt,
+                generation_config=genai.types.GenerationConfig(
+                    temperature=0.3
+                )
+            )
+            
+            if response.candidates and response.candidates[0].content.parts:
+                return response.candidates[0].content.parts[0].text
+            return "⚠️ No response from API"
         except Exception as e:
             return f"⚠️ API Error: {str(e)}"
 
 # Initialize system
 try:
     rag_system = GeminiRAGSystem()
+    init_status = "✅ System ready" if rag_system.dataset_loaded else f"⚠️ Initializing... {rag_system.loading_error or ''}"
 except Exception as e:
-    raise RuntimeError(f"System initialization failed: {str(e)}")
+    init_status = f"❌ Initialization failed: {str(e)}"
+    rag_system = None
 
 # Create interface
-with gr.Blocks(title="UE Chatbot") as app:
-    gr.Markdown("# UE 24 Hour Service")
+with gr.Blocks(title="Document Chatbot") as app:
+    gr.Markdown("# Document Chatbot with Gemini")
     
     with gr.Row():
-        chatbot = gr.Chatbot(
-            height=500,
-            bubble_full_width=False
-        )
+        chatbot = gr.Chatbot(height=500)
     
     with gr.Row():
-        query = gr.Textbox(
-            label="Your question",
-            placeholder="Ask your question...",
-            scale=4
-        )
-        submit_btn = gr.Button("Submit", variant="primary", scale=1)
+        query = gr.Textbox(label="Your question", placeholder="Ask about the documents...")
     
     with gr.Row():
-        clear_btn = gr.Button("Clear Chat", variant="secondary")
-
-    # Status indicator
-    status = gr.Textbox(
-        label="System Status",
-        value="Ready" if rag_system.dataset_loaded else f"Initializing... {rag_system.loading_error or ''}",
-        interactive=False
-    )
+        submit_btn = gr.Button("Submit", variant="primary")
+        clear_btn = gr.Button("Clear", variant="secondary")
+    
+    status = gr.Textbox(label="Status", value=init_status)
 
-    # Event handlers
     def respond(message, chat_history):
-        try:
-            response = rag_system.generate_response(message)
-            chat_history.append((message, response))
-            return "", chat_history
-        except Exception as e:
-            chat_history.append((message, f"Error: {str(e)}"))
-            return "", chat_history
+        if not rag_system:
+            return chat_history + [(message, "System initialization failed")]
+        response = rag_system.generate_response(message)
+        return chat_history + [(message, response)]
     
     def clear_chat():
         return []
     
-    submit_btn.click(respond, [query, chatbot], [query, chatbot])
-    query.submit(respond, [query, chatbot], [query, chatbot])
+    submit_btn.click(respond, [query, chatbot], [chatbot])
+    query.submit(respond, [query, chatbot], [chatbot])
     clear_btn.click(clear_chat, outputs=chatbot)
 
 if __name__ == "__main__":
-    app.launch(share=True)
+    app.launch()