Implement Core LLM Factory Module with provider abstraction and factory pattern

$envOLLAMA_HOST=httpsf943b91f0a0c.n.txt

@@ -0,0 +1,3 @@
+# Ollama Configuration
+$env:OLLAMA_HOST="https://f943b91f0a0c.ngrok-free.app"
+$env:LOCAL_MODEL_NAME="mistral:latest"

core/llm.py

@@ -1,68 +1,51 @@
-import openai
-import requests
-import time
+import logging
 from typing import List, Dict, Optional
-from utils.config import config
+from core.llm_factory import llm_factory, ProviderNotAvailableError
 
-class LLMProvider:
-    def __init__(self, model_name: str, timeout: int = 30, retries: int = 3):
-        self.model_name = model_name
-        self.timeout = timeout
-        self.retries = retries
+logger = logging.getLogger(__name__)
 
-class OllamaProvider(LLMProvider):
-    def generate_response(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
-        url = f"{config.ollama_host}/api/chat"
-        messages = conversation_history
-        
-        payload = {
-            "model": self.model_name,
-            "messages": messages,
-            "stream": False
-        }
-        
-        for attempt in range(self.retries):
-            try:
-                response = requests.post(url, json=payload, timeout=self.timeout)
-                response.raise_for_status()
-                return response.json()["message"]["content"]
-            except Exception as e:
-                if attempt == self.retries - 1:
-                    print(f"Error after {self.retries} attempts: {e}")
-                    return None
-                time.sleep(2 ** attempt)  # Exponential backoff
-        return None
-
-class HuggingFaceProvider(LLMProvider):
-    def __init__(self, model_name: str, timeout: int = 30, retries: int = 3):
-        super().__init__(model_name, timeout, retries)
-        if not config.hf_token:
-            raise ValueError("HF_TOKEN not set - required for Hugging Face provider")
-        
-        self.client = openai.OpenAI(
-            base_url=config.hf_api_url,
-            api_key=config.hf_token
-        )
+class LLMClient:
+    """High-level LLM client that uses the factory pattern"""
+    
+    def __init__(self, provider: Optional[str] = None):
+        self.provider_name = provider
+        try:
+            self.provider = llm_factory.get_provider(provider)
+        except ProviderNotAvailableError:
+            self.provider = None
+            logger.error("No LLM providers available")
     
-    def generate_response(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
+    def generate(self, prompt: str, conversation_history: List[Dict], stream: bool = False):
+        """Generate a response"""
+        if not self.provider:
+            raise ProviderNotAvailableError("No LLM provider available")
+            
         try:
-            response = self.client.chat.completions.create(
-                model=self.model_name,
-                messages=conversation_history,
-                max_tokens=500,
-                temperature=0.7
-            )
-            return response.choices[0].message.content
+            if stream:
+                return self.provider.stream_generate(prompt, conversation_history)
+            else:
+                return self.provider.generate(prompt, conversation_history)
         except Exception as e:
-            print(f"Hugging Face API error: {e}")
-            return None
+            logger.error(f"LLM generation failed: {e}")
+            raise
 
 def send_to_ollama(prompt: str, conversation_history: List[Dict], ollama_url: str, model: str) -> Optional[str]:
-    config.ollama_host = ollama_url
-    provider = OllamaProvider(model)
-    return provider.generate_response(prompt, conversation_history)
+    """Legacy function for backward compatibility"""
+    try:
+        from core.providers.ollama import OllamaProvider
+        provider = OllamaProvider(model)
+        return provider.generate(prompt, conversation_history)
+    except Exception as e:
+        logger.error(f"Ollama call failed: {e}")
+        return None
 
 def send_to_hf(prompt: str, conversation_history: List[Dict]) -> Optional[str]:
-    # Using a common model that works well for coaching
-    provider = HuggingFaceProvider("meta-llama/Llama-2-7b-chat-hf")
-    return provider.generate_response(prompt, conversation_history)
+    """Legacy function for backward compatibility"""
+    try:
+        from utils.config import config
+        from core.providers.huggingface import HuggingFaceProvider
+        provider = HuggingFaceProvider("meta-llama/Llama-2-7b-chat-hf")
+        return provider.generate(prompt, conversation_history)
+    except Exception as e:
+        logger.error(f"Hugging Face call failed: {e}")
+        return None

core/llm_factory.py

@@ -0,0 +1,140 @@
+import logging
+from typing import Optional, List
+from core.providers.base import LLMProvider
+from core.providers.ollama import OllamaProvider
+from core.providers.huggingface import HuggingFaceProvider
+from core.providers.openai import OpenAIProvider
+from utils.config import config
+
+logger = logging.getLogger(__name__)
+
+class ProviderNotAvailableError(Exception):
+    """Raised when no provider is available"""
+    pass
+
+class LLMFactory:
+    """Factory for creating LLM providers with fallback support"""
+    
+    _instance = None
+    _providers = {}
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(LLMFactory, cls).__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self):
+        if self._initialized:
+            return
+            
+        self._initialized = True
+        self._provider_chain = []
+        self._circuit_breakers = {}
+        self._initialize_providers()
+    
+    def _initialize_providers(self):
+        """Initialize all available providers based on configuration"""
+        # Define provider priority order
+        provider_configs = [
+            {
+                'name': 'ollama',
+                'class': OllamaProvider,
+                'enabled': bool(config.ollama_host),
+                'model': config.local_model_name
+            },
+            {
+                'name': 'huggingface',
+                'class': HuggingFaceProvider,
+                'enabled': bool(config.hf_token),
+                'model': "meta-llama/Llama-2-7b-chat-hf"  # Default HF model
+            },
+            {
+                'name': 'openai',
+                'class': OpenAIProvider,
+                'enabled': bool(config.openai_api_key),
+                'model': "gpt-3.5-turbo"  # Default OpenAI model
+            }
+        ]
+        
+        # Initialize providers in priority order
+        for provider_config in provider_configs:
+            if provider_config['enabled']:
+                try:
+                    provider = provider_config['class'](
+                        model_name=provider_config['model']
+                    )
+                    self._providers[provider_config['name']] = provider
+                    self._provider_chain.append(provider_config['name'])
+                    self._circuit_breakers[provider_config['name']] = {
+                        'failures': 0,
+                        'last_failure': None,
+                        'tripped': False
+                    }
+                    logger.info(f"Initialized {provider_config['name']} provider")
+                except Exception as e:
+                    logger.warning(f"Failed to initialize {provider_config['name']} provider: {e}")
+    
+    def get_provider(self, preferred_provider: Optional[str] = None) -> LLMProvider:
+        """
+        Get an LLM provider based on preference and availability
+        
+        Args:
+            preferred_provider: Preferred provider name (ollama, huggingface, openai)
+            
+        Returns:
+            LLMProvider instance
+            
+        Raises:
+            ProviderNotAvailableError: When no providers are available
+        """
+        # Check preferred provider first
+        if preferred_provider and preferred_provider in self._providers:
+            provider = self._providers[preferred_provider]
+            if self._is_provider_available(preferred_provider) and provider.validate_model():
+                logger.info(f"Using preferred provider: {preferred_provider}")
+                return provider
+        
+        # Fallback through provider chain
+        for provider_name in self._provider_chain:
+            if self._is_provider_available(provider_name):
+                provider = self._providers[provider_name]
+                try:
+                    if provider.validate_model():
+                        logger.info(f"Using fallback provider: {provider_name}")
+                        return provider
+                except Exception as e:
+                    logger.warning(f"Provider {provider_name} model validation failed: {e}")
+                    self._record_provider_failure(provider_name)
+        
+        raise ProviderNotAvailableError("No LLM providers are available")
+    
+    def get_all_providers(self) -> List[LLMProvider]:
+        """Get all initialized providers"""
+        return list(self._providers.values())
+    
+    def _is_provider_available(self, provider_name: str) -> bool:
+        """Check if a provider is available (not tripped by circuit breaker)"""
+        if provider_name not in self._circuit_breakers:
+            return False
+            
+        breaker = self._circuit_breakers[provider_name]
+        if not breaker['tripped']:
+            return True
+            
+        # Check if enough time has passed to reset the circuit breaker
+        # In a real implementation, you might want more sophisticated logic here
+        return False
+    
+    def _record_provider_failure(self, provider_name: str):
+        """Record a provider failure for circuit breaker logic"""
+        if provider_name in self._circuit_breakers:
+            breaker = self._circuit_breakers[provider_name]
+            breaker['failures'] += 1
+            # Trip the circuit breaker after 3 failures
+            if breaker['failures'] >= 3:
+                breaker['tripped'] = True
+                logger.warning(f"Circuit breaker tripped for provider: {provider_name}")
+
+# Global factory instance
+llm_factory = LLMFactory()

core/providers/base.py

@@ -0,0 +1,61 @@
+import time
+import logging
+from abc import ABC, abstractmethod
+from typing import List, Dict, Optional, Union
+from utils.config import config
+
+logger = logging.getLogger(__name__)
+
+class LLMProvider(ABC):
+    """Abstract base class for all LLM providers"""
+    
+    def __init__(self, model_name: str, timeout: int = 30, max_retries: int = 3):
+        self.model_name = model_name
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.is_available = True
+    
+    @abstractmethod
+    def generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
+        """Generate a response synchronously"""
+        pass
+    
+    @abstractmethod
+    def stream_generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[Union[str, List[str]]]:
+        """Generate a response with streaming support"""
+        pass
+    
+    @abstractmethod
+    def validate_model(self) -> bool:
+        """Validate if the model is available"""
+        pass
+    
+    def _retry_with_backoff(self, func, *args, **kwargs):
+        """Retry logic with exponential backoff"""
+        last_exception = None
+        
+        for attempt in range(self.max_retries):
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                last_exception = e
+                if attempt < self.max_retries - 1:  # Don't sleep on last attempt
+                    sleep_time = (2 ** attempt) * 0.5  # Exponential backoff starting at 0.5s
+                    logger.warning(f"Attempt {attempt + 1} failed: {str(e)}. Retrying in {sleep_time}s...")
+                    time.sleep(sleep_time)
+                else:
+                    logger.error(f"All {self.max_retries} attempts failed. Last error: {str(e)}")
+        
+        raise last_exception
+    
+    def _is_rate_limited(self, error: Exception) -> bool:
+        """Check if the error is related to rate limiting"""
+        error_str = str(error).lower()
+        rate_limit_indicators = [
+            "rate limit",
+            "too many requests",
+            "quota exceeded",
+            "429",
+            "limit exceeded"
+        ]
+        return any(indicator in error_str for indicator in rate_limit_indicators)

core/providers/huggingface.py

@@ -0,0 +1,138 @@
+import time
+import logging
+from typing import List, Dict, Optional, Union
+from core.providers.base import LLMProvider
+from utils.config import config
+
+logger = logging.getLogger(__name__)
+
+try:
+    from openai import OpenAI
+    HUGGINGFACE_SDK_AVAILABLE = True
+except ImportError:
+    HUGGINGFACE_SDK_AVAILABLE = False
+    OpenAI = None
+
+class HuggingFaceProvider(LLMProvider):
+    """Hugging Face LLM provider implementation"""
+    
+    def __init__(self, model_name: str, timeout: int = 30, max_retries: int = 3):
+        super().__init__(model_name, timeout, max_retries)
+        
+        if not HUGGINGFACE_SDK_AVAILABLE:
+            raise ImportError("Hugging Face provider requires 'openai' package")
+            
+        if not config.hf_token:
+            raise ValueError("HF_TOKEN not set - required for Hugging Face provider")
+            
+        self.client = OpenAI(
+            base_url=config.hf_api_url,
+            api_key=config.hf_token
+        )
+    
+    def generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
+        """Generate a response synchronously"""
+        try:
+            return self._retry_with_backoff(self._generate_impl, prompt, conversation_history)
+        except Exception as e:
+            logger.error(f"Hugging Face generation failed: {e}")
+            return None
+    
+    def stream_generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[Union[str, List[str]]]:
+        """Generate a response with streaming support"""
+        try:
+            return self._retry_with_backoff(self._stream_generate_impl, prompt, conversation_history)
+        except Exception as e:
+            logger.error(f"Hugging Face stream generation failed: {e}")
+            return None
+    
+    def validate_model(self) -> bool:
+        """Validate if the model is available"""
+        # For Hugging Face endpoints, we'll assume the model is valid if we can connect
+        # In production, you might want to ping the endpoint specifically
+        try:
+            # Simple connectivity check
+            self.client.models.list()
+            return True
+        except Exception as e:
+            logger.warning(f"Hugging Face model validation failed: {e}")
+            return False
+    
+    def _generate_impl(self, prompt: str, conversation_history: List[Dict]) -> str:
+        """Implementation of synchronous generation"""
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=conversation_history,
+                max_tokens=500,
+                temperature=0.7
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            # Handle scale-to-zero behavior
+            if self._is_scale_to_zero_error(e):
+                logger.info("Hugging Face endpoint is scaling up, waiting...")
+                time.sleep(60)  # Wait for endpoint to initialize
+                # Retry once after waiting
+                response = self.client.chat.completions.create(
+                    model=self.model_name,
+                    messages=conversation_history,
+                    max_tokens=500,
+                    temperature=0.7
+                )
+                return response.choices[0].message.content
+            else:
+                raise
+    
+    def _stream_generate_impl(self, prompt: str, conversation_history: List[Dict]) -> List[str]:
+        """Implementation of streaming generation"""
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=conversation_history,
+                max_tokens=500,
+                temperature=0.7,
+                stream=True
+            )
+            
+            chunks = []
+            for chunk in response:
+                content = chunk.choices[0].delta.content
+                if content:
+                    chunks.append(content)
+                    
+            return chunks
+        except Exception as e:
+            # Handle scale-to-zero behavior
+            if self._is_scale_to_zero_error(e):
+                logger.info("Hugging Face endpoint is scaling up, waiting...")
+                time.sleep(60)  # Wait for endpoint to initialize
+                # Retry once after waiting
+                response = self.client.chat.completions.create(
+                    model=self.model_name,
+                    messages=conversation_history,
+                    max_tokens=500,
+                    temperature=0.7,
+                    stream=True
+                )
+                
+                chunks = []
+                for chunk in response:
+                    content = chunk.choices[0].delta.content
+                    if content:
+                        chunks.append(content)
+                        
+                return chunks
+            else:
+                raise
+    
+    def _is_scale_to_zero_error(self, error: Exception) -> bool:
+        """Check if the error is related to scale-to-zero initialization"""
+        error_str = str(error).lower()
+        scale_to_zero_indicators = [
+            "503",
+            "service unavailable",
+            "initializing",
+            "cold start"
+        ]
+        return any(indicator in error_str for indicator in scale_to_zero_indicators)

