Implement enhanced debug panel with comprehensive system monitoring and controls

app.py

@@ -68,72 +68,83 @@ with st.sidebar:
         st.success("History cleared!")
     
     # Enhanced Debug Panel
-    with st.expander("🔍 Advanced Debug", expanded=False):
-        st.subheader("System Controls")
+    with st.sidebar.expander("🔍 Advanced System Monitor", expanded=False):
+        st.subheader("🎛️ System Controls")
         
         # Fallback Mode Toggle
         fallback_mode = st.checkbox(
-            "Enable Fallback Mode",
+            "Enable Provider Fallback",
             value=config.use_fallback,
-            help="Enable automatic fallback between providers"
+            help="Enable automatic fallback between AI providers"
         )
         
-        # HF Endpoint Control
-        hf_enabled = st.checkbox(
+        # HF Deep Analysis Toggle
+        hf_analysis = st.checkbox(
             "Enable HF Deep Analysis",
             value=bool(config.hf_token),
-            help="Enable Hugging Face endpoint coordination"
+            help="Enable Hugging Face endpoint for deep analysis"
         )
         
         # Web Search Toggle
-        web_search_enabled = st.checkbox(
-            "Enable Web Search",
+        web_search = st.checkbox(
+            "Enable Web Research",
             value=bool(os.getenv("TAVILY_API_KEY")),
             help="Enable Tavily/DDG web search integration"
         )
         
-        st.subheader("Provider Status")
+        st.divider()
         
-        # Ollama Status
+        st.subheader("📊 Provider Status")
+        
+        # Ollama Status with Detailed Info
         try:
             from services.ollama_monitor import check_ollama_status
             ollama_status = check_ollama_status()
             if ollama_status.get("running"):
-                st.success(f"🦙 Ollama: Running ({ollama_status.get('model_loaded', 'Unknown')})")
+                st.success(f"🦙 Ollama: Running")
+                if ollama_status.get("model_loaded"):
+                    st.caption(f"Model: {ollama_status['model_loaded']}")
+                st.caption(f"URL: {ollama_status.get('ngrok_url', 'N/A')}")
             else:
                 st.error("🦙 Ollama: Unavailable")
+                if st.button("🔄 Refresh Ollama Status", key="refresh_ollama"):
+                    st.experimental_rerun()
         except Exception as e:
             st.warning(f"🦙 Ollama: Status check failed")
         
-        # Enhanced HF Status Display
-        st.subheader("HF Endpoint Status")
+        # HF Endpoint Status with Scale-to-Zero Handling
         try:
             from services.hf_endpoint_monitor import hf_monitor
+            hf_status_detail = hf_monitor.check_endpoint_status()
             
-            # Show current status
-            status_summary = hf_monitor.get_status_summary()
-            if "🟢" in status_summary:
-                st.success(status_summary)
-            elif "🟡" in status_summary:
-                st.warning(status_summary)
-                if st.button("⚡ Wake Up HF Endpoint"):
-                    with st.spinner("Waking up HF endpoint... (this may take 2-4 minutes)"):
-                        success = hf_monitor.handle_scale_to_zero()
-                        if success:
-                            st.success("✅ HF endpoint is now awake!")
-                        else:
-                            st.error("❌ Failed to wake up HF endpoint. Please try again.")
+            if hf_status_detail['available']:
+                if hf_status_detail.get('initialized', False):
+                    st.success("🤗 HF Endpoint: Available & Initialized")
+                else:
+                    st.warning("🤗 HF Endpoint: Available (Initializing)")
             else:
-                st.error(status_summary)
-                if st.button("🚀 Initialize HF Endpoint"):
-                    with st.spinner("Initializing HF endpoint... (this may take 2-4 minutes)"):
+                st.error("🤗 HF Endpoint: Scaled to Zero")
+            
+            # Show detailed status
+            st.caption(f"Status Code: {hf_status_detail.get('status_code', 'N/A')}")
+            if 'response_time' in hf_status_detail:
+                st.caption(f"Response Time: {hf_status_detail['response_time']:.2f}s")
+            
+            # Wake-up button for scaled-to-zero endpoints
+            if not hf_status_detail['available'] and config.hf_token:
+                if st.button("⚡ Wake Up HF Endpoint", key="wake_hf"):
+                    with st.spinner("Waking up HF endpoint... (2-4 minutes)"):
                         success = hf_monitor.handle_scale_to_zero()
                         if success:
-                            st.success("✅ HF endpoint initialized successfully!")
+                            st.success("✅ HF endpoint activated!")
+                            time.sleep(2)
+                            st.experimental_rerun()
                         else:
-                            st.error("❌ Failed to initialize HF endpoint.")
+                            st.error("❌ Failed to activate HF endpoint")
+        
         except Exception as e:
-            st.error(f"❌ HF Monitor Error: {str(e)}")
+            st.warning(f"🤗 HF Endpoint: Monitor unavailable")
+            st.caption(f"Error: {str(e)[:50]}...")
         
         # Redis Status
         redis_healthy = check_redis_health()
@@ -142,76 +153,82 @@ with st.sidebar:
         else:
             st.error("💾 Redis: Disconnected")
         
-        st.subheader("External Services")
+        st.divider()
+        
+        st.subheader("🌐 External Services")
         
         # Web Search Status
-        if os.getenv("TAVILY_API_KEY"):
+        tavily_key = os.getenv("TAVILY_API_KEY")
+        if tavily_key:
             st.success("🔍 Web Search: Tavily API Active")
+            # Test search button
+            if st.button("🧪 Test Web Search", key="test_web_search"):
+                try:
+                    from tavily import TavilyClient
+                    tavily = TavilyClient(api_key=tavily_key)
+                    with st.spinner("Testing web search..."):
+                        test_result = tavily.search("AI life coach benefits", max_results=1)
+                        st.success("✅ Web search working!")
+                except Exception as e:
+                    st.error(f"❌ Web search test failed: {str(e)[:30]}...")
         else:
             st.info("🔍 Web Search: Not configured")
         
         # Weather Service
         if config.openweather_api_key:
             st.success("🌤️ Weather: API Active")
+            if st.button("🌡️ Test Weather", key="test_weather"):
+                try:
+                    from services.weather import weather_service
+                    with st.spinner("Testing weather service..."):
+                        test_weather = weather_service.get_current_weather("New York")
+                        if test_weather:
+                            st.success(f"✅ Weather working! {test_weather['temperature']}°C in New York")
+                        else:
+                            st.warning("⚠️ Weather service returned no data")
+                except Exception as e:
+                    st.error(f"❌ Weather test failed: {str(e)[:30]}...")
         else:
             st.info("🌤️ Weather: Not configured")
         
+        st.divider()
+        
+        st.subheader("📈 Session Statistics")
+        
         # Session Stats
         try:
             user_session = session_manager.get_session("default_user")
-            conversation_length = len(user_session.get("conversation", []))
-            st.info(f"💬 Conversation Length: {conversation_length} messages")
-        except:
-            st.info("💬 Session: Not initialized")
-        
-        # Real-time Web Search Status
-        st.subheader("Web Search Activity")
-        
-        # Recent searches (if tracking enabled)
-        if 'recent_searches' in st.session_state:
-            for search in st.session_state.recent_searches[-3:]:  # Last 3 searches
-                st.caption(f"🔍 {search['query'][:30]}... ({search['timestamp']})")
-        else:
-            st.info("No recent searches")
-        
-        # Search test button
-        if st.button("🧪 Test Web Search"):
-            try:
-                from tavily import TavilyClient
-                if os.getenv("TAVILY_API_KEY"):
-                    tavily = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
-                    test_result = tavily.search("AI life coach benefits", max_results=1)
-                    st.success("✅ Web search working")
-                    if test_result.get('results'):
-                        st.caption(f"Sample: {test_result['results'][0].get('title', 'No title')}")
-                else:
-                    st.warning("Web API key not configured")
-            except Exception as e:
-                st.error(f"❌ Web search test failed: {e}")
+            conversation = user_session.get("conversation", [])
+            st.caption(f"💬 Messages: {len(conversation)}")
+            
+            # AI Coordination Stats (if available)
+            coord_stats = user_session.get('ai_coordination', {})
+            if coord_stats:
+                st.caption(f"🤖 AI Requests: {coord_stats.get('requests_processed', 0)}")
+                st.caption(f"🦙 Ollama Responses: {coord_stats.get('ollama_responses', 0)}")
+                st.caption(f"🤗 HF Responses: {coord_stats.get('hf_responses', 0)}")
+            else:
+                st.caption("🤖 AI Coordination: Not active")
         
-        # Enhanced Configuration Display
-        st.subheader("Configuration Details")
+        except Exception as e:
+            st.caption("💬 Session: Not initialized")
         
-        # Provider Configuration
-        st.caption(f"**Primary Provider**: Ollama ({config.local_model_name})")
-        if config.hf_token:
-            st.caption(f"**Secondary Provider**: Hugging Face")
-            st.caption(f"**HF Endpoint**: {config.hf_api_url}")
+        st.divider()
         
-        # Environment Detection
-        env_type = "☁️ HF Space" if config.is_hf_space else "🏠 Local"
-        st.caption(f"**Environment**: {env_type}")
+        st.subheader("⚙️ Configuration")
+        st.caption(f"**Environment**: {'☁️ HF Space' if config.is_hf_space else '🏠 Local'}")
+        st.caption(f"**Primary Model**: {config.local_model_name or 'Not set'}")
         
-        # Feature Flags
+        # Feature Flags Summary
         features = []
-        if config.use_fallback:
-            features.append("Fallback Mode")
-        if os.getenv("TAVILY_API_KEY"):
+        if fallback_mode:
+            features.append("Fallback")
+        if hf_analysis and config.hf_token:
+            features.append("HF Deep Analysis")
+        if web_search and tavily_key:
             features.append("Web Search")
         if config.openweather_api_key:
-            features.append("Weather Data")
-        if config.hf_token:
-            features.append("Deep Analysis")
+            features.append("Weather")
         
         if features:
             st.caption(f"**Active Features**: {', '.join(features)}")

services/hf_endpoint_monitor.py

@@ -19,6 +19,10 @@ class HFEndpointMonitor:
         self.check_interval = 60  # Check every minute
         self.warmup_attempts = 0
         self.max_warmup_attempts = 3
+        self.warmup_count = 0
+        self.successful_requests = 0
+        self.failed_requests = 0
+        self.avg_response_time = 0
         
         logger.info(f"Initialized HF Monitor with URL: {self.endpoint_url}")
 
@@ -140,6 +144,7 @@ class HFEndpointMonitor:
             success = response.status_code in [200, 201]
             if success:
                 self.is_initialized = True
+                self.warmup_count += 1
                 self.warmup_attempts = 0  # Reset on success
                 logger.info("✅ HF endpoint warmed up successfully")
             else:
@@ -150,6 +155,7 @@ class HFEndpointMonitor:
             
         except Exception as e:
             logger.error(f"HF endpoint warm-up failed: {e}")
+            self.failed_requests += 1
             return False
 
     def get_status_summary(self) -> str:

test_enhanced_debug.py

@@ -0,0 +1,93 @@
+import sys
+from pathlib import Path
+
+# Add project root to path
+project_root = Path(__file__).parent
+sys.path.append(str(project_root))
+
+from utils.config import config
+from core.session import session_manager
+import os
+
+def test_enhanced_debug_features():
+    """Test the enhanced debug panel features"""
+    print("=== Enhanced Debug Panel Feature Test ===")
+    print()
+    
+    # Test System Controls Configuration
+    print("1. Testing System Controls Configuration:")
+    print(f"   Fallback Mode: {config.use_fallback}")
+    print(f"   HF Token Available: {bool(config.hf_token)}")
+    print(f"   Tavily API Key: {bool(os.getenv('TAVILY_API_KEY'))}")
+    print(f"   OpenWeather API Key: {bool(config.openweather_api_key)}")
+    print()
+    
+    # Test Provider Status
+    print("2. Testing Provider Status:")
+    try:
+        from services.ollama_monitor import check_ollama_status
+        ollama_status = check_ollama_status()
+        print(f"   Ollama Running: {ollama_status.get('running', 'Unknown')}")
+        print(f"   Ollama Model: {ollama_status.get('model_loaded', 'Unknown')}")
+    except Exception as e:
+        print(f"   Ollama Status Check Failed: {e}")
+    
+    try:
+        from services.hf_endpoint_monitor import hf_monitor
+        hf_status = hf_monitor.check_endpoint_status()
+        print(f"   HF Available: {hf_status.get('available', 'Unknown')}")
+        print(f"   HF Initialized: {hf_status.get('initialized', 'Unknown')}")
+        print(f"   HF Status Code: {hf_status.get('status_code', 'Unknown')}")
+    except Exception as e:
+        print(f"   HF Status Check Failed: {e}")
+    
+    print()
+    
+    # Test External Services
+    print("3. Testing External Services:")
+    print(f"   Tavily API: {'✅ Configured' if os.getenv('TAVILY_API_KEY') else '❌ Not configured'}")
+    print(f"   Weather API: {'✅ Configured' if config.openweather_api_key else '❌ Not configured'}")
+    print()
+    
+    # Test Session Statistics
+    print("4. Testing Session Statistics:")
+    try:
+        user_session = session_manager.get_session("default_user")
+        conversation = user_session.get("conversation", [])
+        print(f"   Conversation Length: {len(conversation)} messages")
+        
+        coord_stats = user_session.get('ai_coordination', {})
+        if coord_stats:
+            print(f"   AI Requests: {coord_stats.get('requests_processed', 0)}")
+            print(f"   Ollama Responses: {coord_stats.get('ollama_responses', 0)}")
+            print(f"   HF Responses: {coord_stats.get('hf_responses', 0)}")
+        else:
+            print("   AI Coordination: Not active")
+    except Exception as e:
+        print(f"   Session Stats Failed: {e}")
+    
+    print()
+    
+    # Test Configuration Summary
+    print("5. Testing Configuration Summary:")
+    print(f"   Environment: {'HF Space' if config.is_hf_space else 'Local'}")
+    print(f"   Primary Model: {config.local_model_name or 'Not set'}")
+    
+    # Feature Flags Summary
+    features = []
+    if config.use_fallback:
+        features.append("Fallback")
+    if config.hf_token:
+        features.append("HF Deep Analysis")
+    if os.getenv("TAVILY_API_KEY"):
+        features.append("Web Search")
+    if config.openweather_api_key:
+        features.append("Weather")
+    
+    print(f"   Active Features: {', '.join(features) if features else 'None'}")
+    
+    print()
+    print("🎉 Enhanced Debug Panel Feature Test Completed!")
+
+if __name__ == "__main__":
+    test_enhanced_debug_features()