crewai-memanto 0.1.0__tar.gz

crewai_memanto-0.1.0/.gitignore

@@ -0,0 +1,106 @@
+# Environment variables and secrets
+.env
+.env.local
+.env.*.local
+*.key
+*.pem
+*.crt
+secrets/
+.secrets
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+uv.lock
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+venv/
+.venv/
+ENV/
+env/
+.env/
+
+# IDEs
+.vscode/
+.idea/
+.claude/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Testing
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.log
+.pytest_cache/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# Logs
+logs/
+*.log
+pip-log.txt
+pip-delete-this-directory.txt
+
+# OS
+.DS_Store
+Thumbs.db
+Desktop.ini
+
+# Temporary files
+tmp/
+temp/
+*.tmp
+*.bak
+*.swp
+*.swo
+
+# Generated version file
+**/_version.py

crewai_memanto-0.1.0/PKG-INFO

@@ -0,0 +1,226 @@
+Metadata-Version: 2.4
+Name: crewai-memanto
+Version: 0.1.0
+Summary: CrewAI tools and integration for Memanto's persistent memory
+Author-email: Memanto <info@memanto.ai>
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: <4,>=3.10
+Requires-Dist: crewai>=0.80.0
+Requires-Dist: memanto>=0.1.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Description-Content-Type: text/markdown
+
+# CrewAI + Memanto: Persistent Multi-Agent Memory
+
+This package provides [CrewAI](https://github.com/joaomdmoura/crewai) tools for integrating [Memanto's](https://memanto.ai) persistent, cross-agent memory capabilities into your CrewAI pipelines. 
+
+## Installation
+
+```bash
+pip install crewai-memanto
+```
+
+---
+
+A real-world example of CrewAI agents using **Memanto** as their shared, persistent memory layer. Two agents collaborate through a semantic memory database that survives across sessions, agents, and runs.
+
+## What This Demonstrates
+
+- **Cross-agent memory sharing**: A Research Agent stores findings that a Writer Agent retrieves
+- **Cross-session persistence**: Run the researcher today, run the writer tomorrow -- memories persist
+- **Typed semantic memory**: 13 memory types (fact, observation, decision, etc.) with confidence scoring
+- **Contradictory memory handling**: Detect and resolve conflicting facts (bonus)
+
+## Architecture
+
+![CrewAI + Memanto: Persistent Multi-Agent Memory](https://github.com/moorcheh-ai/memanto/raw/main/assets/crewai-architecture.png)
+
+Both CrewAI agents share the **same Memanto agent ID** (`crewai-research-team`), giving them access to a shared memory namespace.
+
+## Prerequisites
+
+- Python 3.10+
+- A [Moorcheh API key](https://console.moorcheh.ai/api-keys) (free tier: 100K ops/month)
+- An [OpenRouter API key](https://openrouter.ai/keys) (for CrewAI's LLM — free tier available)
+
+## Setup
+
+```bash
+# 1. Clone the repo (if you haven't already)
+git clone https://github.com/moorcheh-ai/memanto.git
+cd memanto/examples/crewai-memory
+
+# 2. Create a virtual environment
+python -m venv venv
+source venv/bin/activate  # Windows: venv\Scripts\activate
+
+# 3. Install dependencies
+pip install -r requirements.txt
+
+# 4. Configure API keys
+cp .env.example .env
+# Edit .env and add your MOORCHEH_API_KEY and OPENROUTER_API_KEY
+```
+
+## Quick Start
+
+Run the full pipeline (Research Agent + Writer Agent) in one command:
+
+```bash
+python run_full_pipeline.py
+```
+
+## Step-by-Step Demo (Proves Persistence)
+
+This is the recommended flow for your terminal recording:
+
+```bash
+# Step 1: Research Agent stores findings in Memanto
+python run_research.py
+
+# Step 2: Writer Agent retrieves those memories in a NEW session
+# (This proves memories persist across sessions!)
+python run_writer.py
+
+# Step 3 (Bonus): Demonstrate contradictory memory handling
+python run_contradiction.py
+```
+
+## Architecture: Why Tool-Based Integration?
+
+CrewAI offers two ways to plug in external memory:
+
+1. **Native `StorageBackend` override** — Implement CrewAI's `StorageBackend` protocol and pass it via `Memory(storage=my_backend)`. CrewAI's memory pipeline (LLM analysis, consolidation, composite scoring) runs on top of your backend.
+
+2. **Tool-based integration** — Provide Memanto operations as CrewAI tools that agents call directly.
+
+**This example uses the tool-based approach.** Here's why:
+
+- **API mismatch**: CrewAI's `StorageBackend.search()` receives a pre-computed **vector embedding**. By the time it reaches the storage layer, the original query text is lost. Memanto's API performs semantic search from **natural language text**, not raw vectors. There's no clean way to bridge this gap without redundant embedding work or losing Memanto's search quality.
+
+- **Rich metadata**: The tool-based approach lets the LLM choose the right memory type (out of 13 semantic types), set confidence scores, and add tags at write time. A native backend override only receives what CrewAI's encoding pipeline extracts, which doesn't map to Memanto's type system.
+
+- **No dual memory risk**: We explicitly set `memory=False` on all Crews to prevent CrewAI from injecting its own LanceDB-backed memory tools alongside the Memanto tools. When `memory=True`, CrewAI auto-injects "Search memory" and "Save to memory" tools into every agent — running both systems would cause duplicate storage and retrieval confusion.
+
+> **Note**: Native `StorageBackend` integrations (like [Hindsight](https://hindsight.vectorize.io/) or [Mengram](https://community.crewai.com/t/mengram-human-like-memory-backend-for-crewai-pr-4595/7363)) work well when the external system accepts vector embeddings directly. Memanto's information-theoretic search operates on text, making the tool-based pattern the better fit.
+
+### Namespace Design
+
+All CrewAI agents in this example share a **single Memanto agent ID** (`crewai-research-team`), which maps to one Memanto namespace. This is intentional: the Research Agent stores findings and the Writer Agent retrieves them from the same namespace. Memanto's scope system (`memanto_agent_{agent_id}`) provides the isolation boundary — different crews or projects should use different agent IDs.
+
+## How to Swap CrewAI Memory for Memanto
+
+### Before: CrewAI's Built-in Memory
+
+```python
+from crewai import Crew
+
+# CrewAI's built-in memory uses LanceDB locally
+# When memory=True, CrewAI auto-injects "Search memory" and
+# "Save to memory" tools into every agent
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[research_task, writing_task],
+    memory=True,  # Uses LanceDB, lost when storage is cleared
+)
+```
+
+### After: Memanto Memory (Persistent)
+
+```python
+from memanto.cli.client.sdk_client import SdkClient
+from crewai_memanto import MemantoSetup, create_memanto_tools
+
+# 1. Set up Memanto (one-time per session)
+setup = MemantoSetup(api_key="your-moorcheh-key")
+client = setup.setup(agent_id="my-crew")
+
+# 2. Create memory tools bound to your agent
+tools = create_memanto_tools(client, agent_id="my-crew")
+
+# 3. Give agents Memanto tools instead of using memory=True
+researcher = Agent(
+    role="Researcher",
+    goal="Research and store findings",
+    backstory="...",
+    tools=[tools["remember"], tools["recall"]],  # Persistent memory!
+)
+
+writer = Agent(
+    role="Writer",
+    goal="Retrieve findings and write",
+    backstory="...",
+    tools=[tools["recall"], tools["answer"]],  # Reads persistent memory!
+)
+
+# 4. Run the crew with memory=False to prevent dual memory systems
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[...],
+    memory=False,  # Memanto handles memory via tools
+)
+crew.kickoff()
+```
+
+**Key differences:**
+| Feature | CrewAI Memory | Memanto Memory |
+|---------|---------------|----------------|
+| Persistence | Session only | Permanent |
+| Cross-agent | Same crew only | Any agent, any session |
+| Search | Embedding-based | Semantic (Moorcheh) |
+| Memory types | Untyped | 13 semantic types |
+| Confidence scoring | No | Yes (0.0-1.0) |
+| Conflict detection | No | Yes |
+| Cost at idle | N/A | Zero (serverless) |
+
+## File Structure
+
+```
+examples/crewai-memory/
+├── README.md              # This file
+├── requirements.txt       # Python dependencies
+├── .env.example           # API key template
+├── memanto_tools.py       # CrewAI Tool wrappers around Memanto SdkClient
+├── agents.py              # Research Agent + Writer Agent definitions
+├── tasks.py               # Task definitions
+├── crew.py                # Crew orchestration factories
+├── run_research.py        # Run 1: Research Agent stores findings
+├── run_writer.py          # Run 2: Writer Agent recalls (proves persistence)
+├── run_full_pipeline.py   # Full pipeline in one run
+└── run_contradiction.py   # Bonus: contradictory memory handling
+```
+
+## Bonus: Cursor Integration
+
+After running the CrewAI pipeline, you can access the same memories from Cursor:
+
+```bash
+# Connect Cursor to Memanto globally (all projects)
+memanto connect cursor --global
+
+# Or for a specific project directory
+memanto connect cursor --project-dir /path/to/your/project
+```
+
+This creates `.cursor/rules/memanto.mdc` (memory instructions) and `.cursor/skills/memanto/SKILL.md` (memory type guide). Open any project in Cursor and ask it to recall your research findings -- it accesses the same Memanto memory namespace used by the CrewAI agents.
+
+**Example Cursor prompt after running the CrewAI pipeline:**
+> "Use memanto recall to find what the research team stored about AI agent market size"
+
+## Troubleshooting
+
+- **"MOORCHEH_API_KEY not set"**: Copy `.env.example` to `.env` and add your key
+- **"No active session"**: The setup manager handles this automatically; check your API key is valid
+- **"Agent already exists"**: This is normal -- the setup reuses existing agents
+- **CrewAI LLM errors**: Ensure `OPENROUTER_API_KEY` is set, or override with `CREWAI_LLM` env var
+
+## Learn More
+
+- [Memanto Documentation](https://docs.memanto.ai)
+- [CrewAI Documentation](https://docs.crewai.com)
+- [Moorcheh API Keys](https://console.moorcheh.ai/api-keys)
+- [OpenRouter](https://openrouter.ai/) — unified LLM gateway (free tier available)

crewai_memanto-0.1.0/README.md

@@ -0,0 +1,210 @@
+# CrewAI + Memanto: Persistent Multi-Agent Memory
+
+This package provides [CrewAI](https://github.com/joaomdmoura/crewai) tools for integrating [Memanto's](https://memanto.ai) persistent, cross-agent memory capabilities into your CrewAI pipelines. 
+
+## Installation
+
+```bash
+pip install crewai-memanto
+```
+
+---
+
+A real-world example of CrewAI agents using **Memanto** as their shared, persistent memory layer. Two agents collaborate through a semantic memory database that survives across sessions, agents, and runs.
+
+## What This Demonstrates
+
+- **Cross-agent memory sharing**: A Research Agent stores findings that a Writer Agent retrieves
+- **Cross-session persistence**: Run the researcher today, run the writer tomorrow -- memories persist
+- **Typed semantic memory**: 13 memory types (fact, observation, decision, etc.) with confidence scoring
+- **Contradictory memory handling**: Detect and resolve conflicting facts (bonus)
+
+## Architecture
+
+![CrewAI + Memanto: Persistent Multi-Agent Memory](https://github.com/moorcheh-ai/memanto/raw/main/assets/crewai-architecture.png)
+
+Both CrewAI agents share the **same Memanto agent ID** (`crewai-research-team`), giving them access to a shared memory namespace.
+
+## Prerequisites
+
+- Python 3.10+
+- A [Moorcheh API key](https://console.moorcheh.ai/api-keys) (free tier: 100K ops/month)
+- An [OpenRouter API key](https://openrouter.ai/keys) (for CrewAI's LLM — free tier available)
+
+## Setup
+
+```bash
+# 1. Clone the repo (if you haven't already)
+git clone https://github.com/moorcheh-ai/memanto.git
+cd memanto/examples/crewai-memory
+
+# 2. Create a virtual environment
+python -m venv venv
+source venv/bin/activate  # Windows: venv\Scripts\activate
+
+# 3. Install dependencies
+pip install -r requirements.txt
+
+# 4. Configure API keys
+cp .env.example .env
+# Edit .env and add your MOORCHEH_API_KEY and OPENROUTER_API_KEY
+```
+
+## Quick Start
+
+Run the full pipeline (Research Agent + Writer Agent) in one command:
+
+```bash
+python run_full_pipeline.py
+```
+
+## Step-by-Step Demo (Proves Persistence)
+
+This is the recommended flow for your terminal recording:
+
+```bash
+# Step 1: Research Agent stores findings in Memanto
+python run_research.py
+
+# Step 2: Writer Agent retrieves those memories in a NEW session
+# (This proves memories persist across sessions!)
+python run_writer.py
+
+# Step 3 (Bonus): Demonstrate contradictory memory handling
+python run_contradiction.py
+```
+
+## Architecture: Why Tool-Based Integration?
+
+CrewAI offers two ways to plug in external memory:
+
+1. **Native `StorageBackend` override** — Implement CrewAI's `StorageBackend` protocol and pass it via `Memory(storage=my_backend)`. CrewAI's memory pipeline (LLM analysis, consolidation, composite scoring) runs on top of your backend.
+
+2. **Tool-based integration** — Provide Memanto operations as CrewAI tools that agents call directly.
+
+**This example uses the tool-based approach.** Here's why:
+
+- **API mismatch**: CrewAI's `StorageBackend.search()` receives a pre-computed **vector embedding**. By the time it reaches the storage layer, the original query text is lost. Memanto's API performs semantic search from **natural language text**, not raw vectors. There's no clean way to bridge this gap without redundant embedding work or losing Memanto's search quality.
+
+- **Rich metadata**: The tool-based approach lets the LLM choose the right memory type (out of 13 semantic types), set confidence scores, and add tags at write time. A native backend override only receives what CrewAI's encoding pipeline extracts, which doesn't map to Memanto's type system.
+
+- **No dual memory risk**: We explicitly set `memory=False` on all Crews to prevent CrewAI from injecting its own LanceDB-backed memory tools alongside the Memanto tools. When `memory=True`, CrewAI auto-injects "Search memory" and "Save to memory" tools into every agent — running both systems would cause duplicate storage and retrieval confusion.
+
+> **Note**: Native `StorageBackend` integrations (like [Hindsight](https://hindsight.vectorize.io/) or [Mengram](https://community.crewai.com/t/mengram-human-like-memory-backend-for-crewai-pr-4595/7363)) work well when the external system accepts vector embeddings directly. Memanto's information-theoretic search operates on text, making the tool-based pattern the better fit.
+
+### Namespace Design
+
+All CrewAI agents in this example share a **single Memanto agent ID** (`crewai-research-team`), which maps to one Memanto namespace. This is intentional: the Research Agent stores findings and the Writer Agent retrieves them from the same namespace. Memanto's scope system (`memanto_agent_{agent_id}`) provides the isolation boundary — different crews or projects should use different agent IDs.
+
+## How to Swap CrewAI Memory for Memanto
+
+### Before: CrewAI's Built-in Memory
+
+```python
+from crewai import Crew
+
+# CrewAI's built-in memory uses LanceDB locally
+# When memory=True, CrewAI auto-injects "Search memory" and
+# "Save to memory" tools into every agent
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[research_task, writing_task],
+    memory=True,  # Uses LanceDB, lost when storage is cleared
+)
+```
+
+### After: Memanto Memory (Persistent)
+
+```python
+from memanto.cli.client.sdk_client import SdkClient
+from crewai_memanto import MemantoSetup, create_memanto_tools
+
+# 1. Set up Memanto (one-time per session)
+setup = MemantoSetup(api_key="your-moorcheh-key")
+client = setup.setup(agent_id="my-crew")
+
+# 2. Create memory tools bound to your agent
+tools = create_memanto_tools(client, agent_id="my-crew")
+
+# 3. Give agents Memanto tools instead of using memory=True
+researcher = Agent(
+    role="Researcher",
+    goal="Research and store findings",
+    backstory="...",
+    tools=[tools["remember"], tools["recall"]],  # Persistent memory!
+)
+
+writer = Agent(
+    role="Writer",
+    goal="Retrieve findings and write",
+    backstory="...",
+    tools=[tools["recall"], tools["answer"]],  # Reads persistent memory!
+)
+
+# 4. Run the crew with memory=False to prevent dual memory systems
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[...],
+    memory=False,  # Memanto handles memory via tools
+)
+crew.kickoff()
+```
+
+**Key differences:**
+| Feature | CrewAI Memory | Memanto Memory |
+|---------|---------------|----------------|
+| Persistence | Session only | Permanent |
+| Cross-agent | Same crew only | Any agent, any session |
+| Search | Embedding-based | Semantic (Moorcheh) |
+| Memory types | Untyped | 13 semantic types |
+| Confidence scoring | No | Yes (0.0-1.0) |
+| Conflict detection | No | Yes |
+| Cost at idle | N/A | Zero (serverless) |
+
+## File Structure
+
+```
+examples/crewai-memory/
+├── README.md              # This file
+├── requirements.txt       # Python dependencies
+├── .env.example           # API key template
+├── memanto_tools.py       # CrewAI Tool wrappers around Memanto SdkClient
+├── agents.py              # Research Agent + Writer Agent definitions
+├── tasks.py               # Task definitions
+├── crew.py                # Crew orchestration factories
+├── run_research.py        # Run 1: Research Agent stores findings
+├── run_writer.py          # Run 2: Writer Agent recalls (proves persistence)
+├── run_full_pipeline.py   # Full pipeline in one run
+└── run_contradiction.py   # Bonus: contradictory memory handling
+```
+
+## Bonus: Cursor Integration
+
+After running the CrewAI pipeline, you can access the same memories from Cursor:
+
+```bash
+# Connect Cursor to Memanto globally (all projects)
+memanto connect cursor --global
+
+# Or for a specific project directory
+memanto connect cursor --project-dir /path/to/your/project
+```
+
+This creates `.cursor/rules/memanto.mdc` (memory instructions) and `.cursor/skills/memanto/SKILL.md` (memory type guide). Open any project in Cursor and ask it to recall your research findings -- it accesses the same Memanto memory namespace used by the CrewAI agents.
+
+**Example Cursor prompt after running the CrewAI pipeline:**
+> "Use memanto recall to find what the research team stored about AI agent market size"
+
+## Troubleshooting
+
+- **"MOORCHEH_API_KEY not set"**: Copy `.env.example` to `.env` and add your key
+- **"No active session"**: The setup manager handles this automatically; check your API key is valid
+- **"Agent already exists"**: This is normal -- the setup reuses existing agents
+- **CrewAI LLM errors**: Ensure `OPENROUTER_API_KEY` is set, or override with `CREWAI_LLM` env var
+
+## Learn More
+
+- [Memanto Documentation](https://docs.memanto.ai)
+- [CrewAI Documentation](https://docs.crewai.com)
+- [Moorcheh API Keys](https://console.moorcheh.ai/api-keys)
+- [OpenRouter](https://openrouter.ai/) — unified LLM gateway (free tier available)

crewai_memanto-0.1.0/crewai_memanto/__init__.py

@@ -0,0 +1,15 @@
+from .tools import (
+    MemantoAnswerTool,
+    MemantoRecallTool,
+    MemantoRememberTool,
+    MemantoSetup,
+    create_memanto_tools,
+)
+
+__all__ = [
+    "MemantoSetup",
+    "MemantoRememberTool",
+    "MemantoRecallTool",
+    "MemantoAnswerTool",
+    "create_memanto_tools",
+]

crewai_memanto-0.1.0/crewai_memanto/tools.py

@@ -0,0 +1,303 @@
+"""
+Memanto Tools for CrewAI
+
+CrewAI tool wrappers around Memanto's SdkClient for persistent,
+cross-agent memory operations. These tools let CrewAI agents store
+and retrieve memories that survive across sessions and agents.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
+
+from memanto.cli.client.sdk_client import SdkClient
+
+logger = logging.getLogger(__name__)
+
+# Valid Memanto memory types for reference in tool descriptions
+VALID_MEMORY_TYPES = (
+    "fact, preference, goal, decision, artifact, learning, event, "
+    "instruction, relationship, context, observation, commitment, error"
+)
+
+
+class MemantoSetup:
+    """
+    Manages Memanto agent lifecycle for CrewAI integration.
+
+    Handles agent creation, session activation, and teardown so that
+    CrewAI scripts can focus on task orchestration.
+    """
+
+    def __init__(self, api_key: str) -> None:
+        self.client = SdkClient(api_key=api_key)
+
+    def setup(
+        self,
+        agent_id: str,
+        pattern: str = "tool",
+        description: str | None = None,
+        duration_hours: int = 6,
+    ) -> SdkClient:
+        """Create agent (if needed) and activate a session."""
+        try:
+            self.client.create_agent(
+                agent_id=agent_id,
+                pattern=pattern,
+                description=description,
+            )
+            logger.info("Created Memanto agent '%s'", agent_id)
+        except Exception:
+            logger.info("Memanto agent '%s' already exists, reusing", agent_id)
+
+        self.client.activate_agent(agent_id, duration_hours=duration_hours)
+        logger.info("Activated session for agent '%s'", agent_id)
+        return self.client
+
+    def teardown(self, agent_id: str) -> None:
+        """Deactivate the agent session."""
+        try:
+            self.client.deactivate_agent(agent_id)
+            logger.info("Deactivated session for agent '%s'", agent_id)
+        except Exception as e:
+            logger.warning("Failed to deactivate agent '%s': %s", agent_id, e)
+
+
+# ---------------------------------------------------------------------------
+# Tool input schemas
+# ---------------------------------------------------------------------------
+
+
+class RememberInput(BaseModel):
+    """Input schema for the Memanto remember tool."""
+
+    memory_type: str = Field(
+        ...,
+        description=(
+            f"The semantic type of memory to store. Must be one of: {VALID_MEMORY_TYPES}"
+        ),
+    )
+    title: str = Field(
+        ...,
+        description="Short title for the memory (max 100 characters).",
+    )
+    content: str = Field(
+        ...,
+        description="The memory content to store (max 10000 characters). Be concise and atomic.",
+    )
+    confidence: float = Field(
+        default=0.85,
+        description="Confidence score from 0.0 to 1.0. Use 1.0 for explicit facts, 0.7-0.85 for observations.",
+    )
+    tags: str = Field(
+        default="",
+        description="Comma-separated tags for categorization (e.g. 'market,ai,trend'). Use lowercase.",
+    )
+
+
+class RecallInput(BaseModel):
+    """Input schema for the Memanto recall tool."""
+
+    query: str = Field(
+        ...,
+        description="Natural language search query to find relevant memories.",
+    )
+    limit: int = Field(
+        default=5,
+        description="Maximum number of memories to retrieve (1-20).",
+    )
+    memory_types: str = Field(
+        default="",
+        description=(
+            "Comma-separated memory types to filter by "
+            "(e.g. 'fact,observation'). Leave empty for all types."
+        ),
+    )
+
+
+class AnswerInput(BaseModel):
+    """Input schema for the Memanto answer tool."""
+
+    question: str = Field(
+        ...,
+        description="A question to answer using RAG over the agent's stored memories.",
+    )
+
+
+# ---------------------------------------------------------------------------
+# CrewAI Tool classes
+# ---------------------------------------------------------------------------
+
+
+class MemantoRememberTool(BaseTool):
+    """Store a memory in Memanto's persistent semantic database."""
+
+    name: str = "memanto_remember"
+    description: str = (
+        "Store a structured memory in Memanto for long-term persistence. "
+        "Use this to save facts, observations, decisions, preferences, or any "
+        "information that should be available to other agents or future sessions. "
+        "Each memory has a type, title (max 100 chars), content (max 10000 chars), "
+        "confidence score, and optional tags."
+    )
+    args_schema: type[BaseModel] = RememberInput
+
+    # Injected at construction time
+    _client: SdkClient
+    _agent_id: str
+
+    def __init__(self, client: SdkClient, agent_id: str, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        object.__setattr__(self, "_client", client)
+        object.__setattr__(self, "_agent_id", agent_id)
+
+    def _run(
+        self,
+        memory_type: str,
+        title: str,
+        content: str,
+        confidence: float = 0.85,
+        tags: str = "",
+    ) -> str:
+        tag_list = [t.strip() for t in tags.split(",") if t.strip()] if tags else []
+
+        result = self._client.remember(
+            agent_id=self._agent_id,
+            memory_type=memory_type,
+            title=title,
+            content=content,
+            confidence=confidence,
+            tags=tag_list,
+            source="crewai-agent",
+            provenance="explicit_statement",
+        )
+
+        return (
+            f"Memory stored successfully.\n"
+            f"  ID: {result['memory_id']}\n"
+            f"  Type: {memory_type}\n"
+            f"  Title: {title}\n"
+            f"  Confidence: {confidence}"
+        )
+
+
+class MemantoRecallTool(BaseTool):
+    """Search and retrieve memories from Memanto's persistent database."""
+
+    name: str = "memanto_recall"
+    description: str = (
+        "Search Memanto's persistent memory database using natural language. "
+        "Returns stored memories ranked by semantic relevance. Use this to "
+        "retrieve facts, research findings, decisions, or any previously "
+        "stored information from any agent that shares this memory namespace."
+    )
+    args_schema: type[BaseModel] = RecallInput
+
+    _client: SdkClient
+    _agent_id: str
+
+    def __init__(self, client: SdkClient, agent_id: str, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        object.__setattr__(self, "_client", client)
+        object.__setattr__(self, "_agent_id", agent_id)
+
+    def _run(
+        self,
+        query: str,
+        limit: int = 5,
+        memory_types: str = "",
+    ) -> str:
+        type_list = (
+            [t.strip() for t in memory_types.split(",") if t.strip()]
+            if memory_types
+            else None
+        )
+
+        result = self._client.recall(
+            agent_id=self._agent_id,
+            query=query,
+            limit=min(limit, 20),
+            type=type_list,
+        )
+
+        memories = result.get("memories", [])
+        if not memories:
+            return f"No memories found for query: '{query}'"
+
+        lines = [f"Found {len(memories)} memories for '{query}':\n"]
+        for i, mem in enumerate(memories, 1):
+            title = mem.get("title", "Untitled")
+            content = mem.get("content", "")
+            mem_type = mem.get("type", "unknown")
+            confidence = mem.get("confidence", "N/A")
+            tags = mem.get("tags", [])
+            tag_str = f" [tags: {', '.join(tags)}]" if tags else ""
+
+            lines.append(
+                f"  {i}. [{mem_type}] {title} (confidence: {confidence}){tag_str}\n"
+                f"     {content}\n"
+            )
+
+        return "\n".join(lines)
+
+
+class MemantoAnswerTool(BaseTool):
+    """Get AI-generated answers grounded in stored memories (RAG)."""
+
+    name: str = "memanto_answer"
+    description: str = (
+        "Ask a question and get an AI-generated answer grounded in the agent's "
+        "stored memories using Retrieval-Augmented Generation (RAG). This is "
+        "useful for synthesizing insights from multiple stored memories into "
+        "a coherent answer."
+    )
+    args_schema: type[BaseModel] = AnswerInput
+
+    _client: SdkClient
+    _agent_id: str
+
+    def __init__(self, client: SdkClient, agent_id: str, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        object.__setattr__(self, "_client", client)
+        object.__setattr__(self, "_agent_id", agent_id)
+
+    def _run(self, question: str) -> str:
+        result = self._client.answer(
+            agent_id=self._agent_id,
+            question=question,
+        )
+
+        answer = result.get("answer", "No answer could be generated.")
+        sources = result.get("sources", [])
+
+        output = f"Answer: {answer}"
+        if sources:
+            output += f"\n\nBased on {len(sources)} memory source(s)."
+
+        return output
+
+
+# ---------------------------------------------------------------------------
+# Factory function
+# ---------------------------------------------------------------------------
+
+
+def create_memanto_tools(
+    client: SdkClient,
+    agent_id: str,
+) -> dict[str, BaseTool]:
+    """
+    Create all Memanto tools bound to a specific client and agent.
+
+    Returns:
+        Dict with keys 'remember', 'recall', 'answer' mapping to tool instances.
+    """
+    return {
+        "remember": MemantoRememberTool(client=client, agent_id=agent_id),
+        "recall": MemantoRecallTool(client=client, agent_id=agent_id),
+        "answer": MemantoAnswerTool(client=client, agent_id=agent_id),
+    }

crewai_memanto-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "crewai-memanto"
+version = "0.1.0"
+description = "CrewAI tools and integration for Memanto's persistent memory"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10,<4"
+authors = [
+    { name = "Memanto", email = "info@memanto.ai" }
+]
+dependencies = [
+    "crewai>=0.80.0",
+    "memanto>=0.1.0",
+    "pydantic>=2.0.0",
+    "python-dotenv>=1.0.0"
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["crewai_memanto"]