core/providers/ollama.py

@@ -0,0 +1,126 @@
+import requests
+import logging
+from typing import List, Dict, Optional, Union
+from core.providers.base import LLMProvider
+from utils.config import config
+
+logger = logging.getLogger(__name__)
+
+class OllamaProvider(LLMProvider):
+    """Ollama LLM provider implementation"""
+    
+    def __init__(self, model_name: str, timeout: int = 30, max_retries: int = 3):
+        super().__init__(model_name, timeout, max_retries)
+        self.host = config.ollama_host or "http://localhost:11434"
+        # Headers to skip ngrok browser warning
+        self.headers = {
+            "ngrok-skip-browser-warning": "true",
+            "User-Agent": "AI-Life-Coach-Ollama"
+        }
+    
+    def generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
+        """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}")
+            return None
+    
+    def stream_generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[Union[str, List[str]]]:
+        """Generate a response with streaming support"""
+        try:
+            return self._retry_with_backoff(self._stream_generate_impl, prompt, conversation_history)
+        except Exception as e:
+            logger.error(f"Ollama stream generation failed: {e}")
+            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"""
+        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,
+            "stream": False
+        }
+        
+        response = requests.post(
+            url, 
+            json=payload, 
+            headers=self.headers,
+            timeout=self.timeout
+        )
+        response.raise_for_status()
+        
+        result = response.json()
+        return result["message"]["content"]
+    
+    def _stream_generate_impl(self, prompt: str, conversation_history: List[Dict]) -> List[str]:
+        """Implementation of streaming generation"""
+        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,
+            "stream": True
+        }
+        
+        response = requests.post(
+            url, 
+            json=payload, 
+            headers=self.headers,
+            timeout=self.timeout,
+            stream=True
+        )
+        response.raise_for_status()
+        
+        chunks = []
+        for line in response.iter_lines():
+            if line:
+                chunk = line.decode('utf-8')
+                try:
+                    data = eval(chunk)  # Simplified JSON parsing
+                    content = data.get("message", {}).get("content", "")
+                    if content:
+                        chunks.append(content)
+                except:
+                    continue
+                    
+        return chunks

