Implement context enrichment service for current data awareness

src/llm/enhanced_provider.py

@@ -0,0 +1,32 @@
+import json
+from typing import List, Dict, Optional, Union
+from src.llm.base_provider import LLMProvider
+from src.services.context_enrichment import context_service
+
+class EnhancedLLMProvider(LLMProvider):
+    """Base provider with 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"""
+        # 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']}]"
+        }
+        
+        # Insert context at the beginning
+        enriched_history = [context_message] + conversation_history
+        return enriched_history

src/llm/ollama_provider.py

@@ -2,13 +2,13 @@ import requests
 import logging
 import re
 from typing import List, Dict, Optional, Union
-from src.llm.base_provider import LLMProvider
+from src.llm.enhanced_provider import EnhancedLLMProvider
 from utils.config import config
 
 logger = logging.getLogger(__name__)
 
-class OllamaProvider(LLMProvider):
-    """Ollama LLM provider implementation"""
+class OllamaProvider(EnhancedLLMProvider):
+    """Ollama LLM provider implementation with context enrichment"""
 
     def __init__(self, model_name: str, timeout: int = 60, max_retries: int = 3):
         super().__init__(model_name, timeout, max_retries)
@@ -29,43 +29,64 @@ class OllamaProvider(LLMProvider):
         return host
 
     def generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
-        """Generate a response synchronously"""
-        return self._retry_with_backoff(self._generate_impl, prompt, conversation_history)
-
-    def stream_generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[Union[str, List[str]]]:
-        """Generate a response with streaming support"""
-        return self._retry_with_backoff(self._stream_generate_impl, prompt, conversation_history)
-
-    def _generate_impl(self, prompt: str, conversation_history: List[Dict]) -> str:
-        """Implementation of synchronous generation"""
+        """Generate a response synchronously with context enrichment"""
         try:
+            # Enrich context
+            enriched_history = self._enrich_context(conversation_history)
+            
             url = f"{self.host}/api/chat"
             payload = {
                 "model": self.model_name,
-                "messages": conversation_history,
+                "messages": enriched_history,
                 "stream": False
             }
             
+            logger.info(f"Ollama request URL: {url}")
+            logger.info(f"Ollama request payload: {payload}")
+            logger.info(f"Ollama headers: {self.headers}")
+            
             response = requests.post(
                 url,
                 json=payload,
                 headers=self.headers,
                 timeout=self.timeout
             )
+            
+            logger.info(f"Ollama response status: {response.status_code}")
+            logger.info(f"Ollama response headers: {dict(response.headers)}")
+            
             response.raise_for_status()
             result = response.json()
-            return result["message"]["content"]
+            logger.info(f"Ollama response body: {result}")
+            
+            # Extract content properly
+            if "message" in result and "content" in result["message"]:
+                content = result["message"]["content"]
+                logger.info(f"Extracted content: {content[:100] if content else 'None'}")
+                return content
+            elif "response" in result:
+                content = result["response"]
+                logger.info(f"Extracted response: {content[:100] if content else 'None'}")
+                return content
+            else:
+                content = str(result)
+                logger.info(f"Raw result as string: {content[:100]}")
+                return content
+                
         except Exception as e:
             logger.error(f"Ollama generation failed: {e}")
             raise
 
-    def _stream_generate_impl(self, prompt: str, conversation_history: List[Dict]) -> List[str]:
-        """Implementation of streaming generation"""
+    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)
+            
             url = f"{self.host}/api/chat"
             payload = {
                 "model": self.model_name,
-                "messages": conversation_history,
+                "messages": enriched_history,
                 "stream": True
             }
             
@@ -83,7 +104,7 @@ class OllamaProvider(LLMProvider):
                 if line:
                     chunk = line.decode('utf-8')
                     try:
-                        data = eval(chunk)
+                        data = eval(chunk)  # Simplified JSON parsing
                         content = data.get("message", {}).get("content", "")
                         if content:
                             chunks.append(content)

src/services/context_enrichment.py

@@ -0,0 +1,69 @@
+import datetime
+import requests
+from typing import Dict, Any, Optional
+from utils.config import config
+
+class ContextEnrichmentService:
+    """Service for enriching AI context with current data"""
+    
+    def __init__(self):
+        self.openweather_api_key = config.openweather_api_key
+        self.tavily_api_key = config.tavily_api_key
+        
+    def get_current_context(self, user_query: str = "") -> Dict[str, Any]:
+        """Get current context including time, weather, and recent news"""
+        context = {
+            "current_time": self._get_current_time(),
+            "weather": self._get_weather_summary("New York"),  # Default location
+            "recent_news": self._get_recent_news(user_query) if user_query else []
+        }
+        return context
+    
+    def _get_current_time(self) -> str:
+        """Get current date and time"""
+        now = datetime.datetime.now()
+        return now.strftime("%A, %B %d, %Y at %I:%M %p")
+    
+    def _get_weather_summary(self, city: str = "New York") -> Optional[str]:
+        """Get weather summary for a city"""
+        if not self.openweather_api_key:
+            return "Weather data not configured"
+            
+        try:
+            url = f"http://api.openweathermap.org/data/2.5/weather"
+            params = {
+                'q': city,
+                '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"{data['weather'][0]['description']}, {data['main']['temp']}°C in {data['name']}"
+        except Exception:
+            pass
+        return "Clear skies"
+    
+    def _get_recent_news(self, query: str) -> list:
+        """Get recent news related to query"""
+        if not self.tavily_api_key:
+            return []
+            
+        try:
+            url = "https://api.tavily.com/search"
+            headers = {"Content-Type": "application/json"}
+            data = {
+                "query": query,
+                "api_key": self.tavily_api_key,
+                "max_results": 3
+            }
+            response = requests.post(url, json=data, headers=headers, timeout=10)
+            if response.status_code == 200:
+                result = response.json()
+                return result.get("results", [])
+        except Exception:
+            pass
+        return []
+
+# Global instance
+context_service = ContextEnrichmentService()