Implement enhanced debug panel with toggle controls and detailed status tracking

app.py

@@ -10,31 +10,29 @@ from utils.config import config
 from core.llm import send_to_ollama, send_to_hf
 from core.session import session_manager
 from core.memory import check_redis_health
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 st.set_page_config(page_title="AI Life Coach", page_icon="🧠", layout="wide")
 
 # Initialize session state
 if "messages" not in st.session_state:
     st.session_state.messages = []
-
 if "last_error" not in st.session_state:
     st.session_state.last_error = ""
-
 if "last_ollama_call_success" not in st.session_state:
     st.session_state.last_ollama_call_success = None
-
 if "last_ollama_call_time" not in st.session_state:
     st.session_state.last_ollama_call_time = ""
-
 if "last_ollama_response_preview" not in st.session_state:
     st.session_state.last_ollama_response_preview = ""
-
 if "last_hf_call_success" not in st.session_state:
     st.session_state.last_hf_call_success = None
-
 if "last_hf_call_time" not in st.session_state:
     st.session_state.last_hf_call_time = ""
-
 if "last_hf_response_preview" not in st.session_state:
     st.session_state.last_hf_response_preview = ""
 
@@ -42,7 +40,7 @@ if "last_hf_response_preview" not in st.session_state:
 with st.sidebar:
     st.title("AI Life Coach")
     st.markdown("Your personal AI-powered life development assistant")
-
+    
     # Model selection
     model_options = {
         "Mistral 7B (Local)": "mistral:latest",
@@ -55,54 +53,153 @@ with st.sidebar:
         index=0
     )
     st.session_state.selected_model = model_options[selected_model_name]
-
+    
     # Ollama URL input
     st.session_state.ngrok_url = st.text_input(
         "Ollama Server URL",
         value=st.session_state.get("ngrok_url", "http://localhost:11434"),
         help="Enter the URL to your Ollama server"
     )
-
+    
     # Conversation history
     st.subheader("Conversation History")
     if st.button("Clear History"):
         st.session_state.messages = []
         st.success("History cleared!")
