Updated config file so llm use docker model runner ollama style for better reproducable

backend/app/config.py

@@ -2,55 +2,114 @@
 Configuration for LLM Data Analyzer
 Supports both MLX (local) and Docker Model Runner modes
 All values from .env.local - NO hardcoded defaults
+Follows Metis pattern for portability
 """
 import logging
+import os
 from functools import lru_cache
 from pydantic_settings import BaseSettings
+from pydantic import Field
+
 
 logger = logging.getLogger(__name__)
 
+
 # Conditional MLX import
 HAS_MLX = False
 
+
 class Settings(BaseSettings):
-    """Main settings - all from .env.local"""
+    """Main settings - all from .env.local with sensible defaults"""
     
     # ===== CORE SETTINGS =====
-    fastapi_env: str
-    fastapi_debug: bool
-    log_level: str
+    fastapi_env: str = Field(default="development", env="FASTAPI_ENV")
+    fastapi_debug: bool = Field(default=False, env="FASTAPI_DEBUG")
+    log_level: str = Field(default="INFO", env="LOG_LEVEL")
     
     # ===== LLM MODE SELECTION =====
     # True = Use MLX locally (macOS Apple Silicon)
     # False = Use Docker Model Runner
-    debug: bool
+    debug: bool = Field(default=False, env="DEBUG")
+    llm_mode: str = Field(
+        default="docker_model_runner",
+        env="LLM_MODE",
+        description="'mlx', 'docker_model_runner', or 'mock'"
+    )
     
     # ===== MLX MODE (DEBUG=true) =====
-    llm_model_name_mlx: str
-    llm_max_tokens: int
-    llm_temperature: float
-    llm_device: str
+    llm_model_name_mlx: str = Field(
+        default="mlx-community/Llama-3.2-3B-Instruct-4bit",
+        env="LLM_MODEL_NAME_MLX",
+        description="MLX model from HuggingFace"
+    )
+    llm_max_tokens: int = Field(
+        default=512,
+        env="LLM_MAX_TOKENS",
+        description="Max tokens for generation"
+    )
+    llm_temperature: float = Field(
+        default=0.7,
+        env="LLM_TEMPERATURE",
+        description="Temperature for sampling (0.0-1.0)"
+    )
+    llm_device: str = Field(
+        default="auto",
+        env="LLM_DEVICE",
+        description="MLX device: 'auto', 'cpu', 'gpu'"
+    )
     
     # ===== DOCKER MODEL RUNNER MODE (DEBUG=false) =====
-    docker_model_runner_url: str
-    llm_model_name_docker: str
-    docker_timeout: int
+    # Metis pattern: stateless HTTP API to DMR on host
+    model_runner_url: str = Field(
+        default="http://host.docker.internal:11434/v1",
+        env="MODEL_RUNNER_URL",
+        description="Docker Model Runner API endpoint (from containers use host.docker.internal)"
+    )
+    model_name: str = Field(
+        default="llama3.2:1B-Q4_0",
+        env="MODEL_NAME",
+        description="Model name as shown in 'docker model ls'"
+    )
+    docker_timeout: int = Field(
+        default=300,
+        env="DOCKER_TIMEOUT",
+        description="Timeout for Docker Model Runner requests (seconds)"
+    )
+    
+    # ===== BACKWARDS COMPATIBILITY (deprecated) =====
+    # These are kept for backwards compatibility but use new names above
+    @property
+    def docker_model_runner_url(self) -> str:
+        """Backwards compatible alias for model_runner_url"""
+        return self.model_runner_url
+    
+    @property
+    def llm_model_name_docker(self) -> str:
+        """Backwards compatible alias for model_name"""
+        return self.model_name
     
     # ===== DATA PROCESSING =====
-    max_file_size_mb: int
+    max_file_size_mb: int = Field(
+        default=50,
+        env="MAX_FILE_SIZE_MB",
+        description="Maximum file upload size in MB"
+    )
     
-    # Hardcoded (lists can't be parsed from env vars)
+    # Hardcoded (lists can't be parsed from env vars easily)
     supported_file_types: list = ["csv", "xlsx", "xls"]
     
     class Config:
         env_file = ".env.local"
         case_sensitive = False
+        extra = "allow"
+
 
 @lru_cache
 def get_settings():
     """Get cached settings from .env.local"""
     return Settings()
 
+
 # Check if MLX is available (only needed for DEBUG=true)
 try:
     import mlx.core
@@ -62,8 +121,9 @@ except ImportError:
     HAS_MLX = False
     logger.warning("⚠️  MLX not available (will use Docker Model Runner or mock)")
 
+
 settings = get_settings()
 
-# Export both settings and MLX availability
-__all__ = ["settings", "get_settings", "HAS_MLX"]
 
+# Export both settings and MLX availability
+__all__ = ["settings", "get_settings", "HAS_MLX"]

backend/app/services/llm_service.py

@@ -6,12 +6,15 @@ Dual-mode LLM Service
 """
 import asyncio
 import logging
