lisa-pack-mem0 0.1.0__tar.gz

lisa_pack_mem0-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: lisa-pack-mem0
+Version: 0.1.0
+Summary: Lisa Mem0 provider pack - external memory backend and MCP server manifest
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.14.0; extra == "dev"

lisa_pack_mem0-0.1.0/README.md

@@ -0,0 +1,64 @@
+# lisa-pack-mem0
+
+Lisa Mem0 provider pack — external memory backend and MCP server manifest.
+
+The pack owns the generic `memory.add` / `memory.search` / `memory.list`
+aliases and routes them to Mem0, so any Lisa operation that reads or writes
+long-term memory works against Mem0 without changing.
+
+## What it provides
+
+| Layer | Path | Role |
+| --- | --- | --- |
+| MCP manifest | `mcp_servers.yaml` | Declares the Mem0 backend, its result maps, and the tool policy. |
+| Result maps | `result_maps.py` | Normalize Mem0 responses to canonical Lisa `MemoryRecord` JSON. |
+
+### Result maps
+
+- **`mem0_add_result_map`** — normalizes the add response to a confirmation
+  string.
+- **`mem0_search_result_map`** — maps the Mem0 `score` field to `salience`.
+- **`mem0_list_result_map`** — unwraps the paginated envelope into a flat
+  JSON array of records.
+
+### Tool policy
+
+The manifest denies `delete_all_memories`, `delete_entitites`, and
+`delete_memory`, so a model cannot erase the user's memory through the pack.
+
+## Configuration
+
+| Variable | Meaning |
+| --- | --- |
+| `MEM0_API_KEY` | Bearer token for the Mem0 MCP server. |
+
+Select the pack as the memory owner via session context:
+
+```yaml
+providers:
+  capabilities:
+    memory: lisa-pack-mem0
+```
+
+## Installation
+
+```bash
+pip install lisa-pack-mem0
+```
+
+## Development
+
+```bash
+uv run ruff format --check lisa_packs/mem0
+uv run ruff check lisa_packs/mem0
+uv run mypy lisa_packs/mem0
+uv run pytest -m "not live"
+```
+
+Run the checks from a sibling framework checkout so the shared
+`[tool.ruff]` and `[tool.mypy]` settings apply; `pytest` runs from the pack
+root so `pythonpath = ["."]` makes `lisa_packs.mem0` importable.
+
+## License
+
+MIT.

lisa_pack_mem0-0.1.0/lisa_pack_mem0.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: lisa-pack-mem0
+Version: 0.1.0
+Summary: Lisa Mem0 provider pack - external memory backend and MCP server manifest
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.14.0; extra == "dev"

lisa_pack_mem0-0.1.0/lisa_pack_mem0.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+lisa_pack_mem0.egg-info/PKG-INFO
+lisa_pack_mem0.egg-info/SOURCES.txt
+lisa_pack_mem0.egg-info/dependency_links.txt
+lisa_pack_mem0.egg-info/entry_points.txt
+lisa_pack_mem0.egg-info/requires.txt
+lisa_pack_mem0.egg-info/top_level.txt
+lisa_packs/__init__.py
+lisa_packs/mem0/__init__.py
+lisa_packs/mem0/mcp_servers.yaml
+lisa_packs/mem0/result_maps.py
+lisa_packs/mem0/tests/__init__.py
+lisa_packs/mem0/tests/test_manifest.py
+lisa_packs/mem0/tests/test_result_maps.py

lisa_pack_mem0-0.1.0/lisa_pack_mem0.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lisa_pack_mem0-0.1.0/lisa_pack_mem0.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[lisa.extensions.content_roots]
+mem0 = lisa_packs.mem0:get_content_root

lisa_pack_mem0-0.1.0/lisa_pack_mem0.egg-info/requires.txt

@@ -0,0 +1,5 @@
+
+[dev]
+pytest>=8.0.0
+pytest-asyncio>=0.23.0
+pytest-mock>=3.14.0

