minder-cli 0.5.6__tar.gz → 0.5.7__tar.gz

{minder_cli-0.5.6 → minder_cli-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minder-cli
-Version: 0.5.6
+Version: 0.5.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

{minder_cli-0.5.6 → minder_cli-0.5.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "minder-cli"
-version = "0.5.6"
+version = "0.5.7"
 description = "Minder CLI is the command-line interface for the Minder self-hosted MCP platform."
 readme = "README.md"
 requires-python = ">=3.14"

{minder_cli-0.5.6 → minder_cli-0.5.7}/src/minder/application/admin/use_cases.py

@@ -373,6 +373,9 @@ class AdminConsoleUseCases:
             "antigravity": (
                 f'{{"mcpServers":{{"minder":{{"serverUrl":"{base_url}/mcp","headers":{{"X-Minder-Client-Key":"<mkc_...>"}}}}}}}}'
             ),
+            "gemini": (
+                f'{{"mcpServers":{{"minder":{{"serverUrl":"{base_url}/mcp","headers":{{"X-Minder-Client-Key":"<mkc_...>"}}}}}}}}'
+            ),
             "cursor": (
                 f'{{"mcpServers":{{"minder":{{"url":"{base_url}/mcp","headers":{{"X-Minder-Client-Key":"<mkc_...>"}}}}}}}}'
             ),

{minder_cli-0.5.6 → minder_cli-0.5.7}/src/minder/bootstrap/transport.py

@@ -9,6 +9,7 @@ from minder.auth.service import AuthError
 from minder.auth.service import AuthService
 from minder.cache.providers import LRUCacheProvider
 from minder.config import MinderConfig
+from minder.graph import MinderGraph
 from minder.presentation.http.admin.routes import build_http_routes
 from minder.prompts import PromptRegistry
 from minder.resources import ResourceRegistry
@@ -45,13 +46,20 @@ def build_transport(
     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)
     graph_tools = GraphTools(graph_store, store)
+    shared_graph = MinderGraph(store, config, graph_tools=graph_tools)
+    workflow_tools = WorkflowTools(
+        store,
+        repo_state_store,
+        graph=shared_graph,
+        config=config,
+    )
     query_tools = QueryTools(
         store,
         config,
+        graph=shared_graph,
         vector_store=vector_store,
         graph_tools=graph_tools,
     )
@@ -302,12 +310,19 @@ def build_transport(
         )
 
     async def minder_workflow_step(
-        *, user=None, repo_id: str, repo_path: str
+        *,
+        user=None,
+        repo_id: str | None = None,
+        repo_path: str | None = None,
+        session_id: str | None = None,
+        decision: dict[str, Any] | None = None,
     ) -> dict[str, Any]:  # noqa: ANN001
         del user
         return await workflow_tools.minder_workflow_step(
-            repo_id=uuid.UUID(repo_id),
+            repo_id=uuid.UUID(repo_id) if repo_id else None,
             repo_path=repo_path,
+            session_id=uuid.UUID(session_id) if session_id else None,
+            decision=decision,
         )
 
     async def minder_workflow_update(

{minder_cli-0.5.6 → minder_cli-0.5.7}/src/minder/config.py

@@ -92,6 +92,24 @@ class RetrievalConfig(BaseModel):
     hybrid_alpha: float = 0.7
 
 
+class MemoryConfig(BaseModel):
+    agentic_recall: bool = False
+    recall_min_score: float = 0.4
+    recall_max_iterations: int = 3
+
+
+class SessionConfig(BaseModel):
+    agentic_restore: bool = False
+    restore_recall_count: int = 8
+
+
+class GraphConfig(BaseModel):
+    runtime: str = "langgraph"
+    enable_parallel_retrieval: bool = False
+    enable_checkpointing: bool = True
+    checkpoint_ttl_days: int = 7
+
+
 class CacheConfig(BaseModel):
     enabled: bool = True
     provider: str = "redis"  # "redis" is the only supported runtime backend
@@ -145,6 +163,9 @@ class Settings(BaseSettings):
     mongodb: MongoDBConfig = Field(default_factory=MongoDBConfig)
     redis: RedisConfig = Field(default_factory=RedisConfig)
     retrieval: RetrievalConfig = Field(default_factory=RetrievalConfig)
+    memory: MemoryConfig = Field(default_factory=MemoryConfig)
+    session: SessionConfig = Field(default_factory=SessionConfig)
+    graph: GraphConfig = Field(default_factory=GraphConfig)
     cache: CacheConfig = Field(default_factory=CacheConfig)
     rate_limit: RateLimitConfig = Field(default_factory=RateLimitConfig)
     verification: VerificationConfig = Field(default_factory=VerificationConfig)

{minder_cli-0.5.6 → minder_cli-0.5.7}/src/minder/embedding/local.py

@@ -13,7 +13,7 @@ import math
 from collections import OrderedDict
 from typing import Any
 
-from minder.runtime import llama_cpp_usable
+from minder.runtime import get_writable_hf_cache_dir, llama_cpp_usable
 
 logger = logging.getLogger(__name__)
 
@@ -61,11 +61,16 @@ class LocalEmbeddingProvider:
             from llama_cpp import Llama
 
             logger.info("Initializing Llama.cpp embedding engine for %s", self._model_repo)
+            cache_dir = get_writable_hf_cache_dir()
+            cache_kwargs: dict[str, Any] = (
+                {} if cache_dir is None else {"cache_dir": cache_dir}
+            )
             self._model = Llama.from_pretrained(
                 repo_id=self._model_repo,
                 filename=self._model_file,
                 embedding=True,
                 verbose=False,
+                **cache_kwargs,
             )
             _MODEL_CACHE[cache_key] = self._model
         except Exception as e:

{minder_cli-0.5.6 → minder_cli-0.5.7}/src/minder/graph/__init__.py

@@ -1,6 +1,6 @@
-from .state import GraphState
+from .state import GraphState, GraphStateSchema
 
-__all__ = ["GraphState", "MinderGraph"]
+__all__ = ["GraphState", "GraphStateSchema", "MinderGraph"]
 
 
 def __getattr__(name: str):

minder_cli-0.5.7/src/minder/graph/checkpoint.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator, Sequence
+import zlib
+from typing import Any
+
+from langgraph.checkpoint.base import (
+    BaseCheckpointSaver,
+    Checkpoint,
+    CheckpointMetadata,
+    CheckpointTuple,
+)
+from langchain_core.runnables import RunnableConfig
+
+from minder.store.interfaces import IOperationalStore
+
+
+class MinderCheckpointSaver(BaseCheckpointSaver):
+    def __init__(self, store: IOperationalStore) -> None:
+        super().__init__()
+        self._store = store
+
+    async def aget_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
+        configurable = config.get("configurable", {})
+        thread_id = configurable.get("thread_id")
+        if not thread_id:
+            return None
+
+        # Check if the store implements ICheckpointRepository
+        if not hasattr(self._store, "get_checkpoint"):
+            return None
+
+        data = await self._store.get_checkpoint(thread_id)
+        if data is None:
+            return None
+
+        metadata = data.get("metadata", {})
+        type_name = metadata.pop("_checkpoint_type", "msgpack")
+        payload = bytes(data["checkpoint"])
+        if metadata.pop("_checkpoint_compression", None) == "zlib":
+            payload = zlib.decompress(payload)
+        checkpoint = self.serde.loads_typed((type_name, payload))
+        
+        return CheckpointTuple(
+            config=config,
+            checkpoint=checkpoint,
+            metadata=metadata,
+            parent_config=None,  # We don't track full history trees in simple setup
+        )
+
+    async def aput(
+        self,
+        config: RunnableConfig,
+        checkpoint: Checkpoint,
+        metadata: CheckpointMetadata,
+        new_versions: dict[str, str | float | int],
+    ) -> RunnableConfig:
+        configurable = config.get("configurable", {})
+        thread_id = configurable.get("thread_id")
+        if not thread_id:
+            return config
+
+        if not hasattr(self._store, "save_checkpoint"):
+            return config
+
+        type_name, payload = self.serde.dumps_typed(checkpoint)
+        payload = zlib.compress(payload)
+        db_metadata = dict(metadata or {})
+        db_metadata["_checkpoint_type"] = type_name
+        db_metadata["_checkpoint_compression"] = "zlib"
+
+        await self._store.save_checkpoint(
+            thread_id=thread_id,
+            checkpoint_id=checkpoint["id"],
+            checkpoint=payload,
+            metadata=db_metadata,
+        )
+        
+        return {
+            "configurable": {
+                "thread_id": thread_id,
+                "checkpoint_ns": configurable.get("checkpoint_ns", ""),
+                "checkpoint_id": checkpoint["id"],
+            }
+        }
+
+    async def alist(
+        self,
+        config: RunnableConfig | None,
+        *,
+        filter: dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
+    ) -> AsyncGenerator[CheckpointTuple, None]:
+        if config is None:
+            return
+            
+        configurable = config.get("configurable", {})
+        thread_id = configurable.get("thread_id")
+        if not thread_id:
+            return
+
+        if not hasattr(self._store, "list_checkpoints"):
+            return
+
+        records = await self._store.list_checkpoints(thread_id, limit=limit or 10)
+        for record in records:
+            metadata = record.get("metadata", {})
+            type_name = metadata.pop("_checkpoint_type", "msgpack")
+            payload = bytes(record["checkpoint"])
+            if metadata.pop("_checkpoint_compression", None) == "zlib":
+                payload = zlib.decompress(payload)
+            checkpoint = self.serde.loads_typed((type_name, payload))
+            yield CheckpointTuple(
+                config={
+                    "configurable": {
+                        "thread_id": thread_id,
+                        "checkpoint_ns": configurable.get("checkpoint_ns", ""),
+                        "checkpoint_id": record["checkpoint_id"],
+                    }
+                },
+                checkpoint=checkpoint,
+                metadata=metadata,
+                parent_config=None,
+            )
+
+    async def aput_writes(
+        self,
+        config: RunnableConfig,
+        writes: Sequence[tuple[str, Any]],
+        task_id: str,
+        task_path: str = "",
+    ) -> None:
+        # We only persist full checkpoints for Minder's workflow right now.
+        # LangGraph requires this method, but for simple state sync it can be a no-op
+        # unless fine-grained node-level recovery is needed.
+        pass
+
+    # Note: Sync versions of these methods must be implemented but can just raise NotImplementedError
+    # since we only use async langgraph execution (`ainvoke`).
+
+    def get_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
+        raise NotImplementedError("MinderCheckpointSaver only supports async.")
+
+    def put(
+        self,
+        config: RunnableConfig,
+        checkpoint: Checkpoint,
+        metadata: CheckpointMetadata,
+        new_versions: dict[str, str | float | int],
+    ) -> RunnableConfig:
+        raise NotImplementedError("MinderCheckpointSaver only supports async.")
+
+    def list(
+        self,
+        config: RunnableConfig | None,
+        *,
+        filter: dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
+    ):
+        raise NotImplementedError("MinderCheckpointSaver only supports async.")