+import os
 from abc import ABC, abstractmethod
 from typing import List, Optional
 import httpx
 
+
 logger = logging.getLogger(__name__)
 
+
 # Import MLX conditionally
 try:
     from mlx_lm import load
@@ -21,6 +24,7 @@ except ImportError:
     HAS_MLX = False
 
 
+
 class BaseLLMService(ABC):
     """Abstract base class for LLM services"""
     
@@ -43,7 +47,7 @@ class BaseLLMService(ABC):
         pass
     
     async def chat(self, messages: List[dict], system_prompt: str = None) -> str:
-        """Chat interface"""
+        """Chat interface - converts chat format to prompt format"""
         prompt = self._build_prompt(messages, system_prompt)
         return await self.generate(prompt)
     
@@ -63,6 +67,7 @@ class BaseLLMService(ABC):
         return "".join(prompt_parts)
 
 
+
 class LLMServiceMLX(BaseLLMService):
     """MLX implementation for Apple Silicon (DEBUG=true)"""
     
@@ -134,17 +139,33 @@ class LLMServiceMLX(BaseLLMService):
 
 
 
+
 class LLMServiceDockerModelRunner(BaseLLMService):
-    """Docker Model Runner implementation - OpenAI-compatible API"""
+    """Docker Model Runner implementation - OpenAI-compatible API
     
-    def __init__(self, model_name: str, max_tokens: int, temperature: float, docker_url: str, timeout: int = 300):
+    Uses stateless HTTP calls to DMR running on host machine.
+    Optimal for Apple Silicon GPU acceleration via llama.cpp Metal backend.
+    """
+    
+    def __init__(
+        self, 
+        model_name: str, 
+        max_tokens: int, 
+        temperature: float, 
+        docker_url: str,
+        timeout: int = 300
+    ):
         super().__init__(model_name, max_tokens, temperature)
         self.docker_url = docker_url.rstrip("/")  # Remove trailing slash
         self.timeout = timeout
         self.client = None
     
     async def load_model(self) -> bool:
-        """Initialize Docker Model Runner connection"""
+        """Initialize Docker Model Runner connection
+        
+        Tests connectivity to the DMR HTTP API endpoint.
+        DMR itself handles model loading on the host.
+        """
         if self.is_loaded:
             return True
         
@@ -156,8 +177,10 @@ class LLMServiceDockerModelRunner(BaseLLMService):
             response = await self.client.get(f"{self.docker_url}/models")
             
             if response.status_code == 200:
-                self.is_loaded = True
+                models = response.json()
                 self.logger.info(f"✅ Docker Model Runner connected")
+                self.logger.info(f"📋 Available models: {models}")
+                self.is_loaded = True
                 return True
             else:
                 self.logger.error(f"❌ Docker Model Runner returned {response.status_code}")
@@ -167,13 +190,17 @@ class LLMServiceDockerModelRunner(BaseLLMService):
             return False
     
     async def generate(self, prompt: str) -> str:
