Update app.py

app.py

@@ -1,6 +1,7 @@
 """
 Advanced Agriculture Intelligence System with Professional UI
-Integrates Gemini 1.5 Pro, Llama-3.3, and Multilingual Support
+Integrates Gemini (Google) + Groq (Llama) + Multilingual Support
+Corrected version with improved error handling and language mapping.
 """
 
 import gradio as gr
@@ -25,16 +26,20 @@ class AgricultureIntelligenceSystem:
     def __init__(self):
         print("Initializing Agriculture Intelligence System...")
         
-        self.google_api_key = os.environ.get("GOOGLE_API_KEY", "")
-        self.gemini_api_url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={self.google_api_key}"
+        # Load API keys from env
+        self.google_api_key = os.environ.get("GOOGLE_API_KEY", "").strip()
+        # Note: user earlier referenced Gemini 1.5 Pro — adjust endpoint if you have another model name.
+        # Keep key as query param for simplicity; you may prefer Authorization header in prod.
+        self.gemini_api_url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-pro:generateContent?key={self.google_api_key}"
         
-        self.groq_api_key = os.environ.get("GROQ_API_KEY", "")
+        self.groq_api_key = os.environ.get("GROQ_API_KEY", "").strip()
         self.groq_api_url = "https://api.groq.com/openai/v1/chat/completions"
         
         self.conversation_history = []
         self.image_context = None
         self.current_analysis = None
         
+        # Map UI labels to language codes
         self.supported_languages = {
             "🇬🇧 English": "en",
             "🇮🇳 हिंदी (Hindi)": "hi",
@@ -52,10 +57,14 @@ class AgricultureIntelligenceSystem:
     
     def encode_image_to_base64(self, image: Image.Image) -> str:
         buffered = io.BytesIO()
-        image.save(buffered, format="JPEG")
+        image.save(buffered, format="JPEG", quality=90)
         return base64.b64encode(buffered.getvalue()).decode('utf-8')
     
     def analyze_with_gemini(self, image: Image.Image) -> Dict:
+        """
+        Send image + prompt to Gemini (Generative Language API). This function is robust to several
+        API output shapes and returns a parsed JSON analysis dict or a helpful error dict.
+        """
         if not self.google_api_key:
             return {"error": "Google API Key not configured"}
         
@@ -105,8 +114,8 @@ class AgricultureIntelligenceSystem:
   }
 }
 
