mimir-crewai 0.1.1__tar.gz

mimir_crewai-0.1.1/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: mimir-crewai
+Version: 0.1.1
+Summary: Mimir persistent memory tool for CrewAI agents
+Author: Perseus Computing LLC
+License: MIT
+Project-URL: Homepage, https://github.com/Perseus-Computing-LLC/mimir
+Project-URL: Repository, https://github.com/Perseus-Computing-LLC/mimir
+Keywords: crewai,mimir,memory,mcp,agents
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: crewai>=0.30.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+
+# Mimir CrewAI Integration
+
+Persistent memory for CrewAI agents via Mimir.
+
+## Install
+
+Install from source (not yet published to PyPI):
+
+```bash
+pip install crewai
+pip install -e integrations/crewai/
+```
+
+## Quick Start
+
+```python
+from crewai import Agent, Task, Crew
+from mimir_crewai import MimirMemoryTool
+
+# Create the memory tool
+memory = MimirMemoryTool(
+    db_path="~/.mimir/data/crew.db"
+)
+
+# Give it to your agents
+researcher = Agent(
+    role="Senior Researcher",
+    goal="Find and analyze information",
+    backstory="Expert at gathering and synthesizing data",
+    tools=[memory],
+    verbose=True,
+)
+
+# Agents use it naturally
+task = Task(
+    description=(
+        "Research the competitor's pricing strategy. "
+        "Use Mimir Memory to recall any previous findings on this topic, "
+        "then remember your new conclusions."
+    ),
+    agent=researcher,
+    expected_output="A report with pricing analysis",
+)
+
+crew = Crew(agents=[researcher], tasks=[task])
+result = crew.kickoff()
+```
+
+## Available Actions
+
+| Action | Description | Parameters |
+|---|---|---|
+| `remember` | Store a fact or decision | `category`, `key`, `content`, `entity_type?` |
+| `recall` | Search stored memories | `query`, `category?`, `limit?` |
+| `journal` | Record a significant event | `event_type`, `description`, `context?` |
+| `context` | Get session context summary | (none) |
+
+## How It Works
+
+The `MimirMemoryTool` wraps Mimir's MCP tools as a CrewAI tool:
+
+- `remember` → `mimir_remember`
+- `recall` → `mimir_recall`
+- `journal` → `mimir_journal`
+- `context` → `mimir_context`
+
+All memories persist across sessions and crews. Agents can build up
+a shared knowledge base over time.
+
+## Requirements
+
+- Mimir v1.0.0+ (`curl -sSL https://raw.githubusercontent.com/Perseus-Computing-LLC/mimir/main/scripts/bootstrap.sh | bash`)
+- CrewAI >= 0.30.0
+- Python 3.10+

mimir_crewai-0.1.1/README.md

@@ -0,0 +1,74 @@
+# Mimir CrewAI Integration
+
+Persistent memory for CrewAI agents via Mimir.
+
+## Install
+
+Install from source (not yet published to PyPI):
+
+```bash
+pip install crewai
+pip install -e integrations/crewai/
+```
+
+## Quick Start
+
+```python
+from crewai import Agent, Task, Crew
+from mimir_crewai import MimirMemoryTool
+
+# Create the memory tool
+memory = MimirMemoryTool(
+    db_path="~/.mimir/data/crew.db"
+)
+
+# Give it to your agents
+researcher = Agent(
+    role="Senior Researcher",
+    goal="Find and analyze information",
+    backstory="Expert at gathering and synthesizing data",
+    tools=[memory],
+    verbose=True,
+)
+
+# Agents use it naturally
+task = Task(
+    description=(
+        "Research the competitor's pricing strategy. "
+        "Use Mimir Memory to recall any previous findings on this topic, "
+        "then remember your new conclusions."
+    ),
+    agent=researcher,
+    expected_output="A report with pricing analysis",
+)
+
+crew = Crew(agents=[researcher], tasks=[task])
+result = crew.kickoff()
+```
+
+## Available Actions
+
+| Action | Description | Parameters |
+|---|---|---|
+| `remember` | Store a fact or decision | `category`, `key`, `content`, `entity_type?` |
+| `recall` | Search stored memories | `query`, `category?`, `limit?` |
+| `journal` | Record a significant event | `event_type`, `description`, `context?` |
+| `context` | Get session context summary | (none) |
+
+## How It Works
+
+The `MimirMemoryTool` wraps Mimir's MCP tools as a CrewAI tool:
+
+- `remember` → `mimir_remember`
+- `recall` → `mimir_recall`
+- `journal` → `mimir_journal`
+- `context` → `mimir_context`
+
+All memories persist across sessions and crews. Agents can build up
+a shared knowledge base over time.
+
+## Requirements
+
+- Mimir v1.0.0+ (`curl -sSL https://raw.githubusercontent.com/Perseus-Computing-LLC/mimir/main/scripts/bootstrap.sh | bash`)
+- CrewAI >= 0.30.0
+- Python 3.10+

