Mem0 Memory Layer

Give your agent a memory that survives across turns, sessions, and users. This skill wires Mem0 into your agent's call loop so it extracts durable facts from conversations, stores them in a vector store, and retrieves the relevant ones before each response. It's for Python developers building chatbots, support agents, or assistants that need to remember who the user is and what they said last week — without stuffing the whole history into the prompt.

When to use it

• A user tells your agent "I'm vegetarian" or "I use TypeScript" and you want that recalled in future sessions.
• You're building a multi-tenant assistant and need memories isolated per user_id.
• Your context window is overflowing with chat history and you'd rather retrieve only the facts that matter for the current query.
• You need an audit trail of how a stored fact changed over time.

How it works

The core is two calls. Memory.add(messages, user_id=...) runs an LLM pass that extracts atomic facts from the turn, then reconciles them against existing memories — adding, updating, or deleting as needed (it won't store five copies of "likes coffee"). Memory.search(query, user_id=...) does semantic retrieval and returns ranked memories to inject into your prompt.

Scope everything with user_id, agent_id, and run_id (session). Round out the lifecycle with get_all(), get(memory_id), update(), delete()/delete_all(), and history(memory_id) to inspect changes. search() and get_all() accept metadata filters for narrowing by your own tags.

Two backends share the same API: self-hosted Memory (you bring the vector store, LLM, and embedder via a config dict) and hosted MemoryClient (managed by Mem0, API-key auth).

Usage

curl -fsSL --create-dirs -o ~/.claude/skills/mem0-agent-memory/SKILL.md https://claudeskil.com/skills/mem0-agent-memory/SKILL.md
pip install mem0ai

from mem0 import Memory

m = Memory()  # or Memory.from_config(cfg) to pick vector store / LLM

# After a turn, persist facts
m.add(
    [{"role": "user", "content": "I'm allergic to peanuts"}],
    user_id="alex",
)

# Before the next response, retrieve and inject
hits = m.search("what can this user eat?", user_id="alex", limit=3)
context = "\n".join(h["memory"] for h in hits["results"])

Tips & gotchas

• add() makes its own LLM calls for extraction — it has latency and token cost. Call it after responding, not in the hot path, or batch it.
• Don't store raw transcripts. Mem0 distills facts; passing huge blobs wastes the extraction budget. Pass the recent turns.
• Migrating from MemoryClient to self-hosted Memory? The method names match, but configure the same embedder or your existing vectors won't match queries.
• Always pass at least one scope id. Memories added without user_id/agent_id/run_id are hard to retrieve cleanly later.

FAQ

Self-hosted vs hosted — which? Use Memory (self-hosted) when you need data residency or your own Qdrant/pgvector/Chroma. Use MemoryClient when you'd rather not run infrastructure.

Does it support async? Yes — AsyncMemory mirrors the sync API for add/search/etc.

How are conflicting facts handled? add() detects contradictions and updates the existing memory rather than appending; use history() to see the prior value.