lisa_pack_mem0-0.1.0/lisa_pack_mem0.egg-info/top_level.txt

@@ -0,0 +1 @@
+lisa_packs

lisa_pack_mem0-0.1.0/lisa_packs/__init__.py

@@ -0,0 +1,5 @@
+"""Lisa external pack namespace."""
+
+from pkgutil import extend_path
+
+__path__ = extend_path(__path__, __name__)

lisa_pack_mem0-0.1.0/lisa_packs/mem0/__init__.py

@@ -0,0 +1,10 @@
+"""External Mem0 memory provider pack for Lisa."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def get_content_root() -> Path:
+    """Return the content root directory for this pack."""
+    return Path(__file__).parent

lisa_pack_mem0-0.1.0/lisa_packs/mem0/mcp_servers.yaml

@@ -0,0 +1,40 @@
+---
+version: 1
+
+# External Mem0 provider for memory capability ownership.
+# When selected by host policy, this pack owns memory aliases and routes
+# memory.add/search/list through Mem0.
+memory:
+  default_backend: mem0
+  backends:
+    - id: mem0
+      kind: http
+      url: https://mcp.mem0.ai/mcp
+      headers:
+        Authorization: "Bearer ${MEM0_API_KEY}"
+      agent_id: lisa
+      tool_names:
+        add: add_memory
+        search: search_memories
+        list: get_memories
+      result_maps:
+        add: lisa_packs.mem0.result_maps.mem0_add_result_map
+        search: lisa_packs.mem0.result_maps.mem0_search_result_map
+        list: lisa_packs.mem0.result_maps.mem0_list_result_map
+
+servers:
+  - server_id: mem0
+    runtime_kind: http
+    url: https://mcp.mem0.ai/mcp
+    auth:
+      type: bearer
+      token: "${MEM0_API_KEY}"
+    tool_policy:
+      denied_tools:
+        - delete_all_memories
+        - delete_entitites
+        - delete_memory
+    proxy_policy:
+      ambient:
+        user_id: user_slug
+      structured_filters: true

lisa_pack_mem0-0.1.0/lisa_packs/mem0/result_maps.py

@@ -0,0 +1,147 @@
+"""Output-normalization adapters for Mem0 MCP tool responses.
+
+These functions are declared in ``mcp_servers.yaml`` under
+``memory.backends[].result_maps`` and resolved by
+:func:`hosts.core.memory_aliases._backend_result_maps` at alias-registration
+time. Each one receives the raw ``output_text`` from the Mem0 MCP tool and
+returns a normalized string in the **canonical memory shape** — a JSON array
+of ``MemoryRecord``-compatible dicts — so the learning-pack operations
+(``recall_memory``, ``synthesize_and_store_learning``) consume a uniform
+shape regardless of which backend is active.
+
+Mem0 response shapes (v3):
+    - ``get_memories`` (list): ``{"count": N, "next": ..., "previous": ..., "results": [...]}``
+    - ``search_memories`` (search): ``{"results": [...]}`` — items include a ``score`` field
+    - ``add_memory`` (add): ``{"results": [{"id": ..., "memory": ..., "event_id": ...}]}``
+
+Each result item has:
+    - ``id``: UUID string (not int)
+    - ``memory``: the memory text (not ``content``)
+    - ``created_at``: ISO datetime string
+    - ``score`` (search only): float 0..1
+    - ``user_id``: the scoped user
+    - ``metadata``: dict
+    - ``categories``: list[str]
+    - ``updated_at``: ISO datetime or null
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def _unwrap_results(raw_text: str) -> list[dict[str, Any]]:
+    """Parse the raw MCP tool output and extract the results list.
+
+    Handles three shapes:
+    1. Mem0 paginated envelope: ``{"results": [...], "count": ...}``
+    2. Bare list of items (already canonical from some other backend)
+    3. Empty or invalid → returns ``[]``
+    """
+    if not raw_text or not raw_text.strip():
+        return []
+    try:
+        data: Any = json.loads(raw_text)
+    except (json.JSONDecodeError, TypeError):
+        logger.debug("result_map: failed to parse JSON, returning empty list")
+        return []
+    if isinstance(data, list):
+        return [item for item in data if isinstance(item, dict)]
+    if isinstance(data, dict):
+        results = data.get("results")
+        if isinstance(results, list):
+            return [item for item in results if isinstance(item, dict)]
+    return []
+
+
+def _mem0_item_to_record(item: dict[str, Any]) -> dict[str, Any]:
+    """Map one Mem0 result item to a canonical ``MemoryRecord``-compatible dict.
+
+    Mem0 fields → canonical fields:
+        id (UUID str) → id (kept as str; MemoryRecord.id accepts int|str)
+        memory → content
+        created_at → created_at
+        user_id → user_slug
+        score → salience (search responses only)
+        metadata → content_json (merged as-is)
+        categories → stored in content_json for preservation
+    """
+    content_json: dict[str, Any] = {}
+    metadata = item.get("metadata")
+    if isinstance(metadata, dict):
+        content_json["metadata"] = metadata
+    categories = item.get("categories")
+    if isinstance(categories, list):
+        content_json["categories"] = categories
+
+    return {
+        "id": str(item.get("id", "")),
+        "content": str(item.get("memory", "")),
+        "created_at": str(item.get("created_at", "")),
+        "user_slug": str(item.get("user_id", "")),
+        "user_id": str(item.get("user_id", "")),
+        "salience": float(item.get("score", 0.0) or 0.0),
+        "content_json": content_json,
+        "memory_scope": "personal",
+        "memory_tier": "long_term",
+        "surface_id": "",
+        "source_user_slug": str(item.get("user_id", "")),
+        "operation_id": "mem0.add_memory",
+        "agent_id": "lisa",
+        "workspace_id": "default",
+        "memory_kind": "episodic",
+        "confidence": 1.0,
+        "evidence_ids": [],
+        "supersedes_id": None,
+        "valid_until": None,
+        "last_accessed_at": None,
+        "access_count": 0,
+        "status": "active",
+    }
+
+
+def mem0_list_result_map(raw_text: str) -> str:
+    """Normalize ``get_memories`` output into a canonical JSON array of records.
+
+    Mem0's ``get_memories`` returns a paginated envelope:
+    ``{"count": N, "next": ..., "previous": ..., "results": [...]}``
+
+    This unwraps ``results``, maps each item to the ``MemoryRecord`` shape,
+    and returns a flat JSON array string.
+    """
+    items = _unwrap_results(raw_text)
+    records = [_mem0_item_to_record(item) for item in items]
+    return json.dumps(records, default=str)
+
+
+def mem0_search_result_map(raw_text: str) -> str:
+    """Normalize ``search_memories`` output into a canonical JSON array of records.
+
+    Same envelope as ``get_memories`` (``{"results": [...]}``), but each
+    search item includes a ``score`` field (float 0..1) that maps to
+    ``salience`` in the canonical record.
+    """
+    items = _unwrap_results(raw_text)
+    records = [_mem0_item_to_record(item) for item in items]
+    return json.dumps(records, default=str)
+
+
+def mem0_add_result_map(raw_text: str) -> str:
+    """Normalize ``add_memory`` output into a simple confirmation string.
+
+    Mem0's ``add_memory`` returns ``{"results": [{"id": ..., "memory": ..., "event_id": ...}]}``
+    (an async job accepted response). Normalize to a simple confirmation
+    so operations checking ``tool_result.error`` see a clean success.
+    """
+    items = _unwrap_results(raw_text)
+    if not items:
+        return "Memory stored."
+    first = items[0]
+    memory_id = first.get("id", "")
+    if memory_id:
+        return f"Memory stored with ID {memory_id}"
+    return "Memory stored."

