minder-cli 0.4.9__tar.gz → 0.5.1__tar.gz

{minder_cli-0.4.9 → minder_cli-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minder-cli
-Version: 0.4.9
+Version: 0.5.1
 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
@@ -19,10 +19,9 @@ Requires-Dist: fastapi>=0.136.0
 Requires-Dist: httpx>=0.28.0
 Provides-Extra: server
 Requires-Dist: aiosqlite>=0.21.0; extra == 'server'
-Requires-Dist: fastembed>=0.5.1; extra == 'server'
 Requires-Dist: langgraph>=1.1.8; extra == 'server'
 Requires-Dist: litellm>=1.83.1; extra == 'server'
-Requires-Dist: litert-lm-api-nightly>=0.10; extra == 'server'
+Requires-Dist: llama-cpp-python>=0.3.7; 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'
@@ -67,25 +66,22 @@ Developer → minder-cli → Minder Server ←→ AI agents (Codex / Copilot / C
                │
           ┌─────┴──────┐
           │            │
-       LiteRT-LM    FastEmbed
+       llama.cpp    llama.cpp
        (LLM gen)   (embedding)
 ```
 
-- **LLM inference**: LiteRT-LM (Google AI Edge) — on-device, hardware-accelerated, no HTTP overhead
-- **Embedding inference**: FastEmbed running natively in-process (`mxbai-embed-large-v1`) — zero-dependency ONNX acceleration
+- **LLM inference**: llama-cpp-python — GGUF models auto-downloaded from HuggingFace, hardware-accelerated (Metal on Mac, CPU elsewhere)
+- **Embedding inference**: llama-cpp-python — dedicated GGUF embedding model, in-process, no HTTP overhead
 
 ## Quick Start
 
 ### Run the server
 
 ```bash
-# 1. Download the LiteRT-LM model
-./scripts/download_models.sh
-
-# 2. Start infra (MongoDB + Redis + Milvus)
+# 1. Start infra (MongoDB + Redis + Milvus)
 docker compose -f docker/docker-compose.local.yml up -d
 
-# 3. Run Minder Server
+# 2. Run Minder Server (GGUF models auto-download on first start)
 uv run python -m minder.server
 ```
 

{minder_cli-0.4.9 → minder_cli-0.5.1}/README.md

@@ -27,25 +27,22 @@ Developer → minder-cli → Minder Server ←→ AI agents (Codex / Copilot / C
                │
           ┌─────┴──────┐
           │            │
-       LiteRT-LM    FastEmbed
+       llama.cpp    llama.cpp
        (LLM gen)   (embedding)
 ```
 
-- **LLM inference**: LiteRT-LM (Google AI Edge) — on-device, hardware-accelerated, no HTTP overhead
-- **Embedding inference**: FastEmbed running natively in-process (`mxbai-embed-large-v1`) — zero-dependency ONNX acceleration
+- **LLM inference**: llama-cpp-python — GGUF models auto-downloaded from HuggingFace, hardware-accelerated (Metal on Mac, CPU elsewhere)
+- **Embedding inference**: llama-cpp-python — dedicated GGUF embedding model, in-process, no HTTP overhead
 
 ## Quick Start
 
 ### Run the server
 
 ```bash
-# 1. Download the LiteRT-LM model
-./scripts/download_models.sh
-
-# 2. Start infra (MongoDB + Redis + Milvus)
+# 1. Start infra (MongoDB + Redis + Milvus)
 docker compose -f docker/docker-compose.local.yml up -d
 
-# 3. Run Minder Server
+# 2. Run Minder Server (GGUF models auto-download on first start)
 uv run python -m minder.server
 ```
 

{minder_cli-0.4.9 → minder_cli-0.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "minder-cli"
-version = "0.4.9"
+version = "0.5.1"
 description = "Minder CLI is the command-line interface for the Minder self-hosted MCP platform."
 readme = "README.md"
 requires-python = ">=3.14"
@@ -26,10 +26,9 @@ dependencies = [
 [project.optional-dependencies]
 server = [
     "aiosqlite>=0.21.0",
-    "fastembed>=0.5.1",
     "langgraph>=1.1.8",
     "litellm>=1.83.1",
-    "litert-lm-api-nightly>=0.10",
+    "llama-cpp-python>=0.3.7",
     "mcp>=1.26.0",
     "motor>=3.7.0",
     "passlib[bcrypt]>=1.7.4",

{minder_cli-0.4.9 → minder_cli-0.5.1}/src/minder/application/admin/use_cases.py

@@ -66,21 +66,19 @@ _UNSET: Any = object()  # sentinel for optional update fields
 DASHBOARD_TOOL_SCOPE_OPTIONS = [tool.name for tool in SCOPEABLE_TOOLS]
 
 DASHBOARD_TOOL_SCOPE_PRESETS: dict[str, list[str]] = {
-    "Query Only": ["minder_query", "minder_search_code", "minder_search_errors"],
+    "Query Only": ["minder_search_code", "minder_search_errors", "minder_memory_recall"],
     "Read Only": [
-        "minder_query",
         "minder_search_code",
         "minder_search_errors",
-        "minder_search",
         "minder_memory_recall",
+        "minder_skill_recall",
         "minder_workflow_get",
     ],
     "Full Dev Assistant": [
-        "minder_query",
         "minder_search_code",
         "minder_search_errors",
-        "minder_search",
         "minder_memory_recall",
+        "minder_skill_recall",
         "minder_workflow_get",
         "minder_workflow_step",
     ],

minder_cli-0.5.1/src/minder/bootstrap/agent_seeder.py

@@ -0,0 +1,25 @@
+"""Seed default SubAgent definitions on first startup."""
+
+from __future__ import annotations
+
+import logging
+
+from minder.store.interfaces import IOperationalStore
+from minder.tools.seeds.default_agents import DEFAULT_AGENTS
+
+logger = logging.getLogger(__name__)
+
+
+async def seed_default_agents(store: IOperationalStore) -> None:
+    """Insert default agents only if they do not already exist.
+
+    Never overwrites user-modified defaults — guards by name existence check.
+    """
+    for defn in DEFAULT_AGENTS:
+        name = defn["name"]
+        existing = await store.get_agent_by_name(name)
+        if existing is not None:
+            logger.debug("SubAgent %r already exists, skipping seed", name)
+            continue
+        await store.create_agent(**defn)
+        logger.info("Seeded default SubAgent: %r", name)

{minder_cli-0.4.9 → minder_cli-0.5.1}/src/minder/bootstrap/transport.py

@@ -19,12 +19,12 @@ from minder.store.interfaces import (
     IVectorStore,
 )
 from minder.store.repo_state import RepoStateStore
+from minder.tools.agents import AgentTools
 from minder.tools.auth import AuthTools
 from minder.tools.graph import GraphTools
 from minder.tools.memory import MemoryTools
 from minder.tools.query import QueryTools
 from minder.tools.registry import TOOL_DESCRIPTIONS
-from minder.tools.search import SearchTools
 from minder.tools.session import SessionTools
 from minder.tools.skills import SkillTools
 from minder.tools.workflow import WorkflowTools
@@ -42,12 +42,12 @@ def build_transport(
     auth_service = AuthService(store, config, cache=cache)
     cache_provider = cache or LRUCacheProvider()
     repo_state_store = RepoStateStore(config.workflow.repo_state_dir)
+    agent_tools = AgentTools(store)
     auth_tools = AuthTools(store, auth_service)
     session_tools = SessionTools(store)
     workflow_tools = WorkflowTools(store, repo_state_store)
     memory_tools = MemoryTools(store, config)
     skill_tools = SkillTools(store, config)
-    search_tools = SearchTools(store, config)
     graph_tools = GraphTools(graph_store, store)
     query_tools = QueryTools(
         store,
@@ -518,37 +518,6 @@ def build_transport(
             excerpt_kind=excerpt_kind,
         )
 
-    async def minder_search(
-        *, user=None, query: str, limit: int = 5
-    ) -> list[dict[str, Any]]:  # noqa: ANN001
-        del user
-        return await search_tools.minder_search(query, limit=limit)
-
-    async def minder_query(
-        *,
-        user=None,
-        principal: Principal | None = None,
-        query: str,
-        repo_path: str,
-        session_id: str | None = None,
-        repo_id: str | None = None,
-        workflow_name: str | None = None,
-    ) -> dict[str, Any]:  # noqa: ANN001
-        if user is None and principal is None:
-            raise AuthError("AUTH_MISSING_TOKEN", "Authenticated principal required")
-        ensure_client_repo_access(principal, repo_path=repo_path)
-        return await query_tools.minder_query(
-            query,
-            repo_path=repo_path,
-            session_id=uuid.UUID(session_id) if session_id else None,
-            user_id=user.id if user else None,
-            repo_id=uuid.UUID(repo_id) if repo_id else None,
-            workflow_name=workflow_name,
-            allowed_repo_scopes=(
-                principal.repo_scope if isinstance(principal, ClientPrincipal) else None
-            ),
-        )
-
     async def minder_search_code(
         *,
         user=None,
@@ -801,18 +770,6 @@ def build_transport(
         require_auth=True,
         description=TOOL_DESCRIPTIONS["minder_skill_import_git"],
     )
-    transport.register_tool(
-        "minder_search",
-        minder_search,
-        require_auth=True,
-        description=TOOL_DESCRIPTIONS["minder_search"],
-    )
-    transport.register_tool(
-        "minder_query",
-        minder_query,
-        require_auth=True,
-        description=TOOL_DESCRIPTIONS["minder_query"],
-    )
     transport.register_tool(
         "minder_search_code",
         minder_search_code,
@@ -838,6 +795,123 @@ def build_transport(
         description=TOOL_DESCRIPTIONS["minder_find_impact"],
     )
 
+    async def minder_agent_list(
+        *,
+        user=None,  # noqa: ANN001
+        workflow_step: str | None = None,
+        tag: str | None = None,
+        is_default: bool | None = None,
+    ) -> list[dict[str, Any]]:
+        del user
+        return await agent_tools.minder_agent_list(
+            workflow_step=workflow_step,
+            tag=tag,
+            is_default=is_default,
+        )
+
+    async def minder_agent_get(
+        *,
+        user=None,  # noqa: ANN001
+        name: str,
+    ) -> dict[str, Any] | None:
+        del user
+        return await agent_tools.minder_agent_get(name)
+
+    async def minder_agent_store(
+        *,
+        user=None,  # noqa: ANN001
+        name: str,
+        title: str,
+        description: str,
+        system_prompt: str,
+        tools: list[str] | None = None,
+        workflow_steps: list[str] | None = None,
+        artifact_types: list[str] | None = None,
+        tags: list[str] | None = None,
+        is_default: bool = False,
+    ) -> dict[str, Any]:
+        del user
+        return await agent_tools.minder_agent_store(
+            name,
+            title=title,
+            description=description,
+            system_prompt=system_prompt,
+            tools=tools,
+            workflow_steps=workflow_steps,
+            artifact_types=artifact_types,
+            tags=tags,
+            is_default=is_default,
+        )
+
+    async def minder_agent_update(
+        *,
+        user=None,  # noqa: ANN001
+        name: str,
+        title: str | None = None,
+        description: str | None = None,
+        system_prompt: str | None = None,
+        tools: list[str] | None = None,
+        workflow_steps: list[str] | None = None,
+        artifact_types: list[str] | None = None,
+        tags: list[str] | None = None,
+        is_default: bool | None = None,
+    ) -> dict[str, Any] | None:
+        del user
+        kwargs = {
+            k: v
+            for k, v in {
+                "title": title,
+                "description": description,
+                "system_prompt": system_prompt,
+                "tools": tools,
+                "workflow_steps": workflow_steps,
+                "artifact_types": artifact_types,
+                "tags": tags,
+                "is_default": is_default,
+            }.items()
+            if v is not None
+        }
+        return await agent_tools.minder_agent_update(name, **kwargs)
+
+    async def minder_agent_delete(
+        *,
+        user=None,  # noqa: ANN001
+        name: str,
+    ) -> dict[str, Any]:
+        del user
+        return await agent_tools.minder_agent_delete(name)
+
+    transport.register_tool(
+        "minder_agent_list",
+        minder_agent_list,
+        require_auth=True,
+        description=TOOL_DESCRIPTIONS["minder_agent_list"],
+    )
+    transport.register_tool(
+        "minder_agent_get",
+        minder_agent_get,
+        require_auth=True,
+        description=TOOL_DESCRIPTIONS["minder_agent_get"],
+    )
+    transport.register_tool(
+        "minder_agent_store",
+        minder_agent_store,
+        require_auth=True,
+        description=TOOL_DESCRIPTIONS["minder_agent_store"],
+    )
+    transport.register_tool(
+        "minder_agent_update",
+        minder_agent_update,
+        require_auth=True,
+        description=TOOL_DESCRIPTIONS["minder_agent_update"],
+    )
+    transport.register_tool(
+        "minder_agent_delete",
+        minder_agent_delete,
+        require_auth=True,
+        description=TOOL_DESCRIPTIONS["minder_agent_delete"],
+    )
+
     ResourceRegistry.register(transport.app, store, graph_store=graph_store)
     PromptRegistry.register(transport.app, store=store)
     return transport

{minder_cli-0.4.9 → minder_cli-0.5.1}/src/minder/config.py

@@ -31,21 +31,19 @@ class AuthConfig(BaseModel):
 
 
 class EmbeddingConfig(BaseModel):
-    provider: str = "fastembed"
-    runtime: str = "auto"  # "auto" | "fastembed" | "mock"
-    fastembed_model: str = "mixedbread-ai/mxbai-embed-large-v1"
-    fastembed_cache_dir: str = "~/.minder/cache/fastembed"
-    dimensions: int = 1024
+    provider: str = "llama_cpp"
+    runtime: str = "auto"  # "auto" | "llama_cpp" | "mock"
+    llama_cpp_model_repo: str = "ggml-org/embeddinggemma-300M-GGUF"
+    llama_cpp_model_file: str = "*.gguf"
+    dimensions: int = 768
     openai_api_key: Optional[str] = None
     openai_model: str = "text-embedding-3-small"
 
 
 class LLMConfig(BaseModel):
-    provider: str = "litert"  # "litert" | "openai"
-    # LiteRT-LM fields
-    litert_model_path: str = "~/.minder/models/gemma-4-E2B-it.litertlm"
-    litert_backend: str = "auto"  # "auto" (GPU on Mac, CPU elsewhere) | "cpu" | "gpu"
-    litert_cache_dir: str = "~/.minder/cache/litert"
+    provider: str = "llama_cpp"  # "llama_cpp" | "openai"
+    llama_cpp_model_repo: str = "ggml-org/gemma-4-E2B-it-GGUF"
+    llama_cpp_model_file: str = "*.gguf"
     context_length: int = 16384
     temperature: float = 0.1
     openai_api_key: Optional[str] = None

{minder_cli-0.4.9 → minder_cli-0.5.1}/src/minder/continuity.py

@@ -52,10 +52,10 @@ def allowed_tools_for_step(step_name: str | None) -> list[str]:
     if "test" in normalized:
         return base_tools + ["minder_search_code", "minder_search_errors"]
     if "implement" in normalized:
-        return base_tools + ["minder_search_code", "minder_query"]
+        return base_tools + ["minder_search_code", "minder_skill_recall"]
     if "review" in normalized:
-        return base_tools + ["minder_query", "minder_search_code"]
-    return base_tools + ["minder_search", "minder_search_code"]
+        return base_tools + ["minder_skill_recall", "minder_search_code"]
+    return base_tools + ["minder_memory_recall", "minder_search_code"]
 
 
 def forbidden_actions_for_step(
@@ -325,7 +325,7 @@ class ContinuitySynthesizer:
                 ).items()
             },
         }, {
-            "provider": "litert_lm",
+            "provider": self._config.llm.provider,
             "model": self._config.llm.provider,
             "runtime": self._llm.runtime,
         }

{minder_cli-0.4.9 → minder_cli-0.5.1}/src/minder/embedding/local.py

@@ -1,5 +1,5 @@
 """
-Local Embedding provider — delegates to FastEmbed using ONNX runtime.
+Local Embedding provider — delegates to llama-cpp-python using GGUF models.
 
 Falls back to a deterministic hash-based stub if initialization fails.
 """
@@ -11,9 +11,10 @@ import hashlib
 import logging
 import math
 from collections import OrderedDict
-from pathlib import Path
 from typing import Any
 
+from minder.runtime import llama_cpp_usable
+
 logger = logging.getLogger(__name__)
 
 
@@ -26,42 +27,53 @@ MAX_TEXT_LENGTH = 8000  # Safety truncation to avoid over-context (~2000 tokens)
 class LocalEmbeddingProvider:
     def __init__(
         self,
-        fastembed_model: str = "mixedbread-ai/mxbai-embed-large-v1",
-        fastembed_cache_dir: str = "~/.minder/cache/fastembed",
-        dimensions: int = 1024,
+        llama_cpp_model_repo: str = "ggml-org/embeddinggemma-300M-GGUF",
+        llama_cpp_model_file: str = "*Q4_K_M.gguf",
+        dimensions: int = 768,
         runtime: str = "auto",
     ) -> None:
-        self._model_name = fastembed_model
-        self._cache_dir = str(Path(fastembed_cache_dir).expanduser())
+        self._model_repo = llama_cpp_model_repo
+        self._model_file = llama_cpp_model_file
         self._dimensions = dimensions
         self._runtime = runtime
         self._model: Any | None = None
-        self._init_model()
+        self._initialized = False
+
+    def _ensure_initialized(self) -> None:
+        if not self._initialized:
+            self._init_model()
+            self._initialized = True
 
     def _init_model(self) -> None:
         if self._runtime == "mock":
             return
 
-        cache_key = f"{self._model_name}:{self._cache_dir}"
+        cache_key = f"{self._model_repo}:{self._model_file}"
         if cache_key in _MODEL_CACHE:
             self._model = _MODEL_CACHE[cache_key]
             return
 
+        if not llama_cpp_usable():
+            logger.warning(
+                "CPU does not support AVX2; llama.cpp unavailable. Using mock embedding."
+            )
+            return
+
         try:
-            from fastembed import TextEmbedding  # type: ignore[import-not-found]
-
-            # Optimize for speed and resource usage:
-            # - threads=4 limits CPU usage while maintaining good throughput
-            # - lazy_load=False ensures first request is fast
-            self._model = TextEmbedding(
-                model_name=self._model_name,
-                cache_dir=self._cache_dir,
-                threads=4,
+            from llama_cpp import Llama
+
+            logger.info("Initializing Llama.cpp embedding engine for %s", self._model_repo)
+            self._model = Llama.from_pretrained(
+                repo_id=self._model_repo,
+                filename=self._model_file,
+                embedding=True,
+                verbose=False,
             )
             _MODEL_CACHE[cache_key] = self._model
         except Exception as e:
             logger.warning(
-                f"Failed to initialize FastEmbed model {self._model_name}: {e}. Using mock."
+                "Failed to initialize Llama.cpp model %s: %s. Using mock.",
+                self._model_repo, e,
             )
             self._model = None
 
@@ -69,9 +81,10 @@ class LocalEmbeddingProvider:
     def runtime(self) -> str:
         if self._runtime != "auto":
             return self._runtime
-        return "fastembed" if self._model is not None else "mock"
+        return "llama_cpp" if self._model is not None else "mock"
 
     def embed(self, text: str) -> list[float]:
+        self._ensure_initialized()
         if not text:
             return [0.0] * self._dimensions
 
@@ -85,16 +98,14 @@ class LocalEmbeddingProvider:
 
         # 3. Perform embedding
         embedding: list[float]
-        if self.runtime == "fastembed" and self._model is not None:
+        if self.runtime == "llama_cpp" and self._model is not None:
             try:
-                # FastEmbed returns a generator of numpy arrays
-                embeddings = list(self._model.embed([safe_text]))
-                if embeddings:
-                    embedding = embeddings[0].tolist()[: self._dimensions]
-                else:
-                    embedding = self._hash_embed(safe_text)
+                # llama_cpp returns a dict with 'data'
+                result = self._model.create_embedding(safe_text)
+                vector = result["data"][0]["embedding"]
+                embedding = vector[: self._dimensions]
             except Exception as e:
-                logger.warning(f"FastEmbed failed during inference: {e}")
+                logger.warning(f"Llama.cpp failed during embedding inference: {e}")
                 embedding = self._hash_embed(safe_text)
         else:
             embedding = self._hash_embed(safe_text)
@@ -107,6 +118,7 @@ class LocalEmbeddingProvider:
         return embedding
 
     def embed_many(self, texts: list[str]) -> list[list[float]]:
+        self._ensure_initialized()
         if not texts:
             return []
 
@@ -130,17 +142,19 @@ class LocalEmbeddingProvider:
             return results
 
         # 2. Batch embed the missing ones
-        if self.runtime == "fastembed" and self._model is not None:
+        if self.runtime == "llama_cpp" and self._model is not None:
             try:
-                embeddings = list(self._model.embed(to_embed_texts))
+                # pass list of strings directly
+                res = self._model.create_embedding(to_embed_texts)
+                embeddings = [data["embedding"] for data in res["data"]]
                 for i, emb in enumerate(embeddings):
                     idx = to_embed_indices[i]
-                    vector = emb.tolist()[: self._dimensions]
+                    vector = emb[: self._dimensions]
                     results[idx] = vector
                     # Update cache
                     _EMBEDDING_CACHE[to_embed_texts[i]] = vector
             except Exception as e:
-                logger.warning(f"FastEmbed batch failed: {e}")
+                logger.warning(f"Llama.cpp batch embedding failed: {e}")
                 for i, idx in enumerate(to_embed_indices):
                     vector = self._hash_embed(to_embed_texts[i])
                     results[idx] = vector
@@ -178,7 +192,13 @@ class LocalEmbeddingProvider:
 def clear_caches() -> None:
     """Clear global model and embedding caches to reclaim memory."""
     global _MODEL_CACHE, _EMBEDDING_CACHE
+    for model in _MODEL_CACHE.values():
+        try:
+            if hasattr(model, "close"):
+                model.close()
+        except Exception:
+            pass
     _MODEL_CACHE.clear()
     _EMBEDDING_CACHE.clear()
     gc.collect()
-    logger.debug("Cleared FastEmbed global caches.")
+    logger.debug("Cleared Llama.cpp embedding global caches.")