Update app.py

app.py

@@ -24,8 +24,11 @@ class GeminiRAGSystem:
         self.dataset_loaded = False
         self.gemini_api_key = os.getenv("AIzaSyASrFvE3gFPigihza0JTuALzZmBx0Kc3d0")
         
-        # Initialize embedding model
+        # Initialize embedding model with explicit version compatibility
         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)}")
@@ -35,11 +38,17 @@ class GeminiRAGSystem:
             genai.configure(api_key=self.gemini_api_key)
     
     def load_dataset(self):
-        """Load dataset from Hugging Face"""
+        """Load dataset from Hugging Face with compatibility fallbacks"""
         try:
             with gr.Progress() as progress:
                 progress(0.1, desc="📦 Downloading dataset...")
-                dataset = load_dataset(DATASET_NAME, split='train')
+                
+                # Workaround for dataset loading
+                dataset = load_dataset(
+                    DATASET_NAME,
+                    split='train',
+                    download_config={"use_auth_token": False}
+                )
                 
                 progress(0.5, desc="🔨 Processing dataset...")
                 if 'text' in dataset.features:
@@ -50,7 +59,11 @@ class GeminiRAGSystem:
                     raise ValueError("Dataset must have 'text' or 'context' field")
                 
                 progress(0.7, desc="🧠 Creating embeddings...")
-                embeddings = self.embedding_model.encode(self.chunks, show_progress_bar=False)
+                embeddings = self.embedding_model.encode(
+                    self.chunks,
+                    show_progress_bar=False,
+                    convert_to_numpy=True
+                )
                 self.index = faiss.IndexFlatL2(embeddings.shape[1])
                 self.index.add(embeddings.astype('float32'))
                 
@@ -58,25 +71,28 @@ class GeminiRAGSystem:
                 progress(1.0, desc="✅ Dataset loaded successfully!")
             return True
         except Exception as e:
-            gr.Warning(f"Failed to load dataset: {str(e)}")
+            gr.Warning(f"Dataset loading error: {str(e)}")
             return False
     
     def get_relevant_context(self, query: str) -> str:
-        """Retrieve most relevant chunks"""
+        """Retrieve most relevant chunks with version-safe operations"""
         if not self.index:
             return ""
             
-        query_embed = self.embedding_model.encode([query])
-        _, indices = self.index.search(query_embed.astype('float32'), k=TOP_K)
-        
-        context = []
-        for idx in indices[0]:
-            if idx < len(self.chunks):
-                context.append(self.chunks[idx])
-        return "\n\n".join(context)
-    
+        try:
+            query_embed = self.embedding_model.encode(
+                [query],
+                convert_to_numpy=True
+            ).astype('float32')
+            
+            _, indices = self.index.search(query_embed, k=TOP_K)
+            return "\n\n".join([self.chunks[i] for i in indices[0] if i < len(self.chunks)])
+        except Exception as e:
+            print(f"Search error: {str(e)}")
+            return ""
+
     def generate_response(self, query: str) -> str:
-        """Generate response using Gemini"""
+        """Generate response with robust error handling"""
         if not self.dataset_loaded:
             return "⚠️ Please load the dataset first"
         if not self.gemini_api_key:
@@ -97,39 +113,55 @@ class GeminiRAGSystem:
             response = model.generate_content(prompt)
             return response.text
         except Exception as e:
-            return f"⚠️ Error: {str(e)}"
+            return f"⚠️ API Error: {str(e)}"
 
-# Initialize system
-rag_system = GeminiRAGSystem()
+# Initialize system with compatibility checks
+try:
+    rag_system = GeminiRAGSystem()
+except Exception as e:
+    raise RuntimeError(f"System initialization failed: {str(e)}")
 
 # Create interface
-with gr.Blocks(title="RAG Chatbot") as app:
-    gr.Markdown("# UE_ChatBot")
+with gr.Blocks(title="UE Chatbot") as app:
+    gr.Markdown("UE 24 Hour Service")
     
     with gr.Row():
         with gr.Column():
-            load_btn = gr.Button("🚀 Load Dataset", variant="primary")
-            status = gr.Markdown("ℹ️ Click to load dataset")
+            load_btn = gr.Button("Load Dataset", variant="primary")
+            status = gr.Markdown("System ready - Load dataset to begin")
         
         with gr.Column():
-            chatbot = gr.Chatbot()
+            chatbot = gr.Chatbot(height=500)
             query = gr.Textbox(label="Your question", placeholder="Ask about the dataset...")
-            submit_btn = gr.Button("📤 Submit", variant="primary")
+            with gr.Row():
+                submit_btn = gr.Button("Submit", variant="primary")
+                clear_btn = gr.Button("Clear", variant="secondary")
     
     # Event handlers
     def load_dataset():
-        if rag_system.load_dataset():
-            return "✅ Dataset ready! You can now ask questions."
-        return "❌ Failed to 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)}"
     
     def respond(message, chat_history):
-        response = rag_system.generate_response(message)
-        chat_history.append((message, response))
-        return "", 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
+    
+    def clear_chat():
+        return []
     
     load_btn.click(load_dataset, outputs=status)
     submit_btn.click(respond, [query, chatbot], [query, chatbot])
     query.submit(respond, [query, chatbot], [query, chatbot])
+    clear_btn.click(clear_chat, outputs=chatbot)
 
 if __name__ == "__main__":
     app.launch(share=True)