lisa_pack_mem0-0.1.0/lisa_packs/mem0/tests/test_manifest.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import pytest
+from kernel.mcp_launch.server_manifest import load_mcp_server_manifest
+
+from lisa_packs.mem0 import get_content_root
+
+
+def test_mem0_pack_manifest_loads_and_owns_memory(monkeypatch: pytest.MonkeyPatch) -> None:
+    # The manifest expands ${MEM0_API_KEY} at load time and the manifest
+    # loader rejects an empty bearer token, so a value must be present even
+    # though this test never contacts the server.
+    monkeypatch.setenv("MEM0_API_KEY", "test-key")
+
+    root = get_content_root()
+    specs, memory = load_mcp_server_manifest(root / "mcp_servers.yaml")
+
+    assert memory.default_backend == "mem0"
+    assert any(backend.id == "mem0" for backend in memory.backends)
+    assert any(spec.server_id == "mem0" for spec in specs)

lisa_pack_mem0-0.1.0/lisa_packs/mem0/tests/test_result_maps.py

@@ -0,0 +1,147 @@
+"""Tests for lisa_packs.mem0.result_maps — Mem0 response normalization adapters.
+
+Covers:
+- mem0_list_result_map unwraps the paginated envelope into a flat JSON array.
+- mem0_search_result_map maps score → salience.
+- mem0_add_result_map normalizes the add response to a confirmation string.
+- Edge cases: empty input, bare list, invalid JSON, missing fields.
+"""
+
+from __future__ import annotations
+
+import json
+
+from lisa_packs.mem0.result_maps import (
+    mem0_add_result_map,
+    mem0_list_result_map,
+    mem0_search_result_map,
+)
+
+_EXPECTED_RESULT_COUNT = 2
+_EXPECTED_SEARCH_SALIENCE = 0.82
+
+
+# ── Realistic Mem0 response payloads ──────────────────────────────────────
+
+
+_MEM0_LIST_RESPONSE = json.dumps(
+    {
+        "count": 2,
+        "next": None,
+        "previous": None,
+        "results": [
+            {
+                "id": "f4cbdb08-7062-4f3e-8eb2-9f5c80dfe64c",
+                "memory": "User moved to San Francisco from New York in January 2026",
+                "metadata": {"category": "location"},
+                "categories": ["location"],
+                "created_at": "2026-01-15T10:30:00Z",
+                "updated_at": "2026-01-15T10:30:00Z",
+            },
+            {
+                "id": "a2b8c3d4-5e6f-7g8h-9i0j-1k2l3m4n5o6p",
+                "memory": "Alex prefers vegetarian restaurants",
+                "metadata": {},
+                "categories": [],
+                "created_at": "2026-07-05T15:30:00Z",
+                "updated_at": "2026-07-05T15:30:00Z",
+            },
+        ],
+    }
+)
+
+_MEM0_SEARCH_RESPONSE = json.dumps(
+    {
+        "results": [
+            {
+                "id": "ea925981-272f-40dd-b576-be64e4871429",
+                "memory": "Likes to play cricket and plays cricket on weekends.",
+                "user_id": "alice",
+                "metadata": {"category": "hobbies"},
+                "categories": ["hobbies"],
+                "score": 0.82,
+                "expiration_date": None,
+                "created_at": "2024-07-26T10:29:36.630547-07:00",
+                "updated_at": None,
+            },
+        ],
+    }
+)
+
+_MEM0_ADD_RESPONSE = json.dumps(
+    {
+        "results": [
+            {
+                "id": "new-mem-uuid-1234",
+                "memory": "The user likes hiking",
+                "event_id": "evt-5678",
+            },
+        ],
+    }
+)
+
+
+# ── Tests ─────────────────────────────────────────────────────────────────
+
+
+def test_mem0_list_result_map_unwraps_envelope() -> None:
+    """The paginated dict envelope is unwrapped to a flat JSON array."""
+    raw = mem0_list_result_map(_MEM0_LIST_RESPONSE)
+    data = json.loads(raw)
+    assert isinstance(data, list)
+    assert len(data) == _EXPECTED_RESULT_COUNT
+    assert data[0]["content"] == "User moved to San Francisco from New York in January 2026"
+    assert data[0]["id"] == "f4cbdb08-7062-4f3e-8eb2-9f5c80dfe64c"
+    assert data[0]["created_at"] == "2026-01-15T10:30:00Z"
+    # metadata preserved in content_json
+    assert data[0]["content_json"]["metadata"] == {"category": "location"}
+    assert data[0]["content_json"]["categories"] == ["location"]
+
+
+def test_mem0_search_result_map_maps_score_to_salience() -> None:
+    """The search score field maps to salience in the canonical record."""
+    raw = mem0_search_result_map(_MEM0_SEARCH_RESPONSE)
+    data = json.loads(raw)
+    assert isinstance(data, list)
+    assert len(data) == 1
+    assert data[0]["content"] == "Likes to play cricket and plays cricket on weekends."
+    assert data[0]["salience"] == _EXPECTED_SEARCH_SALIENCE
+    assert data[0]["user_slug"] == "alice"
+
+
+def test_mem0_add_result_map_returns_confirmation() -> None:
+    """The add response normalizes to a simple confirmation string."""
+    raw = mem0_add_result_map(_MEM0_ADD_RESPONSE)
+    assert raw == "Memory stored with ID new-mem-uuid-1234"
+
+
+def test_mem0_list_result_map_empty_input() -> None:
+    """Empty input returns an empty JSON array."""
+    assert json.loads(mem0_list_result_map("")) == []
+
+
+def test_mem0_list_result_map_bare_list() -> None:
+    """A bare list (already canonical) passes through after normalization."""
+    bare = json.dumps([{"id": 1, "memory": "test", "created_at": "2026-01-01"}])
+    data = json.loads(mem0_list_result_map(bare))
+    assert isinstance(data, list)
+    assert len(data) == 1
+    assert data[0]["content"] == "test"
+
+
+def test_mem0_list_result_map_invalid_json() -> None:
+    """Invalid JSON returns an empty array."""
+    assert json.loads(mem0_list_result_map("not json")) == []
+
+
+def test_mem0_search_result_map_missing_score() -> None:
+    """Items without a score field default salience to 0.0."""
+    raw = json.dumps({"results": [{"id": "x", "memory": "no score", "created_at": "2026-01-01"}]})
+    data = json.loads(mem0_search_result_map(raw))
+    assert data[0]["salience"] == 0.0
+
+
+def test_mem0_add_result_map_empty() -> None:
+    """Empty add response returns a generic confirmation."""
+    assert mem0_add_result_map("") == "Memory stored."
+    assert mem0_add_result_map("{}") == "Memory stored."

lisa_pack_mem0-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["lisa_packs*", "lisa_packs.mem0*"]
+
+[tool.setuptools.package-data]
+"lisa_packs" = ["*"]
+"lisa_packs.mem0" = ["mcp_servers.yaml"]
+
+[project]
+name = "lisa-pack-mem0"
+version = "0.1.0"
+description = "Lisa Mem0 provider pack - external memory backend and MCP server manifest"
+requires-python = ">=3.11"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "pytest-mock>=3.14.0",
+]
+
+[tool.pytest.ini_options]
+pythonpath = ["."]
+testpaths = ["lisa_packs/mem0/tests"]
+markers = [
+    "live: hits real external signal or provider APIs and prints a tester-visible summary",
+    "integration: multi-module in-process test",
+    "eval: deterministic agent regression evals (no model calls, no I/O)",
+]
+
+[project.entry-points."lisa.extensions.content_roots"]
+mem0 = "lisa_packs.mem0:get_content_root"

lisa_pack_mem0-0.1.0/setup.cfg

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