-
-    # Debug info
-    with st.sidebar.expander("🔧 Debug Info"):
-        st.write(f"**OLLAMA_HOST**: {st.session_state.ngrok_url}")
-        st.write(f"**Selected Model**: {st.session_state.selected_model}")
-        st.write(f"Fallback Mode: {'✅ On' if config.use_fallback else '❌ Off'}")
-        st.write(f"Redis Status: {'✅ Healthy' if check_redis_health() else '⚠️ Unavailable'}")
-        st.write(f"Env Detected As: {'☁️ HF Space' if config.is_hf_space else '🏠 Local'}")
-        st.write(f"HF Token Set: {'✅ Yes' if config.hf_token else '❌ No'}")
-        
-        if st.session_state.last_error:
-            st.warning(f"Last Error: {st.session_state.last_error}")
-
-    # Ollama API Call Tracking
-    if st.session_state.last_ollama_call_success is not None:
-        status_icon = "✅ Success" if st.session_state.last_ollama_call_success else "❌ Failed"
-        st.write(f"Last Ollama Call: {status_icon}")
-        st.write(f"At: {st.session_state.last_ollama_call_time}")
-        if st.session_state.last_ollama_response_preview:
-            st.code(st.session_state.last_ollama_response_preview[:200] + ("..." if len(st.session_state.last_ollama_response_preview) > 200 else ""), language="text")
-
-    # Hugging Face API Call Tracking
-    if st.session_state.last_hf_call_success is not None:
-        status_icon = "✅ Success" if st.session_state.last_hf_call_success else "❌ Failed"
-        st.write(f"Last HF Call: {status_icon}")
-        st.write(f"At: {st.session_state.last_hf_call_time}")
-        if st.session_state.last_hf_response_preview:
-            st.code(st.session_state.last_hf_response_preview[:200] + ("..." if len(st.session_state.last_hf_response_preview) > 200 else ""), language="text")
-
-    # Manual Refresh Button
-    if st.button("🔄 Refresh Ollama Status"):
-        from services.ollama_monitor import check_ollama_status
-        status = check_ollama_status()
-        # Fix Streamlit toast issue - replace with compatible function
-        st.sidebar.info(f"Ollama Status: {'Running' if status['running'] else 'Unavailable'}")
+    
+    # Enhanced Debug Panel
+    with st.expander("🔍 Advanced Debug", expanded=False):
+        st.subheader("System Controls")
+        
+        # Fallback Mode Toggle
+        fallback_mode = st.checkbox(
+            "Enable Fallback Mode",
+            value=config.use_fallback,
+            help="Enable automatic fallback between providers"
+        )
+        
+        # HF Endpoint Control
+        hf_enabled = st.checkbox(
+            "Enable HF Deep Analysis",
+            value=bool(config.hf_token),
+            help="Enable Hugging Face endpoint coordination"
+        )
+        
+        # Web Search Toggle
+        web_search_enabled = st.checkbox(
+            "Enable Web Search",
+            value=bool(os.getenv("TAVILY_API_KEY")),
+            help="Enable Tavily/DDG web search integration"
+        )
+        
+        st.subheader("Provider Status")
+        
+        # Ollama Status
+        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')})")
+            else:
+                st.error("🦙 Ollama: Unavailable")
+        except Exception as e:
+            st.warning(f"🦙 Ollama: Status check failed")
+        
+        # HF Endpoint Status
+        try:
+            from services.hf_endpoint_monitor import hf_monitor
+            hf_status = hf_monitor.get_status_summary()
+            if "🟢" in hf_status:
+                st.success(f"🤗 HF Endpoint: {hf_status.replace('🟢 ', '')}")
+            elif "🟡" in hf_status:
+                st.warning(f"🤗 HF Endpoint: {hf_status.replace('🟡 ', '')}")
+            else:
+                st.error(f"🤗 HF Endpoint: {hf_status.replace('🔴 ', '')}")
+        except Exception as e:
+            st.warning("🤗 HF Endpoint: Status check failed")
+        
+        # Redis Status
+        redis_healthy = check_redis_health()
+        if redis_healthy:
+            st.success("💾 Redis: Connected")
+        else:
+            st.error("💾 Redis: Disconnected")
+        
+        st.subheader("External Services")
+        
+        # Web Search Status
+        if os.getenv("TAVILY_API_KEY"):
+            st.success("🔍 Web Search: Tavily API Active")
+        else:
+            st.info("🔍 Web Search: Not configured")
+        
+        # Weather Service
+        if config.openweather_api_key:
+            st.success("🌤️ Weather: API Active")
+        else:
+            st.info("🌤️ Weather: Not configured")
+        
+        # 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}")
+        
+        # Enhanced Configuration Display
+        st.subheader("Configuration Details")
+        
+        # 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}")
+        
+        # Environment Detection
+        env_type = "☁️ HF Space" if config.is_hf_space else "🏠 Local"
+        st.caption(f"**Environment**: {env_type}")
+        
+        # Feature Flags
+        features = []
+        if config.use_fallback:
+            features.append("Fallback Mode")
+        if os.getenv("TAVILY_API_KEY"):
+            features.append("Web Search")
+        if config.openweather_api_key:
+            features.append("Weather Data")
+        if config.hf_token:
+            features.append("Deep Analysis")
+        
+        if features:
+            st.caption(f"**Active Features**: {', '.join(features)}")
+        else:
+            st.caption("**Active Features**: None")
 
 # Main chat interface
 st.title("🧠 AI Life Coach")
@@ -129,32 +226,31 @@ if send_button and user_input.strip():
     # Display user message
     with st.chat_message("user"):
         st.markdown(user_input)
-
+    
     # Add user message to history
     st.session_state.messages.append({"role": "user", "content": user_input})
-
+    
     # Reset error state
     st.session_state.last_error = ""
-
+    
     # Get conversation history
     user_session = session_manager.get_session("default_user")
     conversation = user_session.get("conversation", [])
     conversation_history = conversation[-5:]  # Last 5 messages
     conversation_history.append({"role": "user", "content": user_input})
-
+    
     # Send to backend
     with st.chat_message("assistant"):
         with st.spinner("AI Coach is thinking..."):
             ai_response = None
             backend_used = ""
             error_msg = ""
