self healing/weather update

src/llm/enhanced_provider.py

@@ -1,32 +1,41 @@
 import json
 from typing import List, Dict, Optional, Union
 from src.llm.base_provider import LLMProvider
-from src.services.context_enrichment import context_service
+from src.services.context_provider import context_provider
 
 class EnhancedLLMProvider(LLMProvider):
-    """Base provider with context enrichment"""
+    """Base provider with intelligent context enrichment"""
     
     def __init__(self, model_name: str, timeout: int = 30, max_retries: int = 3):
         super().__init__(model_name, timeout, max_retries)
         
-    def _enrich_context(self, conversation_history: List[Dict]) -> List[Dict]:
-        """Add current context to conversation"""
+    def _enrich_context_intelligently(self, conversation_history: List[Dict]) -> List[Dict]:
+        """Add context only when it's actually relevant"""
+        if not conversation_history:
+            return conversation_history
+        
         # Get the last user message to determine context needs
         last_user_message = ""
         for msg in reversed(conversation_history):
             if msg["role"] == "user":
                 last_user_message = msg["content"]
                 break
-                
-        # Get current context
-        context = context_service.get_current_context(last_user_message)
         
-        # Add context as system message at the beginning
-        context_message = {
-            "role": "system",
-            "content": f"[Current Context: {context['current_time']} | Weather: {context['weather']}]"
-        }
+        # Get intelligent context
+        context_string = context_provider.get_context_for_llm(
+            last_user_message, 
+            conversation_history
+        )
+        
+        # Only add context if it's relevant
+        if context_string:
+            context_message = {
+                "role": "system",
+                "content": context_string
+            }
+            # Insert context at the beginning
+            enriched_history = [context_message] + conversation_history
+            return enriched_history
         
-        # Insert context at the beginning
-        enriched_history = [context_message] + conversation_history
-        return enriched_history
+        # Return original history if no context needed
+        return conversation_history

src/llm/hf_provider.py

@@ -3,8 +3,7 @@ import logging
 from typing import List, Dict, Optional, Union
 from src.llm.enhanced_provider import EnhancedLLMProvider
 from utils.config import config
-from src.services.context_enrichment import context_service
-
+from src.services.context_provider import context_provider
 logger = logging.getLogger(__name__)
 
 try:
@@ -36,8 +35,8 @@ class HuggingFaceProvider(EnhancedLLMProvider):
     def generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
         """Generate a response synchronously"""
         try:
