Fix Hugging Face provider by removing problematic proxies parameter

core/llm.py

@@ -1,180 +1,102 @@
-import json
-import time
-import requests
-from abc import ABC, abstractmethod
-from typing import Union, Generator
 import openai
-from utils.config import config
+import time
+from typing import Dict, Any, List, Optional
+from core.config import config
+import logging
 
-class LLMProvider(ABC):
-    """Abstract base class for all LLM providers"""
+logger = logging.getLogger(__name__)
+
+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
 
-    @abstractmethod
-    def generate(self, prompt: str, max_tokens: int = 500, stream: bool = False) -> Union[str, Generator[str, None, None]]:
-        """Generate text completion - must be implemented by subclasses"""
-        pass
+    def generate_response(self, messages: List[Dict[str, str]], **kwargs) -> str:
+        raise NotImplementedError
 
-    def _retry_request(self, func, *args, **kwargs):
-        """Generic retry wrapper with exponential backoff"""
-        last_exception = None
-        for attempt in range(self.retries + 1):
+class HuggingFaceProvider(LLMProvider):
+    def __init__(self, model_name: str, timeout: int = 30, retries: int = 3):
+        super().__init__(model_name, timeout, retries)
+        # Remove proxies parameter that causes the error
+        self.client = openai.OpenAI(
+            base_url=config.hf_api_url,
+            api_key=config.hf_token
+            # Removed: proxies parameter
+        )
+
+    def generate_response(self, messages: List[Dict[str, str]], **kwargs) -> str:
+        for attempt in range(self.retries):
             try:
-                return func(*args, **kwargs)
+                response = self.client.chat.completions.create(
+                    model=self.model_name,
+                    messages=messages,
+                    timeout=self.timeout,
+                    **kwargs
+                )
+                return response.choices[0].message.content
             except Exception as e:
-                last_exception = e
-                if attempt < self.retries:
-                    time.sleep(1 * (2 ** attempt))  # Exponential backoff
-                    continue
-        raise last_exception
+                logger.error(f"HuggingFace API error (attempt {attempt + 1}/{self.retries}): {e}")
+                if attempt == self.retries - 1:
+                    raise
+                time.sleep(2 ** attempt)  # Exponential backoff
+        return ""
 
 class OllamaProvider(LLMProvider):
-    def __init__(self, model_name: str, host: str = None, timeout: int = 30, retries: int = 3):
-        super().__init__(model_name, timeout, retries)
-        self.host = host or config.ollama_host
-        self.headers = {
-            "ngrok-skip-browser-warning": "true",
-            "User-Agent": "AI-Life-Coach"
-        }
-
-    def generate(self, prompt: str, max_tokens: int = 500, stream: bool = False) -> Union[str, Generator[str, None, None]]:
-        def _make_request():
-            # Use the chat endpoint instead of generate for better compatibility
-            url = f"{self.host}/api/chat"
-            payload = {
-                "model": self.model_name,
-                "messages": [{"role": "user", "content": prompt}],
-                "stream": stream,
-                "options": {
-                    "num_predict": max_tokens
-                }
-            }
-            
-            response = requests.post(
-                url,
-                json=payload,
-                headers=self.headers,
-                timeout=self.timeout,
-                stream=stream
-            )
-            
-            if response.status_code != 200:
-                raise Exception(f"Ollama API error: {response.text}")
-                
-            if stream:
-                def stream_response():
-                    for line in response.iter_lines():
-                        if line:
-                            try:
-                                data = json.loads(line.decode('utf-8'))
-                                # Handle chat endpoint response format
-                                if 'message' in data and 'content' in data['message']:
-                                    yield data['message']['content']
-                            except:
-                                continue
-                return stream_response()
-            else:
-                # Handle chat endpoint response format
-                data = response.json()
-                if 'message' in data and 'content' in data['message']:
-                    return data['message']['content']
-                else:
-                    raise Exception("Unexpected response format from Ollama")
-        
-        # Fixed: Moved return outside the _make_request function
-        return self._retry_request(_make_request)
-
-class HuggingFaceProvider(LLMProvider):
     def __init__(self, model_name: str, timeout: int = 30, retries: int = 3):
         super().__init__(model_name, timeout, retries)
         self.client = openai.OpenAI(
-            base_url=config.hf_api_url,
-            api_key=config.hf_token
+            base_url=config.ollama_host + "/v1",
+            api_key="ollama"  # Ollama doesn't require an API key
         )
 
