mnemo-agent 0.1.0__py3-none-any.whl

mnemo/__init__.py

@@ -0,0 +1,4 @@
+"""mnemo — local-first agent memory CLI."""
+
+__version__ = "0.1.0"
+__author__ = "Joshua Ndala"

mnemo/adapters/letta_adapter.py

@@ -0,0 +1,81 @@
+"""Letta adapter — calls real API when letta-client is installed, stubs otherwise."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from mnemo.models import AgentDump, Fact
+
+
+def _require_letta() -> Any:
+    try:
+        from letta_client import Letta  # type: ignore
+        return Letta
+    except ImportError:
+        raise ImportError(
+            "letta adapter requires: pip install letta-client\n"
+            "Or: pip install 'mnemo[letta]'"
+        )
+
+
+def dump_from_letta(base_url: str, agent_id: str, agent_name: str) -> AgentDump:
+    """Fetch memories from a Letta agent and return a normalized AgentDump."""
+    Letta = _require_letta()
+    client = Letta(base_url=base_url)
+
+    # Letta: GET /v1/agents/{agent_id}/memory/messages or /core_memory
+    try:
+        memory_blocks = client.agents.memory.retrieve(agent_id=agent_id)
+    except Exception as exc:
+        raise RuntimeError(f"Letta API error: {exc}") from exc
+
+    facts: list[Fact] = []
+
+    # Letta returns human/persona/custom memory blocks
+    for block in getattr(memory_blocks, "blocks", []):
+        label = getattr(block, "label", "memory")
+        value = getattr(block, "value", "")
+        block_id = str(getattr(block, "id", ""))
+
+        if not value:
+            continue
+
+        # Treat each newline-separated line as a separate fact
+        for line in str(value).splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            facts.append(
+                Fact(
+                    entity=agent_id,
+                    attribute=label,
+                    value=line,
+                    source="letta",
+                    confidence=1.0,
+                    metadata={"block_id": block_id, "agent_id": agent_id},
+                )
+            )
+
+    return AgentDump(agent=agent_name, source="letta", facts=facts)
+
+
+def load_to_letta(dump: AgentDump, base_url: str, agent_id: str) -> int:
+    """Append facts to a Letta agent's core memory. Returns count pushed."""
+    Letta = _require_letta()
+    client = Letta(base_url=base_url)
+
+    pushed = 0
+    for fact in dump.facts:
+        try:
+            client.agents.core_memory.modify(
+                agent_id=agent_id,
+                label="human",
+                value=fact.to_text(),
+                append=True,
+            )
+            pushed += 1
+        except Exception as exc:  # noqa: BLE001
+            import click
+            click.echo(f"  ⚠  Failed to push fact {fact.id}: {exc}", err=True)
+
+    return pushed

mnemo/adapters/mem0_adapter.py

@@ -0,0 +1,69 @@
+"""Mem0 adapter — calls real API when mem0ai is installed, stubs otherwise."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from mnemo.models import AgentDump, Fact
+
+
+def _require_mem0() -> Any:
+    try:
+        import mem0ai  # type: ignore
+        return mem0ai
+    except ImportError:
+        raise ImportError(
+            "mem0 adapter requires: pip install mem0ai\n"
+            "Or: pip install 'mnemo[mem0]'"
+        )
+
+
+def dump_from_mem0(api_key: str, user_id: str, agent: str) -> AgentDump:
+    """Fetch all memories from Mem0 and return a normalized AgentDump."""
+    mem0 = _require_mem0()
+    client = mem0.MemoryClient(api_key=api_key)
+
+    raw_memories: list[dict] = client.get_all(user_id=user_id)
+
+    facts: list[Fact] = []
+    for mem in raw_memories:
+        # Mem0 returns: {id, memory, user_id, metadata, created_at, ...}
+        # We normalize to entity=user_id, attribute="memory", value=text
+        facts.append(
+            Fact(
+                id=str(mem.get("id", "")),
+                entity=user_id,
+                attribute="memory",
+                value=str(mem.get("memory", "")),
+                source="mem0",
+                confidence=float(mem.get("score", 1.0)),
+                metadata={
+                    k: v
+                    for k, v in mem.items()
+                    if k not in ("id", "memory", "user_id", "score")
+                },
+            )
+        )
+
+    return AgentDump(agent=agent, source="mem0", facts=facts)
+
+
+def load_to_mem0(dump: AgentDump, api_key: str, user_id: str) -> int:
+    """Push facts from a dump into Mem0. Returns count of facts pushed."""
+    mem0 = _require_mem0()
+    client = mem0.MemoryClient(api_key=api_key)
+
+    pushed = 0
+    for fact in dump.facts:
+        try:
+            client.add(
+                messages=[{"role": "user", "content": fact.to_text()}],
+                user_id=user_id,
+                metadata={"mnemo_id": fact.id, **fact.metadata},
+            )
+            pushed += 1
+        except Exception as exc:  # noqa: BLE001
+            import click
+            click.echo(f"  ⚠  Failed to push fact {fact.id}: {exc}", err=True)
+
+    return pushed