Implement modular LLM provider interface with Hugging Face support

src/config/llm_config.py

@@ -0,0 +1,26 @@
+import os
+from typing import Optional
+
+class LLMConfig:
+    """Configuration loader for LLM providers"""
+    
+    @staticmethod
+    def get_active_provider() -> Optional[str]:
+        """Get the name of the active provider based on environment variables"""
+        if os.getenv("HF_TOKEN"):
+            return "huggingface"
+        # elif os.getenv("OLLAMA_HOST"):
+        #     return "ollama"
+        # elif os.getenv("OPENAI_API_KEY"):
+        #     return "openai"
+        return None
+
+    @staticmethod
+    def get_provider_model(provider: str) -> str:
+        """Get the model name for a given provider"""
+        model_map = {
+            "huggingface": os.getenv("HF_MODEL_NAME", "meta-llama/Llama-2-7b-chat-hf"),
+            # "ollama": os.getenv("LOCAL_MODEL_NAME", "mistral:latest"),
+            # "openai": "gpt-3.5-turbo"
+        }
+        return model_map.get(provider, "unknown-model")

src/llm/base_provider.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Optional, Union
+
+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
+
+    @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

src/llm/factory.py

@@ -0,0 +1,51 @@
+import os
+from typing import Optional
+from src.llm.base_provider import LLMProvider
+from src.llm.hf_provider import HuggingFaceProvider
+# Import other providers as they are implemented
+# from src.llm.ollama_provider import OllamaProvider
+# from src.llm.openai_provider import OpenAIProvider
+
+class ProviderNotAvailableError(Exception):
+    """Raised when no provider is available"""
+    pass
+
+class LLMFactory:
+    """Factory for creating LLM providers"""
+    
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(LLMFactory, cls).__new__(cls)
+        return cls._instance
+
+    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 ('huggingface', 'ollama', 'openai')
+            
+        Returns:
+            LLMProvider instance
+            
+        Raises:
+            ProviderNotAvailableError: When no providers are available
+        """
+        # For now, we only have HF provider implemented
+        if preferred_provider == "huggingface" or (preferred_provider is None and os.getenv("HF_TOKEN")):
+            return HuggingFaceProvider(
+                model_name=os.getenv("HF_MODEL_NAME", "meta-llama/Llama-2-7b-chat-hf")
+            )
+        
+        # Add other providers as they are implemented
+        # elif preferred_provider == "ollama" or (preferred_provider is None and os.getenv("OLLAMA_HOST")):
+        #     return OllamaProvider(model_name=os.getenv("LOCAL_MODEL_NAME", "mistral:latest"))
+        # elif preferred_provider == "openai" or (preferred_provider is None and os.getenv("OPENAI_API_KEY")):
+        #     return OpenAIProvider(model_name="gpt-3.5-turbo")
+        
+        raise ProviderNotAvailableError("No LLM providers are available or configured")
+
+# Global factory instance
+llm_factory = LLMFactory()

src/llm/hf_provider.py

@@ -0,0 +1,20 @@
+from typing import List, Dict, Optional, Union
+from src.llm.base_provider import LLMProvider
+
+class HuggingFaceProvider(LLMProvider):
+    """Hugging Face LLM provider stub implementation"""
+
+    def __init__(self, model_name: str, timeout: int = 30, max_retries: int = 3):
+        super().__init__(model_name, timeout, max_retries)
+        # Placeholder for actual client initialization
+        self.client = None
+
+    def generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
+        """Stub for synchronous generation"""
+        # In a real implementation, this would call the HF API
+        return f"[HuggingFace Stub] Response to: {prompt}"
+
+    def stream_generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[Union[str, List[str]]]:
+        """Stub for streaming generation"""
+        # In a real implementation, this would stream from the HF API
+        return ["[HuggingFace", " Streaming", " Stub]"]

src/services/chat_service.py

@@ -0,0 +1,40 @@
+from typing import List, Dict, Optional
+from src.llm.factory import llm_factory, ProviderNotAvailableError
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ChatService:
+    """Service for handling chat interactions with LLM providers"""
+
+    def __init__(self):
+        try:
+            self.provider = llm_factory.get_provider()
+        except ProviderNotAvailableError:
+            self.provider = None
+            logger.error("No LLM providers available")
+
+    def generate_response(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
+        """Generate a response using the configured provider"""
+        if not self.provider:
+            raise ProviderNotAvailableError("No LLM provider available")
+
+        try:
+            return self.provider.generate(prompt, conversation_history)
+        except Exception as e:
+            logger.error(f"LLM generation failed: {e}")
+            raise
+
+    def stream_response(self, prompt: str, conversation_history: List[Dict]):
+        """Stream a response using the configured provider"""
+        if not self.provider:
+            raise ProviderNotAvailableError("No LLM provider available")
+
+        try:
+            return self.provider.stream_generate(prompt, conversation_history)
+        except Exception as e:
+            logger.error(f"LLM stream generation failed: {e}")
+            raise
+
+# Global chat service instance
+chat_service = ChatService()