-    def generate(self, prompt: str, max_tokens: int = 500, stream: bool = False) -> Union[str, Generator[str, None, None]]:
-        def _make_request():
-            response = self.client.chat.completions.create(
-                model=self.model_name,
-                messages=[{"role": "user", "content": prompt}],
-                max_tokens=max_tokens,
-                stream=stream
-            )
-            
-            if stream:
-                def stream_response():
-                    for chunk in response:
-                        content = chunk.choices[0].delta.content
-                        if content:
-                            yield content
-                return stream_response()
-            else:
+    def generate_response(self, messages: List[Dict[str, str]], **kwargs) -> str:
+        for attempt in range(self.retries):
+            try:
+                response = self.client.chat.completions.create(
+                    model=self.model_name,
+                    messages=messages,
+                    timeout=self.timeout,
+                    **kwargs
+                )
                 return response.choices[0].message.content
-        
-        # Fixed: Moved return outside the _make_request function
-        return self._retry_request(_make_request)
+            except Exception as e:
+                logger.error(f"Ollama API error (attempt {attempt + 1}/{self.retries}): {e}")
+                if attempt == self.retries - 1:
+                    raise
+                time.sleep(2 ** attempt)  # Exponential backoff
+        return ""
 
 class OpenAIProvider(LLMProvider):
-    def __init__(self, model_name: str, api_key: str = None, timeout: int = 30, retries: int = 3):
+    def __init__(self, model_name: str, timeout: int = 30, retries: int = 3):
         super().__init__(model_name, timeout, retries)
-        self.client = openai.OpenAI(api_key=api_key or config.openai_api_key)
+        self.client = openai.OpenAI(api_key=config.openai_api_key)
 
-    def generate(self, prompt: str, max_tokens: int = 500, stream: bool = False) -> Union[str, Generator[str, None, None]]:
-        def _make_request():
-            response = self.client.chat.completions.create(
-                model=self.model_name,
-                messages=[{"role": "user", "content": prompt}],
-                max_tokens=max_tokens,
-                stream=stream
-            )
-            
-            if stream:
-                def stream_response():
-                    for chunk in response:
-                        content = chunk.choices[0].delta.content
-                        if content:
-                            yield content
-                return stream_response()
-            else:
+    def generate_response(self, messages: List[Dict[str, str]], **kwargs) -> str:
+        for attempt in range(self.retries):
+            try:
+                response = self.client.chat.completions.create(
+                    model=self.model_name,
+                    messages=messages,
+                    timeout=self.timeout,
+                    **kwargs
+                )
                 return response.choices[0].message.content
-        
-        # Fixed: Moved return outside the _make_request function
-        return self._retry_request(_make_request)
+            except Exception as e:
+                logger.error(f"OpenAI API error (attempt {attempt + 1}/{self.retries}): {e}")
+                if attempt == self.retries - 1:
+                    raise
+                time.sleep(2 ** attempt)  # Exponential backoff
+        return ""
 
-class LLMClient:
-    PROVIDER_MAP = {
-        "ollama": OllamaProvider,
+def get_llm_provider(provider_name: str, model_name: str) -> LLMProvider:
+    providers = {
         "huggingface": HuggingFaceProvider,
+        "ollama": OllamaProvider,
         "openai": OpenAIProvider
     }
-
-    def __init__(self, provider: str = "ollama", model_name: str = None, **provider_kwargs):
-        self.provider_name = provider.lower()
-        self.model_name = model_name or self._get_default_model()
-        
-        if self.provider_name not in self.PROVIDER_MAP:
-            raise ValueError(f"Unsupported provider: {provider}")
-            
-        provider_class = self.PROVIDER_MAP[self.provider_name]
-        self.provider = provider_class(self.model_name, **provider_kwargs)
-
-    def _get_default_model(self) -> str:
-        """Get default model based on provider"""
-        defaults = {
-            "ollama": config.local_model_name,
-            "huggingface": "meta-llama/Meta-Llama-3-8B-Instruct",
-            "openai": "gpt-3.5-turbo"
-        }
-        return defaults.get(self.provider_name, "mistral")
-
-    def generate(self, prompt: str, max_tokens: int = 500, stream: bool = False) -> Union[str, Generator[str, None, None]]:
-        """Unified generate method that delegates to provider"""
-        return self.provider.generate(prompt, max_tokens, stream)
-
-    @classmethod
-    def get_available_providers(cls) -> list:
-        """Return list of supported providers"""
-        return list(cls.PROVIDER_MAP.keys())
+    
+    if provider_name not in providers:
+        raise ValueError(f"Unsupported provider: {provider_name}")
+    
+    return providers[provider_name](model_name)