Mem0

By Mem0

Memory layer for agents — extracts and recalls facts across sessions, not raw chat logs.

Website ↗ Repository ↗ Docs ↗

v2.0.132026-07-22PythonApache-2.0

#memory #rag #personalization #python

61.5k Open source Free tier Paid

Doc version 1.0 · Updated June 28, 2026

Related tools

Multi-Agent Orchestration

Overview

Mem0 is a memory layer that gives agents long-term, per-user recall.
Instead of storing raw conversation chunks, it runs an extraction step that distils messages into compact facts, then retrieves the relevant ones when you search — a different shape of problem than plain vector retrieval.

flowchart LR
  msg[messages] --> mem0[Mem0]
  mem0 --> store[(vector store)]
  q[query] --> mem0
  mem0 --> facts[relevant memories]

The Code samples tab shows storing and searching memories, then folding them into a prompt — pick from the selector to compare.

When to use it

Choose Mem0 when an agent should remember user preferences and facts across sessions, rather than re-reading the whole history every turn.

Pricing

Open source, free to self-host. Mem0 Platform is the hosted memory service.

Plan	Price	Notes
Free	$0	10k memories
Starter	$19/mo	Higher limits
Growth	$79/mo	Team usage
Pro	$249/mo	Scale, priority support
Enterprise	Custom	SSO, SLA, on-prem

Source ↗ · as of 2026-06-27

Example

Python · add & search

When to use

Reach for Mem0 when an agent needs durable, per-user memory that survives across sessions.

How it flows

add distils messages into compact facts and stores them; search returns the memories relevant to a query.

Structure

flowchart LR
  msg[messages] --> mem0[Mem0]
  mem0 --> store[(vector store)]
  q[query] --> mem0
  mem0 --> facts[relevant memories]

from mem0 import Memory

m = Memory()  # an LLM extracts facts; a vector store recalls them

m.add("I prefer window seats and vegetarian meals.", user_id="alice")

hits = m.search("what are alice's travel preferences?", user_id="alice")
for h in hits["results"]:
    print(h["memory"])

When to use

Inject recalled memories into the prompt so the model personalises its answer.

How it flows

Search Mem0 for relevant facts, format them, and prepend them to the model call.

Structure

flowchart LR
  q[query] --> mem0[Mem0]
  mem0 --> ctx[memories]
  ctx --> llm[LLM]
  llm --> reply[reply]

from mem0 import Memory
from litellm import completion

m = Memory()
m.add("Alice is allergic to peanuts.", user_id="alice")

# Pull relevant memories and prepend them to the prompt.
memories = m.search("food", user_id="alice")["results"]
context = "\n".join(f"- {x['memory']}" for x in memories)

resp = completion(
    model="anthropic/claude-opus-4-8",
    messages=[{"role": "user", "content": f"Known facts:\n{context}\n\nSuggest a snack."}],
)
print(resp.choices[0].message.content)

Example

Mem0 — store and recall a memory

A real, runnable mini-project. Download it and run with Docker.

View samples/mem0_1 on GitHub ↗

June 28, 2026

Mem0 — store and recall a memory

A tiny Mem0 script: it adds a fact for a user, then searches for it. Mem0 distils messages into compact facts (with an LLM) and recalls the relevant ones (from a vector store). The config uses OpenAI.

Configure

cd samples/mem0_1
cp .env.sample .env
# edit .env: set OPENAI_API_KEY

Mem0's config here uses OpenAI for fact extraction and embeddings. Get a key at platform.openai.com/api-keys. .env is gitignored — only .env.sample is committed.

Run with Docker

cd samples/mem0_1
docker build -t aas-mem0 .
docker run --rm --env-file .env aas-mem0 "what are alice's travel preferences?"

Run with Docker (in a devcontainer with DooD)

In a dev container that talks to the host Docker daemon (Docker-outside-of-Docker), the foreground docker run above often prints nothing and exits 0 — but the run itself succeeds. The script runs to completion and Docker captures all of its output; only the live attached stream drops it over the VM boundary. Run detached and follow the logs instead:

cd samples/mem0_1
docker build -t aas-mem0 .
docker logs -f "$(docker run -d --env-file .env aas-mem0 \
  "what are alice's travel preferences?")"

Run locally

cd samples/mem0_1
pip install -r requirements.txt
python app.py "what are alice's travel preferences?"

python-dotenv loads .env automatically.

Example run

Output varies by model and run — LLMs are non-deterministic, so the recalled phrasing differs each time. Below is one run (extraction + recall via OpenAI).

query: what are alice's travel preferences?
  - User prefers window seats when traveling and enjoys vegetarian meals.

Files

.env.sample

# Copy this file to `.env` and add your OpenAI API key.
#   cp .env.sample .env
#
# Mem0's default config uses OpenAI for both fact extraction and embeddings.
# Get a key at https://platform.openai.com/api-keys
OPENAI_API_KEY=

app.py

"""Mem0: store a memory, then recall it.

Adds a fact for a user, then searches — Mem0 distils messages into compact
facts (with an LLM) and recalls the relevant ones (from a vector store). The
config below uses OpenAI, so set OPENAI_API_KEY.

Run:
    docker build -t aas-mem0 .
    docker run --rm --env-file .env aas-mem0 "what are alice's travel preferences?"
"""

import sys

from dotenv import load_dotenv
from mem0 import Memory

# Load .env when running locally; in Docker the key comes from --env-file.
load_dotenv()

# Pin the OpenAI models Mem0 uses (the default model rejects a custom temperature).
CONFIG = {
    "llm": {"provider": "openai", "config": {"model": "gpt-4o-mini"}},
    "embedder": {"provider": "openai", "config": {"model": "text-embedding-3-small"}},
}


def main() -> None:
    query = " ".join(sys.argv[1:]) or "what are alice's travel preferences?"
    user = "alice"

    m = Memory.from_config(CONFIG)
    m.add("I prefer window seats and vegetarian meals.", user_id=user)

    # Mem0 2.x takes the user as a filter on search.
    results = m.search(query, filters={"user_id": user})

    print(f"query: {query}")
    for r in results["results"]:
        print(f"  - {r['memory']}")


if __name__ == "__main__":
    main()

Dockerfile

# Minimal image for the Mem0 sample.
FROM python:3.13-slim

ENV PYTHONUNBUFFERED=1

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

# Provide your config at run time (.env is NOT baked into the image):
#   docker run --rm --env-file .env aas-mem0 "<query>"
ENTRYPOINT ["python", "app.py"]