-            # Enrich context
-            enriched_history = self._enrich_context(conversation_history)
+            # Intelligently enrich context
+            enriched_history = self._enrich_context_intelligently(conversation_history)
             
             response = self.client.chat.completions.create(
                 model=self.model_name,
@@ -53,7 +52,7 @@ class HuggingFaceProvider(EnhancedLLMProvider):
             if self._is_scale_to_zero_error(e):
                 logger.info("HF endpoint is scaling up, waiting...")
                 time.sleep(60)  # Wait for endpoint to initialize
-                # Retry once
+                # Retry once after waiting
                 response = self.client.chat.completions.create(
                     model=self.model_name,
                     messages=conversation_history,
@@ -67,8 +66,8 @@ class HuggingFaceProvider(EnhancedLLMProvider):
     def stream_generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[Union[str, List[str]]]:
         """Generate a response with streaming support"""
         try:
-            # Enrich context
-            enriched_history = self._enrich_context(conversation_history)
+            # Intelligently enrich context
+            enriched_history = self._enrich_context_intelligently(conversation_history)
             
             response = self.client.chat.completions.create(
                 model=self.model_name,
@@ -90,7 +89,7 @@ class HuggingFaceProvider(EnhancedLLMProvider):
             if self._is_scale_to_zero_error(e):
                 logger.info("HF endpoint is scaling up, waiting...")
                 time.sleep(60)  # Wait for endpoint to initialize
-                # Retry once
+                # Retry once after waiting
                 response = self.client.chat.completions.create(
                     model=self.model_name,
                     messages=conversation_history,
@@ -107,27 +106,36 @@ class HuggingFaceProvider(EnhancedLLMProvider):
                 return chunks
             raise
 
-    def _enrich_context(self, conversation_history: List[Dict]) -> List[Dict]:
-        """Add current context to conversation"""
+    def _enrich_context_intelligently(self, conversation_history: List[Dict]) -> List[Dict]:
+        """Intelligently add context only when relevant"""
+        if not conversation_history:
+            return conversation_history
+        
         # Get the last user message to determine context needs
         last_user_message = ""
         for msg in reversed(conversation_history):
             if msg["role"] == "user":
                 last_user_message = msg["content"]
                 break
-                
-        # Get current context
-        context = context_service.get_current_context(last_user_message)
         
-        # Add context as system message at the beginning
-        context_message = {
-            "role": "system",
-            "content": f"[Current Context: {context['current_time']} | Weather: {context['weather']}]"
-        }
+        # Get intelligent context
+        context_string = context_provider.get_context_for_llm(
+            last_user_message, 
+            conversation_history
+        )
+        
+        # Only add context if it's relevant
+        if context_string:
+            context_message = {
+                "role": "system",
+                "content": context_string
+            }
+            # Insert context at the beginning
+            enriched_history = [context_message] + conversation_history
+            return enriched_history
         
-        # Insert context at the beginning
-        enriched_history = [context_message] + conversation_history
-        return enriched_history
+        # Return original history if no context needed
+        return conversation_history
 
     def _is_scale_to_zero_error(self, error: Exception) -> bool:
         """Check if the error is related to scale-to-zero initialization"""
@@ -136,7 +144,6 @@ class HuggingFaceProvider(EnhancedLLMProvider):
             "503",
             "service unavailable",
             "initializing",
-            "cold start",
-            "timeout"
+            "cold start"
         ]
         return any(indicator in error_str for indicator in scale_to_zero_indicators)

src/llm/ollama_provider.py

@@ -1,17 +1,17 @@
 import requests
 import logging
 import re
-import time
 from typing import List, Dict, Optional, Union
 from src.llm.base_provider import LLMProvider
 from utils.config import config
+from src.services.context_provider import context_provider
 
 logger = logging.getLogger(__name__)
 
 class OllamaProvider(LLMProvider):
-    """Ollama LLM provider implementation with enhanced error handling"""
+    """Ollama LLM provider implementation"""
 
-    def __init__(self, model_name: str, timeout: int = 30, max_retries: int = 2):
+    def __init__(self, model_name: str, timeout: int = 60, max_retries: int = 3):
         super().__init__(model_name, timeout, max_retries)
         self.host = self._sanitize_host(config.ollama_host or "http://localhost:11434")
         self.headers = {
@@ -30,12 +30,12 @@ class OllamaProvider(LLMProvider):
         return host
 
     def generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
-        """Generate a response synchronously with better error handling"""
+        """Generate a response synchronously"""
         try:
             return self._retry_with_backoff(self._generate_impl, prompt, conversation_history)
         except Exception as e:
             logger.error(f"Ollama generation failed: {e}")
-            raise Exception(f"Ollama is not responding. Please check your connection or try the HF Endpoint.")
+            return None
 
     def stream_generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[Union[str, List[str]]]:
         """Generate a response with streaming support"""
@@ -43,16 +43,44 @@ class OllamaProvider(LLMProvider):
             return self._retry_with_backoff(self._stream_generate_impl, prompt, conversation_history)
         except Exception as e:
             logger.error(f"Ollama stream generation failed: {e}")
-            raise Exception(f"Ollama is not responding. Please check your connection or try the HF Endpoint.")
+            return None
+
+    def validate_model(self) -> bool:
+        """Validate if the model is available"""
+        try:
+            response = requests.get(
+                f"{self.host}/api/tags",
+                headers=self.headers,
+                timeout=self.timeout
+            )
+            if response.status_code == 200:
+                models = response.json().get("models", [])
+                model_names = [model.get("name") for model in models]
+                return self.model_name in model_names
+            elif response.status_code == 404:
+                # Try alternative endpoint
+                response2 = requests.get(
+                    f"{self.host}",
+                    headers=self.headers,
+                    timeout=self.timeout
+                )
+                return response2.status_code == 200
+            return False
+        except Exception as e:
+            logger.error(f"Model validation failed: {e}")
+            return False
 
     def _generate_impl(self, prompt: str, conversation_history: List[Dict]) -> str:
-        """Implementation of synchronous generation with enhanced debugging"""
+        """Implementation of synchronous generation with intelligent context"""
         try:
             url = f"{self.host}/api/chat"
             
+            # Intelligently enrich context
+            enriched_history = self._enrich_context_intelligently(conversation_history)
+            
             # Prepare messages - ensure proper format
             messages = []
-            for msg in conversation_history:
+            for msg in enriched_history:
                 if isinstance(msg, dict) and "role" in msg and "content" in msg:
                     messages.append({
                         "role": msg["role"],
@@ -69,14 +97,12 @@ class OllamaProvider(LLMProvider):
             logger.info(f"Ollama request payload: {payload}")
             logger.info(f"Ollama headers: {self.headers}")
 
-            # Use shorter timeout for better UX
             response = requests.post(
                 url,
                 json=payload,
                 headers=self.headers,
-                timeout=30  # Reduced from 60 to 30 seconds
+                timeout=self.timeout
             )
-            
             logger.info(f"Ollama response status: {response.status_code}")
             logger.info(f"Ollama response headers: {dict(response.headers)}")
 
@@ -106,15 +132,13 @@ class OllamaProvider(LLMProvider):
     def _stream_generate_impl(self, prompt: str, conversation_history: List[Dict]) -> List[str]:
         """Implementation of streaming generation"""
         try:
+            # Intelligently enrich context
+            enriched_history = self._enrich_context_intelligently(conversation_history)
+            
             url = f"{self.host}/api/chat"
-            messages = conversation_history.copy()
-            # Add the current prompt if not already in history
-            if not messages or messages[-1].get("content") != prompt:
-                messages.append({"role": "user", "content": prompt})
-                
             payload = {
                 "model": self.model_name,
-                "messages": messages,
+                "messages": enriched_history,
                 "stream": True
             }
             
@@ -142,3 +166,34 @@ class OllamaProvider(LLMProvider):
         except Exception as e:
             logger.error(f"Ollama stream generation failed: {e}")
             raise
+
+    def _enrich_context_intelligently(self, conversation_history: List[Dict]) -> List[Dict]:
+        """Intelligently add context only when relevant"""
+        if not conversation_history:
+            return conversation_history
+        
+        # Get the last user message to determine context needs
+        last_user_message = ""
+        for msg in reversed(conversation_history):
+            if msg["role"] == "user":
+                last_user_message = msg["content"]
+                break
+        
+        # Get intelligent context
+        context_string = context_provider.get_context_for_llm(
+            last_user_message, 
+            conversation_history
+        )
+        
+        # Only add context if it's relevant
+        if context_string:
+            context_message = {
+                "role": "system",
+                "content": context_string
+            }
+            # Insert context at the beginning
+            enriched_history = [context_message] + conversation_history
+            return enriched_history
+        
+        # Return original history if no context needed
+        return conversation_history

src/services/context_provider.py

@@ -0,0 +1,61 @@
+import requests
+from typing import Dict, Any, Optional
+from utils.config import config
+from src.services.smart_context import smart_context
+
+class ContextProvider:
+    """Provides context data only when relevant"""
+    
+    def __init__(self):
+        self.openweather_api_key = getattr(config, 'openweather_api_key', None)
+    
+    def get_context_for_llm(self, user_query: str, 
+                          conversation_history: list = None) -> Optional[str]:
+        """Generate context string only when relevant for LLM consumption"""
+        # Get smart context detection
+        context_info = smart_context.get_relevant_context(user_query, conversation_history)
+        
+        context_parts = []
+        
+        # Add time context if relevant
+        if context_info['include_time'] and 'time_data' in context_info:
+            time_data = context_info['time_data']
+            context_parts.append(f"Current time: {time_data['current_time']}")
+        
+        # Add weather context if relevant
+        if context_info['include_weather']:
+            weather_data = self._get_weather_data(context_info['detected_location'] or 'New York')
+            if weather_data:
+                context_parts.append(weather_data)
+        
+        # Only return context if there's something relevant
+        if context_parts:
+            return f"[Context: {', '.join(context_parts)}]"
+        
+        return None  # No context needed
+    
+    def _get_weather_data(self, location: str) -> Optional[str]:
+        """Get weather data for a specific location"""
+        if not self.openweather_api_key:
+            return None
+            
+        try:
+            url = "http://api.openweathermap.org/data/2.5/weather"
+            params = {
+                'q': location,
+                'appid': self.openweather_api_key,
+                'units': 'metric'
+            }
+            
+            response = requests.get(url, params=params, timeout=5)
+            if response.status_code == 200:
+                data = response.json()
+                return (f"Weather in {data['name']}: {data['weather'][0]['description']}, "
+                       f"{data['main']['temp']}°C, humidity {data['main']['humidity']}%")
+        except Exception:
+            pass
+            
+        return None
+
+# Global instance
+context_provider = ContextProvider()

src/services/smart_context.py

@@ -0,0 +1,116 @@
+import time
+import re
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+from utils.config import config
+
+class SmartContextDetector:
+    """Intelligently detects when context is relevant to user queries"""
+    
+    def __init__(self):
+        # Keywords that suggest time/weather relevance
+        self.time_indicators = [
+            'time', 'date', 'today', 'now', 'current', 'moment', 
+            'morning', 'afternoon', 'evening', 'night', 'weekend',
+            'what time', 'what day', 'what year', 'what month'
+        ]
+        
+        self.weather_indicators = [
+            'weather', 'temperature', 'rain', 'snow', 'sunny', 'cloudy',
+            'forecast', 'climate', 'season', 'hot', 'cold', 'warm', 'cool',
+            'umbrella', 'jacket', 'outdoor', 'outside'
+        ]
+        
+        self.location_indicators = [
+            'in', 'at', 'near', 'around', 'local', 'here', 'there'
+        ]
+    
+    def should_include_time_context(self, user_query: str, 
+                                  conversation_history: List[Dict] = None) -> bool:
+        """Determine if time context is relevant to the query"""
+        query_lower = user_query.lower()
+        
+        # Direct time references
+        if any(indicator in query_lower for indicator in self.time_indicators):
+            return True
+        
+        # Check conversation context for time-related discussions
+        if conversation_history:
+            recent_messages = conversation_history[-3:]  # Last 3 messages
+            context_text = " ".join([msg.get('content', '') for msg in recent_messages]).lower()
+            if any(word in context_text for word in self.time_indicators):
+                return True
+        
+        return False
+    
+    def should_include_weather_context(self, user_query: str,
+                                     conversation_history: List[Dict] = None) -> bool:
+        """Determine if weather context is relevant to the query"""
+        query_lower = user_query.lower()
+        
+        # Direct weather references
+        if any(indicator in query_lower for indicator in self.weather_indicators):
+            return True
+        
+        # Location + activity combinations that often involve weather
+        location_mentioned = any(loc.lower() in query_lower for loc in 
+                               ['new york', 'london', 'tokyo', 'paris', 'los angeles', 'sydney', 'singapore', 'mumbai'])
+        activity_mentioned = any(activity in query_lower for activity in 
+                               ['outdoor', 'outside', 'walk', 'run', 'travel', 'trip', 'plans', 'going'])
+        
+        if location_mentioned and activity_mentioned:
+            return True
+        
+        # Check conversation context
+        if conversation_history:
+            recent_messages = conversation_history[-3:]
+            context_text = " ".join([msg.get('content', '') for msg in recent_messages]).lower()
+            if any(word in context_text for word in self.weather_indicators):
+                return True
+        
+        return False
+    
+    def extract_location_if_relevant(self, user_query: str) -> Optional[str]:
+        """Extract location if query suggests location-specific context"""
+        # Common locations
+        locations = {
+            'new york': ['new york', 'ny', 'nyc'],
+            'london': ['london', 'uk', 'england'],
+            'tokyo': ['tokyo', 'japan', 'jp'],
+            'paris': ['paris', 'france', 'fr'],
+            'los angeles': ['los angeles', 'la', 'california'],
+            'sydney': ['sydney', 'australia', 'au'],
+            'singapore': ['singapore', 'sg'],
+            'mumbai': ['mumbai', 'india', 'in']
+        }
+        
+        query_lower = user_query.lower()
+        for location, aliases in locations.items():
+            if any(alias in query_lower for alias in aliases):
+                return location
+        
+        return None
+    
+    def get_relevant_context(self, user_query: str, 
+                           conversation_history: List[Dict] = None) -> Dict[str, Any]:
+        """Get only the context that's actually relevant"""
+        context = {
+            'include_time': self.should_include_time_context(user_query, conversation_history),
+            'include_weather': self.should_include_weather_context(user_query, conversation_history),
+            'detected_location': self.extract_location_if_relevant(user_query),
+            'timestamp': time.time()
+        }
+        
+        # Add actual context data only if needed
+        if context['include_time']:
+            now = datetime.now()
+            context['time_data'] = {
+                'current_time': now.strftime("%A, %B %d, %Y at %I:%M %p"),
+                'day_of_week': now.strftime("%A"),
+                'is_business_hours': 9 <= now.hour <= 17
+            }
+        
+        return context
+
+# Global instance
+smart_context = SmartContextDetector()