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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minder-cli
-Version: 0.4.9
+Version: 0.5.0
 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'

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "minder-cli"
-version = "0.4.9"
+version = "0.5.0"
 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.0}/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.0}/src/minder/continuity.py

@@ -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.0}/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.")

minder_cli-0.5.0/src/minder/graph/executor.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from minder.graph.edges import determine_next_edge
+from minder.graph.nodes import (
+    ClarificationNode,
+    EvaluatorNode,
+    GuardNode,
+    LLMNode,
+    PlanningNode,
+    ReasoningNode,
+    RerankerNode,
+    ReflectionNode,
+    RetrieverNode,
+    VerificationNode,
+    WorkflowPlannerNode,
+)
+from minder.graph.runtime import graph_runtime_name, load_langgraph_state_graph
+from minder.graph.state import GraphState
+
+
+@dataclass
+class GraphNodes:
+    workflow_planner: WorkflowPlannerNode
+    planning: PlanningNode
+    clarification: ClarificationNode
+    retriever: RetrieverNode
+    reasoning: ReasoningNode
+    llm: LLMNode
+    guard: GuardNode
+    verification: VerificationNode
+    evaluator: EvaluatorNode
+    reranker: RerankerNode | None = field(default=None)
+    reflection: ReflectionNode | None = field(default=None)
+
+
+class InternalGraphExecutor:
+    def __init__(self, nodes: GraphNodes) -> None:
+        self._nodes = nodes
+
+    async def run(self, state: GraphState) -> GraphState:
+        max_attempts = int(state.metadata.get("max_attempts", 1))
+        state.metadata.setdefault("attempt_failures", [])
+        state.metadata["orchestration_runtime"] = "internal"
+        state = await self._nodes.workflow_planner.run(state)
+        state = self._nodes.planning.run(state)
+        state = self._nodes.clarification.run(state)
+        if state.metadata.get("needs_clarification"):
+            return state
+        state = await self._nodes.retriever.run(state)
+        if self._nodes.reranker is not None:
+            state = await self._nodes.reranker.run(state)
+
+        attempt = 0
+        while True:
+            attempt += 1
+            state.retry_count = attempt - 1
+            state = self._nodes.reasoning.run(state)
+            state = self._nodes.llm.run(state)
+            state = self._nodes.guard.run(state)
+            state = self._nodes.verification.run(state)
+            edge = determine_next_edge(state)
+            state.transition_log.append(
+                {
+                    "attempt": attempt,
+                    "edge": edge,
+                    "provider": state.llm_output.get("provider"),
+                    "fallback_used": state.metadata.get("fallback_used", False),
+                }
+            )
+            if (
+                edge not in {"verification_failed", "guard_failed"}
+                or attempt >= max_attempts
+            ):
+                break
+            retry_reason = (
+                "; ".join(
+                    str(reason)
+                    for reason in state.guard_result.get("reasons", [])
+                    if reason
+                )
+                if edge == "guard_failed"
+                else state.verification_result.get("stderr", "verification failed")
+            )
+            state.metadata["attempt_failures"].append(
+                {
+                    "attempt": attempt,
+                    "reason": retry_reason,
+                    "provider": state.llm_output.get("provider"),
+                    "edge": edge,
+                }
+            )
+            state.metadata["retry_reason"] = retry_reason
+
+        state = self._nodes.evaluator.run(state)
+        state.metadata["edge"] = determine_next_edge(state)
+
+        if self._nodes.reflection is not None:
+            state = await self._nodes.reflection.run(state)
+
+        return state
+
+
+class LangGraphExecutorAdapter:
+    def __init__(self, nodes: GraphNodes) -> None:
+        self._nodes = nodes
+        self._internal = InternalGraphExecutor(nodes)
+        self._compiled_graph = None
+
+    async def run(self, state: GraphState) -> GraphState:
+        if graph_runtime_name() != "langgraph":
+            state = await self._internal.run(state)
+            state.metadata["orchestration_runtime"] = "internal"
+            return state
+
+        compiled = self._compiled_graph or self._build_compiled_graph()
+        self._compiled_graph = compiled
+        
+        # StateGraph invocation
+        state.metadata.setdefault("attempt_failures", [])
+        result = await compiled.ainvoke(state)
+        
+        if isinstance(result, GraphState):
+            result.metadata["orchestration_runtime"] = "langgraph"
+            result.metadata["edge"] = determine_next_edge(result)
+            return result
+        validated = GraphState.model_validate(result)
+        validated.metadata["orchestration_runtime"] = "langgraph"
+        validated.metadata["edge"] = determine_next_edge(validated)
+        return validated
+
+    def _build_compiled_graph(self):
+        state_graph_cls = load_langgraph_state_graph()
+        if state_graph_cls is None:
+            raise RuntimeError(
+                "LangGraph runtime requested but StateGraph is unavailable"
+            )
+
+        workflow = state_graph_cls(GraphState)
+        
+        # 1. Add nodes
+        workflow.add_node("workflow_planner", self._nodes.workflow_planner.run)
+        workflow.add_node("planning", self._nodes.planning.run)
+        workflow.add_node("clarification", self._nodes.clarification.run)
+        workflow.add_node("retriever", self._nodes.retriever.run)
+        
+        if self._nodes.reranker is not None:
+            workflow.add_node("reranker", self._nodes.reranker.run)
+            
+        workflow.add_node("reasoning", self._node_reasoning_wrapper)
+        workflow.add_node("llm", self._nodes.llm.run)
+        workflow.add_node("guard", self._nodes.guard.run)
+        workflow.add_node("verification", self._nodes.verification.run)
+        workflow.add_node("evaluator", self._nodes.evaluator.run)
+        
+        if self._nodes.reflection is not None:
+            workflow.add_node("reflection", self._nodes.reflection.run)
+
+        # 2. Add Edges
+        workflow.set_entry_point("workflow_planner")
+        workflow.add_edge("workflow_planner", "planning")
+        workflow.add_edge("planning", "clarification")
+
+        def clarification_router(state: GraphState) -> str:
+            if state.metadata.get("needs_clarification"):
+                return "END"
+            return "retriever"
+        
+        workflow.add_conditional_edges("clarification", clarification_router, {"END": "__end__", "retriever": "retriever"})
+        
+        if self._nodes.reranker is not None:
+            workflow.add_edge("retriever", "reranker")
+            workflow.add_edge("reranker", "reasoning")
+        else:
+            workflow.add_edge("retriever", "reasoning")
+            
+        workflow.add_edge("reasoning", "llm")
+        workflow.add_edge("llm", "guard")
+        workflow.add_edge("guard", "verification")
+
+        def record_transition(state: GraphState) -> GraphState:
+            attempt = state.retry_count + 1
+            edge = determine_next_edge(state)
+            
+            new_log = list(state.transition_log)
+            new_log.append(
+                {
+                    "attempt": attempt,
+                    "edge": edge,
+                    "provider": state.llm_output.get("provider"),
+                    "fallback_used": state.metadata.get("fallback_used", False),
+                }
+            )
+            state.transition_log = new_log
+            
+            max_attempts = int(state.metadata.get("max_attempts", 1))
+            if edge in {"verification_failed", "guard_failed"} and attempt < max_attempts:
+                retry_reason = (
+                    "; ".join(
+                        str(reason)
+                        for reason in state.guard_result.get("reasons", [])
+                        if reason
+                    )
+                    if edge == "guard_failed"
+                    else state.verification_result.get("stderr", "verification failed")
+                )
+                if "attempt_failures" not in state.metadata:
+                    state.metadata["attempt_failures"] = []
+                    
+                state.metadata["attempt_failures"].append(
+                    {
+                        "attempt": attempt,
+                        "reason": retry_reason,
+                        "provider": state.llm_output.get("provider"),
+                        "edge": edge,
+                    }
+                )
+                state.metadata["retry_reason"] = retry_reason
+            return state
+
+        workflow.add_node("record_transition", record_transition)
+        workflow.add_edge("verification", "record_transition")
+
+        def check_attempt_loop(state: GraphState) -> str:
+            max_attempts = int(state.metadata.get("max_attempts", 1))
+            attempt = state.retry_count + 1
+            edge = determine_next_edge(state)
+            if edge not in {"verification_failed", "guard_failed"} or attempt >= max_attempts:
+                return "evaluator"
+            return "reasoning"
+
+        workflow.add_conditional_edges("record_transition", check_attempt_loop, {"reasoning": "reasoning", "evaluator": "evaluator"})
+        
+        if self._nodes.reflection is not None:
+            workflow.add_edge("evaluator", "reflection")
+            workflow.add_edge("reflection", "__end__")
+        else:
+            workflow.add_edge("evaluator", "__end__")
+            
+        return workflow.compile()
+
+    def _node_reasoning_wrapper(self, state: GraphState) -> GraphState:
+        if "attempt_failures" not in state.metadata:
+            state.metadata["attempt_failures"] = []
+        state.retry_count = len(state.metadata["attempt_failures"])
+        return self._nodes.reasoning.run(state)

