minder-cli 0.2.5__tar.gz → 0.2.7__tar.gz

{minder_cli-0.2.5 → minder_cli-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minder-cli
-Version: 0.2.5
+Version: 0.2.7
 Summary: Minder CLI is the command-line interface for the Minder self-hosted MCP platform.
 Project-URL: Homepage, https://github.com/hiimtrung/minder
 Project-URL: Repository, https://github.com/hiimtrung/minder
@@ -12,16 +12,15 @@ Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.13
+Requires-Python: >=3.14
 Requires-Dist: fastapi>=0.136.0
-Requires-Dist: httpx>=0.27.0
+Requires-Dist: httpx>=0.28.0
 Provides-Extra: server
 Requires-Dist: aiosqlite>=0.21.0; extra == 'server'
-Requires-Dist: langgraph>=1.1.4; extra == 'server'
+Requires-Dist: langgraph>=1.1.8; extra == 'server'
 Requires-Dist: litellm>=1.83.1; extra == 'server'
-Requires-Dist: llama-cpp-python>=0.3.20; extra == 'server'
 Requires-Dist: mcp>=1.26.0; extra == 'server'
 Requires-Dist: motor>=3.7.0; extra == 'server'
 Requires-Dist: passlib[bcrypt]>=1.7.4; extra == 'server'
@@ -29,9 +28,11 @@ Requires-Dist: prometheus-client>=0.24.1; extra == 'server'
 Requires-Dist: pydantic-settings[toml]>=2.13.1; extra == 'server'
 Requires-Dist: pydantic>=2.12.5; extra == 'server'
 Requires-Dist: pyjwt>=2.12.1; extra == 'server'
-Requires-Dist: pymilvus>=2.5.0; extra == 'server'
-Requires-Dist: redis[hiredis]>=6.0.0; extra == 'server'
-Requires-Dist: sqlalchemy[asyncio]>=2.0.48; extra == 'server'
+Requires-Dist: pymilvus>=2.6.12; extra == 'server'
+Requires-Dist: sqlalchemy[asyncio]>=2.0.49; extra == 'server'
+Requires-Dist: yarl>=1.16.0; extra == 'server'
+Requires-Dist: zipp>=3.21.0; extra == 'server'
+Requires-Dist: zstandard>=0.25.0; extra == 'server'
 Description-Content-Type: text/markdown
 
 # Minder CLI

{minder_cli-0.2.5 → minder_cli-0.2.7}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "hatchling.build"
 
 [project]
 name = "minder-cli"
-version = "0.2.5"
+version = "0.2.7"
 description = "Minder CLI is the command-line interface for the Minder self-hosted MCP platform."
 readme = "README.md"
-requires-python = ">=3.13"
+requires-python = ">=3.14"
 keywords = ["mcp", "cli", "ai", "code-search", "workflow"]
 classifiers = [
     "Development Status :: 3 - Alpha",
@@ -15,20 +15,19 @@ classifiers = [
     "Intended Audience :: Developers",
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
 dependencies = [
     "fastapi>=0.136.0",
-    "httpx>=0.27.0",
+    "httpx>=0.28.0",
 ]
 
 [project.optional-dependencies]
 server = [
     "aiosqlite>=0.21.0",
-    "langgraph>=1.1.4",
+    "langgraph>=1.1.8",
     "litellm>=1.83.1",
-    "llama-cpp-python>=0.3.20",
     "mcp>=1.26.0",
     "motor>=3.7.0",
     "passlib[bcrypt]>=1.7.4",
@@ -36,9 +35,11 @@ server = [
     "pydantic>=2.12.5",
     "pydantic-settings[toml]>=2.13.1",
     "pyjwt>=2.12.1",
-    "pymilvus>=2.5.0",
-    "redis[hiredis]>=6.0.0",
-    "sqlalchemy[asyncio]>=2.0.48",
+    "pymilvus>=2.6.12",
+    "sqlalchemy[asyncio]>=2.0.49",
+    "yarl>=1.16.0",
+    "zipp>=3.21.0",
+    "zstandard>=0.25.0",
 ]
 
 [project.urls]
@@ -51,8 +52,8 @@ minder = "minder.cli:main"
 
 [dependency-groups]
 dev = [
-    "fakeredis[lua]>=2.26.0",
-    "mypy>=1.20.0",
+    "fakeredis[lua]>=2.27.0",
+    "mypy>=1.20.1",
     "pytest>=9.0.2",
     "pytest-asyncio>=1.3.0",
     "pytest-timeout>=2.3.1",

{minder_cli-0.2.5 → minder_cli-0.2.7}/src/minder/config.py

@@ -31,18 +31,18 @@ class AuthConfig(BaseModel):
 
 
 class EmbeddingConfig(BaseModel):
-    provider: str = "llamacpp"
-    model_name: str = "ggml-org/embeddinggemma-300M-GGUF"
-    model_path: str = "~/.minder/models/embeddinggemma-300M-Q8_0.gguf"
+    provider: str = "ollama"
+    ollama_url: str = "http://localhost:11434"
+    ollama_model: str = "embeddinggemma"
     dimensions: int = 768
     openai_api_key: Optional[str] = None
     openai_model: str = "text-embedding-3-small"
 
 
 class LLMConfig(BaseModel):
-    provider: str = "llamacpp"
-    model_name: str = "ggml-org/gemma-4-E2B-it-GGUF"
-    model_path: str = "~/.minder/models/gemma-4-e2b-it-Q8_0.gguf"
+    provider: str = "ollama"
+    ollama_url: str = "http://localhost:11434"
+    ollama_model: str = "gemma3:4b"
     context_length: int = 131072
     temperature: float = 0.1
     openai_api_key: Optional[str] = None

{minder_cli-0.2.5 → minder_cli-0.2.7}/src/minder/continuity.py

@@ -272,8 +272,8 @@ class ContinuitySynthesizer:
 
         self._config = config
         self._llm = LocalModelLLM(
-            config.llm.model_path,
-            runtime="auto",
+            ollama_url=config.llm.ollama_url,
+            ollama_model=config.llm.ollama_model,
             context_length=config.llm.context_length,
         )
 
@@ -312,7 +312,7 @@ class ContinuitySynthesizer:
         if not parsed:
             return fallback, {
                 "provider": "heuristic",
-                "model": self._config.llm.model_name,
+                "model": self._config.llm.ollama_model,
                 "runtime": self._llm.runtime,
             }
         return {

minder_cli-0.2.7/src/minder/embedding/local.py

@@ -0,0 +1,76 @@
+"""
+Local Embedding provider — delegates to Ollama HTTP API.
+
+Falls back to a deterministic hash-based stub when Ollama is unreachable.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+from urllib.request import Request, urlopen
+
+logger = logging.getLogger(__name__)
+
+
+class LocalEmbeddingProvider:
+    def __init__(
+        self,
+        ollama_url: str = "http://localhost:11434",
+        ollama_model: str = "embeddinggemma",
+        dimensions: int = 768,
+        runtime: str = "auto",
+    ) -> None:
+        self._ollama_url = ollama_url.rstrip("/")
+        self._ollama_model = ollama_model
+        self._dimensions = dimensions
+        self._runtime = runtime
+
+    @property
+    def runtime(self) -> str:
+        runtime = self._runtime
+        if runtime == "auto":
+            try:
+                req = Request(f"{self._ollama_url}/api/tags", method="GET")
+                with urlopen(req, timeout=3):
+                    return "ollama"
+            except Exception:
+                return "mock"
+        return runtime
+
+    def embed(self, text: str) -> list[float]:
+        if self.runtime == "ollama":
+            embedded = self._embed_with_ollama(text)
+            if embedded is not None:
+                return embedded[: self._dimensions]
+        # Deterministic hash-based fallback
+        digest = hashlib.sha256(text.encode("utf-8")).digest()
+        values: list[float] = []
+        for index in range(self._dimensions):
+            byte = digest[index % len(digest)]
+            values.append(round(byte / 255.0, 6))
+        return values
+
+    def _embed_with_ollama(self, text: str) -> list[float] | None:
+        payload = {
+            "model": self._ollama_model,
+            "input": text,
+        }
+        data = json.dumps(payload).encode()
+        req = Request(
+            f"{self._ollama_url}/api/embed",
+            data=data,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        try:
+            with urlopen(req, timeout=30) as resp:
+                body = json.loads(resp.read())
+            embeddings = body.get("embeddings", [])
+            if embeddings and isinstance(embeddings[0], list):
+                return [float(v) for v in embeddings[0]]
+            return None
+        except Exception:
+            logger.warning("Ollama embedding failed, using hash fallback")
+            return None

{minder_cli-0.2.5 → minder_cli-0.2.7}/src/minder/graph/graph.py

@@ -58,7 +58,8 @@ class MinderGraph:
         self._planning = planning or PlanningNode()
         vector_store = VectorStore(store, store)
         embedder = LocalEmbeddingProvider(
-            config.embedding.model_path,
+            ollama_url=config.embedding.ollama_url,
+            ollama_model=config.embedding.ollama_model,
             dimensions=config.embedding.dimensions,
             runtime="auto",
         )
@@ -72,8 +73,8 @@ class MinderGraph:
         self._reasoning = reasoning or ReasoningNode()
         self._llm = llm or LLMNode(
             primary=LocalModelLLM(
-                config.llm.model_path,
-                runtime="auto",
+                ollama_url=config.llm.ollama_url,
+                ollama_model=config.llm.ollama_model,
                 context_length=config.llm.context_length,
             ),
             fallback=OpenAIFallbackLLM(

minder_cli-0.2.7/src/minder/llm/local.py

@@ -0,0 +1,233 @@
+"""
+Local LLM provider — delegates inference to an Ollama HTTP server.
+
+Ollama must be running and accessible at the configured URL (default
+``http://localhost:11434``).  The provider gracefully falls back to a
+deterministic text stub when Ollama is unreachable so that the rest of
+the Minder pipeline can still operate.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from collections.abc import Generator
+from urllib.request import Request, urlopen
+
+from minder.graph.state import GraphState
+
+logger = logging.getLogger(__name__)
+
+
+class LocalModelLLM:
+
+    def __init__(
+        self,
+        ollama_url: str = "http://localhost:11434",
+        ollama_model: str = "gemma3:4b",
+        fail: bool = False,
+        context_length: int = 131072,
+    ) -> None:
+        self._ollama_url = ollama_url.rstrip("/")
+        self._ollama_model = ollama_model
+        self._fail = fail
+        self._context_length = max(512, context_length)
+
+    @property
+    def runtime(self) -> str:
+        if self._fail:
+            return "mock"
+        try:
+            req = Request(f"{self._ollama_url}/api/tags", method="GET")
+            with urlopen(req, timeout=3):
+                return "ollama"
+        except Exception:
+            return "mock"
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def generate(self, state: GraphState) -> dict[str, object]:
+        if self._fail:
+            raise RuntimeError("Local model unavailable")
+
+        runtime = self.runtime
+        source_paths = [doc["path"] for doc in state.reranked_docs[:3]]
+        guidance = state.workflow_context.get("guidance", "")
+        fallback = (
+            f"{guidance}\n"
+            f"Plan intent: {state.plan.get('intent', 'unknown')}.\n"
+            f"Answer: grounded response for '{state.query}'.\n"
+            f"Sources: {', '.join(source_paths) if source_paths else 'none'}."
+        )
+
+        text = fallback
+        if runtime == "ollama":
+            text = self._generate_with_ollama(state, fallback=fallback)
+
+        return {
+            "text": text,
+            "sources": source_paths,
+            "provider": "local_llm",
+            "model": self._ollama_model,
+            "runtime": runtime,
+            "stream": [line for line in text.splitlines() if line],
+        }
+
+    def stream_generate(
+        self, state: GraphState
+    ) -> Generator[dict[str, object], None, None]:
+        if self._fail:
+            raise RuntimeError("Local model unavailable")
+
+        runtime = self.runtime
+        source_paths = [doc["path"] for doc in state.reranked_docs[:3]]
+        guidance = state.workflow_context.get("guidance", "")
+        fallback = (
+            f"{guidance}\n"
+            f"Plan intent: {state.plan.get('intent', 'unknown')}.\n"
+            f"Answer: grounded response for '{state.query}'.\n"
+            f"Sources: {', '.join(source_paths) if source_paths else 'none'}."
+        )
+
+        if runtime != "ollama":
+            if fallback:
+                yield {"type": "chunk", "delta": fallback}
+            yield {
+                "type": "result",
+                "result": self._build_result(fallback, source_paths, runtime),
+            }
+            return
+
+        deltas: list[str] = []
+        try:
+            for delta in self._stream_ollama(str(state.query)):
+                deltas.append(delta)
+                yield {"type": "chunk", "delta": delta}
+        except Exception:
+            logger.warning("Ollama stream failed, using fallback")
+            if fallback:
+                yield {"type": "chunk", "delta": fallback}
+            deltas = [fallback] if fallback else []
+
+        text = "".join(deltas).strip() or fallback
+        yield {
+            "type": "result",
+            "result": self._build_result(text, source_paths, runtime, deltas),
+        }
+
+    def complete_text(
+        self,
+        prompt: str,
+        *,
+        max_tokens: int = 512,
+        temperature: float = 0.1,
+        fallback: str = "",
+    ) -> str:
+        if self._fail:
+            raise RuntimeError("Local model unavailable")
+
+        if self.runtime != "ollama":
+            return fallback
+
+        try:
+            return self._chat_ollama(prompt, max_tokens=max_tokens, temperature=temperature)
+        except Exception:
+            logger.warning("Ollama completion failed, using fallback")
+            return fallback
+
+    # ------------------------------------------------------------------
+    # Ollama HTTP helpers
+    # ------------------------------------------------------------------
+
+    def _chat_ollama(
+        self,
+        prompt: str,
+        *,
+        max_tokens: int = 512,
+        temperature: float = 0.1,
+    ) -> str:
+        payload = {
+            "model": self._ollama_model,
+            "messages": [{"role": "user", "content": prompt}],
+            "stream": False,
+            "options": {
+                "temperature": temperature,
+                "num_predict": max_tokens,
+                "num_ctx": self._context_length,
+            },
+        }
+        data = json.dumps(payload).encode()
+        req = Request(
+            f"{self._ollama_url}/api/chat",
+            data=data,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        with urlopen(req, timeout=120) as resp:
+            body = json.loads(resp.read())
+        return body.get("message", {}).get("content", "").strip()
+
+    def _stream_ollama(
+        self,
+        prompt: str,
+        *,
+        max_tokens: int = 256,
+        temperature: float = 0.1,
+    ) -> Generator[str, None, None]:
+        payload = {
+            "model": self._ollama_model,
+            "messages": [{"role": "user", "content": prompt}],
+            "stream": True,
+            "options": {
+                "temperature": temperature,
+                "num_predict": max_tokens,
+                "num_ctx": self._context_length,
+            },
+        }
+        data = json.dumps(payload).encode()
+        req = Request(
+            f"{self._ollama_url}/api/chat",
+            data=data,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        with urlopen(req, timeout=120) as resp:
+            for line in resp:
+                if not line:
+                    continue
+                chunk = json.loads(line)
+                content = chunk.get("message", {}).get("content", "")
+                if content:
+                    yield content
+
+    def _generate_with_ollama(self, state: GraphState, *, fallback: str) -> str:
+        reasoning_output = getattr(state, "reasoning_output", {}) or {}
+        prompt = reasoning_output.get("prompt") or state.query
+        return self.complete_text(
+            str(prompt),
+            max_tokens=256,
+            temperature=0.1,
+            fallback=fallback,
+        )
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def _build_result(
+        self,
+        text: str,
+        source_paths: list[str],
+        runtime: str,
+        stream: list[str] | None = None,
+    ) -> dict[str, object]:
+        return {
+            "text": text,
+            "sources": source_paths,
+            "provider": "local_llm",
+            "model": self._ollama_model,
+            "runtime": runtime,
+            "stream": stream if stream else ([text] if text else []),
+        }

{minder_cli-0.2.5 → minder_cli-0.2.7}/src/minder/presentation/http/admin/memories.py

@@ -140,7 +140,8 @@ def build_memories_routes(context: AdminRouteContext) -> list[BaseRoute]:
             if "title" in update_data or "content" in update_data:
                 config = _config_from_request(request)
                 embedder = LocalEmbeddingProvider(
-                    config.embedding.model_path,
+                    ollama_url=config.embedding.ollama_url,
+                    ollama_model=config.embedding.ollama_model,
                     dimensions=min(config.embedding.dimensions, 16),
                     runtime="auto",
                 )

{minder_cli-0.2.5 → minder_cli-0.2.7}/src/minder/presentation/http/admin/search.py

@@ -73,7 +73,8 @@ def _rank_serialized_items(
         return items
 
     embedder = LocalEmbeddingProvider(
-        config.embedding.model_path,
+        ollama_url=config.embedding.ollama_url,
+        ollama_model=config.embedding.ollama_model,
         dimensions=min(config.embedding.dimensions, 16),
         runtime="auto",
     )
@@ -108,7 +109,8 @@ def _rank_skill_items(
         return items
 
     embedder = LocalEmbeddingProvider(
-        config.embedding.model_path,
+        ollama_url=config.embedding.ollama_url,
+        ollama_model=config.embedding.ollama_model,
         dimensions=min(config.embedding.dimensions, 16),
         runtime="auto",
     )

{minder_cli-0.2.5 → minder_cli-0.2.7}/src/minder/prompts/formatter.py

@@ -89,8 +89,8 @@ def polish_prompt_draft(
 
     polished = _heuristic_polish(draft)
     llm = LocalModelLLM(
-        config.llm.model_path,
-        runtime="auto",
+        ollama_url=config.llm.ollama_url,
+        ollama_model=config.llm.ollama_model,
         context_length=config.llm.context_length,
     )
     runtime = llm.runtime
@@ -118,7 +118,7 @@ Make the prompt direct, structured, and useful for a coding workflow.
     if not parsed:
         return polished, {
             "provider": "heuristic",
-            "model": config.llm.model_name,
+            "model": config.llm.ollama_model,
             "runtime": runtime,
         }
 

{minder_cli-0.2.5 → minder_cli-0.2.7}/src/minder/server.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import asyncio
 import sys
-from pathlib import Path
 
 from minder.bootstrap.providers import (
     build_cache,
@@ -33,12 +32,13 @@ __all__ = [
 
 def runtime_summary(config: Settings) -> dict[str, object]:
     llm = LocalModelLLM(
-        config.llm.model_path,
-        runtime="auto",
+        ollama_url=config.llm.ollama_url,
+        ollama_model=config.llm.ollama_model,
         context_length=config.llm.context_length,
     )
     embedder = LocalEmbeddingProvider(
-        config.embedding.model_path,
+        ollama_url=config.embedding.ollama_url,
+        ollama_model=config.embedding.ollama_model,
         dimensions=config.embedding.dimensions,
         runtime="auto",
     )
@@ -53,10 +53,14 @@ def runtime_summary(config: Settings) -> dict[str, object]:
         "orchestration_runtime_effective": graph_runtime_name(
             config.workflow.orchestration_runtime
         ),
-        "llm_model_path": str(Path(config.llm.model_path).expanduser()),
+        "llm_provider": config.llm.provider,
+        "llm_ollama_url": config.llm.ollama_url,
+        "llm_ollama_model": config.llm.ollama_model,
         "llm_runtime_effective": llm.runtime,
         "llm_context_length": config.llm.context_length,
-        "embedding_model_path": str(Path(config.embedding.model_path).expanduser()),
+        "embedding_provider": config.embedding.provider,
+        "embedding_ollama_url": config.embedding.ollama_url,
+        "embedding_ollama_model": config.embedding.ollama_model,
         "embedding_runtime_effective": embedder.runtime,
         "openai_fallback_configured": fallback.available(),
         "openai_fallback_runtime_effective": fallback.runtime,

{minder_cli-0.2.5 → minder_cli-0.2.7}/src/minder/store/milvus/client.py

@@ -5,7 +5,7 @@ Milvus Client — connection wrapper.
 from __future__ import annotations
 
 import asyncio
-from pymilvus import MilvusClient as PyMilvusClient  # type: ignore[import-untyped]
+from pymilvus import MilvusClient as PyMilvusClient  # type: ignore[import-not-found, import-untyped]
 
 
 class MilvusClient:

{minder_cli-0.2.5 → minder_cli-0.2.7}/src/minder/store/milvus/collections.py

@@ -1,7 +1,7 @@
 """
 Milvus Collections — schema definitions.
 """
-from pymilvus import CollectionSchema, DataType, FieldSchema  # type: ignore[import-untyped]
+from pymilvus import CollectionSchema, DataType, FieldSchema  # type: ignore[import-not-found, import-untyped]
 
 def get_document_schema(dimensions: int = 768) -> CollectionSchema:
     fields = [

{minder_cli-0.2.5 → minder_cli-0.2.7}/src/minder/tools/memory.py

@@ -19,7 +19,8 @@ class MemoryTools:
         self._store = store
         self._config = config
         self._embedder = LocalEmbeddingProvider(
-            config.embedding.model_path,
+            ollama_url=config.embedding.ollama_url,
+            ollama_model=config.embedding.ollama_model,
             dimensions=min(config.embedding.dimensions, 16),
             runtime="auto",
         )

{minder_cli-0.2.5 → minder_cli-0.2.7}/src/minder/tools/query.py

@@ -35,7 +35,8 @@ class QueryTools:
         self._graph = graph or MinderGraph(store, config)
         self._vector_store = vector_store or VectorStore(store, store)
         self._embedding_provider = LocalEmbeddingProvider(
-            config.embedding.model_path,
+            ollama_url=config.embedding.ollama_url,
+            ollama_model=config.embedding.ollama_model,
             dimensions=config.embedding.dimensions,
             runtime="auto",
         )
@@ -132,7 +133,7 @@ class QueryTools:
             "evaluation": result.evaluation,
             "provider": result.llm_output.get("provider"),
             "model": result.llm_output.get(
-                "model", result.llm_output.get("model_path")
+                "model", result.llm_output.get("ollama_model")
             ),
             "runtime": result.llm_output.get("runtime"),
             "orchestration_runtime": result.metadata.get("orchestration_runtime"),
@@ -237,7 +238,7 @@ class QueryTools:
             "evaluation": result.evaluation,
             "provider": result.llm_output.get("provider"),
             "model": result.llm_output.get(
-                "model", result.llm_output.get("model_path")
+                "model", result.llm_output.get("ollama_model")
             ),
             "runtime": result.llm_output.get("runtime"),
             "orchestration_runtime": result.metadata.get("orchestration_runtime"),

{minder_cli-0.2.5 → minder_cli-0.2.7}/src/minder/tools/skills.py

@@ -86,7 +86,8 @@ class SkillTools:
     def __init__(self, store: IOperationalStore, config: MinderConfig) -> None:
         self._store = store
         self._embedder = LocalEmbeddingProvider(
-            config.embedding.model_path,
+            ollama_url=config.embedding.ollama_url,
+            ollama_model=config.embedding.ollama_model,
             dimensions=min(config.embedding.dimensions, 16),
             runtime="auto",
         )