Learn more · Join Discord · Demo

📄 Benchmarking Mem0's token-efficient memory algorithm →

New Memory Algorithm (April 2026)

Benchmark	Old	New	Tokens	Latency p50
LoCoMo	71.4	92.5	7.0K	0.88s
LongMemEval	67.8	94.4	6.8K	1.09s
BEAM (1M)	n/a	64.1	6.7K	1.00s
BEAM (10M)	n/a	48.6	6.9K	1.05s

All benchmarks run on the same production-representative model stack. Single-pass retrieval (one call, no agentic loops) at a top_200 retrieval budget. Scores reflect Mem0's managed platform, which includes proprietary optimizations not available in the open-source SDK; open-source users should expect directionally similar gains but not identical numbers.

What changed:

• Single-pass ADD-only extraction: one LLM call, no UPDATE/DELETE. Memories accumulate; nothing is overwritten.
• Agent-generated facts are first-class: when an agent confirms an action, that information is now stored with equal weight.
• Entity linking: entities are extracted, embedded, and linked across memories for retrieval boosting.
• Multi-signal retrieval: semantic, BM25 keyword, and entity matching scored in parallel and fused.
• Temporal Reasoning: time-aware retrieval that ranks the right dated instance for queries about current state, past events, and upcoming plans.

See the migration guide for upgrade instructions. The evaluation framework is open-sourced so anyone can reproduce the numbers.

Research Highlights

• 92.5 on LoCoMo: +21 points over the previous algorithm
• 94.4 on LongMemEval: +27 points, with 98.2 on assistant memory recall
• 64.1 on BEAM (1M): production-scale memory evaluation at 1M tokens
• Read the full paper

Introduction

Mem0 ("mem-zero") gives AI assistants and agents persistent memory. It stores facts extracted from conversations, scopes them to a user, agent, or run, and retrieves the relevant ones on the next query.

Key Features & Use Cases

Core capabilities:

• Memory scoped to user_id, agent_id, or run_id, with metadata and filters on top
• The same API across the OSS library, self-hosted server, and hosted Platform, plus Python and TypeScript SDKs

Use cases:

• AI assistants and chatbots that keep context across sessions
• Customer support tools that recall a user's past tickets and preferences
• Coding agents that remember project conventions and prior decisions (Agent Skills)

🚀 Quickstart Guide

Sign up as an agent

AI agents can mint a working Mem0 API key in under five seconds: no email, no dashboard, no OTP. Four commands end-to-end:

# 1. Install
npm install -g @mem0/cli      # or: pip install mem0-cli

# 2. Sign up as an agent (replace `claude-code` with your name)
mem0 init --agent --agent-caller claude-code

# 3. Add a memory
mem0 add "I am using mem0"

# 4. Search
mem0 search "am I using mem0"

The human owner can claim the account later with mem0 init --email <their-email> (same key, memories preserved). Full guide: Sign up as an agent.

	Library	Self-Hosted Server	Cloud Platform
Best for	Testing, prototyping	Teams running on their own infrastructure	Zero-ops production use
Setup	pip install mem0ai	docker compose up	Sign up at app.mem0.ai
Dashboard	n/a	Yes	Yes
Auth & API Keys	n/a	Yes	Yes
Advanced Features	n/a	Teasers	All included

Just testing? Use the library. Building for a team? Self-hosted. Want zero ops? Cloud.

Library (pip / npm)

pip install mem0ai

For enhanced hybrid search with BM25 keyword matching and entity extraction, install with NLP support:

pip install mem0ai[nlp]
python -m spacy download en_core_web_sm

Install sdk via npm:

npm install mem0ai

Self-Hosted Server

Note: Self-hosted auth is on by default. Upgrading from a pre-auth build? Set ADMIN_API_KEY, register an admin through the wizard, or AUTH_DISABLED=true for local dev only. See upgrade notes.

# Recommended: one command starts the stack, creates an admin, and issues the first API key.
cd server && make bootstrap

# Manual: start the stack and finish setup via the browser wizard.
cd server && docker compose up -d    # http://localhost:3000

See the self-hosted docs for configuration.

Cloud Platform

1. Sign up on Mem0 Platform
2. Embed the memory layer via SDK or API keys
3. Using hosted Qdrant vectors? See the Platform migration guide to import them into Mem0 Platform.

CLI

Manage memories from your terminal:

npm install -g @mem0/cli   # or: pip install mem0-cli

mem0 init
mem0 add "Prefers dark mode and vim keybindings" --user-id alice
mem0 search "What does Alice prefer?" --user-id alice

See the CLI documentation for the full command reference.

Agent Skills

Teach your AI coding assistant (Claude Code, Codex, Cursor, Windsurf, OpenCode, OpenClaw, and any tool that supports the skills standard) how to build with Mem0. Two categories:

Reference skills, always on (SDK knowledge loaded into the assistant's context):

npx skills add https://github.com/mem0ai/mem0 --skill mem0
npx skills add https://github.com/mem0ai/mem0 --skill mem0-cli
npx skills add https://github.com/mem0ai/mem0 --skill mem0-vercel-ai-sdk

Pipeline skills, run on demand (execute an end-to-end workflow in an existing repo):

npx skills add https://github.com/mem0ai/mem0 --skill mem0-integrate
npx skills add https://github.com/mem0ai/mem0 --skill mem0-test-integration
npx skills add https://github.com/mem0ai/mem0 --skill mem0-oss-to-platform

Use /mem0-integrate to wire Mem0 into an existing repo via a test-first pipeline, then /mem0-test-integration to verify. Use /mem0-oss-to-platform to migrate an existing project from Mem0 OSS to the hosted Platform SDK. See the skills catalog or Vibecoding with Mem0 for the full picture.

Basic Usage

Mem0 requires an LLM to function, with gpt-5-mini from OpenAI as the default. It supports a variety of LLMs; see Supported LLMs.

The default embedding model is text-embedding-3-small from OpenAI. For best results with hybrid search (semantic + keyword + entity boosting), use at least Qwen 600M or a comparable embedding model. See Supported Embeddings for configuration details.

Self-hosted (Memory, pip install mem0ai):

from openai import OpenAI
from mem0 import Memory

openai_client = OpenAI()
memory = Memory()

def chat_with_memories(message: str, user_id: str = "default_user") -> str:
    relevant_memories = memory.search(query=message, filters={"user_id": user_id}, top_k=3)
    memories_str = "\n".join(f"- {entry['memory']}" for entry in relevant_memories["results"])

    system_prompt = f"You are a helpful AI. Answer the question based on query and memories.\nUser Memories:\n{memories_str}"
    messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": message}]
    response = openai_client.chat.completions.create(model="gpt-5-mini", messages=messages)
    assistant_response = response.choices[0].message.content

    messages.append({"role": "assistant", "content": assistant_response})
    memory.add(messages, user_id=user_id)

    return assistant_response

print(chat_with_memories("I prefer dark mode and vim keybindings"))
print(chat_with_memories("What editor settings do I like?"))

Hosted Platform (MemoryClient, MEM0_API_KEY from app.mem0.ai):

import os
from mem0 import MemoryClient

client = MemoryClient(api_key=os.environ["MEM0_API_KEY"])

messages = [{"role": "user", "content": "I prefer dark mode and vim keybindings"}]
client.add(messages, user_id="alice")

results = client.search("What does Alice prefer?", filters={"user_id": "alice"}, top_k=3)
all_memories = client.get_all(filters={"user_id": "alice"})

TypeScript (npm install mem0ai; see mem0-ts/README.md and the Node quickstart):

import { MemoryClient, type Message } from "mem0ai";
import { Memory } from "mem0ai/oss";

const messages: Message[] = [{ role: "user", content: "I prefer dark mode and vim keybindings" }];

const client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY! });
await client.add(messages, { userId: "alice" });
const results = await client.search("What does Alice prefer?", { filters: { user_id: "alice" } });

const memory = new Memory();
await memory.add(messages, { userId: "alice" });
const local = await memory.search("What does Alice prefer?", { filters: { user_id: "alice" } });

For detailed integration steps, see the Python Quickstart, Platform Quickstart, and API Reference.

What the SDK Covers

Feature	Docs
Memory ops: add, search, get, get_all, update, delete, delete_all, history	Python Quickstart
Entity scoping (user_id, agent_id, run_id)	Entity-scoped memory
Metadata and filters	Metadata filtering
Async clients (AsyncMemory, AsyncMemoryClient)	Async memory
Graph memory	Graph memory
Rerankers	Reranker-enhanced search
Custom instructions	Custom instructions
Multimodal (images, files)	Multimodal support
Webhooks (Platform)	Webhooks
Memory export (Platform)	Memory export
Feedback (Platform)	Feedback mechanism
Memory expiration (Platform)	Memory expiration
Custom categories (Platform)	Custom categories
Dream, memory synthesis (Platform)	Dream

🔗 Integrations & Demos

• ChatGPT with Memory: Personalized chat powered by Mem0 (Live Demo)
• Browser Extension: Store memories across ChatGPT, Perplexity, and Claude (Chrome Extension)
• Langgraph Support: Build a customer bot with Langgraph + Mem0 (Guide)
• CrewAI Integration: Tailor CrewAI outputs with Mem0 (Example)

📚 Documentation & Support

• Full docs: https://docs.mem0.ai
• Community: Discord · X (formerly Twitter)
• Contact: founders@mem0.ai

Citation

We now have a paper you can cite:

@article{mem0,
  title={Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory},
  author={Chhikara, Prateek and Khant, Dev and Aryan, Saket and Singh, Taranjeet and Yadav, Deshraj},
  journal={arXiv preprint arXiv:2504.19413},
  year={2025}
}

⚖️ License

Apache 2.0. See the LICENSE file for details.