chore: remove integration page from the docs

Co-authored-by: Livia Ellen <liviaellen@msn.com>

.github/workflows/ci.yml

@@ -14,8 +14,48 @@ on:
       - 'mem0/**'
       - 'tests/**'
       - 'embedchain/**'
+      - 'pyproject.toml'
 
 jobs:
+  changelog_check:
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Require CHANGELOG entry when Python SDK version changes
+        env:
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: |
+          set -euo pipefail
+
+          extract_version() {
+            python3 -c "import sys, re; m = re.search(r'^\s*version\s*=\s*\"([^\"]+)\"', sys.stdin.read(), re.M); print(m.group(1) if m else '')"
+          }
+
+          base_version=$(git show "$BASE_SHA:pyproject.toml" 2>/dev/null | extract_version || echo "")
+          head_version=$(extract_version < pyproject.toml)
+
+          echo "Base version: ${base_version:-<unknown>}"
+          echo "Head version: $head_version"
+
+          if [ -z "$base_version" ] || [ "$base_version" = "$head_version" ]; then
+            echo "pyproject.toml version unchanged — no CHANGELOG entry required."
+            exit 0
+          fi
+
+          echo "Detected version bump ${base_version} -> ${head_version}. Checking docs/changelog/sdk.mdx…"
+
+          if git diff --name-only "$BASE_SHA" "$HEAD_SHA" -- docs/changelog/sdk.mdx | grep -q .; then
+            echo "Changelog update present in docs/changelog/sdk.mdx ✅"
+          else
+            echo "::error file=pyproject.toml::pyproject.toml version changed from ${base_version} to ${head_version} but docs/changelog/sdk.mdx was not updated in this PR. Add a new <Update> entry under the Python tab for v${head_version}."
+            exit 1
+          fi
+
   check_changes:
     runs-on: ubuntu-latest
     outputs:

.github/workflows/docs-llms-txt-check.yml

@@ -0,0 +1,45 @@
+name: docs - llms.txt check
+
+# Blocks PRs that introduce new .mdx pages without a matching entry in
+# docs/llms.txt, or that link to pages that no longer exist. Contributors
+# must update docs/llms.txt in the same PR. Run locally with:
+#   python scripts/check-llms-txt-coverage.py           # read-only
+#   python scripts/check-llms-txt-coverage.py --write   # scaffold placeholders
+
+on:
+  pull_request:
+    paths:
+      - 'docs/**/*.mdx'
+      - 'docs/llms.txt'
+      - 'scripts/check-llms-txt-coverage.py'
+      - 'scripts/llms-txt-ignore.txt'
+  workflow_dispatch: {}
+
+permissions:
+  contents: read
+
+jobs:
+  check-llms-txt:
+    runs-on: ubuntu-24.04-arm
+    timeout-minutes: 2
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Verify docs/llms.txt coverage
+        run: |
+          if ! python3 scripts/check-llms-txt-coverage.py; then
+            echo ""
+            echo "::error title=llms.txt out of sync::docs/llms.txt does not match docs/**/*.mdx."
+            echo ""
+            echo "To fix:"
+            echo "  1. Run locally:  python scripts/check-llms-txt-coverage.py --write"
+            echo "     This appends placeholder entries under '## Unclassified - needs triage'."
+            echo "  2. For each placeholder:"
+            echo "       - replace [TODO: Platform|OSS|Both] with the correct scope tag"
+            echo "       - rewrite the description as 'Use when ...'"
+            echo "       - move the entry into the appropriate section"
+            echo "       - delete the '## Unclassified - needs triage' heading once empty"
+            echo "  3. Resolve any stale URLs listed above by updating or removing the link."
+            echo "  4. Commit the updated docs/llms.txt to this PR."
+            exit 1
+          fi

.github/workflows/ts-sdk-ci.yml

@@ -24,6 +24,42 @@ jobs:
             ts_sdk:
               - 'mem0-ts/**'
 
+  changelog_check:
+    needs: check_changes
+    if: github.event_name == 'pull_request' && needs.check_changes.outputs.ts_sdk_changed == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Require CHANGELOG entry when SDK version changes
+        env:
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: |
+          set -euo pipefail
+
+          base_version=$(git show "$BASE_SHA:mem0-ts/package.json" 2>/dev/null | jq -r .version || echo "")
+          head_version=$(jq -r .version mem0-ts/package.json)
+
+          echo "Base version: ${base_version:-<unknown>}"
+          echo "Head version: $head_version"
+
+          if [ -z "$base_version" ] || [ "$base_version" = "$head_version" ]; then
+            echo "mem0-ts/package.json version unchanged — no CHANGELOG entry required."
+            exit 0
+          fi
+
+          echo "Detected version bump ${base_version} -> ${head_version}. Checking docs/changelog/sdk.mdx…"
+
+          if git diff --name-only "$BASE_SHA" "$HEAD_SHA" -- docs/changelog/sdk.mdx | grep -q .; then
+            echo "Changelog update present in docs/changelog/sdk.mdx ✅"
+          else
+            echo "::error file=mem0-ts/package.json::mem0-ts/package.json version changed from ${base_version} to ${head_version} but docs/changelog/sdk.mdx was not updated in this PR. Add a new <Update> entry under the TypeScript tab for v${head_version}."
+            exit 1
+          fi
+
   build_ts_sdk:
     needs: check_changes
     if: needs.check_changes.outputs.ts_sdk_changed == 'true'

AGENTS.md

@@ -35,6 +35,7 @@ This is a **polyglot monorepo** containing Python and TypeScript packages, CLIs,
 | `cookbooks/` | Jupyter notebooks — customer support chatbot, AutoGen integration |
 | `embedchain/` | Legacy Embedchain RAG framework (maintained separately, Poetry-based) |
 | `pr-reviews/` | Pull request review materials |
+| `scripts/` | Repo-wide utility scripts (e.g., `check-llms-txt-coverage.py` for docs/llms.txt sync) |
 
 ### Core Package Dependencies
 
@@ -433,6 +434,7 @@ To add a new LLM, embedding, vector store, or reranker provider:
 |----------|------|---------|
 | Issue Labeler | `issue-labeler.yml` | Automatic issue labeling |
 | Stale Bot | `stale.yml` | Marks stale issues and PRs |
+| llms.txt Check | `docs-llms-txt-check.yml` | Blocks PRs touching `docs/**/*.mdx` when `docs/llms.txt` is out of sync. Fix locally with `python scripts/check-llms-txt-coverage.py --write`. |
 
 ## Task Completion Guidelines
 
@@ -451,6 +453,7 @@ These guidelines outline typical artifacts for different task types. Use judgmen
 2. **Unit tests**: Comprehensive test coverage for new functionality
 3. **Documentation**: Update relevant docs in `docs/` for public APIs
 4. **Examples**: Add usage examples if the feature introduces new user-facing behavior
+5. **llms.txt**: Any new `.mdx` page under `docs/` must be linked in `docs/llms.txt` with a scope tag (`[Platform]` / `[OSS]` / `[Both]`) and a `Use when ...` description. The `docs-llms-txt-check.yml` workflow runs on every PR that touches docs and **fails the check** if the index is out of sync. To fix: run `python scripts/check-llms-txt-coverage.py --write` locally to scaffold placeholders under `## Unclassified - needs triage`, then replace the `[TODO: ...]` tags, rewrite descriptions as `Use when ...`, move entries into the right section, and delete the triage heading when empty.
 
 ### New Provider (LLM / Embedding / Vector Store / Reranker)
 

README.md

@@ -41,16 +41,30 @@
 <p align="center">
   <a href="https://mem0.ai/research"><strong>📄 Building Production-Ready AI Agents with Scalable Long-Term Memory →</strong></a>
 </p>
-<p align="center">
-  <strong>⚡ +26% Accuracy vs. OpenAI Memory • 🚀 91% Faster • 💰 90% Fewer Tokens</strong>
-</p>
 
-> **🎉 mem0ai v1.0.0 is now available!** This major release includes API modernization, improved vector store support, and enhanced GCP integration. [See migration guide →](MIGRATION_GUIDE_v1.0.md)
+## New Memory Algorithm (April 2026)
 
-##  🔥 Research Highlights
-- **+26% Accuracy** over OpenAI Memory on the LOCOMO benchmark
-- **91% Faster Responses** than full-context, ensuring low-latency at scale
-- **90% Lower Token Usage** than full-context, cutting costs without compromise
+| Benchmark | Old | New  | Tokens  | Latency p50  |
+| --- | --- | --- | --- | --- |
+| **LoCoMo** | 71.4 | **91.6** | 7.0K  | 0.88s  |
+| **LongMemEval** | 67.8 | **93.4** | 6.8K  | 1.09s  |
+| **BEAM (1M)** | — | **64.1** | 6.7K  | 1.00s  |
+| **BEAM (10M)** | — | **48.6** | 6.9K  | 1.05s  |
+
+All benchmarks run on the same production-representative model stack. Single-pass retrieval (one call, no agentic loops).
+
+**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.
+
+See the [migration guide](https://docs.mem0.ai/migration/oss-v2-to-v3) for upgrade instructions. The [evaluation framework](https://github.com/mem0ai/memory-benchmarks) is open-sourced so anyone can reproduce the numbers.
+
+## Research Highlights
+- **91.6 on LoCoMo** -- +20 points over the previous algorithm
+- **93.4 on LongMemEval** -- +26 points, with +53.6 on assistant memory recall
+- **64.1 on BEAM (1M)** -- production-scale memory evaluation at 1M tokens
 - [Read the full paper](https://mem0.ai/research)
 
 # Introduction
@@ -88,6 +102,13 @@ Install the sdk via pip:
 pip install mem0ai
 ```
 
+For enhanced hybrid search with BM25 keyword matching and entity extraction, install with NLP support:
+
+```bash
+pip install mem0ai[nlp]
+python -m spacy download en_core_web_sm
+```
+
 Install sdk via npm:
 ```bash
 npm install mem0ai
@@ -109,7 +130,9 @@ See the [CLI documentation](https://docs.mem0.ai/platform/cli) for the full comm
 
 ### Basic Usage
 
-Mem0 requires an LLM to function, with `gpt-4.1-nano-2025-04-14 from OpenAI as the default. However, it supports a variety of LLMs; for details, refer to our [Supported LLMs documentation](https://docs.mem0.ai/components/llms/overview).
+Mem0 requires an LLM to function, with `gpt-5-mini` from OpenAI as the default. However, it supports a variety of LLMs; for details, refer to our [Supported LLMs documentation](https://docs.mem0.ai/components/llms/overview).
+
+Mem0 uses `text-embedding-3-small` from OpenAI as the default embedding model. For best results with hybrid search (semantic + keyword + entity boosting), we recommend using at least [Qwen 600M](https://huggingface.co/Alibaba-NLP/gte-Qwen2-1.5B-instruct) or a comparable embedding model. See [Supported Embeddings](https://docs.mem0.ai/components/embedders/overview) for configuration details.
 
 First step is to instantiate the memory:
 
@@ -122,13 +145,13 @@ memory = Memory()
 
 def chat_with_memories(message: str, user_id: str = "default_user") -> str:
     # Retrieve relevant memories
-    relevant_memories = memory.search(query=message, user_id=user_id, limit=3)
+    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"])
 
     # Generate Assistant response
     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-4.1-nano-2025-04-14", messages=messages)
+    response = openai_client.chat.completions.create(model="gpt-5-mini", messages=messages)
     assistant_response = response.choices[0].message.content
 
     # Create new memories from the conversation

cookbooks/helper/mem0_teachability.py

@@ -56,7 +56,7 @@ class Mem0Teachability(AgentCapability):
 
     def process_last_received_message(self, text: Union[Dict, str]):
         expanded_text = text
-        if self.memory.get_all(agent_id=self.agent_id):
+        if self.memory.get_all(filters={"agent_id": self.agent_id}):
             expanded_text = self._consider_memo_retrieval(text)
         self._consider_memo_storage(text)
         return expanded_text
@@ -139,7 +139,7 @@ class Mem0Teachability(AgentCapability):
         return comment + self._concatenate_memo_texts(memo_list)
 
     def _retrieve_relevant_memos(self, input_text: str) -> list:
-        search_results = self.memory.search(input_text, agent_id=self.agent_id, limit=self.max_num_retrievals)
+        search_results = self.memory.search(input_text, filters={"agent_id": self.agent_id}, top_k=self.max_num_retrievals)
         memo_list = [result["memory"] for result in search_results if result["score"] <= self.recall_threshold]
 
         if self.verbosity >= 1 and not memo_list:

docs/_snippets/paper-release.mdx

@@ -1,3 +0,0 @@
-<Note type="info">
-  <strong>🎉 Mem0 1.0.0 is here!</strong> Enhanced filtering, reranking, and smarter memory management.
-</Note>

docs/api-reference/memory/get-memories.mdx

@@ -53,47 +53,3 @@ memories = client.get_all(
 
 </CodeGroup>
 
-## Graph Memory
-
-To retrieve graph memory relationships between entities, pass `output_format="v1.1"` in your request. This will return memories with entity and relationship information from the knowledge graph.
-
-<CodeGroup>
-```python Code
-memories = client.get_all(
-    filters={
-        "user_id": "alex"
-    }
-)
-```
-
-```python Output
-{
-    "results": [
-        {
-            "id": "f4cbdb08-7062-4f3e-8eb2-9f5c80dfe64c",
-            "memory": "Alex is planning a trip to San Francisco",
-            "entities": [
-                {
-                    "id": "entity-1",
-                    "name": "Alex",
-                    "type": "person"
-                },
-                {
-                    "id": "entity-2",
-                    "name": "San Francisco",
-                    "type": "location"
-                }
-            ],
-            "relations": [
-                {
-                    "source": "entity-1",
-                    "target": "entity-2",
-                    "relationship": "traveling_to"
-                }
-            ]
-        }
-    ]
-}
-```
-
-</CodeGroup>

docs/changelog/highlights.mdx

@@ -4,6 +4,26 @@ description: "Major product launches, headline features, and milestones for Mem0
 mode: "wide"
 ---
 
+<Update label="2026-04-14" description="Mem0 SDK v2.0.0 / v3.0.0">
+
+**New Memory Algorithm — State-of-the-Art Accuracy at ~3-4x Lower Cost**
+
+Ground-up rewrite of the memory pipeline with 20+ point benchmark improvements:
+
+- **LoCoMo:** 71.4 → **91.6** (+20) — multi-turn conversation recall
+- **LongMemEval:** 67.8 → **93.4** (+26) — long-term memory across sessions
+- **BEAM (1M tokens):** **64.1** — production-scale memory evaluation
+- **Agent memories are first-class** — Previous algorithm: 46% on assistant recall. New: **100%**
+- **Temporal reasoning works** — "Where did I live before SF?" Previous: 51%. New: **93%**
+- **~3-4x fewer tokens** — Under 7K tokens per retrieval vs 25K+ for full-context approaches
+- **ADD-only extraction** — Memories accumulate; nothing is overwritten or deleted
+- **Hybrid retrieval** — Semantic + BM25 keyword + entity boost, scored in parallel
+- **Entity linking** — Entities extracted, embedded, and linked across memories
+
+Breaking changes: Graph memory removed from OSS, `search()` defaults changed, deprecated params removed. See [migration guide](/migration/oss-v2-to-v3).
+
+</Update>
+
 <Update label="2026-04-06" description="Mem0 Skill Graph">
 
 **Mem0 Skill Graph — In-Context Documentation for AI Agents**
@@ -31,7 +51,7 @@ A full-featured command-line interface for Mem0, available in both Python and No
 
 </Update>
 
-<Update label="2026-04-04" description="OpenClaw v1.0.4">
+<Update label="2026-04-06" description="OpenClaw v1.0.4">
 
 **OpenClaw Plugin — Production-Ready**
 

docs/changelog/openclaw.mdx

@@ -4,6 +4,19 @@ description: "Release notes for the OpenClaw plugin and agent harness."
 mode: "wide"
 ---
 
+<Update label="2026-04-20" description="v1.0.7">
+
+**New Features:**
+- **Chat-Based Setup:** Added chat-based Platform setup flow — users can now configure the plugin conversationally instead of editing config files manually
+- **Installation Docs Rewrite:** Rewrote README and integration docs with chat-first setup, numbered manual steps.
+
+**Improvements:**
+- **SDK Upgrade:** Bumped `mem0ai` dependency to 3.0.1 for V3 API compatibility
+- **Config Cleanup:** Dropped deprecated `orgId`, `projectId`, `enableGraph` config options; updated CLI prompts ([#4734](https://github.com/mem0ai/mem0/pull/4734), [#4764](https://github.com/mem0ai/mem0/pull/4764))
+- **Noise Filtering:** Expanded noise patterns in memory add tool; handle leading text in JSON extraction
+
+</Update>
+
 <Update label="2026-04-11" description="v1.0.6">
 
 **Bug Fixes:**

docs/changelog/platform.mdx

@@ -4,6 +4,13 @@ description: "Release notes for the Mem0 hosted platform — backend, dashboard,
 mode: "wide"
 ---
 
+<Update label="2026-04-16" description="">
+
+**Improvements:**
+- **UI:** Removed Graph Memory tab, page, and all references from dashboard, sidebar, project settings, playground, and billing
+
+</Update>
+
 <Update label="2025-07-23" description="">
 
 **Bug Fixes:**

docs/changelog/sdk.mdx

@@ -7,7 +7,57 @@ mode: "wide"
 <Tabs>
 <Tab title="Python">
 
-<Update label="2026-04-04" description="v1.0.11">
+<Update label="2026-04-14" description="v2.0.0">
+
+**Major Release** — Python SDK with V3 memory pipeline, ADD-only extraction, and cleaned-up API surface.
+
+**New Features:**
+- **Single-Pass Extraction:** Replaced 2-LLM-call pipeline with additive extraction using `ADDITIVE_EXTRACTION_PROMPT`. Memories accumulate via `linked_memory_ids` — no more UPDATE/DELETE events ([#4805](https://github.com/mem0ai/mem0/pull/4805))
+- **Hybrid Search:** Combined semantic + BM25 keyword matching + entity boost with additive scoring. Native `keyword_search()` added to 15 vector store adapters (Qdrant, Elasticsearch, OpenSearch, Azure AI Search, Weaviate, Redis, PGVector, Pinecone, Databricks, MongoDB, Milvus, Baidu, Upstash, Azure MySQL, Vertex AI) ([#4805](https://github.com/mem0ai/mem0/pull/4805))
+- **Entity Extraction & Linking:** spaCy-based entity extraction with second vector collection (`{collection}_entities`) for cross-memory relationship retrieval. Optional dependency: `pip install mem0ai[nlp]` ([#4805](https://github.com/mem0ai/mem0/pull/4805))
+- **Batch Operations:** Batch embedding, batch persist, and batch entity linking (8-phase pipeline) for both sync `Memory` and async `AsyncMemory` at full parity ([#4805](https://github.com/mem0ai/mem0/pull/4805))
+- **Message Persistence:** SQLite-based rolling window (10 messages per session scope) for LLM context ([#4805](https://github.com/mem0ai/mem0/pull/4805))
+- **Valkey Cluster Mode:** Added `cluster_mode` parameter for Valkey Cluster Mode Enabled (CME) deployments ([#4759](https://github.com/mem0ai/mem0/pull/4759))
+- **V3 API Endpoints:** `MemoryClient.add()` now posts to `/v3/memories/add/`; `MemoryClient.get_all()` posts to `/v3/memories/` and returns a paginated envelope `{"count": int, "next": str | None, "previous": str | None, "results": [...]}` ([#4856](https://github.com/mem0ai/mem0/pull/4856))
+- **Default model:** `gpt-5-mini` is now the default across `OpenAILLM`, `OpenAIStructuredLLM`, `AzureOpenAILLM`, `AzureOpenAIStructuredLLM`, and `LiteLLM` fallback ([#4829](https://github.com/mem0ai/mem0/pull/4829))
+
+**Breaking Changes:**
+- **`add()` returns ADD-only events** — No more `"UPDATE"` or `"DELETE"` events. Memories accumulate; nothing is overwritten ([#4805](https://github.com/mem0ai/mem0/pull/4805))
+- **`search()` default `threshold` is now `0.1`** — Pass `threshold=0.0` for previous behavior ([#4805](https://github.com/mem0ai/mem0/pull/4805))
+- **`search()` `score` is now a combined multi-signal score** — The top-level `score` fuses semantic similarity, BM25 keyword match, and entity boost into one value. Absolute numbers shift versus the old raw cosine score; retune any hard thresholds against representative queries. Per-signal scores are not exposed on the response ([#4805](https://github.com/mem0ai/mem0/pull/4805), [#4836](https://github.com/mem0ai/mem0/pull/4836))
+- **`search()` default `rerank` is now `False`** — Pass `rerank=True` for previous behavior ([#4805](https://github.com/mem0ai/mem0/pull/4805))
+- **`top_k` default changed 100 → 20** in `Memory.get_all()` and `Memory.search()` (sync + async). Pass `top_k=100` explicitly to restore the old behavior ([#4843](https://github.com/mem0ai/mem0/pull/4843))
+- **Entity ID validation:** `user_id` / `agent_id` / `run_id` are trimmed; empty-string and whitespace-only values now raise `ValueError` ([#4843](https://github.com/mem0ai/mem0/pull/4843))
+- **Search params validation:** `threshold` must be a number in `[0, 1]`; `top_k` must be a non-negative integer — invalid inputs raise `ValueError` ([#4843](https://github.com/mem0ai/mem0/pull/4843))
+- **`messages` in `Memory.add()` rejects invalid types:** Passing `None` or non-`(str | dict | list)` values raises `Mem0ValidationError` (`error_code="VALIDATION_003"`) ([#4843](https://github.com/mem0ai/mem0/pull/4843))
+- **`qdrant-client>=1.12.0` required** — Upgrade from `>=1.9.1` ([#4805](https://github.com/mem0ai/mem0/pull/4805))
+- **`org_id` and `project_id` removed** — Removed from `MemoryClient` constructor and all method signatures ([#4740](https://github.com/mem0ai/mem0/pull/4740))
+- **Graph Memory Removed (OSS):** `mem0/memory/graph_memory.py`, `memgraph_memory.py`, `kuzu_memory.py`, `apache_age_memory.py`, and `mem0/graphs/` (Neo4j / Memgraph / Kuzu / Apache AGE / Neptune drivers) deleted — ~4,000 lines. Graph memory is no longer supported in the OSS SDK; graph drivers (neo4j, memgraph, kuzu, etc.) can be uninstalled. Use the Platform API for graph features. Remove `enable_graph` and `graph_store` from your config ([#4805](https://github.com/mem0ai/mem0/pull/4805))
+- **`enable_graph` removed from Client SDK** — Graph memory is now a project-level setting on the Platform. Remove `enable_graph` from `MemoryClient.add()` / `search()` / `get_all()` / `update_project()` calls ([#4776](https://github.com/mem0ai/mem0/pull/4776))
+- **`custom_fact_extraction_prompt` renamed to `custom_instructions`** — Update config and memory module references ([#4740](https://github.com/mem0ai/mem0/pull/4740))
+- **Typed option classes** — Added Pydantic v2 typed classes: `AddMemoryOptions`, `SearchMemoryOptions`, `GetAllMemoryOptions`, `DeleteAllMemoryOptions`, `UpdateMemoryOptions`, `ProjectUpdateOptions` ([#4740](https://github.com/mem0ai/mem0/pull/4740))
+
+**Security:**
+- **FAISS:** Prevent arbitrary code execution via pickle deserialization in `FAISS` vector store ([#4833](https://github.com/mem0ai/mem0/pull/4833))
+
+**Bug Fixes:**
+- **V3 migration crashes:** Fixed crashes in the v3 migration path; entity linking on OSS is now functional across Qdrant and Milvus backends ([#4836](https://github.com/mem0ai/mem0/pull/4836))
+- **Qdrant entity store:** Entity store now shares the existing Qdrant client when using embedded mode (`path=...`), eliminating RocksDB lock contention between the main and entity collections ([#4836](https://github.com/mem0ai/mem0/pull/4836))
+- **Reranker:** Fixed incorrect use of SentenceTransformer for cross-encoder reranker models — switched to CrossEncoder API for proper scoring ([#4806](https://github.com/mem0ai/mem0/pull/4806))
+- **S3 Vectors:** Handle `vector=None` in `update()` to prevent boto3 validation error when `event=NONE` ([#4594](https://github.com/mem0ai/mem0/pull/4594))
+- **LLMs:** Made OpenAI `store` parameter opt-in to prevent leaking to non-OpenAI backends like Google Gemini ([#4757](https://github.com/mem0ai/mem0/pull/4757))
+- **LLMs:** Forward `response_format` to Azure OpenAI API to prevent JSON parsing failures ([#4689](https://github.com/mem0ai/mem0/pull/4689))
+- **Core:** Guard `temp_uuid_mapping` lookups against LLM-hallucinated IDs with safe `.get()` and warnings ([#4674](https://github.com/mem0ai/mem0/pull/4674))
+- **Client:** Prevent `MemoryClient.feedback()` telemetry TypeError by merging feedback data into single payload ([#4795](https://github.com/mem0ai/mem0/pull/4795))
+
+**Improvements:**
+- **Telemetry:** Sample OSS hot-path events at 10% via PostHog `before_send` hook to reduce event volume ([#4771](https://github.com/mem0ai/mem0/pull/4771))
+
+See the [OSS v1 to v2 migration guide](https://docs.mem0.ai/migration/oss-v1-to-v2) and [Platform migration guide](https://docs.mem0.ai/migration/platform-v2-to-v3) for upgrade instructions.
+
+</Update>
+
+<Update label="2026-04-06" description="v1.0.11">
 
 **New Features & Updates:**
 - **SDK:** Added `multilingual` parameter to project update ([#4314](https://github.com/mem0ai/mem0/pull/4314))
@@ -843,7 +893,66 @@ mode: "wide"
 </Tab>
 
 <Tab title="TypeScript">
-<Update label="2026-04-04" description="v2.4.6">
+<Update label="2026-04-20" description="v3.0.1">
+
+**Bug Fixes:**
+- **Telemetry:** SDK version is now injected into telemetry at build time via esbuild's `define`, replacing the two hardcoded version strings in `src/client/telemetry.ts` and `src/oss/src/utils/telemetry.ts`. Previously these were stuck at `2.1.36` and `2.1.34` while the published package was on `3.x`, so every telemetry event was reporting the wrong `client_version`. The placeholder is substituted with a string literal at bundle time — no runtime `require("./package.json")` in the shipped bundle ([#4897](https://github.com/mem0ai/mem0/pull/4897)).
+
+</Update>
+
+<Update label="2026-04-14" description="v3.0.0">
+
+**Major Release** — TypeScript SDK with V3 memory pipeline, camelCase parameters, and cleaned-up API surface.
+
+**V3 Memory Pipeline (OSS):**
+- **Single-Pass Extraction:** Additive extraction pipeline aligned with Python SDK — memories accumulate, no UPDATE/DELETE events ([#4805](https://github.com/mem0ai/mem0/pull/4805))
+- **Entity Extraction & Linking:** New `entity_extraction.ts` module (720+ lines) with cross-memory relationship retrieval ([#4805](https://github.com/mem0ai/mem0/pull/4805))
+- **Message Persistence:** SQLite-based message history via new `SQLiteManager.ts` with rolling window for LLM context ([#4805](https://github.com/mem0ai/mem0/pull/4805))
+- **Batch Embeddings:** `embedBatch()` support in OpenAI and Azure embedding providers ([#4805](https://github.com/mem0ai/mem0/pull/4805))
+- **Scoring & Lemmatization:** New `scoring.ts` and `lemmatization.ts` utilities for hybrid search ([#4805](https://github.com/mem0ai/mem0/pull/4805))
+- **New Prompts:** `prompts/index.ts` (592+ lines) with additive extraction prompt aligned with Python SDK ([#4805](https://github.com/mem0ai/mem0/pull/4805))
+- **V3 API Endpoints:** `MemoryClient.add()` now posts to `/v3/memories/add/`; `MemoryClient.getAll()` posts to `/v3/memories/` with paginated envelope `{ count, next, previous, results }` ([#4856](https://github.com/mem0ai/mem0/pull/4856))
+- **Default model:** `gpt-5-mini` is now the default in `OpenAI`, `OpenAIStructured`, and `Azure` LLM providers ([#4829](https://github.com/mem0ai/mem0/pull/4829))
+
+**Breaking Changes:**
+- **Graph Memory Removed (OSS):** `graph_memory.ts` (675 lines), `graphs/tools.ts` (267 lines), `graphs/utils.ts` (116 lines), `graphs/configs.ts` (30 lines) deleted. Graph memory is no longer supported in the OSS SDK — use Platform API for graph features ([#4805](https://github.com/mem0ai/mem0/pull/4805))
+- **camelCase Parameters (Client SDK):** All user-facing parameters converted from snake_case to camelCase. Mapping is transparent at API boundary via `camelToSnakeKeys()` / `snakeToCamelKeys()` ([#4776](https://github.com/mem0ai/mem0/pull/4776))
+  ```typescript
+  // Before
+  client.add(messages, { user_id: "alice", top_k: 5 });
+  // After
+  client.add(messages, { userId: "alice", topK: 5 });
+  ```
+- **Per-Method Option Types:** Replaced monolithic `MemoryOptions` with typed interfaces: `AddMemoryOptions`, `SearchMemoryOptions`, `GetAllMemoryOptions`, `DeleteAllMemoryOptions` ([#4740](https://github.com/mem0ai/mem0/pull/4740))
+- **Removed Deprecated Parameters:** `org_id`, `project_id`, `api_version`, `output_format`, `async_mode`, `enable_graph`, `limit` removed from client method signatures. `ClientOptions` reduced to `{ apiKey, host }` only ([#4740](https://github.com/mem0ai/mem0/pull/4740))
+- **`limit` renamed to `topK` (OSS):** Update all search calls ([#4740](https://github.com/mem0ai/mem0/pull/4740))
+- **`topK` default changed 100 → 20** in `Memory.getAll()` and `Memory.search()`. Pass `topK: 100` explicitly to restore the old behavior ([#4843](https://github.com/mem0ai/mem0/pull/4843))
+- **Entity ID validation:** `userId` / `agentId` / `runId` are trimmed; empty-string and whitespace-only values now throw ([#4843](https://github.com/mem0ai/mem0/pull/4843))
+- **Search params validation:** `threshold` must be in `[0, 1]`; `topK` must be a non-negative integer — invalid inputs throw ([#4843](https://github.com/mem0ai/mem0/pull/4843))
+- **`messages` in `Memory.add()` is required:** Passing `undefined` or `null` now throws ([#4843](https://github.com/mem0ai/mem0/pull/4843))
+- **`customPrompt` renamed to `customInstructions` (OSS):** Update memory and vector store configurations ([#4740](https://github.com/mem0ai/mem0/pull/4740))
+- **`enableGraph` removed (OSS):** Config option removed — graph memory no longer available in OSS ([#4776](https://github.com/mem0ai/mem0/pull/4776))
+
+**New Features:**
+- **LLMs:** Added DeepSeek LLM provider with OpenAI-compatible integration using custom baseURL to `api.deepseek.com` ([#4613](https://github.com/mem0ai/mem0/pull/4613))
+- **Entity store isolation:** `MemoryVectorStore` now uses a dedicated `_entities.db` file, preventing entity/memory store collisions ([#4829](https://github.com/mem0ai/mem0/pull/4829), [#4841](https://github.com/mem0ai/mem0/pull/4841))
+- **Payload backward compatibility:** Legacy camelCase payload keys normalized to snake_case on read ([#4841](https://github.com/mem0ai/mem0/pull/4841))
+
+**Bug Fixes:**
+- **V3 migration:** Fixed crashes in the OSS migration path; entity linking works end-to-end ([#4836](https://github.com/mem0ai/mem0/pull/4836))
+- **PGVector init race:** `PGVector.initialize()` now memoises the in-flight init promise ([#4841](https://github.com/mem0ai/mem0/pull/4841))
+- **Redis module detection:** Handles both node-redis v4+ and legacy `moduleList` response shapes ([#4841](https://github.com/mem0ai/mem0/pull/4841))
+- **Config:** Fixed `ConfigManager.mergeConfig()` to only include `graphStore` when explicitly provided by user, preventing default Neo4j connection attempts ([#4776](https://github.com/mem0ai/mem0/pull/4776))
+- **LLMs:** Config manager now falls back to `userConf.url` for `baseURL` — prevents custom LLM providers (Ollama, LMStudio) from silently connecting to OpenAI ([#4761](https://github.com/mem0ai/mem0/pull/4761))
+
+**Improvements:**
+- **Telemetry:** Sample OSS hot-path events at 10% to reduce PostHog event volume ([#4771](https://github.com/mem0ai/mem0/pull/4771))
+
+See the [TypeScript SDK migration guide](https://docs.mem0.ai/migration/ts-v2-to-v3) for upgrade instructions.
+
+</Update>
+
+<Update label="2026-04-06" description="v2.4.6">
 
 **New Features & Updates:**
 - **Client:** Added `multilingual` parameter to project update types ([#4314](https://github.com/mem0ai/mem0/pull/4314))

docs/components/llms/models/langchain.mdx

@@ -21,7 +21,7 @@ os.environ["OPENAI_API_KEY"] = "your-api-key"
 
 # Initialize a LangChain model directly
 openai_model = ChatOpenAI(
-    model="gpt-4.1-nano-2025-04-14",
+    model="gpt-5-mini",
     temperature=0.2,
     max_tokens=2000
 )

docs/components/llms/models/litellm.mdx

@@ -16,7 +16,7 @@ config = {
     "llm": {
         "provider": "litellm",
         "config": {
-            "model": "gpt-4.1-nano-2025-04-14",
+            "model": "gpt-5-mini",
             "temperature": 0.2,
             "max_tokens": 2000,
         }

docs/components/llms/models/openai.mdx

@@ -20,7 +20,7 @@ config = {
     "llm": {
         "provider": "openai",
         "config": {
-            "model": "gpt-4.1-nano-2025-04-14",
+            "model": "gpt-5-mini",
             "temperature": 0.2,
             "max_tokens": 2000,
         }
@@ -86,7 +86,7 @@ config = {
     "llm": {
         "provider": "openai_structured",
         "config": {
-            "model": "gpt-4.1-nano-2025-04-14",
+            "model": "gpt-5-mini",
             "temperature": 0.0,
         }
     }

docs/components/rerankers/config.mdx

@@ -91,7 +91,7 @@ config = {
     "llm": {
         "provider": "openai",
         "config": {
-            "model": "gpt-4.1-nano-2025-04-14"
+            "model": "gpt-5-mini"
         }
     },
     "reranker": {

docs/components/rerankers/custom-prompts.mdx

@@ -189,7 +189,7 @@ for i, prompt in enumerate(prompts):
     config["reranker"]["config"]["scoring_prompt"] = prompt
     memory = Memory.from_config(config)
 
-    results = memory.search("test query", user_id="test_user")
+    results = memory.search("test query", filters={"user_id": "test_user"})
     print(f"Prompt {i+1} results: {results}")
 ```
 

docs/components/rerankers/models/cohere.mdx

@@ -35,7 +35,7 @@ config = {
     "llm": {
         "provider": "openai",
         "config": {
-            "model": "gpt-4.1-nano-2025-04-14"
+            "model": "gpt-5-mini"
         }
     },
     "reranker": {
@@ -95,7 +95,7 @@ messages = [
 memory.add(messages, user_id="bob")
 
 # Search with reranking
-results = memory.search("What is the user's profession?", user_id="bob")
+results = memory.search("What is the user's profession?", filters={"user_id": "bob"})
 
 for result in results['results']:
     print(f"Memory: {result['memory']}")

docs/components/rerankers/models/huggingface.mdx

@@ -175,7 +175,7 @@ queries = [
 
 results = []
 for query in queries:
-    result = m.search(query, user_id="alice", rerank=True)
+    result = m.search(query, filters={"user_id": "alice"}, rerank=True)
     results.append(result)
 ```
 

docs/components/rerankers/models/llm.mdx

@@ -111,7 +111,7 @@ messages = [
 memory.add(messages, user_id="david")
 
 # Search with LLM reranking
-results = memory.search("What programming topics is the user studying?", user_id="david")
+results = memory.search("What programming topics is the user studying?", filters={"user_id": "david"})
 
 for result in results['results']:
     print(f"Memory: {result['memory']}")

docs/components/rerankers/models/llm_reranker.mdx

@@ -283,12 +283,12 @@ for result in results["results"]:
 def safe_llm_rerank_search(query, user_id, max_retries=3):
     for attempt in range(max_retries):
         try:
-            return m.search(query, user_id=user_id, rerank=True)
+            return m.search(query, filters={"user_id": user_id}, rerank=True)
         except Exception as e:
             print(f"Attempt {attempt + 1} failed: {e}")
             if attempt == max_retries - 1:
                 # Fall back to vector search
-                return m.search(query, user_id=user_id, rerank=False)
+                return m.search(query, filters={"user_id": user_id}, rerank=False)
 
 # Use the safe function
 results = safe_llm_rerank_search("What are my preferences?", "alice")
@@ -376,19 +376,19 @@ class RobustLLMReranker:
         # Try primary LLM reranker
         for attempt in range(max_retries):
             try:
-                return self.primary.search(query, user_id=user_id, rerank=True)
+                return self.primary.search(query, filters={"user_id": user_id}, rerank=True)
             except Exception as e:
                 print(f"Primary reranker attempt {attempt + 1} failed: {e}")
 
         # Try fallback reranker
         if self.fallback:
             try:
-                return self.fallback.search(query, user_id=user_id, rerank=True)
+                return self.fallback.search(query, filters={"user_id": user_id}, rerank=True)
             except Exception as e:
                 print(f"Fallback reranker failed: {e}")
 
         # Final fallback: vector search only
-        return self.primary.search(query, user_id=user_id, rerank=False)
+        return self.primary.search(query, filters={"user_id": user_id}, rerank=False)
 
 # Usage
 primary_config = {

docs/components/rerankers/models/sentence_transformer.mdx

@@ -101,7 +101,7 @@ messages = [
 memory.add(messages, user_id="charlie")
 
 # Search with local reranking
-results = memory.search("What books does the user like?", user_id="charlie")
+results = memory.search("What books does the user like?", filters={"user_id": "charlie"})
 
 for result in results['results']:
     print(f"Memory: {result['memory']}")

docs/components/rerankers/models/zero_entropy.mdx

@@ -86,7 +86,7 @@ messages = [
 memory.add(messages, user_id="alice")
 
 # Search with reranking
-results = memory.search("What Italian food does the user like?", user_id="alice")
+results = memory.search("What Italian food does the user like?", filters={"user_id": "alice"})
 
 for result in results['results']:
     print(f"Memory: {result['memory']}")

docs/components/rerankers/optimization.mdx

@@ -153,7 +153,7 @@ def measure_reranker_performance(config, queries, user_id):
     latencies = []
     for query in queries:
         start_time = time.time()
-        results = memory.search(query, user_id=user_id)
+        results = memory.search(query, filters={"user_id": user_id})
         latency = time.time() - start_time
         latencies.append(latency)
 
@@ -191,7 +191,7 @@ class CachedReranker:
 
     @lru_cache(maxsize=1000)
     def search_cached(self, query_hash, user_id):
-        return self.memory.search(query, user_id=user_id)
+        return self.memory.search(query, filters={"user_id": user_id})
 
     def search(self, query, user_id):
         query_hash = hashlib.md5(f"{query}_{user_id}".encode()).hexdigest()

docs/components/vectordbs/dbs/opensearch.mdx

@@ -72,7 +72,7 @@ m.add(messages, user_id="alice", metadata={"category": "movies"})
 ### Search Memories
 
 ```python
-results = m.search("What kind of movies does Alice like?", user_id="alice")
+results = m.search("What kind of movies does Alice like?", filters={"user_id": "alice"})
 ```
 
 ### Features

docs/components/vectordbs/dbs/turbopuffer.mdx

@@ -36,7 +36,7 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 
 # Search memories
-results = m.search(query="sci-fi recommendations", user_id="alice")
+results = m.search(query="sci-fi recommendations", filters={"user_id": "alice"})
 ```
 
 ### Config

docs/components/vectordbs/dbs/valkey.mdx

@@ -50,4 +50,25 @@ Here are the parameters available for configuring Valkey:
 | `hnsw_m` | Number of bi-directional links for HNSW | `16` |
 | `hnsw_ef_construction` | Size of dynamic candidate list for HNSW | `200` |
 | `hnsw_ef_runtime` | Size of dynamic candidate list for search | `10` |
+| `cluster_mode` | Enable cluster mode for Valkey cluster (CME) deployments | `false` |
 | `distance_metric` | Distance metric for vector similarity | `cosine` |
+
+## Cluster Mode
+
+To use Valkey with cluster mode enabled (CME), set `cluster_mode` to `true`:
+
+```python
+config = {
+    "vector_store": {
+        "provider": "valkey",
+        "config": {
+            "collection_name": "memories",
+            "valkey_url": "valkey://cluster-endpoint:6379",
+            "embedding_model_dims": 1536,
+            "cluster_mode": True
+        }
+    }
+}
+```
+
+When cluster mode is enabled, the connector uses `ValkeyCluster` instead of the standalone client, which handles `MOVED`/`ASK` redirections automatically. Search queries are coordinated across all shards by the valkey-search module's built-in coordinator. See the [valkey-search documentation](https://github.com/valkey-io/valkey-search) for details on cluster mode behavior.

docs/cookbooks/companions/ai-tutor.mdx

@@ -60,7 +60,7 @@ class PersonalAITutor:
         """
         # Start a streaming response request to the AI
         response = self.client.responses.create(
-            model="gpt-4.1-nano-2025-04-14",
+            model="gpt-5-mini",
             instructions="You are a personal AI Tutor.",
             input=question,
             stream=True
@@ -81,7 +81,7 @@ class PersonalAITutor:
         :param user_id: Optional user ID to filter memories.
         :return: List of memories.
         """
-        return self.memory.get_all(user_id=user_id)
+        return self.memory.get_all(filters={"user_id": user_id})
 
 # Instantiate the PersonalAITutor
 ai_tutor = PersonalAITutor()

docs/cookbooks/companions/local-companion-ollama.mdx

@@ -57,7 +57,7 @@ m = Memory.from_config(config)
 m.add("I'm visiting Paris", user_id="john")
 
 # Retrieve memories
-memories = m.get_all(user_id="john")
+memories = m.get_all(filters={"user_id": "john"})
 ```
 
 ## Key Points

docs/cookbooks/companions/nodejs-companion.mdx

@@ -47,7 +47,7 @@ ${memoriesStr}`;
   ];
   
   const response = await openaiClient.chat.completions.create({
-    model: "gpt-4.1-nano-2025-04-14",
+    model: "gpt-5-mini",
     messages: messages
   });
   

docs/cookbooks/companions/travel-assistant.mdx

@@ -36,7 +36,7 @@ config = {
     "llm": {
         "provider": "openai",
         "config": {
-            "model": "gpt-4.1-nano-2025-04-14",
+            "model": "gpt-5-mini",
             "temperature": 0.1,
             "max_tokens": 2000,
         }
@@ -54,7 +54,6 @@ config = {
             "embedding_model_dims": 3072,
         }
     },
-    "version": "v1.1",
 }
 
 class PersonalTravelAssistant:
@@ -77,7 +76,7 @@ class PersonalTravelAssistant:
 
         # Generate response using Responses API
         response = self.client.responses.create(
-            model="gpt-4.1-nano-2025-04-14",
+            model="gpt-5-mini",
             input=prompt
         )
 
@@ -89,11 +88,11 @@ class PersonalTravelAssistant:
         return answer
 
     def get_memories(self, user_id):
-        memories = self.memory.get_all(user_id=user_id)
+        memories = self.memory.get_all(filters={"user_id": user_id})
         return [m['memory'] for m in memories['results']]
 
     def search_memories(self, query, user_id):
-        memories = self.memory.search(query, user_id=user_id)
+        memories = self.memory.search(query, filters={"user_id": user_id})
         return [m['memory'] for m in memories['results']]
 
 # Usage example
@@ -143,7 +142,7 @@ class PersonalTravelAssistant:
 
         # Generate response using gpt-4.1-nano
         response = self.client.chat.completions.create(
-            model="gpt-4.1-nano-2025-04-14"2025-04-14",
+            model="gpt-5-mini",
             messages=self.messages
         )
         answer = response.choices[0].message.content
@@ -154,11 +153,11 @@ class PersonalTravelAssistant:
         return answer
 
     def get_memories(self, user_id):
-        memories = self.memory.get_all(user_id=user_id)
+        memories = self.memory.get_all(filters={"user_id": user_id})
         return [m['memory'] for m in memories.get('results', [])]
 
     def search_memories(self, query, user_id):
-        memories = self.memory.search(query, user_id=user_id)
+        memories = self.memory.search(query, filters={"user_id": user_id})
         return [m['memory'] for m in memories.get('results', [])]
 
 # Usage example

docs/cookbooks/companions/voice-companion-openai.mdx

@@ -126,10 +126,9 @@ async def search_memories(
     print(f"Finding memories related to: {query}")
     results = await mem0_client.search(
         query,
-        user_id=USER_ID,
-        limit=5,
+        filters={"user_id": USER_ID},
+        top_k=5,
         threshold=0.7,  # Higher threshold for more relevant results
-
     )
 
     # Format and return the results
@@ -161,7 +160,7 @@ def create_memory_voice_agent():
             Use the search_memories tool when you need context from past conversations or user asks you to recall something.
             """,
         ),
-        model="gpt-4.1-nano-2025-04-14",
+        model="gpt-5-mini",
         tools=[save_memories, search_memories],
     )
     
@@ -342,10 +341,9 @@ async def search_memories(
     print(f"Finding memories related to: {query}")
     results = await mem0_client.search(
         query,
-        user_id=USER_ID,
-        limit=5,
+        filters={"user_id": USER_ID},
+        top_k=5,
         threshold=0.7,  # Higher threshold for more relevant results
-
     )
 
     # Format and return the results
@@ -368,7 +366,7 @@ def create_memory_voice_agent():
             Use the search_memories tool when you need context from past conversations or user asks you to recall something.
             """,
         ),
-        model="gpt-4.1-nano-2025-04-14",
+        model="gpt-5-mini",
         tools=[save_memories, search_memories],
     )
     

docs/cookbooks/essentials/building-ai-companion.mdx

@@ -62,7 +62,7 @@ mem0_client = MemoryClient(api_key="your-mem0-key")
 
 def chat(user_input, user_id):
     # Retrieve relevant memories
-    memories = mem0_client.search(user_input, user_id=user_id, limit=5)
+    memories = mem0_client.search(user_input, filters={"user_id": user_id}, top_k=5)
     context = "\\n".join(m["memory"] for m in memories["results"])
 
     # Call LLM with memory context
@@ -123,7 +123,7 @@ ollama_chat = OpenAI(base_url=f"{OLLAMA_URL}/v1", api_key="ollama")
 
 def chat(user_input, user_id):
     # Retrieve relevant memories
-    memories = memory.search(user_input, user_id=user_id, limit=5)
+    memories = memory.search(user_input, filters={"user_id": user_id}, top_k=5)
     context = "\n".join(m["memory"] for m in memories["results"])
 
     # Call LLM with memory context (Ollama via OpenAI-compatible API)
@@ -319,7 +319,7 @@ print([m["memory"] for m in memories["results"]])
   </Tab>
   <Tab title="Open Source">
 ```python
-memories = memory.get_all(user_id="max")
+memories = memory.get_all(filters={"user_id": "max"})
 print([m["memory"] for m in memories["results"]])
 # Output: ["Max wants to run marathon under 4 hours", "hey", "lol ok", "cool thanks", "gtg bye"]
 ```
@@ -354,10 +354,10 @@ Exclude:
 ```
   </Tab>
   <Tab title="Open Source">
-Tell Mem0 what matters by including `custom_fact_extraction_prompt` in the config dict:
+Tell Mem0 what matters by including `custom_instructions` in the config dict:
 
 ```python
-MEMORY_CONFIG["custom_fact_extraction_prompt"] = """
+MEMORY_CONFIG["custom_instructions"] = """
 Extract from running coach conversations:
 - Training goals and race targets
 - Physical constraints or injuries
@@ -375,7 +375,7 @@ Return JSON with key "facts" as a list of strings (use [] if nothing to store).
 memory = Memory.from_config(MEMORY_CONFIG)
 ```
 
-<Note>`custom_fact_extraction_prompt` is a top-level key in the config dictionary passed to `Memory.from_config()`. Make sure it's set before creating the Memory instance — not after.</Note>
+<Note>`custom_instructions` is a top-level key in the config dictionary passed to `Memory.from_config()`. Make sure it's set before creating the Memory instance — not after.</Note>
   </Tab>
 </Tabs>
 
@@ -397,7 +397,7 @@ print([m["memory"] for m in memories["results"]])
 chat("hey how's it going", user_id="max")
 chat("I prefer trail running over roads", user_id="max")
 
-memories = memory.get_all(user_id="max")
+memories = memory.get_all(filters={"user_id": "max"})
 print([m["memory"] for m in memories["results"]])
 # Output: ["Max wants to run marathon under 4 hours", "Max prefers trail running over roads"]
 ```
@@ -446,7 +446,7 @@ Retrieve agent style alongside user memories:
   <Tab title="Platform">
 ```python
 # Get coach personality
-agent_memories = mem0_client.search("coaching style", agent_id="ray_coach")
+agent_memories = mem0_client.search("coaching style", filters={"agent_id": "ray_coach"})
 # Output: ["Max wants direct, data-driven feedback. Skip motivational language."]
 
 # Store conversations with agent_id
@@ -459,7 +459,7 @@ mem0_client.add([
   <Tab title="Open Source">
 ```python
 # Get coach personality
-agent_memories = memory.search("coaching style", agent_id="ray_coach")
+agent_memories = memory.search("coaching style", filters={"agent_id": "ray_coach"})
 # Output: ["Max wants direct, data-driven feedback. Skip motivational language."]
 
 # Store conversations with agent_id
@@ -520,7 +520,7 @@ memory.add(
 # "hey" → don't store
 # "cool thanks" → don't store
 
-# Or rely on custom_fact_extraction_prompt to filter automatically
+# Or rely on custom_instructions to filter automatically
 ```
   </Tab>
 </Tabs>
@@ -545,11 +545,11 @@ expiration = (datetime.now() + timedelta(days=14)).strftime("%Y-%m-%d")
 mem0_client.add(
     [{"role": "user", "content": "Rolled my left ankle, needs rest"}],
     user_id="max",
-    expiration_date=expiration
+    metadata={"memory_bucket": "constraints", "expires_on": expiration}
 )
 ```
 
-In 14 days, this memory disappears automatically. Ray stops asking about the ankle.
+Store `expires_on` in metadata and periodically clean up expired memories. Ray stops asking about the ankle once it's removed.
   </Tab>
   <Tab title="Open Source">
 ```python
@@ -627,7 +627,7 @@ MEMORY_CONFIG = {
             "ollama_base_url": "http://localhost:11434",
         },
     },
-    "custom_fact_extraction_prompt": """
+    "custom_instructions": """
     Extract: goals, constraints, preferences, progress
     Exclude: greetings, filler, casual chat
     Return JSON with key "facts" as a list of strings.
@@ -684,8 +684,7 @@ expiration = (datetime.now() + timedelta(days=14)).strftime("%Y-%m-%d")
 mem0_client.add(
     [{"role": "user", "content": "Rolled ankle, need light workouts"}],
     user_id="max",
-    categories=["constraints"],
-    expiration_date=expiration
+    metadata={"memory_bucket": "constraints", "expires_on": expiration}
 )
 ```
   </Tab>
@@ -706,13 +705,13 @@ memory.add(
 <Tabs>
   <Tab title="Platform">
 ```python
-memories = mem0_client.search("training plan", user_id="max", limit=5)
+memories = mem0_client.search("training plan", filters={"user_id": "max"}, top_k=5)
 # Gets: marathon goal, trail preference, ankle injury (if still valid)
 ```
   </Tab>
   <Tab title="Open Source">
 ```python
-memories = memory.search("training plan", user_id="max", limit=5)
+memories = memory.search("training plan", filters={"user_id": "max"}, top_k=5)
 # Gets: marathon goal, trail preference, ankle injury (if still valid / not pruned)
 ```
   </Tab>
@@ -806,7 +805,7 @@ mem0_client.update(goal_memory["id"], "Max wants to run sub-3:45 marathon")
   <Tab title="Open Source">
 ```python
 # Find the old memory
-memories = memory.get_all(user_id="max")
+memories = memory.get_all(filters={"user_id": "max"})
 goal_memory = [m for m in memories["results"] if "sub-4" in m["memory"]][0]
 
 # Update it

docs/cookbooks/essentials/choosing-memory-architecture-vector-vs-graph.mdx

@@ -1,361 +0,0 @@
----
-title: Choose Vector vs Graph Memory
-description: "Blend vector search with graph relationships to answer multi-hop questions."
----
-
-
-Most AI agents use vector stores for RAG operations - they work great for semantic search and retrieving relevant context. But there's a gap when queries require understanding connections between entities.
-
-Mem0 brings graph memory into the picture to fill this gap. In this cookbook, we'll create a company knowledge base with Mem0, using both vector and graph stores. You'll learn when each one helps along the way.
-
----
-
-## Vector and Graph Stores
-
-When you add a memory to Mem0, it goes into a **vector store** by default. Vector stores are excellent at semantic search - finding memories that match the meaning of your query.
-
-**Graph stores** work differently. They extract **entities** (people, projects, teams) and **relationships between them** (works_with, reports_to, member_of). This lets you answer questions that need connecting information across multiple memories.
-
-We will go through examples in this cookbook while building a company's knowledge base along the way.
-
----
-
-## Starting Simple
-
-Since we're building a company knowledge base, let's add some employee information:
-
-```python
-from mem0 import MemoryClient
-
-client = MemoryClient(api_key="your-api-key")
-# Add employee info
-client.add("Emma is a software engineer in Seattle", user_id="company_kb")
-client.add("David is a product manager in Austin", user_id="company_kb")
-
-```
-
-Now let's search for Emma's role:
-
-```python
-results = client.search("What does Emma do?", filters={"user_id": "company_kb"})
-print(results['results'][0]['memory'])
-
-```
-
-**Output:**
-
-```
-Emma is a software engineer in Seattle
-
-```
-
-<Info>
-**Expected output:** Vector search returned Emma's role instantly. When queries ask for facts directly stored in one memory, vector semantic search is perfect—fast and accurate.
-</Info>
-
-This works perfectly. Vector search found the memory that semantically matches "What does Emma do?" and returned Emma's role.
-
----
-
-## Adding Team Structure
-
-Let's add some information about how the team works together:
-
-```python
-client.add("Emma works with David on the mobile app redesign", user_id="company_kb")
-client.add("David reports to Rachel, who manages the design team", user_id="company_kb")
-
-```
-
-Now we have two pieces of information stored:
-
-1. Emma works with David
-2. David reports to Rachel
-
-Let's try asking something that needs both pieces:
-
-```python
-results = client.search(
-    "Who is Emma's teammate's manager?",
-    filters={"user_id": "company_kb"}
-)
-
-for r in results['results']:
-    print(r['memory'])
-
-```
-
-**Output:**
-
-```
-Emma works with David on the mobile app redesign
-David reports to Rachel, who manages the design team
-
-```
-
-Vector search returned both memories, but it didn't connect them. You'd need to manually figure out:
-
-- Emma's teammate is David (from memory 1)
-- David's manager is Rachel (from memory 2)
-- So the answer is Rachel
-
-<Warning>
-Vector search can't traverse relationships. It returns relevant memories, but you must connect the dots manually. For "Who is Emma's teammate's manager?", vector search gives you the pieces—not the answer. This breaks down as queries get more complex (3+ hops).
-</Warning>
-
----
-
-## Enter Graph Memory
-
-Let's add the same information with graph memory enabled:
-
-```python
-client.add(
-    "Emma works with David on the mobile app redesign",
-    user_id="company_kb",
-    enable_graph=True
-)
-
-client.add(
-    "David reports to Rachel, who manages the design team",
-    user_id="company_kb",
-    enable_graph=True
-)
-
-```
-
-When you set `enable_graph=True`, Mem0 extracts entities and relationships:
-
-- `emma --[works_with]--> david`
-- `david --[reports_to]--> rachel`
-- `rachel --[manages]--> design_team`
-
-Now the same query works differently:
-
-```python
-results = client.search(
-    "Who is Emma's teammate's manager?",
-    filters={"user_id": "company_kb"},
-    enable_graph=True
-)
-
-print(results['results'][0]['memory'])
-print("\\nRelationships found:")
-for rel in results.get('relations', []):
-    print(f"  {rel['source']}, {rel['target']} ({rel['relationship']})")
-
-```
-
-**Output:**
-
-```
-David reports to Rachel, who manages the design team
-
-Relationships found:
-  emma, david (works_with)
-  david, rachel (reports_to)
-
-```
-
-<Info>
-**Expected behavior:** Graph memory returns the direct answer—"David reports to Rachel"—plus the relationship chain that got there. No manual connecting needed. The graph traversed: Emma → works_with → David → reports_to → Rachel.
-</Info>
-
-Graph memory traversed the relationships automatically: Emma works with David, David reports to Rachel, so Rachel is the answer.
-
----
-
-## How It Connects
-
-Here's what the graph looks like behind the scenes:
-
-```mermaid
-graph LR
-    Emma[Emma] -->|works_with| David[David]
-    David -->|reports_to| Rachel[Rachel]
-    Rachel -->|manages| DesignTeam[Design Team]
-    David -->|works_on| MobileApp[Mobile App]
-    Emma -->|works_on| MobileApp
-
-```
-
-Graph memory lets you discover relations and memories which are tricky to do with direct vector stores.
-
-Vector search would need the exact words in your query to match. Graph memory follows the connections.
-
----
-
-## When to Use Each
-
-Use **vector store** (default) when:
-
-- Searching documents by semantic similarity
-- Looking up facts that don't need relationships
-- Building FAQs or knowledge bases where each item stands alone
-
-Use **graph memory** when:
-
-- Tracking organizational hierarchies (who reports to whom)
-- Understanding project teams (who collaborates with whom)
-- Building CRMs (which contacts connect to which companies)
-- Product recommendations (what items are bought together)
-
-For our company knowledge base, we'll use both:
-
-- Vector for individual facts: "Emma specializes in React"
-- Graph for relationships: "Emma works with David"
-
----
-
-## Putting It Together
-
-Let's build a small company knowledge base with both approaches:
-
-```python
-# Facts about individuals - vector store is fine
-client.add("Emma specializes in React and TypeScript", user_id="company_kb")
-client.add("David has 5 years of product management experience", user_id="company_kb")
-
-# Relationships - use graph memory
-client.add(
-    "Emma and David work together on the mobile app",
-    user_id="company_kb",
-    enable_graph=True
-)
-
-client.add(
-    "David reports to Rachel",
-    user_id="company_kb",
-    enable_graph=True
-)
-
-client.add(
-    "Rachel runs weekly team syncs every Tuesday",
-    user_id="company_kb",
-    enable_graph=True
-)
-
-```
-
-Now we can ask different types of questions:
-
-```python
-# Direct fact - vector search
-results = client.search("What are Emma's skills?", filters={"user_id": "company_kb"})
-print(results['results'][0]['memory'])
-
-```
-
-**Output:**
-
-```
-Emma specializes in React and TypeScript
-
-```
-
-```python
-# Multi-hop relationship - graph search
-results = client.search(
-    "What meetings does Emma's project manager's boss run?",
-    filters={"user_id": "company_kb"},
-    enable_graph=True
-)
-print(results['results'][0]['memory'])
-
-```
-
-**Output:**
-
-```
-Rachel runs weekly team syncs every Tuesday
-
-```
-
-Graph memory connected: Emma works with David, David reports to Rachel, Rachel runs team syncs.
-
-<Tip>
-Enable graph memory when your queries need multi-hop traversal: org charts (who reports to whom), project teams (who collaborates), CRMs (which contacts connect to companies). For single-fact lookups, stick with vector search—it's faster and cheaper.
-</Tip>
-
----
-
-## The Tradeoff
-
-Graph memory adds processing time and cost. When you call `client.add()` with `enable_graph=True`, Mem0 makes extra LLM calls to extract entities and relationships.
-
-<Note>
-**Cost consideration:** Graph memory extraction adds ~2-3 extra LLM calls per `add()` operation to identify entities and relationships. Use it selectively—enable graph for organizational structure and long-term relationships, skip it for temporary notes and simple facts.
-</Note>
-
-Use graph memory when the relationship traversal adds real value. For most use cases, vector search is sufficient and faster.
-
-```python
-# Long-term organizational structure - worth using graph
-client.add(
-    "Emma mentors two junior engineers on the frontend team",
-    user_id="company_kb",
-    enable_graph=True
-)
-
-# Temporary notes - skip graph, not worth the cost
-client.add(
-    "Emma is out sick today",
-    user_id="company_kb",
-    run_id="daily_notes"
-)
-
-```
-
----
-
-## Enabling Graph Memory
-
-You can enable graph memory in two ways:
-
-**Per-call** (recommended to start):
-
-```python
-client.add("Emma works with David", user_id="company_kb", enable_graph=True)
-client.search("team structure", filters={"user_id": "company_kb"}, enable_graph=True)
-
-```
-
-**Project-wide** (if most of your data has relationships):
-
-```python
-client.project.update(enable_graph=True)
-
-# Now every add uses graph automatically
-client.add("Emma mentors Jordan", user_id="company_kb")
-
-```
-
----
-
-## What You Built
-
-A hybrid company knowledge base that combines both architectures:
-
-- **Vector search** - Fast semantic lookups for individual facts (Emma's skills, David's experience)
-- **Graph memory** - Multi-hop relationship traversal (Emma's teammate's manager, project hierarchies)
-- **Selective enablement** - Graph only for long-term organizational structure, vector for everything else
-- **Cost optimization** - Skip graph extraction for temporary notes and simple facts
-
-This pattern scales from 10-person startups to enterprise org charts with thousands of employees.
-
----
-
-## Summary
-
-Vector stores handle most memory operations efficiently—semantic search works great for finding relevant information. Add graph memory when your queries need to understand how entities connect across multiple hops.
-
-The key is knowing which tool fits your query pattern: direct questions work with vectors, multi-hop relationship queries need graphs.
-
-<CardGroup cols={2}>
-  <Card title="Partition Memories by Entity" icon="layers" href="/cookbooks/essentials/entity-partitioning-playbook">
-    Scope memories across users, agents, apps, and sessions to balance personalization and reuse.
-  </Card>
-  <Card title="Export Everything Safely" icon="download" href="/cookbooks/essentials/exporting-memories">
-    Learn how to migrate or audit stored memories with structured exports.
-  </Card>
-</CardGroup>

docs/cookbooks/essentials/controlling-memory-ingestion.mdx

@@ -513,11 +513,6 @@ These controls prevent retrieval failures and ensure your AI assistant works wit
 
 Start with conservative filters (only store confirmed facts) and iterate based on your application's needs. Combine custom instructions with confidence thresholds for the most reliable memory ingestion pipeline.
 
-<CardGroup cols={2}>
-  <Card title="Expire Short-Term Data" icon="timer" href="/cookbooks/essentials/memory-expiration-short-and-long-term">
-    Automatically clean up session context before it clutters retrieval.
-  </Card>
-  <Card title="Choose Your Memory Architecture" icon="sitemap" href="/cookbooks/essentials/choosing-memory-architecture-vector-vs-graph">
-    Learn when to layer graph memory alongside vectors for multi-hop queries.
-  </Card>
-</CardGroup>
+<Card title="Build a Mem0 Companion" icon="users" href="/cookbooks/essentials/building-ai-companion">
+  Learn core memory patterns including temporary vs permanent data handling.
+</Card>

docs/cookbooks/essentials/exporting-memories.mdx

@@ -280,8 +280,8 @@ This covers data portability, GDPR compliance, system migrations, and manual rev
 Use **`get_all()`** for bulk retrieval, **`search()`** for specific questions, and **`create_memory_export()`** for structured data exports with custom schemas. Remember exports expire after 7 days—download them locally for long-term archives.
 
 <CardGroup cols={2}>
-  <Card title="Expire Short-Term Data" icon="timer" href="/cookbooks/essentials/memory-expiration-short-and-long-term">
-    Keep exports lean by clearing session context before you archive it.
+  <Card title="Build a Mem0 Companion" icon="users" href="/cookbooks/essentials/building-ai-companion">
+    Learn core memory patterns including temporary vs permanent data handling.
   </Card>
   <Card title="Control Memory Ingestion" icon="filter" href="/cookbooks/essentials/controlling-memory-ingestion">
     Ensure only verified insights make it into your export pipeline.

docs/cookbooks/essentials/memory-expiration-short-and-long-term.mdx

@@ -1,277 +0,0 @@
----
-title: Set Memory Expiration
-description: "Define short-term versus long-term retention so the store stays fresh."
----
-
-
-While building memory systems, we realized their size grows fast. Session notes, temporary context, chat history - everything starts accumulating and bogging down the system. This pollutes search results and increase storage costs. Not every memory needs to persist forever.
-
-In this cookbook, we'll go through how to use short-term vs long-term memories and see where it's best to use them.
-
----
-
-## Overview
-
-By default, Mem0 memories persist forever. This works for user preferences and core facts, but temporary data should expire automatically.
-
-In this tutorial, we will:
-
-- Understand default (permanent) memory behavior
-- Add expiration dates for temporary memories
-- Decide what should be temporary vs permanent
-
----
-
-## Setup
-
-```python
-from mem0 import MemoryClient
-from datetime import datetime, timedelta
-
-client = MemoryClient(api_key="your-api-key")
-```
-
-<Note>
-Import `datetime` and `timedelta` to calculate expiration dates. Without these imports, you'll need to manually format ISO timestamps—error-prone and harder to read.
-</Note>
-
----
-
-## Default Behavior: Everything Persists
-
-By default, all memories persist forever:
-
-```python
-# Store user preference
-client.add("User prefers dark mode", user_id="sarah")
-
-# Store session context
-client.add("Currently browsing electronics category", user_id="sarah")
-
-# 6 months later - both still exist
-results = client.get_all(filters={"user_id": "sarah"})
-print(f"Total memories: {len(results['results'])}")
-
-```
-
-**Output:**
-
-```
-Total memories: 2
-
-```
-
-Both the preference and session context persist. The preference is useful, but the 6-month-old session context is not.
-
----
-
-## The Problem: Memory Bloat
-
-Without expiration, memories accumulate forever. Session notes from weeks ago mix with current preferences. Storage grows, search results get polluted with irrelevant old context, and retrieval quality degrades.
-
-<Warning>
-Memory bloat degrades search quality. When "User prefers dark mode" competes with "Currently browsing electronics" from 6 months ago, semantic search returns stale session data instead of actual preferences. Old memories pollute retrieval.
-</Warning>
-
----
-
-## Short-Term Memories: Adding Expiration
-
-Set `expiration_date` to make memories temporary:
-
-```python
-from datetime import datetime, timedelta
-
-# Session context - expires in 7 days
-expires_at = (datetime.now() + timedelta(days=7)).isoformat()
-
-client.add(
-    "Currently browsing electronics category",
-    user_id="sarah",
-    expiration_date=expires_at
-)
-
-# User preference - no expiration, persists forever
-client.add(
-    "User prefers dark mode",
-    user_id="sarah"
-)
-
-```
-
-<Info icon="check">
-**Expected behavior:** After 7 days, the session context automatically disappears—no cron jobs, no manual cleanup. The preference persists forever. Mem0 handles expiration transparently.
-</Info>
-
-Memories with `expiration_date` are automatically removed after expiring. No cleanup job needed - Mem0 handles it.
-
-<Tip>
-Start conservative with short expiration windows (7 days), then extend them based on usage patterns. It's easier to increase retention than to clean up over-retained stale data. Monitor search quality to find the right balance.
-</Tip>
-
----
-
-## When to Use Each
-
-### Permanent Memories (no expiration_date):
-
-**Use for:**
-
-- User preferences and settings
-- Account information
-- Important facts and milestones
-- Historical data that matters long-term
-
-```python
-client.add("User prefers email notifications", user_id="sarah")
-client.add("User's birthday is March 15th", user_id="sarah")
-client.add("User completed onboarding on Jan 5th", user_id="sarah")
-
-```
-
-### Temporary Memories (with expiration_date):
-
-**Use for:**
-
-- Session context (current page, browsing history)
-- Temporary reminders
-- Recent chat history
-- Cached data
-
-```python
-expires_7d = (datetime.now() + timedelta(days=7)).isoformat()
-
-client.add(
-    "Currently viewing product ABC123",
-    user_id="sarah",
-    expiration_date=expires_7d
-)
-
-client.add(
-    "Asked about return policy",
-    user_id="sarah",
-    expiration_date=expires_7d
-)
-
-```
-
----
-
-## Setting Different Expiration Periods
-
-Different data needs different lifetimes:
-
-```python
-# Session context - 7 days
-expires_7d = (datetime.now() + timedelta(days=7)).isoformat()
-client.add("Browsing electronics", user_id="sarah", expiration_date=expires_7d)
-
-# Recent chat - 30 days
-expires_30d = (datetime.now() + timedelta(days=30)).isoformat()
-client.add("User asked about warranty", user_id="sarah", expiration_date=expires_30d)
-
-# Important preference - no expiration
-client.add("User prefers dark mode", user_id="sarah")
-
-```
-
----
-
-## Using Metadata to Track Memory Types
-
-Tag memories to make filtering easier:
-
-```python
-expires_7d = (datetime.now() + timedelta(days=7)).isoformat()
-
-# Tag session context
-client.add(
-    "Browsing electronics",
-    user_id="sarah",
-    expiration_date=expires_7d,
-    metadata={"type": "session"}
-)
-
-# Tag preference
-client.add(
-    "User prefers dark mode",
-    user_id="sarah",
-    metadata={"type": "preference"}
-)
-
-# Query only preferences
-preferences = client.get_all(
-    filters={
-        "AND": [
-            {"user_id": "sarah"},
-            {"metadata": {"type": "preference"}}
-        ]
-    }
-)
-
-```
-
----
-
-## Checking Expiration Status
-
-See which memories will expire and when:
-
-```python
-results = client.get_all(filters={"user_id": "sarah"})
-
-for memory in results['results']:
-    exp_date = memory.get('expiration_date')
-
-    if exp_date:
-        print(f"Temporary: {memory['memory']}")
-        print(f"  Expires: {exp_date}\\n")
-    else:
-        print(f"Permanent: {memory['memory']}\\n")
-
-```
-
-**Output:**
-
-```
-Temporary: Browsing electronics
-  Expires: 2025-11-01T10:30:00Z
-
-Temporary: Viewed MacBook Pro and Dell XPS
-  Expires: 2025-11-01T10:30:00Z
-
-Permanent: User prefers dark mode
-
-Permanent: User prefers email notifications
-
-```
-
----
-
-## What You Built
-
-A self-cleaning memory system with automatic retention policies:
-
-- **Automatic expiration** - Memories self-destruct after defined periods, no cron jobs needed
-- **Tiered retention** - 7-day session context, 30-day chat history, permanent preferences
-- **Metadata tagging** - Classify memories by type (session, preference, chat) for filtered retrieval
-- **Expiration tracking** - Check which memories will expire and when using `get_all()`
-
-This pattern keeps storage costs low and search quality high as your memory store scales.
-
----
-
-## Summary
-
-Memory expiration keeps storage clean and search results relevant. Use **`expiration_date`** for temporary data (session context, recent chats), skip it for permanent facts (preferences, account info). Mem0 handles cleanup automatically—no background jobs required.
-
-Start by identifying what's temporary versus permanent, then set conservative expiration windows and adjust based on retrieval quality.
-
-<CardGroup cols={2}>
-  <Card title="Control Memory Ingestion" icon="filter" href="/cookbooks/essentials/controlling-memory-ingestion">
-    Pair expirations with ingestion rules so only trusted context persists.
-  </Card>
-  <Card title="Export Memories Safely" icon="download" href="/cookbooks/essentials/exporting-memories">
-    Build compliant archives once your retention windows are dialed in.
-  </Card>
-</CardGroup>

docs/cookbooks/frameworks/chrome-extension.mdx

@@ -1,70 +0,0 @@
----
-title: Browser Extension Memory
-description: "Add Mem0's universal memory layer to Chrome chat surfaces."
----
-
-
-Enhance your AI interactions with Mem0, a Chrome extension that introduces a universal memory layer across platforms like ChatGPT, Claude, and Perplexity. Mem0 ensures seamless context sharing, making your AI experiences more personalized and efficient.
-
-<Note>
-  We now support Grok! The Mem0 Chrome Extension has been updated to work with Grok, bringing the same powerful memory capabilities to your Grok conversations.
-</Note>
-
-
-## Features
-
-- **Universal Memory Layer**: Share context seamlessly across ChatGPT, Claude, Perplexity, and Grok.
-- **Smart Context Detection**: Automatically captures relevant information from your conversations.
-- **Intelligent Memory Retrieval**: Surfaces pertinent memories at the right time.
-- **One-Click Sync**: Easily synchronize with existing ChatGPT memories.
-- **Memory Dashboard**: Manage all your memories in one centralized location.
-
-## Installation
-
-You can install the Mem0 Chrome Extension using one of the following methods:
-
-### Method 1: Chrome Web Store Installation
-
-1. **Download the Extension**: Open Google Chrome and navigate to the [Mem0 Chrome Extension page](https://chromewebstore.google.com/detail/mem0/onihkkbipkfeijkadecaafbgagkhglop?hl=en).
-2. **Add to Chrome**: Click on the "Add to Chrome" button.
-3. **Confirm Installation**: In the pop-up dialog, click "Add extension" to confirm. The Mem0 icon should now appear in your Chrome toolbar.
-
-### Method 2: Manual Installation
-
-1. **Download the Extension**: Clone or download the extension files from the [Mem0 Chrome Extension GitHub repository](https://github.com/mem0ai/mem0-chrome-extension).
-2. **Access Chrome Extensions**: Open Google Chrome and navigate to `chrome://extensions`.
-3. **Enable Developer Mode**: Toggle the "Developer mode" switch in the top right corner.
-4. **Load Unpacked Extension**: Click "Load unpacked" and select the directory containing the extension files.
-5. **Confirm Installation**: The Mem0 Chrome Extension should now appear in your Chrome toolbar.
-
-## Usage
-
-1. **Locate the Mem0 Icon**: After installation, find the Mem0 icon in your Chrome toolbar.
-2. **Sign In**: Click the icon and sign in with your Google account.
-3. **Interact with AI Assistants**:
-   - **ChatGPT and Perplexity**: Continue your conversations as usual; Mem0 operates seamlessly in the background.
-   - **Claude**: Click the Mem0 button or use the shortcut `Ctrl + M` to activate memory functions.
-
-## Configuration
-
-- **API Key**: Obtain your API key from the Mem0 Dashboard to connect the extension to the Mem0 API.
-- **User ID**: This is your unique identifier in the Mem0 system. If not provided, it defaults to `chrome-extension-user`.
-
-## Demo Video
-
-<iframe width="700" height="400" src="https://www.youtube.com/embed/dqenCMMlfwQ?si=zhGVrkq6IS_0Jwyj" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
-
-## Privacy and Data Security
-
-Your messages are sent to the Mem0 API for extracting and retrieving memories. Mem0 is committed to ensuring your data's privacy and security.
-
----
-
-<CardGroup cols={2}>
-  <Card title="Build a Mem0 Companion" icon="users" href="/cookbooks/essentials/building-ai-companion">
-    Learn the foundations of memory-powered assistants that work across platforms.
-  </Card>
-  <Card title="Multimodal Support" icon="image" href="/platform/features/multimodal-support">
-    Extend your browser interactions with vision and audio memory.
-  </Card>
-</CardGroup>

docs/cookbooks/frameworks/llamaindex-multiagent.mdx

@@ -83,7 +83,7 @@ class MultiAgentLearningSystem:
 
     def __init__(self, student_id: str):
         self.student_id = student_id
-        self.llm = OpenAI(model="gpt-4.1-nano-2025-04-14", temperature=0.2)
+        self.llm = OpenAI(model="gpt-5-mini", temperature=0.2)
 
         # Memory context for this student
         self.memory_context = {"user_id": student_id, "app": "learning_assistant"}

docs/cookbooks/frameworks/llamaindex-react.mdx

@@ -22,7 +22,7 @@ import os
 from llama_index.llms.openai import OpenAI
 
 os.environ["OPENAI_API_KEY"] = "<your-openai-api-key>"
-llm = OpenAI(model="gpt-4.1-nano-2025-04-14")
+llm = OpenAI(model="gpt-5-mini")
 ```
 
 Initialize the Mem0 client. You can find your API key <a href="https://app.mem0.ai/dashboard/api-keys" rel="nofollow">here</a>. Read about Mem0 [Open Source](https://docs.mem0.ai/open-source/overview).

docs/cookbooks/frameworks/mirofish-swarm-memory.mdx

@@ -1,766 +0,0 @@
----
-title: MiroFish Swarm Memory
-description: "Build a multi-agent swarm simulation with graph-powered memory using Mem0 and MiroFish patterns."
----
-
-<Snippet file="blank-notif.mdx" />
-
-Build a multi-agent swarm simulation with graph-powered memory using Mem0 OSS and [MiroFish](https://github.com/666ghj/MiroFish) patterns. MiroFish is a graph-centric system — it extracts entities and relationships from documents, builds a knowledge graph, and queries it throughout its pipeline. Mem0's Graph Memory is a natural replacement for its Zep Cloud integration.
-
-<Note>
-  This cookbook demonstrates the **core memory patterns** using a simplified simulation. MiroFish's actual architecture uses a factory pattern (`memory_factory.py`) with abstract providers, batch buffering with retries in `ZepGraphMemoryUpdater`, and IPC-based agent interviews. This cookbook focuses on the Mem0 API integration points — wrap these calls in your own retry/batch logic for production use.
-</Note>
-
-## Overview
-
-This cookbook implements a **Housing Policy Prediction Simulation** following MiroFish's five-stage workflow:
-
-1. **Graph Building** — Ingest seed documents, extract entities and relationships
-2. **Environment Setup** — Query the knowledge graph to enrich agent profiles
-3. **Simulation** — Track agent interactions with per-agent memory isolation
-4. **Report Generation** — Semantic search + graph traversal for analysis
-5. **Deep Interaction** — Query post-simulation memory and relationships (MiroFish also supports live agent interviews via IPC — not covered here)
-
-Three agents debate a housing policy reform:
-- **Mayor Chen** — Policy advocate pushing for zoning reform
-- **Wang (Homeowner)** — Opposition leader organizing resistance
-- **Professor Li** — Academic providing data-driven analysis
-
-## Prerequisites
-
-```bash
-pip install "mem0ai[graph]"
-```
-
-You need a graph backend. Choose one:
-
-| Backend | Setup | Best for |
-|---|---|---|
-| **Neo4j Aura** (free tier) | [Sign up](https://neo4j.com/product/auradb/), get Bolt URI | Production, closest to Zep |
-| **Neo4j Docker** | `docker run -p 7687:7687 -e NEO4J_AUTH=neo4j/password neo4j:5` | Local development |
-| **Kuzu** (embedded) | No setup needed — runs in-process | Quick testing, zero dependencies |
-
-```bash
-export OPENAI_API_KEY="sk-..."
-
-# Option A: Neo4j Docker (local development)
-docker run -p 7687:7687 -e NEO4J_AUTH=neo4j/password neo4j:5
-export NEO4J_URL="neo4j://localhost:7687"
-export NEO4J_USERNAME="neo4j"
-export NEO4J_PASSWORD="password"
-
-# Option B: Neo4j Aura (production — free tier available)
-export NEO4J_URL="neo4j+s://<your-instance>.databases.neo4j.io"
-export NEO4J_USERNAME="neo4j"
-export NEO4J_PASSWORD="your-aura-password"
-
-# Option C: Kuzu (zero setup — auto-detected when NEO4J_URL is not set)
-# No exports needed
-```
-
-## Complete Implementation
-
-```python
-"""
-MiroFish Swarm Prediction Simulation with Mem0 Graph Memory
-
-MiroFish uses Zep Cloud as its knowledge graph backend. This implementation
-replaces Zep with Mem0 OSS Graph Memory, which provides:
-- Automatic entity extraction from text
-- Relationship mining (source → relationship → destination triples)
-- Combined vector + graph search returning memories AND relations
-- Per-agent isolation via run_id
-- Self-hosted with no node caps
-
-Follows MiroFish's 5-stage pipeline:
-1. Graph Building    - Ingest seed documents, extract entities
-2. Environment Setup - Query graph to enrich agent profiles
-3. Simulation        - Track agent actions with per-agent isolation
-4. Report Generation - Semantic + graph search for analysis
-5. Deep Interaction  - Query post-simulation knowledge graph
-
-Run:
-    export OPENAI_API_KEY="sk-..."
-    export NEO4J_URL="neo4j://localhost:7687"
-    export NEO4J_USERNAME="neo4j"
-    export NEO4J_PASSWORD="password"
-    python mirofish_swarm_memory.py
-"""
-
-import os
-import time
-from mem0 import Memory
-
-
-# ======================================================================
-# MiroFish Agent Action Types (matches OASIS simulation output)
-# ======================================================================
-
-# Twitter actions
-TWITTER_ACTIONS = [
-    "CREATE_POST", "LIKE_POST", "REPOST", "FOLLOW",
-    "DO_NOTHING", "QUOTE_POST",
-]
-
-# Reddit actions (superset — includes moderation + discovery)
-REDDIT_ACTIONS = [
-    "LIKE_POST", "DISLIKE_POST", "CREATE_POST", "CREATE_COMMENT",
-    "LIKE_COMMENT", "DISLIKE_COMMENT", "SEARCH_POSTS", "SEARCH_USER",
-    "TREND", "REFRESH", "DO_NOTHING", "FOLLOW", "MUTE",
-]
-
-# Combined (DO_NOTHING is skipped during memory storage)
-MIROFISH_ACTIONS = list(set(TWITTER_ACTIONS + REDDIT_ACTIONS) - {"DO_NOTHING"})
-
-
-# ======================================================================
-# Graph Memory Configuration
-# ======================================================================
-
-def build_config():
-    """Build Mem0 config with Graph Memory.
-
-    Uses Neo4j if credentials are set, otherwise falls back to Kuzu (embedded).
-    """
-    neo4j_url = os.environ.get("NEO4J_URL")
-
-    # Shared config for LLM, embedder, and vector store
-    base = {
-        "llm": {
-            "provider": "openai",
-            "config": {"model": "gpt-4o-mini", "temperature": 0.1}
-        },
-        "embedder": {
-            "provider": "openai",
-            "config": {"model": "text-embedding-3-small", "embedding_dims": 1536}
-        },
-        "vector_store": {
-            "provider": "qdrant",
-            "config": {
-                "collection_name": "mirofish",
-                "embedding_model_dims": 1536,
-            }
-        },
-    }
-
-    custom_prompt = (
-        "Extract all people, organizations, policies, locations, "
-        "and their relationships. Capture support/opposition stances, "
-        "affiliations, and quantitative claims."
-    )
-
-    if neo4j_url:
-        base["graph_store"] = {
-            "provider": "neo4j",
-            "config": {
-                "url": neo4j_url,
-                "username": os.environ.get("NEO4J_USERNAME", "neo4j"),
-                "password": os.environ.get("NEO4J_PASSWORD", "password"),
-            },
-            "custom_prompt": custom_prompt,
-        }
-    else:
-        # Fallback: Kuzu embedded (no external services needed)
-        print("  NEO4J_URL not set — using Kuzu (embedded) graph store")
-        base["graph_store"] = {
-            "provider": "kuzu",
-            "config": {"db": "/tmp/mirofish_graph.kuzu"},
-            "custom_prompt": custom_prompt,
-        }
-
-    return base
-
-
-# ======================================================================
-# Simulation Engine
-# ======================================================================
-
-class MiroFishSimulation:
-    """
-    Multi-agent simulation with graph-powered memory.
-
-    Uses Mem0 Graph Memory to replace MiroFish's Zep Cloud integration:
-    - Entities and relationships are extracted automatically from text
-    - search() returns both semantic memories AND graph relations
-    - Per-agent isolation via run_id
-    - Project isolation via user_id
-    """
-
-    def __init__(self, project_id: str, config: dict):
-        self.project_id = project_id
-        self.memory = Memory.from_config(config)
-        self.stats = {
-            "documents_ingested": 0,
-            "activities_recorded": 0,
-            "rounds_completed": 0,
-        }
-
-    # ------------------------------------------------------------------
-    # Stage 1: Graph Building — Seed Document Ingestion
-    # ------------------------------------------------------------------
-
-    def ingest_documents(self, documents: list[str]):
-        """Ingest seed documents and extract entities + relationships.
-
-        MiroFish equivalent: GraphBuilderService.build_graph()
-        Zep equivalent: graph.add_batch() with episode polling
-
-        With Mem0 Graph Memory, each document is processed by the LLM
-        to extract entities (people, orgs, policies) and relationships
-        (supports, opposes, filed). These become nodes and edges in the
-        graph store, alongside vector embeddings for semantic search.
-        """
-        print("  Ingesting documents and building knowledge graph...")
-        for i, doc in enumerate(documents):
-            result = self.memory.add(
-                [{"role": "user", "content": doc}],
-                user_id=self.project_id,
-                metadata={"stage": "graph_building", "source": "seed_document", "chunk_index": i}
-            )
-            # Graph Memory returns extracted relations
-            relations = result.get("relations", {})
-            added = relations.get("added_entities", [])
-            if added:
-                print(f"    Doc {i}: extracted {len(added)} entities/relations")
-
-        self.stats["documents_ingested"] = len(documents)
-        print(f"  Ingested {len(documents)} documents")
-
-    # ------------------------------------------------------------------
-    # Stage 2: Environment Setup — Agent Profile Enrichment
-    # ------------------------------------------------------------------
-
-    def enrich_agent_profile(self, agent_name: str, persona_query: str) -> dict:
-        """Search memory + graph for context relevant to an agent's persona.
-
-        MiroFish equivalent: OasisProfileGenerator using graph.search()
-
-        Returns both semantic memories and graph relations that can be
-        injected into the agent's system prompt.
-        """
-        results = self.memory.search(
-            persona_query,
-            user_id=self.project_id,
-            limit=10
-        )
-        facts = [r["memory"] for r in results.get("results", [])]
-        relations = results.get("relations", [])
-
-        print(f"  {agent_name}: {len(facts)} facts, {len(relations)} relations")
-        return {"facts": facts, "relations": relations}
-
-    # ------------------------------------------------------------------
-    # Stage 3: Simulation — Agent Activity Tracking
-    # ------------------------------------------------------------------
-
-    def record_action(self, agent_id: str, agent_name: str,
-                      action_type: str, content: str,
-                      platform: str, round_num: int):
-        """Record a single agent action as a memory with graph extraction.
-
-        MiroFish equivalent: ZepGraphMemoryUpdater.add_activity()
-        Zep equivalent: graph.add(type="text", data=episode_text)
-
-        Agent memories use run_id to group by agent (no assistant
-        memories involved). Graph Memory extracts entities/relationships
-        from the action content automatically.
-        """
-        formatted = f"{agent_name} [{action_type}]: {content}"
-
-        self.memory.add(
-            [{"role": "user", "content": formatted}],
-            run_id=agent_id,
-            metadata={
-                "action_type": action_type,
-                "platform": platform,
-                "round": round_num,
-                "agent_name": agent_name,
-            }
-        )
-        self.stats["activities_recorded"] += 1
-
-    def run_round(self, round_num: int, activities: list[tuple]):
-        """Execute one simulation round."""
-        print(f"  Round {round_num}: {len(activities)} actions")
-        for agent_id, agent_name, action_type, content, platform in activities:
-            self.record_action(agent_id, agent_name, action_type, content, platform, round_num)
-        self.stats["rounds_completed"] = max(self.stats["rounds_completed"], round_num)
-
-    def recall_agent_memory(self, agent_id: str, query: str) -> dict:
-        """Agent recalls its own memories mid-simulation.
-
-        Searches by run_id to match the scope used during add().
-        """
-        results = self.memory.search(
-            query,
-            run_id=agent_id,
-            limit=5
-        )
-        return {
-            "memories": [r["memory"] for r in results.get("results", [])],
-            "relations": results.get("relations", []),
-        }
-
-    # ------------------------------------------------------------------
-    # Stage 4: Report Generation — Semantic + Graph Retrieval
-    # ------------------------------------------------------------------
-
-    def quick_search(self, query: str, limit: int = 10) -> dict:
-        """Semantic search + graph relations across all agents.
-
-        MiroFish equivalent: ZepToolsService.quick_search()
-        Returns both vector-matched memories and related graph triples.
-        """
-        results = self.memory.search(
-            query,
-            user_id=self.project_id,
-            limit=limit
-        )
-        return {
-            "memories": [r["memory"] for r in results.get("results", [])],
-            "relations": results.get("relations", []),
-        }
-
-    def panorama_search(self) -> dict:
-        """Retrieve all memories + all graph relations.
-
-        MiroFish equivalent: ZepToolsService.panorama_search()
-        Returns the complete knowledge state for report generation.
-        """
-        results = self.memory.get_all(user_id=self.project_id)
-        return {
-            "memories": [r["memory"] for r in results.get("results", [])],
-            "relations": results.get("relations", []),
-        }
-
-    def agent_search(self, agent_id: str, query: str, limit: int = 10) -> dict:
-        """Search within a single agent's memory space."""
-        results = self.memory.search(
-            query,
-            run_id=agent_id,
-            limit=limit
-        )
-        return {
-            "memories": [r["memory"] for r in results.get("results", [])],
-            "relations": results.get("relations", []),
-        }
-
-    # ------------------------------------------------------------------
-    # Cleanup
-    # ------------------------------------------------------------------
-
-    def cleanup(self):
-        """Delete all memories and graph data for this simulation."""
-        self.memory.delete_all(user_id=self.project_id)
-        print(f"  Cleaned up all memories for {self.project_id}")
-
-
-# ======================================================================
-# Run the full 5-stage pipeline
-# ======================================================================
-
-def main():
-    project_id = f"mirofish_housing_{int(time.time())}"
-    config = build_config()
-    sim = MiroFishSimulation(project_id=project_id, config=config)
-
-    # ==================================================================
-    # STAGE 1: Graph Building — Ingest seed documents
-    # ==================================================================
-    print("=" * 60)
-    print("STAGE 1: Graph Building")
-    print("=" * 60)
-
-    sim.ingest_documents([
-        "The city council proposed a new zoning reform allowing higher "
-        "density housing in suburban areas. Mayor Chen expressed strong "
-        "support, citing a 40% housing shortage affecting young professionals. "
-        "The reform would allow buildings up to 8 stories in previously "
-        "restricted 3-story zones.",
-
-        "Local homeowners association president Wang opposes the reform, "
-        "arguing it will decrease property values by 15-20%. The association "
-        "represents 5,000 homeowners in the affected districts. Wang has "
-        "organized three community meetings and collected 2,000 signatures.",
-
-        "Professor Li from Beijing University published research showing "
-        "similar reforms in Shenzhen led to 15% price drops in existing "
-        "homes but created 30% more affordable housing units within 3 years. "
-        "The study covered 12 districts and 50,000 housing units.",
-    ])
-
-    # ==================================================================
-    # STAGE 2: Environment Setup — Enrich agent profiles
-    # ==================================================================
-    print("\n" + "=" * 60)
-    print("STAGE 2: Environment Setup")
-    print("=" * 60)
-
-    mayor_context = sim.enrich_agent_profile(
-        "Mayor Chen",
-        "Mayor Chen housing reform zoning policy"
-    )
-    wang_context = sim.enrich_agent_profile(
-        "Wang",
-        "Wang homeowner opposition property values petition"
-    )
-    li_context = sim.enrich_agent_profile(
-        "Professor Li",
-        "Professor Li research housing data Shenzhen"
-    )
-
-    print("\n  Example profile context for Mayor Chen:")
-    for fact in mayor_context["facts"][:3]:
-        print(f"    Fact: {fact}")
-    for rel in mayor_context["relations"][:3]:
-        src = rel.get("source", "?")
-        edge = rel.get("relationship", "?")
-        dst = rel.get("destination", rel.get("target", "?"))
-        print(f"    Relation: {src} --[{edge}]--> {dst}")
-
-    # ==================================================================
-    # STAGE 3: Simulation — Run agent interactions
-    # ==================================================================
-    print("\n" + "=" * 60)
-    print("STAGE 3: Simulation")
-    print("=" * 60)
-
-    # Round 1: Opening statements
-    sim.run_round(1, [
-        ("mayor_chen", "Mayor Chen", "CREATE_POST",
-         "This reform will create 10,000 new housing units by 2028. "
-         "Young families deserve affordable homes. #HousingForAll",
-         "twitter"),
-
-        ("wang_homeowner", "Wang", "CREATE_POST",
-         "Our property values will plummet! The council ignores the "
-         "voices of 5,000 homeowners. #StopTheReform",
-         "twitter"),
-
-        ("prof_li", "Professor Li", "CREATE_POST",
-         "New analysis: Shenzhen zoning data shows net positive outcomes "
-         "after 3 years. Short-term pain, long-term gain for housing equity.",
-         "twitter"),
-    ])
-
-    # Round 2: Debate and interaction
-    sim.run_round(2, [
-        ("wang_homeowner", "Wang", "CREATE_COMMENT",
-         "Replied to Professor Li: 'Shenzhen is a tier-1 city with "
-         "completely different dynamics. Your comparison is misleading.'",
-         "twitter"),
-
-        ("mayor_chen", "Mayor Chen", "LIKE_POST",
-         "Liked Professor Li's post about Shenzhen housing data.",
-         "twitter"),
-
-        ("prof_li", "Professor Li", "CREATE_COMMENT",
-         "Replied to Wang: 'The methodology controls for city tier "
-         "and population density. I invite you to review the full dataset.'",
-         "twitter"),
-
-        ("mayor_chen", "Mayor Chen", "CREATE_POST",
-         "Data from @ProfLi confirms what we've been saying: zoning "
-         "reform works. Let's move forward with evidence, not fear.",
-         "twitter"),
-    ])
-
-    # Round 3: Escalation and platform expansion
-    sim.run_round(3, [
-        ("wang_homeowner", "Wang", "CREATE_POST",
-         "Filing formal petition with 3,000 signatures against the "
-         "zoning reform. Council meeting next Tuesday. All homeowners "
-         "must attend!",
-         "reddit"),
-
-        ("mayor_chen", "Mayor Chen", "CREATE_POST",
-         "Announcing public town hall on zoning reform this Saturday. "
-         "All voices welcome. Data-driven decisions benefit everyone.",
-         "twitter"),
-
-        ("prof_li", "Professor Li", "CREATE_POST",
-         "Published full dataset and methodology on my university page. "
-         "Transparency is essential for informed public debate.",
-         "twitter"),
-
-        ("wang_homeowner", "Wang", "FOLLOW",
-         "Followed @MayorChen to monitor policy updates.",
-         "twitter"),
-    ])
-
-    # Mid-simulation: agent recalls own memory + graph
-    print("\n  Mid-simulation recall for Mayor Chen:")
-    mayor_recall = sim.recall_agent_memory(
-        "mayor_chen",
-        "What positions have I taken on housing reform?"
-    )
-    for mem in mayor_recall["memories"]:
-        print(f"    Memory: {mem}")
-    for rel in mayor_recall["relations"][:3]:
-        src = rel.get("source", "?")
-        edge = rel.get("relationship", "?")
-        dst = rel.get("destination", rel.get("target", "?"))
-        print(f"    Relation: {src} --[{edge}]--> {dst}")
-
-    # ==================================================================
-    # STAGE 4: Report Generation — Retrieve memories + graph for analysis
-    # ==================================================================
-    print("\n" + "=" * 60)
-    print("STAGE 4: Report Generation")
-    print("=" * 60)
-
-    # Quick search: targeted query
-    print("\n  Quick Search: 'opposition to housing reform'")
-    opposition = sim.quick_search("opposition to housing reform", limit=5)
-    for mem in opposition["memories"]:
-        print(f"    Memory: {mem}")
-    for rel in opposition["relations"][:3]:
-        src = rel.get("source", "?")
-        edge = rel.get("relationship", "?")
-        dst = rel.get("destination", rel.get("target", "?"))
-        print(f"    Relation: {src} --[{edge}]--> {dst}")
-
-    # Agent-specific search
-    print("\n  Agent Search: Wang's activities")
-    wang_activities = sim.agent_search("wang_homeowner", "all actions and statements")
-    for mem in wang_activities["memories"]:
-        print(f"    Memory: {mem}")
-
-    # Panorama: full overview
-    print("\n  Panorama Search: all memories + relations")
-    panorama = sim.panorama_search()
-    print(f"    Total memories: {len(panorama['memories'])}")
-    print(f"    Total relations: {len(panorama['relations'])}")
-    for mem in panorama["memories"][:5]:
-        print(f"    Memory: {mem}")
-    if len(panorama["memories"]) > 5:
-        print(f"    ... and {len(panorama['memories']) - 5} more")
-    for rel in panorama["relations"][:5]:
-        src = rel.get("source", "?")
-        edge = rel.get("relationship", "?")
-        dst = rel.get("destination", rel.get("target", "?"))
-        print(f"    Relation: {src} --[{edge}]--> {dst}")
-
-    # ==================================================================
-    # STAGE 5: Deep Interaction — Post-simulation queries
-    # ==================================================================
-    print("\n" + "=" * 60)
-    print("STAGE 5: Deep Interaction")
-    print("=" * 60)
-
-    queries = [
-        "How did the debate evolve across the three rounds?",
-        "What evidence was cited by each side?",
-        "Who supports and who opposes the reform?",
-    ]
-
-    for query in queries:
-        print(f"\n  Query: '{query}'")
-        results = sim.quick_search(query, limit=3)
-        for mem in results["memories"][:2]:
-            print(f"    Memory: {mem}")
-        for rel in results["relations"][:2]:
-            src = rel.get("source", rel.get("source_node", "?"))
-            edge = rel.get("relationship", rel.get("relation", "?"))
-            dst = rel.get("destination", rel.get("destination_node", "?"))
-            print(f"    Relation: {src} --[{edge}]--> {dst}")
-
-    # ==================================================================
-    # Summary
-    # ==================================================================
-    print("\n" + "=" * 60)
-    print("SIMULATION COMPLETE")
-    print("=" * 60)
-    print(f"  Project ID:        {project_id}")
-    print(f"  Documents ingested: {sim.stats['documents_ingested']}")
-    print(f"  Activities tracked: {sim.stats['activities_recorded']}")
-    print(f"  Rounds completed:  {sim.stats['rounds_completed']}")
-    print(f"  Total memories:    {len(panorama['memories'])}")
-    print(f"  Total relations:   {len(panorama['relations'])}")
-
-    # Cleanup (uncomment to delete all memories + graph data)
-    # sim.cleanup()
-
-
-if __name__ == "__main__":
-    print("MiroFish Swarm Prediction Simulation powered by Mem0 Graph Memory\n")
-    main()
-```
-
-## How It Works
-
-### Graph Memory: The Right Fit for MiroFish
-
-MiroFish's entire pipeline revolves around a **knowledge graph** — it extracts entities from documents, builds relationships, and queries the graph throughout simulation and reporting. Mem0's Graph Memory provides the same capabilities:
-
-| MiroFish needs | Zep Cloud | Mem0 Graph Memory |
-|---|---|---|
-| **Entity extraction** | Built-in via Zep API | Automatic via LLM extraction |
-| **Relationship mining** | Graph edges | `(source) --[relationship]--> (destination)` triples |
-| **Semantic + keyword search** | Semantic + BM25 | Vector similarity + graph relation retrieval |
-| **Graph traversal** | Node/edge queries | `relations` array in search results |
-| **Per-agent isolation** | Single shared graph in MiroFish | Native `run_id` scoping |
-| **Self-hosting** | No (cloud only) | Yes — Neo4j, Memgraph, Kuzu, Neptune |
-| **Node/memory limits** | Capped on free tier | Unlimited (self-hosted) |
-
-### How search() Returns Both Memories and Relations
-
-When Graph Memory is enabled, every `search()` call returns two arrays:
-
-```python
-results = memory.search("housing reform", user_id="my_sim")
-
-# Vector-matched memories (ordered by similarity)
-results["results"]   # [{"memory": "...", "score": 0.85, ...}, ...]
-
-# Graph relations connected to query entities
-results["relations"] # [{"source": "mayor_chen", "relationship": "supports", "destination": "zoning_reform"}, ...]
-```
-
-This is what makes Mem0 Graph Memory a natural replacement for Zep — you get semantic search AND structured graph data in a single call.
-
-### Per-Agent Memory Isolation
-
-`user_id` scopes the simulation project. `run_id` tags individual agent actions at storage time (we use `run_id` instead of `agent_id` since no assistant memories are involved). Searches use `user_id` for project-wide retrieval:
-
-```python
-# Store project-level memories (seed documents)
-memory.add(
-    [{"role": "user", "content": "Mayor Chen supports the zoning reform."}],
-    user_id="my_sim"
-)
-
-# Store agent-specific memories (simulation actions)
-memory.add(
-    [{"role": "user", "content": "Mayor Chen [CREATE_POST]: Reform works!"}],
-    run_id="mayor_chen"
-)
-
-# Search project-level memories (seed docs)
-memory.search("housing reform", user_id="my_sim")
-
-# Search agent-specific memories (actions stored with run_id)
-memory.search("housing reform", run_id="mayor_chen")
-
-# Get all project-level memories + graph relations
-memory.get_all(user_id="my_sim")
-```
-
-<Note>
-  Use `user_id` for project-level data (seed documents) and `run_id` for agent actions — both for `add()` and `search()`. Always match the scope: if you `add()` with `run_id`, `search()` with `run_id`. Use the message list format `[{"role": "user", "content": "..."}]` for all `add()` calls — it works on both OSS and Cloud.
-</Note>
-
-### Stage Mapping
-
-| MiroFish Stage | What Happens | Mem0 Graph Memory Call |
-|---|---|---|
-| **1. Graph Building** | Ingest docs, extract entities | `memory.add(doc, user_id=project)` — entities/relations extracted automatically |
-| **2. Environment Setup** | Enrich agent personas from graph | `memory.search(query, user_id=project)` — returns facts + relations |
-| **3. Simulation** | Track per-agent actions | `memory.add(messages, run_id=agent)` |
-| **3. Simulation** | Mid-round recall | `memory.search(query, run_id=agent)` |
-| **4. Report Generation** | Targeted analysis | `memory.search(query, user_id=project)` — memories + graph |
-| **4. Report Generation** | Full overview | `memory.get_all(user_id=project)` — all memories + all relations |
-| **5. Deep Interaction** | Follow-up queries | `memory.search(query, user_id=project)` |
-
-### Zep-to-Mem0 Migration Reference
-
-For developers replacing MiroFish's Zep integration. Note that Mem0 Graph Memory covers the core graph operations but some Zep features have no direct equivalent — see caveats below.
-
-| MiroFish Service | Zep Call | Mem0 Graph Memory Equivalent | Caveat |
-|---|---|---|---|
-| GraphBuilderService | `client.graph.create()` | Implicit on first `memory.add()` | |
-| GraphBuilderService | `client.graph.set_ontology()` | `custom_prompt` in graph_store config | Freeform text, not a typed schema like Zep's `EntityModel`/`EdgeModel` |
-| GraphBuilderService | `client.graph.add_batch(episodes)` | `memory.add()` per chunk | No batch API — call per chunk |
-| GraphBuilderService | `client.graph.episode.get(uuid)` | Not needed (add is synchronous in OSS) | |
-| GraphBuilderService | `client.graph.delete(id)` | `memory.delete_all(user_id=...)` | |
-| ZepEntityReader | `client.graph.node.get_by_graph_id()` | `memory.get_all(user_id=...)` → `relations` | |
-| ZepEntityReader | `client.graph.node.get(uuid)` | `memory.search(entity_name, user_id=...)` | Semantic search, not exact ID lookup |
-| ZepEntityReader | `client.graph.node.get_entity_edges()` | `memory.search(entity_name, user_id=...)` → `relations` | Returns all matching relations, not edges for a specific node |
-| ZepGraphMemoryUpdater | `client.graph.add(type="text")` | `memory.add(messages, run_id=...)` | No batch buffering or retry — implement in your wrapper |
-| ZepToolsService | `search_graph(query, scope)` | `memory.search(query, user_id=...)` → memories + relations | |
-| ZepToolsService | `get_entities()` | `memory.get_all(user_id=...)` → `relations` | |
-| ZepToolsService | Panorama (all nodes + edges) | `memory.get_all(user_id=...)` | No temporal fact separation (active vs historical) |
-| ZepToolsService | InsightForge (multi-query decomposition) | Not available | Implement LLM-driven sub-query decomposition in your own ReportAgent |
-| OasisProfileGenerator | `client.graph.search()` | `memory.search(query, user_id=...)` | |
-
-<Note>
-  **What Mem0 Graph Memory does not cover**: Zep's typed ontology schemas (`EntityModel`, `EdgeModel`), temporal fact lifecycle (`valid_at`/`invalid_at`/`expired_at`), single-node-by-ID lookup, and InsightForge's multi-query decomposition. For InsightForge-like functionality, implement sub-query logic in your own ReportAgent using `memory.search()` as the retrieval primitive.
-</Note>
-
-### Custom Extraction Prompts
-
-Guide what entities and relationships Mem0 extracts — analogous to (but less structured than) Zep's `set_ontology()`:
-
-```python
-config = {
-    "graph_store": {
-        "provider": "neo4j",
-        "config": {"url": "...", "username": "...", "password": "..."},
-        "custom_prompt": (
-            "Extract all people, organizations, policies, locations, "
-            "and their relationships. Capture support/opposition stances, "
-            "affiliations, and quantitative claims."
-        ),
-    }
-}
-```
-
-### Action Types
-
-MiroFish's OASIS engine produces these agent action types. Format them as natural language when storing. Skip `DO_NOTHING` actions (no memory value). `TREND` and `REFRESH` are Reddit-only discovery actions — store if you want to track browsing behavior.
-
-| Action Type | Platform | Example Memory Content |
-|---|---|---|
-| `CREATE_POST` | Both | `"Mayor Chen [CREATE_POST]: This reform will create 10,000 units"` |
-| `CREATE_COMMENT` | Reddit | `"Wang [CREATE_COMMENT]: Replied to Prof Li: 'Your data is misleading'"` |
-| `LIKE_POST` | Both | `"Mayor Chen [LIKE_POST]: Liked Prof Li's post about Shenzhen data"` |
-| `REPOST` | Twitter | `"Prof Li [REPOST]: Reposted Mayor Chen's town hall announcement"` |
-| `FOLLOW` | Both | `"Wang [FOLLOW]: Followed @MayorChen"` |
-| `QUOTE_POST` | Twitter | `"Mayor Chen [QUOTE_POST]: 'Data confirms reform works' quoting Prof Li"` |
-| `DISLIKE_POST` | Reddit | `"Wang [DISLIKE_POST]: Downvoted Mayor Chen's reform post"` |
-| `TREND` | Reddit | `"Prof Li [TREND]: Browsed trending topics"` |
-| `DO_NOTHING` | Both | Skip — no memory value |
-
-## Running the Example
-
-```bash
-# Option A: Neo4j (production)
-export OPENAI_API_KEY="sk-..."
-export NEO4J_URL="neo4j://localhost:7687"
-export NEO4J_USERNAME="neo4j"
-export NEO4J_PASSWORD="password"
-python mirofish_swarm_memory.py
-
-# Option B: Kuzu (zero dependencies, just need OpenAI key)
-export OPENAI_API_KEY="sk-..."
-python mirofish_swarm_memory.py  # auto-detects missing NEO4J_URL, uses Kuzu
-```
-
-<Note>
-Exact output varies as Mem0 automatically extracts and deduplicates entities. The specific relations and memory counts depend on LLM extraction quality.
-</Note>
-
-## Best Practices
-
-1. **Unique `user_id` per simulation** — Use timestamps or UUIDs (e.g., `mirofish_housing_1742198400`) to prevent memory collisions between runs
-2. **Always set `run_id` for agent actions** — Per-agent isolation prevents memory cross-contamination between agents
-3. **Use `custom_prompt`** — Guide entity extraction to capture domain-specific relationships (people, policies, stances)
-4. **Format actions as natural language** — `"Mayor Chen [CREATE_POST]: content"` extracts better entities than raw JSON
-5. **Query relations for reports** — The `relations` array in search results gives structured `(source, relationship, destination)` triples for building analytical reports
-6. **Cleanup old simulations** — Call `delete_all(user_id=...)` when a simulation run is no longer needed
-
-## Resources
-
-- [MiroFish GitHub](https://github.com/666ghj/MiroFish) — Source code and setup guide
-- [MiroFish Documentation](https://deepwiki.com/666ghj/MiroFish) — Full framework docs
-- [Mem0 Graph Memory](/open-source/features/graph-memory) — Graph Memory documentation
-- [Mem0 Documentation](https://docs.mem0.ai/introduction) — Full API reference
-
-<CardGroup cols={2}>
-  <Card title="Graph Memory" icon="network-wired" href="/open-source/features/graph-memory">
-    Full Graph Memory documentation with provider setup.
-  </Card>
-  <Card title="MiroFish GitHub" icon="fish" href="https://github.com/666ghj/MiroFish">
-    MiroFish source code and setup guide.
-  </Card>
-</CardGroup>

docs/cookbooks/integrations/agents-sdk-tool.mdx

@@ -112,7 +112,7 @@ async def search_memory(
         query: The search query.
     """
     user_id = context.context.user_id or "default_user"
-    memories = await client.search(query, user_id=user_id)
+    memories = await client.search(query, filters={"user_id": user_id})
     results = '\n'.join([result["memory"] for result in memories["results"]])
     return str(results)
 ```

docs/cookbooks/integrations/aws-bedrock.mdx

@@ -1,17 +1,17 @@
 ---
 title: Bedrock with Persistent Memory
-description: "Pair Mem0 with AWS Bedrock, OpenSearch, and Neptune for a managed stack."
+description: "Pair Mem0 with AWS Bedrock and OpenSearch for a managed stack."
 ---
 
 
-This example demonstrates how to configure and use the `mem0ai` SDK with **AWS Bedrock**, **OpenSearch Service (AOSS)**, and **AWS Neptune Analytics** for persistent memory capabilities in Python.
+This example demonstrates how to configure and use the `mem0ai` SDK with **AWS Bedrock** and **OpenSearch Service (AOSS)** for persistent memory capabilities in Python.
 
 ## Installation
 
 Install the required dependencies to include the Amazon data stack, including **boto3**, **opensearch-py**, and **langchain-aws**:
 
 ```bash
-pip install "mem0ai[graph,extras]"
+pip install "mem0ai[extras]"
 ```
 
 ## Environment Setup
@@ -38,12 +38,11 @@ This sets up Mem0 with:
 - [AWS Bedrock for LLM](https://docs.mem0.ai/components/llms/models/aws_bedrock)
 - [AWS Bedrock for embeddings](https://docs.mem0.ai/components/embedders/models/aws_bedrock#aws-bedrock)
 - [OpenSearch as the vector store](https://docs.mem0.ai/components/vectordbs/dbs/opensearch)
-- [Graph Memory guide](https://docs.mem0.ai/open-source/features/graph-memory)
 
 ```python
 import boto3
 from opensearchpy import RequestsHttpConnection, AWSV4SignerAuth
-from mem0.memory.main import Memory
+from mem0 import Memory
 
 region = 'us-west-2'
 service = 'aoss'
@@ -79,12 +78,6 @@ config = {
             "embedding_model_dims": 1024,
         }
     },
-    "graph_store": {
-        "provider": "neptune",
-        "config": {
-            "endpoint": f"neptune-graph://my-graph-identifier",
-        },
-    },
 }
 
 # Initialize the memory system
@@ -93,8 +86,6 @@ m = Memory.from_config(config)
 
 ## Usage
 
-Reference [Notebook example](https://github.com/mem0ai/mem0/blob/main/examples/graph-db-demo/neptune-example.ipynb)
-
 ### Add a memory
 
 ```python
@@ -112,13 +103,13 @@ result = m.add(messages, user_id="alice", metadata={"category": "movie_recommend
 ### Search a memory
 
 ```python
-relevant_memories = m.search(query, user_id="alice")
+relevant_memories = m.search(query, filters={"user_id": "alice"})
 ```
 
 ### Get all memories
 
 ```python
-all_memories = m.get_all(user_id="alice")
+all_memories = m.get_all(filters={"user_id": "alice"})
 ```
 
 ### Get a specific memory
@@ -129,15 +120,12 @@ memory = m.get(memory_id)
 
 ## Conclusion
 
-With Mem0 and AWS services like Bedrock, OpenSearch, and Neptune Analytics, you can build intelligent AI companions that remember, adapt, and personalize their responses over time. This makes them ideal for long-term assistants, tutors, or support bots with persistent memory and natural conversation abilities.
+With Mem0 and AWS services like Bedrock and OpenSearch, you can build intelligent AI companions that remember, adapt, and personalize their responses over time. This makes them ideal for long-term assistants, tutors, or support bots with persistent memory and natural conversation abilities.
 
 ---
 
 <CardGroup cols={2}>
-  <Card title="Neptune Analytics with Mem0" icon="database" href="/cookbooks/integrations/neptune-analytics">
-    Explore graph-based memory storage with AWS Neptune Analytics.
-  </Card>
-  <Card title="Graph Memory Features" icon="sitemap" href="/open-source/features/graph-memory">
-    Learn how to leverage knowledge graphs for entity relationships.
+  <Card title="Memory Evaluation" icon="chart-line" href="/core-concepts/memory-evaluation">
+    Understand how Mem0's memory system is benchmarked and evaluated.
   </Card>
 </CardGroup>

docs/cookbooks/integrations/healthcare-google-adk.mdx

@@ -77,7 +77,7 @@ def retrieve_patient_info(query: str) -> dict:
     results = mem0_client.search(
         query,
         user_id=USER_ID,
-        limit=5,
+        top_k=5,
         threshold=0.7  # Higher threshold for more relevant results
     )
 

docs/cookbooks/integrations/neptune-analytics.mdx

@@ -1,133 +0,0 @@
----
-title: Graph Memory on Neptune
-description: "Combine Mem0 graph memory with AWS Neptune Analytics and Bedrock."
----
-
-
-This example demonstrates how to configure and use the `mem0ai` SDK with **AWS Bedrock** and **AWS Neptune Analytics** for persistent memory capabilities in Python.
-
-## Installation
-
-Install the required dependencies to include the Amazon data stack, including **boto3** and **langchain-aws**:
-
-```bash
-pip install "mem0ai[graph,extras]"
-```
-
-## Environment Setup
-
-Set your AWS environment variables:
-
-```python
-import os
-
-# Set these in your environment or notebook
-os.environ['AWS_REGION'] = 'us-west-2'
-os.environ['AWS_ACCESS_KEY_ID'] = 'AK00000000000000000'
-os.environ['AWS_SECRET_ACCESS_KEY'] = 'AS00000000000000000'
-
-# Confirm they are set
-print(os.environ['AWS_REGION'])
-print(os.environ['AWS_ACCESS_KEY_ID'])
-print(os.environ['AWS_SECRET_ACCESS_KEY'])
-```
-
-## Configuration and Usage
-
-This sets up Mem0 with:
-- [AWS Bedrock for LLM](https://docs.mem0.ai/components/llms/models/aws_bedrock)
-- [AWS Bedrock for embeddings](https://docs.mem0.ai/components/embedders/models/aws_bedrock#aws-bedrock)
-- [Neptune Analytics as the vector store](https://docs.mem0.ai/components/vectordbs/dbs/neptune_analytics)
-- [Graph Memory guide](https://docs.mem0.ai/open-source/features/graph-memory).
-
-```python
-import boto3
-from mem0.memory.main import Memory
-
-region = 'us-west-2'
-neptune_analytics_endpoint = 'neptune-graph://my-graph-identifier'
-
-config = {
-    "embedder": {
-        "provider": "aws_bedrock",
-        "config": {
-            "model": "amazon.titan-embed-text-v2:0"
-        }
-    },
-    "llm": {
-        "provider": "aws_bedrock",
-        "config": {
-            "model": "us.anthropic.claude-3-7-sonnet-20250219-v1:0",
-            "temperature": 0.1,
-            "max_tokens": 2000
-        }
-    },
-    "vector_store": {
-        "provider": "neptune",
-        "config": {
-            "collection_name": "mem0",
-            "endpoint": neptune_analytics_endpoint,
-        },
-    },
-    "graph_store": {
-        "provider": "neptune",
-        "config": {
-            "endpoint": neptune_analytics_endpoint,
-        },
-    },
-}
-
-# Initialize the memory system
-m = Memory.from_config(config)
-```
-
-## Usage
-
-Reference [Notebook example](https://github.com/mem0ai/mem0/blob/main/examples/graph-db-demo/neptune-example.ipynb)
-
-#### Add a memory:
-
-```python
-messages = [
-    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
-    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
-    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
-]
-
-# Store inferred memories (default behavior)
-result = m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"})
-```
-
-#### Search a memory:
-```python
-relevant_memories = m.search(query, user_id="alice")
-```
-
-#### Get all memories:
-```python
-all_memories = m.get_all(user_id="alice")
-```
-
-#### Get a specific memory:
-```python
-memory = m.get(memory_id)
-```
-
-
----
-
-## Conclusion
-
-With Mem0 and AWS services like Bedrock and Neptune Analytics, you can build intelligent AI companions that remember, adapt, and personalize their responses over time. This makes them ideal for long-term assistants, tutors, or support bots with persistent memory and natural conversation abilities.
-
----
-
-<CardGroup cols={2}>
-  <Card title="AWS Bedrock with Mem0" icon="aws" href="/cookbooks/integrations/aws-bedrock">
-    Combine Neptune Analytics with AWS Bedrock for complete AWS stack.
-  </Card>
-  <Card title="Graph Memory Architecture" icon="sitemap" href="/cookbooks/essentials/choosing-memory-architecture-vector-vs-graph">
-    Understand when to use graph vs vector memory for your use case.
-  </Card>
-</CardGroup>

docs/cookbooks/integrations/openai-tool-calls.mdx

@@ -28,13 +28,10 @@ Get your Mem0 API key from the <a href="https://app.mem0.ai/dashboard/api-keys"
 ### Configuration
 
 ```javascript
-const mem0Config = {
-    apiKey: process.env.MEM0_API_KEY,
-    user_id: "sample-user",
-};
+const USER_ID = "sample-user";
 
 const openAIClient = new OpenAI();
-const mem0Client = new MemoryClient(mem0Config);
+const mem0Client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY });
 ```
 
 ## Adding Memories
@@ -43,14 +40,14 @@ Store user preferences, past interactions, or any relevant information:
 <CodeGroup>
 ```javascript JavaScript
 async function addUserPreferences() {
-    const mem0Client = new MemoryClient(mem0Config);
+    const mem0Client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY });
     
     const userPreferences = "I Love BMW, Audi and Porsche. I Hate Mercedes. I love Red cars and Maroon cars. I have a budget of 120K to 150K USD. I like Audi the most.";
     
     await mem0Client.add([{
         role: "user",
         content: userPreferences,
-    }], mem0Config);
+    }], { userId: "sample-user" });
 }
 
 await addUserPreferences();
@@ -91,7 +88,7 @@ await addUserPreferences();
 Search for relevant memories based on the current user input:
 
 ```javascript
-const relevantMemories = await mem0Client.search(userInput, mem0Config);
+const relevantMemories = await mem0Client.search(userInput, { userId: USER_ID });
 ```
 
 ## Structured Responses with Zod
@@ -121,7 +118,7 @@ const carRecommendationTool = zodResponsesFunction({
 
 // Use the tool in your OpenAI request
 const response = await openAIClient.responses.create({
-    model: "gpt-4.1-nano-2025-04-14",
+    model: "gpt-5-mini",
     tools: [{ type: "web_search_preview" }, carRecommendationTool],
     input: `${getMemoryString(relevantMemories)}\n${userInput}`,
 });
@@ -133,7 +130,7 @@ Combine memory with web search for up-to-date recommendations:
 
 ```javascript
 const response = await openAIClient.responses.create({
-    model: "gpt-4.1-nano-2025-04-14",
+    model: "gpt-5-mini",
     tools: [{ type: "web_search_preview" }, carRecommendationTool],
     input: `${getMemoryString(relevantMemories)}\n${userInput}`,
 });
@@ -152,10 +149,7 @@ import dotenv from 'dotenv';
 
 dotenv.config();
 
-const mem0Config = {
-    apiKey: process.env.MEM0_API_KEY,
-    user_id: "sample-user",
-};
+const USER_ID = "sample-user";
 
 async function run() {
     // Responses without memories
@@ -185,7 +179,7 @@ const Cars = z.object({
 
 async function main(memory = false) {
   const openAIClient = new OpenAI();
-  const mem0Client = new MemoryClient(mem0Config);
+  const mem0Client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY });
 
   const input = "Suggest me some cars that I can buy today.";
 
@@ -195,16 +189,16 @@ async function main(memory = false) {
   await mem0Client.add([{
     role: "user",
     content: input,
-  }], mem0Config);
+  }], { userId: USER_ID });
 
   // Search for relevant memories
   let relevantMemories = []
   if (memory) {
-    relevantMemories = await mem0Client.search(input, mem0Config);
+    relevantMemories = await mem0Client.search(input, { userId: USER_ID });
   }
 
   const response = await openAIClient.responses.create({
-    model: "gpt-4.1-nano-2025-04-14",
+    model: "gpt-5-mini",
     tools: [{ type: "web_search_preview" }, tool],
     input: `${getMemoryString(relevantMemories)}\n${input}`,
   });
@@ -213,14 +207,14 @@ async function main(memory = false) {
 }
 
 async function addSampleMemories() {
-  const mem0Client = new MemoryClient(mem0Config);
+  const mem0Client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY });
 
   const myInterests = "I Love BMW, Audi and Porsche. I Hate Mercedes. I love Red cars and Maroon cars. I have a budget of 120K to 150K USD. I like Audi the most.";
   
   await mem0Client.add([{
     role: "user",
     content: myInterests,
-  }], mem0Config);
+  }], { userId: USER_ID });
 }
 
 const getMemoryString = (memories) => {

docs/cookbooks/operations/content-writing.mdx

@@ -202,7 +202,7 @@ Preferences:
     ]
 
     response = openai.chat.completions.create(
-        model="gpt-4.1-nano-2025-04-14",
+        model="gpt-5-mini",
         messages=messages
     )
     clean_response = response.choices[0].message.content.strip()

docs/cookbooks/operations/support-inbox.mdx

@@ -79,7 +79,7 @@ class CustomerSupportAIAgent:
         :param user_id: Optional user ID to filter memories.
         :return: List of memories.
         """
-        return self.memory.get_all(user_id=user_id)
+        return self.memory.get_all(filters={"user_id": user_id})
 
 # Instantiate the CustomerSupportAIAgent
 support_agent = CustomerSupportAIAgent()

docs/cookbooks/operations/team-task-agent.mdx

@@ -45,7 +45,7 @@ class CollaborativeAgent:
 
     def brainstorm(self, prompt):
         # Get recent messages for context
-        memories = self.mem.search(prompt, run_id=self.run_id, limit=5)["results"]
+        memories = self.mem.search(prompt, filters={"run_id": self.run_id}, top_k=5)["results"]
         context = "\n".join(f"- {m['memory']} (by {m.get('actor_id', 'Unknown')})" for m in memories)
         client = OpenAI()
         messages = [
@@ -53,14 +53,14 @@ class CollaborativeAgent:
             {"role": "user", "content": f"Prompt: {prompt}\nContext:\n{context}"}
         ]
         reply = client.chat.completions.create(
-            model="gpt-4.1-nano-2025-04-14",
+            model="gpt-5-mini",
             messages=messages
         ).choices[0].message.content.strip()
         self.add_message("assistant", "assistant", reply)
         return reply
 
     def get_all_messages(self):
-        return self.mem.get_all(run_id=self.run_id)["results"]
+        return self.mem.get_all(filters={"run_id": self.run_id})["results"]
 
     def print_sorted_by_time(self):
         messages = self.get_all_messages()

docs/cookbooks/overview.mdx

@@ -37,13 +37,6 @@ Here are some examples of how Mem0 can be integrated into various applications:
   >
     Filter speculation and low-confidence data.
   </Card>
-  <Card
-    title="Set Memory Expiration"
-    icon="timer"
-    href="/cookbooks/essentials/memory-expiration-short-and-long-term"
-  >
-    Short-term vs long-term retention strategies.
-  </Card>
 </CardGroup>
 
 ## Companion Playbooks
@@ -201,10 +194,7 @@ Here are some examples of how Mem0 can be integrated into various applications:
   >
     Persistent personality for Eliza agents.
   </Card>
-  <Card title="Browser Extension Memory" icon="globe" href="/cookbooks/frameworks/chrome-extension">
-    Universal memory layer for Chrome.
-  </Card>
-</CardGroup>
+  </CardGroup>
 
 ---
 

docs/core-concepts/memory-evaluation.mdx

@@ -0,0 +1,354 @@
+---
+title: "Memory Evaluation"
+description: "Understand how Mem0's memory system is evaluated, benchmark results, and how to run evaluations on your own data."
+icon: "chart-bar"
+iconType: "solid"
+---
+
+## Why Memory Evaluation Matters
+
+Most AI agent memory systems retrieve information by maximizing context window size. That works on benchmarks but not in production, where every token adds cost. **Token efficiency** — achieving high accuracy with less context per query — is what separates benchmark performance from production viability.
+
+The new Mem0 algorithm achieves competitive accuracy on LoCoMo, LongMemEval, and BEAM while averaging **under 7,000 tokens per retrieval call**. Full-context approaches on the same benchmarks routinely consume 25,000+ tokens per query.
+
+Evaluating a memory system at scale comes down to three parameters: **accuracy** (what the benchmarks measure), **cost** (context tokens per query), and **performance** (latency). Optimizing one is easy. Balancing all three at scale is the actual problem.
+
+Some benchmarks today — particularly smaller ones like LoCoMo and LongMemEval — can be materially improved by aggressive retrieval strategies, larger context windows, or frontier models. That does not necessarily mean the underlying memory system has gotten better. We evaluate under constraints that reflect how memory systems actually run in production: limited context windows and practical token budgets.
+
+## Architecture Overview
+
+Mem0's memory system operates across two phases — **extraction** (writing) and **retrieval** (reading) — with an entity linking layer connecting them.
+
+### Memory Extraction (Distillation)
+
+When new conversations arrive, the extraction pipeline processes them through five stages:
+
+1. **Store New Memories** — Conversation enters the pipeline asynchronously (after the agent responds)
+2. **Context Lookup** — Find related existing memories to avoid duplicates
+3. **Distill Memories** — Single-pass LLM extraction produces ADD-only facts from input + context
+4. **Deduplicate + Embed** — Hash-based deduplication, then vectorize new memories
+5. **Entity Linking** — Identify entities (proper nouns, quoted text, compound noun phrases) and link them across memories
+
+Memories are distributed across three storage layers, each tuned for a specific retrieval pattern:
+
+| Store | Contents | Purpose |
+|---|---|---|
+| **Vector Database** | Memory text, embeddings, metadata (timestamps, hash, categories, attributed_to) | Primary fact storage + semantic retrieval |
+| **Entity Store** | Entities + embeddings + linked memory IDs | Entity-based retrieval boost |
+| **SQL Database** | History log (ADD events) + rolling message window | Audit trail + extraction dedup context |
+
+<Info>
+The key architectural decision is **ADD-only extraction**. New facts are stored alongside old ones — nothing is overwritten or deleted. When information changes, both the old and new facts survive. This preserves temporal context and eliminates information loss from premature consolidation.
+</Info>
+
+### Multi-Signal Retrieval
+
+When a query arrives, the retrieval pipeline scores candidates across three signals in parallel:
+
+1. **Semantic Search** — Vector similarity scoring against memory embeddings
+2. **Keyword Search** — Normalized term matching via BM25 with verb-form lemmatization
+3. **Entity Search** — Entity graph matching boosts memories linked to query entities
+
+Results are fused via rank scoring into a final top-K set. Different query types lean on different signals:
+
+| Query Type | Primary Signal | Example |
+|---|---|---|
+| Conceptual | Semantic | "What does the user think about remote work?" |
+| Factual/exact | BM25 keyword | "What meetings did I attend last week?" |
+| Entity-centric | Entity matching | "What do we know about Alice?" |
+| Temporal | Semantic + keyword | "When did the user first mention the project?" |
+
+The combined score outperformed every individual signal across every category tested.
+
+## Benchmarks
+
+### LoCoMo
+
+[LoCoMo](https://github.com/snap-stanford/locomo) tests single-hop, multi-hop, open-domain, and temporal memory recall across conversational sessions.
+
+| Category | Old Algorithm | New Algorithm | Delta |
+|---|---|---|---|
+| **Overall** | **71.4** | **91.6** | **+20.2** |
+| Single-hop | 76.6 | 92.3 | +15.7 |
+| Multi-hop | 70.2 | 93.3 | +23.1 |
+| Open-domain | 57.3 | 76.0 | +18.7 |
+| Temporal | 63.2 | 92.8 | +29.6 |
+
+*Mean tokens: 6,956*
+
+The two largest gains are **temporal queries (+29.6)** and **multi-hop reasoning (+23.1)**. Both categories directly test the ADD-only architecture (preserving temporal context) and entity linking (connecting facts across memories).
+
+### LongMemEval
+
+[LongMemEval](https://github.com/xiaowu0162/LongMemEval) evaluates memory across single-session and multi-session contexts, including knowledge updates and temporal reasoning.
+
+| Category | Old Algorithm | New Algorithm | Delta |
+|---|---|---|---|
+| **Overall** | **67.8** | **93.4** | **+25.6** |
+| Single-session (user) | 94.3 | 97.1 | +2.8 |
+| Single-session (assistant) | 46.4 | 100.0 | +53.6 |
+| Single-session (preference) | 76.7 | 96.7 | +20.0 |
+| Knowledge update | 79.5 | 96.2 | +16.7 |
+| Temporal reasoning | 51.1 | 93.2 | +42.1 |
+| Multi-session | 70.7 | 86.5 | +15.8 |
+
+*Mean tokens: 6,787*
+
+The biggest gain is **single-session assistant (+53.6)** — the previous algorithm had a blind spot for agent-generated facts. The new algorithm treats them as first-class memories.
+
+The **+42.1 on temporal reasoning** reflects the ADD-only architecture preserving chronological context that the previous UPDATE/DELETE model would destroy.
+
+### BEAM
+
+[BEAM](https://github.com/mem0ai/memory-benchmarks) evaluates memory systems at 1M and 10M token scales across ten task categories. It is the only public benchmark that operates at context volumes production AI agents actually encounter.
+
+| Category | 1M | 10M |
+|---|---|---|
+| **Overall** | **64.1** | **48.6** |
+| preference_following | 88.3 | 90.4 |
+| instruction_following | 85.2 | 82.5 |
+| information_extraction | 70.0 | 56.3 |
+| knowledge_update | 65.0 | 75.0 |
+| multi_session_reasoning | 65.2 | 26.1 |
+| summarization | 63.5 | 46.9 |
+| temporal_reasoning | 61.8 | 16.3 |
+| event_ordering | 53.6 | 20.2 |
+| abstention | 52.5 | 40.0 |
+| contradiction_resolution | 35.7 | 32.5 |
+
+*Mean tokens (1M): 6,719. Mean tokens (10M): 6,914.*
+
+<Info>
+**BEAM is the most relevant benchmark here.** It operates at 1M and 10M token scales and cannot be solved by simply expanding the context window. The results at 10M reflect where memory systems actually stand at production context volumes. The system holds up well on preference following, instruction following, and knowledge updates at both scales. Weaker categories at 10M (temporal reasoning, event ordering, multi-session reasoning) are open problems across the field — they require higher-order representations of how events relate to each other across time, which is a primary focus of our ongoing research.
+</Info>
+
+### Performance Summary
+
+All results use a single-pass retrieval setup: one retrieval call, one answer, no agentic loops.
+
+| Benchmark | Old Algorithm | New Algorithm | Average tokens / query |
+|---|---|---|---|
+| **LoCoMo** | 71.4 | **91.6** | 6,956 |
+| **LongMemEval** | 67.8 | **93.4** | 6,787 |
+| **BEAM (1M)** | — | **64.1** | 6,719 |
+| **BEAM (10M)** | — | **48.6** | 6,914 |
+
+<Info>
+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.
+</Info>
+
+All benchmarks run on the same production-representative model stack. Scores carry a ±1 point confidence interval due to judge inconsistency.
+
+## Running Evaluations
+
+The full evaluation framework is [open-sourced](https://github.com/mem0ai/memory-benchmarks) so anyone can reproduce the numbers independently. It supports both Mem0 Cloud and self-hosted OSS backends.
+
+### Setup
+
+<Tabs>
+  <Tab title="Mem0 Cloud">
+    ```bash
+    git clone https://github.com/mem0ai/memory-benchmarks.git
+    cd memory-benchmarks
+    pip install -r requirements.txt
+
+    # Set your API keys
+    export MEM0_API_KEY=m0-your-key
+    export OPENAI_API_KEY=sk-your-key
+    ```
+  </Tab>
+  <Tab title="Mem0 OSS (Docker)">
+    ```bash
+    git clone https://github.com/mem0ai/memory-benchmarks.git
+    cd memory-benchmarks
+    pip install -r requirements.txt
+
+    # Copy and configure environment
+    cp .env.example .env
+    # Edit .env to add OPENAI_API_KEY
+
+    # Start local Mem0 server + Qdrant
+    docker compose up -d
+    # Mem0 server: http://localhost:8888
+    # Qdrant:      http://localhost:6333
+    ```
+  </Tab>
+</Tabs>
+
+### Running a Benchmark
+
+Each benchmark is a Python module with its own runner ([source code](https://github.com/mem0ai/memory-benchmarks/tree/main/benchmarks)). All share common CLI options:
+
+| Option | Default | Description |
+|---|---|---|
+| `--project-name` | (required) | Run identifier for tracking results |
+| `--backend` | `oss` | `oss` (self-hosted) or `cloud` (Mem0 Platform) |
+| `--mem0-api-key` | — | Mem0 API key (required for `cloud` backend) |
+| `--mem0-host` | `http://localhost:8888` | Mem0 server URL (for `oss` backend) |
+| `--top-k` | `200` | Number of memories to retrieve per query |
+| `--top-k-cutoffs` | `10,20,50,200` | Evaluate accuracy at multiple retrieval depths (BEAM default: `100`) |
+| `--answerer-model` | *(varies)* | LLM for generating answers from retrieved memories |
+| `--judge-model` | *(varies)* | LLM for judging answer correctness |
+| `--provider` | `openai` | LLM provider: `openai`, `anthropic`, `azure` |
+| `--judge-provider` | (same as `--provider`) | Override provider for the judge model |
+| `--max-workers` | `10` | Parallel workers for evaluation |
+| `--predict-only` | — | Stop after search, skip answer + judge phases |
+| `--evaluate-only` | — | Skip ingest + search, evaluate existing results |
+| `--resume` | — | Resume from checkpoint (BEAM and LongMemEval; on by default for LongMemEval) |
+
+<CodeGroup>
+```bash LoCoMo
+# ~300 questions across 10 conversations (fastest benchmark)
+python -m benchmarks.locomo.run \
+  --project-name my-eval \
+  --backend cloud \
+  --mem0-api-key $MEM0_API_KEY \
+  --top-k 200
+
+# Self-hosted
+python -m benchmarks.locomo.run \
+  --project-name my-eval \
+  --top-k 200
+```
+
+```bash LongMemEval
+# 500 questions across 6 categories
+python -m benchmarks.longmemeval.run \
+  --project-name my-eval \
+  --backend cloud \
+  --mem0-api-key $MEM0_API_KEY \
+  --all-questions \
+  --top-k 200
+
+# Self-hosted
+python -m benchmarks.longmemeval.run \
+  --project-name my-eval \
+  --all-questions \
+  --top-k 200
+```
+
+```bash BEAM
+# 1M token scale (100 conversations)
+python -m benchmarks.beam.run \
+  --project-name my-eval \
+  --backend cloud \
+  --mem0-api-key $MEM0_API_KEY \
+  --chat-sizes 1M \
+  --conversations 0-99 \
+  --top-k 200
+
+# 10M token scale
+python -m benchmarks.beam.run \
+  --project-name my-eval \
+  --backend cloud \
+  --mem0-api-key $MEM0_API_KEY \
+  --chat-sizes 10M \
+  --conversations 0-99 \
+  --top-k 200
+```
+</CodeGroup>
+
+### Custom Model Configuration
+
+To run evaluations with custom models (Azure OpenAI, Ollama, etc.), copy one of the provided configs:
+
+```bash
+# Available configs: openai.yaml, azure-openai.yaml, ollama.yaml
+cp configs/azure-openai.yaml mem0-config.yaml
+# Edit mem0-config.yaml with your model details
+
+# Uncomment the volume mount in docker-compose.yml, then restart:
+docker compose down && docker compose up -d
+```
+
+### Viewing Results
+
+Results are saved to `results/[benchmark]/` and can be explored through the built-in web UI:
+
+```bash
+npm install
+npm run dev -- -p 3001
+# Open http://localhost:3001
+```
+
+The UI lets you browse per-question results, inspect retrieval details, and compare multiple runs.
+
+### Result Format
+
+Each evaluated question produces a structured result:
+
+```json
+{
+  "id": "locomo_q_001",
+  "group": "temporal",
+  "question": "When did the user first mention moving?",
+  "ground_truth": "During the March 3rd conversation",
+  "retrieval": {
+    "search_query": "when did user mention moving",
+    "search_results": ["..."],
+    "search_latency_ms": 123.4,
+    "total_results": 42
+  },
+  "generation": {
+    "generated_answer": "The user first mentioned moving on March 3rd",
+    "model": "<answerer-model>",
+    "prompt_tokens": 500,
+    "completion_tokens": 100
+  },
+  "judgment": {
+    "judgment": "CORRECT",
+    "score": 0.85,
+    "reason": "Answer correctly identifies the date",
+    "model": "<judge-model>"
+  },
+  "cutoff_results": {
+    "top_10": { "score": 0.75, "judgment": "CORRECT" },
+    "top_50": { "score": 0.85, "judgment": "CORRECT" },
+    "top_200": { "score": 0.90, "judgment": "CORRECT" }
+  }
+}
+```
+
+## Interpreting Results
+
+When evaluating memory systems, keep these considerations in mind:
+
+- **Saturating a small benchmark is not the same as building a memory system that works at scale.** Small benchmarks can be brute-forced with aggressive retrieval and frontier models.
+- **Token efficiency matters as much as accuracy.** A system that scores 95% using 25K tokens per query isn't comparable to one scoring 90% using 7K tokens. Report mean tokens per query alongside scores.
+- **Compare at equal constraints.** Always compare systems using the same retrieval budget, the same model, and the same latency budget. A frontier model at maximum recall is not comparable to a smaller production-grade model at production-realistic retrieval depth.
+- **Watch for score ceiling effects.** Categories like "single-session user" are already near-saturated (97%+). Improvements in these categories are less meaningful than gains in harder categories like temporal reasoning or multi-session.
+- **BEAM at 10M is the real test.** Any system can look good at small scale. The 10M-token BEAM benchmark reveals whether the retrieval system actually scales.
+
+## FAQ
+
+<AccordionGroup>
+  <Accordion title="What judge model is used for evaluation?">
+    The judge model is configurable via `--judge-model` and `--judge-provider` flags. See the [evaluation repository](https://github.com/mem0ai/memory-benchmarks) for the current defaults. Scores carry a ±1 point confidence interval due to judge inconsistency.
+  </Accordion>
+  <Accordion title="Can I evaluate with a different extraction model?">
+    Yes. For self-hosted, configure the extraction model in your `mem0-config.yaml` (see the `configs/` directory of the evaluation repo for provider-specific examples). For Mem0 Cloud, extraction uses the platform's default. Using a frontier model will likely produce higher scores but at higher cost and latency.
+  </Accordion>
+  <Accordion title="Why are BEAM scores lower than LoCoMo/LongMemEval?">
+    BEAM operates at 1M and 10M token scales — orders of magnitude larger than LoCoMo or LongMemEval. At these scales, similar content appears multiple times across the window, and the memory system must surface the exact correct memory over many close matches. The scores reflect the genuine difficulty of the task, not a regression in the algorithm.
+  </Accordion>
+  <Accordion title="How do I contribute a new benchmark?">
+    Open a pull request to the [memory-benchmarks repository](https://github.com/mem0ai/memory-benchmarks) with your benchmark implementation. See the repository README for the expected interface and format.
+  </Accordion>
+</AccordionGroup>
+
+## Resources
+
+<CardGroup cols={2}>
+  <Card title="Evaluation Repository" icon="github" href="https://github.com/mem0ai/memory-benchmarks">
+    Open-source evaluation framework for reproducing all benchmark results
+  </Card>
+  <Card title="Research" icon="flask" href="https://mem0.ai/research">
+    Published research papers and technical reports
+  </Card>
+  <Card title="Blog Post" icon="newspaper" href="https://mem0.ai/blog/new-algorithm">
+    Detailed writeup of the new algorithm design and results
+  </Card>
+  <Card title="Platform Migration" icon="arrow-right" href="/migration/platform-v2-to-v3">
+    Guide for migrating your Platform integration
+  </Card>
+</CardGroup>

docs/core-concepts/memory-operations/search.mdx

@@ -56,7 +56,7 @@ Search converts your natural language question into a vector embedding, then fin
 client.search("What are Alice's hobbies?", filters={"user_id": "alice"})
 
 # OSS
-m.search("What are Alice's hobbies?", user_id="alice")
+m.search("What are Alice's hobbies?", filters={"user_id": "alice"})
 ```
 
 <Tip>
@@ -74,7 +74,7 @@ m.search("What are Alice's hobbies?", user_id="alice")
 
 | Capability | Mem0 Platform | Mem0 OSS |
 | --- | --- | --- |
-| **user_id usage** | In `filters={"user_id": "alice"}` for search/get_all | As parameter `user_id="alice"` for all operations |
+| **Entity IDs on search / get_all** | Inside `filters={"user_id": "alice"}` | Inside `filters={"user_id": "alice"}` (aligned with Platform in v3 — top-level kwargs raise `ValueError`) |
 | **Filter syntax** | Logical operators (`AND`, `OR`, comparisons) with field-level access | Basic field filters, extend via Python hooks |
 | **Reranking** | Toggle `rerank=True` with managed reranker catalog | Requires configuring local or third-party rerankers |
 | **Thresholds** | Request-level configuration (`threshold`, `top_k`) | Controlled via SDK parameters |
@@ -125,14 +125,13 @@ from mem0 import Memory
 
 m = Memory()
 
-# Simple search
-related_memories = m.search("Should I drink coffee or tea?", user_id="alice")
+# Simple search — entity IDs go in `filters`
+related_memories = m.search("Should I drink coffee or tea?", filters={"user_id": "alice"})
 
-# Search with filters
+# Search with additional metadata filters (combine entity + metadata in the same dict)
 memories = m.search(
     "food preferences",
-    user_id="alice",
-    filters={"categories": {"contains": "diet"}}
+    filters={"user_id": "alice", "categories": {"contains": "diet"}},
 )
 ```
 
@@ -141,13 +140,14 @@ import { Memory } from 'mem0ai/oss';
 
 const memory = new Memory();
 
-// Simple search
-const relatedMemories = memory.search("Should I drink coffee or tea?", { userId: "alice" });
+// Simple search — entity IDs go inside `filters`
+const relatedMemories = memory.search("Should I drink coffee or tea?", {
+    filters: { userId: "alice" },
+});
 
-// Search with filters (if supported)
+// Combine entity + metadata filters in the same filters object
 const memories = memory.search("food preferences", {
-    userId: "alice",
-    filters: { categories: { contains: "diet" } }
+    filters: { userId: "alice", categories: { contains: "diet" } },
 });
 ```
 </CodeGroup>
@@ -176,8 +176,12 @@ client.search("query", filters={
 
 *OSS:*
 ```python
-# Get memories from a specific agent session
-m.search("query", user_id="alice", agent_id="chatbot", run_id="session-123")
+# Get memories from a specific agent session — entity IDs combined in filters
+m.search("query", filters={
+    "user_id": "alice",
+    "agent_id": "chatbot",
+    "run_id": "session-123",
+})
 ```
 
 **Filter by Date Range:**

docs/docs.json

@@ -55,7 +55,8 @@
                       "core-concepts/memory-operations/add",
                       "core-concepts/memory-operations/search",
                       "core-concepts/memory-operations/update",
-                      "core-concepts/memory-operations/delete"
+                      "core-concepts/memory-operations/delete",
+                      "core-concepts/memory-evaluation"
                     ]
                   },
                   {
@@ -78,7 +79,6 @@
                         "group": "Advanced Features",
                         "icon": "bolt",
                         "pages": [
-                          "platform/features/graph-threshold",
                           "platform/features/advanced-retrieval",
                           "platform/advanced-memory-operations",
                           "platform/features/criteria-retrieval",
@@ -118,6 +118,7 @@
                     "group": "Migration Guide",
                     "icon": "arrow-right",
                     "pages": [
+                      "migration/platform-v2-to-v3",
                       "migration/oss-to-platform",
                       "migration/api-changes"
                     ]
@@ -162,13 +163,11 @@
                     "icon": "server",
                     "pages": [
                       "open-source/features/overview",
-                      "open-source/features/graph-memory",
                       "open-source/features/metadata-filtering",
                       "open-source/features/reranker-search",
                       "open-source/features/async-memory",
                       "open-source/features/multimodal-support",
                       "open-source/features/custom-instructions",
-                      "open-source/features/custom-update-memory-prompt",
                       "open-source/features/rest-api",
                       "open-source/features/openai_compatibility"
                     ]
@@ -295,6 +294,13 @@
                       }
                     ]
                   },
+                  {
+                    "group": "Migration",
+                    "icon": "arrow-right",
+                    "pages": [
+                      "migration/oss-v2-to-v3"
+                    ]
+                  },
                   {
                     "group": "Community & Support",
                     "icon": "users",
@@ -322,10 +328,8 @@
                       "cookbooks/essentials/building-ai-companion",
                       "cookbooks/essentials/entity-partitioning-playbook",
                       "cookbooks/essentials/controlling-memory-ingestion",
-                      "cookbooks/essentials/memory-expiration-short-and-long-term",
                       "cookbooks/essentials/tagging-and-organizing-memories",
-                      "cookbooks/essentials/exporting-memories",
-                      "cookbooks/essentials/choosing-memory-architecture-vector-vs-graph"
+                      "cookbooks/essentials/exporting-memories"
                     ]
                   },
                   {
@@ -361,7 +365,6 @@
                       "cookbooks/integrations/mastra-agent",
                       "cookbooks/integrations/healthcare-google-adk",
                       "cookbooks/integrations/aws-bedrock",
-                      "cookbooks/integrations/neptune-analytics",
                       "cookbooks/integrations/tavily-search"
                     ]
                   },
@@ -373,9 +376,7 @@
                       "cookbooks/frameworks/llamaindex-multiagent",
                       "cookbooks/frameworks/multimodal-retrieval",
                       "cookbooks/frameworks/eliza-os-character",
-                      "cookbooks/frameworks/chrome-extension",
-                      "cookbooks/frameworks/gemini-3-with-mem0-mcp",
-                      "cookbooks/frameworks/mirofish-swarm-memory"
+                      "cookbooks/frameworks/gemini-3-with-mem0-mcp"
                     ]
                   }
                 ]
@@ -398,8 +399,6 @@
                       "integrations/langgraph",
                       "integrations/llama-index",
                       "integrations/crewai",
-                      "integrations/autogen",
-                      "integrations/agno",
                       "integrations/camel-ai",
                       "integrations/openai-agents-sdk",
                       "integrations/google-ai-adk",
@@ -428,12 +427,7 @@
                     "group": "Developer Tools",
                     "icon": "wrench",
                     "pages": [
-                      "integrations/dify",
-                      "integrations/flowise",
-                      "integrations/langchain-tools",
-                      "integrations/agentops",
-                      "integrations/keywords",
-                      "integrations/raycast"
+                      "integrations/langchain-tools"
                     ]
                   }
                 ]
@@ -624,6 +618,10 @@
       "source": "/platform/features/expiration-date",
       "destination": "/"
     },
+    {
+      "source": "/cookbooks/essentials/memory-expiration-short-and-long-term",
+      "destination": "/cookbooks/essentials/building-ai-companion"
+    },
     {
       "source": "/platform/features/async-mode-default-change",
       "destination": "/"
@@ -634,7 +632,11 @@
     },
     {
       "source": "/platform/features/graph-memory",
-      "destination": "/open-source/features/graph-memory"
+      "destination": "/migration/oss-v2-to-v3"
+    },
+    {
+      "source": "/cookbooks/essentials/choosing-memory-architecture-vector-vs-graph",
+      "destination": "/migration/oss-v2-to-v3"
     },
     {
       "source": "/changelog",
@@ -734,11 +736,23 @@
     },
     {
       "source": "/examples/aws_neptune_analytics_hybrid_store",
-      "destination": "/cookbooks/integrations/neptune-analytics"
+      "destination": "/migration/oss-v2-to-v3"
     },
     {
       "source": "/examples/aws_neptune_analytics_hybrid_st",
-      "destination": "/cookbooks/integrations/neptune-analytics"
+      "destination": "/migration/oss-v2-to-v3"
+    },
+    {
+      "source": "/cookbooks/integrations/neptune-analytics",
+      "destination": "/migration/oss-v2-to-v3"
+    },
+    {
+      "source": "/platform/features/graph-threshold",
+      "destination": "/migration/platform-v2-to-v3"
+    },
+    {
+      "source": "/open-source/features/custom-update-memory-prompt",
+      "destination": "/open-source/features/custom-instructions"
     },
     {
       "source": "/examples/personalized-search-tavily-mem0",
@@ -798,7 +812,11 @@
     },
     {
       "source": "/examples/chrome-extension",
-      "destination": "/cookbooks/frameworks/chrome-extension"
+      "destination": "/cookbooks/overview"
+    },
+    {
+      "source": "/cookbooks/frameworks/chrome-extension",
+      "destination": "/cookbooks/overview"
     },
     {
       "source": "/examples",
@@ -806,11 +824,11 @@
     },
     {
       "source": "/open-source/graph_memory/overview",
-      "destination": "/open-source/features/graph-memory"
+      "destination": "/migration/oss-v2-to-v3"
     },
     {
       "source": "/open-source/graph_memory/features",
-      "destination": "/open-source/features/graph-memory"
+      "destination": "/migration/oss-v2-to-v3"
     },
     {
       "source": "/v0x/examples/ai_companion_js",
@@ -838,7 +856,7 @@
     },
     {
       "source": "/v0x/examples/chrome-extension",
-      "destination": "/cookbooks/frameworks/chrome-extension"
+      "destination": "/cookbooks/overview"
     },
     {
       "source": "/v0x/examples/youtube-assistant",
@@ -906,7 +924,7 @@
     },
     {
       "source": "/v0x/examples/aws_neptune_analytics_hybrid_store",
-      "destination": "/cookbooks/integrations/neptune-analytics"
+      "destination": "/migration/oss-v2-to-v3"
     },
     {
       "source": "/features/memory-export",
@@ -990,7 +1008,7 @@
     },
     {
       "source": "/features/graph-memory",
-      "destination": "/open-source/features/graph-memory"
+      "destination": "/migration/oss-v2-to-v3"
     },
     {
       "source": "/features/:slug",
@@ -1076,6 +1094,34 @@
       "source": "/v0x/faqs",
       "destination": "/platform/faqs"
     },
+    {
+      "source": "/integrations/raycast",
+      "destination": "/integrations"
+    },
+    {
+      "source": "/integrations/autogen",
+      "destination": "/integrations"
+    },
+    {
+      "source": "/integrations/keywords",
+      "destination": "/integrations"
+    },
+    {
+      "source": "/integrations/agentops",
+      "destination": "/integrations"
+    },
+    {
+      "source": "/integrations/flowise",
+      "destination": "/integrations"
+    },
+    {
+      "source": "/integrations/agno",
+      "destination": "/integrations"
+    },
+    {
+      "source": "/integrations/dify",
+      "destination": "/integrations"
+    },
     {
       "source": "/integrations/multion",
       "destination": "/integrations"
@@ -1098,7 +1144,7 @@
     },
     {
       "source": "/open-source/graph-memory",
-      "destination": "/open-source/features/graph-memory"
+      "destination": "/migration/oss-v2-to-v3"
     },
     {
       "source": "/cookbooks/customer-support-agent",

docs/integrations.mdx

@@ -20,23 +20,6 @@ Here are the available integrations for Mem0:
 ## Integrations
 
 <CardGroup cols={2}>
-  <Card
-    title="AgentOps"
-    icon={
-      <svg
-        xmlns="http://www.w3.org/2000/svg"
-        width="25"
-        height="26"
-        viewBox="0 0 30 36"
-        fill="none"
-      >
-      <path d="M10.4659 6.47277C10.45 6.37428 10.4381 6.27986 10.4303 6.18101L10.4285 6.16388C10.4212 6.09482 10.414 6.02566 10.4106 5.95626L1.18538 21.8752C0.505422 23.0493 0.323356 24.4208 0.675227 25.7289C0.849119 26.3869 1.14971 26.9859 1.55323 27.5098C1.95675 28.0338 2.46282 28.4751 3.05175 28.8143C3.83464 29.2675 4.70856 29.5 5.59028 29.5C6.03318 29.5 6.4798 29.4408 6.91899 29.3226C8.23581 28.972 9.3349 28.1326 10.0152 26.9545L15.9268 16.749V16.7449L16.5001 15.7637L17.6431 13.7936L16.5001 11.8234L15.9309 10.8381L15.9268 10.8341L13.7836 7.13406C13.6651 6.933 13.5741 6.72418 13.5109 6.51165C13.2817 5.80223 13.3292 5.04172 13.6097 4.37599L13.8115 4.02535C14.3532 3.09155 15.31 2.53987 16.3184 2.47692C16.3738 2.46915 16.4251 2.46915 16.4804 2.46915C16.5421 2.46915 16.6038 2.47257 16.6654 2.47599L16.6822 2.47692C17.6906 2.53987 18.6474 3.09155 19.1892 4.02535L21.2216 7.52838L21.8146 8.55289L21.8421 8.60399L30.1024 22.8601C30.5174 23.5814 30.6281 24.4167 30.4148 25.2205C30.1975 26.0244 29.6832 26.6942 28.9598 27.1081C28.2364 27.5258 27.3977 27.6361 26.5911 27.4195C25.7844 27.2066 25.1123 26.6905 24.6968 25.9696L18.2119 14.7788L17.069 16.7449L22.9847 26.9545C23.6646 28.1326 24.7641 28.972 26.0809 29.3226C26.5197 29.4408 26.9626 29.5 27.4096 29.5C28.2914 29.5 29.1612 29.2675 29.9482 28.8143C31.1264 28.1367 31.9728 27.0411 32.3247 25.7289C32.6766 24.4208 32.4949 23.0493 31.8145 21.8752L21.1261 3.43034C20.7029 2.51617 20.0033 1.72011 19.0621 1.18027C18.5281 0.877027 17.9708 0.675975 17.3975 0.581189C17.3027 0.565268 17.2076 0.549717 17.1129 0.537868C17.0099 0.52602 16.9074 0.518244 16.8045 0.510469C16.6027 0.498621 16.3972 0.494548 16.1914 0.510469C16.0885 0.518244 15.9859 0.52639 15.883 0.537868C15.795 0.54887 15.7067 0.563384 15.6187 0.577852L15.5984 0.581189C15.0291 0.675605 14.4673 0.876657 13.9375 1.18027C12.9885 1.72789 12.2766 2.53579 11.8537 3.46181C11.7742 3.63473 11.707 3.81282 11.6471 3.99314C11.6361 4.02668 11.6269 4.06051 11.6177 4.09435C11.612 4.11503 11.6064 4.13579 11.6003 4.15642C11.5624 4.28601 11.5275 4.41634 11.4996 4.54853C11.4885 4.60231 11.4794 4.65668 11.4703 4.71111L11.4666 4.73329C11.4443 4.86399 11.4264 4.99543 11.4145 5.12762C11.4093 5.18686 11.4045 5.24573 11.4012 5.30534C11.3934 5.44567 11.3923 5.58637 11.3963 5.72744C11.3969 5.74403 11.3962 5.76062 11.3956 5.7772C11.3949 5.79616 11.3942 5.81512 11.3952 5.83407C11.3952 5.86184 11.3952 5.88924 11.3993 5.92071C11.3998 5.9291 11.4006 5.93736 11.4014 5.94564C11.402 5.95125 11.4026 5.95687 11.403 5.96255C11.4045 5.98181 11.4064 6.00106 11.4082 6.02031C11.4097 6.03577 11.4109 6.05122 11.4122 6.06674C11.4142 6.09134 11.4163 6.11621 11.419 6.14139L11.4428 6.32282C11.4506 6.38983 11.4625 6.46092 11.4744 6.52757C11.5063 6.68863 11.5468 6.84896 11.5936 7.0078C11.5944 7.0102 11.5949 7.0127 11.5955 7.0152C11.5958 7.01662 11.5961 7.01804 11.5965 7.01944C11.5967 7.02051 11.597 7.02157 11.5974 7.02261C11.6483 7.19293 11.7081 7.36177 11.7787 7.52838C11.8619 7.72943 11.9607 7.92641 12.0715 8.11932L12.3245 8.5566V8.56067L12.4984 8.85614L12.7199 9.24232H12.7239L12.728 9.25417L14.7802 12.7927V12.7968L14.7883 12.805V12.809L15.3576 13.7943L14.7883 14.7796L8.30344 25.9703C7.88431 26.6912 7.21216 27.2077 6.40921 27.4202C6.14019 27.4913 5.86338 27.5306 5.59474 27.5306C5.053 27.5306 4.51906 27.3888 4.04085 27.1089C3.31705 26.6953 2.79909 26.0251 2.58581 25.2213C2.36845 24.4174 2.47917 23.5821 2.89829 22.8609L11.1585 8.60473L11.186 8.56141V8.55734C11.1266 8.45478 11.0753 8.35629 11.024 8.25409C11.0105 8.22496 10.9969 8.19611 10.9834 8.16739C10.9458 8.08735 10.9086 8.00836 10.8739 7.92715C10.8718 7.92504 10.8708 7.92194 10.8698 7.91887C10.8688 7.91602 10.8679 7.91319 10.8661 7.91123V7.90346C10.8423 7.8483 10.8186 7.79311 10.7989 7.73795C10.7476 7.60799 10.7041 7.47803 10.6644 7.3477C10.6012 7.15479 10.5536 6.96152 10.518 6.76861C10.4942 6.67012 10.4786 6.5757 10.4667 6.47684C10.4667 6.47684 10.47 6.47684 10.4659 6.47277Z" fill="currentColor"></path>
-      </svg>
-    }
-    href="/integrations/agentops"
-  >
-    Monitor and analyze Mem0 operations with comprehensive AI agent analytics and LLM observability.
-  </Card>
   <Card
     title="Camel AI"
     href="/integrations/camel-ai"
@@ -103,27 +86,6 @@ Here are the available integrations for Mem0:
   >
     Build RAG applications with LlamaIndex and Mem0.
   </Card>
-  <Card
-    title="AutoGen"
-    icon={
-      <svg
-        xmlns="http://www.w3.org/2000/svg"
-        width="24"
-        height="24"
-        viewBox="0 0 96 85"
-        fill="none"
-      >
-        <rect width="96" height="85" rx="6" fill="#2D2D2F" />
-        <path
-          d="M32.6484 28.7109L23.3672 57H15.8906L28.5703 22.875H33.3281L32.6484 28.7109ZM40.3594 57L31.0547 28.7109L30.3047 22.875H35.1094L47.8594 57H40.3594ZM39.9375 44.2969V49.8047H21.9141V44.2969H39.9375ZM77.6484 39.1641V52.6875C77.1172 53.3281 76.2969 54.0234 75.1875 54.7734C74.0781 55.5078 72.6484 56.1406 70.8984 56.6719C69.1484 57.2031 67.0312 57.4688 64.5469 57.4688C62.3438 57.4688 60.3359 57.1094 58.5234 56.3906C56.7109 55.6562 55.1484 54.5859 53.8359 53.1797C52.5391 51.7734 51.5391 50.0547 50.8359 48.0234C50.1328 45.9766 49.7812 43.6406 49.7812 41.0156V38.8828C49.7812 36.2578 50.1172 33.9219 50.7891 31.875C51.4766 29.8281 52.4531 28.1016 53.7188 26.6953C54.9844 25.2891 56.4922 24.2188 58.2422 23.4844C59.9922 22.75 61.9375 22.3828 64.0781 22.3828C67.0469 22.3828 69.4844 22.8672 71.3906 23.8359C73.2969 24.7891 74.75 26.1172 75.75 27.8203C76.7656 29.5078 77.3906 31.4453 77.625 33.6328H70.8047C70.6328 32.4766 70.3047 31.4688 69.8203 30.6094C69.3359 29.75 68.6406 29.0781 67.7344 28.5938C66.8438 28.1094 65.6875 27.8672 64.2656 27.8672C63.0938 27.8672 62.0469 28.1094 61.125 28.5938C60.2188 29.0625 59.4531 29.7578 58.8281 30.6797C58.2031 31.6016 57.7266 32.7422 57.3984 34.1016C57.0703 35.4609 56.9062 37.0391 56.9062 38.8359V41.0156C56.9062 42.7969 57.0781 44.375 57.4219 45.75C57.7656 47.1094 58.2734 48.2578 58.9453 49.1953C59.6328 50.1172 60.4766 50.8125 61.4766 51.2812C62.4766 51.75 63.6406 51.9844 64.9688 51.9844C66.0781 51.9844 67 51.8906 67.7344 51.7031C68.4844 51.5156 69.0859 51.2891 69.5391 51.0234C70.0078 50.7422 70.3672 50.4766 70.6172 50.2266V44.1797H64.1953V39.1641H77.6484Z"
-          fill="white"
-        />
-      </svg>
-    }
-    href="/integrations/autogen"
-  >
-    Build multi-agent systems with persistent memory capabilities.
-  </Card>
   <Card
     title="CrewAI"
     icon={
@@ -205,26 +167,6 @@ Here are the available integrations for Mem0:
   >
     Use Mem0 with LangChain Tools for enhanced agent capabilities.
   </Card>
-  <Card
-    title="Dify"
-    icon={
-      <svg
-        xmlns="http://www.w3.org/2000/svg"
-        width="24"
-        height="24"
-        viewBox="0 0 200 200"
-        fill="none"
-      >
-        <path
-          d="M40 20 H120 C160 20, 160 180, 120 180 H40 V20"
-          fill="currentColor"
-        />
-      </svg>
-    }
-    href="/integrations/dify"
-  >
-    Build AI applications with persistent memory using Dify and Mem0.
-  </Card>
   <Card
     title="Livekit"
     icon={
@@ -290,63 +232,6 @@ Here are the available integrations for Mem0:
   >
     Build conversational AI agents with memory using Pipecat.
   </Card>
-  <Card
-    title="Agno"
-    icon={
-      <svg
-        xmlns="http://www.w3.org/2000/svg"
-        width="24"
-        height="24"
-        viewBox="0 0 24 24"
-        fill="none"
-      >
-        <path d="M8 4h8v12h8" stroke="currentColor" strokeWidth="2" fill="none" transform="rotate(15, 12, 12)"/>
-      </svg>
-    }
-    href="/integrations/agno"
-  >
-    Build autonomous agents with memory using Agno framework.
-  </Card>
-
-  <Card
-    title="Keywords AI"
-    icon={
-      <svg
-        xmlns="http://www.w3.org/2000/svg"
-        width="24"
-        height="24"
-        viewBox="0 0 24 24"
-        fill="none"
-      >
-        <path fill-rule="evenodd" clip-rule="evenodd" d="M9.07513 1.1863C9.21663 1.07722 9.39144 1.01009 9.56624 1.01009C9.83261 1.01009 10.0823 1.12756 10.2405 1.33734L15.0101 7.4964V12.4136L16.4335 13.8401C16.7582 14.1673 16.7582 14.7043 16.4335 15.0316C16.1089 15.3588 15.5762 15.3588 15.2515 15.0316L13.3453 13.1016V8.07538L8.92529 2.36944V2.36105C8.64228 2.00024 8.70887 1.4716 9.07513 1.1863ZM18.976 14.4133C18.8344 14.3778 18.7003 14.3042 18.5894 14.1925L16.9163 12.5059C16.7249 12.3129 16.6416 12.0528 16.6749 11.8094V6.88385H16.6499L11.8553 0.691225C11.7282 0.529117 11.6716 0.333133 11.6803 0.140562C11.134 0.0481292 10.5726 0 10 0C4.47715 0 0 4.47715 0 10C0 15.5228 4.47715 20 10 20C13.9387 20 17.3456 17.7229 18.976 14.4133Z" fill="currentColor"></path>
-      </svg>
-    }
-    href="/integrations/keywords"
-  >
-    Build AI applications with persistent memory and comprehensive LLM observability.
-  </Card>
-  <Card
-    title="Raycast"
-    icon={
-      <svg
-        xmlns="http://www.w3.org/2000/svg"
-        width="24"
-        height="24"
-        viewBox="0 0 24 24"
-        fill="none"
-      >
-        <path
-          d="M3 12L21 12M12 3L12 21M7.5 7.5L16.5 16.5M16.5 7.5L7.5 16.5"
-          stroke="currentColor"
-          strokeWidth="2"
-          strokeLinecap="round"
-        />
-      </svg>
-    }
-    href="/integrations/raycast"
-  >
-    Mem0 Raycast extension for intelligent memory management and retrieval.
-  </Card>
   <Card
     title="Mastra"
     icon={
@@ -395,13 +280,6 @@ Here are the available integrations for Mem0:
   >
     Integrate Mem0 with Google Agent Development Kit for persistent memory across multi-agent workflows.
   </Card>
-  <Card
-    title="Flowise"
-    icon="diagram-project"
-    href="/integrations/flowise"
-  >
-    Add persistent Mem0 memory to Flowise chatflows for context-aware conversations in the low-code builder.
-  </Card>
   <Card
     title="AWS Bedrock"
     icon="cloud"

docs/integrations/agentops.mdx

@@ -1,175 +0,0 @@
----
-title: AgentOps
-description: "Integrate Mem0 with AgentOps for automatic monitoring, analytics, and real-time tracking of memory operations."
----
-
-Integrate [**Mem0**](https://github.com/mem0ai/mem0) with [AgentOps](https://agentops.ai), a comprehensive monitoring and analytics platform for AI agents. This integration enables automatic tracking and analysis of memory operations, providing insights into agent performance and memory usage patterns.
-
-## Overview
-
-1. Automatic monitoring of Mem0 operations and performance metrics
-2. Real-time tracking of memory add, search, and retrieval operations
-3. Analytics dashboard with memory usage patterns and insights
-4. Error tracking and debugging capabilities for memory operations
-
-## Prerequisites
-
-Before setting up Mem0 with AgentOps, ensure you have:
-
-1. Installed the required packages:
-```bash
-pip install mem0ai agentops python-dotenv
-```
-
-2. Valid API keys:
-   - [AgentOps API Key](https://app.agentops.ai/dashboard/api-keys)
-   - OpenAI API Key (for LLM operations)
-   - <a href="https://app.mem0.ai/dashboard/api-keys" rel="nofollow">Mem0 API Key</a> (optional, for cloud operations)
-
-## Basic Integration Example
-
-The following example demonstrates how to integrate Mem0 with AgentOps monitoring for comprehensive memory operation tracking:
-
-```python
-#Import the required libraries for local memory management with Mem0
-from mem0 import Memory, AsyncMemory
-import os
-import asyncio
-import logging
-from dotenv import load_dotenv
-import agentops
-import openai
-
-load_dotenv()
-#Set up environment variables for API keys
-os.environ["AGENTOPS_API_KEY"] = os.getenv("AGENTOPS_API_KEY")
-os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
-
-#Set up the configuration for local memory storage and define sample user data. 
-local_config = {
-    "llm": {
-        "provider": "openai",
-        "config": {
-            "model": "gpt-4.1-nano-2025-04-14",
-            "temperature": 0.1,
-            "max_tokens": 2000,
-        },
-    }
-}
-user_id = "alice_demo"
-agent_id = "assistant_demo"
-run_id = "session_001"
-
-sample_messages = [
-    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller? They can be quite engaging."},
-    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
-    {
-        "role": "assistant",
-        "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future.",
-    },
-]
-
-sample_preferences = [
-    "I prefer dark roast coffee over light roast",
-    "I exercise every morning at 6 AM",
-    "I'm vegetarian and avoid all meat products",
-    "I love reading science fiction novels",
-    "I work in software engineering",
-]
-
-#This function demonstrates sequential memory operations using the synchronous Memory class
-def demonstrate_sync_memory(local_config, sample_messages, sample_preferences, user_id):
-    """
-    Demonstrate synchronous Memory class operations.
-    """
-
-    agentops.start_trace("mem0_memory_example", tags=["mem0_memory_example"])
-    try:
-        
-        memory = Memory.from_config(local_config)
-
-        result = memory.add(
-            sample_messages, user_id=user_id, metadata={"category": "movie_preferences", "session": "demo"}
-        )
-
-        for i, preference in enumerate(sample_preferences):
-            result = memory.add(preference, user_id=user_id, metadata={"type": "preference", "index": i})
-       
-        search_queries = [
-            "What movies does the user like?",
-            "What are the user's food preferences?",
-            "When does the user exercise?",
-        ]
-
-        for query in search_queries:
-            results = memory.search(query, user_id=user_id)
-        
-            if results and "results" in results:
-                for j, result in enumerate(results['results']): 
-                    print(f"Result {j+1}: {result.get('memory', 'N/A')}")
-            else:
-                print("No results found")
-
-        all_memories = memory.get_all(user_id=user_id)
-        if all_memories and "results" in all_memories:
-            print(f"Total memories: {len(all_memories['results'])}")
-
-        delete_all_result = memory.delete_all(user_id=user_id)
-        print(f"Delete all result: {delete_all_result}")
-
-        agentops.end_trace(end_state="success")
-    except Exception as e:
-        agentops.end_trace(end_state="error")
-
-# Execute sync demonstrations
-demonstrate_sync_memory(local_config, sample_messages, sample_preferences, user_id)
-
-```
-
-For detailed information on this integration, refer to the official [Agentops Mem0 integration documentation](https://docs.agentops.ai/v2/integrations/mem0).
-
-
-## Key Features
-
-### 1. Automatic Operation Tracking
-
-AgentOps automatically monitors all Mem0 operations:
-
-- **Memory Operations**: Track add, search, get_all, delete operations and much more
-- **Performance Metrics**: Monitor response times and success rates
-- **Error Tracking**: Capture and analyze operation failures
-
-### 2. Real-time Analytics Dashboard
-
-Access comprehensive analytics through the AgentOps dashboard:
-
-- **Usage Patterns**: Visualize memory usage trends over time
-- **User Behavior**: Analyze how different users interact with memory
-- **Performance Insights**: Identify bottlenecks and optimization opportunities
-
-### 3. Session Management
-
-Organize your monitoring with structured sessions:
-
-- **Session Tracking**: Group related operations into logical sessions
-- **Success/Failure Rates**: Track session outcomes for reliability monitoring
-- **Custom Metadata**: Add context to sessions for better analysis
-
-## Best Practices
-
-1. **Initialize Early**: Always initialize AgentOps before importing Mem0 classes
-2. **Session Management**: Use meaningful session names and end sessions appropriately
-3. **Error Handling**: Wrap operations in try-catch blocks and report failures
-4. **Tagging**: Use tags to organize different types of memory operations
-5. **Environment Separation**: Use different projects or tags for dev/staging/prod
-
-<CardGroup cols={2}>
-  <Card title="CrewAI Integration" icon="users" href="/integrations/crewai">
-    Monitor multi-agent CrewAI systems
-  </Card>
-  <Card title="LangChain Integration" icon="link" href="/integrations/langchain">
-    Track LangChain agent performance
-  </Card>
-</CardGroup>
-

docs/integrations/agno.mdx

@@ -1,207 +0,0 @@
----
-title: Agno
-description: "Add persistent multimodal memory to Agno-based agents using Mem0 for text and image interactions."
----
-
-This integration of [**Mem0**](https://github.com/mem0ai/mem0) with [Agno](https://github.com/agno-agi/agno) enables persistent, multimodal memory for Agno-based agents - improving personalization, context awareness, and continuity across conversations.
-
-## Overview
-
-1. Store and retrieve memories from Mem0 within Agno agents
-2. Support for multimodal interactions (text and images)
-3. Semantic search for relevant past conversations
-4. Personalized responses based on user history
-5. One-line memory integration via `Mem0Tools`
-
-## Prerequisites
-
-Before setting up Mem0 with Agno, ensure you have:
-
-1. Installed the required packages:
-```bash
-pip install agno mem0ai python-dotenv
-```
-
-2. Valid API keys:
-   - <a href="https://app.mem0.ai/dashboard/api-keys" rel="nofollow">Mem0 API Key</a>
-   - OpenAI API Key (for the agent model)
-
-## Quick Integration (Using `Mem0Tools`)
-
-The simplest way to integrate Mem0 with Agno Agents is to use Mem0 as a tool using built-in `Mem0Tools`:
-
-```python
-from agno.agent import Agent
-from agno.models.openai import OpenAIChat
-from agno.tools.mem0 import Mem0Tools
-
-agent = Agent(
-    name="Memory Agent",
-    model=OpenAIChat(id="gpt-4.1-nano-2025-04-14"),
-    tools=[Mem0Tools()],
-    description="An assistant that remembers and personalizes using Mem0 memory."
-)
-```
-
-This enables memory functionality out of the box:
-
-- **Persistent memory writing**: `Mem0Tools` uses `MemoryClient.add(...)` to store messages from user-agent interactions, including optional metadata such as user ID or session.
-- **Contextual memory search**: Compatible queries use `MemoryClient.search(...)` to retrieve relevant past messages, improving contextual understanding.
-- **Multimodal support**: Both text and image inputs are supported, allowing richer memory records.
-
-> `Mem0Tools` uses the `MemoryClient` under the hood and requires no additional setup. You can customize its behavior by modifying your tools list or extending it in code.
-
-## Full Manual Example
-
-> Note: Mem0 can also be used with Agno Agents as a separate memory layer.
-
-The following example demonstrates how to create an Agno agent with Mem0 memory integration, including support for image processing:
-
-```python
-import base64
-from pathlib import Path
-from typing import Optional
-
-from agno.agent import Agent
-from agno.media import Image
-from agno.models.openai import OpenAIChat
-from mem0 import MemoryClient
-
-# Initialize the Mem0 client
-client = MemoryClient()
-
-# Define the agent
-agent = Agent(
-    name="Personal Agent",
-    model=OpenAIChat(id="gpt-4"),
-    description="You are a helpful personal agent that helps me with day to day activities."
-                "You can process both text and images.",
-    markdown=True
-)
-
-
-def chat_user(
-    user_input: Optional[str] = None,
-    user_id: str = "alex",
-    image_path: Optional[str] = None
-) -> str:
-    """
-    Handle user input with memory integration, supporting both text and images.
-
-    Args:
-        user_input: The user's text input
-        user_id: Unique identifier for the user
-        image_path: Path to an image file if provided
-
-    Returns:
-        The agent's response as a string
-    """
-    if image_path:
-        # Convert image to base64
-        with open(image_path, "rb") as image_file:
-            base64_image = base64.b64encode(image_file.read()).decode("utf-8")
-
-        # Create message objects for text and image
-        messages = []
-
-        if user_input:
-            messages.append({
-                "role": "user",
-                "content": user_input
-            })
-
-        messages.append({
-            "role": "user",
-            "content": {
-                "type": "image_url",
-                "image_url": {
-                    "url": f"data:image/jpeg;base64,{base64_image}"
-                }
-            }
-        })
-
-        # Store messages in memory
-        client.add(messages, user_id=user_id)
-        print("✅ Image and text stored in memory.")
-
-    if user_input:
-        # Search for relevant memories
-        memories = client.search(user_input, user_id=user_id)
-        memory_context = "\n".join(f"- {m['memory']}" for m in memories['results'])
-
-        # Construct the prompt
-        prompt = f"""
-You are a helpful personal assistant who helps users with their day-to-day activities and keeps track of everything.
-
-Your task is to:
-1. Analyze the given image (if present) and extract meaningful details to answer the user's question.
-2. Use your past memory of the user to personalize your answer.
-3. Combine the image content and memory to generate a helpful, context-aware response.
-
-Here is what I remember about the user:
-{memory_context}
-
-User question:
-{user_input}
-"""
-        # Get response from agent
-        if image_path:
-            response = agent.run(prompt, images=[Image(filepath=Path(image_path))])
-        else:
-            response = agent.run(prompt)
-
-        # Store the interaction in memory
-        interaction_message = [{"role": "user", "content": f"User: {user_input}\nAssistant: {response.content}"}]
-        client.add(interaction_message, user_id=user_id)
-        return response.content
-
-    return "No user input or image provided."
-
-
-# Example Usage
-if __name__ == "__main__":
-    response = chat_user(
-        "I like to travel and my favorite destination is London",
-        image_path="travel_items.jpeg",
-        user_id="alex"
-    )
-    print(response)
-```
-
-## Key Features
-
-### 1. Multimodal Memory Storage
-
-The integration supports storing both text and image data:
-
-- **Text Storage**: Conversation history is saved in a structured format
-- **Image Analysis**: Agents can analyze images and store visual information
-- **Combined Context**: Memory retrieval combines both text and visual data
-
-### 2. Personalized Agent Responses
-
-Improve your agent's context awareness:
-
-- **Memory Retrieval**: Semantic search finds relevant past interactions
-- **User Preferences**: Personalize responses based on stored user information
-- **Continuity**: Maintain conversation threads across multiple sessions
-
-### 3. Flexible Configuration
-
-Customize the integration to your needs:
-
-- **Use `Mem0Tools()`** for drop-in memory support
-- **Use `MemoryClient` directly** for advanced control
-- **User Identification**: Organize memories by user ID
-- **Memory Search**: Configure search relevance and result count
-- **Memory Formatting**: Support for various OpenAI message formats
-
-<CardGroup cols={2}>
-  <Card title="OpenAI Agents SDK" icon="cube" href="/integrations/openai-agents-sdk">
-    Build agents with OpenAI SDK and Mem0
-  </Card>
-  <Card title="Mastra Integration" icon="star" href="/integrations/mastra">
-    Create intelligent agents with Mastra framework
-  </Card>
-</CardGroup>
-

docs/integrations/autogen.mdx

@@ -1,142 +0,0 @@
----
-title: AutoGen
-description: "Build conversational AI agents with AutoGen and Mem0 for context-aware, personalized interactions."
----
-
-Build conversational AI agents with memory capabilities. This integration combines AutoGen for creating AI agents with Mem0 for memory management, enabling context-aware and personalized interactions.
-
-## Overview
-
-This guide demonstrates creating a conversational AI system with memory. We'll build a customer service bot that can recall previous interactions and provide personalized responses.
-
-## Setup and Configuration
-
-Install necessary libraries:
-
-```bash
-pip install autogen mem0ai openai python-dotenv
-```
-
-First, we'll import the necessary libraries and set up our configurations.
-
-<Note>Remember to get the Mem0 API key from <a href="https://app.mem0.ai" rel="nofollow">Mem0 Platform</a>.</Note>
-
-```python
-import os
-from autogen import ConversableAgent
-from mem0 import MemoryClient
-from openai import OpenAI
-from dotenv import load_dotenv
-
-load_dotenv()
-
-# Configuration
-# OPENAI_API_KEY = 'sk-xxx'  # Replace with your actual OpenAI API key
-# MEM0_API_KEY = 'your-mem0-key'  # Replace with your actual Mem0 API key from https://app.mem0.ai
-USER_ID = "alice"
-
-# Set up OpenAI API key
-OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY')
-# os.environ['MEM0_API_KEY'] = MEM0_API_KEY
-
-# Initialize Mem0 and AutoGen agents
-memory_client = MemoryClient()
-agent = ConversableAgent(
-    "chatbot",
-    llm_config={"config_list": [{"model": "gpt-4", "api_key": OPENAI_API_KEY}]},
-    code_execution_config=False,
-    human_input_mode="NEVER",
-)
-```
-
-## Storing Conversations in Memory
-
-Add conversation history to Mem0 for future reference:
-
-```python
-conversation = [
-    {"role": "assistant", "content": "Hi, I'm Best Buy's chatbot! How can I help you?"},
-    {"role": "user", "content": "I'm seeing horizontal lines on my TV."},
-    {"role": "assistant", "content": "I'm sorry to hear that. Can you provide your TV model?"},
-    {"role": "user", "content": "It's a Sony - 77\" Class BRAVIA XR A80K OLED 4K UHD Smart Google TV"},
-    {"role": "assistant", "content": "Thank you for the information. Let's troubleshoot this issue..."}
-]
-
-memory_client.add(messages=conversation, user_id=USER_ID)
-print("Conversation added to memory.")
-```
-
-## Retrieving and Using Memory
-
-Create a function to get context-aware responses based on user's question and previous interactions:
-
-```python
-def get_context_aware_response(question):
-    relevant_memories = memory_client.search(question, user_id=USER_ID)
-    context = "\n".join([m["memory"] for m in relevant_memories.get('results', [])])
-
-    prompt = f"""Answer the user question considering the previous interactions:
-    Previous interactions:
-    {context}
-
-    Question: {question}
-    """
-
-    reply = agent.generate_reply(messages=[{"content": prompt, "role": "user"}])
-    return reply
-
-# Example usage
-question = "What was the issue with my TV?"
-answer = get_context_aware_response(question)
-print("Context-aware answer:", answer)
-```
-
-## Multi-Agent Conversation
-
-For more complex scenarios, you can create multiple agents:
-
-```python
-manager = ConversableAgent(
-    "manager",
-    system_message="You are a manager who helps in resolving complex customer issues.",
-    llm_config={"config_list": [{"model": "gpt-4", "api_key": OPENAI_API_KEY}]},
-    human_input_mode="NEVER"
-)
-
-def escalate_to_manager(question):
-    relevant_memories = memory_client.search(question, user_id=USER_ID)
-    context = "\n".join([m["memory"] for m in relevant_memories.get('results', [])])
-
-    prompt = f"""
-    Context from previous interactions:
-    {context}
-
-    Customer question: {question}
-
-    As a manager, how would you address this issue?
-    """
-
-    manager_response = manager.generate_reply(messages=[{"content": prompt, "role": "user"}])
-    return manager_response
-
-# Example usage
-complex_question = "I'm not satisfied with the troubleshooting steps. What else can be done?"
-manager_answer = escalate_to_manager(complex_question)
-print("Manager's response:", manager_answer)
-```
-
-## Conclusion
-
-By integrating AutoGen with Mem0, you've created a conversational AI system with memory capabilities. This example demonstrates a customer service bot that can recall previous interactions and provide context-aware responses, with the ability to escalate complex issues to a manager agent.
-
-This integration enables the creation of more intelligent and personalized AI agents for various applications, such as customer support, virtual assistants, and interactive chatbots.
-
-<CardGroup cols={2}>
-  <Card title="CrewAI Integration" icon="users" href="/integrations/crewai">
-    Build multi-agent systems with CrewAI and Mem0
-  </Card>
-  <Card title="LangGraph Integration" icon="diagram-project" href="/integrations/langgraph">
-    Create stateful workflows with LangGraph
-  </Card>
-</CardGroup>
-

docs/integrations/aws-bedrock.mdx

@@ -49,7 +49,7 @@ Import necessary modules and configure Mem0:
 ```python
 import boto3
 from opensearchpy import OpenSearch, RequestsHttpConnection, AWSV4SignerAuth
-from mem0.memory.main import Memory
+from mem0 import Memory
 
 region = 'us-west-2'
 service = 'aoss'
@@ -107,10 +107,10 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"})
 
 # Search for memory
-relevant = m.search("What kind of movies does Alice like?", user_id="alice")
+relevant = m.search("What kind of movies does Alice like?", filters={"user_id": "alice"})
 
 # Retrieve all user memories
-all_memories = m.get_all(user_id="alice")
+all_memories = m.get_all(filters={"user_id": "alice"})
 ```
 
 ## Key Features
@@ -125,8 +125,5 @@ all_memories = m.get_all(user_id="alice")
   <Card title="AWS Bedrock Cookbook" icon="aws" href="/cookbooks/integrations/aws-bedrock">
     Complete guide to using Bedrock with Mem0
   </Card>
-  <Card title="Neptune Analytics Cookbook" icon="database" href="/cookbooks/integrations/neptune-analytics">
-    Build graph memory with AWS Neptune
-  </Card>
 </CardGroup>
 

docs/integrations/chatdev.mdx

@@ -237,7 +237,7 @@ By adding Mem0 as a memory store in ChatDev, your multi-agent workflows gain per
   <Card title="CrewAI Integration" icon="users" href="/integrations/crewai">
     Build multi-agent systems with CrewAI and Mem0
   </Card>
-  <Card title="AutoGen Integration" icon="robot" href="/integrations/autogen">
-    Build conversational agents with AutoGen and Mem0
+  <Card title="OpenAI Agents SDK" icon="robot" href="/integrations/openai-agents-sdk">
+    Build conversational agents with OpenAI Agents SDK and Mem0
   </Card>
 </CardGroup>

docs/integrations/crewai.mdx

@@ -162,8 +162,8 @@ if __name__ == "__main__":
 By combining CrewAI with Mem0, you can create sophisticated AI systems that maintain context and provide personalized experiences while leveraging the power of autonomous agents.
 
 <CardGroup cols={2}>
-  <Card title="AutoGen Integration" icon="users" href="/integrations/autogen">
-    Build multi-agent systems with AutoGen and Mem0
+  <Card title="OpenAI Agents SDK" icon="users" href="/integrations/openai-agents-sdk">
+    Build multi-agent systems with OpenAI Agents SDK and Mem0
   </Card>
   <Card title="LangGraph Integration" icon="diagram-project" href="/integrations/langgraph">
     Create stateful agent workflows with memory

docs/integrations/dify.mdx

@@ -1,42 +0,0 @@
----
-title: Dify
-description: "Integrate Mem0 as a plugin in Dify AI workflows for persistent conversation storage and retrieval."
----
-
-# Integrating Mem0 with Dify AI
-
-Mem0 brings a robust memory layer to Dify AI, empowering your AI agents with persistent conversation storage and retrieval capabilities. With Mem0, your Dify applications gain the ability to recall past interactions and maintain context, ensuring more natural and insightful conversations.
-
----
-
-## How to Integrate Mem0 in Your Dify Workflow
-
-1. **Install the Mem0 Plugin:**  
-   Head to the [Dify Marketplace](https://marketplace.dify.ai/plugins/yevanchen/mem0) and install the Mem0 plugin. This is your first step toward adding intelligent memory to your AI applications.
-
-2. **Create or Open Your Dify Project:**  
-   Whether you're starting fresh or updating an existing project, simply create or open your Dify workspace.
-
-3. **Add the Mem0 Plugin to Your Project:**  
-   Within your project, add the Mem0 plugin. This integration connects Mem0’s memory management capabilities directly to your Dify application.
-
-4. **Configure Your Mem0 Settings:**  
-   Customize Mem0 to suit your needs—set preferences for how conversation history is stored, the search parameters, and any other context-aware features.
-
-5. **Leverage Mem0 in Your Workflow:**  
-   Use Mem0 to store every conversation turn and retrieve past interactions seamlessly. This integration ensures that your AI agents can refer back to important context, making multi-turn dialogues more effective and user-centric.
-
----
-
-![Mem0 Dify Integration](/images/dify-mem0-integration.png)
-
-Enhance your Dify-powered AI with Mem0 and transform your conversational experiences. Start integrating intelligent memory management today and give your agents the context they need to excel!
-
-<CardGroup cols={2}>
-  <Card title="Flowise Integration" icon="share-nodes" href="/integrations/flowise">
-    Build visual AI workflows with Flowise
-  </Card>
-  <Card title="LangChain Integration" icon="link" href="/integrations/langchain">
-    Create LangChain-powered applications
-  </Card>
-</CardGroup>

docs/integrations/flowise.mdx

@@ -1,127 +0,0 @@
----
-title: Flowise
-description: "Add persistent Mem0 memory to Flowise chatflows for context-aware conversations in the low-code builder."
----
-
-The [**Mem0 Memory**](https://github.com/mem0ai/mem0) integration with [Flowise](https://github.com/FlowiseAI/Flowise) enables persistent memory capabilities for your AI chatflows. [Flowise](https://flowiseai.com/) is an open-source low-code tool for developers to build customized LLM orchestration flows & AI agents using a drag & drop interface.
-
-## Overview
-
-1. Provides persistent memory storage for Flowise chatflows
-2. Seamless integration with existing Flowise templates
-3. Compatible with various LLM nodes in Flowise
-4. Supports custom memory configurations
-5. Easy to set up and manage
-
-## Prerequisites
-
-Before setting up Mem0 with Flowise, ensure you have:
-
-1. [Flowise installed](https://github.com/FlowiseAI/Flowise#⚡quick-start) (NodeJS >= 18.15.0 required):
-```bash
-npm install -g flowise
-npx flowise start
-```
-
-2. Access to the Flowise UI at http://localhost:3000
-3. Basic familiarity with [Flowise's LLM orchestration](https://flowiseai.com/#features) concepts
-
-## Setup and Configuration
-
-### 1. Set Up Flowise
-
-1. Open the Flowise application and create a new canvas, or select a template from the Flowise marketplace.
-2. In this example, we use the **Conversation Chain** template.
-3. Replace the default **Buffer Memory** with **Mem0 Memory**.
-
-![Flowise Memory Integration](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/flowise-flow.png)
-
-### 2. Obtain Your Mem0 API Key
-
-1. Navigate to the <a href="https://app.mem0.ai/dashboard/api-keys" rel="nofollow">Mem0 API Key dashboard</a>.
-2. Generate or copy your existing Mem0 API Key.
-
-![Mem0 API Key](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/api-key.png)
-
-### 3. Configure Mem0 Credentials
-
-1. Enter the **Mem0 API Key** in the Mem0 Credentials section.
-2. Configure additional settings as needed:
-
-```typescript
-{
-  "apiKey": "m0-xxx",
-  "userId": "user-123",  // Optional: Specify user ID
-  "projectId": "proj-xxx",  // Optional: Specify project ID
-  "orgId": "org-xxx"  // Optional: Specify organization ID
-}
-```
-
-<figure>
-  <img src="https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/creds.png" alt="Mem0 Credentials" />
-  <figcaption>Configure API Credentials</figcaption>
-</figure>
-
-## Memory Features
-
-### 1. Basic Memory Storage
-
-Test your memory configuration:
-
-1. Save your Flowise configuration
-2. Run a test chat and store some information
-3. Verify the stored memories in the <a href="https://app.mem0.ai/dashboard/requests" rel="nofollow">Mem0 Dashboard</a>
-
-![Flowise Test Chat](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/flowise-chat-1.png)
-
-### 2. Memory Retention
-
-Validate memory persistence:
-
-1. Clear the chat history in Flowise
-2. Ask a question about previously stored information
-3. Confirm that the AI remembers the context
-
-![Testing Memory Retention](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/flowise-chat-2.png)
-
-## Advanced Configuration
-
-### Memory Settings
-
-![Mem0 Settings](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/settings.png)
-
-Available settings include:
-
-1. **Search Only Mode**: Enable memory retrieval without creating new memories
-2. **Mem0 Entities**: Configure identifiers:
-   - `user_id`: Unique identifier for each user
-   - `run_id`: Specific conversation session ID
-   - `app_id`: Application identifier
-   - `agent_id`: AI agent identifier
-3. **Project ID**: Assign memories to specific projects
-4. **Organization ID**: Organize memories by organization
-
-### Platform Configuration
-
-Additional settings available in <a href="https://app.mem0.ai/dashboard/project-settings" rel="nofollow">Mem0 Project Settings</a>:
-
-1. **Custom Instructions**: Define memory extraction rules
-2. **Expiration Date**: Set automatic memory cleanup periods
-
-![Mem0 Project Settings](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/mem0-settings.png)
-
-## Best Practices
-
-1. **User Identification**: Use consistent `user_id` values for reliable memory retrieval
-2. **Memory Organization**: Utilize projects and organizations for better memory management
-3. **Regular Maintenance**: Monitor and clean up unused memories periodically
-
-<CardGroup cols={2}>
-  <Card title="LangChain Integration" icon="link" href="/integrations/langchain">
-    Build LangChain-powered flows with memory
-  </Card>
-  <Card title="Dify Integration" icon="blocks" href="/integrations/dify">
-    Create AI workflows with Dify platform
-  </Card>
-</CardGroup>
-

docs/integrations/keywords.mdx

@@ -1,142 +0,0 @@
----
-title: Keywords AI
-description: "Combine Mem0 persistent memory with Keywords AI observability for tracked, cost-optimized AI applications."
----
-
-Build AI applications with persistent memory and comprehensive LLM observability by integrating Mem0 with Keywords AI.
-
-## Overview
-
-Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users. Keywords AI provides complete LLM observability.
-
-Combining Mem0 with Keywords AI allows you to:
-1. Add persistent memory to your AI applications
-2. Track interactions across sessions
-3. Monitor memory usage and retrieval with Keywords AI observability
-4. Optimize token usage and reduce costs
-
-<Note>
-You can get your Mem0 API key from the <a href="https://app.mem0.ai/" rel="nofollow">Mem0 dashboard</a>.
-</Note>
-
-## Setup and Configuration
-
-Install the necessary libraries:
-
-```bash
-pip install mem0 keywordsai-sdk
-```
-
-Set up your environment variables:
-
-```python
-import os
-
-# Set your API keys
-os.environ["MEM0_API_KEY"] = "your-mem0-api-key"
-os.environ["KEYWORDSAI_API_KEY"] = "your-keywords-api-key"
-os.environ["KEYWORDSAI_BASE_URL"] = "https://api.keywordsai.co/api/"
-```
-
-## Basic Integration Example
-
-Here's a simple example of using Mem0 with Keywords AI:
-
-```python
-from mem0 import Memory
-import os
-
-# Configuration
-api_key = os.getenv("MEM0_API_KEY")
-keywordsai_api_key = os.getenv("KEYWORDSAI_API_KEY")
-base_url = os.getenv("KEYWORDSAI_BASE_URL") # "https://api.keywordsai.co/api/"
-
-# Set up Mem0 with Keywords AI as the LLM provider
-config = {
-    "llm": {
-        "provider": "openai",
-        "config": {
-            "model": "gpt-4.1-nano-2025-04-14",
-            "temperature": 0.0,
-            "api_key": keywordsai_api_key,
-            "openai_base_url": base_url,
-        },
-    }
-}
-
-# Initialize Memory
-memory = Memory.from_config(config_dict=config)
-
-# Add a memory
-result = memory.add(
-    "I like to take long walks on weekends.",
-    user_id="alice",
-    metadata={"category": "hobbies"},
-)
-
-print(result)
-```
-
-## Advanced Integration with OpenAI SDK
-
-For more advanced use cases, you can integrate Keywords AI with Mem0 through the OpenAI SDK:
-
-```python
-from openai import OpenAI
-import os
-import json
-
-# Initialize client
-client = OpenAI(
-    api_key=os.environ.get("KEYWORDSAI_API_KEY"),
-    base_url=os.environ.get("KEYWORDSAI_BASE_URL"),
-)
-
-# Sample conversation messages
-messages = [
-    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
-    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
-    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
-]
-
-# Add memory and generate a response
-response = client.chat.completions.create(
-    model="openai/gpt-4.1-nano",
-    messages=messages,
-    extra_body={
-        "mem0_params": {
-            "user_id": "test_user",
-            "api_key": os.environ.get("MEM0_API_KEY"),
-            "add_memories": {
-                "messages": messages,
-            },
-        }
-    },
-)
-
-print(json.dumps(response.model_dump(), indent=4))
-```
-
-For detailed information on this integration, refer to the official [Keywords AI Mem0 integration documentation](https://docs.keywordsai.co/integration/development-frameworks/mem0).
-
-## Key Features
-
-1. **Memory Integration**: Store and retrieve relevant information from past interactions
-2. **LLM Observability**: Track memory usage and retrieval patterns with Keywords AI
-3. **Session Persistence**: Maintain context across multiple user sessions
-4. **Cost Optimization**: Reduce token usage through efficient memory retrieval
-
-## Conclusion
-
-Integrating Mem0 with Keywords AI provides a powerful combination for building AI applications with persistent memory and comprehensive observability. This integration enables more personalized user experiences while providing insights into your application's memory usage.
-
-<CardGroup cols={2}>
-  <Card title="OpenAI Agents SDK" icon="cube" href="/integrations/openai-agents-sdk">
-    Build monitored agents with OpenAI SDK
-  </Card>
-  <Card title="AgentOps Integration" icon="chart-line" href="/integrations/agentops">
-    Monitor agent performance with AgentOps
-  </Card>
-</CardGroup>
-

docs/integrations/langchain.mdx

@@ -40,7 +40,7 @@ load_dotenv()
 # os.environ["MEM0_API_KEY"] = "your-mem0-api-key"
 
 # Initialize LangChain and Mem0
-llm = ChatOpenAI(model="gpt-4.1-nano-2025-04-14")
+llm = ChatOpenAI(model="gpt-5-mini")
 mem0 = MemoryClient()
 ```
 
@@ -66,7 +66,7 @@ Create functions to handle context retrieval, response generation, and addition
 def retrieve_context(query: str, user_id: str) -> List[Dict]:
     """Retrieve relevant context from Mem0"""
     try:
-        memories = mem0.search(query, user_id=user_id)
+        memories = mem0.search(query, filters={"user_id": user_id})
         memory_list = memories['results']
         
         serialized_memories = ' '.join([mem["memory"] for mem in memory_list])

docs/integrations/langgraph.mdx

@@ -68,7 +68,7 @@ def chatbot(state: State):
 
     try:
         # Retrieve relevant memories
-        memories = mem0.search(messages[-1].content, user_id=user_id)
+        memories = mem0.search(messages[-1].content, filters={"user_id": user_id})
         
         # Handle dict response format
         memory_list = memories['results']

docs/integrations/livekit.mdx

@@ -148,7 +148,7 @@ async def entrypoint(ctx: JobContext):
 
     session = AgentSession(
         stt=deepgram.STT(),
-        llm=openai.LLM(model="gpt-4.1-nano-2025-04-14"),
+        llm=openai.LLM(model="gpt-5-mini"),
         tts=openai.TTS(voice="ash",),
         turn_detection=EnglishModel(),
         vad=silero.VAD.load(),

docs/integrations/llama-index.mdx

@@ -83,7 +83,7 @@ config = {
     "llm": {
         "provider": "openai",
         "config": {
-            "model": "gpt-4.1-nano-2025-04-14",
+            "model": "gpt-5-mini",
             "temperature": 0.2,
             "max_tokens": 2000,
         },
@@ -92,7 +92,6 @@ config = {
         "provider": "openai",
         "config": {"model": "text-embedding-3-small"},
     },
-    "version": "v1.1",
 }
 ```
 
@@ -116,7 +115,7 @@ from dotenv import load_dotenv
 load_dotenv()
 
 # os.environ["OPENAI_API_KEY"] = "<your-openai-api-key>"
-llm = OpenAI(model="gpt-4.1-nano-2025-04-14")
+llm = OpenAI(model="gpt-5-mini")
 ```
 
 ### SimpleChatEngine

docs/integrations/openai-agents-sdk.mdx

@@ -45,7 +45,7 @@ mem0 = MemoryClient()
 @function_tool
 def search_memory(query: str, user_id: str) -> str:
     """Search through past conversations and memories"""
-    memories = mem0.search(query, user_id=user_id, top_k=3)
+    memories = mem0.search(query, filters={"user_id": user_id}, top_k=3)
     if memories and memories.get('results'):
         return "\n".join([f"- {mem['memory']}" for mem in memories['results']])
     return "No relevant memories found."
@@ -64,7 +64,7 @@ agent = Agent(
     Use the save_memory tool to store important information about the user.
     Always personalize your responses based on available memory.""",
     tools=[search_memory, save_memory],
-    model="gpt-4.1-nano-2025-04-14"
+    model="gpt-5-mini"
 )
 
 def chat_with_agent(user_input: str, user_id: str) -> str:
@@ -115,7 +115,7 @@ travel_agent = Agent(
     understand the user's travel preferences and history before making recommendations.
     After providing your response, use store_conversation to save important details.""",
     tools=[search_memory, save_memory],
-    model="gpt-4.1-nano-2025-04-14"
+    model="gpt-5-mini"
 )
 
 health_agent = Agent(
@@ -124,7 +124,7 @@ health_agent = Agent(
     understand the user's health goals and dietary preferences.
     After providing advice, use store_conversation to save relevant information.""",
     tools=[search_memory, save_memory],
-    model="gpt-4.1-nano-2025-04-14"
+    model="gpt-5-mini"
 )
 
 # Triage agent with handoffs
@@ -135,7 +135,7 @@ triage_agent = Agent(
     For health-related questions (fitness, diet, wellness, exercise), hand off to the Health Advisor.
     For general questions, handle them directly using available tools.""",
     handoffs=[travel_agent, health_agent],
-    model="gpt-4.1-nano-2025-04-14"
+    model="gpt-5-mini"
 )
 
 def chat_with_handoffs(user_input: str, user_id: str) -> str:
@@ -214,7 +214,7 @@ Customize memory behavior:
 # Configure memory search
 memories = mem0.search(
     query="travel preferences",
-    user_id="alex",
+    filters={"user_id": "alex"},
     top_k=5  # Number of memories to retrieve
 )
 

docs/integrations/openclaw.mdx

@@ -14,16 +14,37 @@ Add long-term memory to [OpenClaw](https://github.com/openclaw/openclaw) agents
 The plugin provides:
 1. **Auto-Recall** — Before the agent responds, memories matching the current message are injected into context
 2. **Auto-Capture** — After the agent responds, the exchange is sent to Mem0 which decides what's worth keeping
-3. **Agent Tools** — Five tools for explicit memory operations during conversations
+3. **Agent Tools** — Eight tools for explicit memory operations during conversations
 
 Both auto-recall and auto-capture run silently with no manual configuration required.
 
-## Installation
+## Requirements
+
+Check your OpenClaw version:
 
 ```bash
-openclaw plugins install @mem0/openclaw-mem0
+openclaw --version
+# OpenClaw 2026.4.15 (041266a)
 ```
 
+| OpenClaw Version | Plugin Support |
+|------------------|----------------|
+| `>= 2026.4.15`   | Fully supported |
+
+## Installation
+
+The fastest way is to install directly from your OpenClaw chat, no CLI or config editing needed.
+
+**Copy and paste this into your OpenClaw chat**; Telegram, WhatsApp, default chat, or any channel where your agent lives:
+
+```
+Setup Mem0 from mem0.ai/claw-setup
+```
+
+OpenClaw installs the plugin, prompts you for your email, and connects your Mem0 account with OTP verification. See [Chat Setup](#option-1-chat-setup-recommended) below for the full walkthrough.
+
+If you prefer the OpenClaw CLI, or are setting up self-hosted / open-source mode, see [Manual Config](#option-2-manual-config) and [Open-Source Mode](#open-source-mode-self-hosted) below.
+
 ## Setup and Configuration
 
 ### Understanding `userId`
@@ -36,37 +57,113 @@ Pick any stable, unique identifier for the user. Common choices:
 - A UUID (e.g. `"550e8400-e29b-41d4-a716-446655440000"`)
 - A simple username (e.g. `"alice"`)
 
-All memories are scoped to this `userId` — different values create separate memory namespaces. If you don't set it, it defaults to `"default"`, which means all users share the same memory space.
+All memories are scoped to this `userId` — different values create separate memory namespaces. If you don't set it, it defaults to your OS username.
 
 <Tip>In a multi-user application, set `userId` dynamically per user (e.g. from your auth system) rather than hardcoding a single value.</Tip>
 
 ### Platform Mode (Mem0 Cloud)
 
-<Note>Get your API key from <a href="https://app.mem0.ai" rel="nofollow">app.mem0.ai</a>.</Note>
+There are two ways to set up `@mem0/openclaw-mem0` on the Mem0 platform:
 
-Add to your `openclaw.json`:
+- **Chat setup (recommended)** — run the setup inside any OpenClaw chat. No config editing, no API key handling.
+- **Manual config** — edit `openclaw.json` directly.
 
-```json5
-// plugins.entries
-"openclaw-mem0": {
-  "enabled": true,
-  "config": {
-    "apiKey": "${MEM0_API_KEY}",
-    "userId": "alice"  // any unique identifier you choose for this user
-  }
-}
-```
+#### Option 1: Chat Setup (Recommended)
+
+You no longer need manual config editing to get started. Everything happens inside the OpenClaw chat itself.
+
+<Steps>
+  <Step title="Send the setup command to your OpenClaw agent">
+    Open any OpenClaw channel — Telegram, WhatsApp, your default chat, wherever your agent lives. Paste and send this command:
+
+    ```
+    Setup Mem0 from mem0.ai/claw-setup
+    ```
+
+    OpenClaw responds with a Mem0 setup card and immediately asks:
+
+    > "What's your email address? I'll send you a verification code to connect your Mem0 account."
+  </Step>
+
+  <Step title="Enter your email">
+    Type your email address and send it. Mem0 sends back:
+
+    > "Check your email for a 6-digit code and paste it here."
+  </Step>
+
+  <Step title="Paste the OTP">
+    Copy the 6-digit code from your email inbox and paste it into the chat.
+
+    You'll see the confirmation:
+
+    > "Connected to Mem0."
+  </Step>
+</Steps>
+
+That's it. No API key, no config file editing, no environment variables. The plugin is now active and auto-capture and auto-recall are running on every turn.
+
+<Note>The chat flow uses the same underlying config as manual setup — it writes `apiKey` and `userId` into `openclaw.json` for you. You can still open the file to inspect or override values afterward.</Note>
+
+#### Option 2: Manual Config
+
+<Steps>
+  <Step title="Install the plugin via the OpenClaw CLI">
+    ```bash
+    openclaw plugins install @mem0/openclaw-mem0
+    ```
+  </Step>
+
+  <Step title="Get your API key">
+    Get your API key from <a href="https://app.mem0.ai?utm_source=mem0-docs" rel="nofollow">app.mem0.ai</a>.
+  </Step>
+
+  <Step title="Select the plugin as your memory backend in `openclaw.json`">
+    Add the full config to your `openclaw.json`:
+
+    ```json5
+    {
+      "plugins": {
+        "slots": {
+          "memory": "openclaw-mem0"
+        },
+        "entries": {
+          "openclaw-mem0": {
+            "enabled": true,
+            "config": {
+              "apiKey": "${MEM0_API_KEY}",
+              "userId": "alice"  // any unique identifier you choose for this user
+            }
+          }
+        }
+      }
+    }
+    ```
+  </Step>
+</Steps>
+
+<Warning>
+OpenClaw treats memory plugins as an exclusive slot. Installing the plugin alone does **not** activate it — you must also set `plugins.slots.memory` as shown above.
+</Warning>
 
 ### Open-Source Mode (Self-hosted)
 
 No Mem0 key needed. Requires `OPENAI_API_KEY` for default embeddings/LLM.
 
 ```json5
-"openclaw-mem0": {
-  "enabled": true,
-  "config": {
-    "mode": "open-source",
-    "userId": "alice"  // any unique identifier you choose for this user
+{
+  "plugins": {
+    "slots": {
+      "memory": "openclaw-mem0"
+    },
+    "entries": {
+      "openclaw-mem0": {
+        "enabled": true,
+        "config": {
+          "mode": "open-source",
+          "userId": "alice"  // any unique identifier you choose for this user
+        }
+      }
+    }
   }
 }
 ```
@@ -74,13 +171,25 @@ No Mem0 key needed. Requires `OPENAI_API_KEY` for default embeddings/LLM.
 Sensible defaults work out of the box. To customize the embedder, vector store, or LLM:
 
 ```json5
-"config": {
-  "mode": "open-source",
-  "userId": "your-user-id",
-  "oss": {
-    "embedder": { "provider": "openai", "config": { "model": "text-embedding-3-small" } },
-    "vectorStore": { "provider": "qdrant", "config": { "host": "localhost", "port": 6333 } },
-    "llm": { "provider": "openai", "config": { "model": "gpt-4o" } }
+{
+  "plugins": {
+    "slots": {
+      "memory": "openclaw-mem0"
+    },
+    "entries": {
+      "openclaw-mem0": {
+        "enabled": true,
+        "config": {
+          "mode": "open-source",
+          "userId": "your-user-id",
+          "oss": {
+            "embedder": { "provider": "openai", "config": { "model": "text-embedding-3-small" } },
+            "vectorStore": { "provider": "qdrant", "config": { "host": "localhost", "port": 6333 } },
+            "llm": { "provider": "openai", "config": { "model": "gpt-4o" } }
+          }
+        }
+      }
+    }
   }
 }
 ```
@@ -93,23 +202,26 @@ Memories are organized into two scopes:
 
 - **Session (short-term)** — Auto-capture stores memories scoped to the current session via Mem0's `run_id` / `runId` parameter. These are contextual to the ongoing conversation.
 
-- **User (long-term)** — The agent can explicitly store long-term memories using the `memory_store` tool (with `longTerm: true`, the default). These persist across all sessions for the user.
+- **User (long-term)** — The agent can explicitly store long-term memories using the `memory_add` tool (with `longTerm: true`, the default). These persist across all sessions for the user.
 
 During **auto-recall**, the plugin searches both scopes and presents them separately — long-term memories first, then session memories — so the agent has full context.
 
 ## Agent Tools
 
-The agent gets five tools it can call during conversations:
+The agent gets eight tools it can call during conversations:
 
 | Tool | Description |
 |------|-------------|
-| `memory_search` | Search memories by natural language |
-| `memory_list` | List all stored memories for a user |
-| `memory_store` | Explicitly save a fact |
-| `memory_get` | Retrieve a memory by ID |
-| `memory_forget` | Delete by ID or by query |
+| `memory_search` | Search memories by natural language query. Supports `scope`, `categories`, `filters`. |
+| `memory_add` | Store facts. Accepts `text` or `facts` array, `category`, `importance`, `metadata`. |
+| `memory_get` | Retrieve a single memory by ID |
+| `memory_list` | List all memories. Filter by `userId`, `agentId`, `scope`. |
+| `memory_update` | Update a memory's text in place. Preserves history. |
+| `memory_delete` | Delete by `memoryId`, `query` (search-and-delete), or `all: true`. |
+| `memory_event_list` | List recent background processing events (platform mode only). |
+| `memory_event_status` | Get status of a specific event by ID (platform mode only). |
 
-The `memory_search` and `memory_list` tools accept a `scope` parameter (`"session"`, `"long-term"`, or `"all"`) to control which memories are queried. The `memory_store` tool accepts a `longTerm` boolean (default: `true`) to choose where to store.
+The `memory_search` and `memory_list` tools accept a `scope` parameter (`"session"`, `"long-term"`, or `"all"`) to control which memories are queried.
 
 ## CLI Commands
 
@@ -123,8 +235,9 @@ openclaw mem0 search "what languages does the user know" --scope long-term
 # Search only session/short-term memories
 openclaw mem0 search "what languages does the user know" --scope session
 
-# View stats
-openclaw mem0 stats
+# List all memories
+openclaw mem0 list
+openclaw mem0 list --user-id alice --top-k 20
 ```
 
 ## Configuration Options
@@ -134,7 +247,7 @@ openclaw mem0 stats
 | Key | Type | Default | Description |
 |-----|------|---------|-------------|
 | `mode` | `"platform"` \| `"open-source"` | `"platform"` | Which backend to use |
-| `userId` | `string` | `"default"` | Scope memories per user |
+| `userId` | `string` | OS username | Scope memories per user |
 | `autoRecall` | `boolean` | `true` | Inject memories before each turn |
 | `autoCapture` | `boolean` | `true` | Store facts after each turn |
 | `topK` | `number` | `5` | Max memories per recall |
@@ -145,9 +258,6 @@ openclaw mem0 stats
 | Key | Type | Default | Description |
 |-----|------|---------|-------------|
 | `apiKey` | `string` | — | **Required.** Mem0 API key (supports `${MEM0_API_KEY}`) |
-| `orgId` | `string` | — | Organization ID |
-| `projectId` | `string` | — | Project ID |
-| `enableGraph` | `boolean` | `false` | Entity graph for relationships |
 | `customInstructions` | `string` | *(built-in)* | Extraction rules — what to store, how to format |
 | `customCategories` | `object` | *(12 defaults)* | Category name → description map for tagging |
 
@@ -163,15 +273,77 @@ openclaw mem0 stats
 | `oss.llm.provider` | `string` | `"openai"` | LLM provider (`"openai"`, `"anthropic"`, `"ollama"`, etc.) |
 | `oss.llm.config` | `object` | — | Provider config: `apiKey`, `model`, `baseURL`, `temperature` |
 | `oss.historyDbPath` | `string` | — | SQLite path for memory edit history |
+| `oss.disableHistory` | `boolean` | `false` | Disable memory edit history tracking |
 
 Everything inside `oss` is optional — defaults use OpenAI embeddings (`text-embedding-3-small`), in-memory vector store, and OpenAI LLM.
 
+## Plugin Management
+
+### Updating the Plugin
+
+```bash
+openclaw plugins update @mem0/openclaw-mem0
+```
+
+<Note>Use the npm package name (`@mem0/openclaw-mem0`) for plugin management commands, not the plugin ID (`openclaw-mem0`).</Note>
+
+### Checking Plugin Status
+
+```bash
+openclaw plugins list
+openclaw plugins inspect openclaw-mem0
+```
+
+## Troubleshooting
+
+### "plugins.allow excludes mem0" Error
+
+If you see an error like:
+
+```
+[openclaw] Failed to start CLI: Error: The `openclaw mem0` command is unavailable
+because `plugins.allow` excludes "mem0". Add "mem0" to `plugins.allow` if you want
+that bundled plugin CLI surface.
+```
+
+Add `mem0` to your `plugins.allow` list in `openclaw.json`:
+
+```json5
+{
+  "plugins": {
+    "allow": ["mem0"],
+    "slots": {
+      "memory": "openclaw-mem0"
+    }
+  }
+}
+```
+
+### Plugin Not Activating
+
+If the plugin installs but doesn't work:
+
+1. Verify `plugins.slots.memory` is set to `"openclaw-mem0"` (not the npm package name)
+2. Check `openclaw plugins list --enabled` to confirm the plugin is loaded
+3. Run `openclaw mem0 status` to verify configuration
+
+### Plugin Update Not Working
+
+If `openclaw plugins update` fails:
+
+1. Use the full npm package name: `openclaw plugins update @mem0/openclaw-mem0`
+2. If that fails, uninstall and reinstall:
+   ```bash
+   openclaw plugins uninstall openclaw-mem0
+   openclaw plugins install @mem0/openclaw-mem0
+   ```
+
 ## Key Features
 
 1. **Zero Configuration** — Auto-recall and auto-capture work out of the box with no prompting required
 2. **Dual Memory Scopes** — Session-scoped short-term and user-scoped long-term memories
 3. **Flexible Backend** — Use Mem0 Cloud for managed service or self-host with open-source mode
-4. **Rich Tool Suite** — Five agent tools for explicit memory operations when needed
+4. **Rich Tool Suite** — Eight agent tools for explicit memory operations when needed
 
 ## Conclusion
 

docs/integrations/raycast.mdx

@@ -1,50 +0,0 @@
----
-title: "Raycast Extension"
-description: "Mem0 Raycast extension for intelligent memory management"
----
-
-Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users. This extension lets you store and retrieve text snippets using Mem0's intelligent memory system. Find Mem0 in [Raycast Store](https://www.raycast.com/dev_khant/mem0) for using it.
-
-## Getting Started
-
-**Get your API Key**: You'll need a Mem0 API key to use this extension:
-
-a. Sign up at <a href="https://app.mem0.ai" rel="nofollow">app.mem0.ai</a>
-
-b. Navigate to your API Keys page
-
-c. Copy your API key
-
-d. Enter this key in the extension preferences
-
-**Basic Usage**:
-
-- Store memories and text snippets
-- Retrieve context-aware information
-- Manage persistent user preferences
-- Search through stored memories
-
-## Features
-
-**Remember Everything**: Never lose important information. Store notes, preferences, and conversations that your AI can recall later.
-
-**Smart Connections**: Automatically links related topics, helping you discover useful connections.
-
-**Cost Saver**: Spend less on AI usage by efficiently retrieving relevant information instead of regenerating responses.
-
-## How This Helps You
-
-**More Personal Experience**: Your AI remembers your preferences and past conversations, making interactions feel more natural.
-
-**Learn Your Style**: Adapts to how you work and what you like, becoming more helpful over time.
-
-**No More Repetition**: Stop explaining the same things repeatedly. Your AI remembers your context and preferences.
-
-<CardGroup cols={2}>
-  <Card title="OpenAI Agents SDK" icon="cube" href="/integrations/openai-agents-sdk">
-    Build desktop AI agents with OpenAI SDK
-  </Card>
-  <Card title="Mastra Integration" icon="star" href="/integrations/mastra">
-    Create intelligent desktop workflows
-  </Card>
-</CardGroup>

docs/integrations/vercel-ai-sdk.mdx

@@ -78,7 +78,7 @@ npm install @mem0/vercel-ai-provider
 
      > `getMemories` will return raw memories in the form of an array of objects, while `retrieveMemories` will return a response in string format with a system prompt ingested with the retrieved memories.
 
-     > `getMemories` is an object with two keys: `results` and `relations` if `enable_graph` is enabled. Otherwise, it will return an array of objects.
+     > `getMemories` returns an array of memory objects.
 
 ### 1. Basic Text Generation with Memory Context
 
@@ -270,24 +270,6 @@ main();
 
 > **Note**: File support is available with providers that support multimodal capabilities like Google's Gemini models. The example shows how to process PDF files, but you can also work with images, text files, and other supported formats.
 
-## Graph Memory
-
-Mem0 AI SDK now supports Graph Memory. You can enable it by setting `enable_graph` to `true` in the `mem0Config` object.
-
-```typescript
-const mem0 = createMem0({
-  mem0Config: { enable_graph: true },
-});
-```
-
-You can also pass `enable_graph` in the standalone functions. This includes `getMemories`, `retrieveMemories`, and `addMemories`.
-
-```typescript
-const memories = await getMemories(prompt, { user_id: "borat", mem0ApiKey: "m0-xxx", enable_graph: true });
-```
-
-The `getMemories` function will return an object with two keys: `results` and `relations`, if `enable_graph` is set to `true`. Otherwise, it will return an array of objects.
-
 ## Supported LLM Providers
 
 | Provider | Configuration Value |

docs/llms.txt

@@ -1,308 +1,466 @@
 # Mem0
 
-> Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that retain context across sessions, adapt over time, and reduce costs by intelligently storing and retrieving relevant information.
+> Mem0 is a memory layer for LLM agents - persistent, self-improving context that survives across sessions. Two products share one mental model: Mem0 Platform (managed) and Mem0 Open Source (self-hosted). Every link below is tagged `[Platform]`, `[OSS]`, or `[Both]` so you can load only what the current user needs.
 
-Mem0 provides both a managed platform and open-source solutions for adding persistent memory to AI agents and applications. Unlike traditional RAG systems that are stateless, Mem0 creates stateful agents that remember user preferences, learn from interactions, and evolve behavior over time.
+## For agents reading this file
 
-Key differentiators:
-- **Stateful vs Stateless**: Retains context across sessions rather than forgetting after each interaction
-- **Intelligent Memory Management**: Uses LLMs to extract, filter, and organize relevant information
-- **Dual Storage Architecture**: Combines vector embeddings with graph databases for comprehensive memory
-- **Sub-50ms Retrieval**: Lightning-fast memory lookups for real-time applications
-- **Multimodal Support**: Handles text, images, and documents seamlessly
+- Use `MemoryClient` (Python) / `mem0ai` (npm) when the user has a Mem0 Platform API key. Docs under `/platform/` and `/api-reference/` apply; the managed product handles providers server-side, so you can ignore `## Optional` below.
+- Use `Memory` (Python) / `mem0ai/oss` (npm) when the user self-hosts. Docs under `/open-source/` and `/components/` apply; Platform-only features (entity filters v2, custom categories, webhooks, advanced retrieval) may not be available.
+- Scope tag reference: `[Platform]` = managed only, `[OSS]` = self-hosted only, `[Both]` = same API surface on both.
+- OpenAPI spec: https://docs.mem0.ai/openapi.json
+- Live MCP server: https://mcp.mem0.ai (see `platform/mem0-mcp`).
+- Source repo: https://github.com/mem0ai/mem0
+
+## Install
+
+- Python SDK: `pip install mem0ai`
+- Node SDK: `npm install mem0ai`
+- Python CLI: `pip install mem0-cli`
+- Node CLI: `npm install -g @mem0/cli`
+
+## Identify the User's Setup
+
+Look at the user's imports first - they determine which product (Platform vs OSS) and which language you should quote docs from. **Mem0 Platform (managed) is the recommended path** - 4-line integration, sub-50ms retrieval, no infra. Route to OSS only when the user has an explicit self-hosting requirement.
+
+### Platform - Python [Platform]
+
+Import signature: `from mem0 import MemoryClient`
+
+```python
+from mem0 import MemoryClient
+
+client = MemoryClient(api_key="your-api-key")
+
+# Create
+client.add(
+    [{"role": "user", "content": "I love hiking on weekends"}],
+    user_id="alice",
+)
+
+# Read
+client.search("What does Alice like to do?", user_id="alice")
+client.get_all(user_id="alice")
+client.get(memory_id="<id>")
+
+# Update
+client.update(memory_id="<id>", data="Alice loves mountain hiking")
+
+# Delete
+client.delete(memory_id="<id>")
+client.delete_all(user_id="alice")
+```
+
+Relevant docs: `platform/quickstart`, `platform/features/*`, `api-reference/*`.
+
+### Platform - TypeScript / JavaScript [Platform]
+
+Import signature: `import MemoryClient from "mem0ai"`
+
+```ts
+import MemoryClient from "mem0ai";
+
+const client = new MemoryClient({ apiKey: "your-api-key" });
+
+// Create
+await client.add(
+  [{ role: "user", content: "I love hiking on weekends" }],
+  { user_id: "alice" },
+);
+
+// Read
+await client.search("What does Alice like to do?", { user_id: "alice" });
+await client.getAll({ user_id: "alice" });
+await client.get("<memory_id>");
+
+// Update
+await client.update("<memory_id>", { text: "Alice loves mountain hiking" });
+
+// Delete
+await client.delete("<memory_id>");
+await client.deleteAll({ user_id: "alice" });
+```
+
+Relevant docs: same as Platform Python.
+
+### OSS - Python [OSS]
+
+Import signature: `from mem0 import Memory`
+
+```python
+from mem0 import Memory
+
+m = Memory()   # needs OPENAI_API_KEY; see components/ for custom providers
+
+# Create
+m.add("I love hiking on weekends", user_id="alice")
+
+# Read
+m.search("What does Alice like to do?", user_id="alice")
+m.get_all(user_id="alice")
+m.get(memory_id="<id>")
+
+# Update
+m.update(memory_id="<id>", data="Alice loves mountain hiking")
+
+# Delete
+m.delete(memory_id="<id>")
+m.delete_all(user_id="alice")
+```
+
+Relevant docs: `open-source/*` plus provider pages under `## Optional`.
+
+### OSS - Node [OSS]
+
+Import signature: `import { Memory } from "mem0ai/oss"`
+
+```ts
+import { Memory } from "mem0ai/oss";
+
+const memory = new Memory();
+
+// Create
+await memory.add("I love hiking on weekends", { userId: "alice" });
+
+// Read
+await memory.search("What does Alice like to do?", { userId: "alice" });
+await memory.getAll({ userId: "alice" });
+await memory.get("<memory_id>");
+
+// Update
+await memory.update("<memory_id>", "Alice loves mountain hiking");
+
+// Delete
+await memory.delete("<memory_id>");
+await memory.deleteAll({ userId: "alice" });
+```
+
+Relevant docs: same as OSS Python.
+
+### Version Probes
+
+Once you know which product, check the installed version - v2 vs v3 APIs differ in both OSS and Platform. Current published versions: Python `mem0ai` 2.x, TypeScript `mem0ai` 3.x, Node CLI `@mem0/cli` 0.2.x.
+
+```bash
+pip show mem0ai | grep -i ^version
+npm list mem0ai --depth 0 2>/dev/null | grep mem0ai
+mem0 --version          # Python or Node CLI, whichever is on PATH
+```
+
+If the user is on a pre-current major (Python < 2, TS < 3, or Platform `output_format: "v1.1"`), route them through the matching migration guide in the Platform section before quoting current docs. If no Mem0 package is installed, recommend `pip install mem0ai` or `npm install mem0ai` and the corresponding quickstart above.
 
 ## Getting Started
 
-- [Introduction](https://docs.mem0.ai/introduction): Overview of Mem0's memory layer for AI agents, including stateless vs stateful agents and how memory fits in the agent stack
-- [Platform Overview](https://docs.mem0.ai/platform/overview): Managed solution with 4-line integration, sub-50ms latency, and intuitive dashboard
-- [Vibe Code with Mem0](https://docs.mem0.ai/vibecoding): Single entry point for developers using AI coding tools (Claude Code, Cursor, Windsurf) with Mem0
-- [Mem0 MCP Server](https://docs.mem0.ai/platform/mem0-mcp): Model Context Protocol server for integrating Mem0 with AI coding assistants
-- [Platform vs Open Source](https://docs.mem0.ai/platform/platform-vs-oss): Compare managed platform vs self-hosted options
-- [Platform Quickstart](https://docs.mem0.ai/platform/quickstart): Get started with Mem0 Platform (managed) in minutes
-- [Open Source Overview](https://docs.mem0.ai/open-source/overview): Self-hosted solution with full infrastructure control and customization
-- [Open Source Python Quickstart](https://docs.mem0.ai/open-source/python-quickstart): Get started with Mem0 Open Source using Python
-- [Open Source Node.js Quickstart](https://docs.mem0.ai/open-source/node-quickstart): Get started with Mem0 Open Source using Node.js
+- [Introduction](https://docs.mem0.ai/introduction) [Both]: Use when the user wants a one-page overview of how memory fits between the LLM and the app.
+- [Vibe Code with Mem0](https://docs.mem0.ai/vibecoding) [Both]: Use when the user is in Claude Code, Cursor, or Windsurf and wants memory wired into their editor.
+- [Platform Overview](https://docs.mem0.ai/platform/overview) [Platform]: Use when the user picks the managed product - 4-line integration, sub-50ms retrieval, dashboard.
+- [Platform vs Open Source](https://docs.mem0.ai/platform/platform-vs-oss) [Both]: Use when the user is deciding between managed and self-hosted.
+- [Platform Quickstart](https://docs.mem0.ai/platform/quickstart) [Platform]: Use for the first Platform integration - API key plus `MemoryClient.add/search`.
+- [Platform CLI](https://docs.mem0.ai/platform/cli) [Platform]: Use when the user wants to manage Platform memories from the terminal.
+- [Mem0 MCP Server](https://docs.mem0.ai/platform/mem0-mcp) [Platform]: Use when connecting memory to AI coding tools over MCP.
+- [Open Source Overview](https://docs.mem0.ai/open-source/overview) [OSS]: Use when the user needs full infra control and custom provider wiring.
+- [Open Source Configuration](https://docs.mem0.ai/open-source/configuration) [OSS]: Use when configuring `Memory` - LLM, embedder, vector store, graph store.
+- [Open Source Python Quickstart](https://docs.mem0.ai/open-source/python-quickstart) [OSS]: Use for the first self-hosted Python integration.
+- [Open Source Node.js Quickstart](https://docs.mem0.ai/open-source/node-quickstart) [OSS]: Use for the first self-hosted Node integration.
 
 ## Core Concepts
 
-- [Memory Types](https://docs.mem0.ai/core-concepts/memory-types): Working memory (short-term session awareness), factual memory (structured knowledge), episodic memory (past conversations), and semantic memory (general knowledge)
-- [Memory Operations - Add](https://docs.mem0.ai/core-concepts/memory-operations/add): How Mem0 processes conversations through information extraction, conflict resolution, and dual storage
-- [Memory Operations - Search](https://docs.mem0.ai/core-concepts/memory-operations/search): Retrieval of relevant memories using semantic search with query processing and result ranking
-- [Memory Operations - Update](https://docs.mem0.ai/core-concepts/memory-operations/update): Modifying existing memories when new information conflicts or supplements stored data
-- [Memory Operations - Delete](https://docs.mem0.ai/core-concepts/memory-operations/delete): Removing outdated or irrelevant memories to maintain memory quality
+- [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.
+- [Memory Operations - Update](https://docs.mem0.ai/core-concepts/memory-operations/update) [Both]: Use when memories need to be edited in place or reconciled against new info.
+- [Memory Operations - Delete](https://docs.mem0.ai/core-concepts/memory-operations/delete) [Both]: Use when outdated memories must be removed.
+- [Memory Evaluation](https://docs.mem0.ai/core-concepts/memory-evaluation) [Both]: Use when benchmarking memory quality or comparing against baselines.
 
-## Platform Features
+## Platform
 
-- [Platform Features Overview](https://docs.mem0.ai/platform/features/platform-overview): High-level overview of all Mem0 Platform capabilities
-- [Advanced Memory Operations](https://docs.mem0.ai/platform/advanced-memory-operations): Sophisticated memory management techniques for complex applications
+### 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.
+- [Async Client](https://docs.mem0.ai/platform/features/async-client) [Platform]: Use when the app issues many concurrent Mem0 calls and needs non-blocking I/O.
+- [Multimodal Support](https://docs.mem0.ai/platform/features/multimodal-support) [Platform]: Use when storing images or PDFs as memory input.
+- [Custom Categories](https://docs.mem0.ai/platform/features/custom-categories) [Platform]: Use when the default categories do not match the domain.
 
-### Essential Features
-- [V2 Memory Filters](https://docs.mem0.ai/platform/features/v2-memory-filters): Advanced filtering and querying capabilities for memories
-- [Entity-Scoped Memory](https://docs.mem0.ai/platform/features/entity-scoped-memory): Organize memories by user, agent, app, and session identifiers
-- [Async Client](https://docs.mem0.ai/platform/features/async-client): Non-blocking operations for high-concurrency applications
-- [Async Mode Default Changes](https://docs.mem0.ai/platform/features/async-mode-default-change): Understanding new async behavior defaults
-- [Multimodal Support](https://docs.mem0.ai/platform/features/multimodal-support): Integration of images and documents (JPG, PNG, MDX, TXT, PDF) via URLs or Base64
-- [Custom Categories](https://docs.mem0.ai/platform/features/custom-categories): Define domain-specific categories to improve memory organization
+### Features - Advanced Retrieval
+- [Advanced Retrieval](https://docs.mem0.ai/platform/features/advanced-retrieval) [Platform]: Use when the user needs keyword search, reranking, or hybrid retrieval.
+- [Criteria-Based Retrieval](https://docs.mem0.ai/platform/features/criteria-retrieval) [Platform]: Use when targeting memories by custom criteria, not just semantic similarity.
+- [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.
+- [Advanced Memory Operations](https://docs.mem0.ai/platform/advanced-memory-operations) [Platform]: Use when basic CRUD is not enough - batch ops, complex filters, workflows.
 
-### Advanced Features
-- [Graph Memory](https://docs.mem0.ai/platform/features/graph-memory): Build and query relationships between entities for contextually relevant retrieval
-- [Graph Threshold](https://docs.mem0.ai/platform/features/graph-threshold): Configure graph relationship sensitivity and strength
-- [Advanced Retrieval](https://docs.mem0.ai/platform/features/advanced-retrieval): Enhanced search with keyword search, reranking, and filtering capabilities
-- [Criteria-Based Retrieval](https://docs.mem0.ai/platform/features/criteria-retrieval): Targeted memory retrieval using custom criteria
-- [Contextual Add](https://docs.mem0.ai/platform/features/contextual-add): Add memories with enhanced context awareness
-- [Custom Instructions](https://docs.mem0.ai/platform/features/custom-instructions): Customize how Mem0 processes and stores information
+### Features - Data Management
+- [Direct Import](https://docs.mem0.ai/platform/features/direct-import) [Platform]: Use when seeding a Mem0 project from existing data.
+- [Memory Export](https://docs.mem0.ai/platform/features/memory-export) [Platform]: Use when exporting memories via a Pydantic schema.
+- [Timestamp Support](https://docs.mem0.ai/platform/features/timestamp) [Platform]: Use when temporal queries or time-based filtering matter.
 
-### Data Management
-- [Direct Import](https://docs.mem0.ai/platform/features/direct-import): Bulk import existing data into Mem0 memory
-- [Memory Export](https://docs.mem0.ai/platform/features/memory-export): Export memories in structured formats using customizable Pydantic schemas
-- [Timestamp Support](https://docs.mem0.ai/platform/features/timestamp): Temporal memory management with time-based queries
-- [Expiration Dates](https://docs.mem0.ai/platform/features/expiration-date): Automatic memory cleanup with configurable expiration
-
-### Integration Features
-- [Webhooks](https://docs.mem0.ai/platform/features/webhooks): Real-time notifications for memory events
-- [Feedback Mechanism](https://docs.mem0.ai/platform/features/feedback-mechanism): Improve memory quality through user feedback
-- [Group Chat Support](https://docs.mem0.ai/platform/features/group-chat): Multi-conversation memory management
-- [MCP Integration](https://docs.mem0.ai/platform/features/mcp-integration): Model Context Protocol integration for AI coding tools
+### Features - Integration & Ops
+- [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): Frequently asked questions about Mem0 Platform
-- [Contribute Guide](https://docs.mem0.ai/platform/contribute): Contributing to Mem0 Platform development
-- [OSS to Platform Migration](https://docs.mem0.ai/migration/oss-to-platform): Guide for migrating from open-source to managed platform
-- [V0 to V1 Migration](https://docs.mem0.ai/migration/v0-to-v1): Upgrading from Mem0 v0 to v1
-- [Breaking Changes](https://docs.mem0.ai/migration/breaking-changes): List of breaking changes across versions
-- [API Changes](https://docs.mem0.ai/migration/api-changes): Detailed API changes and migration paths
+- [FAQs](https://docs.mem0.ai/platform/faqs) [Platform]: Use when answering common Platform questions.
+- [Contribute to Platform](https://docs.mem0.ai/platform/contribute) [Platform]: Use when a user wants to contribute to Platform docs or code.
+- [OSS to Platform Migration](https://docs.mem0.ai/migration/oss-to-platform) [Both]: Use when moving from self-hosted to managed.
+- [OSS v2 to v3 Migration](https://docs.mem0.ai/migration/oss-v2-to-v3) [OSS]: Use when upgrading a self-hosted deployment across major versions.
+- [Platform v2 to v3 Migration](https://docs.mem0.ai/migration/platform-v2-to-v3) [Platform]: Use when upgrading a Platform integration across major versions.
+- [API Changes](https://docs.mem0.ai/migration/api-changes) [Both]: Use when the upgrade involves API surface changes.
+- [Changelog](https://docs.mem0.ai/changelog/highlights) [Both]: Use when the user asks what shipped recently.
 
 ## Open Source
 
-### Getting Started
-- [Python Quickstart](https://docs.mem0.ai/open-source/python-quickstart): Installation, configuration, and usage examples for Python SDK
-- [Node.js Quickstart](https://docs.mem0.ai/open-source/node-quickstart): Installation, configuration, and usage examples for Node.js SDK
-- [Configuration Guide](https://docs.mem0.ai/open-source/configuration): Complete configuration options for self-hosted deployment
-
-### Open Source Features
-- [Features Overview](https://docs.mem0.ai/open-source/features/overview): Overview of all open-source features
-- [Graph Memory](https://docs.mem0.ai/open-source/features/graph-memory): Build and query entity relationships using graph stores like Neo4j
-- [Metadata Filtering](https://docs.mem0.ai/open-source/features/metadata-filtering): Advanced filtering using custom metadata fields
-- [Reranker Search](https://docs.mem0.ai/open-source/features/reranker-search): Enhanced search results with reranking models
-- [Async Memory](https://docs.mem0.ai/open-source/features/async-memory): Asynchronous memory operations for better performance
-- [Multimodal Support](https://docs.mem0.ai/open-source/features/multimodal-support): Handle text, images, and documents in self-hosted setup
-- [Custom Instructions](https://docs.mem0.ai/open-source/features/custom-instructions): Tailor information extraction for specific use cases
-- [Custom Memory Update Prompt](https://docs.mem0.ai/open-source/features/custom-update-memory-prompt): Customize how memories are updated and merged
-- [REST API Server](https://docs.mem0.ai/open-source/features/rest-api): FastAPI-based server with core operations and OpenAPI documentation
-- [OpenAI Compatibility](https://docs.mem0.ai/open-source/features/openai_compatibility): Seamless integration with OpenAI-compatible APIs
-
-## Components
-
-### LLMs
-- [LLM Overview](https://docs.mem0.ai/components/llms/overview): Comprehensive guide to Large Language Model integration and configuration options
-- [LLM Configuration](https://docs.mem0.ai/components/llms/config): Configuration reference for LLM providers
-- [OpenAI](https://docs.mem0.ai/components/llms/models/openai): Integration with OpenAI models including GPT-4
-- [Anthropic](https://docs.mem0.ai/components/llms/models/anthropic): Claude model integration with advanced reasoning capabilities
-- [Azure OpenAI](https://docs.mem0.ai/components/llms/models/azure_openai): Microsoft Azure hosted OpenAI models for enterprise environments
-- [Ollama](https://docs.mem0.ai/components/llms/models/ollama): Local model deployment for privacy-focused applications
-- [Together](https://docs.mem0.ai/components/llms/models/together): Open-source model inference platform
-- [Groq](https://docs.mem0.ai/components/llms/models/groq): High-performance LPU optimized models for fast inference
-- [LiteLLM](https://docs.mem0.ai/components/llms/models/litellm): Unified LLM interface and proxy
-- [Mistral AI](https://docs.mem0.ai/components/llms/models/mistral_AI): Mistral model integration
-- [Google AI](https://docs.mem0.ai/components/llms/models/google_AI): Gemini model integration for multimodal applications
-- [AWS Bedrock](https://docs.mem0.ai/components/llms/models/aws_bedrock): Enterprise-grade AWS managed model integration
-- [DeepSeek](https://docs.mem0.ai/components/llms/models/deepseek): Advanced reasoning models
-- [MiniMax](https://docs.mem0.ai/components/llms/models/minimax): MiniMax model integration
-- [xAI](https://docs.mem0.ai/components/llms/models/xAI): xAI Grok models integration
-- [Sarvam](https://docs.mem0.ai/components/llms/models/sarvam): Indian language models
-- [LM Studio](https://docs.mem0.ai/components/llms/models/lmstudio): Local model management and deployment
-- [LangChain LLM](https://docs.mem0.ai/components/llms/models/langchain): LangChain LLM integration
-- [vLLM](https://docs.mem0.ai/components/llms/models/vllm): High-performance inference framework
-
-### Vector Databases
-- [Vector Database Overview](https://docs.mem0.ai/components/vectordbs/overview): Guide to supported vector databases for semantic memory storage
-- [Vector Database Configuration](https://docs.mem0.ai/components/vectordbs/config): Configuration reference for vector database providers
-- [Qdrant](https://docs.mem0.ai/components/vectordbs/dbs/qdrant): High-performance vector similarity search engine
-- [Chroma](https://docs.mem0.ai/components/vectordbs/dbs/chroma): AI-native open-source vector database optimized for speed
-- [PGVector](https://docs.mem0.ai/components/vectordbs/dbs/pgvector): PostgreSQL extension for vector similarity search
-- [Milvus](https://docs.mem0.ai/components/vectordbs/dbs/milvus): Open-source vector database for AI applications at scale
-- [Pinecone](https://docs.mem0.ai/components/vectordbs/dbs/pinecone): Managed vector database with serverless and pod deployment options
-- [MongoDB](https://docs.mem0.ai/components/vectordbs/dbs/mongodb): Document database with vector search capabilities
-- [Azure AI Search](https://docs.mem0.ai/components/vectordbs/dbs/azure): Microsoft's enterprise search service
-- [Azure MySQL](https://docs.mem0.ai/components/vectordbs/dbs/azure_mysql): Azure Database for MySQL with vector search
-- [Redis](https://docs.mem0.ai/components/vectordbs/dbs/redis): Real-time vector storage and search with Redis Stack
-- [Valkey](https://docs.mem0.ai/components/vectordbs/dbs/valkey): Open-source Redis alternative with vector search
-- [Elasticsearch](https://docs.mem0.ai/components/vectordbs/dbs/elasticsearch): Distributed search and analytics engine
-- [OpenSearch](https://docs.mem0.ai/components/vectordbs/dbs/opensearch): Open-source search and analytics platform
-- [Supabase](https://docs.mem0.ai/components/vectordbs/dbs/supabase): Open-source Firebase alternative with vector support
-- [Upstash Vector](https://docs.mem0.ai/components/vectordbs/dbs/upstash-vector): Serverless vector database
-- [Vectorize](https://docs.mem0.ai/components/vectordbs/dbs/vectorize): Vectorize vector database integration
-- [Vertex AI Vector Search](https://docs.mem0.ai/components/vectordbs/dbs/vertex_ai): Google Cloud's vector search service
-- [Weaviate](https://docs.mem0.ai/components/vectordbs/dbs/weaviate): Open-source vector search engine with built-in ML capabilities
-- [FAISS](https://docs.mem0.ai/components/vectordbs/dbs/faiss): Facebook AI Similarity Search library
-- [LangChain Vector Store](https://docs.mem0.ai/components/vectordbs/dbs/langchain): LangChain vector store integration
-- [Baidu](https://docs.mem0.ai/components/vectordbs/dbs/baidu): Baidu vector database integration
-- [Cassandra](https://docs.mem0.ai/components/vectordbs/dbs/cassandra): Apache Cassandra with vector search capabilities
-- [S3 Vectors](https://docs.mem0.ai/components/vectordbs/dbs/s3_vectors): Amazon S3 Vectors integration
-- [Databricks](https://docs.mem0.ai/components/vectordbs/dbs/databricks): Delta Lake integration for vector search
-- [Neptune Analytics](https://docs.mem0.ai/components/vectordbs/dbs/neptune_analytics): AWS Neptune Analytics for graph and vector search
-- [Turbopuffer](https://docs.mem0.ai/components/vectordbs/dbs/turbopuffer): High-performance serverless vector database
-
-### Embedding Models
-- [Embeddings Overview](https://docs.mem0.ai/components/embedders/overview): Embedding model configuration for semantic understanding
-- [Embeddings Configuration](https://docs.mem0.ai/components/embedders/config): Configuration reference for embedding providers
-- [OpenAI Embeddings](https://docs.mem0.ai/components/embedders/models/openai): High-quality text embeddings with customizable dimensions
-- [Azure OpenAI Embeddings](https://docs.mem0.ai/components/embedders/models/azure_openai): Enterprise Azure-hosted embedding models
-- [Ollama Embeddings](https://docs.mem0.ai/components/embedders/models/ollama): Local embedding models for privacy-focused applications
-- [Hugging Face Embeddings](https://docs.mem0.ai/components/embedders/models/huggingface): Open-source embedding models for local deployment
-- [Vertex AI Embeddings](https://docs.mem0.ai/components/embedders/models/vertexai): Google Cloud's enterprise embedding models
-- [Google AI Embeddings](https://docs.mem0.ai/components/embedders/models/google_AI): Gemini embedding models
-- [LM Studio Embeddings](https://docs.mem0.ai/components/embedders/models/lmstudio): Local model embeddings
-- [Together Embeddings](https://docs.mem0.ai/components/embedders/models/together): Open-source model embeddings
-- [LangChain Embeddings](https://docs.mem0.ai/components/embedders/models/langchain): LangChain embedder integration
-- [AWS Bedrock Embeddings](https://docs.mem0.ai/components/embedders/models/aws_bedrock): Amazon embedding models through Bedrock
-
-### Rerankers
-- [Reranker Overview](https://docs.mem0.ai/components/rerankers/overview): Guide to reranking models for improving search result quality
-- [Reranker Configuration](https://docs.mem0.ai/components/rerankers/config): Configuration reference for reranker providers
-- [Reranker Optimization](https://docs.mem0.ai/components/rerankers/optimization): Performance tuning and optimization strategies for rerankers
-- [Custom Reranker Prompts](https://docs.mem0.ai/components/rerankers/custom-prompts): Customize reranker behavior with custom prompts
-- [Cohere Reranker](https://docs.mem0.ai/components/rerankers/models/cohere): Cohere reranking model integration
-- [Sentence Transformer Reranker](https://docs.mem0.ai/components/rerankers/models/sentence_transformer): Cross-encoder reranking with sentence transformers
-- [Hugging Face Reranker](https://docs.mem0.ai/components/rerankers/models/huggingface): Hugging Face reranking models
-- [LLM Reranker](https://docs.mem0.ai/components/rerankers/models/llm_reranker): Use LLMs as rerankers for flexible relevance scoring
-- [Zero Entropy Reranker](https://docs.mem0.ai/components/rerankers/models/zero_entropy): Zero Entropy reranking model
+- [Open Source Features Overview](https://docs.mem0.ai/open-source/features/overview) [OSS]: Use when surveying OSS-only capabilities.
+- [Metadata Filtering](https://docs.mem0.ai/open-source/features/metadata-filtering) [OSS]: Use when filtering by custom metadata fields in self-hosted.
+- [Reranker Search](https://docs.mem0.ai/open-source/features/reranker-search) [OSS]: Use when improving OSS search quality with a reranker.
+- [Reranking](https://docs.mem0.ai/open-source/features/reranking) [OSS]: Use when configuring reranking end-to-end in OSS.
+- [Async Memory](https://docs.mem0.ai/open-source/features/async-memory) [OSS]: Use when the self-hosted app needs `AsyncMemory`.
+- [OSS Multimodal Support (features)](https://docs.mem0.ai/open-source/features/multimodal-support) [OSS]: Use when handling images and PDFs self-hosted (feature guide).
+- [OSS Multimodal Support](https://docs.mem0.ai/open-source/multimodal-support) [OSS]: Use when handling images and PDFs self-hosted (concept overview).
+- [Custom Instructions (OSS)](https://docs.mem0.ai/open-source/features/custom-instructions) [OSS]: Use when tailoring extraction prompts in OSS.
+- [REST API Server](https://docs.mem0.ai/open-source/features/rest-api) [OSS]: Use when exposing a self-hosted Mem0 as a FastAPI service.
+- [OpenAI Compatibility](https://docs.mem0.ai/open-source/features/openai_compatibility) [OSS]: Use when hitting an OpenAI-compatible endpoint with self-hosted.
 
 ## Integrations
 
-- [Integrations Overview](https://docs.mem0.ai/integrations): Overview of all available Mem0 integrations
+- [Integrations Overview](https://docs.mem0.ai/integrations) [Both]: Use when surveying every available integration.
 
 ### Agent Frameworks
-- [LangChain](https://docs.mem0.ai/integrations/langchain): Seamless integration with LangChain framework for enhanced agent capabilities
-- [LangGraph](https://docs.mem0.ai/integrations/langgraph): Build stateful, multi-actor applications with persistent memory
-- [LlamaIndex](https://docs.mem0.ai/integrations/llama-index): Enhanced RAG applications with intelligent memory layer
-- [CrewAI](https://docs.mem0.ai/integrations/crewai): Multi-agent systems with shared and individual memory capabilities
-- [AutoGen](https://docs.mem0.ai/integrations/autogen): Microsoft's multi-agent conversation framework with memory
-- [Agno](https://docs.mem0.ai/integrations/agno): Agno framework integration with persistent memory
-- [Camel AI](https://docs.mem0.ai/integrations/camel-ai): Camel AI multi-agent framework with memory support
-- [OpenClaw](https://docs.mem0.ai/integrations/openclaw): OpenClaw framework integration
-- [OpenAI Agents SDK](https://docs.mem0.ai/integrations/openai-agents-sdk): OpenAI's agent framework with Mem0 memory
-- [Google AI ADK](https://docs.mem0.ai/integrations/google-ai-adk): Google AI Agent Development Kit with persistent memory
-- [Mastra](https://docs.mem0.ai/integrations/mastra): Mastra TypeScript agent framework integration
-- [Vercel AI SDK](https://docs.mem0.ai/integrations/vercel-ai-sdk): Build AI-powered web applications with persistent memory
+- [LangChain](https://docs.mem0.ai/integrations/langchain) [Both]: Use when the user is on LangChain.
+- [LangGraph](https://docs.mem0.ai/integrations/langgraph) [Both]: Use when building stateful multi-actor LangGraph apps.
+- [LangChain Tools](https://docs.mem0.ai/integrations/langchain-tools) [Both]: Use when Mem0 should be exposed as a LangChain tool.
+- [LlamaIndex](https://docs.mem0.ai/integrations/llama-index) [Both]: Use when layering memory on a LlamaIndex RAG app.
+- [CrewAI](https://docs.mem0.ai/integrations/crewai) [Both]: Use when building CrewAI multi-agent systems.
+- [Camel AI](https://docs.mem0.ai/integrations/camel-ai) [Both]: Use when the user is on Camel AI.
+- [ChatDev](https://docs.mem0.ai/integrations/chatdev) [Both]: Use when the user is on ChatDev.
+- [Hermes](https://docs.mem0.ai/integrations/hermes) [Both]: Use when the user is on Hermes.
+- [OpenAI Agents SDK](https://docs.mem0.ai/integrations/openai-agents-sdk) [Both]: Use when the user is on the OpenAI Agents SDK.
+- [Google AI ADK](https://docs.mem0.ai/integrations/google-ai-adk) [Both]: Use when the user is on Google's Agent Development Kit.
+- [Mastra](https://docs.mem0.ai/integrations/mastra) [Both]: Use when the user is on Mastra (TypeScript).
+- [OpenClaw](https://docs.mem0.ai/integrations/openclaw) [Both]: Use when wiring Mem0 into Claude Code or editors via OpenClaw.
+- [Vercel AI SDK](https://docs.mem0.ai/integrations/vercel-ai-sdk) [Both]: Use when the user is on the Vercel AI SDK.
+
+### AI Coding Tools
+- [Claude Code](https://docs.mem0.ai/integrations/claude-code) [Both]: Use when wiring memory into Claude Code.
+- [Cursor](https://docs.mem0.ai/integrations/cursor) [Both]: Use when wiring memory into Cursor.
+- [Codex](https://docs.mem0.ai/integrations/codex) [Both]: Use when wiring memory into Codex / other editor assistants.
 
 ### Voice & Real-time
-- [LiveKit](https://docs.mem0.ai/integrations/livekit): Real-time voice and video AI with persistent memory
-- [Pipecat](https://docs.mem0.ai/integrations/pipecat): Voice AI pipeline framework with memory capabilities
-- [ElevenLabs](https://docs.mem0.ai/integrations/elevenlabs): Voice synthesis integration with conversational memory
+- [LiveKit](https://docs.mem0.ai/integrations/livekit) [Both]: Use when building real-time voice/video with memory.
+- [Pipecat](https://docs.mem0.ai/integrations/pipecat) [Both]: Use when the voice pipeline is Pipecat.
+- [ElevenLabs](https://docs.mem0.ai/integrations/elevenlabs) [Both]: Use when voice synthesis uses ElevenLabs.
 
 ### Cloud & Infrastructure
-- [AWS Bedrock](https://docs.mem0.ai/integrations/aws-bedrock): Enterprise AWS integration for managed AI services
+- [AWS Bedrock](https://docs.mem0.ai/integrations/aws-bedrock) [Both]: Use when the user is on AWS Bedrock managed AI services.
 
-### Developer Tools
-- [Dify](https://docs.mem0.ai/integrations/dify): LLMOps platform integration for production AI applications
-- [Flowise](https://docs.mem0.ai/integrations/flowise): No-code LLM workflow builder with memory capabilities
-- [LangChain Tools](https://docs.mem0.ai/integrations/langchain-tools): Use Mem0 as a LangChain tool for agents
-- [AgentOps](https://docs.mem0.ai/integrations/agentops): Agent observability and monitoring with memory tracking
-- [Keywords AI](https://docs.mem0.ai/integrations/keywords): Keywords AI integration for LLM monitoring
-- [Raycast](https://docs.mem0.ai/integrations/raycast): Raycast extension for quick memory access
 
-## Cookbooks and Examples
+## Cookbooks
 
-- [Cookbooks Overview](https://docs.mem0.ai/cookbooks/overview): Complete guide to Mem0 examples and implementation patterns
+- [Cookbooks Overview](https://docs.mem0.ai/cookbooks/overview) [Both]: Use when surveying all reference examples.
 
-### Essential Guides
-- [Building AI Companion](https://docs.mem0.ai/cookbooks/essentials/building-ai-companion): Core patterns for building AI agents with memory
-- [Partition Memories by Entity](https://docs.mem0.ai/cookbooks/essentials/entity-partitioning-playbook): Keep multi-tenant assistants isolated by tagging user, agent, app, and session identifiers
-- [Controlling Memory Ingestion](https://docs.mem0.ai/cookbooks/essentials/controlling-memory-ingestion): Fine-tune what gets stored in memory and when
-- [Memory Expiration](https://docs.mem0.ai/cookbooks/essentials/memory-expiration-short-and-long-term): Implement short-term and long-term memory strategies
-- [Tagging and Organizing Memories](https://docs.mem0.ai/cookbooks/essentials/tagging-and-organizing-memories): Advanced memory organization and categorization
-- [Exporting Memories](https://docs.mem0.ai/cookbooks/essentials/exporting-memories): Backup and transfer memory data between systems
-- [Choosing Memory Architecture](https://docs.mem0.ai/cookbooks/essentials/choosing-memory-architecture-vector-vs-graph): Vector vs Graph memory architectures comparison
+### Essentials
+- [Building an AI Companion](https://docs.mem0.ai/cookbooks/essentials/building-ai-companion) [Both]: Use when starting a companion app from scratch.
+- [Partition Memories by Entity](https://docs.mem0.ai/cookbooks/essentials/entity-partitioning-playbook) [Both]: Use when isolating multi-tenant memories.
+- [Controlling Memory Ingestion](https://docs.mem0.ai/cookbooks/essentials/controlling-memory-ingestion) [Both]: Use when deciding what to store and what to skip.
+- [Tagging and Organizing Memories](https://docs.mem0.ai/cookbooks/essentials/tagging-and-organizing-memories) [Both]: Use when memory taxonomy matters.
+- [Exporting Memories](https://docs.mem0.ai/cookbooks/essentials/exporting-memories) [Both]: Use when backing up or migrating memory data.
 
-### AI Companion Examples
-- [Quickstart Demo](https://docs.mem0.ai/cookbooks/companions/quickstart-demo): Quick demo of building an AI companion with memory
-- [Node.js Companion](https://docs.mem0.ai/cookbooks/companions/nodejs-companion): JavaScript-based AI companion applications
-- [AI Tutor](https://docs.mem0.ai/cookbooks/companions/ai-tutor): Educational AI that adapts to learning progress
-- [Travel Assistant](https://docs.mem0.ai/cookbooks/companions/travel-assistant): Travel planning agent that learns preferences
-- [YouTube Research Assistant](https://docs.mem0.ai/cookbooks/companions/youtube-research): AI that researches and learns from video content
-- [Voice Companion](https://docs.mem0.ai/cookbooks/companions/voice-companion-openai): Voice-enabled AI with conversational memory
-- [Local Companion](https://docs.mem0.ai/cookbooks/companions/local-companion-ollama): Privacy-focused companion using local models
+### AI Companions
+- [Quickstart Demo](https://docs.mem0.ai/cookbooks/companions/quickstart-demo) [Both]: Use when showing the smallest end-to-end companion.
+- [Node.js Companion](https://docs.mem0.ai/cookbooks/companions/nodejs-companion) [Both]: Use when the companion is in JavaScript/TypeScript.
+- [AI Tutor](https://docs.mem0.ai/cookbooks/companions/ai-tutor) [Both]: Use when the agent adapts to a learner over time.
+- [Travel Assistant](https://docs.mem0.ai/cookbooks/companions/travel-assistant) [Both]: Use when the agent learns travel preferences.
+- [YouTube Research Assistant](https://docs.mem0.ai/cookbooks/companions/youtube-research) [Both]: Use when building an agent that ingests video content over sessions.
+- [Voice Companion (OpenAI)](https://docs.mem0.ai/cookbooks/companions/voice-companion-openai) [Both]: Use when the companion is voice-first with OpenAI Realtime.
+- [Local Companion (Ollama)](https://docs.mem0.ai/cookbooks/companions/local-companion-ollama) [OSS]: Use when the companion must run entirely on local models.
 
 ### Operations & Automation
-- [Support Inbox](https://docs.mem0.ai/cookbooks/operations/support-inbox): Customer service agents with conversation history
-- [Email Automation](https://docs.mem0.ai/cookbooks/operations/email-automation): Smart email processing with contextual memory
-- [Content Writing](https://docs.mem0.ai/cookbooks/operations/content-writing): AI writers that maintain brand voice and style
-- [Deep Research](https://docs.mem0.ai/cookbooks/operations/deep-research): Research assistants that build on previous findings
-- [Team Task Agent](https://docs.mem0.ai/cookbooks/operations/team-task-agent): Collaborative AI agents with shared project memory
+- [Support Inbox](https://docs.mem0.ai/cookbooks/operations/support-inbox) [Both]: Use when a support agent needs conversation history across tickets.
+- [Email Automation](https://docs.mem0.ai/cookbooks/operations/email-automation) [Both]: Use when processing email with contextual memory.
+- [Content Writing](https://docs.mem0.ai/cookbooks/operations/content-writing) [Both]: Use when an AI writer must maintain brand voice across sessions.
+- [Deep Research](https://docs.mem0.ai/cookbooks/operations/deep-research) [Both]: Use when research agents build on previous findings.
+- [Team Task Agent](https://docs.mem0.ai/cookbooks/operations/team-task-agent) [Both]: Use when collaborative agents share project memory.
 
 ### Integration Examples
-- [Agents SDK Tool](https://docs.mem0.ai/cookbooks/integrations/agents-sdk-tool): Using Mem0 as a tool with OpenAI Agents SDK
-- [OpenAI Tool Calls](https://docs.mem0.ai/cookbooks/integrations/openai-tool-calls): Mem0 integrated with OpenAI function calling
-- [Mastra Agent](https://docs.mem0.ai/cookbooks/integrations/mastra-agent): Mastra framework integration with memory
-- [Healthcare Google ADK](https://docs.mem0.ai/cookbooks/integrations/healthcare-google-adk): Medical AI applications with memory
-- [AWS Bedrock](https://docs.mem0.ai/cookbooks/integrations/aws-bedrock): Enterprise memory with AWS managed services
-- [Neptune Analytics](https://docs.mem0.ai/cookbooks/integrations/neptune-analytics): Graph and vector search with AWS Neptune
-- [Tavily Search](https://docs.mem0.ai/cookbooks/integrations/tavily-search): Web search with persistent memory of results
+- [Agents SDK Tool](https://docs.mem0.ai/cookbooks/integrations/agents-sdk-tool) [Platform]: Use when exposing Mem0 as a tool in OpenAI Agents SDK.
+- [OpenAI Tool Calls](https://docs.mem0.ai/cookbooks/integrations/openai-tool-calls) [Platform]: Use when hooking Mem0 into OpenAI function calling.
+- [Mastra Agent](https://docs.mem0.ai/cookbooks/integrations/mastra-agent) [Both]: Use when the agent is built in Mastra.
+- [Healthcare Google ADK](https://docs.mem0.ai/cookbooks/integrations/healthcare-google-adk) [Both]: Use when the domain is medical and the framework is Google ADK.
+- [AWS Bedrock](https://docs.mem0.ai/cookbooks/integrations/aws-bedrock) [Both]: Use when deploying with AWS managed model services.
+- [Tavily Search](https://docs.mem0.ai/cookbooks/integrations/tavily-search) [Both]: Use when the agent layers web search on memory.
 
 ### Framework Examples
-- [LlamaIndex React](https://docs.mem0.ai/cookbooks/frameworks/llamaindex-react): React applications with LlamaIndex and memory
-- [LlamaIndex Multiagent](https://docs.mem0.ai/cookbooks/frameworks/llamaindex-multiagent): Multi-agent systems with shared memory
-- [Multimodal Retrieval](https://docs.mem0.ai/cookbooks/frameworks/multimodal-retrieval): Memory systems handling text, images, and documents
-- [Eliza OS Character](https://docs.mem0.ai/cookbooks/frameworks/eliza-os-character): Character-based AI with persistent personality
-- [Chrome Extension](https://docs.mem0.ai/cookbooks/frameworks/chrome-extension): Browser extensions that remember user interactions
-- [Gemini with Mem0 MCP](https://docs.mem0.ai/cookbooks/frameworks/gemini-3-with-mem0-mcp): Google Gemini integration using MCP server
-- [Mirofish Swarm Memory](https://docs.mem0.ai/cookbooks/frameworks/mirofish-swarm-memory): Swarm-based multi-agent memory patterns
+- [LlamaIndex React](https://docs.mem0.ai/cookbooks/frameworks/llamaindex-react) [Both]: Use when building a React UI with LlamaIndex and memory.
+- [LlamaIndex Multiagent](https://docs.mem0.ai/cookbooks/frameworks/llamaindex-multiagent) [Both]: Use when running LlamaIndex multi-agent systems with shared memory.
+- [Multimodal Retrieval](https://docs.mem0.ai/cookbooks/frameworks/multimodal-retrieval) [Both]: Use when memory must handle text, images, and docs together.
+- [Eliza OS Character](https://docs.mem0.ai/cookbooks/frameworks/eliza-os-character) [Both]: Use when building a character-based agent with persistent personality.
+- [Gemini with Mem0 MCP](https://docs.mem0.ai/cookbooks/frameworks/gemini-3-with-mem0-mcp) [Platform]: Use when Gemini connects to Mem0 over MCP.
 
 ## API Reference
 
-- [API Reference Overview](https://docs.mem0.ai/api-reference): REST API overview with authentication and quick start guide
-- [Organizations & Projects](https://docs.mem0.ai/api-reference/organizations-projects): Managing organizations and projects for multi-tenant setups
+All API Reference docs describe Mem0 Platform REST endpoints (requires API key).
 
-### Core Memory APIs
-- [Add Memories](https://docs.mem0.ai/api-reference/memory/add-memories): REST API for storing new memories with detailed request/response formats
-- [Get All Memories](https://docs.mem0.ai/api-reference/memory/get-memories): Retrieve all memories with pagination and filtering options
-- [Search Memories](https://docs.mem0.ai/api-reference/memory/search-memories): Advanced search API with filtering and ranking capabilities
-- [Update Memory](https://docs.mem0.ai/api-reference/memory/update-memory): Modify existing memories with conflict resolution
-- [Delete Memory](https://docs.mem0.ai/api-reference/memory/delete-memory): Remove a specific memory by ID
+- [API Reference Overview](https://docs.mem0.ai/api-reference) [Platform]: Use when explaining authentication and the general request/response shape.
+- [Organizations & Projects](https://docs.mem0.ai/api-reference/organizations-projects) [Platform]: Use when the user needs multi-tenant isolation.
 
-### Additional Memory APIs
-- [Create Memory Export](https://docs.mem0.ai/api-reference/memory/create-memory-export): Export memories in bulk
-- [Feedback](https://docs.mem0.ai/api-reference/memory/feedback): Submit feedback on memory quality
-- [Get Memory](https://docs.mem0.ai/api-reference/memory/get-memory): Retrieve a single memory by ID
-- [Memory History](https://docs.mem0.ai/api-reference/memory/history-memory): View the history of changes to a memory
-- [Get Memory Export](https://docs.mem0.ai/api-reference/memory/get-memory-export): Retrieve a previously created memory export
-- [Batch Update](https://docs.mem0.ai/api-reference/memory/batch-update): Update multiple memories in a single request
-- [Batch Delete](https://docs.mem0.ai/api-reference/memory/batch-delete): Delete multiple memories in a single request
-- [Delete All Memories](https://docs.mem0.ai/api-reference/memory/delete-memories): Remove all memories matching criteria
+### Core Memory
+- [Add Memories](https://docs.mem0.ai/api-reference/memory/add-memories) [Platform]: Use when writing one or more memories.
+- [Get All Memories](https://docs.mem0.ai/api-reference/memory/get-memories) [Platform]: Use when paginating memories for a user/agent.
+- [Get Memory](https://docs.mem0.ai/api-reference/memory/get-memory) [Platform]: Use when fetching one memory by ID.
+- [Search Memories](https://docs.mem0.ai/api-reference/memory/search-memories) [Platform]: Use when running a semantic query with filters.
+- [Update Memory](https://docs.mem0.ai/api-reference/memory/update-memory) [Platform]: Use when editing a memory in place.
+- [Delete Memory](https://docs.mem0.ai/api-reference/memory/delete-memory) [Platform]: Use when removing one memory.
+- [Delete All Memories](https://docs.mem0.ai/api-reference/memory/delete-memories) [Platform]: Use when purging memories matching a scope.
+- [Batch Update](https://docs.mem0.ai/api-reference/memory/batch-update) [Platform]: Use when updating many memories in one call.
+- [Batch Delete](https://docs.mem0.ai/api-reference/memory/batch-delete) [Platform]: Use when deleting many memories in one call.
+- [Memory History](https://docs.mem0.ai/api-reference/memory/history-memory) [Platform]: Use when the user needs the change log for a memory.
+- [Feedback](https://docs.mem0.ai/api-reference/memory/feedback) [Platform]: Use when capturing user signals on memory quality.
+- [Create Memory Export](https://docs.mem0.ai/api-reference/memory/create-memory-export) [Platform]: Use when kicking off an async export job.
+- [Get Memory Export](https://docs.mem0.ai/api-reference/memory/get-memory-export) [Platform]: Use when fetching the result of an export job.
 
-### Events APIs
-- [Get Events](https://docs.mem0.ai/api-reference/events/get-events): List asynchronous memory operation events
-- [Get Event](https://docs.mem0.ai/api-reference/events/get-event): Retrieve details of a specific event
+### Events
+- [Get Events](https://docs.mem0.ai/api-reference/events/get-events) [Platform]: Use when listing async memory operation events.
+- [Get Event](https://docs.mem0.ai/api-reference/events/get-event) [Platform]: Use when fetching one event by ID.
 
-### Entities APIs
-- [Get Users](https://docs.mem0.ai/api-reference/entities/get-users): List all entities (users, agents, apps)
-- [Delete User](https://docs.mem0.ai/api-reference/entities/delete-user): Remove an entity and all associated memories
+### Entities
+- [Get Users](https://docs.mem0.ai/api-reference/entities/get-users) [Platform]: Use when listing users, agents, or apps known to a project.
+- [Delete User](https://docs.mem0.ai/api-reference/entities/delete-user) [Platform]: Use when removing an entity and all its memories.
 
-### Organizations APIs
-- [Create Organization](https://docs.mem0.ai/api-reference/organization/create-org): Create a new organization
-- [Get Organizations](https://docs.mem0.ai/api-reference/organization/get-orgs): List all organizations
-- [Get Organization](https://docs.mem0.ai/api-reference/organization/get-org): Retrieve organization details
-- [Get Organization Members](https://docs.mem0.ai/api-reference/organization/get-org-members): List organization members
-- [Add Organization Member](https://docs.mem0.ai/api-reference/organization/add-org-member): Add a member to an organization
-- [Delete Organization](https://docs.mem0.ai/api-reference/organization/delete-org): Remove an organization
+### Organizations
+- [Create Organization](https://docs.mem0.ai/api-reference/organization/create-org) [Platform]: Use when setting up a new org.
+- [Get Organizations](https://docs.mem0.ai/api-reference/organization/get-orgs) [Platform]: Use when listing orgs.
+- [Get Organization](https://docs.mem0.ai/api-reference/organization/get-org) [Platform]: Use when fetching one org.
+- [Get Organization Members](https://docs.mem0.ai/api-reference/organization/get-org-members) [Platform]: Use when listing org members.
+- [Add Organization Member](https://docs.mem0.ai/api-reference/organization/add-org-member) [Platform]: Use when inviting a member to an org.
+- [Delete Organization](https://docs.mem0.ai/api-reference/organization/delete-org) [Platform]: Use when removing an org.
 
-### Project APIs
-- [Create Project](https://docs.mem0.ai/api-reference/project/create-project): Create a new project within an organization
-- [Get Projects](https://docs.mem0.ai/api-reference/project/get-projects): List all projects
-- [Get Project](https://docs.mem0.ai/api-reference/project/get-project): Retrieve project details
-- [Get Project Members](https://docs.mem0.ai/api-reference/project/get-project-members): List project members
-- [Add Project Member](https://docs.mem0.ai/api-reference/project/add-project-member): Add a member to a project
-- [Delete Project](https://docs.mem0.ai/api-reference/project/delete-project): Remove a project
+### Projects
+- [Create Project](https://docs.mem0.ai/api-reference/project/create-project) [Platform]: Use when creating a project inside an org.
+- [Get Projects](https://docs.mem0.ai/api-reference/project/get-projects) [Platform]: Use when listing projects.
+- [Get Project](https://docs.mem0.ai/api-reference/project/get-project) [Platform]: Use when fetching one project.
+- [Get Project Members](https://docs.mem0.ai/api-reference/project/get-project-members) [Platform]: Use when listing project members.
+- [Add Project Member](https://docs.mem0.ai/api-reference/project/add-project-member) [Platform]: Use when inviting a member to a project.
+- [Delete Project](https://docs.mem0.ai/api-reference/project/delete-project) [Platform]: Use when removing a project.
 
-### Webhook APIs
-- [Create Webhook](https://docs.mem0.ai/api-reference/webhook/create-webhook): Register a new webhook endpoint
-- [Get Webhook](https://docs.mem0.ai/api-reference/webhook/get-webhook): Retrieve webhook configuration
-- [Update Webhook](https://docs.mem0.ai/api-reference/webhook/update-webhook): Modify webhook settings
-- [Delete Webhook](https://docs.mem0.ai/api-reference/webhook/delete-webhook): Remove a webhook
+### Webhooks
+- [Create Webhook](https://docs.mem0.ai/api-reference/webhook/create-webhook) [Platform]: Use when registering a webhook endpoint.
+- [Get Webhook](https://docs.mem0.ai/api-reference/webhook/get-webhook) [Platform]: Use when fetching webhook config.
+- [Update Webhook](https://docs.mem0.ai/api-reference/webhook/update-webhook) [Platform]: Use when modifying webhook settings.
+- [Delete Webhook](https://docs.mem0.ai/api-reference/webhook/delete-webhook) [Platform]: Use when removing a webhook.
+
+## Skills & Plugins
+
+Mem0 ships first-class integrations for AI coding editors and MCP-aware tools. When the user is in Claude Code, Cursor, Codex, or any MCP client, load this section first.
+
+### Claude Code Skills (in-repo, not on docs.mem0.ai)
+
+Source: https://github.com/mem0ai/mem0/tree/main/skills
+
+- **skills/mem0** - Default Mem0 skill. Trigger on mentions of `MemoryClient`, "memory layer", personalization, or adding long-term memory to chatbots/agents. Covers Python SDK, TS SDK, and every framework integration.
+- **skills/mem0-cli** - Trigger on CLI / terminal / shell usage of Mem0.
+- **skills/mem0-vercel-ai-sdk** - Trigger when the stack includes `@mem0/vercel-ai-provider` or `createMem0`.
+
+Each subdirectory is a Claude Code Skill (`SKILL.md` + supporting assets). Load only the one that matches the user's stack.
+
+### Editor Plugin (shared glue)
+
+Source: https://github.com/mem0ai/mem0/tree/main/mem0-plugin
+
+The `mem0-plugin/` directory provides MCP server connection, lifecycle hooks, and skill bundling for Claude Code, Cursor, and Codex. It exposes 9 MCP tools: `add_memory`, `search_memories`, `get_memories`, `get_memory`, `update_memory`, `delete_memory`, `delete_all_memories`, `delete_entities`, `list_entities`.
+
+Editor-specific setup docs (already listed above under `## Integrations > AI Coding Tools`):
+
+- `integrations/claude-code` [Both]
+- `integrations/cursor` [Both]
+- `integrations/codex` [Both]
+- `integrations/openclaw` [Both]
+
+### MCP Endpoints
+
+- Hosted MCP server: `https://mcp.mem0.ai` - requires Platform API key. See `platform/mem0-mcp`.
+- Self-hosted MCP server: ships with `openmemory/api/` (FastAPI) - runs against your own Qdrant + LLM stack.
 
 ## Community & Support
 
-- [Contributing - Development](https://docs.mem0.ai/contributing/development): Guidelines for contributing to Mem0's open-source development
-- [Contributing - Documentation](https://docs.mem0.ai/contributing/documentation): Guidelines for contributing to Mem0's documentation
-- [Changelog](https://docs.mem0.ai/changelog): Detailed product updates and version history
+- [Contributing - Development](https://docs.mem0.ai/contributing/development) [Both]: Use when the user wants to contribute code.
+- [Contributing - Documentation](https://docs.mem0.ai/contributing/documentation) [Both]: Use when the user wants to contribute docs.
+
+## Optional
+
+Everything below is OSS-only provider configuration. Skip this entire section when the user is on Mem0 Platform (providers are managed server-side). When the user is self-hosting, load only the subsection that matches the provider they are configuring.
+
+### LLM Providers [OSS]
+- [LLM Overview](https://docs.mem0.ai/components/llms/overview) [OSS]: Use when the user is choosing an LLM for memory extraction.
+- [LLM Configuration](https://docs.mem0.ai/components/llms/config) [OSS]: Use for the `llm` config schema.
+- [OpenAI](https://docs.mem0.ai/components/llms/models/openai) [OSS]: Use when the extraction LLM is OpenAI.
+- [Anthropic](https://docs.mem0.ai/components/llms/models/anthropic) [OSS]: Use when the extraction LLM is Claude.
+- [Azure OpenAI](https://docs.mem0.ai/components/llms/models/azure_openai) [OSS]: Use when the user is on Azure-hosted OpenAI.
+- [AWS Bedrock](https://docs.mem0.ai/components/llms/models/aws_bedrock) [OSS]: Use when the LLM runs through Bedrock.
+- [Google AI](https://docs.mem0.ai/components/llms/models/google_AI) [OSS]: Use when the LLM is Gemini.
+- [Groq](https://docs.mem0.ai/components/llms/models/groq) [OSS]: Use when the user wants Groq's low-latency inference.
+- [DeepSeek](https://docs.mem0.ai/components/llms/models/deepseek) [OSS]: Use when the LLM is DeepSeek.
+- [Mistral AI](https://docs.mem0.ai/components/llms/models/mistral_AI) [OSS]: Use when the LLM is Mistral.
+- [MiniMax](https://docs.mem0.ai/components/llms/models/minimax) [OSS]: Use when the LLM is MiniMax.
+- [xAI](https://docs.mem0.ai/components/llms/models/xAI) [OSS]: Use when the LLM is xAI Grok.
+- [Sarvam](https://docs.mem0.ai/components/llms/models/sarvam) [OSS]: Use for Indian-language Sarvam models.
+- [Together](https://docs.mem0.ai/components/llms/models/together) [OSS]: Use when the LLM runs on Together.
+- [Ollama](https://docs.mem0.ai/components/llms/models/ollama) [OSS]: Use when the LLM is a local Ollama model.
+- [LM Studio](https://docs.mem0.ai/components/llms/models/lmstudio) [OSS]: Use when the LLM is served from LM Studio.
+- [LiteLLM](https://docs.mem0.ai/components/llms/models/litellm) [OSS]: Use when multiplexing many providers behind LiteLLM.
+- [vLLM](https://docs.mem0.ai/components/llms/models/vllm) [OSS]: Use when self-hosting inference with vLLM.
+- [LangChain LLM](https://docs.mem0.ai/components/llms/models/langchain) [OSS]: Use when the LLM is wrapped behind a LangChain adapter.
+
+### Embedding Providers [OSS]
+- [Embeddings Overview](https://docs.mem0.ai/components/embedders/overview) [OSS]: Use when choosing an embedding model.
+- [Embeddings Configuration](https://docs.mem0.ai/components/embedders/config) [OSS]: Use for the `embedder` config schema.
+- [OpenAI Embeddings](https://docs.mem0.ai/components/embedders/models/openai) [OSS]: Use when embeddings come from OpenAI.
+- [Azure OpenAI Embeddings](https://docs.mem0.ai/components/embedders/models/azure_openai) [OSS]: Use for Azure-hosted OpenAI embeddings.
+- [AWS Bedrock Embeddings](https://docs.mem0.ai/components/embedders/models/aws_bedrock) [OSS]: Use for Bedrock-hosted embeddings.
+- [Google AI Embeddings](https://docs.mem0.ai/components/embedders/models/google_AI) [OSS]: Use for Gemini embeddings.
+- [Vertex AI Embeddings](https://docs.mem0.ai/components/embedders/models/vertexai) [OSS]: Use for Google Cloud Vertex AI embeddings.
+- [Hugging Face Embeddings](https://docs.mem0.ai/components/embedders/models/huggingface) [OSS]: Use for open-source HF embedding models.
+- [Ollama Embeddings](https://docs.mem0.ai/components/embedders/models/ollama) [OSS]: Use when embeddings run through local Ollama.
+- [LM Studio Embeddings](https://docs.mem0.ai/components/embedders/models/lmstudio) [OSS]: Use when embeddings run through LM Studio.
+- [Together Embeddings](https://docs.mem0.ai/components/embedders/models/together) [OSS]: Use when embeddings run on Together.
+- [LangChain Embeddings](https://docs.mem0.ai/components/embedders/models/langchain) [OSS]: Use when embeddings are wrapped behind a LangChain adapter.
+
+### Vector Databases [OSS]
+- [Vector Database Overview](https://docs.mem0.ai/components/vectordbs/overview) [OSS]: Use when choosing a vector store.
+- [Vector Database Configuration](https://docs.mem0.ai/components/vectordbs/config) [OSS]: Use for the `vector_store` config schema.
+- [Qdrant](https://docs.mem0.ai/components/vectordbs/dbs/qdrant) [OSS]: Use as the default self-hosted vector store (best-tested).
+- [Chroma](https://docs.mem0.ai/components/vectordbs/dbs/chroma) [OSS]: Use when the user wants a lightweight embedded store.
+- [PGVector](https://docs.mem0.ai/components/vectordbs/dbs/pgvector) [OSS]: Use when Postgres is already in the stack.
+- [Milvus](https://docs.mem0.ai/components/vectordbs/dbs/milvus) [OSS]: Use for large-scale Milvus deployments.
+- [Pinecone](https://docs.mem0.ai/components/vectordbs/dbs/pinecone) [OSS]: Use when the user is on Pinecone managed.
+- [MongoDB](https://docs.mem0.ai/components/vectordbs/dbs/mongodb) [OSS]: Use when Mongo Atlas Vector Search is the backing store.
+- [Azure AI Search](https://docs.mem0.ai/components/vectordbs/dbs/azure) [OSS]: Use when the user is on Azure AI Search.
+- [Azure MySQL](https://docs.mem0.ai/components/vectordbs/dbs/azure_mysql) [OSS]: Use when vector search runs on Azure Database for MySQL.
+- [Redis](https://docs.mem0.ai/components/vectordbs/dbs/redis) [OSS]: Use when Redis Stack is the backing store.
+- [Valkey](https://docs.mem0.ai/components/vectordbs/dbs/valkey) [OSS]: Use when the user is on Valkey (Redis fork).
+- [Elasticsearch](https://docs.mem0.ai/components/vectordbs/dbs/elasticsearch) [OSS]: Use when Elasticsearch is the backing store.
+- [OpenSearch](https://docs.mem0.ai/components/vectordbs/dbs/opensearch) [OSS]: Use when OpenSearch is the backing store.
+- [Supabase](https://docs.mem0.ai/components/vectordbs/dbs/supabase) [OSS]: Use when Supabase with pgvector is the backing store.
+- [Upstash Vector](https://docs.mem0.ai/components/vectordbs/dbs/upstash-vector) [OSS]: Use for serverless Upstash Vector.
+- [Vectorize](https://docs.mem0.ai/components/vectordbs/dbs/vectorize) [OSS]: Use when the store is Cloudflare Vectorize.
+- [Vertex AI Vector Search](https://docs.mem0.ai/components/vectordbs/dbs/vertex_ai) [OSS]: Use when the store is Google Cloud Vertex Vector Search.
+- [Weaviate](https://docs.mem0.ai/components/vectordbs/dbs/weaviate) [OSS]: Use when Weaviate is the backing store.
+- [FAISS](https://docs.mem0.ai/components/vectordbs/dbs/faiss) [OSS]: Use for local FAISS-based similarity search.
+- [LangChain Vector Store](https://docs.mem0.ai/components/vectordbs/dbs/langchain) [OSS]: Use when the vector store is wrapped behind LangChain.
+- [Baidu](https://docs.mem0.ai/components/vectordbs/dbs/baidu) [OSS]: Use when the user is on Baidu Cloud vector service.
+- [Cassandra](https://docs.mem0.ai/components/vectordbs/dbs/cassandra) [OSS]: Use when Cassandra is the backing store.
+- [S3 Vectors](https://docs.mem0.ai/components/vectordbs/dbs/s3_vectors) [OSS]: Use for AWS S3 Vectors.
+- [Databricks](https://docs.mem0.ai/components/vectordbs/dbs/databricks) [OSS]: Use when the user is on Databricks with Delta Lake.
+- [Neptune Analytics](https://docs.mem0.ai/components/vectordbs/dbs/neptune_analytics) [OSS]: Use when the user is on AWS Neptune Analytics (graph + vector).
+- [Turbopuffer](https://docs.mem0.ai/components/vectordbs/dbs/turbopuffer) [OSS]: Use when the user is on Turbopuffer serverless.
+
+### Rerankers [OSS]
+- [Reranker Overview](https://docs.mem0.ai/components/rerankers/overview) [OSS]: Use when the user wants to improve OSS search result quality.
+- [Reranker Configuration](https://docs.mem0.ai/components/rerankers/config) [OSS]: Use for the `reranker` config schema.
+- [Reranker Optimization](https://docs.mem0.ai/components/rerankers/optimization) [OSS]: Use when tuning reranker performance.
+- [Custom Reranker Prompts](https://docs.mem0.ai/components/rerankers/custom-prompts) [OSS]: Use when rewriting reranker prompts.
+- [Cohere Reranker](https://docs.mem0.ai/components/rerankers/models/cohere) [OSS]: Use for Cohere Rerank.
+- [Sentence Transformer Reranker](https://docs.mem0.ai/components/rerankers/models/sentence_transformer) [OSS]: Use for local cross-encoder rerankers.
+- [Hugging Face Reranker](https://docs.mem0.ai/components/rerankers/models/huggingface) [OSS]: Use for HF-hosted reranker models.
+- [LLM Reranker (prompt)](https://docs.mem0.ai/components/rerankers/models/llm) [OSS]: Use when the reranker is a prompted LLM (config guide).
+- [LLM Reranker](https://docs.mem0.ai/components/rerankers/models/llm_reranker) [OSS]: Use when the reranker is a prompted LLM (implementation reference).
+- [Zero Entropy Reranker](https://docs.mem0.ai/components/rerankers/models/zero_entropy) [OSS]: Use for the Zero Entropy reranker.

docs/migration/oss-v2-to-v3.mdx

@@ -0,0 +1,538 @@
+---
+title: "Open Source: Migrating to the New Memory Algorithm"
+description: "Guide for self-hosted Mem0 users to upgrade to the new memory algorithm with ADD-only extraction, hybrid search, and entity linking."
+icon: "arrow-right"
+iconType: "solid"
+---
+
+<Warning>
+**Breaking changes ahead.** This release includes renamed parameters, removed parameters, changed defaults, and a fundamentally different extraction model. Read this guide before upgrading.
+</Warning>
+
+## Overview
+
+The new Mem0 release redesigns both extraction and retrieval, and cleans up the SDK surface across Python and TypeScript:
+
+- **Extraction**: Single-pass ADD-only (one LLM call, no UPDATE/DELETE)
+- **Retrieval**: Multi-signal hybrid search (semantic + BM25 keyword + entity matching)
+- **Entity linking**: Automatic entity extraction and cross-memory linking
+- **SDK cleanup**: Deprecated parameters removed, naming conventions standardized
+- **API surface aligned with Platform**: Entity IDs now follow the same convention across OSS and Platform — top-level kwargs for `add()` / `delete_all()`, inside `filters` for `search()` / `get_all()`
+
+These changes produce a **+20 point improvement on LoCoMo** (71.4 → 91.6) and **+26 point improvement on LongMemEval** (67.8 → 93.4), while cutting extraction latency roughly in half.
+
+## Breaking Changes
+
+### Python Open Source
+
+| Change | Old | New | Migration |
+|---|---|---|---|
+| `search()` / `get_all()` entity IDs | Top-level kwargs (`user_id="..."`) | Inside `filters` dict | `m.search("q", filters={"user_id": "..."})` — top-level kwargs now raise `ValueError` |
+| `top_k` default | `100` | `20` | Pass `top_k=100` explicitly to restore |
+| `threshold` default | `None` (no filtering) | `0.1` (filters low-relevance) | Pass `threshold=0.0` for old behavior |
+| `threshold` validation | Any float | Must be in `[0, 1]` | Out-of-range values now raise `ValueError` |
+| `rerank` default | `True` | `False` | Pass `rerank=True` to restore |
+| Entity ID validation | Accepted any string | Trimmed; empty / whitespace-only rejected (`ValueError`) | Pass a non-empty identifier without internal spaces |
+| `messages` in `add()` | Could be `None` | Must be `str` / `dict` / `list[dict]` — other types raise `Mem0ValidationError` (code `VALIDATION_003`) | Always pass a string, dict, or list of messages |
+| `add()` events | Returns `ADD`, `UPDATE`, `DELETE` | Returns `ADD` only | Update code expecting UPDATE/DELETE |
+| Custom extraction prompt | `custom_fact_extraction_prompt` | `custom_instructions` | Rename in config |
+| Custom update prompt | `custom_update_memory_prompt` | Deprecated | Use `custom_instructions` instead |
+| Graph memory | `enable_graph` + `graph_store` in config | Removed | Graph store support has been removed entirely |
+| Qdrant client | `>=1.9.1` | `>=1.12.0` | Update dependency |
+| Upstash client | `>=0.1.0` | `>=0.6.0` | Update dependency |
+
+### TypeScript Open Source
+
+| Change | Old | New | Migration |
+|---|---|---|---|
+| Search parameter | `search(query, { limit: 10 })` | `search(query, { topK: 10 })` | Rename `limit` → `topK` |
+| `topK` default | `100` | `20` | Pass `topK: 100` explicitly to restore |
+| `search()` / `getAll()` entity IDs | Top-level options (`userId: "..."`) | Inside `filters` object | `m.search("q", { filters: { userId: "..." } })` |
+| `threshold` validation | Any number | Must be in `[0, 1]` | Out-of-range values now throw |
+| Entity ID validation | Any string | Trimmed; empty / whitespace-only rejected | Pass non-empty identifiers without internal spaces |
+| `messages` in `add()` | Could be `null` / `undefined` | Required — throws on null/undefined | Always pass a string or array |
+| Payload key for lemmatized text | `text_lemmatized` (snake_case) | `textLemmatized` (camelCase) | TS-only internal field. If you share a vector store collection between Python and TS SDKs, lemma-based BM25 will not resolve across languages — keep collections language-scoped. |
+| Custom prompt | `customPrompt` | `customInstructions` | Rename in config |
+| Graph memory | `enableGraph` + `graphStore` in config | Removed | Graph store support has been removed entirely |
+| Default graph config | Neo4j default config applied | No default graph config | Graph store config is no longer used |
+
+### Python Client SDK
+
+| Change | Old | New | Migration |
+|---|---|---|---|
+| Constructor | `MemoryClient(api_key, org_id, project_id)` | `MemoryClient(api_key)` | Remove `org_id`, `project_id` from constructor |
+| Method options | `client.add(messages, **kwargs)` | `client.add(messages, options=AddMemoryOptions(...))` | Use typed option classes (or `**kwargs` still works) |
+| Removed params | `api_version`, `output_format`, `async_mode`, `filter_memories`, `expiration_date`, `keyword_search`, `force_add_only`, `batch_size`, `immutable`, `includes`, `excludes`, `enable_graph`, `org_name`, `project_name` | — | Remove from all calls |
+
+### TypeScript Client SDK
+
+| Change | Old | New | Migration |
+|---|---|---|---|
+| Constructor | `new MemoryClient({ apiKey, organizationId, projectId })` | `new MemoryClient({ apiKey })` | Remove `organizationId`, `projectId`, `organizationName`, `projectName` |
+| All params | snake_case: `user_id`, `agent_id`, `top_k` | camelCase: `userId`, `agentId`, `topK` | Rename all params to camelCase |
+| Removed params | `api_version`, `output_format`, `async_mode`, `enable_graph`, `org_id`, `project_id`, `org_name`, `project_name`, `filter_memories`, `batch_size`, `force_add_only`, `immutable`, `expiration_date`, `includes`, `excludes`, `keyword_search` | — | Remove from all calls |
+| Output format enum | `OutputFormat.V1`, `OutputFormat.V1_1` | Removed | v1.1 is now always used |
+| API version enum | `API_VERSION.V1`, `API_VERSION.V2` | Removed | Handled internally |
+
+## Step-by-Step Migration
+
+### 1. Update Installation
+
+<Tabs>
+  <Tab title="Python">
+    ```bash
+    # Basic upgrade
+    pip install --upgrade mem0ai
+
+    # For hybrid search + entity extraction (recommended)
+    pip install --upgrade "mem0ai[nlp]"
+    python -m spacy download en_core_web_sm
+
+    # Qdrant users: also install fastembed to enable BM25 keyword search
+    pip install fastembed
+    ```
+
+    <Info>
+    **Supported Python versions for `[nlp]` extras: 3.10 – 3.12.** spaCy and its `blis` / `thinc` dependencies do not yet ship prebuilt wheels for Python 3.13, so installs on 3.13 will fail at build time. Use Python 3.12 (or older) for the `[nlp]` extras until upstream support lands. The base `mem0ai` package works on all supported Python versions; only the NLP extras are constrained.
+    </Info>
+  </Tab>
+  <Tab title="TypeScript">
+    ```bash
+    npm install mem0ai@latest
+    ```
+  </Tab>
+</Tabs>
+
+<Info>
+The Python `[nlp]` extra installs [spaCy](https://spacy.io/) for entity extraction and keyword lemmatization. Without it, Mem0 still works but falls back to semantic-only search (no entity linking, no BM25 lemmatization).
+</Info>
+
+<Warning>
+**Qdrant users — install `fastembed` to enable BM25 keyword search.** The Qdrant backend uses [fastembed](https://github.com/qdrant/fastembed) to encode sparse (BM25) vectors alongside dense vectors in the same collection. Without it, BM25 is silently disabled and search falls back to semantic-only — you'll see a log warning `"fastembed not installed — BM25 keyword search disabled"` on the first search call. Other vector stores use their native full-text capabilities and don't need `fastembed`.
+
+```bash
+pip install fastembed
+```
+</Warning>
+
+### 2. Update Configuration
+
+<Tabs>
+  <Tab title="Python OSS">
+    ```python
+    # Before
+    config = {
+        "custom_fact_extraction_prompt": "Focus on user preferences",  # [REMOVED] Renamed
+        "custom_update_memory_prompt": "Be concise when updating",      # [REMOVED] Deprecated
+        "graph_store": {
+            "provider": "neo4j",
+            "config": { "url": "...", "username": "...", "password": "..." }
+        },
+        "enable_graph": True,  # [REMOVED] Removed
+    }
+
+    # After
+    config = {
+        "custom_instructions": "Focus on user preferences",  # [OK] New name
+        # custom_update_memory_prompt removed — use custom_instructions
+        # enable_graph and graph_store removed — graph store support has been removed
+    }
+    ```
+  </Tab>
+  <Tab title="TypeScript OSS">
+    ```typescript
+    // Before
+    const config = {
+      customPrompt: "Focus on user preferences",  // [REMOVED] Renamed
+      enableGraph: true,                            // [REMOVED] Removed
+      graphStore: {
+        provider: "neo4j",
+        config: { url: "...", username: "...", password: "..." }
+      }
+    };
+
+    // After
+    const config = {
+      customInstructions: "Focus on user preferences",  // [OK] New name
+      // enableGraph and graphStore removed — graph store support has been removed
+    };
+    ```
+  </Tab>
+</Tabs>
+
+### 3. Update Search Calls
+
+<Tabs>
+  <Tab title="Python OSS">
+    ```python
+    # Before — entity IDs as top-level kwargs
+    results = m.search(
+        "what meetings did I attend?",
+        user_id="alice",
+        top_k=20
+    )
+    for r in results:
+        print(r["score"])  # Was raw cosine similarity
+
+    # After — entity IDs go inside `filters` (matches Platform API)
+    results = m.search(
+        "what meetings did I attend?",
+        filters={"user_id": "alice"},   # [REMOVED top-level kwarg, use filters]
+        top_k=20,           # New default is 20 (was 100)
+        threshold=0.1,      # New default (pass 0.0 to disable)
+        rerank=False         # New default (pass True to restore)
+    )
+    for r in results:
+        print(r["score"])
+    ```
+
+    <Warning>
+    Passing `user_id`, `agent_id`, or `run_id` as a top-level kwarg to `search()` or `get_all()` now raises `ValueError`. They must be inside the `filters` dict. The change aligns the OSS SDK with the Platform API contract.
+    </Warning>
+  </Tab>
+  <Tab title="TypeScript OSS">
+    ```typescript
+    // Before — entity IDs as top-level options
+    const results = await m.search("what meetings did I attend?", {
+      userId: "alice",
+      limit: 20          // [REMOVED] Renamed to 'topK' for consistency
+    });
+
+    // After — entity IDs go inside `filters` (matches Platform API)
+    const results = await m.search("what meetings did I attend?", {
+      filters: { userId: "alice" },   // [REMOVED top-level option, use filters]
+      topK: 20                        // [OK] Renamed from 'limit'
+    });
+    ```
+  </Tab>
+  <Tab title="Python Client SDK">
+    ```python
+    from mem0 import MemoryClient
+    from mem0.client.types import SearchMemoryOptions
+
+    # Before
+    client = MemoryClient(api_key="...", org_id="org-1", project_id="proj-1")
+    results = client.search("query", user_id="alice", top_k=20, enable_graph=True)
+
+    # After
+    client = MemoryClient(api_key="...")  # org_id, project_id removed
+    results = client.search(
+        "query",
+        options=SearchMemoryOptions(
+            filters={"user_id": "alice"},
+            top_k=20
+        )
+    )
+    ```
+  </Tab>
+  <Tab title="TypeScript Client SDK">
+    ```typescript
+    // Before
+    const client = new MemoryClient({
+      apiKey: "...",
+      organizationId: "org-1",  // [REMOVED] Removed
+      projectId: "proj-1"       // [REMOVED] Removed
+    });
+    const results = await client.search("query", {
+      user_id: "alice",         // [REMOVED] snake_case
+      top_k: 20,                // [REMOVED] snake_case
+      enable_graph: true        // [REMOVED] Removed
+    });
+
+    // After
+    const client = new MemoryClient({ apiKey: "..." });
+    const results = await client.search("query", {
+      filters: { userId: "alice" },
+      topK: 20
+    });
+    ```
+  </Tab>
+</Tabs>
+
+### 4. Update Add Calls
+
+<Tabs>
+  <Tab title="Python OSS">
+    ```python
+    # Before — could return ADD, UPDATE, DELETE events
+    result = m.add("I love hiking and my dog's name is Max", user_id="alice")
+    for item in result["results"]:
+        if item["event"] == "ADD":
+            print("New memory:", item["memory"])
+        elif item["event"] == "UPDATE":
+            print("Updated:", item["memory"])     # [REMOVED] No longer returned
+        elif item["event"] == "DELETE":
+            print("Deleted:", item["memory"])      # [REMOVED] No longer returned
+
+    # After — only ADD events
+    result = m.add("I love hiking and my dog's name is Max", user_id="alice")
+    for item in result["results"]:
+        print("New memory:", item["memory"])  # Only ADD events
+    ```
+  </Tab>
+  <Tab title="Python Client SDK">
+    ```python
+    from mem0.client.types import AddMemoryOptions
+
+    # Before
+    client.add(messages, user_id="alice", async_mode=True, output_format="v1.1")
+
+    # After — async_mode and output_format removed (async by default, v1.1 always)
+    client.add(
+        messages,
+        options=AddMemoryOptions(user_id="alice")
+    )
+    # Or using **kwargs
+    client.add(messages, user_id="alice")
+    ```
+  </Tab>
+  <Tab title="TypeScript Client SDK">
+    ```typescript
+    // Before
+    await client.add(messages, {
+      user_id: "alice",       // [REMOVED] snake_case
+      async_mode: true,       // [REMOVED] Removed
+      output_format: "v1.1",  // [REMOVED] Removed
+      enable_graph: true      // [REMOVED] Removed
+    });
+
+    // After
+    await client.add(messages, {
+      userId: "alice"         // [OK] camelCase
+    });
+    ```
+  </Tab>
+</Tabs>
+
+<Tip>
+The ADD-only model means memories accumulate over time. When information changes, the new fact is stored alongside the old one. Retrieval handles ranking — the most relevant, current information surfaces first.
+</Tip>
+
+### 5. Update Vector Store Dependencies
+
+If you're using Qdrant or Upstash, update your client libraries:
+
+```bash
+# Qdrant users
+pip install "qdrant-client>=1.12.0"
+
+# Upstash users
+pip install "upstash-vector>=0.6.0"
+```
+
+### 6. Entity Store Setup
+
+The new algorithm automatically creates a parallel entity store collection named `{your_collection}_entities`. No manual setup is required — it's created on first use.
+
+<Warning>
+Make sure your vector store user/credentials have permission to create new collections. If you're using a managed vector database with restricted permissions, pre-create the `{collection_name}_entities` collection with the same embedding dimensions as your main collection.
+</Warning>
+
+## Graph Memory → Entity Linking
+
+Graph store support has been removed from the open-source SDK. It is replaced by **built-in entity linking**, which runs natively with no external dependencies.
+
+**What was removed:**
+- `enable_graph` / `enableGraph` config flag
+- `graph_store` / `graphStore` configuration block (Neo4j, Memgraph, Kuzu, Apache AGE, Neptune)
+- All graph memory code paths (~4000 lines)
+
+**What replaces it:**
+
+Entity linking extracts entities (proper nouns, quoted text, compound noun phrases) from every memory during the add pipeline and stores them in a parallel collection (`{collection}_entities`) inside your existing vector store. At search time, entities from the query are matched against this collection and used to boost relevant memories. The boost is folded into the combined `score` on each result.
+
+**Migration:**
+- Remove `enable_graph` / `enableGraph` from your config
+- Remove the `graph_store` / `graphStore` block — it is no longer read
+- Uninstall graph drivers (neo4j, memgraph, etc.) if you were using them only for Mem0
+- No data migration is required. Entity linking activates automatically on the next `add()` call.
+
+<Warning>
+Graph relationships exposed via the old `relations` field on search results are no longer populated. Entity relationships are consumed indirectly through retrieval ranking, not exposed as a queryable graph structure. If your application depended on traversing graph relationships directly, you will need to redesign that part against the new API.
+</Warning>
+
+## How the New Algorithm Works
+
+### Extraction: Single-Pass ADD-Only
+
+```
+Input conversation
+    → Retrieve top-10 related existing memories (for deduplication context)
+    → Single LLM call: extract all distinct new facts
+    → Batch embed extracted memories
+    → Hash-based deduplication (MD5, prevents exact duplicates)
+    → Batch insert into vector store
+    → Entity extraction + linking
+```
+
+The previous algorithm used two LLM calls — one to extract candidate facts, one to decide ADD/UPDATE/DELETE actions against existing memories. The new algorithm collapses this into a single call that only adds. The model spends its capacity on understanding the input rather than diffing against existing state.
+
+### Retrieval: Multi-Signal Hybrid Search
+
+```
+Query
+    → Preprocess (lemmatize keywords, extract entities)
+    → Parallel scoring:
+        1. Semantic search (vector similarity)
+        2. BM25 keyword search (normalized term matching)
+        3. Entity matching (entity graph boost)
+    → Score fusion → Top-K selection
+```
+
+**Scoring:** The three signals are normalized and fused into a single combined `score` per result. The fusion adapts based on which signals are available at runtime (semantic-only, semantic + BM25, or all three when spaCy + the entity store are active).
+
+**BM25 is a boost signal, not a recall expander.** Only semantic search results are candidates — BM25 and entity scores boost ranking but don't add new candidates.
+
+## Vector Store Compatibility
+
+All 15 supported vector stores have been enhanced with two new capabilities:
+
+| Capability | Purpose | Fallback if Unsupported |
+|---|---|---|
+| `keyword_search()` | BM25/full-text keyword matching | Falls back to semantic-only search |
+| `search_batch()` | Batch search for entity matching | Falls back to sequential search |
+
+**Qdrant-specific changes:**
+- Now uses sparse vectors (BM25) alongside dense vectors in the same collection
+- Requires `fastembed` library for BM25 encoding (lazy-loaded, gracefully degrades)
+- Install: `pip install fastembed`
+
+**All other vector stores:**
+- Enhanced with `keyword_search()` methods using their native full-text capabilities
+- No additional dependencies required
+
+## Graceful Degradation
+
+The new features degrade gracefully when optional dependencies are missing:
+
+| Missing Dependency | Impact | Search Still Works? |
+|---|---|---|
+| spaCy (`mem0ai[nlp]`) | No entity extraction, no BM25 lemmatization | Yes (semantic-only) |
+| `fastembed` (Qdrant) | No BM25 keyword search | Yes (semantic + entity) |
+| Entity store unavailable | No entity boosting | Yes (semantic + BM25) |
+
+You always get semantic search. Hybrid search features layer on top when available.
+
+## Removed Parameters Reference
+
+These parameters have been removed across all SDKs. Remove them from your code:
+
+### Python Client SDK — Removed parameters
+
+**Constructor:** `org_id`, `project_id`
+
+**All methods:** `api_version`, `output_format`, `async_mode`, `org_name`, `project_name`, `org_id`, `project_id`
+
+**add():** `enable_graph`, `immutable`, `expiration_date`, `filter_memories`, `batch_size`, `force_add_only`, `includes`, `excludes`, `keyword_search`
+
+**search():** `enable_graph`
+
+**get_all():** `enable_graph`
+
+**project.update():** `enable_graph`
+
+### TypeScript Client SDK — Removed parameters
+
+**Constructor:** `organizationId`, `projectId`, `organizationName`, `projectName`
+
+**All methods:** `OutputFormat` enum, `API_VERSION` enum
+
+**add():** `enable_graph` / `enableGraph`, `async_mode` / `asyncMode`, `output_format` / `outputFormat`, `immutable`, `expiration_date` / `expirationDate`, `filter_memories` / `filterMemories`, `batch_size` / `batchSize`, `force_add_only` / `forceAddOnly`, `includes`, `excludes`, `keyword_search` / `keywordSearch`
+
+**search():** `enable_graph` / `enableGraph`
+
+**get_all():** `enable_graph` / `enableGraph`
+
+### Python OSS — Removed/renamed parameters
+
+**Config:** `custom_fact_extraction_prompt` → renamed to `custom_instructions`
+
+**Config:** `custom_update_memory_prompt` → deprecated, use `custom_instructions`
+
+**Config:** `enable_graph` + `graph_store` → removed (graph store support removed entirely)
+
+### TypeScript OSS — Removed/renamed parameters
+
+**Config:** `customPrompt` → renamed to `customInstructions`
+
+**Config:** `enableGraph` + `graphStore` → removed (graph store support removed entirely)
+
+**search():** `limit` → renamed to `topK`
+
+## Common Issues
+
+### TypeScript: `limit` is not a valid parameter
+
+The `limit` parameter has been renamed to `topK` in the TypeScript OSS:
+
+```typescript
+// Before
+const results = await m.search("query", { userId: "alice", limit: 20 });
+
+// After
+const results = await m.search("query", { filters: { userId: "alice" }, topK: 20 });
+```
+
+### TypeScript Client: snake_case params no longer work
+
+All TypeScript Client SDK parameters now use camelCase. The SDK handles conversion to/from the API automatically:
+
+```typescript
+// Before
+await client.search("query", { user_id: "alice", top_k: 20 });
+
+// After
+await client.search("query", { filters: { userId: "alice" }, topK: 20 });
+```
+
+### `ValueError: Top-level entity parameters not supported in search() / get_all()`
+
+`search()` and `get_all()` now require entity IDs inside `filters`. Top-level kwargs raise `ValueError`. This aligns the OSS SDK with the Platform API.
+
+```python
+# Before
+results = m.search("query", user_id="alice", top_k=20)
+
+# After
+results = m.search("query", filters={"user_id": "alice"}, top_k=20)
+```
+
+`add()` and `delete_all()` continue to accept entity IDs as top-level kwargs.
+
+### Search returns fewer results than before
+
+The default `threshold` changed from `None` to `0.1`. Low-relevance results that were previously included are now filtered out. To restore the old behavior:
+
+```python
+results = m.search("query", filters={"user_id": "alice"}, threshold=0.0)
+```
+
+### spaCy model not found
+
+If you see errors about missing spaCy models, download the required model:
+
+```bash
+python -m spacy download en_core_web_sm
+```
+
+If spaCy is not installed at all, install the NLP extras:
+
+```bash
+pip install "mem0ai[nlp]"
+```
+
+### Entity store collection creation fails
+
+The entity store tries to create a `{collection_name}_entities` collection automatically. If your vector database has restricted permissions, pre-create this collection with the same embedding dimensions as your main collection.
+
+### Score values are different from before
+
+The top-level `score` still ranges `[0, 1]`, but it is computed differently in v3. Relative ranking between results stays comparable, but absolute numbers shift — retune any hard thresholds in your app against representative queries.
+
+If you need the raw cosine similarity for a specific use case, run an unboosted vector query directly against your vector store via `vector_store.search(...)`.
+
+## Need Help?
+
+- Join our [Discord community](https://mem0.ai/discord) for real-time support
+- Open an issue on [GitHub](https://github.com/mem0ai/mem0/issues)
+- Check the [evaluation docs](/core-concepts/memory-evaluation) to benchmark the new algorithm on your data

docs/migration/platform-v2-to-v3.mdx

@@ -0,0 +1,328 @@
+---
+title: "Platform: Migrating to the New Memory Algorithm"
+description: "Guide for Mem0 Platform users to adopt the new memory algorithm with single-pass extraction, entity linking, and multi-signal retrieval."
+icon: "arrow-right"
+iconType: "solid"
+---
+
+<Info>
+**No action required for most users.** The new algorithm is rolling out automatically to all Mem0 Platform projects. This guide covers what changed, what to expect, and how to take full advantage of the new capabilities.
+</Info>
+
+## Overview
+
+The new Mem0 memory algorithm is a ground-up redesign of how memories are extracted, stored, and retrieved. It scores **91.6 on LoCoMo** and **93.4 on LongMemEval** — a +20 and +26 point improvement over the previous algorithm — while cutting extraction latency roughly in half.
+
+| What Changed | Before | After |
+|---|---|---|
+| **Extraction** | Two LLM passes (extract + merge) | Single-pass ADD-only (one LLM call) |
+| **Memory mutations** | ADD, UPDATE, DELETE | ADD only — nothing is overwritten or deleted |
+| **Agent-generated facts** | Often ignored | First-class, stored with equal weight |
+| **Entity linking** | Not available | Entities extracted and linked across memories |
+| **Graph memory** | Separate graph store + dashboard visualization | Replaced by built-in entity linking, no graph visuals on platform dashboard |
+| **Retrieval** | Semantic (vector) only | Hybrid retrieval combining multiple signals |
+
+## What This Means for Your Application
+
+### Memories accumulate instead of being overwritten
+
+The previous algorithm could UPDATE or DELETE existing memories during extraction. The new algorithm only adds new facts. When information changes (e.g., a user moves from New York to San Francisco), both facts are preserved with temporal context. This means:
+
+- **More memories over time** — your memory count will grow rather than plateau
+- **Better temporal reasoning** — the system can distinguish "used to live in New York" from "now lives in San Francisco"
+- **No information loss** — facts that seemed contradictory but were actually complementary are preserved
+
+<Tip>
+If your application previously relied on UPDATE/DELETE behavior to keep memory counts low, the new algorithm handles this at retrieval time instead. Multi-signal retrieval ranks the most relevant, current information higher without destroying historical context.
+</Tip>
+
+### Agent-generated facts are now captured
+
+Previously, when an agent said something like "I've booked your flight for March 3rd," the system would often ignore it and only store what the user explicitly stated. The new algorithm treats agent-generated facts as first-class memories. If your application involves agents that confirm actions, provide recommendations, or share information, you'll see significantly better recall on those interactions.
+
+### Retrieval is hybrid now
+
+Search now uses hybrid retrieval, which improves ranking quality — especially for queries involving exact keywords, proper nouns, or entities that appear across multiple memories. The response shape is unchanged:
+
+```json
+{
+  "results": [
+    {
+      "id": "mem-uuid",
+      "memory": "User moved to San Francisco in January 2026",
+      "score": 0.82,
+      "metadata": {},
+      "categories": ["location"]
+    }
+  ]
+}
+```
+
+The top-level `score` remains a `[0, 1]` value. Relative ranking between results stays comparable to v2, but absolute numbers shift since the scoring method changed — retune any hard thresholds in your app against representative queries.
+
+## API Changes
+
+### New V3 Endpoints
+
+The new algorithm is available through the V3 API. The endpoints split into per-operation paths:
+
+| Operation | SDK method | Endpoint |
+|---|---|---|
+| Add memories | `client.add()` | `POST /v3/memories/add/` |
+| Search memories | `client.search()` | `POST /v3/memories/search/` |
+| Get all memories (paginated) | `client.get_all()` | `POST /v3/memories/` |
+
+<Info>
+`get_all` / list now returns a paginated envelope: `{"count": int, "next": str | null, "previous": str | null, "results": [...]}`. Pass `page` and `page_size` as query params to paginate; defaults return the first page.
+</Info>
+
+<CodeGroup>
+```python Python
+from mem0 import MemoryClient
+
+client = MemoryClient(api_key="your-api-key")
+
+# Add memories (same interface, improved extraction)
+result = client.add(
+    messages=[
+        {"role": "user", "content": "I just moved to San Francisco from New York"},
+        {"role": "assistant", "content": "That's exciting! I'll update your location preferences."}
+    ],
+    user_id="alice"
+)
+
+# Search with multi-signal retrieval
+results = client.search(
+    query="where does the user live?",
+    filters={"user_id": "alice"}
+)
+
+# List memories (paginated)
+page = client.get_all(filters={"user_id": "alice"}, page=1, page_size=50)
+# page == {"count": 123, "next": "...", "previous": None, "results": [...]}
+```
+
+```bash cURL
+# Add memories
+curl -X POST https://api.mem0.ai/v3/memories/add/ \
+  -H "Authorization: Token your-api-key" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "messages": [
+      {"role": "user", "content": "I just moved to San Francisco from New York"},
+      {"role": "assistant", "content": "That'\''s exciting! I'\''ll update your location preferences."}
+    ],
+    "user_id": "alice"
+  }'
+
+# Search memories
+curl -X POST https://api.mem0.ai/v3/memories/search/ \
+  -H "Authorization: Token your-api-key" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "query": "where does the user live?",
+    "filters": {"user_id": "alice"}
+  }'
+
+# List memories (paginated)
+curl -X POST 'https://api.mem0.ai/v3/memories/?page=1&page_size=50' \
+  -H "Authorization: Token your-api-key" \
+  -H "Content-Type: application/json" \
+  -d '{"filters": {"user_id": "alice"}}'
+```
+</CodeGroup>
+
+### Search Parameter Changes
+
+| Parameter | V1/V2 | V3 | Notes |
+|---|---|---|---|
+| `top_k` | Supported | Supported (1-1000, default 10) | No change |
+| `threshold` | Default: none | Default: `0.1` | Pass `0.0` to disable |
+| `rerank` | Default: `true` | Default: `false` | Pass `true` to enable (adds latency) |
+| Entity IDs in `search` / `get_all` | Top-level | Inside `filters` dict | Top-level raises 400 |
+
+### Response Format
+
+**Add response** — asynchronous, returns an `event_id` for polling:
+
+```json
+{
+  "message": "Memory processing has been queued for background execution",
+  "status": "PENDING",
+  "event_id": "evt-uuid"
+}
+```
+
+Poll status via `GET /v1/event/{event_id}/` — status will be `SUCCEEDED` or `FAILED`.
+
+**Search response** — combined multi-signal score per result:
+
+```json
+{
+  "results": [
+    {
+      "id": "mem-uuid",
+      "memory": "User moved to San Francisco from New York in January 2026",
+      "score": 0.82,
+      "metadata": {},
+      "categories": ["location"],
+      "created_at": "2026-01-15T10:30:00Z",
+      "updated_at": "2026-01-15T10:30:00Z"
+    }
+  ]
+}
+```
+
+**List response** — paginated envelope (new in V3):
+
+```json
+{
+  "count": 123,
+  "next": "https://api.mem0.ai/v3/memories/?page=2&page_size=50",
+  "previous": null,
+  "results": [
+    {
+      "id": "mem-uuid",
+      "memory": "...",
+      "metadata": {},
+      "categories": [],
+      "created_at": "2026-01-15T10:30:00Z",
+      "updated_at": "2026-01-15T10:30:00Z"
+    }
+  ]
+}
+```
+
+## SDK Breaking Changes
+
+Alongside the algorithm update, the Python and TypeScript client SDKs have been cleaned up. These changes affect how you initialize and call the client.
+
+### Python Client SDK
+
+```python
+from mem0 import MemoryClient
+
+# Before
+client = MemoryClient(
+    api_key="...",
+    org_id="org-1",       # [REMOVED] Removed
+    project_id="proj-1"   # [REMOVED] Removed
+)
+client.add(messages, user_id="alice", async_mode=True, output_format="v1.1")
+
+# After
+client = MemoryClient(api_key="...")
+client.add(messages, user_id="alice")
+# async_mode and output_format removed (async by default, v1.1 always)
+```
+
+**Removed parameters:** `org_id`, `project_id`, `api_version`, `output_format`, `async_mode`, `enable_graph`, `immutable`, `expiration_date`, `filter_memories`, `batch_size`, `force_add_only`, `includes`, `excludes`, `keyword_search`, `org_name`, `project_name`
+
+### TypeScript Client SDK
+
+All parameters now use **camelCase** (the SDK handles conversion to/from the API automatically):
+
+```typescript
+// Before
+const client = new MemoryClient({
+  apiKey: "...",
+  organizationId: "org-1",  // [REMOVED] Removed
+  projectId: "proj-1"       // [REMOVED] Removed
+});
+await client.search("query", {
+  user_id: "alice",          // [REMOVED] snake_case
+  top_k: 20,                 // [REMOVED] snake_case
+  enable_graph: true          // [REMOVED] Removed
+});
+
+// After
+const client = new MemoryClient({ apiKey: "..." });
+await client.search("query", {
+  filters: { userId: "alice" },  // [OK] inside filters
+  topK: 20                       // [OK] camelCase
+});
+```
+
+**Removed:** `OutputFormat` enum, `API_VERSION` enum, `organizationId`, `projectId`, `organizationName`, `projectName`, `enableGraph`, `asyncMode`, `outputFormat`, `immutable`, `expirationDate`, `filterMemories`, `batchSize`, `forceAddOnly`, `includes`, `excludes`, `keywordSearch`
+
+<Info>
+For the full list of parameter changes across all SDKs, see the [OSS migration guide](/migration/oss-v2-to-v3#removed-parameters-reference).
+</Info>
+
+## Graph Memory → Entity Linking
+
+Graph memory has been replaced by **built-in entity linking**. The changes:
+
+- **Graph visualizations removed from the platform dashboard.** The graph view in your project dashboard is no longer available.
+- **`enable_graph` project setting removed.** The toggle is gone from the dashboard; the API parameter is ignored.
+- **No external graph store to configure.** Previously graph memory required a separate Neo4j (or similar) deployment. Entity linking runs natively inside the platform — nothing to provision, no connection strings to manage.
+- **Entity linking is the native replacement.** Entities (proper nouns, quoted text, compound noun phrases) are automatically extracted from every memory and linked across memories belonging to the same user. At search time, entities from the query are matched against this index and used to boost ranking. The boost is folded into the combined `score` returned on each result.
+
+**No migration work is required.** Entity linking activates automatically for all projects on the new algorithm. Existing memories are not re-processed, but any new memories you add will be indexed for entity-based retrieval going forward.
+
+<Note>
+If your application previously read graph relations from the API response (`relations` field on search results), note that this field is no longer populated. Entity relationships are now consumed indirectly through retrieval ranking, not exposed as a separate graph structure.
+</Note>
+
+## Migration Checklist
+
+<Steps>
+  <Step title="Review your search thresholds">
+    The default `threshold` is now `0.1` (previously no threshold). If your application was relying on unfiltered results, explicitly pass `threshold=0.0` in your search calls to preserve the old behavior. In most cases, the new default is better — it filters out low-relevance noise.
+  </Step>
+  <Step title="Review reranking usage">
+    Reranking is now `false` by default. If your application depended on reranked results, add `rerank=True` to your search calls. Note that reranking adds latency (~200-400ms) but can improve ordering quality for complex queries.
+  </Step>
+  <Step title="Update score handling (optional)">
+    The top-level `score` field continues to work as before. It is now a combined multi-signal score (semantic + keyword + entity) rather than pure cosine similarity, so the absolute numbers will differ. Relative ranking remains comparable — if you have threshold-based filtering in your app, retune on a representative query set.
+  </Step>
+  <Step title="Adjust memory count expectations">
+    With ADD-only extraction, memory counts will grow over time rather than being consolidated. This is by design — retrieval handles relevance ranking. If you have hard limits on memory count, consider using the memory expiration feature or periodic cleanup.
+  </Step>
+  <Step title="Test with representative queries">
+    The biggest improvements are in temporal reasoning (+29.6 on LoCoMo), multi-hop queries (+23.1), and assistant memory recall (+53.6 on LongMemEval). Test queries in these categories to see the improvement.
+  </Step>
+</Steps>
+
+## Backward Compatibility
+
+- **V1 and V2 endpoints continue to work.** There is no requirement to migrate to V3 endpoints immediately.
+- **Existing memories are preserved.** The new algorithm does not modify or re-process previously stored memories.
+- **Search response shape is unchanged.** The top-level `score` and `results[]` array are the same; existing code that reads `score` continues to work. What changed is the scoring method behind the number (multi-signal fusion instead of pure cosine), so the absolute values shift even when ranking stays comparable.
+- **List response shape changed.** `get_all` now returns a paginated envelope (`{count, next, previous, results}`) instead of a bare `{results: [...]}`. Update code that reads `response["results"]` to continue working, or switch to the client SDKs which handle both shapes.
+
+## Performance Improvements
+
+| Metric | Previous Algorithm | New Algorithm |
+|---|---|---|
+| **LoCoMo Overall** | 71.4 | **91.6** (+20.2) |
+| **LongMemEval Overall** | 67.8 | **93.4** (+25.6) |
+| **Extraction latency (p50)** | ~2.0s | **~1.0s** |
+| **Mean tokens per query** | — | 6.8-7.0K (top200) |
+
+All benchmarks were run on a production-representative stack — deliberately avoiding frontier models to keep numbers representative of real production workloads.
+
+## FAQ
+
+<AccordionGroup>
+  <Accordion title="Do I need to re-process my existing memories?">
+    No. Existing memories remain as-is. New memories added after the rollout will use the new extraction algorithm. Both old and new memories are searchable through the same retrieval pipeline.
+  </Accordion>
+  <Accordion title="Will my memory count increase faster now?">
+    Yes. The ADD-only approach means memories accumulate rather than being consolidated. This is intentional — the retrieval system handles ranking and relevance. If you need to manage memory volume, use the expiration date feature or the delete API.
+  </Accordion>
+  <Accordion title="Can I opt out of the new algorithm?">
+    The new algorithm is the default for all platform users. If you have a specific need to use the previous extraction behavior, contact support.
+  </Accordion>
+  <Accordion title="How does entity linking affect my existing integrations?">
+    Entity linking is automatic and transparent. It improves retrieval quality without requiring any changes to your integration. Entities are extracted from both new memories and search queries, and matched automatically.
+  </Accordion>
+</AccordionGroup>
+
+## Need Help?
+
+If you run into issues during migration or have questions about the new algorithm:
+
+- Join our [Discord community](https://mem0.ai/discord) for real-time support
+- Email us at [support@mem0.ai](mailto:support@mem0.ai)
+- Check the [API reference](/api-reference) for detailed endpoint documentation

docs/open-source/configuration.mdx

@@ -130,7 +130,7 @@ memory = Memory.from_config_file("config.yaml")
 </Tabs>
 
 <Info icon="check">
-  Run `memory.add(["Remember my favorite cafe in Tokyo."], user_id="alex")` and then `memory.search("favorite cafe", user_id="alex")`. You should see the Qdrant collection populate and the reranker mark the memory as a top hit.
+  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.
 </Info>
 
 ## Tune component settings

docs/open-source/features/async-memory.mdx

@@ -90,7 +90,7 @@ async def get_memory():
 
 async def safe_memory_usage():
     async with get_memory() as memory:
-        return await memory.search("test query", user_id="alice")
+        return await memory.search("test query", filters={"user_id": "alice"})
 ```
 
 <Tip>
@@ -145,7 +145,7 @@ async def robust_memory_search():
     memory = AsyncMemory()
 
     async def search_operation():
-        return await memory.search("test query", user_id="alice")
+        return await memory.search("test query", filters={"user_id": "alice"})
 
     return await with_timeout_and_retry(search_operation)
 ```
@@ -173,11 +173,11 @@ result = await memory.add(
 # Search memories
 results = await memory.search(
     query="Where am I travelling?",
-    user_id="alice"
+    filters={"user_id": "alice"}
 )
 
 # List memories
-all_memories = await memory.get_all(user_id="alice")
+all_memories = await memory.get_all(filters={"user_id": "alice"})
 
 # Get a specific memory
 specific_memory = await memory.get(memory_id="memory-id-here")
@@ -213,13 +213,11 @@ await memory.add(
     run_id="consultation-001"
 )
 
-all_user_memories = await memory.get_all(user_id="alice")
-agent_memories = await memory.get_all(user_id="alice", agent_id="diet-assistant")
-session_memories = await memory.get_all(user_id="alice", run_id="consultation-001")
+all_user_memories = await memory.get_all(filters={"user_id": "alice"})
+agent_memories = await memory.get_all(filters={"user_id": "alice", "agent_id": "diet-assistant"})
+session_memories = await memory.get_all(filters={"user_id": "alice", "run_id": "consultation-001"})
 specific_memories = await memory.get_all(
-    user_id="alice",
-    agent_id="diet-assistant",
-    run_id="consultation-001"
+    filters={"user_id": "alice", "agent_id": "diet-assistant", "run_id": "consultation-001"}
 )
 
 history = await memory.history(memory_id="memory-id-here")
@@ -240,7 +238,7 @@ async_openai_client = AsyncOpenAI()
 async_memory = AsyncMemory()
 
 async def chat_with_memories(message: str, user_id: str = "default_user") -> str:
-    search_result = await async_memory.search(query=message, user_id=user_id, top_k=3)
+    search_result = await async_memory.search(query=message, filters={"user_id": user_id}, top_k=3)
     relevant_memories = search_result["results"]
     memories_str = "\n".join(f"- {entry['memory']}" for entry in relevant_memories)
 
@@ -255,7 +253,7 @@ async def chat_with_memories(message: str, user_id: str = "default_user") -> str
     ]
 
     response = await async_openai_client.chat.completions.create(
-        model="gpt-4.1-nano-2025-04-14",
+        model="gpt-5-mini",
         messages=messages
     )
 
@@ -280,7 +278,7 @@ async def handle_initialization_errors():
     try:
         config = MemoryConfig(
             vector_store={"provider": "chroma", "config": {"path": "./chroma_db"}},
-            llm={"provider": "openai", "config": {"model": "gpt-4.1-nano-2025-04-14"}}
+            llm={"provider": "openai", "config": {"model": "gpt-5-mini"}}
         )
         AsyncMemory(config=config)
         print("AsyncMemory initialized successfully")
@@ -297,7 +295,7 @@ async def handle_memory_operation_errors():
         print(f"Invalid memory ID: {err}")
 
     try:
-        await memory.search(query="", user_id="alice")
+        await memory.search(query="", filters={"user_id": "alice"})
     except ValueError as err:
         print(f"Invalid search query: {err}")
 ```
@@ -326,7 +324,7 @@ async def add_memory(messages: list, user_id: str):
 @app.get("/memories/search")
 async def search_memories(query: str, user_id: str, limit: int = 10):
     try:
-        result = await memory.search(query=query, user_id=user_id, top_k=limit)
+        result = await memory.search(query=query, filters={"user_id": user_id}, top_k=limit)
         return {"status": "success", "data": result}
     except Exception as exc:
         raise HTTPException(status_code=500, detail=str(exc))

docs/open-source/features/custom-instructions.mdx

@@ -109,23 +109,21 @@ config = {
     "llm": {
         "provider": "openai",
         "config": {
-            "model": "gpt-4.1-nano-2025-04-14",
+            "model": "gpt-5-mini",
             "temperature": 0.2,
             "max_tokens": 2000,
         }
     },
     "custom_instructions": custom_instructions,
-    "version": "v1.1"
 }
 
-m = Memory.from_config(config_dict=config)
+m = Memory.from_config(config)
 ```
 
 ```ts TypeScript
 import { Memory } from "mem0ai/oss";
 
 const config = {
-  version: "v1.1",
   llm: {
     provider: "openai",
     config: {

docs/open-source/features/custom-update-memory-prompt.mdx

@@ -1,306 +0,0 @@
----
-title: Custom Update Memory Prompt
-description: Decide how Mem0 adds, updates, or deletes memories using your own rules.
-icon: "arrows-rotate"
----
-
-The custom update memory prompt tells Mem0 how to handle changes when new facts arrive. Craft the prompt so the LLM can compare incoming facts with existing memories and choose the right action.
-
-<Info>
-  **You’ll use this when…**
-  - Stored memories need to stay consistent as users change preferences or correct past statements.
-  - Your product has clear rules for when to add, update, delete, or leave a memory untouched.
-  - You want traceable decisions (ADD, UPDATE, DELETE, NONE) for auditing or compliance.
-</Info>
-
-<Warning>
-  Prompts that mix instructions or omit examples can lead to wrong actions like deleting valid memories. Keep the language simple and test each action path.
-</Warning>
-
----
-
-## Feature anatomy
-
-- **Action verbs:** The prompt teaches the model to return `ADD`, `UPDATE`, `DELETE`, or `NONE` for every memory entry.
-- **ID retention:** Updates reuse the original memory ID so downstream systems maintain history.
-- **Old vs. new text:** Updates include `old_memory` so you can track what changed.
-- **Decision table:** Your prompt should explain when to use each action and show concrete examples.
-
-<AccordionGroup>
-  <Accordion title="Decision guide">
-    | Action | When to choose it | Output details |
-    | --- | --- | --- |
-    | `ADD` | Fact is new and not stored yet | Generate a new ID and set `event: "ADD"`. |
-    | `UPDATE` | Fact replaces older info about the same topic | Keep the original ID, include `old_memory`. |
-    | `DELETE` | Fact contradicts the stored memory or you explicitly remove it | Keep ID, set `event: "DELETE"`. |
-    | `NONE` | Fact matches existing memory or is irrelevant | Keep ID with `event: "NONE"`. |
-  </Accordion>
-</AccordionGroup>
-
----
-
-## Configure it
-
-### Author the prompt
-
-<CodeGroup>
-```python Python
-UPDATE_MEMORY_PROMPT = """You are a smart memory manager which controls the memory of a system.
-You can perform four operations: (1) add into the memory, (2) update the memory, (3) delete from the memory, and (4) no change.
-
-Based on the above four operations, the memory will change.
-
-Compare newly retrieved facts with the existing memory. For each new fact, decide whether to:
-- ADD: Add it to the memory as a new element
-- UPDATE: Update an existing memory element
-- DELETE: Delete an existing memory element
-- NONE: Make no change (if the fact is already present or irrelevant)
-
-There are specific guidelines to select which operation to perform:
-
-1. **Add**: If the retrieved facts contain new information not present in the memory, then you have to add it by generating a new ID in the id field.
-- **Example**:
-    - Old Memory:
-        [
-            {
-                "id" : "0",
-                "text" : "User is a software engineer"
-            }
-        ]
-    - Retrieved facts: ["Name is John"]
-    - New Memory:
-        {
-            "memory" : [
-                {
-                    "id" : "0",
-                    "text" : "User is a software engineer",
-                    "event" : "NONE"
-                },
-                {
-                    "id" : "1",
-                    "text" : "Name is John",
-                    "event" : "ADD"
-                }
-            ]
-
-        }
-
-2. **Update**: If the retrieved facts contain information that is already present in the memory but the information is totally different, then you have to update it. 
-If the retrieved fact contains information that conveys the same thing as the elements present in the memory, then you have to keep the fact which has the most information. 
-Example (a) -- if the memory contains "User likes to play cricket" and the retrieved fact is "Loves to play cricket with friends", then update the memory with the retrieved facts.
-Example (b) -- if the memory contains "Likes cheese pizza" and the retrieved fact is "Loves cheese pizza", then you do not need to update it because they convey the same information.
-If the direction is to update the memory, then you have to update it.
-Please keep in mind while updating you have to keep the same ID.
-Please note to return the IDs in the output from the input IDs only and do not generate any new ID.
-- **Example**:
-    - Old Memory:
-        [
-            {
-                "id" : "0",
-                "text" : "I really like cheese pizza"
-            },
-            {
-                "id" : "1",
-                "text" : "User is a software engineer"
-            },
-            {
-                "id" : "2",
-                "text" : "User likes to play cricket"
-            }
-        ]
-    - Retrieved facts: ["Loves chicken pizza", "Loves to play cricket with friends"]
-    - New Memory:
-        {
-        "memory" : [
-                {
-                    "id" : "0",
-                    "text" : "Loves cheese and chicken pizza",
-                    "event" : "UPDATE",
-                    "old_memory" : "I really like cheese pizza"
-                },
-                {
-                    "id" : "1",
-                    "text" : "User is a software engineer",
-                    "event" : "NONE"
-                },
-                {
-                    "id" : "2",
-                    "text" : "Loves to play cricket with friends",
-                    "event" : "UPDATE",
-                    "old_memory" : "User likes to play cricket"
-                }
-            ]
-        }
-
-
-3. **Delete**: If the retrieved facts contain information that contradicts the information present in the memory, then you have to delete it. Or if the direction is to delete the memory, then you have to delete it.
-Please note to return the IDs in the output from the input IDs only and do not generate any new ID.
-- **Example**:
-    - Old Memory:
-        [
-            {
-                "id" : "0",
-                "text" : "Name is John"
-            },
-            {
-                "id" : "1",
-                "text" : "Loves cheese pizza"
-            }
-        ]
-    - Retrieved facts: ["Dislikes cheese pizza"]
-    - New Memory:
-        {
-        "memory" : [
-                {
-                    "id" : "0",
-                    "text" : "Name is John",
-                    "event" : "NONE"
-                },
-                {
-                    "id" : "1",
-                    "text" : "Loves cheese pizza",
-                    "event" : "DELETE"
-                }
-        ]
-        }
-
-4. **No Change**: If the retrieved facts contain information that is already present in the memory, then you do not need to make any changes.
-- **Example**:
-    - Old Memory:
-        [
-            {
-                "id" : "0",
-                "text" : "Name is John"
-            },
-            {
-                "id" : "1",
-                "text" : "Loves cheese pizza"
-            }
-        ]
-    - Retrieved facts: ["Name is John"]
-    - New Memory:
-        {
-        "memory" : [
-                {
-                    "id" : "0",
-                    "text" : "Name is John",
-                    "event" : "NONE"
-                },
-                {
-                    "id" : "1",
-                    "text" : "Loves cheese pizza",
-                    "event" : "NONE"
-                }
-            ]
-        }
-"""
-```
-</CodeGroup>
-
-### Define the expected output format
-
-<CodeGroup>
-```json Add
-{
-  "memory": [
-    {
-      "id": "0",
-      "text": "This information is new",
-      "event": "ADD"
-    }
-  ]
-}
-```
-
-```json Update
-{
-  "memory": [
-    {
-      "id": "0",
-      "text": "This information replaces the old information",
-      "event": "UPDATE",
-      "old_memory": "Old information"
-    }
-  ]
-}
-```
-
-```json Delete
-{
-  "memory": [
-    {
-      "id": "0",
-      "text": "This information will be deleted",
-      "event": "DELETE"
-    }
-  ]
-}
-```
-
-```json No Change
-{
-  "memory": [
-    {
-      "id": "0",
-      "text": "No changes for this information",
-      "event": "NONE"
-    }
-  ]
-}
-```
-</CodeGroup>
-
-<Info icon="check">
-  Consistent JSON structure makes it easy to parse decisions downstream or log them for auditing.
-</Info>
-
----
-
-## See it in action
-
-- Run reconciliation jobs that compare retrieved facts to existing memories.  
-- Feed both sources into the custom prompt, then apply the returned actions (add new entries, update text, delete outdated facts).
-- Log each decision so product teams can review why a change happened.
-
-<Note>
-  The prompt works alongside `custom_instructions`—fact extraction identifies candidate facts, and the update prompt decides how to merge them into long-term storage.
-</Note>
-
----
-
-## Verify the feature is working
-
-- Test all four actions with targeted examples, including edge cases where facts differ only slightly.
-- Confirm update responses keep the original IDs and include `old_memory`.
-- Ensure delete actions only trigger when contradictions appear or when you explicitly request removal.
-
----
-
-## Best practices
-
-1. **Keep instructions brief:** Remove redundant wording so the LLM focuses on the decision logic.
-2. **Document your schema:** Share the prompt and examples with your team so everyone knows how memories evolve.
-3. **Track prompt versions:** When rules change, bump a version number and archive the prior prompt.
-4. **Review outputs regularly:** Skim audit logs weekly to spot drift or repeated mistakes.
-5. **Pair with monitoring:** Visualize counts of each action to detect spikes in deletes or updates.
-
----
-
-## Compare prompts
-
-| Feature | `custom_update_memory_prompt` | `custom_instructions` |
-| --- | --- | --- |
-| Primary job | Decide memory actions (ADD/UPDATE/DELETE/NONE) | Pull facts from user and assistant messages |
-| Inputs | Retrieved facts + existing memory entries | Raw conversation turns |
-| Output | Structured memory array with events | Array of extracted facts |
-
----
-
-<CardGroup cols={2}>
-  <Card title="Design Fact Extraction" icon="sparkles" href="/open-source/features/custom-instructions">
-    Coordinate both prompts so fact extraction feeds clean inputs into the update flow.
-  </Card>
-  <Card title="Build Email Automations" icon="inbox" href="/cookbooks/operations/email-automation">
-    See how update prompts keep customer profiles current in a working automation.
-  </Card>
-</CardGroup>

docs/open-source/features/graph-memory.mdx

@@ -1,421 +0,0 @@
----
-title: Graph Memory
-description: "Layer relationships onto Mem0 search so agents remember who did what, when, and with whom."
-icon: "network-wired"
----
-
-Graph Memory extends Mem0 by persisting nodes and edges alongside embeddings, so recalls stitch together people, places, and events instead of just keywords.
-
-<Info icon="sparkles">
-**You’ll use this when…**
-- Conversation history mixes multiple actors and objects that vectors alone blur together
-- Compliance or auditing demands a graph of who said what and when
-- Agent teams need shared context without duplicating every memory in each run
-</Info>
-
-## How Graph Memory Maps Context
-
-Mem0 extracts entities and relationships from every memory write, stores embeddings in your vector database, and mirrors relationships in a graph backend. On retrieval, vector search narrows candidates while the graph returns related context alongside the results.
-
-```mermaid
-graph LR
-    A[Conversation] --> B(Extraction LLM)
-    B --> C[Vector Store]
-    B --> D[Graph Store]
-    E[Query] --> C
-    C --> F[Candidate Memories]
-    F --> D
-    D --> G[Contextual Recall]
-```
-
-## How It Works
-
-<Steps>
-<Step title="Extract people, places, and facts">
-Mem0’s extraction LLM identifies entities, relationships, and timestamps from the conversation payload you send to `memory.add`.
-</Step>
-<Step title="Store vectors and edges together">
-Embeddings land in your configured vector database while nodes and edges flow into a graph backend (Neo4j, Memgraph, Neptune, Kuzu, or Apache AGE).
-</Step>
-<Step title="Expose graph context at search time">
-`memory.search` performs vector similarity (optionally reranked by your configured reranker) and returns the results list. Graph Memory runs in parallel and adds related entities in the `relations` array—it does not reorder the vector hits automatically.
-</Step>
-</Steps>
-
-## Quickstart (Neo4j Aura)
-
-<Info icon="clock">
-**Time to implement:** ~10 minutes · **Prerequisites:** Python 3.10+, Node.js 18+, Neo4j Aura DB (free tier)
-</Info>
-
-Provision a free [Neo4j Aura](https://neo4j.com/product/auradb/) instance, copy the Bolt URI, username, and password, then follow the language tab that matches your stack.
-
-<Tabs>
-  <Tab title="Python">
-<Steps>
-<Step title="Install Mem0 with graph extras">
-```bash
-pip install "mem0ai[graph]"
-```
-</Step>
-<Step title="Export Neo4j credentials">
-```bash
-export NEO4J_URL="neo4j+s://<your-instance>.databases.neo4j.io"
-export NEO4J_USERNAME="neo4j"
-export NEO4J_PASSWORD="your-password"
-```
-</Step>
-<Step title="Add and recall a relationship">
-```python
-import os
-from mem0 import Memory
-
-config = {
-    "graph_store": {
-        "provider": "neo4j",
-        "config": {
-            "url": os.environ["NEO4J_URL"],
-            "username": os.environ["NEO4J_USERNAME"],
-            "password": os.environ["NEO4J_PASSWORD"],
-            "database": "neo4j",
-        }
-    }
-}
-
-memory = Memory.from_config(config)
-
-conversation = [
-    {"role": "user", "content": "Alice met Bob at GraphConf 2025 in San Francisco."},
-    {"role": "assistant", "content": "Great! Logging that connection."},
-]
-
-memory.add(conversation, user_id="demo-user")
-
-results = memory.search(
-    "Who did Alice meet at GraphConf?",
-    user_id="demo-user",
-    top_k=3,
-    rerank=True,
-)
-
-for hit in results["results"]:
-    print(hit["memory"])
-```
-</Step>
-</Steps>
-  </Tab>
-  <Tab title="TypeScript">
-<Steps>
-<Step title="Install the OSS SDK">
-```bash
-npm install mem0ai
-```
-</Step>
-<Step title="Load Neo4j credentials">
-```bash
-export NEO4J_URL="neo4j+s://<your-instance>.databases.neo4j.io"
-export NEO4J_USERNAME="neo4j"
-export NEO4J_PASSWORD="your-password"
-```
-</Step>
-<Step title="Enable graph memory and query it">
-```typescript
-import { Memory } from "mem0ai/oss";
-
-const config = {
-  graphStore: {
-    provider: "neo4j",
-    config: {
-      url: process.env.NEO4J_URL!,
-      username: process.env.NEO4J_USERNAME!,
-      password: process.env.NEO4J_PASSWORD!,
-      database: "neo4j",
-    },
-  },
-};
-
-const memory = new Memory(config);
-
-const conversation = [
-  { role: "user", content: "Alice met Bob at GraphConf 2025 in San Francisco." },
-  { role: "assistant", content: "Great! Logging that connection." },
-];
-
-await memory.add(conversation, { userId: "demo-user" });
-
-const results = await memory.search(
-  "Who did Alice meet at GraphConf?",
-  { userId: "demo-user", topK: 3, rerank: true }
-);
-
-results.results.forEach((hit) => {
-  console.log(hit.memory);
-});
-```
-</Step>
-</Steps>
-  </Tab>
-</Tabs>
-
-<Info icon="check">
-Expect to see **Alice met Bob at GraphConf 2025** in the output. In Neo4j Browser run `MATCH (p:Person)-[r]->(q:Person) RETURN p,r,q LIMIT 5;` to confirm the edge exists.
-</Info>
-
-<Note>
-Graph Memory enriches responses by adding related entities in the `relations` key. The ordering of `results` always comes from vector search (plus any reranker you configure); graph edges do not reorder those hits automatically.
-</Note>
-
-## Operate Graph Memory Day-to-Day
-
-<AccordionGroup>
-  <Accordion title="Refine extraction prompts">
-    Guide which relationships become nodes and edges.
-
-<CodeGroup>
-```python Python
-import os
-from mem0 import Memory
-
-config = {
-    "graph_store": {
-        "provider": "neo4j",
-        "config": {
-            "url": os.environ["NEO4J_URL"],
-            "username": os.environ["NEO4J_USERNAME"],
-            "password": os.environ["NEO4J_PASSWORD"],
-        },
-        "custom_prompt": "Please only capture people, organisations, and project links.",
-    }
-}
-
-memory = Memory.from_config(config_dict=config)
-```
-
-```typescript TypeScript
-import { Memory } from "mem0ai/oss";
-
-const config = {
-  graphStore: {
-    provider: "neo4j",
-    config: {
-      url: process.env.NEO4J_URL!,
-      username: process.env.NEO4J_USERNAME!,
-      password: process.env.NEO4J_PASSWORD!,
-    },
-    customInstructions: "Please only capture people, organisations, and project links.",
-  }
-};
-
-const memory = new Memory(config);
-```
-</CodeGroup>
-  </Accordion>
-  <Accordion title="Raise the confidence threshold">
-    Keep noisy edges out of the graph by demanding higher extraction confidence.
-
-```python
-config["graph_store"]["config"]["threshold"] = 0.75
-```
-  </Accordion>
-  <Accordion title="Organize multi-agent graphs">
-    Separate or share context across agents and sessions with `user_id`, `agent_id`, and `run_id`.
-
-<CodeGroup>
-```typescript TypeScript
-memory.add("I prefer Italian cuisine", { userId: "bob", agentId: "food-assistant" });
-memory.add("I'm allergic to peanuts", { userId: "bob", agentId: "health-assistant" });
-memory.add("I live in Seattle", { userId: "bob" });
-
-const food = await memory.search("What food do I like?", { userId: "bob", agentId: "food-assistant" });
-const allergies = await memory.search("What are my allergies?", { userId: "bob", agentId: "health-assistant" });
-const location = await memory.search("Where do I live?", { userId: "bob" });
-```
-</CodeGroup>
-  </Accordion>
-</AccordionGroup>
-
-<Note>
-Monitor graph growth, especially on free tiers, by periodically cleaning dormant nodes: `MATCH (n) WHERE n.lastSeen < date() - duration('P90D') DETACH DELETE n`.
-</Note>
-
-## Troubleshooting
-
-<AccordionGroup>
-  <Accordion title="Neo4j connection refused">
-    Confirm Bolt connectivity is enabled, credentials match Aura, and your IP is allow-listed. Retry after confirming the URI format is `neo4j+s://...`.
-  </Accordion>
-  <Accordion title="Neptune Analytics rejects requests">
-    Ensure the graph identifier matches the vector dimension used by your embedder and that the IAM role allows `neptune-graph:*DataViaQuery` actions.
-  </Accordion>
-</AccordionGroup>
-
-## Decision Points
-
-- Select the graph store that fits your deployment (managed Aura vs. self-hosted Neo4j vs. AWS Neptune vs. local Kuzu vs. Apache AGE on PostgreSQL).
-- Decide whether to include a graph store in your config; routine conversations may stay vector-only to save latency.
-- Set a policy for pruning stale relationships so your graph stays fast and affordable.
-
-## Provider setup
-
-Choose your backend and expand the matching panel for configuration details and links.
-
-<AccordionGroup>
-  <Accordion title="Neo4j Aura or self-hosted">
-    Install the APOC plugin for self-hosted deployments, then configure Mem0:
-
-```typescript
-import { Memory } from "mem0ai/oss";
-
-const config = {
-    graphStore: {
-        provider: "neo4j",
-        config: {
-            url: "neo4j+s://<HOST>",
-            username: "neo4j",
-            password: "<PASSWORD>",
-        }
-    }
-};
-
-const memory = new Memory(config);
-```
-
-Additional docs: [Neo4j Aura Quickstart](https://neo4j.com/docs/aura/), [APOC installation](https://neo4j.com/docs/apoc/current/installation/).
-  </Accordion>
-  <Accordion title="Memgraph (Docker)">
-    Run Memgraph Mage locally with schema introspection enabled:
-
-```bash
-docker run -p 7687:7687 memgraph/memgraph-mage:latest --schema-info-enabled=True
-```
-
-Then point Mem0 at the instance:
-
-```python
-from mem0 import Memory
-
-config = {
-    "graph_store": {
-        "provider": "memgraph",
-        "config": {
-            "url": "bolt://localhost:7687",
-            "username": "memgraph",
-            "password": "your-password",
-        },
-    },
-}
-
-m = Memory.from_config(config_dict=config)
-```
-
-Learn more: [Memgraph Docs](https://memgraph.com/docs).
-  </Accordion>
-  <Accordion title="Amazon Neptune Analytics">
-    Match vector dimensions between Neptune and your embedder, enable public connectivity (if needed), and grant IAM permissions:
-
-```python
-from mem0 import Memory
-
-config = {
-    "graph_store": {
-        "provider": "neptune",
-        "config": {
-            "endpoint": "neptune-graph://<GRAPH_ID>",
-        },
-    },
-}
-
-m = Memory.from_config(config_dict=config)
-```
-
-Reference: [Neptune Analytics Guide](https://docs.aws.amazon.com/neptune/latest/analytics/).
-  </Accordion>
-  <Accordion title="Amazon Neptune DB (with external vectors)">
-    Create a Neptune cluster, enable the public endpoint if you operate outside the VPC, and point Mem0 at the host:
-
-```python
-from mem0 import Memory
-
-config = {
-    "graph_store": {
-        "provider": "neptunedb",
-        "config": {
-            "collection_name": "<VECTOR_COLLECTION_NAME>",
-            "endpoint": "neptune-graph://<HOST_ENDPOINT>",
-        },
-    },
-}
-
-m = Memory.from_config(config_dict=config)
-```
-
-Reference: [Accessing Data in Neptune DB](https://docs.aws.amazon.com/neptune/latest/userguide/).
-  </Accordion>
-  <Accordion title="Kuzu (embedded)">
-    Kuzu runs in-process, so supply a path (or `:memory:`) for the database file:
-
-```python
-config = {
-    "graph_store": {
-        "provider": "kuzu",
-        "config": {
-            "db": "/tmp/mem0-example.kuzu"
-        }
-    }
-}
-```
-
-Kuzu will clear its state when using `:memory:` once the process exits. See the [Kuzu documentation](https://kuzudb.com/docs/) for advanced settings.
-  </Accordion>
-  <Accordion title="Apache AGE (PostgreSQL extension)">
-    [Apache AGE](https://age.apache.org/) adds graph database capabilities to PostgreSQL, letting you run Cypher queries alongside SQL on the same server. Start AGE via Docker, then configure Mem0:
-
-```bash
-docker run --name age-postgres \
-  -e POSTGRES_DB=mem0_db \
-  -e POSTGRES_USER=mem0_user \
-  -e POSTGRES_PASSWORD=mem0_pass \
-  -p 5432:5432 \
-  -d apache/age
-```
-
-```python
-from mem0 import Memory
-
-config = {
-    "graph_store": {
-        "provider": "apache_age",
-        "config": {
-            "host": "localhost",
-            "port": 5432,
-            "database": "mem0_db",
-            "username": "mem0_user",
-            "password": "mem0_pass",
-            "graph_name": "mem0_graph",
-        },
-    },
-}
-
-m = Memory.from_config(config_dict=config)
-```
-
-Apache AGE does not have a built-in vector index, so similarity search is computed client-side. This works well for moderate graph sizes; for very large graphs consider pairing AGE with pgvector for the vector store.
-
-Reference: [Apache AGE documentation](https://age.apache.org/age-manual/master/index.html).
-  </Accordion>
-</AccordionGroup>
-
-<CardGroup cols={2}>
-  <Card
-    title="Enhanced Metadata Filtering"
-    description="Blend field-level filters with graph context to zero in on the right memories."
-    icon="funnel"
-    href="/open-source/features/metadata-filtering"
-  />
-  <Card
-    title="Reranker-Enhanced Search"
-    description="Layer rerankers on top of vectors and graphs for the cleanest results."
-    icon="sparkles"
-    href="/open-source/features/reranker-search"
-  />
-</CardGroup>

docs/open-source/features/metadata-filtering.mdx

@@ -51,8 +51,7 @@ m = Memory()
 # Search with simple metadata filters
 results = m.search(
     "What are my preferences?",
-    user_id="alice",
-    filters={"category": "preferences"}
+    filters={"user_id": "alice", "category": "preferences"}
 )
 ```
 
@@ -68,8 +67,8 @@ Layer greater-than/less-than comparisons to rank results by score, confidence, o
 # Greater than / Less than
 results = m.search(
     "recent activities",
-    user_id="alice",
     filters={
+        "user_id": "alice",
         "score": {"gt": 0.8},
         "priority": {"gte": 5},
         "confidence": {"lt": 0.9},
@@ -80,8 +79,8 @@ results = m.search(
 # Equality operators
 results = m.search(
     "specific content",
-    user_id="alice",
     filters={
+        "user_id": "alice",
         "status": {"eq": "active"},
         "archived": {"ne": True}
     }
@@ -96,8 +95,8 @@ Use `in` and `nin` when you want to pre-approve or exclude specific values witho
 # In / Not in operators
 results = m.search(
     "multi-category search",
-    user_id="alice",
     filters={
+        "user_id": "alice",
         "category": {"in": ["food", "travel", "entertainment"]},
         "status": {"nin": ["deleted", "archived"]}
     }
@@ -116,8 +115,8 @@ results = m.search(
 # Text matching operators
 results = m.search(
     "content search",
-    user_id="alice",
     filters={
+        "user_id": "alice",
         "title": {"contains": "meeting"},
         "description": {"icontains": "important"},
         "tags": {"contains": "urgent"}
@@ -133,8 +132,8 @@ Allow any value for a field while still requiring the field to exist—handy whe
 # Match any value for a field
 results = m.search(
     "all with category",
-    user_id="alice",
     filters={
+        "user_id": "alice",
         "category": "*"
     }
 )
@@ -148,9 +147,9 @@ Combine filters with `AND`, `OR`, and `NOT` to express complex decision trees. N
 # Logical AND
 results = m.search(
     "complex query",
-    user_id="alice",
     filters={
         "AND": [
+            {"user_id": "alice"},
             {"category": "work"},
             {"priority": {"gte": 7}},
             {"status": {"ne": "completed"}}
@@ -161,12 +160,16 @@ results = m.search(
 # Logical OR
 results = m.search(
     "flexible query",
-    user_id="alice",
     filters={
-        "OR": [
-            {"category": "urgent"},
-            {"priority": {"gte": 9}},
-            {"deadline": {"contains": "today"}}
+        "AND": [
+            {"user_id": "alice"},
+            {
+                "OR": [
+                    {"category": "urgent"},
+                    {"priority": {"gte": 9}},
+                    {"deadline": {"contains": "today"}}
+                ]
+            }
         ]
     }
 )
@@ -174,11 +177,15 @@ results = m.search(
 # Logical NOT
 results = m.search(
     "exclusion query",
-    user_id="alice",
     filters={
-        "NOT": [
-            {"category": "archived"},
-            {"status": "deleted"}
+        "AND": [
+            {"user_id": "alice"},
+            {
+                "NOT": [
+                    {"category": "archived"},
+                    {"status": "deleted"}
+                ]
+            }
         ]
     }
 )
@@ -186,9 +193,9 @@ results = m.search(
 # Complex nested logic
 results = m.search(
     "advanced query",
-    user_id="alice",
     filters={
         "AND": [
+            {"user_id": "alice"},
             {
                 "OR": [
                     {"category": "work"},
@@ -288,16 +295,15 @@ Vector store support varies. Confirm operator coverage before shipping:
 # Before (v0.x) - simple key-value filtering only
 results = m.search(
     "query",
-    user_id="alice",
-    filters={"category": "work", "status": "active"}
+    filters={"user_id": "alice", "category": "work", "status": "active"}
 )
 
 # After (v1.0.0) - enhanced filtering with operators
 results = m.search(
     "query",
-    user_id="alice",
     filters={
         "AND": [
+            {"user_id": "alice"},
             {"category": "work"},
             {"status": {"ne": "archived"}},
             {"priority": {"gte": 5}}
@@ -320,9 +326,9 @@ results = m.search(
 # Find high-priority active tasks
 results = m.search(
     "What tasks need attention?",
-    user_id="project_manager",
     filters={
         "AND": [
+            {"user_id": "project_manager"},
             {"project": {"in": ["alpha", ""]}},
             {"priority": {"gte": 8}},
             {"status": {"ne": "completed"}},
@@ -347,9 +353,9 @@ results = m.search(
 # Find recent unresolved tickets
 results = m.search(
     "pending support issues",
-    agent_id="support_bot",
     filters={
         "AND": [
+            {"agent_id": "support_bot"},
             {"ticket_status": {"ne": "resolved"}},
             {"priority": {"in": ["high", "critical"]}},
             {"created_date": {"gte": "2024-01-01"}},
@@ -364,7 +370,7 @@ results = m.search(
 ```
 
 <Tip>
-  Pair `agent_id` filters with ticket-specific metadata so shared support bots return only the tickets they can act on in the current session.
+  Pair agent ID filters with ticket-specific metadata so shared support bots return only the tickets they can act on in the current session.
 </Tip>
 
 ### Content recommendation filtering
@@ -373,9 +379,9 @@ results = m.search(
 # Personalized content filtering
 results = m.search(
     "recommend content",
-    user_id="reader123",
     filters={
         "AND": [
+            {"user_id": "reader123"},
             {
                 "OR": [
                     {"genre": {"in": ["sci-fi", "fantasy"]}},
@@ -400,8 +406,8 @@ results = m.search(
 try:
     results = m.search(
         "test query",
-        user_id="alice",
         filters={
+            "user_id": "alice",
             "invalid_operator": {"unknown": "value"}
         }
     )
@@ -409,8 +415,7 @@ except ValueError as e:
     print(f"Filter error: {e}")
     results = m.search(
         "test query",
-        user_id="alice",
-        filters={"category": "general"}
+        filters={"user_id": "alice", "category": "general"}
     )
 ```
 

docs/open-source/features/openai_compatibility.mdx

@@ -41,7 +41,7 @@ messages = [
 
 chat_completion = client.chat.completions.create(
     messages=messages,
-    model="gpt-4.1-nano-2025-04-14",
+    model="gpt-5-mini",
     user_id="alice"
 )
 ```
@@ -69,7 +69,7 @@ client = Mem0(config=config)
 
 chat_completion = client.chat.completions.create(
     messages=[{"role": "user", "content": "What's the capital of France?"}],
-    model="gpt-4.1-nano-2025-04-14"
+    model="gpt-5-mini"
 )
 ```
 
@@ -85,14 +85,14 @@ client = Mem0(api_key="m0-xxx")
 # Store preferences
 client.chat.completions.create(
     messages=[{"role": "user", "content": "I love Indian food but I'm allergic to cheese."}],
-    model="gpt-4.1-nano-2025-04-14",
+    model="gpt-5-mini",
     user_id="alice"
 )
 
 # Later conversation reuses the memory
 response = client.chat.completions.create(
     messages=[{"role": "user", "content": "Suggest dinner options in San Francisco."}],
-    model="gpt-4.1-nano-2025-04-14",
+    model="gpt-5-mini",
     user_id="alice"
 )
 

docs/open-source/features/overview.mdx

@@ -15,9 +15,6 @@ Mem0 Open Source ships with capabilities that adapt memory behavior for producti
 ## Choose your path
 
 <CardGroup cols={3}>
-  <Card title="Graph Memory" icon="network-wired" href="/open-source/features/graph-memory">
-    Store entity relationships for multi-hop recall.
-  </Card>
   <Card title="Advanced Metadata Filtering" icon="filter" href="/open-source/features/metadata-filtering">
     Query with logical operators and nested conditions.
   </Card>
@@ -35,10 +32,7 @@ Mem0 Open Source ships with capabilities that adapt memory behavior for producti
   </Card>
 </CardGroup>
 
-<CardGroup cols={3}>
-  <Card title="Custom Memory Updates" icon="arrows-rotate" href="/open-source/features/custom-update-memory-prompt">
-    Control memory refinement with custom instructions.
-  </Card>
+<CardGroup cols={2}>
   <Card title="REST API" icon="code" href="/open-source/features/rest-api">
     HTTP endpoints for language-agnostic integrations.
   </Card>

docs/open-source/features/reranker-search.mdx

@@ -189,7 +189,7 @@ async_memory = AsyncMemory.from_config(config)
 async def search_with_rerank():
     return await async_memory.search(
         "What are my preferences?",
-        user_id="alice",
+        filters={"user_id": "alice"},
         rerank=True
     )
 
@@ -222,7 +222,7 @@ config = {
 def smart_search(query, user_id, use_rerank=None):
     if use_rerank is None:
         use_rerank = len(query.split()) > 3
-    return m.search(query, user_id=user_id, rerank=use_rerank)
+    return m.search(query, filters={"user_id": user_id}, rerank=use_rerank)
 ```
 
 <Tip>
@@ -233,10 +233,10 @@ def smart_search(query, user_id, use_rerank=None):
 
 ```python
 try:
-    results = m.search("test query", user_id="alice", rerank=True)
+    results = m.search("test query", filters={"user_id": "alice"}, rerank=True)
 except Exception as exc:
     print(f"Reranking failed: {exc}")
-    results = m.search("test query", user_id="alice", rerank=False)
+    results = m.search("test query", filters={"user_id": "alice"}, rerank=False)
 ```
 
 <Warning>
@@ -247,7 +247,7 @@ except Exception as exc:
 
 ```python
 # Before: basic vector search
-results = m.search("query", user_id="alice")
+results = m.search("query", filters={"user_id": "alice"})
 
 # After: same API with reranking enabled via config
 config = {
@@ -260,7 +260,7 @@ config = {
 }
 
 m = Memory.from_config(config)
-results = m.search("query", user_id="alice")
+results = m.search("query", filters={"user_id": "alice"})
 ```
 
 ---
@@ -272,7 +272,7 @@ results = m.search("query", user_id="alice")
 ```python
 results = m.search(
     "What are my food preferences?",
-    user_id="alice"
+    filters={"user_id": "alice"}
 )
 
 for result in results["results"]:
@@ -289,13 +289,13 @@ for result in results["results"]:
 ```python
 results_with_rerank = m.search(
     "What movies do I like?",
-    user_id="alice",
+    filters={"user_id": "alice"},
     rerank=True
 )
 
 results_without_rerank = m.search(
     "What movies do I like?",
-    user_id="alice",
+    filters={"user_id": "alice"},
     rerank=False
 )
 ```
@@ -313,9 +313,9 @@ results_without_rerank = m.search(
 ```python
 results = m.search(
     "important work tasks",
-    user_id="alice",
     filters={
         "AND": [
+            {"user_id": "alice"},
             {"category": "work"},
             {"priority": {"gte": 7}}
         ]
@@ -348,8 +348,7 @@ m = Memory.from_config(config)
 
 results = m.search(
     "customer having login issues with mobile app",
-    agent_id="support_bot",
-    filters={"category": "technical_support"},
+    filters={"agent_id": "support_bot", "category": "technical_support"},
     rerank=True
 )
 ```
@@ -363,8 +362,7 @@ results = m.search(
 ```python
 results = m.search(
     "science fiction books with space exploration themes",
-    user_id="reader123",
-    filters={"content_type": "book_recommendation"},
+    filters={"user_id": "reader123", "content_type": "book_recommendation"},
     rerank=True,
     top_k=10
 )
@@ -383,9 +381,9 @@ for result in results["results"]:
 ```python
 results = m.search(
     "What restaurants did I enjoy last month that had good vegetarian options?",
-    user_id="foodie_user",
     filters={
         "AND": [
+            {"user_id": "foodie_user"},
             {"category": "dining"},
             {"rating": {"gte": 4}},
             {"date": {"gte": "2024-01-01"}}

docs/open-source/node-quickstart.mdx

@@ -43,7 +43,7 @@ await memory.add(messages, { userId: "alice", metadata: { category: "movie_recom
 
 <Step title="Search memories">
 ```ts
-const results = await memory.search("What do you know about me?", { userId: "alice" });
+const results = await memory.search("What do you know about me?", { filters: { userId: "alice" } });
 console.log(results);
 ```
 
@@ -67,7 +67,7 @@ console.log(results);
 </Steps>
 
 <Note>
-By default the Node SDK uses local-friendly settings (OpenAI `gpt-4.1-nano-2025-04-14`, `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). Swap components by passing a config as shown below.
 </Note>
 
 ## Configure for production
@@ -76,7 +76,6 @@ By default the Node SDK uses local-friendly settings (OpenAI `gpt-4.1-nano-2025-
 import { Memory } from "mem0ai/oss";
 
 const memory = new Memory({
-  version: "v1.1",
   embedder: {
     provider: "openai",
     config: {
@@ -106,7 +105,7 @@ const memory = new Memory({
 
 <CodeGroup>
 ```ts Get all memories
-const allMemories = await memory.getAll({ userId: "alice" });
+const allMemories = await memory.getAll({ filters: { userId: "alice" } });
 console.log(allMemories);
 ```
 
@@ -116,7 +115,7 @@ console.log(singleMemory);
 ```
 
 ```ts Search memories
-const result = await memory.search("What do you know about me?", { userId: "alice" });
+const result = await memory.search("What do you know about me?", { filters: { userId: "alice" } });
 console.log(result);
 ```
 
@@ -221,7 +220,6 @@ Mem0 offers granular configuration across vector stores, LLMs, embedders, and hi
 | Parameter | Description | Default |
 | --- | --- | --- |
 | `historyDbPath` | Path to history database | `"{mem0_dir}/history.db"` |
-| `version` | API version | `"v1.0"` |
 | `customInstructions` | Custom processing prompt | `undefined` |
   </Accordion>
   <Accordion title="History store">
@@ -234,7 +232,6 @@ Mem0 offers granular configuration across vector stores, LLMs, embedders, and hi
   <Accordion title="Complete config example">
 ```ts
 const config = {
-  version: "v1.1",
   embedder: {
     provider: "openai",
     config: {

docs/open-source/overview.mdx

@@ -8,10 +8,6 @@ icon: "house"
 
 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.
 
-<Tip>
-  Mem0 v1.0.0 brought rerankers, async-by-default clients, and Azure OpenAI support. See the <Link href="/changelog">release notes</Link> for the full rundown before upgrading.
-</Tip>
-
 ## What Mem0 OSS provides
 
 - **Full control**: Tune every component, from LLMs to vector stores, inside your environment.
@@ -37,12 +33,12 @@ Mem0 Open Source delivers the same adaptive memory engine as the platform, but p
   <Card title="Configure Components" icon="sliders" href="/open-source/configuration">
     LLM, embedder, vector store, reranker setup.
   </Card>
-  <Card title="Graph Memory Capability" icon="network-wired" href="/open-source/features/graph-memory">
-    Relationship-aware recall with Neo4j, Memgraph.
-  </Card>
   <Card title="Tune Retrieval & Rerankers" icon="sparkles" href="/open-source/features/reranker-search">
     Hybrid retrieval and reranker controls.
   </Card>
+  <Card title="Memory Evaluation" icon="chart-line" href="/core-concepts/memory-evaluation">
+    Benchmarks and how Mem0 is tested.
+  </Card>
 </CardGroup>
 
 <CardGroup cols={2}>
@@ -75,7 +71,7 @@ Mem0 Open Source delivers the same adaptive memory engine as the platform, but p
 
 <Note>
   Mem0 OSS works out of the box with sensible defaults:
-  - LLM: OpenAI `gpt-4.1-nano-2025-04-14` (via `OPENAI_API_KEY`)
+  - LLM: OpenAI `gpt-5-mini` (via `OPENAI_API_KEY`)
   - Embeddings: OpenAI `text-embedding-3-small`
   - Vector store: Local Qdrant instance storing data at `/tmp/qdrant`
   - History store: SQLite database at `~/.mem0/history.db`

docs/open-source/python-quickstart.mdx

@@ -52,7 +52,7 @@ m.add(messages, user_id="alex")
 
 <Step title="Search memories">
 ```python
-results = m.search("What do you know about me?", user_id="alex")
+results = m.search("What do you know about me?", filters={"user_id": "alex"})
 print(results)
 ```
 
@@ -79,7 +79,7 @@ print(results)
 
 <Note>
 By default `Memory()` wires up:
-- OpenAI `gpt-4.1-nano-2025-04-14` for fact extraction and updates
+- OpenAI `gpt-5-mini` for fact extraction and updates
 - OpenAI `text-embedding-3-small` embeddings (1536 dimensions)
 - Qdrant vector store with on-disk data at `/tmp/qdrant`
 - SQLite history at `~/.mem0/history.db`
@@ -98,7 +98,7 @@ Learn how to search, update, and manage memories with full CRUD operations
 </Card>
 
 <Card title="Advanced Features" icon="sparkles" href="/open-source/features/async-memory">
-Explore async support, graph memory, and multi-agent memory organization
+Explore async support and multi-agent memory organization
 </Card>
 </CardGroup>
 

docs/openapi.json

@@ -1048,8 +1048,8 @@
 											},
 											"expiration_date": {
 												"type": "string",
-												"format": "date-time",
-												"description": "The date and time when the memory will expire. Format: YYYY-MM-DD.",
+												"format": "date",
+												"description": "The date when the memory will expire. Format: YYYY-MM-DD.",
 												"title": "Expiration date",
 												"nullable": true,
 												"default": null
@@ -1096,7 +1096,7 @@
 				"x-code-samples": [
 					{
 						"lang": "Python",
-						"source": "# To use the Python SDK, install the package:\n# pip install mem0ai\n\nfrom mem0 import MemoryClient\nclient = MemoryClient(api_key=\"your_api_key\")\n\n# Retrieve memories for a specific user\nuser_memories = client.get_all(user_id=\"<user_id>\")\n\nprint(user_memories)"
+						"source": "# To use the Python SDK, install the package:\n# pip install mem0ai\n\nfrom mem0 import MemoryClient\nclient = MemoryClient(api_key=\"your_api_key\")\n\n# Retrieve memories for a specific user\nuser_memories = client.get_all(filters={\"user_id\": \"<user_id>\"})\n\nprint(user_memories)"
 					},
 					{
 						"lang": "JavaScript",
@@ -1232,8 +1232,8 @@
 				"tags": [
 					"memories"
 				],
-				"description": "Delete memories by filter. At least one filter is required \u2014 previously omitting all filters silently deleted everything; now it returns a validation error.",
-				"operationId": "memories_delete",
+				"description": "Delete memories by filter. At least one filter is required — previously omitting all filters silently deleted everything; now it returns a validation error.",
+				"operationId": "memories_delete_all",
 				"parameters": [
 					{
 						"name": "user_id",
@@ -1315,15 +1315,15 @@
 				"x-code-samples": [
 					{
 						"lang": "Python",
-						"source": "# To use the Python SDK, install the package:\n# pip install mem0ai\n\nfrom mem0 import MemoryClient\nclient = MemoryClient(api_key=\"your_api_key\")\n\n# Delete all memories for a specific user\nclient.delete_all(user_id=\"<user_id>\")\n\n# Delete all memories for every user in the project (wildcard)\nclient.delete_all(user_id=\"*\")\n\n# Full project wipe \u2014 all four filters must be explicitly set to \"*\"\nclient.delete_all(user_id=\"*\", agent_id=\"*\", app_id=\"*\", run_id=\"*\")\n\n# NOTE: Calling delete_all() with no filters raises a validation error.\n# At least one filter is required to prevent accidental data loss."
+						"source": "# To use the Python SDK, install the package:\n# pip install mem0ai\n\nfrom mem0 import MemoryClient\nclient = MemoryClient(api_key=\"your_api_key\")\n\n# Delete all memories for a specific user\nclient.delete_all(user_id=\"<user_id>\")\n\n# Delete all memories for every user in the project (wildcard)\nclient.delete_all(user_id=\"*\")\n\n# Full project wipe — all four filters must be explicitly set to \"*\"\nclient.delete_all(user_id=\"*\", agent_id=\"*\", app_id=\"*\", run_id=\"*\")\n\n# NOTE: Calling delete_all() with no filters raises a validation error.\n# At least one filter is required to prevent accidental data loss."
 					},
 					{
 						"lang": "JavaScript",
-						"source": "// To use the JavaScript SDK, install the package:\n// npm i mem0ai\n\nimport MemoryClient from 'mem0ai';\nconst client = new MemoryClient({ apiKey: \"your-api-key\" });\n\n// Delete all memories for a specific user\nclient.deleteAll({ user_id: \"<user_id>\" })\n  .then(result => console.log(result))\n  .catch(error => console.error(error));\n\n// Delete all memories for every user in the project (wildcard)\nclient.deleteAll({ user_id: \"*\" })\n  .then(result => console.log(result))\n  .catch(error => console.error(error));\n\n// Full project wipe \u2014 all four filters must be explicitly set to \"*\"\nclient.deleteAll({ user_id: \"*\", agent_id: \"*\", app_id: \"*\", run_id: \"*\" })\n  .then(result => console.log(result))\n  .catch(error => console.error(error));"
+						"source": "// To use the JavaScript SDK, install the package:\n// npm i mem0ai\n\nimport MemoryClient from 'mem0ai';\nconst client = new MemoryClient({ apiKey: \"your-api-key\" });\n\n// Delete all memories for a specific user\nclient.deleteAll({ user_id: \"<user_id>\" })\n  .then(result => console.log(result))\n  .catch(error => console.error(error));\n\n// Delete all memories for every user in the project (wildcard)\nclient.deleteAll({ user_id: \"*\" })\n  .then(result => console.log(result))\n  .catch(error => console.error(error));\n\n// Full project wipe — all four filters must be explicitly set to \"*\"\nclient.deleteAll({ user_id: \"*\", agent_id: \"*\", app_id: \"*\", run_id: \"*\" })\n  .then(result => console.log(result))\n  .catch(error => console.error(error));"
 					},
 					{
 						"lang": "cURL",
-						"source": "# Delete memories for a specific user\ncurl --request DELETE \\\n  --url 'https://api.mem0.ai/v1/memories/?user_id=<user_id>' \\\n  --header 'Authorization: Token <api-key>'\n\n# Delete memories for all users (wildcard)\ncurl --request DELETE \\\n  --url 'https://api.mem0.ai/v1/memories/?user_id=*' \\\n  --header 'Authorization: Token <api-key>'\n\n# Full project wipe \u2014 all four filters must be set to *\ncurl --request DELETE \\\n  --url 'https://api.mem0.ai/v1/memories/?user_id=*&agent_id=*&app_id=*&run_id=*' \\\n  --header 'Authorization: Token <api-key>'"
+						"source": "# Delete memories for a specific user\ncurl --request DELETE \\\n  --url 'https://api.mem0.ai/v1/memories/?user_id=<user_id>' \\\n  --header 'Authorization: Token <api-key>'\n\n# Delete memories for all users (wildcard)\ncurl --request DELETE \\\n  --url 'https://api.mem0.ai/v1/memories/?user_id=*' \\\n  --header 'Authorization: Token <api-key>'\n\n# Full project wipe — all four filters must be set to *\ncurl --request DELETE \\\n  --url 'https://api.mem0.ai/v1/memories/?user_id=*&agent_id=*&app_id=*&run_id=*' \\\n  --header 'Authorization: Token <api-key>'"
 					},
 					{
 						"lang": "Go",
@@ -1393,8 +1393,8 @@
 											},
 											"expiration_date": {
 												"type": "string",
-												"format": "date-time",
-												"description": "The date and time when the memory will expire. Format: YYYY-MM-DD.",
+												"format": "date",
+												"description": "The date when the memory will expire. Format: YYYY-MM-DD.",
 												"title": "Expiration date",
 												"nullable": true,
 												"default": null
@@ -1540,8 +1540,8 @@
 											},
 											"expiration_date": {
 												"type": "string",
-												"format": "date-time",
-												"description": "The date and time when the memory will expire. Format: YYYY-MM-DD.",
+												"format": "date",
+												"description": "The date when the memory will expire. Format: YYYY-MM-DD.",
 												"title": "Expiration date",
 												"nullable": true,
 												"default": null
@@ -1589,7 +1589,7 @@
 				"x-code-samples": [
 					{
 						"lang": "Python",
-						"source": "# To use the Python SDK, install the package:\n# pip install mem0ai\n\nfrom mem0 import MemoryClient\nclient = MemoryClient(api_key=\"your_api_key\")\n\nquery = \"Your search query here\"\n\nresults = client.search(query, user_id=\"<user_id>\")\nprint(results)"
+						"source": "# To use the Python SDK, install the package:\n# pip install mem0ai\n\nfrom mem0 import MemoryClient\nclient = MemoryClient(api_key=\"your_api_key\")\n\nquery = \"Your search query here\"\n\nresults = client.search(query, filters={\"user_id\": \"<user_id>\"})\nprint(results)"
 					},
 					{
 						"lang": "JavaScript",
@@ -1675,8 +1675,8 @@
 											},
 											"expiration_date": {
 												"type": "string",
-												"format": "date-time",
-												"description": "The date and time when the memory will expire. Format: YYYY-MM-DD.",
+												"format": "date",
+												"description": "The date when the memory will expire. Format: YYYY-MM-DD.",
 												"title": "Expiration date",
 												"nullable": true,
 												"default": null
@@ -1734,12 +1734,510 @@
 				"x-codegen-request-body-name": "data"
 			}
 		},
+		"/v3/memories/": {
+			"post": {
+				"tags": [
+					"memories"
+				],
+				"summary": "Get all memories (V3, paginated)",
+				"description": "List memories scoped by filters, paginated. Entity IDs **must** be passed inside the `filters` object — top-level `user_id` / `agent_id` / `run_id` are rejected with 400. `filters` supports the same operator set as V2 search (`AND`, `OR`, `NOT`, `in`, `gte`, `lte`, etc.). Response is a paginated envelope; pass `page` and `page_size` as query parameters to step through results.",
+				"operationId": "memories_list_v3",
+				"parameters": [
+					{
+						"in": "query",
+						"name": "page",
+						"schema": {
+							"type": "integer",
+							"minimum": 1,
+							"default": 1
+						},
+						"description": "1-indexed page number."
+					},
+					{
+						"in": "query",
+						"name": "page_size",
+						"schema": {
+							"type": "integer",
+							"minimum": 1,
+							"maximum": 200,
+							"default": 100
+						},
+						"description": "Results per page."
+					}
+				],
+				"requestBody": {
+					"required": true,
+					"content": {
+						"application/json": {
+							"schema": {
+								"type": "object",
+								"required": [
+									"filters"
+								],
+								"properties": {
+									"filters": {
+										"type": "object",
+										"description": "Entity and metadata filters. Must include at least one entity ID (`user_id`, `agent_id`, `app_id`, or `run_id`).",
+										"additionalProperties": true
+									}
+								}
+							},
+							"example": {
+								"filters": {
+									"user_id": "alice"
+								}
+							}
+						}
+					}
+				},
+				"responses": {
+					"200": {
+						"description": "Paginated envelope of memories.",
+						"content": {
+							"application/json": {
+								"schema": {
+									"type": "object",
+									"properties": {
+										"count": {
+											"type": "integer",
+											"description": "Total number of memories matching the filters."
+										},
+										"next": {
+											"type": "string",
+											"format": "uri",
+											"nullable": true,
+											"description": "URL for the next page, or `null` if this is the last page."
+										},
+										"previous": {
+											"type": "string",
+											"format": "uri",
+											"nullable": true,
+											"description": "URL for the previous page, or `null` if this is the first page."
+										},
+										"results": {
+											"type": "array",
+											"items": {
+												"type": "object",
+												"properties": {
+													"id": {
+														"type": "string",
+														"format": "uuid",
+														"description": "Unique memory identifier."
+													},
+													"memory": {
+														"type": "string",
+														"description": "The extracted memory fact."
+													},
+													"score": {
+														"type": "number",
+														"format": "float",
+														"minimum": 0,
+														"maximum": 1,
+														"description": "Combined multi-signal relevance score in [0, 1] (search responses only)."
+													},
+													"metadata": {
+														"type": "object",
+														"additionalProperties": true,
+														"description": "User-supplied metadata attached to the memory."
+													},
+													"categories": {
+														"type": "array",
+														"items": {
+															"type": "string"
+														}
+													},
+													"created_at": {
+														"type": "string",
+														"format": "date-time"
+													},
+													"updated_at": {
+														"type": "string",
+														"format": "date-time"
+													}
+												},
+												"required": [
+													"id",
+													"memory",
+													"created_at"
+												]
+											}
+										}
+									},
+									"required": [
+										"count",
+										"next",
+										"previous",
+										"results"
+									]
+								},
+								"example": {
+									"count": 123,
+									"next": "https://api.mem0.ai/v3/memories/?page=2&page_size=100",
+									"previous": null,
+									"results": [
+										{
+											"id": "mem-uuid",
+											"memory": "User moved to San Francisco from New York in January 2026",
+											"metadata": {},
+											"categories": [
+												"location"
+											],
+											"created_at": "2026-01-15T10:30:00Z",
+											"updated_at": "2026-01-15T10:30:00Z"
+										}
+									]
+								}
+							}
+						}
+					},
+					"400": {
+						"description": "Validation error — e.g. empty `filters` or no positively-scoped entity ID."
+					},
+					"401": {
+						"description": "Unauthorized — missing or invalid API key."
+					}
+				},
+				"security": [
+					{
+						"tokenAuth": []
+					}
+				],
+				"x-codeSamples": [
+					{
+						"lang": "cURL",
+						"source": "curl -X POST 'https://api.mem0.ai/v3/memories/?page=1&page_size=50' \\\n  -H \"Authorization: Token <api-key>\" \\\n  -H \"Content-Type: application/json\" \\\n  -d '{\"filters\": {\"user_id\": \"alice\"}}'"
+					},
+					{
+						"lang": "Python",
+						"source": "from mem0 import MemoryClient\n\nclient = MemoryClient(api_key=\"your-api-key\")\n\npage = client.get_all(filters={\"user_id\": \"alice\"}, page=1, page_size=50)\n# page == {\"count\": 123, \"next\": \"...\", \"previous\": None, \"results\": [...]}\nprint(page[\"count\"], len(page[\"results\"]))"
+					},
+					{
+						"lang": "JavaScript",
+						"source": "import MemoryClient from \"mem0ai\";\n\nconst client = new MemoryClient({ apiKey: \"your-api-key\" });\n\nconst page = await client.getAll({\n  filters: { userId: \"alice\" },\n  page: 1,\n  pageSize: 50,\n});\nconsole.log(page.count, page.results.length);"
+					}
+				]
+			}
+		},
+		"/v3/memories/add/": {
+			"post": {
+				"tags": [
+					"memories"
+				],
+				"summary": "Add memories (V3)",
+				"description": "Extract and store memories from a conversation using the V3 additive pipeline. Entity IDs (`user_id` / `agent_id` / `run_id`) are accepted at the top level. At least one entity ID is required so the memory is scoped to a session.",
+				"operationId": "memories_add_v3",
+				"requestBody": {
+					"required": true,
+					"content": {
+						"application/json": {
+							"schema": {
+								"type": "object",
+								"required": [
+									"messages"
+								],
+								"properties": {
+									"messages": {
+										"type": "array",
+										"description": "Conversation messages to extract memories from.",
+										"items": {
+											"type": "object",
+											"properties": {
+												"role": {
+													"type": "string",
+													"enum": [
+														"user",
+														"assistant",
+														"system"
+													]
+												},
+												"content": {
+													"type": "string"
+												}
+											},
+											"required": [
+												"role",
+												"content"
+											]
+										}
+									},
+									"user_id": {
+										"type": "string",
+										"description": "Scope memories to this user."
+									},
+									"agent_id": {
+										"type": "string",
+										"description": "Scope memories to this agent."
+									},
+									"run_id": {
+										"type": "string",
+										"description": "Scope memories to this session / run."
+									},
+									"metadata": {
+										"type": "object",
+										"additionalProperties": true,
+										"description": "User-supplied metadata to attach to each extracted memory."
+									},
+									"custom_instructions": {
+										"type": "string",
+										"description": "Project-level instructions that guide extraction for this call."
+									},
+									"infer": {
+										"type": "boolean",
+										"default": true,
+										"description": "When `false`, stores each message verbatim without running the extraction LLM."
+									}
+								}
+							},
+							"example": {
+								"messages": [
+									{
+										"role": "user",
+										"content": "I just moved to San Francisco from New York."
+									},
+									{
+										"role": "assistant",
+										"content": "Got it — I'll update your location."
+									}
+								],
+								"user_id": "alice"
+							}
+						}
+					}
+				},
+				"responses": {
+					"200": {
+						"description": "Memory addition queued; returns an event identifier clients can poll via `GET /v1/event/{event_id}/`.",
+						"content": {
+							"application/json": {
+								"schema": {
+									"type": "object",
+									"properties": {
+										"message": {
+											"type": "string"
+										},
+										"status": {
+											"type": "string",
+											"enum": [
+												"PENDING",
+												"SUCCEEDED",
+												"FAILED"
+											]
+										},
+										"event_id": {
+											"type": "string",
+											"format": "uuid"
+										}
+									}
+								},
+								"example": {
+									"message": "Memory processing has been queued for background execution",
+									"status": "PENDING",
+									"event_id": "2c4d1f44-4f7b-4b2f-9f6e-7b5b4f5a1234"
+								}
+							}
+						}
+					},
+					"400": {
+						"description": "Validation error — e.g. missing `messages` or no entity ID supplied."
+					},
+					"401": {
+						"description": "Unauthorized — missing or invalid API key."
+					}
+				},
+				"security": [
+					{
+						"tokenAuth": []
+					}
+				],
+				"x-codeSamples": [
+					{
+						"lang": "cURL",
+						"source": "curl -X POST https://api.mem0.ai/v3/memories/add/ \\\n  -H \"Authorization: Token <api-key>\" \\\n  -H \"Content-Type: application/json\" \\\n  -d '{\n    \"messages\": [\n      {\"role\": \"user\", \"content\": \"I just moved to San Francisco from New York.\"},\n      {\"role\": \"assistant\", \"content\": \"Got it — I\\u0027ll update your location.\"}\n    ],\n    \"user_id\": \"alice\"\n  }'"
+					},
+					{
+						"lang": "Python",
+						"source": "from mem0 import MemoryClient\n\nclient = MemoryClient(api_key=\"your-api-key\")\n\nresult = client.add(\n    messages=[\n        {\"role\": \"user\", \"content\": \"I just moved to San Francisco from New York.\"},\n        {\"role\": \"assistant\", \"content\": \"Got it — I'll update your location.\"}\n    ],\n    user_id=\"alice\",\n)\nprint(result)"
+					},
+					{
+						"lang": "JavaScript",
+						"source": "import MemoryClient from \"mem0ai\";\n\nconst client = new MemoryClient({ apiKey: \"your-api-key\" });\n\nconst result = await client.add(\n  [\n    { role: \"user\", content: \"I just moved to San Francisco from New York.\" },\n    { role: \"assistant\", content: \"Got it — I'll update your location.\" },\n  ],\n  { userId: \"alice\" }\n);\nconsole.log(result);"
+					}
+				]
+			}
+		},
+		"/v3/memories/search/": {
+			"post": {
+				"tags": [
+					"memories"
+				],
+				"summary": "Search memories (V3)",
+				"description": "Relevance-ranked search across stored memories. V3 uses hybrid retrieval — the returned `score` is a combined `[0, 1]` value; per-signal component scores are not exposed on the response. Entity IDs **must** be passed inside the `filters` object — top-level `user_id` / `agent_id` / `run_id` are rejected with 400. At least one entity ID is required.",
+				"operationId": "memories_search_v3",
+				"requestBody": {
+					"required": true,
+					"content": {
+						"application/json": {
+							"schema": {
+								"type": "object",
+								"required": [
+									"query",
+									"filters"
+								],
+								"properties": {
+									"query": {
+										"type": "string",
+										"minLength": 1,
+										"description": "Natural-language search query."
+									},
+									"filters": {
+										"type": "object",
+										"description": "Entity and metadata filters. Must include at least one entity ID (`user_id`, `agent_id`, `app_id`, or `run_id`). Supports `AND`, `OR`, `NOT`, and comparison operators (`in`, `gte`, `lte`, `gt`, `lt`, `contains`, `icontains`, `ne`).",
+										"additionalProperties": true
+									},
+									"top_k": {
+										"type": "integer",
+										"minimum": 1,
+										"maximum": 1000,
+										"default": 10,
+										"description": "Number of results to return."
+									},
+									"threshold": {
+										"type": "number",
+										"minimum": 0.0,
+										"maximum": 1.0,
+										"default": 0.1,
+										"description": "Minimum semantic relevance score. Pass `0.0` to disable filtering."
+									},
+									"rerank": {
+										"type": "boolean",
+										"default": false,
+										"description": "Apply the managed reranker for better ordering (adds latency)."
+									}
+								}
+							},
+							"example": {
+								"query": "where does the user live?",
+								"filters": {
+									"user_id": "alice"
+								},
+								"top_k": 10
+							}
+						}
+					}
+				},
+				"responses": {
+					"200": {
+						"description": "Ranked search results.",
+						"content": {
+							"application/json": {
+								"schema": {
+									"type": "object",
+									"properties": {
+										"results": {
+											"type": "array",
+											"items": {
+												"type": "object",
+												"properties": {
+													"id": {
+														"type": "string",
+														"format": "uuid",
+														"description": "Unique memory identifier."
+													},
+													"memory": {
+														"type": "string",
+														"description": "The extracted memory fact."
+													},
+													"score": {
+														"type": "number",
+														"format": "float",
+														"minimum": 0,
+														"maximum": 1,
+														"description": "Combined multi-signal relevance score in [0, 1] (search responses only)."
+													},
+													"metadata": {
+														"type": "object",
+														"additionalProperties": true,
+														"description": "User-supplied metadata attached to the memory."
+													},
+													"categories": {
+														"type": "array",
+														"items": {
+															"type": "string"
+														}
+													},
+													"created_at": {
+														"type": "string",
+														"format": "date-time"
+													},
+													"updated_at": {
+														"type": "string",
+														"format": "date-time"
+													}
+												},
+												"required": [
+													"id",
+													"memory",
+													"created_at"
+												]
+											}
+										}
+									},
+									"required": [
+										"results"
+									]
+								},
+								"example": {
+									"results": [
+										{
+											"id": "mem-uuid",
+											"memory": "User moved to San Francisco from New York in January 2026",
+											"score": 0.82,
+											"metadata": {},
+											"categories": [
+												"location"
+											],
+											"created_at": "2026-01-15T10:30:00Z",
+											"updated_at": "2026-01-15T10:30:00Z"
+										}
+									]
+								}
+							}
+						}
+					},
+					"400": {
+						"description": "Validation error — e.g. empty `query`, missing `filters`, or no positively-scoped entity ID."
+					},
+					"401": {
+						"description": "Unauthorized — missing or invalid API key."
+					}
+				},
+				"security": [
+					{
+						"tokenAuth": []
+					}
+				],
+				"x-codeSamples": [
+					{
+						"lang": "cURL",
+						"source": "curl -X POST https://api.mem0.ai/v3/memories/search/ \\\n  -H \"Authorization: Token <api-key>\" \\\n  -H \"Content-Type: application/json\" \\\n  -d '{\n    \"query\": \"where does the user live?\",\n    \"filters\": {\"user_id\": \"alice\"},\n    \"top_k\": 10\n  }'"
+					},
+					{
+						"lang": "Python",
+						"source": "from mem0 import MemoryClient\n\nclient = MemoryClient(api_key=\"your-api-key\")\n\nresults = client.search(\n    \"where does the user live?\",\n    filters={\"user_id\": \"alice\"},\n    top_k=10,\n)\nfor r in results[\"results\"]:\n    print(r[\"memory\"], r[\"score\"])"
+					},
+					{
+						"lang": "JavaScript",
+						"source": "import MemoryClient from \"mem0ai\";\n\nconst client = new MemoryClient({ apiKey: \"your-api-key\" });\n\nconst results = await client.search(\"where does the user live?\", {\n  filters: { userId: \"alice\" },\n  topK: 10,\n});\nfor (const r of results.results) {\n  console.log(r.memory, r.score);\n}"
+					}
+				]
+			}
+		},
 		"/v1/memories/{entity_type}/{entity_id}/": {
 			"get": {
 				"tags": [
 					"memories"
 				],
-				"operationId": "memories_read",
+				"operationId": "memories_entity_read",
 				"responses": {
 					"200": {
 						"description": "Successfully retrieved memories.",
@@ -5176,9 +5674,10 @@
 						"nullable": true
 					},
 					"expiration_date": {
-						"description": "The date and time when the memory will expire. Format: YYYY-MM-DD",
+						"description": "The date when the memory will expire. Format: YYYY-MM-DD",
 						"title": "Expiration date",
 						"type": "string",
+						"format": "date",
 						"nullable": true
 					},
 					"org_id": {
@@ -5742,4 +6241,4 @@
 		}
 	},
 	"x-original-swagger-version": "2.0"
-}
+}

docs/platform/features/async-client.mdx

@@ -62,11 +62,11 @@ Search for memories based on a query asynchronously.
 <CodeGroup>
 
 ```python Python
-await client.search("What is Alice's favorite sport?", user_id="alice")
+await client.search("What is Alice's favorite sport?", filters={"user_id": "alice"})
 ```
 
 ```javascript JavaScript
-await client.search("What is Alice's favorite sport?", { userId: "alice" });
+await client.search("What is Alice's favorite sport?", { filters: { userId: "alice" } });
 ```
 
 </CodeGroup>

docs/platform/features/direct-import.mdx

@@ -42,7 +42,7 @@ You can retrieve memories using the `search` method.
 <CodeGroup>
 
 ```python Python
-client.search("What is Alice's favorite sport?", user_id="alice")
+client.search("What is Alice's favorite sport?", filters={"user_id": "alice"})
 ```
 
 ```json Output

docs/platform/features/graph-threshold.mdx

@@ -1,210 +0,0 @@
----
-title: Configurable Graph Threshold
-description: "Configure the graph store threshold parameter to control how strictly nodes are matched during data ingestion."
----
-
-## Overview
-
-The graph store threshold parameter controls how strictly nodes are matched during graph data ingestion based on embedding similarity. This feature allows you to customize the matching behavior to prevent false matches or enable entity merging based on your specific use case.
-
-## Configuration
-
-Add the `threshold` parameter to your graph store configuration:
-
-```python
-from mem0 import Memory
-
-config = {
-    "graph_store": {
-        "provider": "neo4j",  # or memgraph, neptune, kuzu
-        "config": {
-            "url": "bolt://localhost:7687",
-            "username": "neo4j",
-            "password": "password"
-        },
-        "threshold": 0.7  # Default value, range: 0.0 to 1.0
-    }
-}
-
-memory = Memory.from_config(config)
-```
-
-## Parameters
-
-| Parameter | Type | Default | Range | Description |
-|-----------|------|---------|-------|-------------|
-| `threshold` | float | 0.7 | 0.0 - 1.0 | Minimum embedding similarity score required to match existing nodes during graph ingestion |
-
-## Use Cases
-
-### Strict Matching (UUIDs, IDs)
-
-Use higher thresholds (0.95-0.99) when working with identifiers that should remain distinct:
-
-```python
-config = {
-    "graph_store": {
-        "provider": "neo4j",
-        "config": {...},
-        "threshold": 0.95  # Strict matching
-    }
-}
-```
-
-**Example:** Prevents UUID collisions like `MXxBUE18QVBQTElDQVRJT058MjM3MTM4NjI5` being matched with `MXxBUE18QVBQTElDQVRJT058MjA2OTYxMzM`
-
-### Permissive Matching (Natural Language)
-
-Use lower thresholds (0.6-0.7) when entity variations should be merged:
-
-```python
-config = {
-    "graph_store": {
-        "threshold": 0.6  # Permissive matching
-    }
-}
-```
-
-**Example:** Merges similar entities like "Bob" and "Robert" as the same person.
-
-## Threshold Guidelines
-
-| Use Case | Recommended Threshold | Behavior |
-|----------|----------------------|----------|
-| UUIDs, IDs, Keys | 0.95 - 0.99 | Prevent false matches between similar identifiers |
-| Structured Data | 0.85 - 0.9 | Balanced precision and recall |
-| General Purpose | 0.7 - 0.8 | Default recommendation |
-| Natural Language | 0.6 - 0.7 | Allow entity variations to merge |
-
-## Examples
-
-### Example 1: Preventing Data Loss with UUIDs
-
-```python
-from mem0 import Memory
-
-config = {
-    "graph_store": {
-        "provider": "neo4j",
-        "config": {
-            "url": "bolt://localhost:7687",
-            "username": "neo4j",
-            "password": "password"
-        },
-        "threshold": 0.98  # Very strict for UUIDs
-    }
-}
-
-memory = Memory.from_config(config)
-
-# These UUIDs create separate nodes instead of being incorrectly merged
-memory.add(
-    [{"role": "user", "content": "MXxBUE18QVBQTElDQVRJT058MjM3MTM4NjI5 relates to Project A"}],
-    user_id="user1"
-)
-
-memory.add(
-    [{"role": "user", "content": "MXxBUE18QVBQTElDQVRJT058MjA2OTYxMzM relates to Project B"}],
-    user_id="user1"
-)
-```
-
-### Example 2: Merging Entity Variations
-
-```python
-config = {
-    "graph_store": {
-        "provider": "neo4j",
-        "config": {...},
-        "threshold": 0.6  # More permissive
-    }
-}
-
-memory = Memory.from_config(config)
-
-# These will be merged as the same entity
-memory.add([{"role": "user", "content": "Bob works at Google"}], user_id="user1")
-memory.add([{"role": "user", "content": "Robert works at Google"}], user_id="user1")
-```
-
-### Example 3: Different Thresholds for Different Clients
-
-```python
-# Client 1: Strict matching for transactional data
-memory_strict = Memory.from_config({
-    "graph_store": {"threshold": 0.95}
-})
-
-# Client 2: Permissive matching for conversational data
-memory_permissive = Memory.from_config({
-    "graph_store": {"threshold": 0.6}
-})
-```
-
-## Supported Graph Providers
-
-The threshold parameter works with all graph store providers:
-
-- ✅ Neo4j
-- ✅ Memgraph
-- ✅ Kuzu
-- ✅ Neptune (both Analytics and DB)
-
-## How It Works
-
-When adding a relation to the graph:
-
-1. **Embedding Generation**: The system generates embeddings for source and destination entities
-2. **Node Search**: Searches for existing nodes with similar embeddings
-3. **Threshold Comparison**: Compares similarity scores against the configured threshold
-4. **Decision**:
-   - If similarity ≥ threshold: Uses the existing node
-   - If similarity < threshold: Creates a new node
-
-```python
-# Pseudocode
-if node_similarity >= threshold:
-    use_existing_node()
-else:
-    create_new_node()
-```
-
-## Troubleshooting
-
-### Issue: Duplicate nodes being created
-
-**Symptom**: Expected nodes to merge but they're created separately
-
-**Solution**: Lower the threshold
-```python
-config = {"graph_store": {"threshold": 0.6}}
-```
-
-### Issue: Unrelated entities being merged
-
-**Symptom**: Different entities incorrectly matched as the same node
-
-**Solution**: Raise the threshold
-```python
-config = {"graph_store": {"threshold": 0.95}}
-```
-
-### Issue: Validation error
-
-**Symptom**: `ValidationError: threshold must be between 0.0 and 1.0`
-
-**Solution**: Ensure threshold is in valid range
-```python
-config = {"graph_store": {"threshold": 0.7}}  # Valid: 0.0 ≤ x ≤ 1.0
-```
-
-## Backward Compatibility
-
-- **Default Value**: 0.7 (maintains existing behavior)
-- **Optional Parameter**: Existing code works without any changes
-- **No Breaking Changes**: Graceful fallback if not specified
-
-## Related
-
-- [Graph Memory](/open-source/features/graph-memory)
-- [Issue #3590](https://github.com/mem0ai/mem0/issues/3590)

docs/platform/features/group-chat.mdx

@@ -3,8 +3,6 @@ title: Group Chat
 description: 'Enable multi-participant conversations with automatic memory attribution to individual speakers'
 ---
 
-<Snippet file="paper-release.mdx" />
-
 ## Overview
 
 The Group Chat feature enables Mem0 to process conversations involving multiple participants and automatically attribute memories to individual speakers. This allows for precise tracking of each participant's preferences, characteristics, and contributions in collaborative discussions, team meetings, or multi-agent conversations.