core/providers/openai.py

@@ -0,0 +1,82 @@
+import time
+import logging
+from typing import List, Dict, Optional, Union
+from core.providers.base import LLMProvider
+from utils.config import config
+
+logger = logging.getLogger(__name__)
+
+try:
+    from openai import OpenAI
+    OPENAI_SDK_AVAILABLE = True
+except ImportError:
+    OPENAI_SDK_AVAILABLE = False
+    OpenAI = None
+
+class OpenAIProvider(LLMProvider):
+    """OpenAI LLM provider implementation"""
+    
+    def __init__(self, model_name: str, timeout: int = 30, max_retries: int = 3):
+        super().__init__(model_name, timeout, max_retries)
+        
+        if not OPENAI_SDK_AVAILABLE:
+            raise ImportError("OpenAI provider requires 'openai' package")
+            
+        if not config.openai_api_key:
+            raise ValueError("OPENAI_API_KEY not set - required for OpenAI provider")
+            
+        self.client = OpenAI(api_key=config.openai_api_key)
+    
+    def generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
+        """Generate a response synchronously"""
+        try:
+            return self._retry_with_backoff(self._generate_impl, prompt, conversation_history)
+        except Exception as e:
+            logger.error(f"OpenAI generation failed: {e}")
+            return None
+    
+    def stream_generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[Union[str, List[str]]]:
+        """Generate a response with streaming support"""
+        try:
+            return self._retry_with_backoff(self._stream_generate_impl, prompt, conversation_history)
+        except Exception as e:
+            logger.error(f"OpenAI stream generation failed: {e}")
+            return None
+    
+    def validate_model(self) -> bool:
+        """Validate if the model is available"""
+        try:
+            models = self.client.models.list()
+            model_ids = [model.id for model in models.data]
+            return self.model_name in model_ids
+        except Exception as e:
+            logger.warning(f"OpenAI model validation failed: {e}")
+            return False
+    
+    def _generate_impl(self, prompt: str, conversation_history: List[Dict]) -> str:
+        """Implementation of synchronous generation"""
+        response = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=conversation_history,
+            max_tokens=500,
+            temperature=0.7
+        )
+        return response.choices[0].message.content
+    
+    def _stream_generate_impl(self, prompt: str, conversation_history: List[Dict]) -> List[str]:
+        """Implementation of streaming generation"""
+        response = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=conversation_history,
+            max_tokens=500,
+            temperature=0.7,
+            stream=True
+        )
+        
+        chunks = []
+        for chunk in response:
+            content = chunk.choices[0].delta.content
+            if content:
+                chunks.append(content)
+                
+        return chunks