{minder_cli-0.4.9 → minder_cli-0.5.0}/src/minder/graph/graph.py

@@ -61,8 +61,8 @@ class MinderGraph:
         self._clarification = clarification or ClarificationNode()
         vector_store = VectorStore(store, store)
         embedder = LocalEmbeddingProvider(
-            fastembed_model=config.embedding.fastembed_model,
-            fastembed_cache_dir=config.embedding.fastembed_cache_dir,
+            llama_cpp_model_repo=config.embedding.llama_cpp_model_repo,
+            llama_cpp_model_file=config.embedding.llama_cpp_model_file,
             dimensions=config.embedding.dimensions,
             runtime="auto",
         )

{minder_cli-0.4.9 → minder_cli-0.5.0}/src/minder/llm/__init__.py

@@ -1,11 +1,11 @@
 from .base import LLMClient
 from .factory import create_llm
-from .litert import LiteRTModelLLM
+from .llama_cpp_llm import LlamaCppLLM
 from .openai import OpenAIFallbackLLM
 
 __all__ = [
     "LLMClient",
-    "LiteRTModelLLM",
+    "LlamaCppLLM",
     "OpenAIFallbackLLM",
     "create_llm",
 ]

{minder_cli-0.4.9 → minder_cli-0.5.0}/src/minder/llm/factory.py

@@ -2,8 +2,7 @@
 LLM provider factory — selects the correct provider based on config.
 
 Supported providers:
-- ``litert``: LiteRT-LM (on-device, recommended for local LLM)
-
+- ``llama_cpp``: llama-cpp-python GGUF inference (on-device, recommended for local LLM)
 - ``openai``: OpenAI-compatible cloud API
 """
 
@@ -14,18 +13,16 @@ from minder.config import LLMConfig
 
 def create_llm(config: LLMConfig):  # type: ignore[no-untyped-def]
     """Create an LLM client from the given configuration."""
-    if config.provider == "litert":
-        from minder.llm.litert import LiteRTModelLLM
+    if config.provider == "llama_cpp":
+        from minder.llm.llama_cpp_llm import LlamaCppLLM
 
-        return LiteRTModelLLM(
-            model_path=config.litert_model_path,
-            backend=config.litert_backend,
-            cache_dir=config.litert_cache_dir,
+        return LlamaCppLLM(
+            model_repo=config.llama_cpp_model_repo,
+            model_file=config.llama_cpp_model_file,
             context_length=config.context_length,
+            temperature=config.temperature,
         )
 
-
-
     if config.provider == "openai":
         from minder.llm.openai import OpenAIFallbackLLM