Update app.py

app.py

@@ -6,6 +6,7 @@ import faiss
 from sentence_transformers import SentenceTransformer
 from datasets import load_dataset
 from dotenv import load_dotenv
+import threading
 
 # Load environment variables
 load_dotenv()
@@ -13,7 +14,7 @@ load_dotenv()
 # Configuration
 MODEL_NAME = "all-MiniLM-L6-v2"
 GENAI_MODEL = "gemini-pro"
-DATASET_NAME = "midrees2806/7K_Dataset"  # Direct dataset name
+DATASET_NAME = "midrees2806/7K_Dataset"
 CHUNK_SIZE = 500
 TOP_K = 3
 
@@ -22,13 +23,11 @@ class GeminiRAGSystem:
         self.index = None
         self.chunks = []
         self.dataset_loaded = False
-        self.gemini_api_key = os.getenv("AIzaSyASrFvE3gFPigihza0JTuALzZmBx0Kc3d0")
+        self.loading_error = None
+        self.gemini_api_key = os.getenv("AIzaSyASrFvE3gFPigihza0JTuALzZmBx0Kc3d0")  # Changed from hardcoded key
         
-        # Initialize embedding model with explicit version compatibility
+        # Initialize embedding model
         try:
-            # Workaround for huggingface_hub compatibility
-            import huggingface_hub
-            huggingface_hub.__version__ = "0.13.4"  # Force compatible version
             self.embedding_model = SentenceTransformer(MODEL_NAME)
         except Exception as e:
             raise RuntimeError(f"Failed to initialize embedding model: {str(e)}")
@@ -36,21 +35,22 @@ class GeminiRAGSystem:
         # Configure Gemini
         if self.gemini_api_key:
             genai.configure(api_key=self.gemini_api_key)
+        
+        # Start dataset loading in background
+        self.load_dataset_in_background()
     
-    def load_dataset(self):
-        """Load dataset from Hugging Face with compatibility fallbacks"""
-        try:
-            with gr.Progress() as progress:
-                progress(0.1, desc="📦 Downloading dataset...")
-                
-                # Workaround for dataset loading
+    def load_dataset_in_background(self):
+        """Load dataset in a background thread"""
+        def load_task():
+            try:
+                # Load dataset directly without progress bar
                 dataset = load_dataset(
                     DATASET_NAME,
                     split='train',
                     download_config={"use_auth_token": False}
                 )
                 
-                progress(0.5, desc="🔨 Processing dataset...")
+                # Process dataset
                 if 'text' in dataset.features:
                     self.chunks = dataset['text'][:1000]  # Limit to first 1000 entries
                 elif 'context' in dataset.features:
@@ -58,7 +58,7 @@ class GeminiRAGSystem:
                 else:
                     raise ValueError("Dataset must have 'text' or 'context' field")
                 
-                progress(0.7, desc="🧠 Creating embeddings...")
+                # Create embeddings
                 embeddings = self.embedding_model.encode(
                     self.chunks,
                     show_progress_bar=False,
@@ -68,14 +68,15 @@ class GeminiRAGSystem:
                 self.index.add(embeddings.astype('float32'))
                 
                 self.dataset_loaded = True
-                progress(1.0, desc="✅ Dataset loaded successfully!")
-            return True
-        except Exception as e:
-            gr.Warning(f"Dataset loading error: {str(e)}")
-            return False
+            except Exception as e:
+                self.loading_error = str(e)
+                print(f"Dataset loading failed: {str(e)}")
+        
+        # Start the loading thread
+        threading.Thread(target=load_task, daemon=True).start()
     
     def get_relevant_context(self, query: str) -> str:
-        """Retrieve most relevant chunks with version-safe operations"""
+        """Retrieve most relevant chunks"""
         if not self.index:
             return ""
             
@@ -94,9 +95,11 @@ class GeminiRAGSystem:
     def generate_response(self, query: str) -> str:
         """Generate response with robust error handling"""
         if not self.dataset_loaded:
-            return "⚠️ Please load the dataset first"
+            if self.loading_error:
+                return f" Dataset loading failed: {self.loading_error}"
+            return " Dataset is still loading, please wait..."
         if not self.gemini_api_key:
-            return "🔑 Please set your Gemini API key"
+            return " Please set your Gemini API key in environment variables"
         
         context = self.get_relevant_context(query)
         if not context:
@@ -113,9 +116,9 @@ class GeminiRAGSystem:
             response = model.generate_content(prompt)
             return response.text
         except Exception as e:
-            return f"⚠️ API Error: {str(e)}"
+            return f" API Error: {str(e)}"
 
-# Initialize system with compatibility checks
+# Initialize system
 try:
     rag_system = GeminiRAGSystem()
 except Exception as e:
@@ -123,29 +126,22 @@ except Exception as e:
 
 # Create interface
 with gr.Blocks(title="UE Chatbot") as app:
-    gr.Markdown("UE 24 Hour Service")
+    gr.Markdown("# UE 24/7 Service")
     
     with gr.Row():
-        with gr.Column():
-            load_btn = gr.Button("Load Dataset", variant="primary")
-            status = gr.Markdown("System ready - Load dataset to begin")
-        
-        with gr.Column():
-            chatbot = gr.Chatbot(height=500)
-            query = gr.Textbox(label="Your question", placeholder="Ask about the dataset...")
-            with gr.Row():
-                submit_btn = gr.Button("Submit", variant="primary")
-                clear_btn = gr.Button("Clear", variant="secondary")
+        chatbot = gr.Chatbot(height=500)
     
-    # Event handlers
-    def load_dataset():
-        try:
-            if rag_system.load_dataset():
-                return "Dataset ready! Ask questions now."
-            return "Failed to load dataset"
-        except Exception as e:
-            return f" Error: {str(e)}"
+    with gr.Row():
+        query = gr.Textbox(label="Your question", placeholder="Ask your question...", scale=4)
+        submit_btn = gr.Button("Submit", variant="primary", scale=1)
+    
+    with gr.Row():
+        clear_btn = gr.Button("Clear Chat", variant="secondary")
+
+    # Status indicator
+    status = gr.Textbox(label="System Status", visible=False)
     
+    # Event handlers
     def respond(message, chat_history):
         try:
             response = rag_system.generate_response(message)
@@ -158,10 +154,17 @@ with gr.Blocks(title="UE Chatbot") as app:
     def clear_chat():
         return []
     
-    load_btn.click(load_dataset, outputs=status)
+    def get_status():
+        if rag_system.loading_error:
+            return f"Error: {rag_system.loading_error}"
+        return "Ready" if rag_system.dataset_loaded else "Loading dataset..."
+    
     submit_btn.click(respond, [query, chatbot], [query, chatbot])
     query.submit(respond, [query, chatbot], [query, chatbot])
     clear_btn.click(clear_chat, outputs=chatbot)
+    
+    # Periodically check status (hidden from user)
+    app.load(get_status, None, status, every=1)
 
 if __name__ == "__main__":
     app.launch(share=True)