ngrok.yml

@@ -1,9 +1,9 @@
 version: "2"
 authtoken: 32HaXMF3tuRxfas1siT3CIhLjH4_2AXbGGma38NnCF1tjyJNZ
 tunnels:
-  ai-coach-api:
-    addr: 8000
-    proto: http
-  ai-coach-ui:
+  web:
     addr: 8501
+    proto: http
+  api:
+    addr: 11434
     proto: http

ngrok.yml.txt

@@ -1,9 +0,0 @@
-version: "2"
-authtoken: 32HaXMF3tuRxfas1siT3CIhLjH4_2AXbGGma38NnCF1tjyJNZ
-tunnels:
-  ai-coach-api:
-    addr: 8000
-    proto: http
-  ai-coach-ui:
-    addr: 8501
-    proto: http

utils/config.py

@@ -8,8 +8,14 @@ class Config:
         # Detect if running on HF Spaces
         self.is_hf_space = bool(os.getenv("SPACE_ID"))
         
+        # API tokens
         self.hf_token = os.getenv("HF_TOKEN")
+        self.openai_api_key = os.getenv("OPENAI_API_KEY")
+        
+        # API endpoints
         self.hf_api_url = os.getenv("HF_API_ENDPOINT_URL", "https://api-inference.huggingface.co/v1/")
+        
+        # Fallback settings
         self.use_fallback = os.getenv("USE_FALLBACK", "true").lower() == "true"
         
         # Redis configuration (optional for HF)
@@ -23,6 +29,9 @@ class Config:
         # Local model configuration
         self.local_model_name = os.getenv("LOCAL_MODEL_NAME", "mistral:latest")
         self.ollama_host = os.getenv("OLLAMA_HOST", "")
+        
+        # OpenWeather API
+        self.openweather_api_key = os.getenv("OPENWEATHER_API_KEY")
 
 # Global config instance
 config = Config()