mimir_crewai-0.1.1/mimir_crewai/__init__.py

@@ -0,0 +1,234 @@
+"""
+CrewAI Mimir Memory Tool — provides persistent memory for CrewAI agents.
+
+Usage:
+    from crewai import Agent, Task, Crew
+    from mimir_crewai import MimirMemoryTool
+
+    memory = MimirMemoryTool(db_path="~/.mimir/data/crew.db")
+
+    agent = Agent(
+        role="Researcher",
+        goal="Find information",
+        tools=[memory],
+    )
+"""
+
+import json
+import subprocess
+import time
+from pathlib import Path
+from typing import Optional, Any
+from crewai.tools import BaseTool
+
+
+class MimirMemoryTool(BaseTool):
+    """CrewAI tool that provides persistent memory via Mimir.
+
+    Agents can remember facts, recall past decisions, and search
+    the knowledge base — all persisted across sessions and crews.
+
+    Available actions:
+        remember  — Store a fact or decision
+        recall    — Search stored memories
+        journal   — Record a significant event
+        context   — Get the current session context summary
+    """
+
+    name: str = "Mimir Memory"
+    description: str = (
+        "Persistent memory tool for storing and retrieving information "
+        "across sessions. Use this to remember facts, recall past "
+        "decisions, and maintain context between agent interactions.\n"
+        "Actions: remember(category, key, content), "
+        "recall(query, category?), "
+        "journal(event_type, description, context?), "
+        "context() — get session summary"
+    )
+
+    def __init__(
+        self,
+        binary: str = "mimir",
+        db_path: str = "~/.mimir/data/crew.db",
+        timeout: float = 30.0,
+        encryption_key: Optional[str] = None,
+    ):
+        super().__init__()
+        self.binary = binary
+        self.db_path = str(Path(db_path).expanduser())
+        self.timeout = timeout
+        self.encryption_key = encryption_key
+
+    @staticmethod
+    def _unwrap_result(result: dict) -> dict:
+        """Unwrap an MCP ``tools/call`` result into Mimir's payload dict.
+
+        Mimir returns the standard MCP envelope::
+
+            {"content": [{"type": "text", "text": "<json>"}],
+             "structuredContent": {...parsed json...}}
+
+        The payload (``items``, ``context`` ...) lives in ``structuredContent``
+        (preferred) or the JSON text of the first content block. Reading
+        ``result["items"]`` directly always yields nothing.
+        """
+        structured = result.get("structuredContent")
+        if isinstance(structured, dict):
+            return structured
+        content = result.get("content")
+        if isinstance(content, list) and content:
+            text = content[0].get("text", "") if isinstance(content[0], dict) else ""
+            try:
+                parsed = json.loads(text)
+            except (json.JSONDecodeError, TypeError):
+                return {}
+            if isinstance(parsed, dict):
+                return parsed
+        return {}
+
+    def _call_mimir(self, method: str, params: dict) -> dict:
+        """Call a Mimir MCP tool via stdio."""
+        args = [self.binary, "--db", self.db_path]
+        if self.encryption_key:
+            args.extend(["--encryption-key", self.encryption_key])
+
+        init_req = json.dumps({
+            "jsonrpc": "2.0", "id": 1,
+            "method": "initialize",
+            "params": {
+                "protocolVersion": "2024-11-05",
+                "capabilities": {},
+                "clientInfo": {"name": "crewai-mimir", "version": "1.0.0"},
+            },
+        })
+        call_req = json.dumps({
+            "jsonrpc": "2.0", "id": 2,
+            "method": "tools/call",
+            "params": {"name": method, "arguments": params},
+        })
+
+        proc = subprocess.Popen(
+            args,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        try:
+            stdout, _ = proc.communicate(
+                input=init_req + "\n" + call_req + "\n", timeout=self.timeout
+            )
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            proc.communicate()
+            return {"error": "timeout"}
+
+        response = None
+        for line in stdout.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                msg = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if isinstance(msg, dict) and msg.get("id") == 2:
+                response = msg
+                break
+
+        if response is None:
+            return {"error": "no response from mimir"}
+        if response.get("error"):
+            return {"error": response["error"]}
+        return self._unwrap_result(response.get("result", {}))
+
+    def _run(self, action: str, **kwargs) -> str:
+        """Execute a memory action.
+
+        Args:
+            action: One of 'remember', 'recall', 'journal', 'context'
+            **kwargs: Action-specific parameters
+        """
+        if action == "remember":
+            return self._remember(**kwargs)
+        elif action == "recall":
+            return self._recall(**kwargs)
+        elif action == "journal":
+            return self._journal(**kwargs)
+        elif action == "context":
+            return self._context()
+        else:
+            return f"Unknown action: {action}. Use: remember, recall, journal, context"
+
+    def _remember(
+        self,
+        category: str = "crewai",
+        key: str = "",
+        content: str = "",
+        entity_type: str = "fact",
+    ) -> str:
+        """Store a fact, decision, or piece of knowledge."""
+        result = self._call_mimir("mimir_remember", {
+            "category": category,
+            "key": key or f"auto-{int(time.time())}",
+            "body_json": json.dumps({"content": content}),
+            "type": entity_type,
+        })
+        if "error" in result:
+            return f"Failed to remember: {result['error']}"
+        return f"Remembered: [{category}] {key or 'auto'}: {content[:100]}"
+
+    def _recall(
+        self,
+        query: str = "",
+        category: str = "",
+        limit: int = 5,
+    ) -> str:
+        """Search stored memories."""
+        params = {"query": query, "limit": limit}
+        if category:
+            params["category"] = category
+
+        result = self._call_mimir("mimir_recall", params)
+        items = result.get("items", [])
+
+        if not items:
+            return f"No memories found for '{query}'"
+
+        lines = [f"Found {len(items)} memor{'y' if len(items)==1 else 'ies'}:"]
+        for item in items:
+            body = item.get("body_json", "{}")
+            try:
+                content = json.loads(body).get("content", body)
+            except (json.JSONDecodeError, TypeError):
+                content = body
+            lines.append(f"  [{item.get('category', '?')}] {item.get('key', '?')}: {content[:200]}")
+        return "\n".join(lines)
+
+    def _journal(
+        self,
+        event_type: str = "observation",
+        description: str = "",
+        context: str = "",
+    ) -> str:
+        """Record a significant event in the journal."""
+        result = self._call_mimir("mimir_journal", {
+            "event_type": event_type,
+            "category": "crewai",
+            "key": f"event-{int(time.time())}",
+            "evaluated": {"description": description, "context": context},
+        })
+        if "error" in result:
+            return f"Failed to journal: {result['error']}"
+        return f"Journaled {event_type}: {description[:100]}"
+
+    def _context(self) -> str:
+        """Get a summary of recent memories for session context."""
+        result = self._call_mimir("mimir_context", {})
+        if "error" in result:
+            return f"Failed to get context: {result['error']}"
+        context_text = result.get("context", "")
+        if not context_text:
+            return "No stored context. Use 'remember' to store information first."
+        # Return first 1000 chars to avoid overwhelming the agent
+        return context_text[:1000] + ("..." if len(context_text) > 1000 else "")

mimir_crewai-0.1.1/mimir_crewai.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: mimir-crewai
+Version: 0.1.1
+Summary: Mimir persistent memory tool for CrewAI agents
+Author: Perseus Computing LLC
+License: MIT
+Project-URL: Homepage, https://github.com/Perseus-Computing-LLC/mimir
+Project-URL: Repository, https://github.com/Perseus-Computing-LLC/mimir
+Keywords: crewai,mimir,memory,mcp,agents
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: crewai>=0.30.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+
+# Mimir CrewAI Integration
+
+Persistent memory for CrewAI agents via Mimir.
+
+## Install
+
+Install from source (not yet published to PyPI):
+
+```bash
+pip install crewai
+pip install -e integrations/crewai/
+```
+
+## Quick Start
+
+```python
+from crewai import Agent, Task, Crew
+from mimir_crewai import MimirMemoryTool
+
+# Create the memory tool
+memory = MimirMemoryTool(
+    db_path="~/.mimir/data/crew.db"
+)
+
+# Give it to your agents
+researcher = Agent(
+    role="Senior Researcher",
+    goal="Find and analyze information",
+    backstory="Expert at gathering and synthesizing data",
+    tools=[memory],
+    verbose=True,
+)
+
+# Agents use it naturally
+task = Task(
+    description=(
+        "Research the competitor's pricing strategy. "
+        "Use Mimir Memory to recall any previous findings on this topic, "
+        "then remember your new conclusions."
+    ),
+    agent=researcher,
+    expected_output="A report with pricing analysis",
+)
+
+crew = Crew(agents=[researcher], tasks=[task])
+result = crew.kickoff()
+```
+
+## Available Actions
+
+| Action | Description | Parameters |
+|---|---|---|
+| `remember` | Store a fact or decision | `category`, `key`, `content`, `entity_type?` |
+| `recall` | Search stored memories | `query`, `category?`, `limit?` |
+| `journal` | Record a significant event | `event_type`, `description`, `context?` |
+| `context` | Get session context summary | (none) |
+
+## How It Works
+
+The `MimirMemoryTool` wraps Mimir's MCP tools as a CrewAI tool:
+
+- `remember` → `mimir_remember`
+- `recall` → `mimir_recall`
+- `journal` → `mimir_journal`
+- `context` → `mimir_context`
+
+All memories persist across sessions and crews. Agents can build up
+a shared knowledge base over time.
+
+## Requirements
+
+- Mimir v1.0.0+ (`curl -sSL https://raw.githubusercontent.com/Perseus-Computing-LLC/mimir/main/scripts/bootstrap.sh | bash`)
+- CrewAI >= 0.30.0
+- Python 3.10+

mimir_crewai-0.1.1/mimir_crewai.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+./mimir_crewai/__init__.py
+mimir_crewai/__init__.py
+mimir_crewai.egg-info/PKG-INFO
+mimir_crewai.egg-info/SOURCES.txt
+mimir_crewai.egg-info/dependency_links.txt
+mimir_crewai.egg-info/requires.txt
+mimir_crewai.egg-info/top_level.txt
+tests/test_mimir_tool.py

mimir_crewai-0.1.1/mimir_crewai.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mimir_crewai-0.1.1/mimir_crewai.egg-info/requires.txt

@@ -0,0 +1,4 @@
+crewai>=0.30.0
+
+[dev]
+pytest

mimir_crewai-0.1.1/mimir_crewai.egg-info/top_level.txt

@@ -0,0 +1 @@
+mimir_crewai

mimir_crewai-0.1.1/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mimir-crewai"
+version = "0.1.1"
+description = "Mimir persistent memory tool for CrewAI agents"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Perseus Computing LLC" }]
+keywords = ["crewai", "mimir", "memory", "mcp", "agents"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "crewai>=0.30.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest"]
+
+[project.urls]
+Homepage = "https://github.com/Perseus-Computing-LLC/mimir"
+Repository = "https://github.com/Perseus-Computing-LLC/mimir"
+
+[tool.setuptools]
+packages = ["mimir_crewai"]
+package-dir = { "" = "." }

mimir_crewai-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mimir_crewai-0.1.1/tests/test_mimir_tool.py

@@ -0,0 +1,121 @@
+"""Tests for the CrewAI MimirMemoryTool.
+
+CrewAI (and its heavy dependency tree) need not be installed to exercise the
+Mimir wiring: we stub ``crewai.tools.BaseTool`` with a minimal base class, then
+drive the tool against Mimir's real MCP JSON-RPC envelope via a fake subprocess.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import types
+
+import pytest
+
+
+@pytest.fixture(scope="module")
+def MimirMemoryTool():
+    """Import MimirMemoryTool with a stubbed ``crewai.tools.BaseTool``."""
+    if "crewai" not in sys.modules:
+        crewai = types.ModuleType("crewai")
+        tools = types.ModuleType("crewai.tools")
+
+        class BaseTool:
+            name: str = ""
+            description: str = ""
+
+            def __init__(self, *args, **kwargs):
+                pass
+
+        tools.BaseTool = BaseTool
+        crewai.tools = tools
+        sys.modules["crewai"] = crewai
+        sys.modules["crewai.tools"] = tools
+
+    from mimir_crewai import MimirMemoryTool as tool_cls
+
+    return tool_cls
+
+
+def _fake_popen(routes):
+    class FakePopen:
+        last_input = None
+
+        def __init__(self, *args, **kwargs):
+            pass
+
+        def communicate(self, input=None, timeout=None):  # noqa: A002
+            FakePopen.last_input = input
+            call = next(
+                m
+                for m in (json.loads(line) for line in input.splitlines() if line)
+                if m.get("id") == 2
+            )
+            payload = routes[call["params"]["name"]](call["params"]["arguments"])
+            init_resp = json.dumps({"jsonrpc": "2.0", "id": 1, "result": {}})
+            tool_resp = json.dumps(
+                {
+                    "jsonrpc": "2.0",
+                    "id": 2,
+                    "result": {
+                        "content": [{"type": "text", "text": json.dumps(payload)}],
+                        "structuredContent": payload,
+                    },
+                }
+            )
+            return (init_resp + "\n" + tool_resp + "\n", "")
+
+        def kill(self):
+            pass
+
+    return FakePopen
+
+
+def test_remember_sends_type(monkeypatch, MimirMemoryTool):
+    captured = {}
+
+    def remember(args):
+        captured.update(args)
+        return {"id": "mem-1", "status": "ok"}
+
+    monkeypatch.setattr(
+        "mimir_crewai.subprocess.Popen", _fake_popen({"mimir_remember": remember})
+    )
+    tool = MimirMemoryTool()
+    out = tool._remember(category="crewai", key="k1", content="hello world")
+
+    assert captured.get("type") == "fact"  # regression: was the dropped "entity_type"
+    assert "entity_type" not in captured
+    assert json.loads(captured["body_json"]) == {"content": "hello world"}
+    assert "Remembered" in out
+
+
+def test_recall_parses_structured_items(monkeypatch, MimirMemoryTool):
+    def recall(args):
+        return {
+            "items": [
+                {
+                    "category": "crewai",
+                    "key": "k1",
+                    "body_json": json.dumps({"content": "the answer is 42"}),
+                }
+            ],
+            "total": 1,
+        }
+
+    monkeypatch.setattr(
+        "mimir_crewai.subprocess.Popen", _fake_popen({"mimir_recall": recall})
+    )
+    tool = MimirMemoryTool()
+    out = tool._recall(query="answer")
+
+    # Before the envelope-unwrap fix this returned "No memories found".
+    assert "Found 1 memory" in out
+    assert "the answer is 42" in out
+
+
+def test_unwrap_handles_text_only_envelope(MimirMemoryTool):
+    assert MimirMemoryTool._unwrap_result(
+        {"content": [{"type": "text", "text": json.dumps({"items": [1, 2]})}]}
+    ) == {"items": [1, 2]}