+
+
+## The mental model
+
+| Without a memory layer | With Mem0 |
+|---|---|
+| Keep appending chat history to the prompt | Store facts once, then retrieve them by query |
+| Make the model re-read old turns | Give the model only the relevant memories |
+| Lose context when a session ends | Scope memory by `user_id`, `agent_id`, `run_id`, and metadata |
+
+## Messages vs memories
+
+You send Mem0 messages. By default, Mem0 stores extracted memories, not a verbatim transcript.
+
+| Input | Stored memory |
+|---|---|
+| `"I prefer aisle seats"` | `User prefers aisle seats` |
+| `"Let's use Postgres for this project"` | `Project decision: use Postgres` |
+| Message metadata | Filterable fields such as category, app, user, or run |
+
+Use `infer=False` when you need to store raw content exactly as provided. Otherwise, keep inference enabled so retrieval works on clean, deduplicated facts.
+
+## Two phases: extraction and retrieval
+
+Most applications use Mem0 in two places:
+
+1. **After a useful interaction**, call `add` to store what should be remembered.
+2. **Before a model call**, call `search` and pass the best results into your prompt.
+
+### 1. Extraction (writing memory)
+
+When new messages arrive, Mem0 extracts durable facts and stores them with the identifiers and metadata you provide.
+
+1. **Context lookup.** Mem0 checks related existing memories so it can avoid storing the same fact again.
+2. **Fact extraction.** An LLM extracts preferences, decisions, plans, and other details your agent can reuse.
+3. **Deduplication and embedding.** Redundant facts are removed, then each memory is embedded for semantic search.
+4. **Entity linking.** When configured, Mem0 links people, places, organizations, and concepts across memories.
+
+The automatic extraction path is additive. If a user says, "I moved from Austin to Seattle," Mem0 can store the new fact without silently rewriting the old one. Use explicit `update` or `delete` operations when your application needs to correct or remove a memory.
+
+### 2. Retrieval (reading memory)
+
+When you call `search`, Mem0 ranks stored memories against your query and filters.
+
+| Signal | What it does | Best for |
+|---|---|---|
+| **Semantic** | Vector similarity over embeddings | Conceptual questions |
+| **Keyword** | Term matching for exact words and phrases | Names, IDs, and factual lookups |
+| **Entity** | Boosts memories linked to entities in the query | Questions about a person, project, or account |
+
+Platform retrieval uses multiple signals in the managed service. OSS retrieval depends on your configured vector store, optional reranker, and graph store.
+
+
+
+
+
+
+ 
+ 
+ 
+ 
+
-
-
-
- 
- 
- 
- 
- --json` — replace `` with the AI agent you are (e.g. `claude-code`, `cursor`, `codex`). If you forgot to pass `--agent-caller`, run `mem0 identify ` after init to attribute the signup.
+Then run: `mem0 init --agent --agent-caller --json`. Replace `` with the AI agent you are (e.g. `claude-code`, `cursor`, `codex`). If you forgot to pass `--agent-caller`, run `mem0 identify ` after init to attribute the signup.
This mints an evaluation key in <5 seconds. Use it immediately against the Platform API or MCP server. When the human is ready, claim with `mem0 init --email ` to transfer ownership (memories preserved, same API key, no agent disruption).
@@ -184,6 +184,7 @@ If the user is on a pre-current major (Python < 2, TS < 3, or Platform `output_f
## Core Concepts
+- [How Mem0 Works](https://docs.mem0.ai/core-concepts/how-it-works) [Both]: Use when explaining the end-to-end pipeline: extraction (ADD-only distillation), storage across vector/graph/history stores, and multi-signal retrieval.
- [Memory Types](https://docs.mem0.ai/core-concepts/memory-types) [Both]: Use when explaining working, factual, episodic, and semantic memory distinctions.
- [Memory Operations - Add](https://docs.mem0.ai/core-concepts/memory-operations/add) [Both]: Use when explaining how `add()` extracts facts, resolves conflicts, and writes to both stores.
- [Memory Operations - Search](https://docs.mem0.ai/core-concepts/memory-operations/search) [Both]: Use when explaining how queries are processed and ranked.
@@ -194,7 +195,6 @@ If the user is on a pre-current major (Python < 2, TS < 3, or Platform `output_f
## Platform
### Features - Essential
-- [Platform Features Overview](https://docs.mem0.ai/platform/features/platform-overview) [Platform]: Use when surveying what managed offers beyond CRUD.
- [V2 Memory Filters](https://docs.mem0.ai/platform/features/v2-memory-filters) [Platform]: Use when compound filters (AND/OR on metadata, entity, time) are needed at search.
- [Entity-Scoped Memory](https://docs.mem0.ai/platform/features/entity-scoped-memory) [Platform]: Use when partitioning memories by user, agent, app, or run.
- [Graph Memory](https://docs.mem0.ai/platform/features/graph-memory) [Platform]: Use when connecting facts across memories through shared entities for entity-centric or multi-hop questions.
@@ -208,7 +208,7 @@ If the user is on a pre-current major (Python < 2, TS < 3, or Platform `output_f
- [Temporal Reasoning](https://docs.mem0.ai/platform/features/temporal-reasoning) [Platform]: Use when time-aware searches like last week, upcoming, or right now need better result ordering.
- [Contextual Add](https://docs.mem0.ai/platform/features/contextual-add) [Platform]: Use when `add()` should consider the surrounding conversation, not just the latest turn.
- [Custom Instructions](https://docs.mem0.ai/platform/features/custom-instructions) [Platform]: Use when tailoring what Mem0 extracts and stores on Platform.
-- [Memory Decay](https://docs.mem0.ai/platform/features/memory-decay) [Platform]: Use when search results should boost recently-reinforced memories and dampen stale ones — opt-in per project, search-time only, never filters candidates out.
+- [Memory Decay](https://docs.mem0.ai/platform/features/memory-decay) [Platform]: Use when search results should boost recently-reinforced memories and dampen stale ones. Opt in per project; applies at search time and never filters candidates out.
- [Advanced Memory Operations](https://docs.mem0.ai/platform/advanced-memory-operations) [Platform]: Use when basic CRUD is not enough - batch ops, complex filters, workflows.
### Features - Data Management
@@ -220,7 +220,6 @@ If the user is on a pre-current major (Python < 2, TS < 3, or Platform `output_f
- [Webhooks](https://docs.mem0.ai/platform/features/webhooks) [Platform]: Use when another system needs to react to memory changes in real time.
- [Feedback Mechanism](https://docs.mem0.ai/platform/features/feedback-mechanism) [Platform]: Use when capturing user feedback to improve memory quality.
- [Group Chat Support](https://docs.mem0.ai/platform/features/group-chat) [Platform]: Use when the conversation has multiple participants.
-- [MCP Integration](https://docs.mem0.ai/platform/features/mcp-integration) [Platform]: Use when wiring Mem0 into Claude/Cursor/other MCP clients.
### Support & Migration
- [FAQs](https://docs.mem0.ai/platform/faqs) [Platform]: Use when answering common Platform questions.
diff --git a/docs/logo/Favicon copy.png b/docs/logo/Favicon copy.png
deleted file mode 100644
index 683d39cb2..000000000
Binary files a/docs/logo/Favicon copy.png and /dev/null differ
diff --git a/docs/logo/favicon.png b/docs/logo/favicon.png
deleted file mode 100644
index e05a01f72..000000000
Binary files a/docs/logo/favicon.png and /dev/null differ
diff --git a/docs/logo/favicon.svg b/docs/logo/favicon.svg
new file mode 100644
index 000000000..366e7c5c0
--- /dev/null
+++ b/docs/logo/favicon.svg
@@ -0,0 +1 @@
+
diff --git a/docs/logo/favicon_old.png b/docs/logo/favicon_old.png
deleted file mode 100644
index 683d39cb2..000000000
Binary files a/docs/logo/favicon_old.png and /dev/null differ
diff --git a/docs/open-source/configuration.mdx b/docs/open-source/configuration.mdx
index 3e06814bf..acffe1f9a 100644
--- a/docs/open-source/configuration.mdx
+++ b/docs/open-source/configuration.mdx
@@ -1,63 +1,47 @@
---
title: "Configure the OSS Stack"
-description: "Wire up Mem0 OSS with your preferred LLM, vector store, embedder, and reranker."
+description: "Configure Mem0 OSS in Python or TypeScript with your own LLM, embedder, and vector store."
icon: "sliders"
---
-# Configure Mem0 OSS Components
+Mem0 OSS works out of the box with OpenAI defaults. Point it at your own LLM, embedder, and vector store by passing a config when you create `Memory`. The Python SDK also supports a reranker and graph memory.
**Prerequisites**
- - Python 3.10+ with `pip` available
- - Running vector database (e.g., Qdrant, Postgres + pgvector) or access credentials for a managed store
- - API keys for your chosen LLM, embedder, and reranker providers
+ - Python 3.10+ (`pip`) or Node.js 18+ (`npm`)
+ - A running vector store such as Qdrant or Postgres + pgvector (Python's default Qdrant and Node's in-memory store need nothing extra)
+ - API keys for your chosen LLM and embedder providers
- Start from the Python quickstart if you still need the base CLI and repository.
+ New to Mem0 OSS? Run the Python or Node.js quickstart first, then come back to swap in your own providers.
## Install dependencies
-
-
-
-
-```bash
+
+```bash pip
pip install mem0ai
```
-
-
-```bash
-pip install qdrant-client openai
+
+```bash npm
+npm install mem0ai
```
-
-
-
-
-
-
+
+
+Using Qdrant as your vector store? Install its Python client (the Node SDK talks to Qdrant over REST) and run the server locally:
+
```bash
-git clone https://github.com/mem0ai/mem0.git
-cd mem0/examples/docker-compose
+pip install qdrant-client # Python only
+docker run -p 6333:6333 qdrant/qdrant
```
-
-
-```bash
-pip install -r requirements.txt
-```
-
-
-
-
## Define your configuration
-
-
-
-
-```python
+Each component takes a `provider` and a `config`. Keys are `snake_case` in Python and `camelCase` in TypeScript. Pass the config when you create `Memory`:
+
+
+```python Python
from mem0 import Memory
config = {
@@ -67,11 +51,11 @@ config = {
},
"llm": {
"provider": "openai",
- "config": {"model": "gpt-4.1-mini", "temperature": 0.1},
+ "config": {"model": "gpt-5-mini", "temperature": 0.1},
},
"embedder": {
- "provider": "vertexai",
- "config": {"model": "textembedding-gecko@003"},
+ "provider": "openai",
+ "config": {"model": "text-embedding-3-small"},
},
"reranker": {
"provider": "cohere",
@@ -81,86 +65,95 @@ config = {
memory = Memory.from_config(config)
```
-
-
+
+```ts Node.js
+import { Memory } from "mem0ai/oss";
+
+const memory = new Memory({
+ llm: {
+ provider: "openai",
+ config: { apiKey: process.env.OPENAI_API_KEY || "", model: "gpt-5-mini", temperature: 0.1 },
+ },
+ embedder: {
+ provider: "openai",
+ config: { apiKey: process.env.OPENAI_API_KEY || "", model: "text-embedding-3-small" },
+ },
+ vectorStore: {
+ provider: "qdrant",
+ config: { host: "localhost", port: 6333, collectionName: "memories" },
+ },
+});
+```
+
+
+Set your provider keys as environment variables:
+
```bash
-export QDRANT_API_KEY="..."
export OPENAI_API_KEY="..."
-export COHERE_API_KEY="..."
+export COHERE_API_KEY="..." # Python reranker only
```
-
-
-
-
-
-
-```yaml
-vector_store:
- provider: qdrant
- config:
- host: localhost
- port: 6333
-llm:
- provider: azure_openai
- config:
- api_key: ${AZURE_OPENAI_KEY}
- deployment_name: gpt-4.1-mini
+
+ The TypeScript OSS SDK configures the LLM, embedder, vector store, and history store. Reranker and graph memory are Python-only today.
+
-embedder:
- provider: ollama
- config:
- model: nomic-embed-text
+Prefer a config file? Load YAML into Python's `from_config`:
-reranker:
- provider: zero_entropy
- config:
- api_key: ${ZERO_ENTROPY_KEY}
-```
-
-
```python
+import yaml
from mem0 import Memory
-memory = Memory.from_config_file("config.yaml")
+with open("config.yaml") as f:
+ config = yaml.safe_load(f)
+
+memory = Memory.from_config(config)
```
-
-
-
-
- Run `memory.add("Remember my favorite cafe in Tokyo.", user_id="alex")` and then `memory.search("favorite cafe", filters={"user_id": "alex"})`. You should see the Qdrant collection populate and the reranker mark the memory as a top hit.
+ Verify it works: add a memory and search it back. `memory.add(...)` followed by `memory.search(...)` should populate your vector store and return the memory as a top hit.
+## Available providers
+
+Change the `provider` string to switch backends. The most common options:
+
+| Component | Python | TypeScript |
+| --- | --- | --- |
+| LLM | `openai`, `anthropic`, `gemini`, `groq`, `ollama`, `aws_bedrock`, `azure_openai`, `litellm` | `openai`, `anthropic`, `gemini`, `groq`, `ollama`, `azure_openai`, `mistral`, `deepseek` |
+| Embedder | `openai`, `gemini`, `azure_openai`, `ollama`, `huggingface`, `vertexai`, `aws_bedrock` | `openai`, `gemini`, `azure_openai`, `ollama` |
+| Vector store | `qdrant`, `pgvector`, `chroma`, `pinecone`, `redis`, `weaviate`, `milvus`, `elasticsearch` | `memory`, `qdrant`, `pgvector`, `redis`, `supabase`, `azure-ai-search`, `vectorize` |
+
+See the full catalog in Components.
+
## Tune component settings
- Name collections explicitly in production (`collection_name`) to isolate tenants and enable per-tenant retention policies.
+ Name collections explicitly in production (`collection_name` / `collectionName`) to isolate tenants and enable per-tenant retention policies.
- Keep extraction temperatures ≤0.2 so advanced memories stay deterministic. Raise it only when you see missing facts.
+ Keep extraction temperature at or below 0.2 so memories stay deterministic. Raise it only when you see facts being missed.
-
- Limit `top_k` to 10–20 results; sending more adds latency without meaningful gains.
+
+ Limit `top_k` to 10 to 20 results. Sending more adds latency without meaningful gains.
- Mixing managed and self-hosted components? Make sure every outbound provider call happens through a secure network path. Managed rerankers often require outbound internet even if your vector store is on-prem.
+ Mixing managed and self-hosted components? Make sure every outbound provider call has a secure network path. Managed rerankers and embedders often require outbound internet even if your vector store is on-prem.
## Quick recovery
-- Qdrant connection errors → confirm port `6333` is exposed and API key (if set) matches.
-- Empty search results → verify the embedder model name; a mismatch causes dimension errors.
-- `Unknown reranker` → update the SDK (`pip install --upgrade mem0ai`) to load the latest provider registry.
+- Qdrant connection errors: confirm port `6333` is exposed and the API key (if set) matches.
+- Empty search results: verify the embedder model name. A mismatch causes dimension errors.
+- `Unknown reranker` (Python): upgrade the SDK with `pip install --upgrade mem0ai` to load the latest provider registry.
+- `Cannot find module` (Node): import from the OSS entry point, `import { Memory } from "mem0ai/oss"`, not `"mem0ai"`.
-By default the Node SDK uses local-friendly settings (OpenAI `gpt-5-mini`, `text-embedding-3-small`, in-memory vector store, and SQLite history). Swap components by passing a config as shown below.
+By default the Node SDK uses local-friendly settings (OpenAI `gpt-5-mini`, `text-embedding-3-small`, in-memory vector store, and SQLite history). Pass a config to swap any of them.
-## Configure for production
+## Configure providers
+
+Pass a config object to `new Memory()` to use your own LLM, embedder, and vector store:
```ts
import { Memory } from "mem0ai/oss";
const memory = new Memory({
+ llm: {
+ provider: "openai",
+ config: { apiKey: process.env.OPENAI_API_KEY || "", model: "gpt-4-turbo-preview" }
+ },
embedder: {
provider: "openai",
- config: {
- apiKey: process.env.OPENAI_API_KEY || "",
- model: "text-embedding-3-small"
- }
+ config: { apiKey: process.env.OPENAI_API_KEY || "", model: "text-embedding-3-small" }
},
vectorStore: {
provider: "memory",
- config: {
- collectionName: "memories",
- dimension: 1536
- }
- },
- llm: {
- provider: "openai",
- config: {
- apiKey: process.env.OPENAI_API_KEY || "",
- model: "gpt-4-turbo-preview"
- }
- },
- historyDbPath: "memory.db"
-});
-```
-
-## Manage memories (optional)
-
-
-```ts Get all memories
-const allMemories = await memory.getAll({ filters: { userId: "alice" } });
-console.log(allMemories);
-```
-
-```ts Get one memory
-const singleMemory = await memory.get("892db2ae-06d9-49e5-8b3e-585ef9b85b8e");
-console.log(singleMemory);
-```
-
-```ts Search memories
-const result = await memory.search("What do you know about me?", { filters: { userId: "alice" } });
-console.log(result);
-```
-
-```ts Update a memory
-const updateResult = await memory.update(
- "892db2ae-06d9-49e5-8b3e-585ef9b85b8e",
- "I love India, it is my favorite country."
-);
-console.log(updateResult);
-```
-
-
-```ts
-// Audit history
-const history = await memory.history("892db2ae-06d9-49e5-8b3e-585ef9b85b8e");
-console.log(history);
-
-// Delete specific or scoped memories
-await memory.delete("892db2ae-06d9-49e5-8b3e-585ef9b85b8e");
-await memory.deleteAll({ userId: "alice" });
-
-// Reset everything
-await memory.reset();
-```
-
-## Use a custom history store
-
-The Node SDK supports Supabase (or other providers) when you need serverless-friendly history storage.
-
-
-```ts Supabase provider
-import { Memory } from "mem0ai/oss";
-
-const memory = new Memory({
- historyStore: {
- provider: "supabase",
- config: {
- supabaseUrl: process.env.SUPABASE_URL || "",
- supabaseKey: process.env.SUPABASE_KEY || "",
- tableName: "memory_history"
- }
+ config: { collectionName: "memories", dimension: 1536 }
}
});
```
-```ts Disable history
-import { Memory } from "mem0ai/oss";
-
-const memory = new Memory({
- disableHistory: true
-});
-```
-
-
-Create the Supabase table with:
-
-```sql
-create table memory_history (
- id text primary key,
- memory_id text not null,
- previous_value text,
- new_value text,
- action text not null,
- created_at timestamp with time zone default timezone('utc', now()),
- updated_at timestamp with time zone,
- is_deleted integer default 0
-);
-```
-
-## Configuration parameters
-
-Mem0 offers granular configuration across vector stores, LLMs, embedders, and history stores.
-
-
-
-| Parameter | Description | Default |
-| --- | --- | --- |
-| `provider` | Vector store provider (e.g., `"memory"`) | `"memory"` |
-| `host` | Host address | `"localhost"` |
-| `port` | Port number | `undefined` |
-
-
-| Parameter | Description | Provider |
-| --- | --- | --- |
-| `provider` | LLM provider (e.g., `"openai"`, `"anthropic"`) | All |
-| `model` | Model to use | All |
-| `temperature` | Temperature value | All |
-| `apiKey` | API key | All |
-| `maxTokens` | Max tokens to generate | All |
-| `topP` | Probability threshold | All |
-| `topK` | Token count to keep | All |
-| `openaiBaseUrl` | Base URL override | OpenAI |
-
-
-| Parameter | Description | Default |
-| --- | --- | --- |
-| `provider` | Embedding provider | `"openai"` |
-| `model` | Embedding model | `"text-embedding-3-small"` |
-| `apiKey` | API key | `undefined` |
-
-
-| Parameter | Description | Default |
-| --- | --- | --- |
-| `historyDbPath` | Path to history database | `"{mem0_dir}/history.db"` |
-| `customInstructions` | Custom processing prompt | `undefined` |
-
-
-| Parameter | Description | Default |
-| --- | --- | --- |
-| `provider` | History provider | `"sqlite"` |
-| `config` | Provider configuration | `undefined` |
-| `disableHistory` | Disable history store | `false` |
-
-
-```ts
-const config = {
- embedder: {
- provider: "openai",
- config: {
- apiKey: process.env.OPENAI_API_KEY || "",
- model: "text-embedding-3-small"
- }
- },
- vectorStore: {
- provider: "memory",
- config: {
- collectionName: "memories",
- dimension: 1536
- }
- },
- llm: {
- provider: "openai",
- config: {
- apiKey: process.env.OPENAI_API_KEY || "",
- model: "gpt-4-turbo-preview"
- }
- },
- historyStore: {
- provider: "supabase",
- config: {
- supabaseUrl: process.env.SUPABASE_URL || "",
- supabaseKey: process.env.SUPABASE_KEY || "",
- tableName: "memories"
- }
- },
- disableHistory: false,
- customInstructions: "I'm a virtual assistant. I'm here to help you with your queries."
-};
-```
-
-
+For the full provider catalog, history stores, and every config option, see [Configuration](/open-source/configuration).
## What's next?
-
- Review CRUD patterns, filters, and advanced retrieval across the OSS stack.
+
+ Search, update, and manage memories with the full CRUD API.
-
- Swap in your preferred LLM, vector store, and history provider for production use.
+
+ Swap in your own LLM, embedder, and vector store.
-
- See a full Node-based workflow that layers Mem0 memories onto tool-calling agents.
+
+ Wire Mem0 into LangChain, CrewAI, LangGraph, and 20+ more.
diff --git a/docs/open-source/overview.mdx b/docs/open-source/overview.mdx
index 1dc6c931c..c1b015b33 100644
--- a/docs/open-source/overview.mdx
+++ b/docs/open-source/overview.mdx
@@ -4,43 +4,38 @@ description: "Self-host Mem0 with full control over your infrastructure and data
icon: "house"
---
-# Mem0 Open Source Overview
+Mem0 Open Source is the same memory engine as the Platform, running on your own infrastructure. You own the stack, the data, and every component, and you choose where each one runs.
-Mem0 Open Source delivers the same adaptive memory engine as the platform, but packaged for teams that need to run everything on their own infrastructure. You own the stack, the data, and the customizations.
+Run it two ways:
-## What Mem0 OSS provides
+- **As a library** in your app. `pip install mem0ai` (or `npm install mem0ai`), call `Memory()`, and you have memory in a few lines.
+- **As a self-hosted server.** A Docker stack with a dashboard, per-user API keys, and a request audit log.
-- **Full control**: Tune every component, from LLMs to vector stores, inside your environment.
-- **Offline ready**: Keep memory on your own network when compliance or privacy demands it.
-- **Extendable codebase**: Fork the repo, add providers, and ship custom automations.
-
-
- Two ways to run Mem0 OSS: as a **library** inside your app (Python or Node), or as a **self-hosted server** with a dashboard, per-user API keys, and a request audit log.
-
-
-## Choose your path
+## Get started
-
- Run `make bootstrap` to launch the server + dashboard, create an admin, and issue your first API key.
-
- Bootstrap CLI and verify add/search loop.
+ Install the SDK and verify the add/search loop in a few lines.
- Install TypeScript SDK and run starter script.
+ Install the TypeScript SDK and run the starter script.
+
+
+ Run `make bootstrap` to launch the server, dashboard, and your first API key.
+## Go further
+
-
- LLM, embedder, vector store, reranker setup.
+
+ Set your LLM, embedder, vector store, and reranker.
-
- Hybrid retrieval and reranker controls.
+
+ Async memory, metadata filters, reranker search, multimodal, and more.
-
- Benchmarks and how Mem0 is tested.
+
+ End-to-end examples: companions, agents, and integrations.
@@ -48,55 +43,29 @@ Mem0 Open Source delivers the same adaptive memory engine as the platform, but p
Need a managed alternative? Compare hosting models in the Platform vs OSS guide or switch tabs to the Platform documentation.
-
-
-
- | Benefit | What you get |
- | --- | --- |
- | Full infrastructure control | Host on your own servers with complete access to configuration and deployment. |
- | Complete customization | Modify the implementation, extend functionality, and tailor it to your stack. |
- | Local development | Perfect for development, testing, and offline environments. |
- | No vendor lock-in | Keep ownership of your data, providers, and pipelines. |
- | Community driven | Contribute improvements and tap into a growing ecosystem. |
-
-
-
## Default components
-
- **Library defaults** (when you `import` Mem0 and call `Memory()` directly):
- - LLM: OpenAI `gpt-5-mini` (via `OPENAI_API_KEY`)
- - Embeddings: OpenAI `text-embedding-3-small`
- - Vector store: Local Qdrant at `/tmp/qdrant`
- - History store: SQLite at `~/.mem0/history.db`
- - Reranker: Disabled until configured
+Mem0 runs out of the box with the defaults below. Override any of them through [configuration](/open-source/configuration).
- Override any component with `Memory.from_config`.
-
+**As a library** (you `import` Mem0 and call `Memory()`):
-
- **Self-hosted server defaults** (the `server/` Docker Compose stack):
- - LLM: OpenAI `gpt-4.1-nano-2025-04-14` (override with `MEM0_DEFAULT_LLM_MODEL`)
- - Embeddings: OpenAI `text-embedding-3-small` (override with `MEM0_DEFAULT_EMBEDDER_MODEL`)
- - Vector store: Postgres + pgvector
- - Bundled providers: `openai`, `anthropic`, `gemini`: switch from the Configuration page
+| Component | Default |
+|---|---|
+| LLM | OpenAI `gpt-5-mini` (set `OPENAI_API_KEY`) |
+| Embeddings | OpenAI `text-embedding-3-small` |
+| Vector store | Local Qdrant at `/tmp/qdrant` |
+| History store | SQLite at `~/.mem0/history.db` |
+| Reranker | Disabled until configured |
- See Self-Hosted Setup for the full provider list and how to extend it.
-
+Override any component with [`Memory.from_config`](/open-source/configuration).
-## Keep going
+**As a self-hosted server** (the `server/` Docker Compose stack):
-
-
+| Component | Default |
+|---|---|
+| LLM | OpenAI `gpt-5-mini` (override with `MEM0_DEFAULT_LLM_MODEL`) |
+| Embeddings | OpenAI `text-embedding-3-small` (override with `MEM0_DEFAULT_EMBEDDER_MODEL`) |
+| Vector store | Postgres + pgvector |
+| Bundled providers | `openai`, `anthropic`, `gemini` (switch on the Configuration page) |
+
+See [Self-Hosted Setup](/open-source/setup#supported-providers) for the full provider list and how to extend it.
diff --git a/docs/open-source/python-quickstart.mdx b/docs/open-source/python-quickstart.mdx
index 108100517..b95d62318 100644
--- a/docs/open-source/python-quickstart.mdx
+++ b/docs/open-source/python-quickstart.mdx
@@ -86,24 +86,22 @@ By default `Memory()` wires up:
- No reranker (add one in the config when you need it)
-## What's Next?
+## What's next?
-
-Learn how to search, update, and manage memories with full CRUD operations
+
+Search, update, and manage memories with the full CRUD API.
-
- Customize Mem0 with different LLMs, vector stores, and embedders for production use
+
+Swap in your own LLM, embedder, and vector store.
-
-Explore async support and multi-agent memory organization
+
+Wire Mem0 into LangChain, CrewAI, LangGraph, and 20+ more.
-## Additional Resources
+If you have any questions, please feel free to reach out:
-- **[OpenAI Compatibility](/open-source/features/openai_compatibility)** - Use Mem0 with OpenAI-compatible chat completions
-- **[Contributing Guide](/contributing/development)** - Learn how to contribute to Mem0
-- **[Examples](/cookbooks/companions/local-companion-ollama)** - See Mem0 in action with Ollama and other integrations
+
- This section applies to the **browser-first** path (`make up`). If you used `make bootstrap`, the admin and API key were already created: skip ahead to [What the dashboard gives you](#what-the-dashboard-gives-you).
+ This section applies to the **browser-first** path (`make up`). If you used `make bootstrap`, the admin and API key were already created, so skip ahead to [What the dashboard gives you](#what-the-dashboard-gives-you).
On a fresh install the dashboard redirects to `/setup`. Each step submits on Enter.
**1. Create the admin account.** Name, email, password. This account becomes the first admin. Registration closes after the first admin is created; additional accounts are provisioned by the existing admin.
-**2. Review the effective config.** Read-only display of the LLM and embedder the server is running with, sourced from your environment. If anything is wrong here, stop the stack, fix the `.env`, and restart: the dashboard intentionally does not let you change provider secrets at runtime.
+**2. Review the effective config.** Read-only display of the LLM and embedder the server is running with, sourced from your environment. If anything is wrong here, stop the stack, fix the `.env`, and restart. The dashboard intentionally does not let you change provider secrets at runtime.
-**3. Generate your first API key.** The full `m0sk_...` value is shown **once**. Copy it immediately: the server only stores the prefix and a bcrypt hash.
+**3. Generate your first API key.** The full `m0sk_...` value is shown **once**. Copy it immediately. The server stores only the prefix and a bcrypt hash.
**4. Tell us your use case.** Pick a preset or describe your use case in a few words. Mem0 generates custom instructions that tell the memory system what to prioritize. You can edit the instructions before saving, or skip this step entirely.
@@ -125,8 +126,8 @@ For the underlying endpoints (including `/auth/*`, `/api-keys`, `/requests`, `/e
The shipped container bundles the Python packages for:
-- **LLMs**: `openai`, `anthropic`, `gemini`
-- **Embedders**: `openai`, `gemini`
+- **LLMs:** `openai`, `anthropic`, `gemini`
+- **Embedders:** `openai`, `gemini`
The Configuration page and `POST /configure` only accept providers from these lists. Anything else returns a 400 up front instead of failing at the first memory write.
@@ -146,9 +147,9 @@ Heavy providers (`sentence-transformers` pulls in PyTorch, ~2 GB) are intentiona
Previous self-hosted builds allowed open access when `ADMIN_API_KEY` was unset. This build enables auth by default. After pulling the new image, pick **one**:
-1. **Fastest, zero client changes**: set `ADMIN_API_KEY` to a long random value (16+ characters). Existing clients that send `X-API-Key: ` keep working unchanged.
-2. **Recommended for teams**: visit `http://:3000`, run the setup wizard, and switch clients to per-user API keys. You get the audit log and revocation for free.
-3. **Local development only**: set `AUTH_DISABLED=true`. The server logs a warning on every boot. Never use this in production.
+1. **Fastest, zero client changes:** set `ADMIN_API_KEY` to a long random value (16+ characters). Existing clients that send `X-API-Key: ` keep working unchanged.
+2. **Recommended for teams:** visit `http://:3000`, run the setup wizard, and switch clients to per-user API keys. You get the audit log and revocation for free.
+3. **Local development only:** set `AUTH_DISABLED=true`. The server logs a warning on every boot. Never use this in production.
The server prints an unmissable startup banner when it detects the "upgraded but not configured" state so you know exactly which option to pick.
diff --git a/docs/platform/agent-signup.mdx b/docs/platform/agent-signup.mdx
index 9baf58609..03353d325 100644
--- a/docs/platform/agent-signup.mdx
+++ b/docs/platform/agent-signup.mdx
@@ -5,7 +5,7 @@ icon: "robot"
iconType: "solid"
---
-If you're an AI agent (Claude Code, Cursor, Codex, Cline, Aider, Windsurf, or any other autonomous coding tool), you don't need a human to set up Mem0 for you. Four commands: install, sign up, push a memory, search it: and you have persistent memory.
+If you're an AI agent (Claude Code, Cursor, Codex, Cline, Aider, Windsurf, or any other autonomous coding tool), you don't need a human to set up Mem0 for you. Four commands (install, sign up, push a memory, search it) and you have persistent memory.
## The 4-command demo
@@ -39,14 +39,14 @@ mem0 search "am I using mem0"
```
-That's it: under 30 seconds from a fresh shell to a working memory store.
+That's it. Under 30 seconds from a fresh shell to a working memory store.
## Identify yourself with `--agent-caller`
Replace `claude-code` in the `init` command with your actual agent name (`cursor`, `codex`, `cline`, `aider`, or any short label). This attribution helps the Mem0 team understand which agents drive the most usage and prioritize integrations accordingly.
-**Forgot `--agent-caller` on init?** Run `mem0 identify ` after the fact: same key, just back-fills the attribution. Idempotent.
+**Forgot `--agent-caller` on init?** Run `mem0 identify ` after the fact, same key, just back-fills the attribution. Idempotent.
## What happened when you ran `mem0 init --agent`?
@@ -54,13 +54,13 @@ Replace `claude-code` in the `init` command with your actual agent name (`cursor
- A **shadow account** was minted on the Mem0 backend with a fresh API key.
- The key was saved to `~/.mem0/config.json` (mode 0600) on the machine you ran the command on.
- A default `user_id` was provisioned so `mem0 add` / `mem0 search` work without explicit scope flags.
-- The account is **unclaimed**: no human owns it yet.
+- The account is **unclaimed**; no human owns it yet.
Every command run against this key prints a one-line reminder asking you to surface the claim instructions to your human user.
## Claiming the account (for the human owner)
-When the human is ready to take ownership of the agent's account: and all the memories it has accumulated: they run:
+When the human is ready to take ownership of the agent's account (and all the memories it has accumulated), they run:
```bash
mem0 init --email you@yourcompany.com
@@ -68,7 +68,7 @@ mem0 init --email you@yourcompany.com
The CLI detects the existing Agent Mode config, sends a verification code, and upgrades the shadow account in-place:
-- **The API key never changes**: the agent isn't disrupted.
+- **The API key never changes**, so the agent isn't disrupted.
- **All memories transfer** to the human's account.
- **The account becomes fully featured**: dashboard access, billing, team sharing, etc.
@@ -97,7 +97,7 @@ How `add`, `search`, `update`, and `delete` work under the hood.
-Connect agents to Mem0 via the Model Context Protocol: alternative integration path.
+Connect agents to Mem0 via the Model Context Protocol, as an alternative integration path.
diff --git a/docs/platform/cli.mdx b/docs/platform/cli.mdx
index 18fdc2fb7..dd414a7ba 100644
--- a/docs/platform/cli.mdx
+++ b/docs/platform/cli.mdx
@@ -1,6 +1,6 @@
---
title: CLI
-description: "Manage memories from your terminal: built for both humans and AI agents."
+description: "Manage memories from your terminal, for both humans and AI agents."
icon: "terminal"
iconType: "solid"
---
@@ -273,7 +273,7 @@ mem0 version
After running `mem0 init --agent`, the CLI persists a server-issued identifier
(`default_user_id`, e.g. `user_a1b2c3d4e5f6`) in `~/.mem0/config.json`. This
-value is the agent's stable identity: surfaced as the row key on the
+value is the agent's stable identity, surfaced as the row key on the
[AGENTRUSH leaderboard](https://mem0.ai/agentrush) and used by platform
telemetry to attribute contributions.
@@ -286,11 +286,11 @@ mem0 whoami
```
No network call. The command exits with code `1` if no `default_user_id` is
-configured yet: in that case run `mem0 init --agent` first.
+configured yet. In that case, run `mem0 init --agent` first.
## AGENTRUSH: `mem0 agent-rush `
-AGENTRUSH is a 7-day public competition where AI agents: not humans: compete
+AGENTRUSH is a 7-day public competition where AI agents (not humans) compete
inside a single shared Mem0 project. Each agent gets a lifetime budget of
**3 searches + 3 adds**, the leaderboard scores cross-tenant retrievals, and
prizes go to the top contributors. See [mem0.ai/agentrush](https://mem0.ai/agentrush)
@@ -307,12 +307,12 @@ server-side.
# 1. Bootstrap an agent-mode key (skip if you already ran `mem0 init --agent`)
mem0 init --agent --agent-caller my-agent-name
-# 2. Three searches: the search-first rule blocks adds until you've done this
+# 2. Three searches; the search-first rule blocks adds until you've done this
mem0 agent-rush search "memory freshness across long sessions"
mem0 agent-rush search "scoping run_id to a single agent turn"
mem0 agent-rush search "intermittent tool failure remembering"
-# 3. Three adds: the content that gets retrieved earns you leaderboard points
+# 3. Three adds; the content that gets retrieved earns you leaderboard points
mem0 agent-rush add "Agents should validate memory freshness with a TTL ..."
mem0 agent-rush add "Scoping memories by run_id avoids cross-session ..."
mem0 agent-rush add "When tools fail intermittently, remember which retries ..."
@@ -351,7 +351,7 @@ identifying information.** The acknowledgement is stored under
once per machine.
When the CLI is invoked by an agent in a non-interactive (no-TTY) context,
-the warning prints to stderr and the add proceeds: agents cannot answer
+the warning prints to stderr and the add proceeds. Agents cannot answer
y/N prompts. Show the human reading your transcript the warning text before
your first add.
@@ -365,7 +365,7 @@ All commands support the `--output` flag to control how results are displayed:
| `json` | Structured JSON, suitable for piping to `jq` or consumption by AI agents |
| `table` | Tabular format (default for `list`) |
| `quiet` | Minimal output: just IDs or status codes |
-| `agent` | Structured JSON envelope with sanitized fields: set automatically by `--json`/`--agent` |
+| `agent` | Structured JSON envelope with sanitized fields, set automatically by `--json`/`--agent` |
Example with JSON output:
@@ -419,7 +419,7 @@ mem0 --agent delete --all --user-id user-42 --force
Two other agent-friendly features:
-- **`--output json`** returns structured data without sanitization: useful when you want the full raw API response
+- **`--output json`** returns structured data without sanitization, useful when you want the full raw API response
- **`mem0 help --json`** returns the complete command tree as JSON, so agents can self-discover available commands and options
For non-interactive environments (CI, agent runtimes), set credentials via `mem0 init --api-key m0-xxx --user-id alice --force` or the `MEM0_API_KEY` environment variable.
diff --git a/docs/platform/features/graph-memory.mdx b/docs/platform/features/graph-memory.mdx
index 9ea07f950..aeea23dcc 100644
--- a/docs/platform/features/graph-memory.mdx
+++ b/docs/platform/features/graph-memory.mdx
@@ -1,8 +1,6 @@
---
title: "Graph Memory"
description: "Mem0 Platform builds a native graph linking people, places, and concepts across your memories, with no external graph database to provision."
-icon: "circle-nodes"
-iconType: "solid"
---
Mem0 Platform automatically organizes your memories into a **graph**: the **graph entities** mentioned across your memories (the people, places, organizations, and concepts they refer to) become nodes, and memories that share an entity are connected. This is how Mem0 reasons across separate facts, for example linking everything it knows about a person, a company, or a project, without you defining any schema.
diff --git a/docs/platform/features/mcp-integration.mdx b/docs/platform/features/mcp-integration.mdx
deleted file mode 100644
index 8334fa539..000000000
--- a/docs/platform/features/mcp-integration.mdx
+++ /dev/null
@@ -1,157 +0,0 @@
----
-title: MCP Integration
-description: "Connect any AI client to Mem0 using Model Context Protocol for universal memory access"
----
-
-> Model Context Protocol (MCP) provides a standardized way for AI agents to manage their own memory through Mem0, without manual API calls.
-
-## Why use MCP
-
-When building AI applications, memory management often requires manual integration. MCP eliminates this complexity by:
-
-- **Universal compatibility**: Works with any MCP-compatible client (Claude, Claude Code, Cursor, Windsurf, VS Code, OpenCode)
-- **Agent autonomy**: AI agents decide when to save, search, or update memories
-- **Zero infrastructure**: No servers to maintain - Mem0's cloud MCP handles everything
-- **Standardized protocol**: One integration works across all your AI tools
-
-## Setup
-
-Add Mem0 MCP to all supported clients with a single command:
-
-```bash
-npx mcp-add \
- --name mem0-mcp \
- --type http \
- --url "https://mcp.mem0.ai/mcp" \
- --clients "claude,claude code,cursor,windsurf,vscode,opencode"
-```
-
-Or configure a specific client:
-
-```bash
-npx mcp-add \
- --name mem0-mcp \
- --type http \
- --url "https://mcp.mem0.ai/mcp" \
- --clients "cursor"
-```
-
-For manual configuration, add this to your MCP client config:
-
-```json
-{
- "mcpServers": {
- "mem0-mcp": {
- "type": "http",
- "url": "https://mcp.mem0.ai/mcp"
- }
- }
-}
-```
-
-For detailed per-client instructions, see the [Mem0 MCP Quickstart](/platform/mem0-mcp).
-
-## Available tools
-
-The MCP server exposes 11 memory tools to your AI client:
-
-| Tool | Purpose |
-|------|---------|
-| `add_memory` | Store conversations or facts |
-| `search_memories` | Find relevant memories with filters |
-| `get_memories` | List memories with pagination |
-| `update_memory` | Modify existing memory content |
-| `delete_memory` | Remove specific memories |
-| `delete_all_memories` | Bulk delete memories |
-| `delete_entities` | Remove user/agent/app entities |
-| `get_memory` | Retrieve single memory by ID |
-| `list_entities` | View stored entities |
-| `list_events` | List memory operation events with filters and pagination |
-| `get_event_status` | Check the status of an async memory operation by `event_id` |
-
-## How it works
-
-1. **Configure the MCP server** - Add Mem0 MCP to your AI client using the setup command above
-2. **Agent connects** - Your AI client connects to Mem0's cloud MCP server over HTTP
-3. **Autonomous memory** - The agent decides when to store/retrieve memories as part of its reasoning
-4. **No manual API calls** - The agent manages memory automatically through MCP tools
-
-## Example interactions
-
-Once connected, your AI agent can:
-
-```
-User: Remember that I'm allergic to peanuts
-Agent: [calls add_memory] Got it! I've saved your peanut allergy.
-
-User: What dietary restrictions do I know about?
-Agent: [calls search_memories] You have a peanut allergy.
-```
-
-The agent automatically decides when to use memory tools based on context.
-
-## Try these prompts
-
-```python
-# Multi-task operations
-"Generate 5 user personas for our e-commerce app with different demographics, store them all, then search for existing personas"
-
-# Natural context retrieval
-"Anything about my work preferences I should remember?"
-
-# Complex information updates
-"Update my current project: the mobile app is now 80% complete, we've fixed the login issues, and the launch date is March 15"
-
-# Time-based queries
-"What meetings did I have last week about Project Phoenix?"
-
-# Memory cleanup
-"Delete all test data and temporary memories from our development phase"
-
-# Personal preferences
-"I drink oat milk cappuccino with one sugar every morning, and I prefer standing desks"
-
-# Health and wellness tracking
-"I'm allergic to peanuts and shellfish, and I go for 5km runs on weekday mornings"
-```
-
-These examples demonstrate how MCP enables natural language memory operations - the AI agent automatically determines when to add, search, update, or delete memories based on context.
-
-## What you can do
-
-The Mem0 MCP server enables powerful memory capabilities for your AI applications:
-
-- **Health tracking**: "I'm allergic to peanuts and shellfish" - Add new health information
-- **Research data**: "Store these trial parameters: 200 participants, double-blind, placebo-controlled" - Save structured data
-- **Preference queries**: "What do you know about my dietary preferences?" - Search and retrieve relevant memories
-- **Project updates**: "Update my project status: the mobile app is now 80% complete" - Modify existing memory
-- **Data cleanup**: "Delete all memories from 2023" - Bulk remove outdated information
-- **Topic overview**: "Show me everything about Project Phoenix" - List all memories for a subject
-
-## Performance tips
-
-- Use specific filters when searching large memory sets
-- Batch operations when adding multiple memories
-- Monitor memory usage in the Mem0 dashboard
-
-## Best practices
-
-- **Use the cloud MCP**: The hosted MCP server at `https://mcp.mem0.ai/mcp` handles infrastructure for you
-- **Use wildcards**: `user_id: "*"` to search across all users
-- **Monitor usage**: Track memory operations in the dashboard
-- **Document patterns**: Share successful prompt patterns with your team
-
-
-
diff --git a/docs/platform/features/platform-overview.mdx b/docs/platform/features/platform-overview.mdx
deleted file mode 100644
index 510b62808..000000000
--- a/docs/platform/features/platform-overview.mdx
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: Overview
-description: "See how Mem0 Platform features evolve from baseline filters to advanced retrieval."
-icon: "list"
----
-
-Mem0 Platform features help managed deployments scale from basic filtering to advanced retrieval and data governance. Use this page to pick the right feature lane for your team.
-
-
- New to the platform? Start with the Platform quickstart,
- then dive into the journeys below.
-
-
-## Choose your path
-
-
-
- Field-level filtering with async defaults.
-
-
- Non-blocking add/search requests for agents.
-
-
- Metadata filters, rerankers, and toggles.
-
-
- Imports, exports, timestamps, and expirations.
-
-
- Universal memory integration via MCP.
-
-
-
-
- Self-hosting instead? Jump to the{" "}
- OSS feature overview for equivalent
- capabilities.
-
-
-## Keep going
-
-
-
diff --git a/docs/platform/features/temporal-reasoning.mdx b/docs/platform/features/temporal-reasoning.mdx
index a2a630fb7..9853b708c 100644
--- a/docs/platform/features/temporal-reasoning.mdx
+++ b/docs/platform/features/temporal-reasoning.mdx
@@ -1,7 +1,6 @@
---
title: Temporal Reasoning
description: "Time-aware memory retrieval for Mem0 Platform v3 so queries like 'last week', 'upcoming', and 'right now' return the right memories."
-icon: "clock"
badge: "v3"
---
diff --git a/docs/platform/mem0-mcp.mdx b/docs/platform/mem0-mcp.mdx
index f7188ae6e..894915447 100644
--- a/docs/platform/mem0-mcp.mdx
+++ b/docs/platform/mem0-mcp.mdx
@@ -9,7 +9,7 @@ estimatedTime: "~2 minutes"
**Prerequisites**
- Mem0 Platform account (Sign up here)
- API key (Get one from dashboard)
- - Node.js 18+ (for npx)
+ - Node.js 14+ (for npx)
- An MCP-compatible client (Claude, Claude Code, Codex, Cursor, Windsurf, VS Code, OpenCode)
@@ -97,7 +97,7 @@ You can also configure individual clients:
bearer_token_env_var = "MEM0_API_KEY"
```
- Export `MEM0_API_KEY` in the shell you launch Codex from, then restart Codex. `codex mcp add` only supports stdio servers, so HTTP servers must be added via `config.toml` directly: or via the **Plugins → Connect to a custom MCP → Streamable HTTP** UI in the Codex app.
+ Export `MEM0_API_KEY` in the shell you launch Codex from, then restart Codex. `codex mcp add` only supports stdio servers, so HTTP servers must be added via `config.toml` directly, or via the **Plugins → Connect to a custom MCP → Streamable HTTP** UI in the Codex app.
Codex uses the server name `mem0` (not `mem0-mcp` like the other clients on this page) so it matches the name the bundled plugin registers if you ever sideload it later.
@@ -110,7 +110,7 @@ You can also configure individual clients:
codex plugin marketplace add ~/codex-plugins/mem0-source
```
- Then run `codex` and `/plugins`, browse the **Mem0 Plugins** marketplace, and install **Mem0**. Don't combine this with the Direct MCP setup above: the sideloaded plugin auto-registers `mem0` via `.codex-mcp.json`, so a manual `[mcp_servers.mem0]` block would create a duplicate.
+ Then run `codex` and `/plugins`, browse the **Mem0 Plugins** marketplace, and install **Mem0**. Don't combine this with the Direct MCP setup above; the sideloaded plugin auto-registers `mem0` via `.codex-mcp.json`, so a manual `[mcp_servers.mem0]` block would create a duplicate.
See the [Codex integration guide](/integrations/codex) for full details, lifecycle-hook setup, and management commands (`codex plugin marketplace upgrade` / `remove`).
@@ -205,24 +205,8 @@ Agent: Updated your project status successfully.
---
-## Next Steps
+## Next steps
-
-
-
-## Additional Resources
-
-- **[Platform Quickstart](/platform/quickstart)** - Direct API integration guide
-- **[MCP Specification](https://modelcontextprotocol.io)** - Learn about MCP protocol
+- [Platform Quickstart](/platform/quickstart) - direct SDK/API integration guide
+- [MCP Specification](https://modelcontextprotocol.io) - the Model Context Protocol standard
+- [Gemini with Mem0 MCP](/cookbooks/frameworks/gemini-3-with-mem0-mcp) - example integration cookbook
diff --git a/docs/platform/overview.mdx b/docs/platform/overview.mdx
index 61fa8463d..bc91d6a70 100644
--- a/docs/platform/overview.mdx
+++ b/docs/platform/overview.mdx
@@ -1,89 +1,62 @@
---
title: "Overview"
-description: "Managed memory layer for AI agents - production-ready in minutes"
+description: "Managed memory layer for AI agents, production-ready in minutes"
icon: "cloud"
---
-# Mem0 Platform Overview
+Mem0 Platform is the fully managed memory layer for your AI apps and agents. Your users stop repeating themselves and your agents keep context across sessions, with no vector store, reranker, or infrastructure to run.
-Mem0 is the memory engine that keeps conversations contextual so users never repeat themselves and your agents respond with continuity. Mem0 Platform delivers that experience as a fully managed service: scaling, securing, and enriching memories without any infrastructure work on your side.
+## Why teams pick the Platform
-## Why it matters
+- **Personalized replies.** Memories persist across users and agents, cutting prompt bloat and repeat questions.
+- **Zero infrastructure.** Mem0 runs the vector store and rerankers, so there is nothing to provision, tune, or maintain.
+- **Enterprise-ready.** Audit logs and workspace governance ship by default.
-- **Personalized replies**: Memories persist across users and agents, cutting prompt bloat and repeat questions.
-- **Hosted stack**: Mem0 runs the vector store and rerankers: no provisioning, tuning, or maintenance.
-- **Enterprise controls**: Audit logs and workspace governance ship by default for production readiness.
+## How it works
+
+
+
+ Send Mem0 your messages and conversations.
+
+
+ Mem0 distills them into facts and links entities across memories.
+
+
+ At query time, Mem0 returns only the most relevant memories.
+
+
+
+For the full pipeline, see [How Mem0 works](/core-concepts/how-it-works).
| Feature | Why it helps |
| --- | --- |
- | Fast setup | Add a few lines of code and you’re production-ready: no vector database or LLM configuration required. |
+ | Fast setup | Add a few lines of code and you're production-ready, with no vector database or LLM configuration required. |
| Production scale | Automatic scaling, high availability, and managed infrastructure so you focus on product work. |
- | Advanced features | webhooks, multimodal support, and custom categories are ready to enable. |
+ | Advanced features | Webhooks, multimodal support, and custom categories are ready to enable. |
| Enterprise ready | Audit logs, workspace governance, and dedicated support keep security and governance covered. |
-
- Start with the Platform quickstart to provision your workspace, then pick the journey below that matches your next milestone.
-
-
-## Choose your path
-
-
-
- Create project and ship first memory.
-
-
- Use MCP for universal AI integration.
-
-
- User, agent, and session memory behavior.
-
-
-
-
-
- Add, search, update, and delete workflows.
-
-
- async clients and rerankers.
-
-
- Metadata filters and per-request toggles.
-
-
+## Explore the Platform
-
- LangChain, CrewAI, Vercel AI SDK.
+
+ The extraction and retrieval pipeline, end to end.
-
- Track activity and manage workspaces.
+
+ Get an API key and save your first memory.
+
+
+ How user, agent, run, and session memory differ.
+
+
+ The core memory operations, end to end.
- Evaluating self-hosting instead? Jump to the Platform vs OSS comparison to see trade-offs before you commit.
+ Deciding whether to self-host? Compare hosting models in the Platform vs OSS guide, or switch tabs to the Open Source docs to run Mem0 yourself.
-
-## Keep going
-
-{/* DEBUG: verify CTA targets */}
-
-
-
diff --git a/docs/platform/platform-vs-oss.mdx b/docs/platform/platform-vs-oss.mdx
index f8f395f59..d24c38c1c 100644
--- a/docs/platform/platform-vs-oss.mdx
+++ b/docs/platform/platform-vs-oss.mdx
@@ -60,6 +60,10 @@ Mem0 offers two powerful ways to add memory to your AI applications. Choose base
| **Multimodal support** | ✅ | ✅ |
| **Custom categories** | ✅ | Limited |
| **Advanced retrieval** | ✅ | ✅ |
+ | **Criteria retrieval** | ✅ | ❌ |
+ | **Temporal reasoning** | ✅ (v3) | ❌ |
+ | **Memory decay** | ✅ (v3) | ❌ |
+ | **Graph memory** | ✅ Built-in | ✅ External graph store |
| **Memory filters v2** | ✅ | ⚠️ (via metadata) |
| **Webhooks** | ✅ | ❌ |
| **Memory export** | ✅ | ❌ |
@@ -71,8 +75,8 @@ Mem0 offers two powerful ways to add memory to your AI applications. Choose base
| **Hosting** | Managed by Mem0 | Self-hosted |
| **Auto-scaling** | ✅ | Manual |
| **High availability** | ✅ Built-in | DIY setup |
- | **Vector DB choice** | Managed | Qdrant, Chroma, Pinecone, Milvus, +20 more |
- | **LLM choice** | Managed (optimized) | OpenAI, Anthropic, Ollama, Together, +10 more |
+ | **Vector DB choice** | Managed | 20+ stores: Qdrant, Pinecone, Chroma, Weaviate, Milvus, pgvector |
+ | **LLM choice** | Managed (optimized) | 15+ providers: OpenAI, Anthropic, Gemini, Groq, Ollama, Together |
| **Data residency** | US (expandable) | Your choice |
@@ -88,10 +92,10 @@ Mem0 offers two powerful ways to add memory to your AI applications. Choose base
| Feature | Platform | Open Source |
|---------|----------|-------------|
- | **REST API** | ✅ | ✅ (via feature flag) |
+ | **REST API** | ✅ | ✅ (self-hosted server) |
| **Python SDK** | ✅ | ✅ |
| **JavaScript SDK** | ✅ | ✅ |
- | **Framework integrations** | LangChain, CrewAI, LlamaIndex, +15 | Same |
+ | **Framework integrations** | LangChain, CrewAI, LlamaIndex, and 20+ more | Same |
| **Dashboard** | ✅ Web-based | ❌ |
| **Analytics** | ✅ Built-in | DIY |
@@ -101,45 +105,17 @@ Mem0 offers two powerful ways to add memory to your AI applications. Choose base
## Decision Guide
-### Choose **Platform** if you want:
+**Choose Platform if you want:**
+- Fast time to market: get your AI app with memory live in hours, not weeks.
+- Production-ready hosting: auto-scaling, high availability, and managed infrastructure.
+- Built-in analytics: track memory usage, query patterns, and user engagement through the dashboard.
+- Advanced features: webhooks, memory export, custom categories, and priority support.
-
-
- Get your AI app with memory live in hours, not weeks. No infrastructure setup needed.
-
-
-
- Auto-scaling, high availability, and managed infrastructure out of the box.
-
-
-
- Track memory usage, query patterns, and user engagement through our dashboard.
-
-
-
- Access to webhooks, memory export, custom categories, and priority support.
-
-
-
-### Choose **Open Source** if you need:
-
-
-
- Host everything on your infrastructure. Complete data residency and privacy control.
-
-
-
- Choose your own vector DB, LLM provider, embedder, and deployment strategy.
-
-
-
- Modify the codebase, add custom features, and contribute back to the community.
-
-
-
- Use local LLMs (Ollama), self-hosted vector DBs, and optimize for your specific use case.
-
-
+**Choose Open Source if you need:**
+- Full data control: host everything on your infrastructure with complete data residency.
+- Custom configuration: choose your own vector DB, LLM provider, embedder, and deployment strategy.
+- Extensibility: modify the codebase, add custom features, and contribute back to the community.
+- Cost optimization: use local LLMs (Ollama), self-hosted vector DBs, and optimize for your use case.
---
diff --git a/docs/platform/quickstart.mdx b/docs/platform/quickstart.mdx
index 5e97dcc4b..1e876c122 100644
--- a/docs/platform/quickstart.mdx
+++ b/docs/platform/quickstart.mdx
@@ -147,24 +147,22 @@ mem0 search "What are my dietary restrictions?" --user-id user123
**Pro Tip**: Want AI agents to manage their own memory automatically? Use Mem0 MCP to let LLMs decide when to save, search, and update memories.
-## What's Next?
+## What's next?
+
+You stored and searched your first memory. Keep going:
-
-Learn how to search, update, and delete memories with complete CRUD operations
+
+ See how Mem0 extracts, stores, and retrieves memories under the hood.
-
- Explore advanced features like metadata filtering and webhooks
+
+ Go beyond add and search: update, delete, and the full memory lifecycle.
-
-See complete API documentation and integration examples
+
+ Put it to work in a real app, end to end, in about 10 minutes.
-## Additional Resources
-
-- **[Platform vs OSS](/platform/platform-vs-oss)** - Understand the differences between Platform and Open Source
-- **[Troubleshooting](/platform/faqs)** - Common issues and solutions
-- **[Integration Examples](/cookbooks/companions/quickstart-demo)** - See Mem0 in action
+Stuck on setup? See the [FAQs and troubleshooting](/platform/faqs).
diff --git a/docs/vibecoding.mdx b/docs/vibecoding.mdx
index 1e559ecf7..dabbf12a1 100644
--- a/docs/vibecoding.mdx
+++ b/docs/vibecoding.mdx
@@ -11,20 +11,11 @@ We follow the llms.txt standard:
- [llms.txt](https://docs.mem0.ai/llms.txt)
-
-
- Sign up for Mem0 Platform and start building
-
-
- Store your first memory in under 5 minutes
-
-
-
## Agent Skills
Mem0 ships two kinds of skills for AI coding assistants. Both work with Claude Code, Codex, Cursor, Windsurf, OpenCode, OpenClaw, and any assistant that supports the skills standard.
-### Reference skills: always on
+### Reference skills (always on)
Teach your assistant Mem0's SDK surface so it writes correct code in everyday development:
@@ -38,7 +29,7 @@ npx skills add https://github.com/mem0ai/mem0 --skill mem0-vercel-ai-sdk
- `mem0-cli`: terminal workflows for the `mem0` CLI (both Node and Python builds)
- `mem0-vercel-ai-sdk`: `@mem0/vercel-ai-provider` and `createMem0`
-### Pipeline skills: run on demand
+### Pipeline skills (run on demand)
Let your assistant execute an end-to-end workflow in an existing repo. Invoked as slash commands:
@@ -75,7 +66,7 @@ For per-client setup and advanced options, see [Mem0 MCP Setup](/platform/mem0-m
Copy this into any AI tool to start building with Mem0:
```text
-I want to start building with Mem0: a self-improving memory layer for LLM
+I want to start building with Mem0, a self-improving memory layer for LLM
applications that gives agents persistent context across sessions.
## Mem0 Resources
@@ -95,7 +86,7 @@ applications that gives agents persistent context across sessions.
- Cookbooks: https://docs.mem0.ai/cookbooks/overview
**What Mem0 Does:**
-Mem0 is a memory layer for AI apps: managed (Mem0 Platform) or self-hosted
+Mem0 is a memory layer for AI apps, managed (Mem0 Platform) or self-hosted
(Open Source). It stores, retrieves, and manages user memories so agents
remember preferences, learn from interactions, and personalize over time.
Sub-50ms retrieval. Storage: vector embeddings.
Build with Mem0
-+
Universal, self-improving memory layer for LLM applications.
- - - Write your first memory - → -
- Mem0 Platform + Add memory to your app
- Managed memory with production-scale infrastructure, ready in minutes. + Start with the quickstart and store your first memory in minutes.
- Mem0 Open Source + Add memory to your agent
- Self-host the Mem0 stack for full control over data, deployment, and customization. + Give Claude Code, Cursor, and Codex memory that persists across sessions. A drop-in plugin, no code to write. +
+
+
+
+
+
+
+
+ + Sign up for Mem0 as an agent +
++ Let an AI agent mint a Mem0 API key, claim ownership later, and write its first memory from the terminal. +
+
+
+
+
@@ -96,88 +138,36 @@ mode: "custom"
/>
+ Explore Mem0 integrations +
++ Connect Mem0 to LangChain, CrewAI, Vercel AI SDK, and 20+ partner frameworks.
- Cookbooks + See memory-app examples
- Production-ready tutorials that show how to ship memorable AI experiences. + Browse cookbooks for companions, support agents, voice agents, research tools, and more.
- Integrations + Self-host Mem0
- Connect Mem0 to LangChain, CrewAI, Vercel AI SDK, and 20+ partner frameworks. -
-
-
-
-
-
-
-
- - API Reference -
-- Explore every REST endpoint with payload examples and usage guidance. -
-
-
-
-
diff --git a/docs/llms.txt b/docs/llms.txt
index a05dd5e62..21daabcd9 100644
--- a/docs/llms.txt
+++ b/docs/llms.txt
@@ -6,7 +6,7 @@
### Don't have a Mem0 API key?
-Install the CLI, then mint a key — no email, no dashboard, no OTP required:
+Install the CLI, then mint a key without email, dashboard, or OTP:
```bash
# Python
@@ -16,7 +16,7 @@ pip install mem0-cli
npm install -g @mem0/cli
```
-Then run: `mem0 init --agent --agent-caller - Sign up as an agent -
-- For AI agents: mint a Mem0 API key in under five seconds: no email, no dashboard. Four commands to your first memory. + Use Open Source when you want memory without the hosted platform.