Add deterministic Ollama model selection

Author: Zero

zypheron-ai/autopent/ai_decision_engine.py

@@ -199,7 +199,7 @@ def _get_model_for_provider(self, provider: str) -> str:
             AIProvider.GEMINI.value: "gemini-1.5-pro",
             AIProvider.GROK.value: "grok-beta",
             AIProvider.KIMI.value: "moonshot-v1-8k",
-            AIProvider.OLLAMA.value: config.OLLAMA_MODEL or "llama3:latest",
+            AIProvider.OLLAMA.value: config.OLLAMA_MODEL or "llama3.2",
         }
         return model_map.get(provider, "gpt-4-turbo-preview")
 

zypheron-ai/core/config.py

@@ -60,7 +60,7 @@ class AIConfig(BaseSettings):
 
     # Ollama Configuration
     OLLAMA_HOST: str = Field(default="http://localhost:11434", env="OLLAMA_HOST")
-    OLLAMA_MODEL: str = Field(default="qwen3-coder", env="OLLAMA_MODEL")
+    OLLAMA_MODEL: str = Field(default="llama3.2", env="OLLAMA_MODEL")
 
     # Default Model Selection
     DEFAULT_PROVIDER: str = Field(default="anthropic", env="DEFAULT_AI_PROVIDER")

zypheron-ai/core/model_registry.py