-
+            
             # Try Ollama first if not falling back
             if not config.use_fallback:
                 try:
                     ai_response = send_to_ollama(
-                        user_input, conversation_history,
-                        st.session_state.ngrok_url, st.session_state.selected_model
+                        user_input, conversation_history, st.session_state.ngrok_url, st.session_state.selected_model
                     )
                     backend_used = "Ollama"
                     # Capture success metadata
@@ -167,7 +263,7 @@ if send_button and user_input.strip():
                     st.session_state.last_ollama_call_success = False
                     st.session_state.last_ollama_call_time = str(datetime.utcnow())
                     st.session_state.last_ollama_response_preview = str(e)[:200]
-
+            
             # Fallback to Hugging Face if not ai_response and config.hf_token
             if not ai_response and config.hf_token:
                 try:
@@ -183,7 +279,7 @@ if send_button and user_input.strip():
                     st.session_state.last_hf_call_success = False
                     st.session_state.last_hf_call_time = str(datetime.utcnow())
                     st.session_state.last_hf_response_preview = str(e)[:200]
-
+            
             if ai_response:
                 st.markdown(f"{ai_response}")
                 # Update conversation history
@@ -197,6 +293,6 @@ if send_button and user_input.strip():
             else:
                 st.error("Failed to get response from both providers.")
                 st.session_state.last_error = error_msg or "No response from either provider"
-
+    
     # Clear input by forcing rerun
     st.experimental_rerun()

core/coordinator.py

@@ -181,6 +181,33 @@ class AICoordinator:
             logger.error(f"HF response failed: {e}")
             return None
 
+    def get_coordination_status(self) -> Dict:
+        """Get current coordination system status"""
+        return {
+            'tavily_available': self.tavily_client is not None,
+            'weather_available': weather_service.api_key is not None,
+            'web_search_enabled': self.tavily_client is not None,
+            'external_apis_configured': any([
+                weather_service.api_key,
+                os.getenv("TAVILY_API_KEY"),
+                os.getenv("NASA_API_KEY")
+            ])
+        }
+
+    def get_recent_activities(self, user_id: str) -> Dict:
+        """Get recent coordination activities for user"""
+        try:
+            session = session_manager.get_session(user_id)
+            coord_stats = session.get('ai_coordination', {})
+            return {
+                'last_request': coord_stats.get('last_coordination'),
+                'requests_processed': coord_stats.get('requests_processed', 0),
+                'ollama_responses': coord_stats.get('ollama_responses', 0),
+                'hf_responses': coord_stats.get('hf_responses', 0)
+            }
+        except:
+            return {}
+
     def _enhance_query_with_data(self, query: str, data: Dict) -> str:
         """Enhance query with gathered external data"""
         if not data:

debug_dashboard_test.py

@@ -0,0 +1,86 @@
+import sys
+from pathlib import Path
+
+# Add project root to path
+project_root = Path(__file__).parent
+sys.path.append(str(project_root))
+
+from services.hf_endpoint_monitor import hf_monitor
+from core.coordinator import coordinator
+from utils.config import config
+import os
+
+def test_debug_features():
+    """Test the enhanced debug features"""
+    print("=== Debug Dashboard Feature Test ===")
+    print()
+    
+    # Test HF Endpoint Monitor Enhanced Features
+    print("1. Testing HF Endpoint Monitor Enhanced Features:")
+    try:
+        # Basic status
+        basic_status = hf_monitor.get_status_summary()
+        print(f"   Basic Status: {basic_status}")
+        
+        # Detailed status
+        detailed_status = hf_monitor.get_detailed_status()
+        print(f"   Detailed Status Keys: {list(detailed_status.keys())}")
+        
+        # Performance metrics
+        perf_metrics = hf_monitor.get_performance_metrics()
+        print(f"   Performance Metrics: {perf_metrics}")
+        
+        print("   ✅ HF Endpoint Monitor Enhanced Features Working")
+    except Exception as e:
+        print(f"   ❌ HF Endpoint Monitor Test Failed: {e}")
+    
+    print()
+    
+    # Test Coordinator Status Tracking
+    print("2. Testing Coordinator Status Tracking:")
+    try:
+        # Coordination status
+        coord_status = coordinator.get_coordination_status()
+        print(f"   Coordination Status: {coord_status}")
+        
+        # Recent activities (test with demo user)
+        recent_activities = coordinator.get_recent_activities("demo_user")
+        print(f"   Recent Activities Keys: {list(recent_activities.keys())}")
+        
+        print("   ✅ Coordinator Status Tracking Working")
+    except Exception as e:
+        print(f"   ❌ Coordinator Status Tracking Test Failed: {e}")
+    
+    print()
+    
+    # Test Configuration Display
+    print("3. Testing Configuration Display:")
+    try:
+        print(f"   Environment Type: {'HF Space' if config.is_hf_space else 'Local'}")
+        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)}")
+        
+        # Feature flags
+        features = []
+        if config.use_fallback:
+            features.append("Fallback Mode")
+        if os.getenv("TAVILY_API_KEY"):
+            features.append("Web Search")
+        if config.openweather_api_key:
+            features.append("Weather Data")
+        if config.hf_token:
+            features.append("Deep Analysis")
+        
+        print(f"   Active Features: {', '.join(features) if features else 'None'}")
+        
+        print("   ✅ Configuration Display Working")
+    except Exception as e:
+        print(f"   ❌ Configuration Display Test Failed: {e}")
+    
+    print()
+    print("🎉 Debug Dashboard Feature Test Completed!")
+
+if __name__ == "__main__":
+    test_debug_features()

