agno-memorysync

MemorySync memory backend for Agno agents.

A memory-only db for Agno's MemoryManager: user memories live in MemorySync (persistent, semantic, cross-framework) while sessions and other agent state stay in your local db. Ships a sync MemorySyncDb and an async-native AsyncMemorySyncDb twin.

pip install agno-memorysync

Quickstart

from agno.agent import Agent
from agno.db.sqlite import SqliteDb
from agno.memory import MemoryManager
from agno_memorysync import MemorySyncDb

agent = Agent(
    db=SqliteDb(db_file="agent.db"),                  # sessions: local
    memory_manager=MemoryManager(db=MemorySyncDb()),  # memories: MemorySync
    update_memory_on_run=True,   # extract + store memories after every run
    user_id="customer-42",
)
agent.run("I prefer teal dashboards and window seats")
agent.run("Which color should the new chart use?")   # remembers

The API key comes from the MEMORYSYNC_API_KEY environment variable (or MemorySyncDb(api_key=...)). add_memories_to_context auto-enables when a memory manager is set, so recalled memories are injected into context on every run.

Why this instead of the Mem0 toolkit?

Agno's ecosystem has one other memory SaaS: the Mem0Tools toolkit shipped in agno core, plus a cookbook. Verified against their source:

The memory-only contract

BaseDb covers sessions, evals, knowledge, metrics, and traces too. MemorySyncDb implements every memory method for real and makes every other surface raise MemorySyncMemoryOnlyError with the fix in the message — a backend that silently pretended to store sessions would lose them.

Agent(
    db=SqliteDb(...),                                # sessions, evals, ...
    memory_manager=MemoryManager(db=MemorySyncDb())  # memories only
)

Semantic recall

db = MemorySyncDb()
memories = db.get_user_memories(
    user_id="customer-42",
    search_content="what does the user like to eat?",  # real vector search
    limit=5,
)

Agno's built-in search_user_memories offers last_n, first_n, and agentic (an extra LLM call that reads all memories). search_content here is served by MemorySync's vector index — no LLM round-trip, ranked by similarity.

Async agents

from agno_memorysync import AsyncMemorySyncDb

manager = MemoryManager(db=AsyncMemorySyncDb())
# MemoryManager awaits AsyncBaseDb natively on Agent.arun paths.

Delete semantics — designed against data loss

Failure policy

• Reads fail open under a hard budget (recall_timeout, default 1.2 s): a slow or down memory service degrades to no memories, never a stalled or crashed turn.
• Writes fail open by default (fail_open_writes=True): post-run extraction never turns a successful agent run into a failure. The failure is logged loudly and the call returns None — an honest contract value. Set fail_open_writes=False to raise instead.
• Deletes are never fail-open. A delete that did not happen raises.

Configuration

Multimodal memories

Images flow to the model (Agent.run(images=[Image(...)])), the model's understanding is extracted by MemoryManager as text, and the memory lands here with its source input — image-derived memories work through agno's NATIVE pipeline. (The Mem0 docs demo bypasses agno's memory system entirely and pushes raw base64 into their cloud.)

Tests

pip install -e . pytest pytest-asyncio
pytest tests -q   # 30+ checks against the real agno at latest

The suite drives the real MemoryManager and a REAL Agent run (stub model, local session db) and reproduces each named competitor bug as a regression test.

License

MIT © MemorySync.