Add session management, weather service, and TTS modules

README.md

@@ -20,6 +20,9 @@ Your personal AI-powered life coaching assistant.
 - Multiple LLM provider support (Ollama, Hugging Face, OpenAI)
 - Dynamic model selection
 - Remote Ollama integration via ngrok
+- Session management
+- Weather information integration
+- Text-to-speech capabilities
 
 ## How to Use
 
@@ -30,33 +33,42 @@ Your personal AI-powered life coaching assistant.
 
 ## Requirements
 
-All requirements are specified in `requirements.txt`. The app automatically handles:
+All requirements are specified in . The app automatically handles:
 - Streamlit UI
 - FastAPI backend (for future expansion)
 - Redis connection for persistent memory
 - Multiple LLM integrations
+- Weather service integration
+- Text-to-speech capabilities
 
 ## Environment Variables
 
-Configure these in your Hugging Face Space secrets or local `.env` file:
+Configure these in your Hugging Face Space secrets or local  file:
 
-- `OLLAMA_HOST`: Your Ollama server URL (default: ngrok URL)
-- `LOCAL_MODEL_NAME`: Default model name (default: mistral)
-- `HF_TOKEN`: Hugging Face API token (for Hugging Face models)
-- `HF_API_ENDPOINT_URL`: Hugging Face inference API endpoint
-- `USE_FALLBACK`: Whether to use fallback providers (true/false)
-- `REDIS_HOST`: Redis server hostname (default: localhost)
-- `REDIS_PORT`: Redis server port (default: 6379)
-- `REDIS_USERNAME`: Redis username (optional)
-- `REDIS_PASSWORD`: Redis password (optional)
+- : Your Ollama server URL (default: ngrok URL)
+- : Default model name (default: mistral)
+- : Hugging Face API token (for Hugging Face models and TTS)
+- : Hugging Face inference API endpoint
+- : Whether to use fallback providers (true/false)
+- : Redis server hostname (default: localhost)
+- : Redis server port (default: 6379)
+- : Redis username (optional)
+- : Redis password (optional)
+- : OpenWeather API key (for weather features)
+- : Tavily API key (for web search)
 
 ## Architecture
 
 This application consists of:
-- Streamlit frontend (`app.py`)
-- Core LLM abstraction (`core/llm.py`)
-- Memory management (`core/memory.py`)
-- Configuration management (`utils/config.py`)
-- API endpoints (in `api/` directory for future expansion)
+- Streamlit frontend ()
+- Core LLM abstraction ()
+- Memory management ()
+- Session management ()
+- Configuration management ()
+- API endpoints (in  directory for future expansion)
+- Services ( directory):
+  - Weather service ()
+  - Text-to-speech service ()
+  - Ollama monitor ()
 
 Built with Python, Streamlit, FastAPI, and Redis.

core/session.py

@@ -0,0 +1,99 @@
+import json
+import time
+from typing import Dict, Any, Optional
+from core.memory import load_user_state, save_user_state
+
+class SessionManager:
+    """Manages user sessions and conversation context"""
+    
+    def __init__(self, session_timeout: int = 3600):
+        """
+        Initialize session manager
+        
+        Args:
+            session_timeout: Session timeout in seconds (default: 1 hour)
+        """
+        self.session_timeout = session_timeout
+    
+    def get_session(self, user_id: str) -> Dict[str, Any]:
+        """
+        Retrieve user session data
+        
+        Args:
+            user_id: Unique identifier for the user
+            
+        Returns:
+            Dictionary containing session data
+        """
+        try:
+            state = load_user_state(user_id)
+            if not state:
+                return self._create_new_session()
+            
+            # Check if session has expired
+            last_activity = state.get('last_activity', 0)
+            if time.time() - last_activity > self.session_timeout:
+                return self._create_new_session()
+                
+            return state
+        except Exception as e:
+            print(f"Error retrieving session for user {user_id}: {e}")
+            return self._create_new_session()
+    
+    def update_session(self, user_id: str, data: Dict[str, Any]) -> bool:
+        """
+        Update user session data
+        
+        Args:
+            user_id: Unique identifier for the user
+            data: Data to update in the session
+            
+        Returns:
+            Boolean indicating success
+        """
+        try:
+            # Get existing session
+            session = self.get_session(user_id)
+            
+            # Update with new data
+            session.update(data)
+            session['last_activity'] = time.time()
+            
+            # Save updated session
+            return save_user_state(user_id, session)
+        except Exception as e:
+            print(f"Error updating session for user {user_id}: {e}")
+            return False
+    
+    def clear_session(self, user_id: str) -> bool:
+        """
+        Clear user session data
+        
+        Args:
+            user_id: Unique identifier for the user
+            
+        Returns:
+            Boolean indicating success
+        """
+        try:
+            return save_user_state(user_id, {})
+        except Exception as e:
+            print(f"Error clearing session for user {user_id}: {e}")
+            return False
+    
+    def _create_new_session(self) -> Dict[str, Any]:
+        """
+        Create a new session with default values
+        
+        Returns:
+            Dictionary containing new session data
+        """
+        return {
+            'conversation': [],
+            'preferences': {},
+            'last_activity': time.time(),
+            'created_at': time.time()
+        }
+
+# Global session manager instance
+session_manager = SessionManager()

requirements.txt