@@ -151,20 +151,20 @@ class ProviderConfig:
         },
     ),
     "ollama": ProviderConfig(
-        default_model="qwen3-coder",
-        fallback_model="llama3.2:3b",
+        default_model="llama3.2",
+        fallback_model="llama3.2",
         available_models={
+            "llama3.2": ModelEntry(
+                model_id="llama3.2",
+                context_window=131072,
+                max_output=4096,
+                notes="Default local model",
+            ),
             "qwen3-coder": ModelEntry(
                 model_id="qwen3-coder",
                 context_window=131072,
                 max_output=16384,
-                notes="Best local coding model",
-            ),
-            "llama3.2:3b": ModelEntry(
-                model_id="llama3.2:3b",
-                context_window=131072,
-                max_output=4096,
-                notes="Small + fast local model",
+                notes="Local coding model",
             ),
             "mistral:latest": ModelEntry(
                 model_id="mistral:latest",
@@ -192,7 +192,8 @@ class ProviderConfig:
     "grok-3": "gpt-5.4",  # Grok removed, redirect to OpenAI
     "deepseek-coder": "deepseek-r1",
     "moonshot-v1-8k": "kimi-k2",
-    "llama3:latest": "llama3.2:3b",
+    "llama3:latest": "llama3.2",
+    "llama3.2:3b": "llama3.2",
 }
 
 # Provider name aliases

zypheron-ai/env.example

@@ -22,7 +22,7 @@ GROK_API_KEY=your_grok_api_key_here
 # Ollama Configuration (Local LLM)
 # --------------------------------
 OLLAMA_HOST=http://localhost:11434
-OLLAMA_MODEL=llama3:latest
+OLLAMA_MODEL=llama3.2
 
 # Default AI Provider
 # -------------------

zypheron-ai/providers/ollama.py

@@ -10,24 +10,90 @@
 from loguru import logger
 
 
+DEFAULT_OLLAMA_MODEL = "llama3.2"
+
+
+def normalize_ollama_host(host: Optional[str]) -> str:
+    """Normalize an Ollama host for discovery requests."""
+    value = (host or "").strip() or "http://localhost:11434"
+    if "://" not in value:
+        value = f"http://{value}"
+    return value.rstrip("/")
+
+
+def _model_base(model: str) -> str:
+    return model.strip().split(":", 1)[0]
+
+
+def _is_embedding_model(model: str) -> bool:
+    lowered = model.lower()
+    return "embed" in lowered or "embedding" in lowered
+
+
+def select_ollama_model(preferred: Optional[str], available: List[str]) -> str:
+    """
+    Pick an Ollama model deterministically:
+    exact preferred, tag-tolerant preferred, first non-embedding, first available,
+    preferred/default when no list is available.
+    """
+    preferred_model = (preferred or "").strip() or DEFAULT_OLLAMA_MODEL
+    models = [model.strip() for model in available if model and model.strip()]
+    if not models:
+        return preferred_model
+
+    for model in models:
+        if model == preferred_model:
+            return model
+
+    preferred_base = _model_base(preferred_model)
+    for model in models:
+        if _model_base(model) == preferred_base:
+            return model
+
+    for model in models:
+        if not _is_embedding_model(model):
+            return model
+
+    return models[0]
+
+
 class OllamaProvider(BaseAIProvider):
     """Ollama Provider for local LLM inference"""
 
     def __init__(self, host: Optional[str] = None, model: Optional[str] = None, **kwargs):
         super().__init__(api_key=None, **kwargs)
-        self.host = host or config.OLLAMA_HOST
+        self.host = normalize_ollama_host(host or config.OLLAMA_HOST)
         self.model = model or config.OLLAMA_MODEL
         logger.info(f"Ollama provider initialized with host: {self.host}, model: {self.model}")
 
     async def _list_models(self, session: aiohttp.ClientSession) -> List[str]:
         """Return available local Ollama model tags."""
+        native_models = await self._list_native_models(session)
+        if native_models:
+            return native_models
+        return await self._list_openai_compatible_models(session)
+
+    async def _list_native_models(self, session: aiohttp.ClientSession) -> List[str]:
+        """Return models from Ollama's native tag endpoint."""
         try:
             async with session.get(f"{self.host}/api/tags", timeout=aiohttp.ClientTimeout(total=3)) as response:
                 if response.status != 200:
                     return []
                 data = await response.json()
                 models = data.get("models", [])
-                return [m.get("name", "") for m in models if m.get("name")]
+                return [m.get("name", "").strip() for m in models if m.get("name", "").strip()]
+        except Exception:
+            return []
+
+    async def _list_openai_compatible_models(self, session: aiohttp.ClientSession) -> List[str]:
+        """Return models from Ollama's OpenAI-compatible model endpoint."""
+        try:
+            async with session.get(f"{self.host}/v1/models", timeout=aiohttp.ClientTimeout(total=3)) as response:
+                if response.status != 200:
+                    return []
+                data = await response.json()
+                models = data.get("data", [])
+                return [m.get("id", "").strip() for m in models if m.get("id", "").strip()]
         except Exception:
             return []
 
@@ -39,27 +105,14 @@ async def _resolve_model_fallback(
         """
         Find a compatible fallback when requested model is missing.
         Preference:
-        1) same family prefix (e.g. llama3.2:*),
-        2) configured default model if installed,
-        3) llama3:latest if installed,
-        4) first available model.
+        1) exact preferred match,
+        2) tag-tolerant preferred match,
+        3) first non-embedding model,
+        4) first available model,
+        5) requested/default model when offline.
         """
         available = await self._list_models(session)
-        if not available:
-            return None
-        if requested_model in available:
-            return requested_model
-
-        family = requested_model.split(":", 1)[0]
-        for m in available:
-            if m.startswith(family + ":"):
-                return m
-
-        if self.model in available:
-            return self.model
-        if "llama3:latest" in available:
-            return "llama3:latest"
-        return available[0]
+        return select_ollama_model(requested_model or self.model, available)
 
     async def chat(
         self,

zypheron-ai/tests/test_ollama_provider.py

@@ -0,0 +1,157 @@
+"""Tests for Ollama model fallback selection."""
+
+import asyncio
+import importlib.util
+import sys
+import types
+from pathlib import Path
+from types import SimpleNamespace
+
+
+ROOT = Path(__file__).resolve().parents[1]
+PROVIDERS_DIR = ROOT / "providers"
+
+providers_pkg = types.ModuleType("providers")
+providers_pkg.__path__ = [str(PROVIDERS_DIR)]
+sys.modules.setdefault("providers", providers_pkg)
+
+logger = SimpleNamespace(
+    info=lambda *args, **kwargs: None,
+    debug=lambda *args, **kwargs: None,
+    warning=lambda *args, **kwargs: None,
+)
+sys.modules.setdefault("loguru", SimpleNamespace(logger=logger))
+
+core_pkg = types.ModuleType("core")
+core_pkg.__path__ = [str(ROOT / "core")]
+sys.modules.setdefault("core", core_pkg)
+sys.modules.setdefault(
+    "core.config",
+    SimpleNamespace(
+        config=SimpleNamespace(
+            OLLAMA_HOST="http://localhost:11434",
+            OLLAMA_MODEL="llama3.2",
+        )
+    ),
+)
+
+base_spec = importlib.util.spec_from_file_location("providers.base", PROVIDERS_DIR / "base.py")
+base_module = importlib.util.module_from_spec(base_spec)
+sys.modules["providers.base"] = base_module
+base_spec.loader.exec_module(base_module)
+
+ollama_spec = importlib.util.spec_from_file_location("providers.ollama", PROVIDERS_DIR / "ollama.py")
+ollama_module = importlib.util.module_from_spec(ollama_spec)
+sys.modules["providers.ollama"] = ollama_module
+ollama_spec.loader.exec_module(ollama_module)
+
+DEFAULT_OLLAMA_MODEL = ollama_module.DEFAULT_OLLAMA_MODEL
+OllamaProvider = ollama_module.OllamaProvider
+normalize_ollama_host = ollama_module.normalize_ollama_host
+select_ollama_model = ollama_module.select_ollama_model
+
+
+def test_normalize_ollama_host():
+    assert normalize_ollama_host("") == "http://localhost:11434"
+    assert normalize_ollama_host("localhost:11434/") == "http://localhost:11434"
+    assert normalize_ollama_host(" https://ollama.example.com/// ") == "https://ollama.example.com"
+
+
+def test_select_ollama_model_exact_match():
+    assert (
+        select_ollama_model("llama3.2", ["mistral:latest", "llama3.2"])
+        == "llama3.2"
+    )
+
+
+def test_select_ollama_model_tag_match():
+    assert (
+        select_ollama_model("llama3.2", ["mistral:latest", "llama3.2:latest"])
+        == "llama3.2:latest"
+    )
+
+
+def test_select_ollama_model_skips_embedding_models():
+    assert (
+        select_ollama_model("llama3.2", ["nomic-embed-text:latest", "mistral:latest"])
+        == "mistral:latest"
+    )
+
+
+def test_select_ollama_model_empty_list_keeps_preferred():
+    assert select_ollama_model("llama3.3:70b", []) == "llama3.3:70b"
+
+
+def test_select_ollama_model_empty_list_falls_back_default():
+    assert select_ollama_model("", []) == DEFAULT_OLLAMA_MODEL
+
+
+class FakeResponse:
+    def __init__(self, status, payload):
+        self.status = status
+        self.payload = payload
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        return False
+
+    async def json(self):
+        return self.payload
+
+
+class FakeSession:
+    def __init__(self, routes):
+        self.routes = routes
+        self.urls = []
+
+    def get(self, url, timeout=None):
+        self.urls.append(url)
+        key = url.rsplit("/", 2)[-2] + "/" + url.rsplit("/", 1)[-1]
+        status, payload = self.routes[key]
+        return FakeResponse(status, payload)
+
+
+def test_list_models_uses_native_tags_first():
+    async def run():
+        provider = OllamaProvider(host="http://ollama.test", model="llama3.2")
+        session = FakeSession(
+            {
+                "api/tags": (
+                    200,
+                    {"models": [{"name": " llama3.2:latest "}, {"name": ""}]},
+                ),
+            }
+        )
+
+        models = await provider._list_models(session)
+
+        assert models == ["llama3.2:latest"]
+        assert session.urls == ["http://ollama.test/api/tags"]
+
+    asyncio.run(run())
+
+
+def test_list_models_falls_back_to_openai_compatible_models():
+    async def run():
+        provider = OllamaProvider(host="http://ollama.test", model="llama3.2")
+        session = FakeSession(
+            {
+                "api/tags": (404, {"error": "missing"}),
+                "v1/models": (
+                    200,
+                    {"data": [{"id": " qwen2.5-coder:latest "}, {"id": ""}]},
+                ),
+            }
+        )
+
+        models = await provider._list_models(session)
+
+        assert models == ["qwen2.5-coder:latest"]
+        assert session.urls == [
+            "http://ollama.test/api/tags",
+            "http://ollama.test/v1/models",
+        ]
+
+    asyncio.run(run())

zypheron-go/internal/config/.env.example

@@ -34,8 +34,8 @@ ZYPHERON_AI_PROVIDER=ollama
 # Ollama server URL (default: http://localhost:11434)
 OLLAMA_URL=http://localhost:11434
 
-# Ollama model to use (e.g., codellama, llama2, mistral)
-OLLAMA_MODEL=codellama
+# Ollama model to use (e.g., llama3.2, llama2, mistral)
+OLLAMA_MODEL=llama3.2
 
 # =============================================================================
 # AI Model Configuration
@@ -89,7 +89,7 @@ ZYPHERON_AUDIT_LOGGING=true
 # Example 1: Use local Ollama (default, no API key needed)
 # ZYPHERON_AI_PROVIDER=ollama
 # OLLAMA_URL=http://localhost:11434
-# OLLAMA_MODEL=codellama
+# OLLAMA_MODEL=llama3.2
 
 # Example 2: Use Anthropic Claude
 # ZYPHERON_AI_PROVIDER=anthropic