-Be specific, practical, and provide actionable recommendations."""
-
+Be specific, practical, and provide actionable recommendations in strict JSON only (no commentary)."""
+            
             request_body = {
                 "contents": [{
                     "parts": [
@@ -115,41 +124,89 @@ Be specific, practical, and provide actionable recommendations."""
                     ]
                 }],
                 "generationConfig": {
-                    "temperature": 0.4,
-                    "topK": 32,
-                    "topP": 1,
-                    "maxOutputTokens": 4096,
+                    "temperature": 0.2,
+                    "topK": 40,
+                    "topP": 0.95,
+                    "maxOutputTokens": 2048,
                 }
             }
             
+            # Post with a 60s timeout
             response = requests.post(self.gemini_api_url, json=request_body, timeout=60)
             
+            # If non-200, include response text in error for easier debugging
             if response.status_code != 200:
-                return {"error": f"API Error ({response.status_code})"}
+                body_text = ""
+                try:
+                    body_text = response.text
+                except:
+                    body_text = "<no body>"
+                return {"error": f"API Error ({response.status_code})", "raw": body_text}
             
             result = response.json()
             
-            if 'candidates' in result and len(result['candidates']) > 0:
-                text_response = result['candidates'][0]['content']['parts'][0]['text'].strip()
-                
-                # Clean JSON response
-                if text_response.startswith('```json'):
-                    text_response = text_response[7:]
-                if text_response.startswith('```'):
-                    text_response = text_response[3:]
-                if text_response.endswith('```'):
-                    text_response = text_response[:-3]
-                text_response = text_response.strip()
-                
-                try:
-                    analysis_data = json.loads(text_response)
-                    analysis_data['timestamp'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-                    return analysis_data
-                except json.JSONDecodeError:
-                    return {"error": "Failed to parse response", "raw_response": text_response}
+            # Gemini / Generative Language responses have varied shapes.
+            # Try common paths: 'candidates', 'outputs', 'content' etc.
+            text_response = None
+            # Path 1: result['candidates'][0]['content']['parts'][0]['text']
+            try:
+                if isinstance(result, dict):
+                    if 'candidates' in result and len(result['candidates']) > 0:
+                        cand = result['candidates'][0]
+                        # Many shapes inside candidate
+                        if isinstance(cand, dict):
+                            # often: cand['content']['parts'][0]['text']
+                            if 'content' in cand and isinstance(cand['content'], dict):
+                                parts = cand['content'].get('parts', [])
+                                if parts and isinstance(parts[0], dict) and 'text' in parts[0]:
+                                    text_response = parts[0]['text']
+                    # Path 2: 'output' or 'outputs'
+                    if text_response is None:
+                        # Sometimes the model returns in 'outputs'
+                        outputs = result.get('outputs') or result.get('output')
+                        if isinstance(outputs, list) and len(outputs) > 0:
+                            first_out = outputs[0]
+                            if isinstance(first_out, dict):
+                                # check nested text
+                                if 'text' in first_out:
+                                    text_response = first_out['text']
+                                elif 'content' in first_out and isinstance(first_out['content'], dict):
+                                    # content may contain parts
+                                    parts = first_out['content'].get('parts', [])
+                                    if parts and isinstance(parts[0], dict) and 'text' in parts[0]:
+                                        text_response = parts[0]['text']
+                # Fallback: top-level string
+                if text_response is None:
+                    # attempt to find any string value in JSON response heuristically
+                    # (last resort)
+                    maybe = json.dumps(result)
+                    text_response = maybe
+            except Exception as e:
+                return {"error": f"Failed to parse API response: {str(e)}", "raw_response": str(result)}
             
-            return {"error": "No response from API"}
+            if not text_response:
+                return {"error": "No textual response returned from Gemini", "raw_response": result}
             
+            # Clean markdown fences if present
+            text_response = text_response.strip()
+            if text_response.startswith("```json"):
+                text_response = text_response.split("```json", 1)[1].rsplit("```", 1)[0].strip()
+            elif text_response.startswith("```"):
+                text_response = text_response.strip("` \n")
+            
+            # Try to parse as JSON
+            try:
+                analysis_data = json.loads(text_response)
+                if not isinstance(analysis_data, dict):
+                    return {"error": "Parsed response is not JSON object", "raw_response": text_response}
+                analysis_data['timestamp'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                return analysis_data
+            except json.JSONDecodeError:
+                # Return useful debug info so UI shows the raw response for troubleshooting
+                return {"error": "Failed to parse response as JSON", "raw_response": text_response}
+            
+        except requests.Timeout:
+            return {"error": "Timeout while contacting Gemini API"}
         except Exception as e:
             return {"error": f"Analysis failed: {str(e)}"}
     
@@ -161,16 +218,17 @@ Be specific, practical, and provide actionable recommendations."""
             return [
                 "What type of plants can you analyze?",
                 "How accurate is the AI diagnosis?",
-                "Can you explain disease prevention methods?"
+                "Can you explain disease prevention methods?",
+                "What information do you need for better results?"
             ]
         
         health = analysis.get('health_assessment', {})
         disease_name = health.get('disease_name')
-        severity = health.get('severity', '').lower()
+        severity = (health.get('severity', '') or '').lower()
         treatment = analysis.get('treatment', {})
         
         # Disease-specific questions
-        if disease_name and disease_name != "None detected":
+        if disease_name and disease_name not in ("None", "None detected", "", None):
             questions.extend([
                 f"What causes {disease_name}?",
                 f"How do I treat {disease_name} effectively?",
@@ -200,17 +258,34 @@ Be specific, practical, and provide actionable recommendations."""
             "What preventive measures should I take?"
         ])
         
-        return questions[:6]  # Return top 6 questions
+        # Deduplicate and limit to 6
+        seen = set()
+        out = []
+        for q in questions:
+            if q not in seen:
+                out.append(q)
+                seen.add(q)
+            if len(out) >= 6:
+                break
+        return out
     
-    def chat_with_llama(self, user_message: str, language: str = "en", history: List = None) -> str:
+    def chat_with_llama(self, user_message: str, language_label: str = "🇬🇧 English", history: List = None) -> str:
+        """
+        Chat via Groq (Llama). Translates incoming user message to English if necessary,
+        includes current image analysis context, calls the Groq chat endpoint, then translates
+        assistant response back to selected language (if not English).
+        """
         if not self.groq_api_key:
             return "⚠️ Groq API key not configured. Chat functionality unavailable."
         
+        # Map language label to code; default to 'en'
+        lang_code = self.supported_languages.get(language_label, "en")
+        
+        # Build context from latest image analysis (if present)
         context = ""
         if self.image_context:
             plant = self.image_context.get('plant_identification', {})
             health = self.image_context.get('health_assessment', {})
-            
             context = f"""
 Current Plant Analysis:
 - Plant: {plant.get('common_name', 'Unknown')} ({plant.get('scientific_name', 'N/A')})
@@ -218,14 +293,14 @@ Current Plant Analysis:
 - Health: {health.get('status', 'Unknown')}
 - Disease: {health.get('disease_name', 'None')}
 - Severity: {health.get('severity', 'Unknown')}
-- Confidence: {health.get('confidence', 0)}%
+- Confidence: {plant.get('confidence', 0)}%
 """
+        # If user selected a non-English language, translate user_message -> English for the model
+        user_message_en = user_message
+        if lang_code != "en":
+            user_message_en = self.translate_text(user_message, target_lang="en", source_lang=lang_code)
         
-        if language != "en":
-            user_message_en = self.translate_text(user_message, "en", language)
-        else:
-            user_message_en = user_message
-        
+        # Build messages
         messages = [{
             "role": "system",
             "content": f"""You are an expert agricultural advisor specializing in plant diseases and crop management. 
@@ -242,14 +317,13 @@ Provide practical, science-based advice. Be specific about:
 Keep responses clear, actionable, and farmer-friendly. Use bullet points for lists."""
         }]
         
+        # Append last few history items (if present)
         if history:
-            for msg in history[-6:]:
+            for msg in history[-8:]:
                 if isinstance(msg, dict):
-                    if msg.get('role') == 'user':
-                        messages.append({"role": "user", "content": msg.get('content', '')})
-                    elif msg.get('role') == 'assistant':
-                        messages.append({"role": "assistant", "content": msg.get('content', '')})
+                    messages.append(msg)
         
+        # Append user message (English version)
         messages.append({"role": "user", "content": user_message_en})
         
         try:
@@ -261,61 +335,87 @@ Keep responses clear, actionable, and farmer-friendly. Use bullet points for lis
             payload = {
                 "model": "llama-3.3-70b-versatile",
                 "messages": messages,
-                "temperature": 0.7,
-                "max_tokens": 1500,
-                "top_p": 0.9
+                "temperature": 0.6,
+                "max_tokens": 1000,
+                "top_p": 0.95
             }
             
             response = requests.post(self.groq_api_url, headers=headers, json=payload, timeout=30)
+            if response.status_code != 200:
+                # include body for debugging
+                try:
+                    return f"⚠️ API Error ({response.status_code}): {response.text}"
+                except:
+                    return f"⚠️ API Error ({response.status_code})"
             
-            if response.status_code == 200:
-                result = response.json()
+            result = response.json()
+            # Expecting OpenAI-like chat completion shape
+            bot_response = ""
+            try:
                 bot_response = result['choices'][0]['message']['content']
-                
-                if language != "en":
-                    bot_response = self.translate_text(bot_response, language, "en")
-                
-                return bot_response
-            else:
-                return f"⚠️ API Error ({response.status_code})"
-                
+            except Exception:
+                # Fallback for different shapes
+                bot_response = result.get('choices', [{}])[0].get('text') or json.dumps(result)
+            
+            # If user language isn't English, translate bot response -> user language
+            if lang_code != "en" and bot_response:
+                bot_response_translated = self.translate_text(bot_response, target_lang=lang_code, source_lang="en")
+                return bot_response_translated
+            return bot_response
+        
+        except requests.Timeout:
+            return "⚠️ Groq API request timed out."
         except Exception as e:
             return f"⚠️ Error: {str(e)}"
     
     def translate_text(self, text: str, target_lang: str, source_lang: str = "en") -> str:
-        if target_lang == source_lang or target_lang == "en":
+        """
+        Translate `text` from source_lang -> target_lang.
+        For simplicity, we use the Groq chat endpoint and ask it to translate. This is a best-effort
+        approach; consider using a dedicated translation API (Google Translate) for production.
+        """
+        if not text or target_lang == source_lang:
             return text
         
+        # If Groq API is not available, return original text
+        if not self.groq_api_key:
+            return text
+        
+        # Create a short system instruction to force only the translation
+        target_name = target_lang
+        source_name = source_lang
+        # Map codes to readable names for the model if possible
+        code_to_name = {v: k for k, v in self.supported_languages.items()}
+        target_name = code_to_name.get(target_lang, target_lang)
+        source_name = code_to_name.get(source_lang, source_lang)
+        
+        headers = {
+            "Authorization": f"Bearer {self.groq_api_key}",
+            "Content-Type": "application/json"
+        }
+        payload = {
+            "model": "llama-3.3-70b-versatile",
+            "messages": [
+                {
+                    "role": "system",
+                    "content": f"Translate the following text from {source_name} to {target_name}. Only provide the translation, no extra commentary."
+                },
+                {"role": "user", "content": text}
+            ],
+            "temperature": 0.0,
+            "max_tokens": 1500
+        }
+        
         try:
-            if not self.groq_api_key:
-                return text
-            
-            lang_names = {v: k for k, v in self.supported_languages.items()}
-            target_lang_name = lang_names.get(target_lang, target_lang)
-            
-            headers = {
-                "Authorization": f"Bearer {self.groq_api_key}",
-                "Content-Type": "application/json"
-            }
-            
-            payload = {
-                "model": "llama-3.3-70b-versatile",
-                "messages": [
-                    {
-                        "role": "system",
-                        "content": f"Translate to {target_lang_name}. Only provide translation."
-                    },
-                    {"role": "user", "content": text}
-                ],
-                "temperature": 0.3,
-                "max_tokens": 2000
-            }
-            
-            response = requests.post(self.groq_api_url, headers=headers, json=payload, timeout=30)
-            
+            response = requests.post(self.groq_api_url, headers=headers, json=payload, timeout=20)
             if response.status_code == 200:
-                return response.json()['choices'][0]['message']['content']
-            return text
+                result = response.json()
+                try:
+                    return result['choices'][0]['message']['content'].strip()
+                except Exception:
+                    return text
+            else:
+                return text
         except:
             return text
 
@@ -327,7 +427,7 @@ Keep responses clear, actionable, and farmer-friendly. Use bullet points for lis
 def create_advanced_interface():
     system = AgricultureIntelligenceSystem()
     
-    # Custom CSS for professional look
+    # Custom CSS for professional look (kept same)
     custom_css = """
     .container {max-width: 1400px; margin: auto;}
     .header {background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 2rem; border-radius: 10px; margin-bottom: 2rem;}
@@ -342,53 +442,45 @@ def create_advanced_interface():
     
     def process_image(image):
         if image is None:
-            return None, "⚠️ Please upload an image", None, gr.update(visible=False)
+            return None, "<div style='text-align:center;color:#666;padding:1rem;'>⚠️ Please upload an image</div>", [], gr.update(visible=False)
         
         try:
             img = Image.fromarray(image).convert('RGB') if isinstance(image, np.ndarray) else image.convert('RGB')
             
-            # Show loading state
-            loading_html = """
-            <div style='text-align: center; padding: 2rem;'>
-                <div style='font-size: 3rem;'>🔬</div>
-               
-                <p style='color: #666;'>Please wait while AI examines your plant</p>
-            </div>
-            """
-            
             analysis = system.analyze_with_gemini(img)
             
             if "error" in analysis:
                 error_html = f"""
                 <div style='background: #fee; padding: 2rem; border-radius: 8px; border-left: 4px solid #f44;'>
                     <h3 style='color: #c33; margin: 0;'>❌ Analysis Error</h3>
-                    <p style='margin: 0.5rem 0 0 0;'>{analysis['error']}</p>
-                </div>
+                    <p style='margin: 0.5rem 0 0 0;'>{analysis.get('error')}</p>
                 """
-                return None, error_html, None, gr.update(visible=False)
+                raw = analysis.get('raw') or analysis.get('raw_response') or analysis.get('raw_response')
+                if raw:
+                    error_html += f"<pre style='white-space:pre-wrap;margin-top:0.5rem;background:#fff;padding:0.5rem;border-radius:4px;color:#333;'>Debug: {str(raw)[:1000]}</pre>"
+                error_html += "</div>"
+                # Provide nothing to suggestions
+                return analysis, error_html, [], gr.update(visible=False)
             
             system.image_context = analysis
             system.current_analysis = analysis
             
-            # Generate beautiful analysis card
             analysis_html = format_analysis_card(analysis)
-            
-            # Generate suggested questions
             suggestions = system.generate_suggested_questions(analysis)
             
             return analysis, analysis_html, suggestions, gr.update(visible=True)
         
         except Exception as e:
-            return None, f"⚠️ Error: {str(e)}", None, gr.update(visible=False)
+            return {"error": str(e)}, f"<div style='color:#c33;'>⚠️ Error: {str(e)}</div>", [], gr.update(visible=False)
     
     def format_analysis_card(analysis: Dict) -> str:
-        plant = analysis.get('plant_identification', {})
-        health = analysis.get('health_assessment', {})
-        symptoms = analysis.get('visual_symptoms', [])
-        treatment = analysis.get('treatment', {})
-        urgency = analysis.get('urgency', {})
+        plant = analysis.get('plant_identification', {}) if isinstance(analysis, dict) else {}
+        health = analysis.get('health_assessment', {}) if isinstance(analysis, dict) else {}
+        symptoms = analysis.get('visual_symptoms', []) if isinstance(analysis, dict) else []
+        treatment = analysis.get('treatment', {}) if isinstance(analysis, dict) else {}
+        urgency = analysis.get('urgency', {}) if isinstance(analysis, dict) else {}
         
-        status = health.get('status', '').lower()
+        status = (health.get('status') or '').lower()
         disease_name = health.get('disease_name', 'None')
         
         # Determine card style
@@ -396,7 +488,7 @@ def create_advanced_interface():
             card_class = 'healthy-card'
             icon = '✅'
             status_text = 'Plant is Healthy'
-        elif disease_name and disease_name != 'None detected':
+        elif disease_name and disease_name not in ('None', 'None detected', None, ''):
             card_class = 'disease-card'
             icon = '⚠️'
             status_text = 'Disease Detected'
@@ -439,7 +531,7 @@ def create_advanced_interface():
             html += "</ul></div>"
         
         # Treatment
-        if treatment and (treatment.get('immediate_actions') or treatment.get('chemical_treatments')):
+        if treatment and (treatment.get('immediate_actions') or treatment.get('chemical_treatments') or treatment.get('organic_alternatives')):
             html += """
             <div style='background: #fff; padding: 1.5rem; border-radius: 8px; margin: 1rem 0; border: 1px solid #e0e0e0;'>
                 <h3 style='margin: 0 0 1rem 0; color: #333;'>💊 Treatment Recommendations</h3>
@@ -485,12 +577,12 @@ def create_advanced_interface():
         
         return html
     
-    def handle_suggestion_click(question, history, language, analysis):
+    def handle_suggestion_click(question, history, language_label, analysis):
         if not question:
-            return history, ""
+            return history or [], ""
         
         # Get bot response
-        bot_response = system.chat_with_llama(question, system.supported_languages.get(language, "en"), history or [])
+        bot_response = system.chat_with_llama(question, language_label, history or [])
         
         # Update history
         if history is None:
@@ -501,17 +593,16 @@ def create_advanced_interface():
         
         return history, ""
     
-    def send_message(message, history, language, analysis):
-        if not message.strip():
-            return history, ""
-        
-        return handle_suggestion_click(message, history, language, analysis)
+    def send_message(message, history, language_label, analysis):
+        if not message or not message.strip():
+            return history or [], ""
+        return handle_suggestion_click(message.strip(), history or [], language_label, analysis)
     
     def clear_all():
         system.conversation_history = []
         system.image_context = None
         system.current_analysis = None
-        return None, None, "👋 Upload a plant image to begin AI-powered diagnosis", [], None, gr.update(visible=False)
+        return None, None, "<div style='text-align:center;padding:1rem;color:#666;'>👋 Upload a plant image to begin AI-powered diagnosis</div>", [], None, gr.update(visible=False)
     
     # Create interface
     with gr.Blocks(title="AgriBot Pro - AI Plant Doctor") as demo:
@@ -523,7 +614,6 @@ def create_advanced_interface():
         gr.HTML("""
         <div class='header'>
             <h1>🌾 AgriBot Pro - AI Plant Doctor</h1>
-            
         </div>
         """)
         
@@ -567,14 +657,16 @@ def create_advanced_interface():
                 )
                 
                 # Suggested questions row
-                with gr.Row(visible=False) as suggestions_row:
+                suggestions_row = gr.Row(visible=False)
+                with suggestions_row:
                     gr.Markdown("### 💡 Suggested Questions:")
                 
                 suggestions_display = gr.HTML(visible=False)
                 
                 # Create suggestion buttons dynamically
                 suggestion_buttons = []
-                with gr.Row(visible=False) as suggestion_btns_row:
+                suggestion_btns_row = gr.Row(visible=False)
+                with suggestion_btns_row:
                     for i in range(6):
                         btn = gr.Button("", visible=False, elem_classes="suggestion-btn")
                         suggestion_buttons.append(btn)
@@ -589,26 +681,29 @@ def create_advanced_interface():
                     send_btn = gr.Button("📤 Send", variant="primary")
                     clear_btn = gr.Button("🗑️ Clear All")
         
-        # Event Handlers
+        # Helper to update suggestion buttons (returns list of updates for each button + the container)
         def update_suggestions(suggestions):
             if not suggestions:
-                return [gr.update(visible=False)] * 6 + [gr.update(visible=False)]
-            
+                updates = [gr.update(visible=False, value="")] * len(suggestion_buttons)
+                updates.append(gr.update(visible=False))  # hide container
+                return updates
             updates = []
             for i, btn in enumerate(suggestion_buttons):
                 if i < len(suggestions):
                     updates.append(gr.update(visible=True, value=suggestions[i]))
                 else:
-                    updates.append(gr.update(visible=False))
-            updates.append(gr.update(visible=True))
+                    updates.append(gr.update(visible=False, value=""))
+            updates.append(gr.update(visible=True))  # show container
             return updates
         
+        # Wire analyze button
         analyze_btn.click(
             fn=process_image,
             inputs=[image_input],
             outputs=[analysis_state, analysis_display, gr.State(), suggestion_btns_row]
         ).then(
-            fn=lambda x: system.generate_suggested_questions(x) if x else [],
+            # generate suggestions based on analysis_state
+            fn=lambda analysis: system.generate_suggested_questions(analysis) if analysis and isinstance(analysis, dict) and 'error' not in analysis else [],
             inputs=[analysis_state],
             outputs=[gr.State()]
         ).then(
@@ -617,14 +712,15 @@ def create_advanced_interface():
             outputs=suggestion_buttons + [suggestion_btns_row]
         )
         
-        # Connect suggestion buttons
+        # Connect suggestion buttons (each click calls handle_suggestion_click)
         for btn in suggestion_buttons:
             btn.click(
-                fn=lambda b, h, l, a: handle_suggestion_click(b, h, l, a),
+                fn=handle_suggestion_click,
                 inputs=[btn, chatbot, language_selector, analysis_state],
                 outputs=[chatbot, msg_input]
             )
         
+        # Sending messages
         msg_input.submit(
             fn=send_message,
             inputs=[msg_input, chatbot, language_selector, analysis_state],
@@ -664,7 +760,7 @@ if __name__ == "__main__":
         print("⚠️  GOOGLE_API_KEY not found - Image analysis disabled")
         print("Get free key: https://aistudio.google.com/app/apikey\n")
     else:
-        print("✅ Gemini 1.5 Pro enabled\n")
+        print("✅ Gemini enabled\n")
     
     if not groq_key:
         print("⚠️  GROQ_API_KEY not found - Chat disabled")
@@ -677,11 +773,10 @@ if __name__ == "__main__":
     print("🚀 Launching AgriBot Pro...\n")
     print("="*70 + "\n")
     
-    # For Hugging Face Spaces
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
         show_error=True,
-        ssr_mode=False  # Disable SSR for stability
-    )
+        ssr_mode=False
+    )