@@ -7,3 +7,4 @@ openai==1.35.6
 tavily-python>=0.1.0,<1.0.0
 requests==2.31.0
 docker==6.1.3
+pygame==2.5.2

services/tts.py

@@ -0,0 +1,88 @@
+import os
+import requests
+from typing import Optional
+from utils.config import config
+
+class TTSService:
+    """Service for converting text to speech"""
+    
+    def __init__(self):
+        self.hf_token = config.hf_token
+        self.tts_model = "facebook/fastspeech2-en-ljspeech"
+        self.vocoder_model = "facebook/hifigan-universal"
+        
+    def synthesize_speech(self, text: str) -> Optional[bytes]:
+        """
+        Convert text to speech using Hugging Face API
+        
+        Args:
+            text: Text to convert to speech
+            
+        Returns:
+            Audio bytes or None if failed
+        """
+        if not self.hf_token:
+            print("Hugging Face token not configured for TTS")
+            return None
+            
+        try:
+            # First, generate speech with text-to-speech model
+            tts_headers = {
+                "Authorization": f"Bearer {self.hf_token}"
+            }
+            
+            tts_payload = {
+                "inputs": text
+            }
+            
+            tts_response = requests.post(
+                f"https://api-inference.huggingface.co/models/{self.tts_model}",
+                headers=tts_headers,
+                json=tts_payload
+            )
+            
+            if tts_response.status_code != 200:
+                print(f"TTS model error: {tts_response.status_code} - {tts_response.text}")
+                return None
+                
+            # Then, convert to audio with vocoder
+            vocoder_response = requests.post(
+                f"https://api-inference.huggingface.co/models/{self.vocoder_model}",
+                headers=tts_headers,
+                data=tts_response.content
+            )
+            
+            if vocoder_response.status_code == 200:
+                return vocoder_response.content
+            else:
+                print(f"Vocoder error: {vocoder_response.status_code} - {vocoder_response.text}")
+                return None
+                
+        except Exception as e:
+            print(f"Error synthesizing speech: {e}")
+            return None
+    
+    def save_audio_file(self, text: str, filename: str) -> bool:
+        """
+        Synthesize speech and save to file
+        
+        Args:
+            text: Text to convert to speech
+            filename: Output filename (.wav)
+            
+        Returns:
+            Boolean indicating success
+        """
+        audio_data = self.synthesize_speech(text)
+        if audio_data:
+            try:
+                with open(filename, 'wb') as f:
+                    f.write(audio_data)
+                return True
+            except Exception as e:
+                print(f"Error saving audio file: {e}")
+                return False
+        return False
+
+# Global TTS service instance
+tts_service = TTSService()

services/weather.py

@@ -0,0 +1,114 @@
+import requests
+import os
+from typing import Optional, Dict, Any
+from utils.config import config
+
+class WeatherService:
+    """Service for fetching weather information"""
+    
+    def __init__(self):
+        self.api_key = config.openweather_api_key
+        self.base_url = "http://api.openweathermap.org/data/2.5"
+        
+    def get_current_weather(self, city: str) -> Optional[Dict[str, Any]]:
+        """
+        Get current weather for a city
+        
+        Args:
+            city: Name of the city
+            
+        Returns:
+            Dictionary with weather information or None if failed
+        """
+        if not self.api_key:
+            print("OpenWeather API key not configured")
+            return None
+            
+        try:
+            params = {
+                'q': city,
+                'appid': self.api_key,
+                'units': 'metric'  # Celsius
+            }
+            
+            response = requests.get(
+                f"{self.base_url}/weather",
+                params=params,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                return {
+                    'city': data['name'],
+                    'country': data['sys']['country'],
+                    'temperature': data['main']['temp'],
+                    'feels_like': data['main']['feels_like'],
+                    'humidity': data['main']['humidity'],
+                    'description': data['weather'][0]['description'],
+                    'icon': data['weather'][0]['icon']
+                }
+            else:
+                print(f"Weather API error: {response.status_code} - {response.text}")
+                return None
+                
+        except Exception as e:
+            print(f"Error fetching weather data: {e}")
+            return None
+    
+    def get_forecast(self, city: str, days: int = 5) -> Optional[Dict[str, Any]]:
+        """
+        Get weather forecast for a city
+        
+        Args:
+            city: Name of the city
+            days: Number of days to forecast (default: 5)
+            
+        Returns:
+            Dictionary with forecast information or None if failed
+        """
+        if not self.api_key:
+            print("OpenWeather API key not configured")
+            return None
+            
+        try:
+            params = {
+                'q': city,
+                'appid': self.api_key,
+                'units': 'metric',
+                'cnt': days
+            }
+            
+            response = requests.get(
+                f"{self.base_url}/forecast",
+                params=params,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                forecasts = []
+                
+                for item in data['list']:
+                    forecasts.append({
+                        'datetime': item['dt_txt'],
+                        'temperature': item['main']['temp'],
+                        'description': item['weather'][0]['description'],
+                        'icon': item['weather'][0]['icon']
+                    })
+                
+                return {
+                    'city': data['city']['name'],
+                    'country': data['city']['country'],
+                    'forecasts': forecasts
+                }
+            else:
+                print(f"Forecast API error: {response.status_code} - {response.text}")
+                return None
+                
+        except Exception as e:
+            print(f"Error fetching forecast data: {e}")
+            return None
+
+# Global weather service instance
+weather_service = WeatherService()