-        """Generate with Docker Model Runner (OpenAI-compatible API)"""
+        """Generate with Docker Model Runner (OpenAI-compatible API)
+        
+        Makes HTTP request to DMR at host.docker.internal:11434
+        Model inference happens on host GPU (Apple Metal backend)
+        """
         if not self.is_loaded:
             raise RuntimeError("Docker Model Runner not connected")
         
         try:
             payload = {
-                "model": self.model_name,  # "ai/llama3.2:1B-Q4_0"
+                "model": self.model_name,
                 "messages": [{"role": "user", "content": prompt}],
                 "temperature": self.temperature,
                 "max_tokens": self.max_tokens,
@@ -238,13 +265,30 @@ class LLMServiceMock(BaseLLMService):
             return f"Mock response: I processed your prompt about '{prompt[:40]}...' - please note I'm in mock mode with no real LLM."
 
 
-def get_llm_service(debug: bool, mlx_config: dict = None, docker_config: dict = None, settings=None) -> BaseLLMService:
+
+def get_llm_service(debug: bool = None, mlx_config: dict = None, docker_config: dict = None, settings=None) -> BaseLLMService:
     """
     Factory function to get appropriate LLM service
-    Fallback chain: MLX → Docker Model Runner → Mock
+    
+    Fallback chain: MLX (DEBUG=true) → Docker Model Runner → Mock
+    
+    Args:
+        debug: Force DEBUG mode (True=MLX, False=Docker). If None, reads from env/settings
+        mlx_config: Manual MLX config dict
+        docker_config: Manual Docker config dict
+        settings: Pydantic Settings object with llm config
+    
+    Returns:
+        BaseLLMService: One of MLX, DockerModelRunner, or Mock implementation
     """
     
-    # Try MLX first
+    # Determine debug mode
+    if debug is None:
+        debug = os.getenv("DEBUG", "false").lower() == "true"
+        if hasattr(settings, "debug"):
+            debug = settings.debug
+    
+    # Try MLX first (if DEBUG=true)
     if debug and HAS_MLX:
         try:
             config = mlx_config or {
@@ -253,31 +297,46 @@ def get_llm_service(debug: bool, mlx_config: dict = None, docker_config: dict =
                 "temperature": 0.7,
                 "device": "auto"
             }
-            logger.info("📌 Mode: MLX (DEBUG=true)")
+            logger.info("📌 Mode: MLX (DEBUG=true) with Apple Silicon GPU")
             return LLMServiceMLX(**config)
         except Exception as e:
-            logger.warning(f"⚠️  MLX failed: {e}")
+            logger.warning(f"⚠️  MLX failed: {e}, falling back to Docker Model Runner")
     
-    # Try Docker Model Runner
+    # Try Docker Model Runner (Metis pattern)
     docker_url = None
     if docker_config:
         docker_url = docker_config.get("docker_url")
     elif settings:
-        docker_url = settings.docker_model_runner_url
+        docker_url = getattr(settings, "model_runner_url", None)
+    else:
+        docker_url = os.getenv("MODEL_RUNNER_URL")
     
     if docker_url:
         try:
-            config = docker_config or {
-                "model_name": settings.llm_model_name_docker if settings else "llama2",
-                "max_tokens": settings.llm_max_tokens if settings else 512,
-                "temperature": settings.llm_temperature if settings else 0.7,
+            model_name = None
+            if docker_config:
+                model_name = docker_config.get("model_name")
+            elif settings:
+                model_name = getattr(settings, "model_name", None)
+            else:
+                model_name = os.getenv("MODEL_NAME", "llama3.2:1B-Q4_0")
+            
+            config = {
+                "model_name": model_name,
+                "max_tokens": (docker_config or {}).get("max_tokens", 
+                    getattr(settings, "llm_max_tokens", 512) if settings else 512),
+                "temperature": (docker_config or {}).get("temperature", 
+                    getattr(settings, "llm_temperature", 0.7) if settings else 0.7),
                 "docker_url": docker_url,
-                "timeout": settings.docker_timeout if settings else 300
+                "timeout": (docker_config or {}).get("timeout", 
+                    getattr(settings, "docker_timeout", 300) if settings else 300)
             }
             logger.info(f"📌 Mode: Docker Model Runner at {docker_url}")
+            logger.info(f"📌 Model: {config['model_name']}")
+            logger.info(f"✅ Using host GPU acceleration (llama.cpp Metal backend)")
             return LLMServiceDockerModelRunner(**config)
         except Exception as e:
-            logger.warning(f"⚠️  Docker Model Runner failed: {e}")
+            logger.warning(f"⚠️  Docker Model Runner failed: {e}, falling back to Mock")
     
     # Fallback to mock
     logger.warning("⚠️  Using MOCK mode (no LLM available)")
@@ -285,4 +344,4 @@ def get_llm_service(debug: bool, mlx_config: dict = None, docker_config: dict =
         model_name="mock",
         max_tokens=512,
         temperature=0.7
-    )
+    )