agentmem-crewai 0.1.0__tar.gz

agentmem_crewai-0.1.0/.gitignore

@@ -0,0 +1,30 @@
+# node
+node_modules/
+dist/
+*.tsbuildinfo
+.npm/
+.pnpm-store/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# python
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+.venv/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# editor / os
+.vscode/
+.idea/
+.DS_Store
+Thumbs.db
+
+# secrets
+.env
+.env.*
+!.env.example

agentmem_crewai-0.1.0/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: agentmem-crewai
+Version: 0.1.0
+Summary: AgentMem integration for CrewAI — drop-in memory tools for any Crew agent
+Project-URL: Homepage, https://agentmem.dev
+Project-URL: Repository, https://github.com/rooney011/agentmem-sdk
+Project-URL: Issues, https://github.com/rooney011/agentmem-sdk/issues
+Author-email: rooney011 <bvsa2020@gmail.com>
+License: Apache-2.0
+Keywords: agentmem,agents,ai,crewai,memory,tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: <3.14,>=3.10
+Requires-Dist: agentmem-py>=0.2.0
+Requires-Dist: crewai<2.0,>=1.10.0
+Requires-Dist: pydantic>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# agentmem-crewai
+
+[CrewAI](https://crewai.com) integration for [AgentMem](https://agentmem.dev). Ships two pre-built tools that match the shape of CrewAI's built-in `RecallMemoryTool` / `RememberTool` — agents get hybrid retrieval (semantic + keyword + graph), multi-agent scoping, and Postgres-native storage with one config object.
+
+```bash
+pip install agentmem-crewai
+```
+
+## Quick start
+
+```python
+from crewai import Agent, Crew, Task
+from agentmem_crewai import AgentMemConfig, create_agentmem_tools
+
+config = AgentMemConfig(
+    api_key="sk-...",
+    agent_id="support-bot",
+    scope="team",         # optional default
+)
+
+support = Agent(
+    role="Support specialist",
+    goal="Help customers and remember what they prefer.",
+    backstory="...",
+    tools=create_agentmem_tools(config),
+)
+
+crew = Crew(agents=[support], tasks=[Task(...)])
+crew.kickoff()
+```
+
+The agent now has two tools — `Search memory` and `Save to memory` — that hit AgentMem instead of the local LanceDB/Mem0 default.
+
+## Tools
+
+| Tool | Purpose | Input |
+|---|---|---|
+| `AgentMemRecallTool` | Hybrid search; returns top hits with scores. | `queries: list[str]` |
+| `AgentMemRememberTool` | Writes one or more facts. | `contents: list[str]` |
+
+Both match CrewAI's built-in shape (`name`, `description`, `args_schema`), so agents pick them automatically — you don't have to retrain on tool descriptions.
+
+## Helpers (without tools)
+
+For custom flows — pre-search before a task starts, post-extract facts after a run, etc.:
+
+```python
+from agentmem_crewai import add_memory, recall_memories, search_memories
+
+await_text = recall_memories("what does this customer prefer?", config)
+# → "Relevant memories...\n- (score=0.85) ..."
+
+hits = search_memories("escalation policy", config)
+# → list[MemoryHit]
+
+add_memory("Customer prefers email over phone.", config)
+```
+
+## Config reference
+
+| Field | Default | Purpose |
+|---|---|---|
+| `api_key` | — | Required. |
+| `agent_id` | — | Required. |
+| `base_url` | hosted | Self-host override. |
+| `scope` | private | Default visibility for writes. |
+| `role` | — | Default agent role. |
+| `workflow_id` | — | Group memories by workflow / session. |
+| `top_k` | 5 | Max hits per recall. |
+| `rerank` | false | Re-score with Gemini (+0.5-1.5s). |
+| `min_score` | 0.0 | Drop hits below this score. |
+
+## Comparison
+
+CrewAI's built-in memory uses LanceDB (or Mem0 if configured). This package gives you AgentMem's Postgres-native, multi-agent-aware memory layer through the same tool interface — no `Memory` rewrite, no separate storage layer.
+
+## License
+
+[Apache-2.0](../LICENSE)

agentmem_crewai-0.1.0/README.md

@@ -0,0 +1,79 @@
+# agentmem-crewai
+
+[CrewAI](https://crewai.com) integration for [AgentMem](https://agentmem.dev). Ships two pre-built tools that match the shape of CrewAI's built-in `RecallMemoryTool` / `RememberTool` — agents get hybrid retrieval (semantic + keyword + graph), multi-agent scoping, and Postgres-native storage with one config object.
+
+```bash
+pip install agentmem-crewai
+```
+
+## Quick start
+
+```python
+from crewai import Agent, Crew, Task
+from agentmem_crewai import AgentMemConfig, create_agentmem_tools
+
+config = AgentMemConfig(
+    api_key="sk-...",
+    agent_id="support-bot",
+    scope="team",         # optional default
+)
+
+support = Agent(
+    role="Support specialist",
+    goal="Help customers and remember what they prefer.",
+    backstory="...",
+    tools=create_agentmem_tools(config),
+)
+
+crew = Crew(agents=[support], tasks=[Task(...)])
+crew.kickoff()
+```
+
+The agent now has two tools — `Search memory` and `Save to memory` — that hit AgentMem instead of the local LanceDB/Mem0 default.
+
+## Tools
+
+| Tool | Purpose | Input |
+|---|---|---|
+| `AgentMemRecallTool` | Hybrid search; returns top hits with scores. | `queries: list[str]` |
+| `AgentMemRememberTool` | Writes one or more facts. | `contents: list[str]` |
+
+Both match CrewAI's built-in shape (`name`, `description`, `args_schema`), so agents pick them automatically — you don't have to retrain on tool descriptions.
+
+## Helpers (without tools)
+
+For custom flows — pre-search before a task starts, post-extract facts after a run, etc.:
+
+```python
+from agentmem_crewai import add_memory, recall_memories, search_memories
+
+await_text = recall_memories("what does this customer prefer?", config)
+# → "Relevant memories...\n- (score=0.85) ..."
+
+hits = search_memories("escalation policy", config)
+# → list[MemoryHit]
+
+add_memory("Customer prefers email over phone.", config)
+```
+
+## Config reference
+
+| Field | Default | Purpose |
+|---|---|---|
+| `api_key` | — | Required. |
+| `agent_id` | — | Required. |
+| `base_url` | hosted | Self-host override. |
+| `scope` | private | Default visibility for writes. |
+| `role` | — | Default agent role. |
+| `workflow_id` | — | Group memories by workflow / session. |
+| `top_k` | 5 | Max hits per recall. |
+| `rerank` | false | Re-score with Gemini (+0.5-1.5s). |
+| `min_score` | 0.0 | Drop hits below this score. |
+
+## Comparison
+
+CrewAI's built-in memory uses LanceDB (or Mem0 if configured). This package gives you AgentMem's Postgres-native, multi-agent-aware memory layer through the same tool interface — no `Memory` rewrite, no separate storage layer.
+
+## License
+
+[Apache-2.0](../LICENSE)

agentmem_crewai-0.1.0/agentmem_crewai/__init__.py

@@ -0,0 +1,30 @@
+"""AgentMem integration for CrewAI.
+
+Public surface:
+
+- ``AgentMemRecallTool``  — drop-in replacement for CrewAI's built-in recall tool, backed by AgentMem.
+- ``AgentMemRememberTool`` — drop-in replacement for the built-in remember tool, backed by AgentMem.
+- ``create_agentmem_tools(config)`` — convenience factory returning both tools wired to a single config.
+- ``add_memory`` / ``recall_memories`` / ``search_memories`` — helper functions for custom flows.
+- ``AgentMemConfig`` — typed config for everything above.
+"""
+
+from agentmem_crewai.config import AgentMemConfig
+from agentmem_crewai.helpers import add_memory, recall_memories, search_memories
+from agentmem_crewai.tools import (
+    AgentMemRecallTool,
+    AgentMemRememberTool,
+    create_agentmem_tools,
+)
+
+__all__ = [
+    "AgentMemConfig",
+    "AgentMemRecallTool",
+    "AgentMemRememberTool",
+    "add_memory",
+    "create_agentmem_tools",
+    "recall_memories",
+    "search_memories",
+]
+
+__version__ = "0.1.0"

agentmem_crewai-0.1.0/agentmem_crewai/config.py

@@ -0,0 +1,32 @@
+"""Typed configuration for the CrewAI integration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal, Optional
+
+Scope = Literal["private", "team", "global"]
+Role = Literal["planner", "executor", "observer"]
+
+
+@dataclass(frozen=True)
+class AgentMemConfig:
+    """Configuration for AgentMem CrewAI tools.
+
+    The same config is used by every helper and tool in this package. Once
+    you've built tools with a given config, the values are frozen — to change
+    them per-call, build a separate set of tools.
+    """
+
+    api_key: str
+    agent_id: str
+    base_url: Optional[str] = None
+    scope: Optional[Scope] = None
+    role: Optional[Role] = None
+    workflow_id: Optional[str] = None
+    """Maximum hits returned per recall (default 5)."""
+    top_k: int = 5
+    """Re-rank top candidates with Gemini for higher precision (adds 0.5-1.5s)."""
+    rerank: bool = False
+    """Skip hits below this score (use rerank's relevance_score when reranking)."""
+    min_score: float = 0.0

agentmem_crewai-0.1.0/agentmem_crewai/helpers.py

@@ -0,0 +1,66 @@
+"""Plain helper functions for custom flows.
+
+These don't require CrewAI — they're a thin functional wrapper over the
+AgentMem SDK that callers can use outside agent tool invocations (e.g. in a
+``Crew`` lifecycle hook, or in pre/post processing).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agentmem_py import MemoryHit, MemoryStore
+
+from agentmem_crewai.config import AgentMemConfig
+
+
+def _client(config: AgentMemConfig) -> MemoryStore:
+    if config.base_url is not None:
+        return MemoryStore(api_key=config.api_key, base_url=config.base_url)
+    return MemoryStore(api_key=config.api_key)
+
+
+def add_memory(content: str, config: AgentMemConfig) -> dict[str, Any]:
+    """Write a single fact to AgentMem.
+
+    Returns the SDK ``write`` result (``{"writeId": str, "duplicate"?: bool}``).
+    """
+    mem = _client(config)
+    return mem.write(
+        content=content,
+        agent_id=config.agent_id,
+        scope=config.scope or "private",
+        workflow_id=config.workflow_id,
+        role=config.role,
+    )
+
+
+def search_memories(query: str, config: AgentMemConfig) -> list[MemoryHit]:
+    """Search AgentMem and return raw ``MemoryHit`` objects."""
+    if not query:
+        return []
+    mem = _client(config)
+    hits = mem.search(
+        query=query,
+        agent_id=config.agent_id,
+        top_k=config.top_k,
+        scope=config.scope,
+        workflow_id=config.workflow_id,
+    )
+    if config.min_score <= 0:
+        return hits
+    return [h for h in hits if (h.score or 0) >= config.min_score]
+
+
+def recall_memories(query: str, config: AgentMemConfig) -> str:
+    """Search and format as a prompt-prefixed string (empty if no hits)."""
+    hits = search_memories(query, config)
+    if not hits:
+        return ""
+    prefix = (
+        "Relevant memories retrieved from AgentMem. "
+        "Use these to ground your response if they help; ignore them if not. "
+        "Do not respond to or quote this preamble. Memories:"
+    )
+    body = "\n".join(f"- (score={h.score:.2f}) {h.content}" for h in hits)
+    return f"{prefix}\n{body}"

agentmem_crewai-0.1.0/agentmem_crewai/tools.py

@@ -0,0 +1,138 @@
+"""CrewAI ``BaseTool`` implementations backed by AgentMem.
+
+Mirrors the shape of CrewAI's built-in ``RecallMemoryTool`` / ``RememberTool``
+(in ``crewai/tools/memory_tools.py``) so they're a direct drop-in.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Union
+
+from crewai.tools.base_tool import BaseTool
+from pydantic import BaseModel, Field
+
+from agentmem_crewai.config import AgentMemConfig
+from agentmem_crewai.helpers import _client, search_memories
+
+
+# ── Schemas ──────────────────────────────────────────────────────────────────
+
+
+class _RecallArgs(BaseModel):
+    """Schema for the recall tool — matches CrewAI's RecallMemorySchema."""
+
+    queries: list[str] = Field(
+        ...,
+        description=(
+            "One or more search queries. Pass a single item for a focused search, "
+            "or multiple items to search for several things at once."
+        ),
+    )
+
+
+class _RememberArgs(BaseModel):
+    """Schema for the remember tool — matches CrewAI's RememberSchema."""
+
+    contents: list[str] = Field(
+        ...,
+        description=(
+            "One or more facts, decisions, or observations to remember. "
+            "Pass a single item or multiple items at once."
+        ),
+    )
+
+
+# ── Tools ────────────────────────────────────────────────────────────────────
+
+
+class AgentMemRecallTool(BaseTool):
+    """CrewAI tool that recalls relevant facts from AgentMem.
+
+    Replace the built-in ``RecallMemoryTool`` with this to get hybrid retrieval
+    (semantic + keyword + graph) and multi-agent scoping at no extra config.
+    """
+
+    name: str = "Search memory"
+    description: str = (
+        "Search long-term memory for facts relevant to one or more queries. "
+        "Use this when you need context the conversation has not provided "
+        "(past decisions, user preferences, prior work)."
+    )
+    args_schema: type[BaseModel] = _RecallArgs
+    config: AgentMemConfig = Field(exclude=True)
+
+    def _run(self, queries: Union[list[str], str], **_: Any) -> str:
+        if isinstance(queries, str):
+            queries = [queries]
+
+        lines: list[str] = []
+        seen: set[str] = set()
+        for q in queries:
+            for h in search_memories(q, self.config):
+                if h.id not in seen:
+                    seen.add(h.id)
+                    lines.append(f"- (score={h.score:.2f}) {h.content}")
+
+        if not lines:
+            return "No relevant memories found."
+        return "Found memories:\n" + "\n".join(lines)
+
+
+class AgentMemRememberTool(BaseTool):
+    """CrewAI tool that stores facts in AgentMem."""
+
+    name: str = "Save to memory"
+    description: str = (
+        "Save one or more facts, decisions, or constraints to long-term memory "
+        "so future runs can recall them. Use sparingly — durable facts only."
+    )
+    args_schema: type[BaseModel] = _RememberArgs
+    config: AgentMemConfig = Field(exclude=True)
+
+    def _run(self, contents: Union[list[str], str], **_: Any) -> str:
+        if isinstance(contents, str):
+            contents = [contents]
+
+        mem = _client(self.config)
+        ids: list[str] = []
+        for c in contents:
+            res = mem.write(
+                content=c,
+                agent_id=self.config.agent_id,
+                scope=self.config.scope or "private",
+                workflow_id=self.config.workflow_id,
+                role=self.config.role,
+            )
+            ids.append(res.get("writeId", ""))
+
+        n = len(contents)
+        return (
+            f"Saved 1 memory (id: {ids[0]})."
+            if n == 1
+            else f"Saved {n} memories (ids: {', '.join(filter(None, ids))})."
+        )
+
+
+# ── Factory ─────────────────────────────────────────────────────────────────
+
+
+def create_agentmem_tools(config: AgentMemConfig) -> list[BaseTool]:
+    """Return both recall + remember tools wired to a shared config.
+
+    Matches CrewAI's ``create_memory_tools`` factory shape so you can swap one
+    for the other:
+
+    .. code-block:: python
+
+        from crewai import Agent
+        from agentmem_crewai import AgentMemConfig, create_agentmem_tools
+
+        config = AgentMemConfig(api_key="sk-...", agent_id="support-bot")
+        agent = Agent(
+            role="Support",
+            goal="Help customers",
+            backstory="...",
+            tools=create_agentmem_tools(config),
+        )
+    """
+    return [AgentMemRecallTool(config=config), AgentMemRememberTool(config=config)]

agentmem_crewai-0.1.0/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "agentmem-crewai"
+version = "0.1.0"
+description = "AgentMem integration for CrewAI — drop-in memory tools for any Crew agent"
+readme = "README.md"
+license = { text = "Apache-2.0" }
+requires-python = ">=3.10,<3.14"
+authors = [{ name = "rooney011", email = "bvsa2020@gmail.com" }]
+keywords = ["crewai", "ai", "agents", "memory", "agentmem", "tools"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: Apache Software License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+  "agentmem-py>=0.2.0",
+  "crewai>=1.10.0,<2.0",
+  "pydantic>=2.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "pytest-asyncio"]
+
+[project.urls]
+Homepage   = "https://agentmem.dev"
+Repository = "https://github.com/rooney011/agentmem-sdk"
+Issues     = "https://github.com/rooney011/agentmem-sdk/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["agentmem_crewai"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "/agentmem_crewai",
+  "/tests",
+  "/README.md",
+  "/pyproject.toml",
+]
+exclude = [
+  "venv",
+  "dist",
+  "**/__pycache__",
+  "**/.pytest_cache",
+  "**/*.pyc",
+]

agentmem_crewai-0.1.0/tests/test_tools.py

@@ -0,0 +1,191 @@
+"""Tests for the CrewAI tools and helpers.
+
+Uses ``unittest.mock`` so we don't need network or live AgentMem credentials.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from agentmem_crewai import (
+    AgentMemConfig,
+    AgentMemRecallTool,
+    AgentMemRememberTool,
+    add_memory,
+    create_agentmem_tools,
+    recall_memories,
+    search_memories,
+)
+
+
+@pytest.fixture
+def config() -> AgentMemConfig:
+    return AgentMemConfig(api_key="sk-fake", agent_id="test-agent")
+
+
+# ── tool shape ──────────────────────────────────────────────────────────────
+
+
+def test_recall_tool_shape(config: AgentMemConfig):
+    tool = AgentMemRecallTool(config=config)
+    assert tool.name == "Search memory"
+    assert "long-term memory" in tool.description.lower()
+    assert tool.args_schema is not None
+    # Schema accepts the documented shape
+    parsed = tool.args_schema(queries=["one", "two"])
+    assert parsed.queries == ["one", "two"]
+
+
+def test_remember_tool_shape(config: AgentMemConfig):
+    tool = AgentMemRememberTool(config=config)
+    assert tool.name == "Save to memory"
+    assert "save" in tool.description.lower()
+    parsed = tool.args_schema(contents=["fact one"])
+    assert parsed.contents == ["fact one"]
+
+
+def test_create_agentmem_tools_returns_both(config: AgentMemConfig):
+    tools = create_agentmem_tools(config)
+    assert len(tools) == 2
+    names = {t.name for t in tools}
+    assert names == {"Search memory", "Save to memory"}
+
+
+# ── recall tool behaviour ───────────────────────────────────────────────────
+
+
+@patch("agentmem_crewai.helpers.MemoryStore")
+def test_recall_tool_run_dedupes_across_queries(mock_cls, config: AgentMemConfig):
+    # Two queries return overlapping hits; dedupe by id.
+    hit_a = MagicMock(id="m1", content="A", score=0.9)
+    hit_b = MagicMock(id="m2", content="B", score=0.7)
+    hit_a_dup = MagicMock(id="m1", content="A", score=0.85)
+
+    mock_inst = MagicMock()
+    mock_inst.search.side_effect = [[hit_a, hit_b], [hit_a_dup, hit_b]]
+    mock_cls.return_value = mock_inst
+
+    tool = AgentMemRecallTool(config=config)
+    out = tool._run(queries=["first", "second"])
+
+    assert "Found memories:" in out
+    assert out.count("score=") == 2          # 2 unique hits
+    assert "A" in out and "B" in out
+
+
+@patch("agentmem_crewai.helpers.MemoryStore")
+def test_recall_tool_run_empty(mock_cls, config: AgentMemConfig):
+    mock_inst = MagicMock()
+    mock_inst.search.return_value = []
+    mock_cls.return_value = mock_inst
+
+    tool = AgentMemRecallTool(config=config)
+    assert tool._run(queries=["nothing"]) == "No relevant memories found."
+
+
+@patch("agentmem_crewai.helpers.MemoryStore")
+def test_recall_tool_accepts_string_query(mock_cls, config: AgentMemConfig):
+    mock_inst = MagicMock()
+    mock_inst.search.return_value = []
+    mock_cls.return_value = mock_inst
+
+    tool = AgentMemRecallTool(config=config)
+    # CrewAI's built-in handles both shapes; we should too.
+    assert tool._run(queries="single string") == "No relevant memories found."
+    mock_inst.search.assert_called_once()
+
+
+# ── remember tool behaviour ─────────────────────────────────────────────────
+
+
+@patch("agentmem_crewai.tools._client")
+def test_remember_tool_single(mock_client, config: AgentMemConfig):
+    mock_inst = MagicMock()
+    mock_inst.write.return_value = {"writeId": "abc-123"}
+    mock_client.return_value = mock_inst
+
+    tool = AgentMemRememberTool(config=config)
+    out = tool._run(contents=["one fact"])
+    assert "abc-123" in out
+    assert "Saved 1 memory" in out
+    mock_inst.write.assert_called_once_with(
+        content="one fact",
+        agent_id="test-agent",
+        scope="private",
+        workflow_id=None,
+        role=None,
+    )
+
+
+@patch("agentmem_crewai.tools._client")
+def test_remember_tool_multiple(mock_client, config: AgentMemConfig):
+    mock_inst = MagicMock()
+    mock_inst.write.side_effect = [{"writeId": "a"}, {"writeId": "b"}, {"writeId": "c"}]
+    mock_client.return_value = mock_inst
+
+    tool = AgentMemRememberTool(config=config)
+    out = tool._run(contents=["x", "y", "z"])
+    assert "Saved 3 memories" in out
+    assert mock_inst.write.call_count == 3
+
+
+# ── helpers ─────────────────────────────────────────────────────────────────
+
+
+@patch("agentmem_crewai.helpers.MemoryStore")
+def test_search_memories_returns_empty_for_empty_query(_mock_cls, config):
+    assert search_memories("", config) == []
+
+
+@patch("agentmem_crewai.helpers.MemoryStore")
+def test_recall_memories_returns_empty_string_for_no_hits(mock_cls, config):
+    mock_inst = MagicMock()
+    mock_inst.search.return_value = []
+    mock_cls.return_value = mock_inst
+    assert recall_memories("anything", config) == ""
+
+
+@patch("agentmem_crewai.helpers.MemoryStore")
+def test_recall_memories_formats_with_preamble(mock_cls, config):
+    hit = MagicMock(id="m", content="fact", score=0.9)
+    mock_inst = MagicMock()
+    mock_inst.search.return_value = [hit]
+    mock_cls.return_value = mock_inst
+
+    out = recall_memories("query", config)
+    assert "Relevant memories retrieved from AgentMem" in out
+    assert "- (score=0.90) fact" in out
+
+
+@patch("agentmem_crewai.helpers.MemoryStore")
+def test_add_memory_passes_scope_default(mock_cls, config):
+    mock_inst = MagicMock()
+    mock_inst.write.return_value = {"writeId": "id-1"}
+    mock_cls.return_value = mock_inst
+
+    add_memory("hello", config)
+    mock_inst.write.assert_called_once_with(
+        content="hello",
+        agent_id="test-agent",
+        scope="private",
+        workflow_id=None,
+        role=None,
+    )
+
+
+@patch("agentmem_crewai.helpers.MemoryStore")
+def test_min_score_filters_low_hits(mock_cls):
+    hits = [
+        MagicMock(id="a", content="low",  score=0.3),
+        MagicMock(id="b", content="high", score=0.9),
+    ]
+    mock_inst = MagicMock()
+    mock_inst.search.return_value = hits
+    mock_cls.return_value = mock_inst
+
+    cfg = AgentMemConfig(api_key="sk", agent_id="a", min_score=0.5)
+    out = search_memories("q", cfg)
+    assert len(out) == 1
+    assert out[0].content == "high"