services/hf_endpoint_monitor.py

@@ -15,6 +15,10 @@ class HFEndpointMonitor:
         self.is_initialized = False
         self.last_check = 0
         self.check_interval = 60  # Check every minute
+        self.warmup_count = 0
+        self.successful_requests = 0
+        self.failed_requests = 0
+        self.avg_response_time = 0
 
     def check_endpoint_status(self) -> Dict:
         """Check if HF endpoint is available and initialized"""
@@ -49,6 +53,61 @@ class HFEndpointMonitor:
                 'timestamp': time.time()
             }
 
+    def get_detailed_status(self) -> Dict:
+        """Get detailed HF endpoint status with metrics"""
+        try:
+            headers = {"Authorization": f"Bearer {self.hf_token}"}
+            
+            # Get model info
+            model_response = requests.get(
+                f"{self.endpoint_url}/models",
+                headers=headers,
+                timeout=10
+            )
+            
+            # Get endpoint info if available
+            endpoint_info = {}
+            try:
+                info_response = requests.get(
+                    f"{self.endpoint_url}/info",
+                    headers=headers,
+                    timeout=10
+                )
+                if info_response.status_code == 200:
+                    endpoint_info = info_response.json()
+            except:
+                pass
+            
+            status_info = {
+                'available': model_response.status_code == 200,
+                'status_code': model_response.status_code,
+                'initialized': self._is_endpoint_initialized(model_response),
+                'endpoint_info': endpoint_info,
+                'last_checked': time.time(),
+                'warmup_attempts': getattr(self, 'warmup_attempts', 0),
+                'is_warming_up': getattr(self, 'is_warming_up', False)
+            }
+            
+            return status_info
+            
+        except Exception as e:
+            return {
+                'available': False,
+                'status_code': None,
+                'initialized': False,
+                'error': str(e),
+                'last_checked': time.time()
+            }
+
+    def get_performance_metrics(self) -> Dict:
+        """Get HF endpoint performance metrics"""
+        return {
+            'warmup_count': getattr(self, 'warmup_count', 0),
+            'successful_requests': getattr(self, 'successful_requests', 0),
+            'failed_requests': getattr(self, 'failed_requests', 0),
+            'average_response_time': getattr(self, 'avg_response_time', 0)
+        }
+
     def _is_endpoint_initialized(self, response) -> bool:
         """Determine if endpoint is fully initialized"""
         # If we get a model list, it's likely initialized
@@ -84,6 +143,7 @@ class HFEndpointMonitor:
             success = response.status_code in [200, 201]
             if success:
                 self.is_initialized = True
+                self.warmup_count += 1
                 logger.info("✅ HF endpoint warmed up successfully")
             else:
                 logger.warning(f"⚠️ HF endpoint warm-up response: {response.status_code}")
@@ -92,6 +152,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: