chore: update changelog, bump SDK versions to Python 2.0.11 and TypeScript 3.0.13 (#6031)

Signed-off-by: Hrushikesh Yadav <yadavhrushikesh65@gmail.com>

.claude-plugin/marketplace.json

@@ -12,7 +12,7 @@
       "name": "mem0",
       "source": "./integrations/mem0-plugin",
       "description": "Mem0 memory layer for AI applications. Add persistent memory, personalization, and semantic search to Claude workflows.",
-      "version": "0.2.11"
+      "version": "0.2.12"
     }
   ]
 }

.cursor-plugin/marketplace.json

@@ -12,7 +12,7 @@
       "name": "mem0",
       "source": "./integrations/mem0-plugin",
       "description": "Mem0 memory layer for AI applications. Add persistent memory, personalization, and semantic search.",
-      "version": "0.2.11"
+      "version": "0.2.12"
     }
   ]
 }

CONTRIBUTING.md

@@ -1,72 +1,157 @@
-# Contributing to mem0
+# Contributing to Mem0
 
-Let us make contribution easy, collaborative and fun.
+First off, thank you for taking the time to contribute! 🎉 Mem0 is a
+community-driven project and we welcome contributions of all kinds — bug fixes,
+new features, documentation, examples, and integrations.
 
-## Submit your Contribution through PR
+Mem0 is a polyglot monorepo, and this guide covers contributing to both the
+**Python SDK** and the **TypeScript SDK** (and the rest of the repository).
 
-To make a contribution, follow these steps:
+## Before You Start
 
-1. Fork and clone this repository
-2. Do the changes on your fork with dedicated feature branch `feature/f1`
-3. If you modified the code (new feature or bug-fix), please add tests for it
-4. Include proper documentation / docstring and examples to run the feature
-5. Ensure that all tests pass
-6. Submit a pull request
+### 1. Open an Issue First
 
-For more details about pull requests, please read [GitHub's guides](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request).
+**Always open an issue before opening a pull request.** This lets us discuss the
+change, avoid duplicate effort, and agree on the approach before you invest time
+in code.
 
+- Search [existing issues](https://github.com/mem0ai/mem0/issues) first to see if
+  your bug or idea already exists.
+- If it doesn't, open a
+  [bug report](https://github.com/mem0ai/mem0/issues/new?template=bug_report.yml) or
+  [feature request](https://github.com/mem0ai/mem0/issues/new?template=feature_request.yml).
+- For anything beyond a trivial fix, wait for a maintainer to confirm the approach
+  before starting significant work.
 
-### 📦 Development Environment
+Every pull request must link to an issue using `Closes #<issue-number>`.
 
-We use `hatch` for managing development environments. To set up:
+### 2. Sign the Contributor License Agreement (CLA)
+
+**We cannot accept or merge any pull request until you have signed our Contributor
+License Agreement (CLA).**
+
+When you open your first PR, the CLA bot will automatically comment with a link to
+sign. Signing takes less than a minute and only needs to be done once. Pull
+requests from contributors who have not signed the CLA will be blocked from
+merging.
+
+## Repository Layout
+
+The two most common contribution targets are the SDKs:
+
+| Package               | Path       | Language     | Package manager |
+| --------------------- | ---------- | ------------ | --------------- |
+| Python SDK (`mem0ai`) | `mem0/`    | Python 3.9+  | `hatch`         |
+| TypeScript SDK (`mem0ai`) | `mem0-ts/` | TypeScript | `pnpm`        |
+
+Other packages include the CLIs (`cli/python/`, `cli/node/`), integrations
+(`integrations/`), the self-hosted `server/`, `openmemory/`, and the docs site
+(`docs/`). See [AGENTS.md](./AGENTS.md) for a full map of the repository.
+
+## Development Workflow
+
+1. **Fork** the repository and **clone** your fork.
+2. Create a **feature branch** from `main` (e.g. `feature/my-new-feature` or
+   `fix/issue-1234`).
+3. Make your changes — add **tests**, **documentation**, and **examples** as
+   appropriate.
+4. Run **linting and tests** for every package you touched (see below).
+5. Commit using [Conventional Commits](https://www.conventionalcommits.org/)
+   (e.g. `feat:`, `fix:`, `docs:`, `refactor:`, `test:`).
+6. Push and open a **pull request** against `main`, linking the issue with
+   `Closes #<number>` and filling out the
+   [PR template](./.github/PULL_REQUEST_TEMPLATE.md).
+
+### Contributing to the Python SDK (`mem0/`)
+
+We use [`hatch`](https://hatch.pypa.io/latest/install/) to manage environments.
+**Do not use `pip` or `conda` for dependency management.**
 
 ```bash
-# Activate environment for specific Python version:
-hatch shell dev_py_3_9   # Python 3.9
-hatch shell dev_py_3_10  # Python 3.10  
-hatch shell dev_py_3_11  # Python 3.11
-hatch shell dev_py_3_12  # Python 3.12
+# Activate a dev environment (3.9 / 3.10 / 3.11 / 3.12)
+hatch shell dev_py_3_11
 
-# The environment will automatically install all dev dependencies
-# Run tests within the activated shell:
-make test
-```
-
-### 📌 Pre-commit
-
-To ensure our standards, make sure to install pre-commit before starting to contribute.
-
-```bash
+# Install pre-commit hooks (runs ruff + isort on commit)
 pre-commit install
+
+# Lint, format, and sort imports
+make lint
+make format
+make sort
+
+# Run the test suite (run `make install_all` first if deps are missing)
+make test
 ```
 
-### 🧪 Testing
+- **Linter / formatter:** Ruff (line length **120**)
+- **Import sorting:** isort (`profile = "black"`)
+- **Tests:** pytest (in `tests/`)
 
-We use `pytest` to test our code across multiple Python versions. You can run tests using:
+See the full [Development guide](https://docs.mem0.ai/contributing/development) for
+environment details.
+
+### Contributing to the TypeScript SDK (`mem0-ts/`)
+
+We use [`pnpm`](https://pnpm.io/) (v10+) for all TypeScript packages. **Do not use
+`npm` or `yarn`.**
 
 ```bash
-# Run tests with default Python version
-make test
+cd mem0-ts
+pnpm install
 
-# Test specific Python versions:
-make test-py-3.9   # Python 3.9 environment
-make test-py-3.10  # Python 3.10 environment
-make test-py-3.11  # Python 3.11 environment
-make test-py-3.12  # Python 3.12 environment
-
-# When using hatch shells, run tests with:
-make test  # After activating a shell with hatch shell test_XX
+pnpm run build        # tsup (CJS + ESM)
+pnpm run test         # jest (all tests)
+pnpm run test:unit    # unit tests with coverage
 ```
 
-Make sure that all tests pass across all supported Python versions before submitting a pull request.
+- **Build:** tsup
+- **Formatter:** Prettier
+- **Tests:** jest
+- Always run type checking after changes: `pnpm run typecheck` (or `tsc --noEmit`).
+- Use ES module `import` syntax — never `require()`.
 
-We look forward to your pull requests and can't wait to see your contributions!
+## Good Contribution Practices
 
-### 🚀 Releasing
+- **Keep PRs small and focused.** One logical change per PR is easier to review and
+  merge.
+- **Follow existing patterns.** Match the style, structure, and conventions of the
+  code around you. Don't introduce new frameworks or abstractions without
+  discussion.
+- **Write tests** that would fail without your change — regression tests for bugs,
+  coverage for new features.
+- **Update documentation** in `docs/` for any user-facing change. New `.mdx` pages
+  must be added to `docs/llms.txt` (run
+  `python scripts/check-llms-txt-coverage.py --write` to scaffold entries).
+- **Add examples** when introducing new user-facing behavior.
+- **Run linters and tests locally** before pushing — CI re-runs them on every PR
+  via the CI Gate.
+- **Never commit secrets** — no `.env` files, API keys, or credentials.
+- **Don't add core dependencies lightly.** New Python dependencies belong in an
+  optional group in `pyproject.toml`, not the core `dependencies` list.
+- **Be responsive** to review feedback and keep your branch up to date with `main`.
 
-All packages are published automatically via GitHub Actions when a GitHub Release is created with the correct tag prefix.
+## Pull Request Checklist
 
-#### Tag Prefixes
+Before requesting review, make sure:
+
+- [ ] An issue exists and is linked with `Closes #<number>`
+- [ ] You have signed the CLA
+- [ ] Your code follows the project's style guidelines (lint passes)
+- [ ] You performed a self-review of your changes
+- [ ] Tests are added/updated and pass locally
+- [ ] Documentation is updated if needed
+
+## Reporting Security Issues
+
+**Do not report security vulnerabilities through public issues or pull requests.**
+Please follow our [Security Policy](./SECURITY.md) to report them privately.
+
+## Releasing
+
+All packages are published automatically via GitHub Actions when a GitHub Release
+is created with the correct tag prefix.
+
+### Tag Prefixes
 
 | Package | Registry | Tag Prefix | Example |
 |---------|----------|------------|---------|
@@ -77,15 +162,17 @@ All packages are published automatically via GitHub Actions when a GitHub Releas
 | `@mem0/vercel-ai-provider` | npm | `vercel-ai-v*` | `vercel-ai-v2.0.6` |
 | `@mem0/openclaw-mem0` | npm | `openclaw-v*` | `openclaw-v1.0.1` |
 
-#### How to Release
+### How to Release
 
 1. Bump the version in `pyproject.toml` (Python) or `package.json` (Node)
 2. Create a [GitHub Release](https://github.com/mem0ai/mem0/releases/new) with the matching tag prefix
 3. The correct workflow will trigger automatically — verify in the [Actions tab](https://github.com/mem0ai/mem0/actions)
 
-#### Publishing Details
+### Publishing Details
 
 - **PyPI packages** use OIDC trusted publishing via `pypa/gh-action-pypi-publish`
 - **npm packages** use OIDC trusted publishing via npm CLI (>= 11.5.1) — no tokens or secrets required
 - All workflows require `permissions: id-token: write` for OIDC authentication
 - First publish of a new npm package must be done manually; OIDC works for subsequent versions
+
+We look forward to your pull requests and can't wait to see your contributions!

SECURITY.md

@@ -0,0 +1,48 @@
+# Security Policy
+
+We take the security of Mem0 and our community seriously. Thank you for helping
+keep Mem0 and its users safe by disclosing vulnerabilities responsibly.
+
+## Reporting a Vulnerability
+
+Please **do not** report security vulnerabilities through public GitHub issues,
+pull requests, or discussions.
+
+If you believe you have found a security vulnerability in Mem0, please report it
+privately through one of the following channels:
+
+1. **GitHub Private Vulnerability Reporting** — open a
+   [private security advisory](https://github.com/mem0ai/mem0/security/advisories/new)
+   directly on this repository.
+2. **Email** the maintainers at **support@mem0.ai** with the subject line:
+
+   `SECURITY: Mem0 vulnerability report`
+
+To help us triage and resolve the issue quickly, please include as much of the
+following as you can:
+
+- Affected component or package (e.g. Python SDK, TypeScript SDK, server, OpenMemory)
+- Affected version, tag, or commit
+- Clear, step-by-step reproduction instructions
+- The security impact and a proof of concept, if available
+- Any suggested fix or mitigation
+
+## Response Process
+
+- We will acknowledge receipt of your report within **72 hours**.
+- We will work with you privately to confirm the issue and assess its impact.
+- Once a fix or mitigation is ready, we will coordinate a disclosure timeline
+  with you and credit you for the discovery, unless you prefer to remain anonymous.
+
+## Public Disclosure
+
+Please avoid sharing technical details of the vulnerability publicly until the
+maintainers have reviewed the issue and a fix or mitigation has been released. We
+are committed to resolving valid reports promptly and keeping you informed
+throughout the process.
+
+## Supported Versions
+
+We release security fixes against the latest published version of each package.
+Whenever possible, please reproduce the issue on the most recent release before
+reporting.

cli/node/CHANGELOG.md

@@ -1,60 +0,0 @@
-# Changelog
-
-All notable changes to `@mem0/cli` are documented here.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [0.2.9] — 2026-06-19
-
-### Security
-
-- Telemetry no longer passes the Mem0 API key to its child process via
-  command-line arguments. The context is now sent over stdin, so the key is no
-  longer visible in the process list (`ps`, `/proc/<pid>/cmdline`, Activity
-  Monitor). Fixes #4862.
-
-## [0.2.8] — 2026-06-01
-
-### Security
-
-- Pinned transitive dependencies via pnpm overrides to remediate high-severity CVEs:
-  - `jws` → 4.0.1 (CVE-2025-65945)
-  - `langsmith` → ^0.6.0 (CVE-2026-45134)
-  - `tar-fs` → ^2.1.4 (CVE-2025-48387, CVE-2025-59343)
-  - `picomatch` → ^2.3.2 (CVE-2026-33671)
-  - `minimatch` → ^3.1.3 / ^5.1.8 / ^9.0.7 (CVE-2026-27903, CVE-2026-27904, CVE-2026-26996)
-  - `path-to-regexp` → ^8.4.0 (CVE-2026-4926)
-  - `rollup` → ^4.59.0 (CVE-2026-27606)
-  - `glob` → ^10.5.0 (CVE-2025-64756)
-  - `@modelcontextprotocol/sdk` → ^1.25.4 (CVE-2025-66414, CVE-2026-0621)
-
-## [0.2.7] — 2026-05-20
-
-### Added
-
-- `mem0 whoami` — print the active agent's `default_user_id` (the AGENTRUSH
-  leaderboard identifier). Reads from local config, no network call.
-- `mem0 agent-rush <add | search>` — subcommand group that wraps the new
-  `/v1/agent-rush/` platform endpoints for the 7-day AGENTRUSH game. Project
-  routing is implicit (resolved server-side); no flags exposed. Pretty-prints
-  platform error codes into actionable hints (e.g. `agentrush_search_first`
-  → "Run 3 'mem0 agent-rush search' commands before adding.").
-- PII safety prompt on first `mem0 agent-rush add`. Interactive runs require
-  explicit `y` to acknowledge that AGENTRUSH memories are public; the
-  acknowledgement is persisted in `~/.mem0/config.json` under
-  `agent_rush.acknowledged_at` so the prompt only appears once per machine.
-  Non-interactive (agent) invocations surface the warning to stderr without
-  blocking.
-- New config schema field: `agent_rush.acknowledged_at` (ISO timestamp,
-  empty until first interactive acknowledgement).
-
-### Changed
-
-- HTTP requests from the new agent-rush commands send `X-Mem0-Mode: agent-rush`
-  in addition to the existing source headers, so platform telemetry can split
-  game traffic from regular CLI usage.
-
-## [0.2.6] and earlier
-
-Unlogged historical releases. See git history under `cli/node/`.

cli/node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mem0/cli",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "description": "The official CLI for mem0 — the memory layer for AI agents",
   "type": "module",
   "bin": {

cli/node/src/backend/platform.ts

@@ -316,16 +316,18 @@ export class PlatformBackend implements Backend {
 		if (entities.length === 0) {
 			throw new Error("At least one entity ID is required for deleteEntities.");
 		}
-		// Delete each provided entity via the v2 path-based endpoint
-		let result: Record<string, unknown> = {};
+		// Delete each provided entity via the v2 path-based endpoint. Key each
+		// response by entity type so a multi-entity delete (e.g. --user-id and
+		// --agent-id together) doesn't discard everything but the last result.
+		const results: Record<string, unknown> = {};
 		for (const [entityType, entityId] of entities) {
-			result = (await this._request(
+			results[entityType] = (await this._request(
 				"DELETE",
 				`/v2/entities/${entityType}/${entityId}/`,
 				{ params: { source: "CLI" } },
 			)) as Record<string, unknown>;
 		}
-		return result;
+		return results;
 	}
 
 	async ping(): Promise<Record<string, unknown>> {

cli/node/tests/platform-backend.test.ts

@@ -0,0 +1,52 @@
+/**
+ * Tests for the Platform backend (mem0 Platform API client).
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import { PlatformBackend } from "../src/backend/platform.js";
+import { createDefaultConfig } from "../src/config.js";
+
+function makeBackend(): PlatformBackend {
+  // apiKey/baseUrl only build request headers; every test spies on _request,
+  // so no real network calls are made.
+  return new PlatformBackend(createDefaultConfig().platform);
+}
+
+describe("deleteEntities", () => {
+  it("returns all results keyed by entity type for a multi-entity delete", async () => {
+    const backend = makeBackend();
+    const responses: Record<string, unknown> = {
+      "/v2/entities/user/alice/": { message: "user deleted" },
+      "/v2/entities/agent/bob/": { message: "agent deleted" },
+    };
+    const spy = vi
+      // biome-ignore lint/suspicious/noExplicitAny: spying on a private method
+      .spyOn(backend as any, "_request")
+      .mockImplementation(async (_method: string, path: string) => responses[path]);
+
+    const result = await backend.deleteEntities({ userId: "alice", agentId: "bob" });
+
+    // Regression: previously only the last entity's response survived.
+    expect(result).toEqual({
+      user: { message: "user deleted" },
+      agent: { message: "agent deleted" },
+    });
+    expect(spy).toHaveBeenCalledTimes(2);
+  });
+
+  it("keys a single-entity delete by its type", async () => {
+    const backend = makeBackend();
+    // biome-ignore lint/suspicious/noExplicitAny: spying on a private method
+    vi.spyOn(backend as any, "_request").mockResolvedValue({ message: "user deleted" });
+
+    const result = await backend.deleteEntities({ userId: "alice" });
+    expect(result).toEqual({ user: { message: "user deleted" } });
+  });
+
+  it("throws when no entity id is provided", async () => {
+    const backend = makeBackend();
+    await expect(backend.deleteEntities({})).rejects.toThrow(
+      "At least one entity ID is required",
+    );
+  });
+});

cli/python/CHANGELOG.md

@@ -1,49 +0,0 @@
-# Changelog
-
-All notable changes to `mem0-cli` (Python) are documented here.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [0.2.8] — 2026-06-19
-
-### Security
-
-- Telemetry no longer passes the Mem0 API key to its child process via
-  command-line arguments. The context is now sent over stdin, so the key is no
-  longer visible in the process list (`ps`, `/proc/<pid>/cmdline`, Activity
-  Monitor). Fixes #4862.
-
-### Fixed
-
-- `__version__` now matches the packaged version (was stale at 0.2.4).
-
-## [0.2.7] — 2026-05-20
-
-### Added
-
-- `mem0 whoami` — print the active agent's `default_user_id` (the AGENTRUSH
-  leaderboard identifier). Reads from local config, no network call.
-- `mem0 agent-rush <add | search>` — subcommand group that wraps the new
-  `/v1/agent-rush/` platform endpoints for the 7-day AGENTRUSH game. Project
-  routing is implicit (resolved server-side); no flags exposed. Pretty-prints
-  platform error codes into actionable hints (e.g. `agentrush_search_first`
-  → "Run 3 'mem0 agent-rush search' commands before adding.").
-- PII safety prompt on first `mem0 agent-rush add`. Interactive runs require
-  explicit `y` to acknowledge that AGENTRUSH memories are public; the
-  acknowledgement is persisted in `~/.mem0/config.json` under
-  `agent_rush.acknowledged_at` so the prompt only appears once per machine.
-  Non-interactive (agent) invocations surface the warning to stderr without
-  blocking.
-- New config schema field: `agent_rush.acknowledged_at` (ISO timestamp,
-  empty until first interactive acknowledgement).
-
-### Changed
-
-- HTTP requests from the new agent-rush commands send `X-Mem0-Mode: agent-rush`
-  in addition to the existing source headers, so platform telemetry can split
-  game traffic from regular CLI usage.
-
-## [0.2.6] and earlier
-
-Unlogged historical releases. See git history under `cli/python/`.

cli/python/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mem0-cli"
-version = "0.2.8"
+version = "0.2.9"
 description = "The official CLI for mem0 — the memory layer for AI agents"
 readme = "README.md"
 license = "Apache-2.0"

cli/python/src/mem0_cli/__init__.py

@@ -1,3 +1,3 @@
 """mem0 CLI — the command-line interface for the mem0 memory layer."""
 
-__version__ = "0.2.8"
+__version__ = "0.2.9"

cli/python/src/mem0_cli/backend/platform.py

@@ -296,13 +296,15 @@ class PlatformBackend(Backend):
         entities = {t: v for t, v in type_map.items() if v}
         if not entities:
             raise ValueError("At least one entity ID is required for delete_entities.")
-        # Delete each provided entity via the v2 path-based endpoint
-        result: dict = {}
+        # Delete each provided entity via the v2 path-based endpoint. Key each
+        # response by entity type so a multi-entity delete (e.g. --user-id and
+        # --agent-id together) doesn't discard everything but the last result.
+        results: dict = {}
         for entity_type, entity_id in entities.items():
-            result = self._request(
+            results[entity_type] = self._request(
                 "DELETE", f"/v2/entities/{entity_type}/{entity_id}/", params={"source": "CLI"}
             )
-        return result
+        return results
 
     def ping(self, timeout: float | None = None) -> dict:
         """Call the ping endpoint and return the raw response.

cli/python/src/mem0_cli/config.py

@@ -235,7 +235,10 @@ def set_nested_value(config: Mem0Config, dotted_key: str, value: str) -> bool:
     if isinstance(current, bool):
         value = value.lower() in ("true", "1", "yes")  # type: ignore[assignment]
     elif isinstance(current, int):
-        value = int(value)  # type: ignore[assignment]
+        try:
+            value = int(value)  # type: ignore[assignment]
+        except ValueError:
+            return False
 
     setattr(obj, final_key, value)
     return True

cli/python/src/mem0_cli/output.py

@@ -20,8 +20,8 @@ def format_memories_text(console: Console, memories: list[dict], title: str = "m
     console.print(f"\n[{BRAND_COLOR}]Found {count} {title}:[/]\n")
 
     for i, mem in enumerate(memories, 1):
-        memory_text = mem.get("memory", mem.get("text", ""))
-        mem_id = mem.get("id", "")[:8]
+        memory_text = mem.get("memory") or mem.get("text") or ""
+        mem_id = (mem.get("id") or "")[:8]
         score = mem.get("score")
         created = _format_date(mem.get("created_at"))
         category = mem.get("categories", [None])
@@ -67,8 +67,8 @@ def format_memories_table(
     table.add_column("Created", max_width=12)
 
     for mem in memories:
-        mem_id = mem.get("id", "")
-        memory_text = mem.get("memory", mem.get("text", ""))
+        mem_id = mem.get("id") or ""
+        memory_text = mem.get("memory") or mem.get("text") or ""
         if len(memory_text) > 60:
             memory_text = memory_text[:57] + "..."
         categories = mem.get("categories", [])
@@ -104,8 +104,8 @@ def format_single_memory(console: Console, mem: dict, output: str = "text") -> N
         format_json(console, mem)
         return
 
-    memory_text = mem.get("memory", mem.get("text", ""))
-    mem_id = mem.get("id", "")
+    memory_text = mem.get("memory") or mem.get("text") or ""
+    mem_id = mem.get("id") or ""
 
     lines = []
     lines.append(f"  [white bold]{memory_text}[/]")

cli/python/tests/test_config.py

@@ -139,6 +139,11 @@ class TestNestedAccess:
         assert set_nested_value(config, "platform.api_key", "new-key")
         assert config.platform.api_key == "new-key"
 
+    def test_set_int_value_rejects_invalid_input(self):
+        config = Mem0Config()
+        assert set_nested_value(config, "version", "abc") is False
+        assert config.version == 1
+
     def test_set_nonexistent_key(self):
         config = Mem0Config()
         assert set_nested_value(config, "nonexistent.key", "val") is False

cli/python/tests/test_output.py

@@ -54,6 +54,11 @@ class TestTextFormat:
         output = buf.getvalue()
         assert "Found 0" in output
 
+    def test_format_memories_text_handles_null_fields(self):
+        console, buf = _make_console()
+        format_memories_text(console, [{"id": None, "memory": None, "created_at": None}])
+        assert "Found 1 memories" in buf.getvalue()
+
 
 class TestTableFormat:
     def test_format_memories_table(self):
@@ -70,6 +75,13 @@ class TestTableFormat:
         # Should still render (empty table)
         assert "ID" in output
 
+    def test_format_memories_table_handles_null_fields(self):
+        console, buf = _make_console()
+        format_memories_table(console, [{"id": None, "memory": None, "created_at": None}])
+        output = buf.getvalue()
+        assert "ID" in output
+        assert "Memory" in output
+
 
 class TestSingleMemory:
     def test_format_single_memory_text(self):
@@ -87,6 +99,17 @@ class TestSingleMemory:
         output = buf.getvalue()
         assert '"memory"' in output
 
+    def test_format_single_memory_handles_null_fields(self):
+        console, buf = _make_console()
+        format_single_memory(
+            console,
+            {"id": None, "memory": None, "text": "Fallback memory", "created_at": None},
+            "text",
+        )
+        output = buf.getvalue()
+        assert "Fallback memory" in output
+        assert "ID:" not in output
+
 
 class TestAddResult:
     def test_format_add_result_text(self):

cli/python/tests/test_platform_backend.py

@@ -0,0 +1,46 @@
+"""Tests for the Platform backend (mem0 Platform API client)."""
+
+from __future__ import annotations
+
+from unittest.mock import patch
+
+from mem0_cli.backend.platform import PlatformBackend
+from mem0_cli.config import PlatformConfig
+
+
+def _make_backend() -> PlatformBackend:
+    # api_key/base_url are only used to build the httpx client; every test here
+    # patches _request, so no real network calls are made.
+    return PlatformBackend(PlatformConfig(api_key="test-key", base_url="https://api.mem0.ai"))
+
+
+class TestDeleteEntities:
+    def test_multiple_entities_returns_all_results(self):
+        backend = _make_backend()
+        responses = {
+            "/v2/entities/user/alice/": {"message": "user deleted"},
+            "/v2/entities/agent/bob/": {"message": "agent deleted"},
+        }
+        with patch.object(backend, "_request") as mock_request:
+            mock_request.side_effect = lambda method, path, **kw: responses[path]
+            result = backend.delete_entities(user_id="alice", agent_id="bob")
+
+        # Regression: previously only the last entity's response survived.
+        assert result == {
+            "user": {"message": "user deleted"},
+            "agent": {"message": "agent deleted"},
+        }
+        assert mock_request.call_count == 2
+
+    def test_single_entity_keyed_by_type(self):
+        backend = _make_backend()
+        with patch.object(backend, "_request", return_value={"message": "user deleted"}):
+            result = backend.delete_entities(user_id="alice")
+        assert result == {"user": {"message": "user deleted"}}
+
+    def test_no_entities_raises(self):
+        backend = _make_backend()
+        import pytest
+
+        with pytest.raises(ValueError):
+            backend.delete_entities()

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

@@ -4,7 +4,7 @@ description: "Add facts, messages, or metadata to a user memory store with async
 openapi: post /v3/memories/add/
 ---
 
-Extract and store memories from a conversation using the V3 additive pipeline. The endpoint uses single-pass ADD-only extraction — one LLM call, no UPDATE/DELETE. Memories accumulate over time; nothing is overwritten.
+Extract and store memories from a conversation using the V3 additive pipeline. The endpoint uses single-pass ADD-only extraction: one LLM call, no UPDATE/DELETE. Memories accumulate over time; nothing is overwritten.
 
 ## Endpoint
 
@@ -50,6 +50,7 @@ Provide conversation messages for Mem0 to extract memories from. At least one en
 | `app_id` | string | No* | Associates the memory with an app. |
 | `metadata` | object | Optional | Custom key/value metadata (e.g., `{"topic": "preferences"}`). |
 | `infer` | boolean (default `true`) | Optional | Set to `false` to skip inference and store the provided text as-is. |
+| `expiration_date` | string | Optional | Date in `YYYY-MM-DD` format. The memory is visible through this date and hidden by default after it passes. |
 
 > \* At least one entity ID (`user_id`, `agent_id`, `app_id`, or `run_id`) is required.
 
@@ -83,3 +84,11 @@ The request is queued for background processing. The response contains an `event
 <Info>
 Poll the event status via `GET /v1/event/{event_id}/`. Status will be `SUCCEEDED` or `FAILED` once processing completes.
 </Info>
+
+<Info>
+Memories with `expiration_date` remain stored after they expire. Search and get-all hide them by default; pass `show_expired: true` to include them.
+</Info>
+
+<Info>
+Python uses `expiration_date`; TypeScript uses `expirationDate`.
+</Info>

docs/api-reference/memory/create-memory-export.mdx

@@ -4,4 +4,4 @@ description: "Submit an export job to create a structured memory export using a
 openapi: post /v1/exports/
 ---
 
-Submit a job to create a structured export of memories using a customizable Pydantic schema. This process may take some time to complete, especially if you're exporting a large number of memories. You can tailor the export by applying various filters (e.g., `user_id`, `agent_id`, `run_id`, or `session_id`) and by modifying the Pydantic schema to ensure the final data matches your exact needs.
+Submit a job to create a structured export of memories using a customizable Pydantic schema. This process may take some time to complete, especially if you're exporting a large number of memories. You can tailor the export by applying various filters (e.g., `user_id`, `agent_id`, `app_id`, or `run_id`) and by modifying the Pydantic schema to ensure the final data matches your exact needs.

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

@@ -4,7 +4,11 @@ description: "Retrieve memories with paginated results and advanced filtering us
 openapi: post /v3/memories/
 ---
 
-List memories scoped by filters with paginated results. Entity IDs (`user_id`, `agent_id`, `app_id`, `run_id`) **must** be passed inside the `filters` object — top-level entity IDs are rejected with 400.
+List memories scoped by filters with paginated results. Entity IDs (`user_id`, `agent_id`, `app_id`, `run_id`) **must** be passed inside the `filters` object: top-level entity IDs are rejected with 400.
+
+Expired memories are hidden by default. Pass `show_expired: true` to include memories whose `expiration_date` has passed.
+
+Python uses `show_expired`; TypeScript uses `showExpired`.
 
 The `filters` object supports complex logical operations (AND, OR, NOT) and comparison operators:
 
@@ -32,6 +36,7 @@ memories = client.get_all(
             }
         ]
     },
+    show_expired=False,
     page=1,
     page_size=50
 )
@@ -46,12 +51,14 @@ memories = client.get_all(
         {
             "id": "f4cbdb08-7062-4f3e-8eb2-9f5c80dfe64c",
             "memory": "Alex is planning a trip to San Francisco from July 1st to July 10th",
+            "expiration_date": null,
             "created_at": "2024-07-01T12:00:00Z",
             "updated_at": "2024-07-01T12:00:00Z"
         },
         {
             "id": "a2b8c3d4-5e6f-7g8h-9i0j-1k2l3m4n5o6p",
             "memory": "Alex prefers vegetarian restaurants",
+            "expiration_date": null,
             "created_at": "2024-07-05T15:30:00Z",
             "updated_at": "2024-07-05T15:30:00Z"
         }

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

@@ -4,4 +4,4 @@ description: "Retrieve the latest structured memory export after submitting an e
 openapi: post /v1/exports/get
 ---
 
-Retrieve the latest structured memory export after submitting an export job. You can filter the export by `user_id`, `run_id`, `session_id`, or `app_id` to get the most recent export matching your filters.
+Retrieve the latest structured memory export after submitting an export job. You can filter the export by `user_id`, `agent_id`, `app_id`, `run_id`, `created_at`, or `updated_at` to get the most recent export matching your filters.

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

@@ -4,9 +4,13 @@ description: "Search memories with hybrid retrieval (semantic + BM25 + entity ma
 openapi: post /v3/memories/search/
 ---
 
-Relevance-ranked hybrid search across stored memories. V3 uses multi-signal retrieval — semantic, BM25 keyword, and entity matching scored in parallel and fused. The returned `score` is a combined `[0, 1]` value.
+Relevance-ranked hybrid search across stored memories. V3 uses multi-signal retrieval: semantic, BM25 keyword, and entity matching scored in parallel and fused. The returned `score` is a combined `[0, 1]` value.
 
-Entity IDs (`user_id`, `agent_id`, `app_id`, `run_id`) **must** be passed inside the `filters` object — top-level entity IDs are rejected with 400. At least one entity ID is required.
+Entity IDs (`user_id`, `agent_id`, `app_id`, `run_id`) **must** be passed inside the `filters` object: top-level entity IDs are rejected with 400. At least one entity ID is required.
+
+Expired memories are hidden by default. Pass `show_expired: true` to include memories whose `expiration_date` has passed.
+
+Python uses `show_expired`; TypeScript uses `showExpired`.
 
 The `filters` object supports complex logical operations (AND, OR, NOT) and comparison operators:
 - `in`: Matches any of the values specified
@@ -20,16 +24,17 @@ The `filters` object supports complex logical operations (AND, OR, NOT) and comp
 
 ### Search parameter defaults
 
-| Parameter | V1/V2 | V3 |
-| --- | --- | --- |
-| `top_k` | Supported (default 10) | Supported (1-1000, default 10) |
-| `threshold` | No default | Default `0.1` (pass `0.0` to disable) |
-| `rerank` | Default `true` | Default `false` (pass `true` to enable) |
+| Parameter | Default |
+| --- | --- |
+| `top_k` | `10` (range 1–1000) |
+| `threshold` | `0.1` (pass `0.0` to disable) |
+| `rerank` | `false` (pass `true` to enable) |
 
 <CodeGroup>
 ```python Platform API Example
 related_memories = client.search(
     query="What are Alice's hobbies?",
+    show_expired=False,
     filters={
         "OR": [
             {
@@ -54,6 +59,7 @@ related_memories = client.search(
         "category": "hobbies"
       },
       "score": 0.82,
+      "expiration_date": null,
       "created_at": "2024-07-26T10:29:36.630547-07:00",
       "updated_at": null,
       "categories": ["hobbies"]

docs/api-reference/memory/update-memory.mdx

@@ -1,5 +1,14 @@
 ---
 title: 'Update Memory'
-description: "Update the content or metadata of a single memory by its unique ID using the PUT endpoint."
+description: "Update the content, metadata, timestamp, or expiration date of a single memory by its unique ID using the PUT endpoint."
 openapi: put /v1/memories/{memory_id}/
----
+---
+
+Use this endpoint to update mutable memory fields. To make a memory expire, set `expiration_date` to a `YYYY-MM-DD` date. To make it permanent again, send `expiration_date: null`.
+
+```python
+client.update("mem_123", expiration_date="2030-01-31")
+client.update("mem_123", expiration_date=None)
+```
+
+TypeScript uses `expirationDate`.

docs/api-reference/organization/remove-org-member.mdx

@@ -0,0 +1,5 @@
+---
+title: "Remove Organization Member"
+description: "Remove a member from an organization to revoke their access to its projects and resources."
+openapi: "delete /api/v1/orgs/organizations/{org_id}/members/"
+---

docs/api-reference/organization/update-org-member.mdx

@@ -0,0 +1,5 @@
+---
+title: "Update Organization Member"
+description: "Update an existing member's role within an organization to change their permissions and access level."
+openapi: "put /api/v1/orgs/organizations/{org_id}/members/"
+---

docs/api-reference/organizations-projects.mdx

@@ -14,7 +14,7 @@ Organizations and projects are **optional** features. You can use Mem0 without t
 
 ## Key Capabilities
 
-- **Multi-org/project Support**: Specify organization and project when initializing the Mem0 client to attribute API usage appropriately
+- **Multi-org/project Support**: Organization and project are resolved automatically from your API key via `/v1/ping/`: no org or project params are accepted by `MemoryClient.__init__`. Use a project-specific API key to target a particular project.
 - **Member Management**: Control access to data through organization and project membership
 - **Access Control**: Only members can access memories and data within their organization/project scope
 - **Team Isolation**: Maintain data separation between different teams and projects for secure collaboration
@@ -79,7 +79,7 @@ new_project = client.project.create(
 
 ### Update Project Settings
 
-Modify project configuration including custom instructions, categories, and language preferences:
+Modify project configuration including custom instructions, categories, language preferences, retrieval criteria, and memory decay:
 
 ```python
 # Update project with custom categories
@@ -98,6 +98,17 @@ client.project.update(
 # Use the input language for memory storage and retrieval
 client.project.update(multilingual=True)
 
+# Set retrieval criteria to control which memories are surfaced in search
+client.project.update(
+    retrieval_criteria=[
+        {"name": "relevance", "description": "How directly relevant this memory is to the current topic or user query", "weight": 3},
+        {"name": "access_frequency", "description": "How often this memory has been accessed or surfaced recently", "weight": 1}
+    ]
+)
+
+# Enable Memory Decay (boosts recently-accessed memories at search time)
+client.project.update(decay=True)
+
 # Update multiple settings at once
 client.project.update(
     custom_instructions="...",
@@ -109,9 +120,37 @@ client.project.update(
 )
 ```
 
+#### Set Retrieval Criteria
+
+`retrieval_criteria` is a per-project list of dictionaries (`List[Dict]`) that shapes how memories are ranked and filtered during search. Each dictionary has three fields: `name` (identifier), `description` (interpreted by the LLM to score each memory), and `weight` (relative influence on the final score). Use this to focus retrieval on intent-aligned or signal-specific memories:
+
+```python
+client.project.update(
+    retrieval_criteria=[
+        {
+            "name": "joy",
+            "description": "Measure the intensity of positive emotions such as happiness, excitement, or amusement expressed in the memory. A higher score reflects greater joy.",
+            "weight": 3
+        },
+        {
+            "name": "curiosity",
+            "description": "Assess the extent to which the memory reflects inquisitiveness or interest in exploring new information. A higher score reflects stronger curiosity.",
+            "weight": 2
+        },
+        {
+            "name": "access_frequency",
+            "description": "How often this memory has been accessed or surfaced recently.",
+            "weight": 1
+        }
+    ]
+)
+```
+
+Pass an empty list to clear all criteria and restore default retrieval behaviour.
+
 #### Toggle Memory Decay
 
-`decay` is a per-project boolean that turns on [Memory Decay](/platform/features/memory-decay) — a search-time ranking bias that reinforces recently-accessed memories and gently dampens stale ones. The flag is `false` by default; set it via the same project-update endpoint:
+`decay` is a per-project boolean that turns on [Memory Decay](/platform/features/memory-decay): a search-time ranking bias that reinforces recently-accessed memories and gently dampens stale ones. The flag is `false` by default; set it via the same project-update endpoint:
 
 ```bash cURL
 curl -X PATCH https://api.mem0.ai/api/v1/orgs/organizations/$ORG_ID/projects/$PROJECT_ID/ \

docs/api-reference/project/remove-project-member.mdx

@@ -0,0 +1,5 @@
+---
+title: "Remove Project Member"
+description: "Remove a member from a project to revoke their access to its memories, configuration, and resources."
+openapi: "delete /api/v1/orgs/organizations/{org_id}/projects/{project_id}/members/"
+---

docs/api-reference/project/update-project-member.mdx

@@ -0,0 +1,5 @@
+---
+title: "Update Project Member"
+description: "Update an existing member's role within a project to change their permissions and access level."
+openapi: "put /api/v1/orgs/organizations/{org_id}/projects/{project_id}/members/"
+---

docs/api-reference/project/update-project.mdx

@@ -0,0 +1,5 @@
+---
+title: "Update Project"
+description: "Update a project's settings, including name, custom instructions, and other configuration options."
+openapi: "patch /api/v1/orgs/organizations/{org_id}/projects/{project_id}/"
+---

docs/changelog/highlights.mdx

@@ -4,16 +4,121 @@ description: "Major product launches, headline features, and milestones for Mem0
 mode: "wide"
 ---
 
+<Update label="2026-06-27" description="SDK memory expiration">
+
+**SDK Memory Expiration: Expiring Memories Across Python and TypeScript**
+
+The latest SDK releases add first-class expiration controls to memory writes, updates, and reads, plus new TypeScript provider coverage for production deployments.
+
+- **Python client updates:** `MemoryClient.update()` and `AsyncMemoryClient.update()` now accept `expiration_date`, including `None` to clear an existing expiration.
+- **TypeScript client updates:** `AddMemoryOptions`, `update()`, and `Memory` now support `expirationDate`; `search()` and `getAll()` can include expired memories with `showExpired`.
+- **New TypeScript LLM providers:** `MiniMaxLLM` and `LiteLLM` are now available for OpenAI-compatible MiniMax and LiteLLM proxy deployments.
+- **PGVector deployment flexibility:** TypeScript PGVector config now supports `connectionString` and `ssl`, so apps can use a managed Postgres URI instead of separate connection fields.
+
+See [SDK & Tools](/changelog/sdk) for version details and PR links.
+
+</Update>
+
+<Update label="2026-06-25" description="Mem0 Plugin v0.2.11">
+
+**Mem0 Plugin: Shared Memory for Claude Code, Cursor, Codex, and Antigravity**
+
+The shared Mem0 editor plugin is current through v0.2.11:
+
+- **Automatic context injection:** File reads, bash errors, session resume prompts, and startup timelines can retrieve relevant memories automatically.
+- **Project and global scopes:** Project-scoped memories remain the default, while `global_search` supports team-wide recall across users and app scopes.
+- **Coding categories:** A 17-category coding taxonomy installs in the background and is cached per Mem0 account.
+- **Reliable capture:** Auto-capture, compaction summaries, session summaries, and metadata defaults keep memories scoped and readable.
+- **Editor correctness:** Telemetry now reports Claude Code, Cursor, Codex, and Antigravity separately with each editor's real plugin version.
+
+</Update>
+
+<Update label="2026-06-25" description="Antigravity Plugin v0.1.3">
+
+**Antigravity Plugin: Mem0 for Google Antigravity**
+
+Antigravity support in the shared Mem0 editor plugin family is current through v0.1.3:
+
+- **Self-contained plugin:** Includes its own plugin manifest, MCP config, hooks, shared scripts, and skills.
+- **AGENTS.md convention:** Uses Antigravity's `contextFileName: "AGENTS.md"` convention.
+- **Lifecycle hooks:** Wires session start, prompt recall, file-read context, memory-tool metadata enforcement, bash-error lookup, post-tool tracking, and stop summaries.
+- **Shared memory layer:** Reuses the Mem0 Platform MCP tools and the shared 16-skill command bundle.
+- **Better automatic recall:** v0.1.3 adds reranked injected context and clean `files_touched` metadata in session summaries.
+- **Telemetry correctness:** v0.1.2 reports Antigravity as `antigravity` with the plugin's own version.
+
+</Update>
+
+<Update label="2026-06-22" description="OpenCode Plugin v0.2.0">
+
+**OpenCode Plugin: Native SDK Memory Tools for OpenCode**
+
+`@mem0/opencode-plugin` adds memory to OpenCode and is current through v0.2.0:
+
+- **Native SDK tools:** Memory tools register through `@opencode-ai/plugin` and call the `mem0ai` SDK directly, so the plugin no longer depends on `mcp.mem0.ai`.
+- **Memory scopes:** Operations support `project`, `session`, and `global` scope, with `/mem0-scope` to change the default.
+- **Automatic context:** File-context injection, structured compaction summaries, and a recent-activity timeline surface relevant memories without manual recall.
+- **Auto-dream consolidation:** Gated consolidation merges duplicates, drops stale or sensitive entries, and rewrites vague memories.
+- **Skills load in place:** The `config` hook adds bundled skills to `skills.paths` instead of copying them into user config directories.
+- **Safety controls:** Blocks `MEMORY.md` writes and redacts secrets before storing memories.
+
+</Update>
+
+<Update label="2026-06-12" description="Pi Agent Plugin v0.1.2">
+
+**Pi Agent Plugin: Persistent Memory for Pi Agent**
+
+`@mem0/pi-agent-plugin` adds semantic memory to Pi Agent and has been updated through v0.1.2:
+
+- **Agent memory tool:** Registers `mem0_memory` for scoped search, add, get, delete, and delete-all operations.
+- **Slash commands:** Adds `/mem0-remember`, `/mem0-search`, `/mem0-forget`, `/mem0-tour`, `/mem0-dream`, `/mem0-pin`, `/mem0-scope`, and `/mem0-status`.
+- **Auto-capture:** Stores user and assistant memories after agent turns.
+- **Dream consolidation:** Merges duplicates, resolves contradictions, and prunes stale memories behind session, time, and memory-count gates.
+- **Project scoping:** Uses git-root detection for stable `app_id` values across monorepos.
+- **Relevant command results:** v0.1.2 adds visible command feedback and thresholded, reranked search for search, forget, and pin commands.
+
+</Update>
+
+<Update label="2026-06-12" description="OpenClaw v1.0.13">
+
+**OpenClaw Plugin: Current Memory Backend for OpenClaw**
+
+`@mem0/openclaw-mem0` is current through v1.0.13, with the original production-ready memory backend plus newer setup, security, and runtime work:
+
+- **Skills-based memory architecture:** Triage, recall, and dream skills handle extraction, recall, consolidation, and tool guidance.
+- **Chat and CLI setup:** Supports chat-based platform setup, `openclaw mem0 init`, direct API keys, email OTP, autonomous agent setup, and OSS onboarding.
+- **Platform and OSS modes:** Works with Mem0 Platform or self-hosted OSS providers including OpenAI, Anthropic, Ollama, Qdrant, and PGVector.
+- **Agent-friendly CLI:** All 16 CLI commands support `--json` for machine-driven setup and diagnostics.
+- **Runtime integration:** Exposes OpenClaw memory capability APIs for search manager and backend config status.
+- **Security and compliance:** Added path containment checks, sensitive config metadata, dependency overrides, telemetry hashing, and metadata-only registration safety.
+
+</Update>
+
+<Update label="2026-06-10" description="Vercel AI SDK Provider v3.0.0">
+
+**Vercel AI SDK Provider: Memory-Augmented Generation for AI SDK v6**
+
+The Vercel AI SDK provider moved to the v6 provider contract and Mem0 v3 APIs:
+
+- **AI SDK v6 support:** Migrated to `LanguageModelV3` / `ProviderV3`, including v3 stream lifecycle events and content arrays.
+- **Mem0 v3 API support:** Memory writes and searches now use `/v3/memories/add/` and `/v3/memories/search/`.
+- **Mem0 sources in responses:** `generateText` and `streamText` responses include memories as sources with `providerMetadata.mem0.memories`.
+- **Safer prompt handling:** Prompts are cloned before memory injection, avoiding caller-side mutation.
+- **Async storage fix:** `addMemories` is awaited so generated memories are not silently dropped.
+- **Raw memory utilities:** Exports `searchMemories`, `retrieveMemories`, `getMemories`, and `addMemories` for apps that need direct memory control.
+- **Deployment controls:** Per-request `mem0ApiKey` and `host` support Mem0 Platform, custom API keys, and self-hosted API endpoints.
+
+</Update>
+
 <Update label="2026-05-13" description="Temporal Reasoning for Mem0 Platform v3">
 
-**Temporal Reasoning — Time-Aware Retrieval for Platform v3**
+**Temporal Reasoning: Time-Aware Retrieval for Platform v3**
 
 Mem0 Platform v3 can now interpret time-aware memories and queries so assistants retrieve the right information for questions about the past, upcoming plans, and current state.
 
-- **Time-aware search intent** — Queries like `last week`, `upcoming`, `right now`, and `as of March 2025` return contextually appropriate results automatically
-- **Enabled by default** — No per-request toggle required for v3 writes or searches
-- **Anchored relative queries** — `reference_date` anchors relative search phrases for tests, backfills, and reproducible demos
-- **Normal response shape** — Temporal reasoning affects ranking while preserving existing client response patterns
+- **Search intent parsing:** Queries like `last week`, `upcoming`, `right now`, and `as of March 2025` now resolve against memory timestamps automatically.
+- **Default v3 behavior:** No per-request toggle is needed for v3 writes or searches.
+- **Deterministic testing:** Pass `reference_date` to anchor relative phrases in tests, backfills, and demos.
+- **Stable API shape:** Temporal reasoning changes ranking, not the client response contract.
 
 See [Temporal Reasoning](/platform/features/temporal-reasoning) for usage details.
 
@@ -21,11 +126,11 @@ See [Temporal Reasoning](/platform/features/temporal-reasoning) for usage detail
 
 <Update label="2026-05-08" description="Memory Decay">
 
-**Memory Decay — Recently-Used Memories Surface Higher, Automatically**
+**Memory Decay: Recently-Used Memories Surface Higher**
 
 Per-project search-time ranking bias that boosts recently-touched memories and gently dampens stale ones. Off by default; opt in per project via the `decay` field on the project endpoint, or via `client.project.update(decay=True)` in the SDKs (Python `v2.0.2` / TypeScript `v3.0.3`).
 
-- **Soft bias, never a filter.** The scaling factor stays in `0.3×–1.5×`. Decay can reorder candidates but never zeros them out — anything that surfaced before decay can still surface after.
+- **Soft bias, never a filter.** The scaling factor stays in `0.3×–1.5×`. Decay can reorder candidates but never removes them; anything that surfaced before decay can still surface after.
 - **Reinforcement loop.** Every memory returned in a search has its access history updated, so frequently-used facts naturally float to the top over time.
 - **Public score still clamped to `[0, 1]`.** Existing API contract preserved; no client-side changes needed.
 - **v3 search only**, fully reversible. See [Memory Decay docs](/platform/features/memory-decay).
@@ -34,18 +139,18 @@ Per-project search-time ranking bias that boosts recently-touched memories and g
 
 <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**
+**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
+- **LoCoMo:** 71.4 → **91.6** (+20) for multi-turn conversation recall.
+- **LongMemEval:** 67.8 → **93.4** (+26) for long-term memory across sessions.
+- **BEAM (1M tokens):** **64.1** on production-scale memory evaluation.
+- **Agent memories:** Assistant recall moves from 46% to **100%**.
+- **Temporal reasoning:** "Where did I live before SF?" improves from 51% to **93%**.
+- **Lower token use:** Retrieval stays under 7K tokens versus 25K+ for full-context approaches.
+- **ADD-only extraction:** Memories accumulate; nothing is overwritten or deleted.
+- **Hybrid retrieval:** Semantic search, BM25 keyword search, and entity boost are scored in parallel.
 - **Graph memory (built-in)**: entities extracted, embedded, and linked across memories, with no external graph store required
 
 Breaking changes: external graph stores removed from OSS (replaced by built-in graph memory), `search()` defaults changed, deprecated params removed. See [migration guide](/migration/oss-v2-to-v3).
@@ -54,56 +159,28 @@ Breaking changes: external graph stores removed from OSS (replaced by built-in g
 
 <Update label="2026-04-06" description="Mem0 Skill Graph">
 
-**Mem0 Skill Graph — In-Context Documentation for AI Agents**
+**Mem0 Skill Graph: In-Context Documentation for AI Agents**
 
-AI coding agents in Claude Code, Cursor, and Codex can now access Mem0 knowledge directly in their workflow — no doc searching required. Three interconnected skills launched:
+AI coding agents in Claude Code, Cursor, and Codex can now access Mem0 knowledge directly in their workflow without leaving the editor. Three interconnected skills launched:
 
-- **mem0 Core Skill** — Complete Python and TypeScript SDK reference, REST API patterns, and integration guides for LangChain, CrewAI, Autogen, and more
-- **mem0-cli Skill** — Terminal command reference, configuration walkthroughs, and CI/CD recipes
-- **mem0-vercel-ai-sdk Skill** — Vercel AI SDK provider API, memory-augmented generation patterns, and multi-provider setup
+- **mem0 Core Skill:** Python and TypeScript SDK reference, REST API patterns, and integration guides for LangChain, CrewAI, Autogen, and more.
+- **mem0-cli Skill:** Terminal command reference, configuration walkthroughs, and CI/CD recipes.
+- **mem0-vercel-ai-sdk Skill:** Vercel AI SDK provider API, memory-augmented generation patterns, and multi-provider setup.
 
 </Update>
 
 <Update label="2026-04-06" description="Mem0 CLI v0.2.2">
 
-**Official Mem0 CLI — Now on PyPI and npm**
+**Official Mem0 CLI: Now on PyPI and npm**
 
 A full-featured command-line interface for Mem0, available in both Python and Node.js:
 
 - **Install:** `pip install mem0-cli` or `npm install -g @mem0/cli`
-- **Full command suite** — `add`, `search`, `list`, `get`, `update`, `delete`, `import`, `config`, `init`, `status`, `entity`, `event`
-- **Interactive setup** — `mem0 init` with email verification or direct API key entry
-- **Works everywhere** — Platform (Mem0 Cloud) and self-hosted OSS modes
-- **Scriptable** — `--json` flag for CI/CD pipelines and automation
-- **Dual SDK** — Same commands, same experience across Python and Node.js
-
-</Update>
-
-<Update label="2026-04-06" description="OpenClaw v1.0.4">
-
-**OpenClaw Plugin — Production-Ready**
-
-The OpenClaw Mem0 plugin went from initial release to production-ready in one week (v1.0.0 → v1.0.4):
-
-- **Skills-based memory architecture** — New extraction pipeline with skill-loader, batched extraction, and domain-aware memory triage
-- **Dream gate** — Automatic memory consolidation during idle periods for higher-quality long-term recall
-- **Interactive CLI** — `openclaw mem0 init`, `status`, `config`, `import`, and `event` commands
-- **Unified tool naming** — `memory_add` and `memory_delete` replace 4 legacy tools, matching the platform API
-- **Security hardened** — Path traversal protection, pinned dependencies, 329 tests across 10 files
-
-</Update>
-
-<Update label="2026-04-02" description="Mem0 Plugin for AI Editors">
-
-**Mem0 Plugin for Claude Code, Cursor, and Codex**
-
-Launched a unified Mem0 plugin across three major AI development environments — Claude Code and Cursor first (March 25), then Codex (April 2):
-
-- **9 MCP memory tools** — add, search, get, update, delete, bulk delete, entity management via `mcp.mem0.ai`
-- **Lifecycle hooks** — Automatic memory capture at session start, context compaction, task completion, and session end
-- **Cloud MCP server** — Managed endpoint replaces local MCP and Smithery setup
-- **Streamable HTTP transport** — New MCP transport protocol for real-time streaming
-- **Codex-specific skill** — Dedicated skill in `mem0-plugin/skills/mem0-codex` for Codex workflows
+- **Full command suite:** `add`, `search`, `list`, `get`, `update`, `delete`, `import`, `config`, `init`, `status`, `entity`, `event`.
+- **Interactive setup:** `mem0 init` supports email verification and direct API key entry.
+- **Runtime coverage:** Works with Mem0 Platform and self-hosted OSS modes.
+- **Automation support:** Use `--json` for CI/CD pipelines and agent workflows.
+- **Dual implementation:** Same commands and behavior across Python and Node.js.
 
 </Update>
 
@@ -113,11 +190,11 @@ Launched a unified Mem0 plugin across three major AI development environments
 
 Major expansion of the provider ecosystem:
 
-- **Apache AGE** — New graph store support, bringing the total to 4 graph store backends (Neo4j, Memgraph, Kuzu, Apache AGE)
-- **Turbopuffer** — New vector database provider for Python SDK
-- **MiniMax** — New LLM provider with dedicated AWS Bedrock support
-- **pgvector for Node.js** — PostgreSQL vector support added to the TypeScript OSS SDK
-- **Reasoning models** — `reasoning_effort` parameter for OpenAI o1/o3-style models
+- **Apache AGE:** New graph store support, bringing the total to 4 graph store backends (Neo4j, Memgraph, Kuzu, Apache AGE). **Note:** All external graph store backends (Neo4j, Memgraph, Kuzu, Apache AGE) were subsequently removed in v2.0.0 (2026-04-14). Graph memory is now built-in entity linking with no external graph store required; see the [v2.0.0 entry above](#mem0-sdk-v2-0-0-v3-0-0).
+- **Turbopuffer:** New vector database provider for Python SDK.
+- **MiniMax:** New LLM provider with dedicated AWS Bedrock support.
+- **pgvector for Node.js:** PostgreSQL vector support added to the TypeScript OSS SDK.
+- **Reasoning models:** `reasoning_effort` parameter for OpenAI o1/o3-style models.
 
 </Update>
 
@@ -125,6 +202,6 @@ Major expansion of the provider ecosystem:
 
 **Mem0 Platform Skill on skills.sh**
 
-First skill launch — a dedicated Mem0 skill providing platform API reference, quickstart patterns, and integration examples directly inside agent sessions. Available on [skills.sh](https://skills.sh) for any compatible AI coding agent.
+First skill launch: a dedicated Mem0 skill providing platform API reference, quickstart patterns, and integration examples directly inside agent sessions. Available on [skills.sh](https://skills.sh) for any compatible AI coding agent.
 
 </Update>

docs/changelog/openclaw.mdx

@@ -1,336 +0,0 @@
----
-title: "OpenClaw"
-description: "Release notes for the OpenClaw plugin and agent harness."
-mode: "wide"
----
-
-<Update label="2026-06-12" description="v1.0.13">
-
-**Fixes:**
-- **Custom categories payload:** `customCategories` (a `Record<string, string>` map) is now converted via the new `customCategoryMapToList()` helper into the `Array<Record<string, string>>` shape the Mem0 SDK expects on `add` calls — previously the raw object was passed as `custom_categories` and silently ignored ([#5345](https://github.com/mem0ai/mem0/pull/5345))
-- **Skip runtime setup during metadata registration:** `register()` now detects `registrationMode === "cli-metadata"`, registers only the CLI commands, and returns early — avoiding backend initialization, service/tool registration, and hook installation during OpenClaw's metadata-only registration pass ([#5383](https://github.com/mem0ai/mem0/pull/5383))
-
-**Security:**
-- Bumped `mem0ai` from `3.0.3` to `3.0.7` (latest Node SDK) — includes the transitive axios CVE remediation shipped in `3.0.6` ([#5460](https://github.com/mem0ai/mem0/pull/5460))
-- Added pnpm override `uuid@<11.1.1` → `>=11.1.1` to resolve an open MEDIUM Dependabot alert ([#5489](https://github.com/mem0ai/mem0/pull/5489))
-
-**Improvements:**
-- **Repo consolidation:** Plugin moved from repo-root `openclaw/` to `integrations/openclaw/`; `package.json` `repository.directory` updated to match so npm provenance links to the correct subdirectory ([#5491](https://github.com/mem0ai/mem0/pull/5491))
-
-**Tests:**
-- Added `customCategoryMapToList` unit tests and a `PlatformProvider` test asserting `custom_categories` is passed to the Mem0 SDK as a list ([#5345](https://github.com/mem0ai/mem0/pull/5345))
-- Added a regression test asserting `cli-metadata` registration registers only CLI commands and triggers no runtime side effects ([#5383](https://github.com/mem0ai/mem0/pull/5383))
-
-</Update>
-
-<Update label="2026-06-02" description="v1.0.12">
-
-**Docs:**
-- **Agent Mode onboarding:** README now documents an autonomous setup path for AI agents — `mem0 init --agent --json` mints an evaluation Mem0 API key with no email, OTP, or browser and exports it as `MEM0_API_KEY` for `openclaw mem0 init`; a human owner can later run `mem0 init --email <email>` to claim ownership without disrupting the agent ([#5123](https://github.com/mem0ai/mem0/pull/5123))
-
-**Security:**
-- Added pnpm overrides to remediate advisories in transitive dependencies: `langsmith@<0.6.0` → `^0.6.0`, `picomatch@<2.3.2` → `^2.3.2`, `vite` → `^8.0.5`, and `@qdrant/js-client-rest` → `^1.18.0` ([#5294](https://github.com/mem0ai/mem0/pull/5294))
-
-**Dependencies:**
-- Bumped `mem0ai` from `3.0.2` to `3.0.3` ([#5212](https://github.com/mem0ai/mem0/pull/5212))
-- Bumped dev dependencies `@vitest/coverage-v8` and `vitest` from `^4.0.18` to `^4.1.7`; added `vite@^8.0.5` and `@qdrant/js-client-rest@^1.18.0` ([#5294](https://github.com/mem0ai/mem0/pull/5294))
-
-</Update>
-
-<Update label="2026-04-29" description="v1.0.11">
-
-**New Features:**
-- **Skills-mode auto-setup:** `enableSkillsConfig()` now runs automatically after onboarding — enables triage, recall (with reranking + keyword search), and dream consolidation with `tools.profile = "full"` and disables the built-in session-memory hook to avoid conflicts
-- **Memory runtime capability:** Plugin now exposes `runtime.getMemorySearchManager()` and `resolveMemoryBackendConfig()` on the registered memory capability, enabling OpenClaw gateway to query memory status and backend config directly
-- **Dimension-aware collections:** OSS wizard detects embedder dimension changes and creates a new collection (`mem0_<dims>d`) automatically, with a warning about old memories being inaccessible under the new embedder
-- **Tool documentation in skills:** Both `memory-triage` and `memory-dream` SKILL.md files now include full tool reference sections listing all available tools with parameters
-
-**Improvements:**
-- **Auto-capture and auto-recall default to enabled:** `autoCapture` and `autoRecall` now default to `true` (was `false`). Manifest descriptions updated accordingly. Ignored in skills mode
-- **`memory_update` over delete+add:** Skills now prefer `memory_update` for in-place edits — atomic and preserves edit history. Consolidation pattern updated: update best memory, delete redundant ones
-- **Search threshold lowered:** Default `searchThreshold` reduced from `0.5` to `0.1` for broader recall. Removed hardcoded `0.6` recall-specific override — all searches now use the configured threshold
-- **Embedder dimension propagation:** Vector store config auto-resolves dimensions from embedder config when not explicitly set. Syncs `dimension` and `embeddingModelDims` fields for Qdrant/PGVector compatibility
-- **Config file write safety:** `writeFullConfig()` now re-reads and deep-merges the `plugins` section before writing, preserving `installs` and `slots` written by the OpenClaw gateway
-- **Additional embedder models:** Added `mxbai-embed-large` (1024), `all-minilm` (384), and `snowflake-arctic-embed` (1024) to known embedder dimensions
-
-**Security:**
-- Bumped `protobufjs` to `>=7.5.5` via pnpm overrides (GHSA-xq3m-2v4x-88gg) ([#5012](https://github.com/mem0ai/mem0/pull/5012))
-
-**Fixes:**
-- Moved `bootstrapTelemetryFlag()` and removed `ensureInstallRecord()` from module-level side effects — both now run inside `register()` to avoid crashes when loaded outside OpenClaw gateway
-- Fixed OSS history DB path resolution: absolute paths no longer passed through `resolvePath()`, preventing double-prefix bugs
-- Manifest `providerAuthEnvVars` replaced with spec-compliant `setup.providers` format using `id` + `envVars`
-
-**Dependencies:**
-- Bumped `mem0ai` from `3.0.1` to `3.0.2`
-- Bumped `pluginApi` and `minGatewayVersion` compat to `>=2026.4.24`
-
-</Update>
-
-<Update label="2026-04-23" description="v1.0.10">
-
-**Security:**
-- Telemetry `distinct_id` now uses SHA-256 instead of MD5 — prevents rainbow-table reversal of API key hashes
-- User email is now SHA-256 hashed before sending as `distinct_id` — no PII in telemetry payloads
-- Declared PostHog telemetry endpoint (`us.i.posthog.com`) in `providerEndpoints`
-
-**Fixes:**
-- Fixed version-pinned install records preventing plugin updates. `ensureInstallRecord()` now detects semver-pinned specs (e.g. `@mem0/openclaw-mem0@1.0.7`) and rewrites them to `@latest` or `clawhub:` prefix so `openclaw plugins update` resolves to the newest release
-- Fixed `searchThreshold` default inconsistency: standardized to `0.3` across docs, README, and manifest
-- `PLUGIN_VERSION` now injected at build time via tsup `define` from `package.json` — no more hardcoded version strings
-
-**Manifest Compliance:**
-- Removed non-spec fields: `requiredEnvVars`, `dataLocations`, `privacy`, `setup` (with `externalEndpoints`, `providers`, `requiresRuntime`, `postInstallHint`)
-- Replaced `setup.externalEndpoints` with spec-compliant `providerEndpoints` using `endpointClass` + `hosts` format
-- Env var declarations now rely solely on `providerAuthEnvVars` (already spec-compliant)
-
-**Docs:**
-- Fixed `openclaw plugins update` command: uses plugin ID (`openclaw-mem0`), not npm package name (`@mem0/openclaw-mem0`)
-- Added update section to README
-- Removed redundant "Key Features" and "Conclusion" sections from integration docs
-
-</Update>
-
-<Update label="2026-04-22" description="v1.0.9">
-
-**Security & Compliance:**
-- Added top-level `requiredEnvVars` to plugin manifest, declaring env vars per mode (platform, OSS OpenAI, OSS Anthropic, OSS Ollama). Fixes ClaHub scanner "required env vars: none" mismatch
-- Added `sensitive: true` and descriptions to `apiKey` and `userEmail` in `configSchema` — previously only declared in `uiHints`
-- Added `default: false` with descriptions to `autoCapture` and `autoRecall` in `configSchema` so scanner can confirm opt-in defaults
-- Added `dataLocations` field to manifest declaring all persistence paths (config, vectorStore, historyDb, dreamState)
-- Added `privacy` field to manifest documenting data flow for platform vs open-source mode and credential storage guidance
-- Added `externalEndpoints` to `setup` section declaring api.mem0.ai and app.mem0.ai with purpose and requirement context
-
-**Tests:**
-- Replaced direct `process.env` access in `tests/cli-commands.test.ts` and `tests/fs-safe.test.ts` with `vi.stubEnv`/`vi.unstubAllEnvs`. Fixes ClaHub static analysis flag for "environment variable access combined with network send"
-- 421 tests across 15 test files
-
-</Update>
-
-<Update label="2026-04-21" description="v1.0.8">
-
-**New Features:**
-- **OSS Onboarding Wizard:** New guided 4-step interactive setup for open-source mode — walks through LLM provider, embedding provider, vector store, and user ID selection with prefilled defaults
-- **Agent-Friendly CLI:** Added `--json` flag to all 16 CLI commands for machine-readable output. Agents can call `openclaw mem0 help --json` to discover every command and flag
-- **Non-Interactive OSS Setup:** Added `--mode open-source` with `--oss-llm`, `--oss-embedder`, `--oss-vector` flags for fully automated OSS configuration without prompts
-- **JSON Helpers Module:** New `cli/json-helpers.ts` with `jsonOut`, `jsonErr`, and `redactSecrets` utilities for consistent structured output
-
-**Improvements:**
-- **Init Flow Redesigned:** Replaced 3-option flat menu with 2-level structure: Platform (email login or API key) and Open Source (guided wizard)
-- **Provider Selection:** LLM providers: OpenAI, Ollama, Anthropic. Embedding providers: OpenAI, Ollama. Vector stores: Qdrant, PGVector
-- **Input Prefill:** All prompts with defaults (base URL, user ID) now prefill the input field instead of showing defaults in brackets
-- **Smart Reuse:** When LLM and embedder use the same provider, API key and base URL are automatically reused from the LLM step
-- **Default Model:** Updated default LLM model to `gpt-5-mini`
-- **Manifest Compliance:** Removed undocumented fields, aligned env var declarations between SKILL.md and manifest, fixed `configSchema.required` for clean installs
-
-**Tests:**
-- 404 tests across 15 test files (+3 new: `json-helpers.test.ts`, `oss-wizard.test.ts`, `cli-commands.test.ts`)
-
-</Update>
-
-<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:**
-- **Telemetry:** Replaced shared `"anonymous-openclaw"` fallback with a persistent per-machine random hash (`openclaw-anon-<uuid>`), so anonymous plugin users are counted individually in PostHog ([#4790](https://github.com/mem0ai/mem0/pull/4790))
-- **Telemetry:** Added PostHog `$identify` event on first authenticated run to stitch anonymous history onto the authenticated profile ([#4790](https://github.com/mem0ai/mem0/pull/4790))
-- **Telemetry:** Fixed event loss on short-lived CLI invocations — added `beforeExit` handler to flush queued events before the process exits ([#4790](https://github.com/mem0ai/mem0/pull/4790))
-- **Telemetry:** Added lazy `/v1/ping/` email resolution so users who configure API key outside `mem0 init` show as their email in PostHog, not an md5 hash ([#4790](https://github.com/mem0ai/mem0/pull/4790))
-- **Telemetry:** Unified CLI event prefix from `openclaw.<cmd>` to `openclaw.cli.<cmd>` on the needsSetup branch to match the authenticated branch ([#4790](https://github.com/mem0ai/mem0/pull/4790))
-
-**Improvements:**
-- **API:** Added `source: "OPENCLAW"` to all provider calls (`add`, `search`, `getAll`) across tools, CLI commands, recall, and the OSS backend adapter ([#4790](https://github.com/mem0ai/mem0/pull/4790))
-
-</Update>
-
-<Update label="2026-04-07" description="v1.0.5">
-
-**Bug Fixes:**
-- **Init interactive choice bug**: Fixed number selection in `openclaw mem0 init` — entering 1/2/3 now correctly selects the corresponding option (was broken by readline prefill concatenating with user input)
-- **OSS pgvector crash** ([#4727](https://github.com/mem0ai/mem0/issues/4727)): Fixed "Client has already been connected" cascade when using pgvector in OSS mode. The warmup call swallowed errors leaving a half-initialized pg client; concurrent recall/capture then all hit `client.connect()` on the same client. Fix: let warmup errors propagate (so `initPromise` resets and retries with a fresh Memory + fresh pg client) and build fresh config objects per attempt instead of mutating shared state.
-
-**Removed:**
-- **`orgId` / `projectId` config parameters**: Removed from config schema, CLI (`config show/get/set`), init display, and providers. The API key is project-scoped, so separate org/project IDs are unnecessary and could cause access errors if mismatched.
-- **`enableGraph` config parameter**: Removed from all config surfaces, providers, backend, and tools. Graph memory is being deprecated — removing the flag avoids unnecessary exposure.
-
-</Update>
-
-<Update label="2026-04-04" description="v1.0.4">
-
-**New Features:**
-- **Interactive init flow**: `openclaw mem0 init` with interactive menu (email verification or direct API key). Non-interactive modes: `--api-key`, `--email`, `--email --code`
-- **`memory_add` tool**: Replaces `memory_store` — name now matches `mem0` CLI and platform API
-- **`memory_delete` tool**: Unified delete — single ID, search-then-delete, bulk, entity cascade. Replaces `memory_forget` and `memory_delete_all`
-- **CLI subcommands**: `openclaw mem0 init`, `openclaw mem0 status`, `openclaw mem0 config show`, `openclaw mem0 config set`
-- **`import` CLI command**: Bulk-import memories from a JSON file with `--user-id` and `--agent-id` overrides
-- **`event list` / `event status` CLI commands**: Monitor background processing events
-- **`fs-safe.ts` module**: Isolated filesystem wrappers in a separate entry point
-- **`backend/` module**: `PlatformBackend` with direct HTTP API access for CLI commands
-- **Plugin manifest**: Added `contracts.tools`, `configSchema`, and `uiHints` to `openclaw.plugin.json`
-- **Test suite**: 329 tests across 10 test files
-
-**Changes:**
-- **Modular architecture**: Extracted tools into `tools/` directory (6 files) and CLI into `cli/commands.ts`
-- **Code splitting**: tsup builds with `splitting: true` and two entry points
-- **Skills updated**: All SKILL.md files reference new tool names (`memory_add`, `memory_delete`)
-- **Auto-recall timeout**: Recall wrapped in 8-second `Promise.race`
-- **Auto-capture fire-and-forget**: `provider.add()` runs in background via `.then()/.catch()`
-- **Auto-capture minimum content gate**: Skips extraction when total user content is fewer than 50 chars
-
-**Removed:**
-- `memory_store` tool — replaced by `memory_add`
-- `memory_forget` tool — replaced by `memory_delete`
-- `memory_delete_all` tool — merged into `memory_delete`
-- `memory_history` tool and `history` CLI command — deprecated
-
-</Update>
-
-<Update label="2026-04-03" description="v1.0.3">
-
-**Bug Fixes:**
-- **Security**: Added `safePath()` containment helper to `readSkillFile` and `readDomainOverlay` in `skill-loader.ts` — prevents directory traversal
-- **Noise filter**: Reverted incorrect `After-Compaction` regex rename back to `Post-Compaction`
-
-**Changes:**
-- **Supply-chain hardening**: Pinned `mem0ai` dependency to exact `2.3.0` (was `^2.3.0`)
-
-**Tests:**
-- 12 new tests covering `safePath`, `readSkillFile`, `readDomainOverlay`, and `loadSkill` with traversal inputs
-
-</Update>
-
-<Update label="2026-04-02" description="v1.0.2">
-
-**Bug Fixes:**
-- **Security**: Removed `resolveEnvVars()` and `resolveEnvVarsDeep()` from `config.ts` — plugin-side env resolution was redundant and triggered static analysis warnings ([#4676](https://github.com/mem0ai/mem0/pull/4676))
-
-</Update>
-
-<Update label="2026-04-02" description="v1.0.1">
-
-**New Features:**
-- **CD workflow**: Added continuous deployment workflow with OIDC trusted publishing ([#4672](https://github.com/mem0ai/mem0/pull/4672))
-- **Plugin configuration manifest**: Added `compat` and `build` metadata to `package.json` ([#4667](https://github.com/mem0ai/mem0/pull/4667))
-- **LICENSE**: Added Apache-2.0 license file ([#4667](https://github.com/mem0ai/mem0/pull/4667))
-
-**Bug Fixes:**
-- **Dream gate**: Fixed cheap-first ordering, session isolation, and verified completion ([#4666](https://github.com/mem0ai/mem0/pull/4666))
-- **Graceful startup**: Plugin now starts gracefully when no API key is configured ([#4669](https://github.com/mem0ai/mem0/pull/4669))
-
-</Update>
-
-<Update label="2026-04-01" description="v1.0.0">
-
-**New Features:**
-- **Skills-based memory architecture**: New skill-loader and skill-based extraction pipeline with batched extraction ([#4624](https://github.com/mem0ai/mem0/pull/4624))
-- **Dream gate**: Memory consolidation and dream-cycle processing during idle periods
-- **Enhanced recall**: New `recall.ts` module with improved recall logic and skill-aware retrieval
-- **Memory triage skill**: Domain-aware memory triage with companion domain support and recall protocol
-- **Memory dream skill**: Skill for memory consolidation during idle periods
-- **Plugin configuration**: Added `openclaw.plugin.json` manifest and `scripts/configure.py` setup helper
-
-**Changes:**
-- Extraction pipeline refactored to use skills-based architecture for more contextual and higher quality memory capture
-
-</Update>
-
-<Update label="2026-03-26" description="v0.4.1">
-
-**New Features:**
-- **Improved extraction quality**: Enhanced noise filtering, deduplication, and better extraction instructions
-
-**Bug Fixes:**
-- **Credential detection**: Improved detection of credentials, API keys, and secrets in extraction instructions (#4552)
-- **Standalone timestamps**: Prevented extraction of standalone timestamps as memories (#4550)
-
-</Update>
-
-<Update label="2026-03-16" description="v0.4.0">
-
-**New Features:**
-- **Non-interactive trigger filtering**: Skips recall and capture for `cron`, `heartbeat`, `automation`, and `schedule` triggers
-- **Subagent hallucination prevention**: Detects ephemeral subagent sessions and routes recall to parent namespace
-- **Dynamic recall thresholding**: Memories scoring less than 50% of top result are dropped
-- **SQLite resilience**: Init error recovery with automatic retry for OSS mode
-- **`disableHistory` config option**: New `oss.disableHistory` flag
-- 78 unit tests covering filtering, isolation, trigger filtering, subagent detection, and SQLite resilience
-
-**Changes:**
-- Auto-recall threshold raised from 0.5 to 0.6 for stricter precision
-- Recall candidate pool increased to `topK * 2` for better filtering headroom
-- Relaxed extraction instructions: related facts kept together to preserve context
-
-**Bug Fixes:**
-- **Concurrent session race condition**: Lifecycle hooks now use `ctx.sessionKey` directly instead of a shared mutable variable
-
-</Update>
-
-<Update label="2026-03-12" description="v0.3.1">
-
-**New Features:**
-- **Message filtering pipeline**: Multi-stage noise removal before extraction
-- **Broad recall for new sessions**: Short or new-session prompts trigger secondary broad search
-- **Client-side threshold filtering**: Safety net that drops low-relevance results
-- **Temporal anchoring**: Extraction instructions now include current date
-- 55 unit tests covering filtering and isolation helpers
-
-**Changes:**
-- Extraction window expanded from last 10 to last 20 messages
-- Rewritten custom extraction instructions for conciseness and deduplication
-- Refactored monolithic `index.ts` (1772 lines) into 6 focused modules
-
-</Update>
-
-<Update label="2026-03-10" description="v0.3.0">
-
-**Bug Fixes:**
-- Updated `mem0ai` dependency with sqlite3 to better-sqlite3 migration (#4270)
-
-</Update>
-
-<Update label="2026-03-09" description="v0.2.0">
-
-**New Features:**
-- Per-agent memory isolation for multi-agent setups via `agentId`
-- "Understanding userId" section in docs
-
-**Changes:**
-- Updated config examples to use concrete `userId` values instead of placeholders
-
-**Bug Fixes:**
-- Migrated platform search to Mem0 v2 API
-
-</Update>
-
-<Update label="2026-02-19" description="v0.1.2">
-
-**New Features:**
-- Source field for openclaw memory entries
-
-**Bug Fixes:**
-- Auto-recall injection and auto-capture message drop
-
-</Update>
-
-<Update label="2026-02-02" description="v0.1.0">
-
-**New Features:**
-- Initial release of the OpenClaw Mem0 plugin
-- Platform mode (Mem0 Cloud) and open-source mode support
-- Auto-recall: inject relevant memories before each turn
-- Auto-capture: store facts after each turn
-- Configurable `topK`, `threshold`, and `apiVersion` options
-
-</Update>

docs/changelog/platform.mdx

@@ -1,6 +1,6 @@
 ---
 title: "Platform"
-description: "Release notes for the Mem0 hosted platform — backend, dashboard, billing, and infrastructure changes."
+description: "Release notes for the Mem0 hosted platform: backend, dashboard, billing, and infrastructure changes."
 mode: "wide"
 ---
 

docs/components/embedders/models/aws_bedrock.mdx

@@ -59,5 +59,9 @@ Here are the parameters available for configuring AWS Bedrock embedder:
 | Parameter | Description | Default Value |
 | --- | --- | --- |
 | `model` | The name of the embedding model to use | `amazon.titan-embed-text-v1` |
+| `aws_region` | AWS region for the Bedrock client | `us-west-2` |
+| `aws_access_key_id` | AWS access key ID for authentication | `None` |
+| `aws_secret_access_key` | AWS secret access key for authentication | `None` |
+| `aws_session_token` | AWS session token for temporary credentials | `None` |
 </Tab>
 </Tabs>

docs/components/embedders/models/fastembed.mdx

@@ -0,0 +1,50 @@
+---
+title: "FastEmbed"
+description: "Configure FastEmbed as an embedding provider in Mem0 to generate embeddings locally using ONNX-based models without a GPU."
+---
+
+You can use FastEmbed to run embedding models locally in Mem0. FastEmbed is an ONNX-based embedding library that runs efficiently on CPU without requiring a GPU or an external API key.
+
+### Installation
+
+```bash
+pip install fastembed
+```
+
+### Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
+
+config = {
+    "embedder": {
+        "provider": "fastembed",
+        "config": {
+            "model": "thenlper/gte-large"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+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."}
+]
+m.add(messages, user_id="john")
+```
+</CodeGroup>
+
+### Config
+
+Here are the parameters available for configuring FastEmbed embedder:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the FastEmbed model to use | `thenlper/gte-large` |
+| `embedding_dims` | Dimensions of the embedding model (auto-derived from the model if not set) | `None` |

docs/components/embedders/models/google_AI.mdx

@@ -67,14 +67,15 @@ Here are the parameters available for configuring Gemini embedder:
 | Parameter        | Description                          | Default Value           |
 | ---------------- | ------------------------------------ | ----------------------- |
 | `model`          | The name of the embedding model to use| `models/gemini-embedding-001` |
-| `embedding_dims` | Dimensions of the embedding model     | `1536`                  |
+| `embedding_dims` | Dimensions of the embedding model     | `768`                   |
 | `api_key`        | The Google API key                   | `None`                  |
+| `output_dimensionality` | Output dimensionality for the embedding model (Gemini-specific; used when `embedding_dims` is not set) | `None` |
 </Tab>
 <Tab title="TypeScript">
 | Parameter         | Description                                   | Default Value              |
 | ----------------- | --------------------------------------------- | -------------------------- |
 | `model`           | The name of the embedding model to use        | `gemini-embedding-001`     |
-| `embeddingDims`   | Dimensions of the embedding model             | `1536`                     |
+| `embeddingDims`   | Dimensions of the embedding model. When not set, uses the model's native output dimensionality (3072 for `gemini-embedding-001`; MRL truncation to 768, 1536, or 3072 is supported) | `None`                     |
 | `apiKey`          | Google API key                                | `None`                     |
 </Tab>
 </Tabs>

docs/components/embedders/models/lmstudio.mdx

@@ -16,7 +16,7 @@ config = {
     "embedder": {
         "provider": "lmstudio",
         "config": {
-            "model": "nomic-embed-text-v1.5-GGUF/nomic-embed-text-v1.5.f16.gguf"
+            "model": "nomic-ai/nomic-embed-text-v1.5-GGUF"
         }
     }
 }
@@ -37,6 +37,6 @@ Here are the parameters available for configuring LM Studio embedder:
 
 | Parameter | Description | Default Value |
 | --- | --- | --- |
-| `model` | The name of the LM Studio model to use | `nomic-embed-text-v1.5-GGUF/nomic-embed-text-v1.5.f16.gguf` |
+| `model` | The name of the LM Studio model to use | `nomic-ai/nomic-embed-text-v1.5-GGUF` |
 | `embedding_dims` | Dimensions of the embedding model | `1536` |
 | `lmstudio_base_url` | Base URL for LM Studio connection | `http://localhost:1234/v1` |

docs/components/embedders/overview.mdx

@@ -10,7 +10,7 @@ Mem0 offers support for various embedding models, allowing users to choose the o
 See the list of supported embedders below.
 
 <Note>
-  The following embedders are supported in the Python implementation. The TypeScript implementation currently only supports OpenAI.
+  All embedders listed below are supported in the Python implementation. The TypeScript implementation supports: **OpenAI**, **Azure OpenAI**, **Google AI**, **Langchain**, **LM Studio**, and **Ollama**.
 </Note>
 
 <CardGroup cols={4}>
@@ -24,6 +24,7 @@ See the list of supported embedders below.
   <Card title="LM Studio" href="/components/embedders/models/lmstudio"></Card>
   <Card title="Langchain" href="/components/embedders/models/langchain"></Card>
   <Card title="AWS Bedrock" href="/components/embedders/models/aws_bedrock"></Card>
+  <Card title="FastEmbed" href="/components/embedders/models/fastembed"></Card>
 </CardGroup>
 
 ## Usage

docs/components/llms/config.mdx

@@ -98,7 +98,7 @@ Here's a comprehensive list of all parameters that can be used across different
     | `max_tokens`         | Tokens to generate                            | All               |
     | `top_p`              | Probability threshold for nucleus sampling    | All               |
     | `top_k`              | Number of highest probability tokens to keep  | All               |
-    | `http_client_proxies`| Allow proxy server settings                   | AzureOpenAI       |
+    | `http_client_proxies`| Allow proxy server settings                   | All               |
     | `models`             | List of models                                | Openrouter        |
     | `route`              | Routing strategy                              | Openrouter        |
     | `openrouter_base_url`| Base URL for Openrouter API                   | Openrouter        |
@@ -110,7 +110,7 @@ Here's a comprehensive list of all parameters that can be used across different
     | `deepseek_base_url`  | Base URL for DeepSeek API                     | DeepSeek          |
     | `xai_base_url`       | Base URL for XAI API                          | XAI               |
     | `sarvam_base_url`    | Base URL for Sarvam API                       | Sarvam            |
-    | `reasoning_effort`   | Reasoning level (low, medium, high)           | Sarvam            |
+    | `reasoning_effort`   | Reasoning level (low, medium, high)           | All               |
     | `frequency_penalty`  | Penalize frequent tokens (-2.0 to 2.0)        | Sarvam            |
     | `presence_penalty`   | Penalize existing tokens (-2.0 to 2.0)        | Sarvam            |
     | `seed`               | Seed for deterministic sampling               | Sarvam            |

docs/components/llms/models/anthropic.mdx

@@ -20,7 +20,7 @@ config = {
     "llm": {
         "provider": "anthropic",
         "config": {
-            "model": "claude-sonnet-4-20250514",
+            "model": "claude-sonnet-4-6",
             "temperature": 0.1,
             "max_tokens": 2000,
         }
@@ -45,7 +45,7 @@ const config = {
     provider: 'anthropic',
     config: {
       apiKey: process.env.ANTHROPIC_API_KEY || '',
-      model: 'claude-sonnet-4-20250514',
+      model: 'claude-sonnet-4-6',
       temperature: 0.1,
       maxTokens: 2000,
     },

docs/components/llms/models/aws_bedrock.mdx

@@ -6,7 +6,7 @@ description: "Configure AWS Bedrock as an LLM provider in Mem0 with IAM authenti
 ### Setup
 - Before using the AWS Bedrock LLM, make sure you have the appropriate model access from [Bedrock Console](https://us-east-1.console.aws.amazon.com/bedrock/home?region=us-east-1#/modelaccess).
 - You will also need to authenticate the `boto3` client by using a method in the [AWS documentation](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html#configuring-credentials)
-- You will have to export `AWS_REGION`, `AWS_ACCESS_KEY`, and `AWS_SECRET_ACCESS_KEY` to set environment variables.
+- You will have to export `AWS_REGION`, `AWS_ACCESS_KEY_ID`, and `AWS_SECRET_ACCESS_KEY` to set environment variables.
 
 ### Usage
 

docs/components/llms/models/groq.mdx

@@ -21,7 +21,7 @@ config = {
     "llm": {
         "provider": "groq",
         "config": {
-            "model": "mixtral-8x7b-32768",
+            "model": "llama-3.3-70b-versatile",
             "temperature": 0.1,
             "max_tokens": 2000,
         }
@@ -46,7 +46,7 @@ const config = {
     provider: 'groq',
     config: {
       apiKey: process.env.GROQ_API_KEY || '',
-      model: 'mixtral-8x7b-32768',
+      model: 'llama3-70b-8192',
       temperature: 0.1,
       maxTokens: 1000,
     },

docs/components/llms/models/litellm.mdx

@@ -4,9 +4,12 @@ description: "Use LiteLLM as an LLM provider in Mem0 to access over 100 language
 ---
 [Litellm](https://litellm.vercel.app/docs/) is compatible with over 100 large language models (LLMs), all using a standardized input/output format. You can explore the [available models](https://litellm.vercel.app/docs/providers) to use with Litellm. Ensure you set the `API_KEY` for the model you choose to use.
 
+In the TypeScript SDK, run LiteLLM as a [proxy server](https://docs.litellm.ai/docs/simple_proxy) (an OpenAI-compatible endpoint) and point Mem0 at it via `LITELLM_API_BASE` (defaults to `http://localhost:4000`).
+
 ## Usage
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
@@ -33,6 +36,33 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+// Point Mem0 at your LiteLLM proxy. apiKey defaults to "sk-anything"
+// (the proxy handles real auth); baseURL defaults to http://localhost:4000.
+const config = {
+  llm: {
+    provider: 'litellm',
+    config: {
+      apiKey: process.env.LITELLM_API_KEY || 'sk-anything',
+      baseURL: process.env.LITELLM_API_BASE || 'http://localhost:4000',
+      model: 'gpt-5-mini',
+    },
+  },
+};
+
+const memory = new Memory(config);
+const 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."}
+];
+await memory.add(messages, { userId: 'alice', metadata: { category: 'movies' } });
+```
+</CodeGroup>
+
 ## Config
 
 All available parameters for the `litellm` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/minimax.mdx

@@ -7,7 +7,8 @@ To use MiniMax LLM models, you have to set the `MINIMAX_API_KEY` environment var
 
 ## Usage
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
@@ -36,9 +37,37 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  llm: {
+    provider: 'minimax',
+    config: {
+      apiKey: process.env.MINIMAX_API_KEY || '',
+      model: 'MiniMax-M2.7',
+      temperature: 0.2,
+      maxTokens: 2000,
+      topP: 1.0,
+    },
+  },
+};
+const memory = new Memory(config);
+const 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." },
+];
+await memory.add(messages, { userId: 'alice', metadata: { category: 'movies' } });
+```
+
+</CodeGroup>
+
 You can also configure the API base URL in the config:
 
-```python
+<CodeGroup>
+```python Python
 config = {
     "llm": {
         "provider": "minimax",
@@ -51,6 +80,20 @@ config = {
 }
 ```
 
+```typescript TypeScript
+const config = {
+  llm: {
+    provider: 'minimax',
+    config: {
+      model: 'MiniMax-M2.7',
+      baseURL: 'https://your-custom-endpoint.com',
+      apiKey: 'your-api-key', // alternatively to using the environment variable
+    },
+  },
+};
+```
+</CodeGroup>
+
 ## Config
 
 All available parameters for the `minimax` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/xAI.mdx

@@ -20,7 +20,7 @@ config = {
     "llm": {
         "provider": "xai",
         "config": {
-            "model": "grok-3-beta",
+            "model": "grok-4.3",
             "temperature": 0.1,
             "max_tokens": 2000,
         }

docs/components/llms/overview.mdx

@@ -16,7 +16,7 @@ For a comprehensive list of available parameters for llm configuration, please r
 See the list of supported LLMs below.
 
 <Note>
-  All LLMs are supported in Python. The following LLMs are also supported in TypeScript: **OpenAI**, **Anthropic**, and **Groq**.
+  All LLMs are supported in Python. The following LLMs are also supported in TypeScript: **OpenAI**, **Anthropic**, **Groq**, **Azure OpenAI**, **DeepSeek**, **Google AI**, **Langchain**, **LM Studio**, **Mistral AI**, and **Ollama**.
 </Note>
 
 <CardGroup cols={4}>

docs/components/rerankers/custom-prompts.mdx

@@ -198,4 +198,4 @@ for i, prompt in enumerate(prompts):
 - **Too Long**: Keep prompts under token limits for your chosen LLM
 - **Too Vague**: Be specific about scoring criteria
 - **Wrong Scale**: Use 0.0-1.0 scale to match the default score extractor
-- **Extra Output**: Ask for only the numeric score — extra text can confuse score extraction
+- **Extra Output**: Ask for only the numeric score: extra text can confuse score extraction

docs/components/rerankers/models/llm.mdx

@@ -1,226 +0,0 @@
----
-title: LLM as Reranker
-description: "Use any LLM as a flexible reranker in Mem0 with custom prompts and domain-specific scoring logic."
----
-
-<Warning>
-**This page has been superseded.** Please see [LLM Reranker](/components/rerankers/models/llm_reranker) for the complete and up-to-date documentation on using LLMs for reranking.
-</Warning>
-
-LLM-based reranker provides maximum flexibility by using any Large Language Model to score document relevance. This approach allows for custom prompts and domain-specific scoring logic.
-
-## Supported LLM Providers
-
-Any LLM provider supported by Mem0 can be used for reranking:
-
-- **OpenAI**: GPT-4, GPT-3.5-turbo, etc.
-- **Anthropic**: Claude models
-- **Together**: Open-source models
-- **Groq**: Fast inference
-- **Ollama**: Local models
-- And more...
-
-## Configuration
-
-```python Python
-from mem0 import Memory
-
-config = {
-    "vector_store": {
-        "provider": "chroma",
-        "config": {
-            "collection_name": "my_memories",
-            "path": "./chroma_db"
-        }
-    },
-    "llm": {
-        "provider": "openai",
-        "config": {
-            "model": "gpt-4o-mini"
-        }
-    },
-    "reranker": {
-        "provider": "llm",
-        "config": {
-            "model": "gpt-4o-mini",
-            "provider": "openai",
-            "api_key": "your-openai-api-key",  # or set OPENAI_API_KEY
-            "top_k": 5,
-            "temperature": 0.0
-        }
-    }
-}
-
-memory = Memory.from_config(config)
-```
-
-## Custom Scoring Prompt
-
-You can provide a custom prompt for relevance scoring:
-
-```python Python
-custom_prompt = """You are a relevance scoring assistant. Rate how well this document answers the query.
-
-Query: "{query}"
-Document: "{document}"
-
-Score from 0.0 to 1.0 where:
-- 1.0: Perfect match, directly answers the query
-- 0.8-0.9: Highly relevant, good match  
-- 0.6-0.7: Moderately relevant, partial match
-- 0.4-0.5: Slightly relevant, limited useful information
-- 0.0-0.3: Not relevant or no useful information
-
-Provide only a single numerical score between 0.0 and 1.0."""
-
-config["reranker"]["config"]["scoring_prompt"] = custom_prompt
-```
-
-## Usage Example
-
-```python Python
-import os
-from mem0 import Memory
-
-# Set API key
-os.environ["OPENAI_API_KEY"] = "your-api-key"
-
-# Initialize memory with LLM reranker
-config = {
-    "vector_store": {"provider": "chroma"},
-    "llm": {"provider": "openai", "config": {"model": "gpt-4o-mini"}},
-    "reranker": {
-        "provider": "llm",
-        "config": {
-            "model": "gpt-4o-mini",
-            "provider": "openai",
-            "temperature": 0.0
-        }
-    }
-}
-
-memory = Memory.from_config(config)
-
-# Add memories
-messages = [
-    {"role": "user", "content": "I'm learning Python programming"},
-    {"role": "user", "content": "I find object-oriented programming challenging"}, 
-    {"role": "user", "content": "I love hiking in national parks"}
-]
-
-memory.add(messages, user_id="david")
-
-# Search with LLM reranking
-results = memory.search("What programming topics is the user studying?", filters={"user_id": "david"})
-
-for result in results['results']:
-    print(f"Memory: {result['memory']}")
-    print(f"Vector Score: {result['score']:.3f}")
-    print(f"Rerank Score: {result['rerank_score']:.3f}")
-    print()
-```
-
-```text Output
-Memory: I'm learning Python programming
-Vector Score: 0.856
-Rerank Score: 0.920
-
-Memory: I find object-oriented programming challenging
-Vector Score: 0.782
-Rerank Score: 0.850
-```
-
-## Domain-Specific Scoring
-
-Create specialized scoring for your domain:
-
-```python Python
-medical_prompt = """You are a medical relevance expert. Score how relevant this medical record is to the clinical query.
-
-Clinical Query: "{query}"
-Medical Record: "{document}"
-
-Consider:
-- Clinical relevance and accuracy
-- Patient safety implications
-- Diagnostic value
-- Treatment relevance
-
-Score from 0.0 to 1.0. Provide only the numerical score."""
-
-config = {
-    "reranker": {
-        "provider": "llm",
-        "config": {
-            "model": "gpt-4o-mini",
-            "provider": "openai",
-            "scoring_prompt": medical_prompt,
-            "temperature": 0.0
-        }
-    }
-}
-```
-
-## Multiple LLM Providers
-
-Use different LLM providers for reranking:
-
-```python Python
-# Using Anthropic Claude
-anthropic_config = {
-    "reranker": {
-        "provider": "llm",
-        "config": {
-            "model": "claude-3-haiku-20240307",
-            "provider": "anthropic",
-            "temperature": 0.0
-        }
-    }
-}
-
-# Using local Ollama model
-ollama_config = {
-    "reranker": {
-        "provider": "llm",
-        "config": {
-            "model": "llama2:7b",
-            "provider": "ollama",
-            "temperature": 0.0
-        }
-    }
-}
-```
-
-## Configuration Parameters
-
-| Parameter | Description | Type | Default |
-|-----------|-------------|------|---------|
-| `model` | LLM model to use for scoring | `str` | `"gpt-4o-mini"` |
-| `provider` | LLM provider name | `str` | `"openai"` |
-| `api_key` | API key for the LLM provider | `str` | `None` |
-| `top_k` | Maximum documents to return | `int` | `None` |
-| `temperature` | Temperature for LLM generation | `float` | `0.0` |
-| `max_tokens` | Maximum tokens for LLM response | `int` | `100` |
-| `scoring_prompt` | Custom prompt template | `str` | Default prompt |
-
-## Advantages
-
-- **Maximum Flexibility**: Custom prompts for any use case
-- **Domain Expertise**: Leverage LLM knowledge for specialized domains
-- **Interpretability**: Understand scoring through prompt engineering
-- **Multi-criteria**: Score based on multiple relevance factors
-
-## Considerations
-
-- **Latency**: Higher latency than specialized rerankers
-- **Cost**: LLM API costs per reranking operation
-- **Consistency**: May have slight variations in scoring
-- **Prompt Engineering**: Requires careful prompt design
-
-## Best Practices
-
-1. **Temperature**: Use 0.0 for consistent scoring
-2. **Prompt Design**: Be specific about scoring criteria
-3. **Token Efficiency**: Keep prompts concise to reduce costs
-4. **Caching**: Cache results for repeated queries when possible
-5. **Fallback**: Handle API errors gracefully

docs/components/vectordbs/dbs/azure.mdx

@@ -100,7 +100,7 @@ To enable Role-Based Access Control (RBAC) for Azure AI Search, follow these ste
 
 1. In the Azure Portal, navigate to your **Azure AI Search** service.
 2. In the left menu, select **Settings** > **Keys**.
-3. Change the authentication setting to **Role-based access control**, or **Both** if you need API key compatibility. The default is “Key-based authentication”—you must switch it to use Azure roles.
+3. Change the authentication setting to **Role-based access control**, or **Both** if you need API key compatibility. The default is “Key-based authentication”: you must switch it to use Azure roles.
 4. **Go to Access Control (IAM):**
     - In the Azure Portal, select your Search service.
     - Click **Access Control (IAM)** on the left.

docs/components/vectordbs/dbs/baidu.mdx

@@ -46,7 +46,7 @@ Here are the parameters available for configuring Baidu VectorDB:
 | `account` | Baidu VectorDB account name | `root` |
 | `api_key` | API key for accessing Baidu VectorDB | Required |
 | `database_name` | Name of the database | `mem0` |
-| `table_name` | Name of the table | `mem0_table` |
+| `table_name` | Name of the table | `mem0` |
 | `embedding_model_dims` | Dimensions of the embedding model | `1536` |
 | `metric_type` | Distance metric for similarity search | `L2` |
 

docs/components/vectordbs/dbs/elasticsearch.mdx

@@ -56,6 +56,8 @@ Here are the parameters available for configuring Elasticsearch:
 | `api_key`              | API key for authentication                         | `None`        |
 | `user`                 | Username for basic authentication                  | `None`        |
 | `password`             | Password for basic authentication                  | `None`        |
+| `use_ssl`              | Whether to use SSL for the connection              | `True`        |
+| `ca_certs`             | Path to CA bundle for SSL certificate verification | `None`        |
 | `verify_certs`         | Whether to verify SSL certificates                 | `True`        |
 | `auto_create_index`    | Whether to automatically create the index          | `True`        |
 | `custom_search_query`  | Function returning a custom search query           | `None`        |

docs/components/vectordbs/dbs/faiss.mdx

@@ -55,6 +55,7 @@ Here are the parameters available for configuring FAISS:
 | `path` | Path to store FAISS index and metadata | `/tmp/faiss/<collection_name>` |
 | `distance_strategy` | Distance metric strategy to use (options: 'euclidean', 'inner_product', 'cosine') | `euclidean` |
 | `normalize_L2` | Whether to normalize L2 vectors (only applicable for euclidean distance) | `False` |
+| `embedding_model_dims` | Dimensions of the embedding model | `1536` |
 
 ### Performance Considerations
 

docs/components/vectordbs/dbs/langchain.mdx

@@ -47,12 +47,12 @@ m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
 ```typescript TypeScript
-import { Memory } from "mem0ai";
+import { Memory } from "mem0ai/oss";
 import { OpenAIEmbeddings } from "@langchain/openai";
-import { MemoryVectorStore as LangchainMemoryStore } from "langchain/vectorstores/memory";
+import { MemoryVectorStore } from "langchain/vectorstores/memory";
 
 const embeddings = new OpenAIEmbeddings();
-const vectorStore = new LangchainVectorStore(embeddings);
+const vectorStore = new MemoryVectorStore(embeddings);
 
 const config = {
     "vector_store": {

docs/components/vectordbs/dbs/mongodb.mdx

@@ -42,8 +42,8 @@ Here are the parameters available for configuring MongoDB:
 | Parameter | Description | Default Value |
 | --- | --- | --- |
 | db_name | Name of the MongoDB database | `"mem0_db"` |
-| collection_name | Name of the MongoDB collection | `"mem0_collection"` |
+| collection_name | Name of the MongoDB collection | `"mem0"` |
 | embedding_model_dims | Dimensions of the embedding vectors | `1536` |
-| mongo_uri | The MongoDB URI connection string | `mongodb://username:password@localhost:27017` |
+| mongo_uri | The MongoDB URI connection string | `mongodb://localhost:27017` |
 
-> **Note**: If `mongo_uri` is not provided, it will default to `mongodb://username:password@localhost:27017`.
+> **Note**: If `mongo_uri` is not provided, it will default to `mongodb://localhost:27017`.

docs/components/vectordbs/dbs/neptune_analytics.mdx

@@ -10,7 +10,7 @@ description: "Use AWS Neptune Analytics as a vector store in Mem0, combining gra
 ## Installation
 
 ```bash
-pip install mem0ai[vector_stores]
+pip install mem0ai[vector-stores]
 ```
 
 ## Usage

docs/components/vectordbs/dbs/upstash-vector.mdx

@@ -18,7 +18,9 @@ os.environ["UPSTASH_VECTOR_REST_TOKEN"] = "..."
 config = {
     "vector_store": {
         "provider": "upstash_vector",
-        "enable_embeddings": True,
+        "config": {
+            "enable_embeddings": True,
+        }
     }
 }
 

docs/components/vectordbs/dbs/valkey.mdx

@@ -9,7 +9,7 @@ description: "Use Valkey as an open-source vector store in Mem0 for high-perform
 ## Installation
 
 ```bash
-pip install mem0ai[vector_stores]
+pip install mem0ai[vector-stores]
 ```
 
 ## Usage
@@ -51,7 +51,7 @@ Here are the parameters available for configuring Valkey:
 | `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` |
+| `timezone` | Timezone for timestamp handling | `UTC` |
 
 ## Cluster Mode
 

docs/components/vectordbs/dbs/vertex_ai.mdx

@@ -24,7 +24,7 @@ config = {
             "deployment_index_id": "YOUR_DEPLOYMENT_INDEX_ID",  # Required: Deployment-specific ID
             "project_id": "YOUR_PROJECT_ID",              # Required: Google Cloud project ID
             "project_number": "YOUR_PROJECT_NUMBER",      # Required: Google Cloud project number
-            "region": "YOUR_REGION",                      # Optional: Defaults to GOOGLE_CLOUD_REGION
+            "region": "YOUR_REGION",                      # Required: Google Cloud region
             "credentials_path": "path/to/credentials.json", # Optional: Defaults to GOOGLE_APPLICATION_CREDENTIALS
             "vector_search_api_endpoint": "YOUR_API_ENDPOINT" # Required for get operations
         }
@@ -45,5 +45,6 @@ m.add("Your text here", user_id="user", metadata={"category": "example"})
 | `project_id` | Google Cloud project ID | Yes |
 | `project_number` | Google Cloud project number | Yes |
 | `vector_search_api_endpoint` | Vector search API endpoint | Yes (for get operations) |
-| `region` | Google Cloud region | No (defaults to GOOGLE_CLOUD_REGION) |
+| `region` | Google Cloud region | Yes |
 | `credentials_path` | Path to service account credentials | No (defaults to GOOGLE_APPLICATION_CREDENTIALS) |
+| `service_account_json` | Service account credentials as a dictionary (alternative to `credentials_path`) | `None` |

docs/components/vectordbs/dbs/weaviate.mdx

@@ -7,7 +7,7 @@ description: "Use Weaviate as an open-source vector search engine in Mem0 for st
 
 ### Installation
 ```bash
-pip install weaviate weaviate-client
+pip install weaviate-client
 ```
 
 ### Usage
@@ -48,4 +48,5 @@ Here are the parameters available for configuring Weaviate:
 | `collection_name` | The name of the collection to store the vectors | `mem0` |
 | `embedding_model_dims` | Dimensions of the embedding model | `1536` |
 | `cluster_url` | URL for the Weaviate server | `None` |
-| `auth_client_secret` | API key for Weaviate authentication | `None` |
+| `auth_client_secret` | API key for Weaviate authentication | `None` |
+| `additional_headers` | Additional headers to include in requests (`Dict[str, str]`) | `None` |

docs/components/vectordbs/overview.mdx

@@ -10,7 +10,7 @@ Mem0 includes built-in support for various popular databases. Memory can utilize
 See the list of supported vector databases below.
 
 <Note>
-  The following vector databases are supported in the Python implementation. The TypeScript implementation currently only supports Qdrant, Redis, Valkey, Vectorize and in-memory vector database.
+  The following vector databases are supported in the Python implementation. The TypeScript implementation currently supports Qdrant, Redis, PGVector, Supabase, LangChain, Azure AI Search, Vectorize, and an in-memory store.
 </Note>
 
 <CardGroup cols={3}>

docs/contributing/development.mdx

@@ -1,32 +1,65 @@
 ---
 title: Development
-description: "Guide to contributing code to Mem0, covering the fork and clone workflow, PR submission, and code quality checks."
+description: "Guide to contributing code to Mem0, covering the issue-first workflow, the CLA, environment setup for the Python and TypeScript SDKs, and code quality checks."
 icon: "code"
 ---
 
 # Development Contributions
 
-We strive to make contributions **easy, collaborative, and enjoyable**. Follow the steps below to ensure a smooth contribution process.
+We strive to make contributions **easy, collaborative, and enjoyable**. Mem0 is a
+polyglot monorepo containing the **Python SDK** (`mem0/`), the **TypeScript SDK**
+(`mem0-ts/`), CLIs, integrations, the self-hosted server, and the docs site.
+Follow the steps below for a smooth contribution process.
 
-## Submitting Your Contribution through PR
+<Note>
+  For the complete contributor checklist, see
+  [CONTRIBUTING.md](https://github.com/mem0ai/mem0/blob/main/CONTRIBUTING.md) in
+  the repository root.
+</Note>
 
-To contribute, follow these steps:
+## Before You Start
+
+### 1. Open an Issue First
+
+**Always open an issue before opening a pull request.** This lets us discuss the
+change, avoid duplicate work, and agree on the approach before you write code.
+
+- Search [existing issues](https://github.com/mem0ai/mem0/issues) first.
+- If none match, open a
+  [bug report](https://github.com/mem0ai/mem0/issues/new?template=bug_report.yml)
+  or [feature request](https://github.com/mem0ai/mem0/issues/new?template=feature_request.yml).
+- For anything beyond a trivial fix, wait for a maintainer to confirm the approach.
+
+Every pull request must link to an issue using `Closes #<issue-number>`.
+
+### 2. Sign the Contributor License Agreement (CLA)
+
+**We cannot merge any pull request until you have signed our Contributor License
+Agreement (CLA).** When you open your first PR, the CLA bot will comment with a
+link to sign: it takes less than a minute and only needs to be done once.
+
+## Submitting Your Contribution through a PR
 
 1. **Fork & Clone** the repository: [Mem0 on GitHub](https://github.com/mem0ai/mem0)
-2. **Create a Feature Branch**: Use a dedicated branch for your changes, e.g., `feature/my-new-feature`
-3. **Implement Changes**: If adding a feature or fixing a bug, ensure to:
+2. **Create a Feature Branch**: Use a dedicated branch, e.g., `feature/my-new-feature`
+3. **Implement Changes**: If adding a feature or fixing a bug, be sure to:
    - Write necessary **tests**
    - Add **documentation, docstrings, and runnable examples**
 4. **Code Quality Checks**:
    - Run **linting** to catch style issues
    - Ensure **all tests pass**
-5. **Submit a Pull Request**
+5. **Commit** using [Conventional Commits](https://www.conventionalcommits.org/)
+   (`feat:`, `fix:`, `docs:`, `refactor:`, `test:`)
+6. **Submit a Pull Request** against `main`, linking the issue and filling out the
+   PR template.
 
 For detailed guidance on pull requests, refer to [GitHub's documentation](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request).
 
 ---
 
-## Dependency Management
+## Python SDK (`mem0/`)
+
+### Dependency Management
 
 We use `hatch` as our package manager. Install it by following the [official instructions](https://hatch.pypa.io/latest/install/).
 
@@ -44,13 +77,9 @@ hatch -e dev_py_3_11 shell  # For dev_py_3_11 (differences are mentioned in pypr
 make install_all
 ```
 
----
-
-## Development Standards
-
 ### Pre-commit Hooks
 
-Ensure `pre-commit` is installed before contributing:
+Ensure `pre-commit` is installed before contributing (hooks run ruff + isort):
 
 ```bash
 pre-commit install
@@ -58,7 +87,7 @@ pre-commit install
 
 ### Linting with `ruff`
 
-Run the linter and fix any reported issues before submitting your PR:
+Run the linter and fix any reported issues before submitting your PR (line length **120**):
 
 ```bash
 make lint
@@ -66,10 +95,11 @@ make lint
 
 ### Code Formatting
 
-To maintain a consistent code style, format your code:
+To maintain a consistent code style, format your code and sort imports (isort, `profile = "black"`):
 
 ```bash
 make format
+make sort
 ```
 
 ### Testing with `pytest`
@@ -84,10 +114,46 @@ make test
 
 ---
 
-## Release Process
+## TypeScript SDK (`mem0-ts/`)
 
-Currently, releases are handled manually. We aim for frequent releases, typically when new features or bug fixes are introduced.
+We use [`pnpm`](https://pnpm.io/) (v10+) for all TypeScript packages. **Do NOT use
+`npm` or `yarn`.**
+
+```bash
+cd mem0-ts
+pnpm install
+
+pnpm run build        # tsup (CJS + ESM)
+pnpm run test         # jest (all tests)
+pnpm run test:unit    # unit tests with coverage
+```
+
+### Standards
+
+- **Build:** tsup
+- **Formatter:** Prettier
+- **Tests:** jest
+- Always run type checking after changes: `pnpm run typecheck` (or `tsc --noEmit`)
+- Use ES module `import` syntax: never `require()`
 
 ---
 
-Thank you for contributing to Mem0!
+## Reporting Security Issues
+
+**Do not report security vulnerabilities through public issues or pull requests.**
+Please follow our [Security Policy](https://github.com/mem0ai/mem0/blob/main/SECURITY.md)
+to report them privately.
+
+---
+
+## Release Process
+
+Packages are published automatically via GitHub Actions when a GitHub Release is
+created with the correct tag prefix (e.g. `v*` for the Python SDK, `ts-v*` for the
+TypeScript SDK). See
+[CONTRIBUTING.md](https://github.com/mem0ai/mem0/blob/main/CONTRIBUTING.md#releasing)
+for the full tag-prefix table and publishing details.
+
+---
+
+Thank you for contributing to Mem0!

docs/cookbooks/companions/nodejs-companion.mdx

@@ -31,7 +31,7 @@ const openaiClient = new OpenAI();
 const memory = new Memory();
 
 async function chatWithMemories(message, userId = "default_user") {
-  const relevantMemories = await memory.search(message, { userId: userId });
+  const relevantMemories = await memory.search(message, { filters: { user_id: userId } });
   
   const memoriesStr = relevantMemories.results
     .map(entry => `- ${entry.memory}`)

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

@@ -231,7 +231,7 @@ mem0_client.add(
   <Tab title="Open Source">
 **Categories via Metadata:**
 
-In open source, model categories with a stable field in `metadata`—here we use `memory_bucket`:
+In open source, model categories with a stable field in `metadata`. This example uses `memory_bucket`:
 
 ```python
 # Add goal
@@ -289,8 +289,7 @@ print([m["memory"] for m in constraints["results"]])
 ```python
 constraints = memory.search(
     query="injury concerns",
-    user_id="max",
-    filters={"memory_bucket": {"in": ["constraints"]}},
+    filters={"user_id": "max", "memory_bucket": {"in": ["constraints"]}},
     threshold=0.0  # optional: widen recall for short phrases
 )
 print([m["memory"] for m in constraints["results"]])
@@ -327,7 +326,7 @@ print([m["memory"] for m in memories["results"]])
 </Tabs>
 
 <Warning>
-Without filters, Mem0 stores everything—greetings, filler, and casual chat. This pollutes retrieval: instead of pulling "marathon goal," you get "lol ok." Set custom instructions to keep memory clean.
+Without filters, Mem0 stores everything: greetings, filler, and casual chat. This pollutes retrieval: instead of pulling "marathon goal," you get "lol ok." Set custom instructions to keep memory clean.
 </Warning>
 
 Noise. Greetings and filler clutter the memory.
@@ -375,7 +374,7 @@ Return JSON with key "facts" as a list of strings (use [] if nothing to store).
 memory = Memory.from_config(MEMORY_CONFIG)
 ```
 
-<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>
+<Note>`custom_instructions` is a top-level key in the config dictionary passed to `Memory.from_config()`. Set it before creating the Memory instance, not after.</Note>
   </Tab>
 </Tabs>
 
@@ -405,7 +404,7 @@ print([m["memory"] for m in memories["results"]])
 </Tabs>
 
 <Info>
-**Expected output:** Only 2 memories stored—the marathon goal and trail preference. The greeting "hey how's it going" was filtered out automatically. Custom instructions are working.
+**Expected output:** Only 2 memories stored: the marathon goal and trail preference. The greeting "hey how's it going" was filtered out automatically. Custom instructions are working.
 </Info>
 
 Only meaningful facts. Filler gets dropped automatically.
@@ -736,8 +735,7 @@ mem0_client.add(messages, user_id="max", run_id="nyc-2025")
 # Retrieve only Boston memories
 boston_memories = mem0_client.search(
     "training plan",
-    user_id="max",
-    run_id="boston-2025"
+    filters={"user_id": "max", "run_id": "boston-2025"}
 )
 ```
   </Tab>
@@ -749,8 +747,7 @@ memory.add(messages, user_id="max", run_id="nyc-2025")
 # Retrieve only Boston memories
 boston_memories = memory.search(
     "training plan",
-    user_id="max",
-    run_id="boston-2025",
+    filters={"user_id": "max", "run_id": "boston-2025"},
 )
 ```
   </Tab>
@@ -846,14 +843,13 @@ Prioritize recent training over old data:
 ```python
 recent = mem0_client.search(
     "training progress",
-    user_id="max",
-    filters={"created_at": {"gte": "2025-10-01"}}
+    filters={"user_id": "max", "created_at": {"gte": "2025-10-01"}}
 )
 ```
   </Tab>
   <Tab title="Open Source">
 ```python
-# Qdrant range filters require numbers — store an epoch timestamp in metadata
+# Qdrant range filters require numbers: store an epoch timestamp in metadata
 from datetime import datetime
 
 epoch = int(datetime(2025, 10, 15).timestamp())
@@ -866,8 +862,7 @@ memory.add(
 cutoff = int(datetime(2025, 10, 1).timestamp())
 recent = memory.search(
     "training progress",
-    user_id="max",
-    filters={"logged_epoch": {"gte": cutoff}},
+    filters={"user_id": "max", "logged_epoch": {"gte": cutoff}},
 )
 ```
   </Tab>
@@ -889,8 +884,7 @@ mem0_client.add(
 # Later, find all speed workouts
 speed_sessions = mem0_client.search(
     "speed work",
-    user_id="max",
-    filters={"metadata": {"workout_type": "speed"}}
+    filters={"user_id": "max", "metadata": {"workout_type": "speed"}}
 )
 ```
   </Tab>
@@ -905,8 +899,7 @@ memory.add(
 # Later, find all speed workouts
 speed_sessions = memory.search(
     "speed work",
-    user_id="max",
-    filters={"workout_type": "speed"},
+    filters={"user_id": "max", "workout_type": "speed"},
 )
 ```
   </Tab>

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

@@ -65,7 +65,7 @@ Patient is allergic to penicillin
 ```
 
 <Warning>
-Without custom instructions, AI assistants treat speculation as confirmed facts. "I think I might be allergic" becomes "Patient is allergic"—a dangerous transformation in sensitive domains like healthcare, legal, or financial services.
+Without custom instructions, AI assistants treat speculation as confirmed facts. "I think I might be allergic" becomes "Patient is allergic": a dangerous transformation in sensitive domains like healthcare, legal, or financial services.
 </Warning>
 
 The speculation became a confirmed fact. Let's add controls.
@@ -328,7 +328,7 @@ That “no duplicates” promise comes from the inference pipeline. Keep `infer=
 | Mode | What it does | Best for | Watch out for |
 | --- | --- | --- | --- |
 | `infer=True` *(default)* | Runs the LLM pipeline so Mem0 extracts structured facts and resolves conflicts automatically. | Daily conversations, preference tracking, anything you want deduped. | Slightly slower because inference runs on every write. |
-| `infer=False` | Stores your payload exactly as-is—no inference, no dedupe. | Bulk imports, compliance snapshots, curated facts you already trust. | Later `infer=True` calls for the same fact will create duplicates you must clean manually. |
+| `infer=False` | Stores your payload exactly as-is: no inference, no dedupe. | Bulk imports, compliance snapshots, curated facts you already trust. | Later `infer=True` calls for the same fact will create duplicates you must clean manually. |
 
 <Tip>
 Stay consistent per data source. If you need both behaviors, keep them in separate scopes (e.g., different `app_id` or `run_id`) so you always know which memories are inferred vs direct imports.

docs/cookbooks/essentials/entity-partitioning-playbook.mdx

@@ -70,7 +70,7 @@ print(agent_memories)
 ```
 
 <Tip icon="compass">
-Memories can be written with several identifiers, but each search resolves one entity boundary at a time. Run separate queries for user and agent scopes—just like above—rather than combining both in a single filter.
+Memories can be written with several identifiers, but each search resolves one entity boundary at a time. Run separate queries for user and agent scopes, as shown above, rather than combining both in a single filter.
 </Tip>
 
 ## When Memories Leak

docs/cookbooks/essentials/exporting-memories.mdx

@@ -58,6 +58,7 @@ Use `get_all()` with filters to retrieve everything for a specific user:
 ```python
 dev_memories = client.get_all(
     filters={"user_id": "dev"},
+    page=1,
     page_size=50
 )
 
@@ -75,7 +76,7 @@ First memory: Dev works at TechCorp as a senior engineer
 ```
 
 <Info>
-**Expected output:** `get_all()` retrieved Dev's complete memory record. This method returns everything matching your filters—no semantic search, no ranking, just raw retrieval. Perfect for exports and audits.
+**Expected output:** `get_all()` retrieved Dev's complete memory record. This method returns everything matching your filters: no semantic search, no ranking, just raw retrieval. Perfect for exports and audits.
 </Info>
 
 You can filter by metadata to get specific types:
@@ -277,7 +278,7 @@ This covers data portability, GDPR compliance, system migrations, and manual rev
 
 ## Summary
 
-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.
+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="Build a Mem0 Companion" icon="users" href="/cookbooks/essentials/building-ai-companion">

docs/cookbooks/essentials/tagging-and-organizing-memories.mdx

@@ -19,7 +19,7 @@ client = MemoryClient(api_key="your-api-key")
 ```
 
 <Note>
-Define custom categories at the **project level** with `client.project.update()` before adding memories. Categories apply to all future memories—Mem0 auto-assigns them based on content semantics.
+Define custom categories at the **project level** with `client.project.update()` before adding memories. Categories apply to all future memories: Mem0 auto-assigns them based on content semantics.
 </Note>
 
 ---
@@ -67,7 +67,7 @@ Total memories: 3
 ```
 
 <Warning>
-Without categories, agents waste time reading through everything. For a customer with 100 memories, finding one billing issue means scanning all 100. Categories let you filter to exactly what you need—billing issues only, no password resets or feedback mixed in.
+Without categories, agents waste time reading through everything. For a customer with 100 memories, finding one billing issue means scanning all 100. Categories let you filter to exactly what you need: billing issues only, no password resets or feedback mixed in.
 </Warning>
 
 Everything is mixed together. Support agents have to read through all memories to find what they need.
@@ -91,7 +91,7 @@ client.project.update(custom_categories=custom_categories)
 ```
 
 <Tip>
-Start with 3-5 clear categories that match how your team thinks. Too many categories dilute auto-tagging accuracy. Add more later if needed—it's easier to expand than to fix over-complicated classification.
+Start with 3-5 clear categories that match how your team thinks. Too many categories dilute auto-tagging accuracy. Add more later if needed: it's easier to expand than to fix over-complicated classification.
 </Tip>
 
 These categories are now available project-wide. Every memory can be tagged with one or more categories.
@@ -160,7 +160,7 @@ Billing issues:
 ```
 
 <Info icon="check">
-**Expected output:** Only the billing issue returned—no password reset, no upgrade request. Category filtering worked. Joseph can audit billing without reading through unrelated support tickets.
+**Expected output:** Only the billing issue returned: no password reset, no upgrade request. Category filtering worked. Joseph can audit billing without reading through unrelated support tickets.
 </Info>
 
 Only billing-related memories are returned. No need to filter through account updates or feedback.
@@ -239,7 +239,7 @@ This pattern scales from 10 customers to 10,000 without degrading retrieval spee
 
 Categories make retrieval faster and compliance easier. Define 3-5 clear categories with `client.project.update()`, let Mem0 auto-assign them based on content, then filter with `categories: {in: [...]}` to pull exactly what you need.
 
-Instead of searching through everything, agents jump directly to the information type they need—billing issues, account details, or support tickets.
+Instead of searching through everything, agents jump directly to the information type they need: billing issues, account details, or support tickets.
 
 <CardGroup cols={2}>
   <Card title="Control Memory Ingestion" icon="filter" href="/cookbooks/essentials/controlling-memory-ingestion">

docs/cookbooks/frameworks/llamaindex-multiagent.mdx

@@ -211,8 +211,8 @@ class MultiAgentLearningSystem:
         try:
             # Search memory for learning patterns
             memories = self.memory.search(
-                user_id=self.student_id,
-                query="learning machine learning"
+                query="learning machine learning",
+                filters={"user_id": self.student_id}
             )
 
             if memories and memories.get('results'):

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

@@ -50,7 +50,7 @@ load_dotenv()
 USER_ID = "Alex"
 
 # Initialize Mem0 client
-mem0 = MemoryClient()
+mem0_client = MemoryClient()
 ```
 
 ## Define Memory Tools
@@ -76,7 +76,7 @@ def retrieve_patient_info(query: str) -> dict:
     # Search Mem0
     results = mem0_client.search(
         query,
-        user_id=USER_ID,
+        filters={"user_id": USER_ID},
         top_k=5,
         threshold=0.7  # Higher threshold for more relevant results
     )

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

@@ -53,34 +53,12 @@ async function addUserPreferences() {
 await addUserPreferences();
 ```
 
-```json Output (Memories)
- [
-  {
-    "id": "ff9f3367-9e83-415d-b9c5-dc8befd9a4b4",
-    "data": { "memory": "Loves BMW, Audi, and Porsche" },
-    "event": "ADD"
-  },
-  {
-    "id": "04172ce6-3d7b-45a3-b4a1-ee9798593cb4",
-    "data": { "memory": "Hates Mercedes" },
-    "event": "ADD"
-  },
-  {
-    "id": "db363a5d-d258-4953-9e4c-777c120de34d",
-    "data": { "memory": "Loves red cars and maroon cars" },
-    "event": "ADD"
-  },
-  {
-    "id": "5519aaad-a2ac-4c0d-81d7-0d55c6ecdba8",
-    "data": { "memory": "Has a budget of 120K to 150K USD" },
-    "event": "ADD"
-  },
-  {
-    "id": "523b7693-7344-4563-922f-5db08edc8634",
-    "data": { "memory": "Likes Audi the most" },
-    "event": "ADD"
-  }
-]
+```json Output
+{
+  "message": "Memory processing has been queued for background execution",
+  "status": "PENDING",
+  "event_id": "9f8c2b1a-4e7d-4c3a-9b21-1a2b3c4d5e6f"
+}
 ```
 </CodeGroup>
 ## Retrieving Memories
@@ -88,7 +66,7 @@ await addUserPreferences();
 Search for relevant memories based on the current user input:
 
 ```javascript
-const relevantMemories = await mem0Client.search(userInput, { userId: USER_ID });
+const relevantMemories = await mem0Client.search(userInput, { filters: { user_id: USER_ID } });
 ```
 
 ## Structured Responses with Zod
@@ -194,7 +172,7 @@ async function main(memory = false) {
   // Search for relevant memories
   let relevantMemories = []
   if (memory) {
-    relevantMemories = await mem0Client.search(input, { userId: USER_ID });
+    relevantMemories = await mem0Client.search(input, { filters: { user_id: USER_ID } });
   }
 
   const response = await openAIClient.responses.create({

docs/cookbooks/integrations/tavily-search.mdx

@@ -4,8 +4,6 @@ description: "Blend Tavily's realtime results with personal context stored in Me
 ---
 
 
-<Snippet file="security-compliance.mdx" />
-
 Imagine asking a search assistant for "coffee shops nearby" and instead of generic results, it shows remote-work-friendly cafes with great WiFi in your city because it remembers you mentioned working remotely before. Or when you search for "lunchbox ideas for kids" it knows you have a 7-year-old daughter and recommends peanut-free options that align with her allergy.
 
 That's what we are going to build today, a Personalized Search Assistant powered by Mem0 for memory and [Tavily](https://tavily.com) for real-time search.

docs/cookbooks/operations/content-writing.mdx

@@ -217,8 +217,7 @@ def apply_writing_style(original_content):
 
     results = memory.search(
         query="What are my writing style preferences?",
-        user_id=USER_ID,
-        run_id=RUN_ID,
+        filters={"user_id": USER_ID, "run_id": RUN_ID},
     )
 
     if not results:

docs/cookbooks/operations/email-automation.mdx

@@ -314,18 +314,16 @@ class EmailProcessor:
             user_id (str): User identifier
             sender (str, optional): Filter by sender email address
         """
-        # In OSS, user_id is an explicit parameter (not inside filters)
         if not sender:
             results = self.memory.search(
                 query=query,
-                user_id=user_id,
-                filters={"memory_category": "email"},
+                filters={"user_id": user_id, "memory_category": "email"},
             )
         else:
             results = self.memory.search(
                 query=query,
-                user_id=user_id,
                 filters={
+                    "user_id": user_id,
                     "AND": [
                         {"memory_category": "email"},
                         {"sender": sender},
@@ -343,10 +341,9 @@ class EmailProcessor:
             subject (str): Email subject to match
             user_id (str): User identifier
         """
-        # In OSS, user_id is an explicit parameter
         thread = self.memory.get_all(
-            user_id=user_id,
             filters={
+                "user_id": user_id,
                 "AND": [
                     {"memory_category": "email"},
                     {"subject": {"icontains": subject}},

docs/cookbooks/operations/support-inbox.mdx

@@ -57,7 +57,7 @@ class CustomerSupportAIAgent:
         """
         # Start a streaming chat completion request to the AI
         stream = self.client.chat.completions.create(
-            model="gpt-4",
+            model="gpt-5-mini",
             stream=True,
             messages=[
                 {"role": "system", "content": "You are a customer support AI agent."},

docs/core-concepts/memory-evaluation.mdx

@@ -7,13 +7,13 @@ 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.
+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** means achieving high accuracy with less context per query. It 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.
+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
 
@@ -23,10 +23,10 @@ Mem0's memory system operates across two phases, **extraction** (writing) and **
 
 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
+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. **Graph Memory (Entity Linking)**: Identify entities (proper nouns, quoted text, compound noun phrases) and link them across memories into a graph
 
 Memories are distributed across three storage layers, each tuned for a specific retrieval pattern:
@@ -38,16 +38,16 @@ Memories are distributed across three storage layers, each tuned for a specific
 | **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.
+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 matching boosts memories linked to query entities
+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 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:
 
@@ -94,7 +94,7 @@ The two largest gains are **temporal queries (+29.6)** and **multi-hop reasoning
 
 *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 biggest gain is **single-session assistant (+53.6)** because 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.
 
@@ -119,7 +119,7 @@ The **+42.1 on temporal reasoning** reflects the ADD-only architecture preservin
 *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.
+**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
@@ -130,8 +130,8 @@ All results use a single-pass retrieval setup: one retrieval call, one answer, n
 |---|---|---|---|
 | **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 |
+| **BEAM (1M)** | N/A | **64.1** | 6,719 |
+| **BEAM (10M)** | N/A | **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.
@@ -183,7 +183,7 @@ Each benchmark is a Python module with its own runner ([source code](https://git
 |---|---|---|
 | `--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-api-key` | N/A | 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`) |
@@ -192,9 +192,9 @@ Each benchmark is a Python module with its own runner ([source code](https://git
 | `--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) |
+| `--predict-only` | N/A | Stop after search, skip answer + judge phases |
+| `--evaluate-only` | N/A | Skip ingest + search, evaluate existing results |
+| `--resume` | N/A | Resume from checkpoint (BEAM and LongMemEval; on by default for LongMemEval) |
 
 <CodeGroup>
 ```bash LoCoMo
@@ -329,7 +329,7 @@ When evaluating memory systems, keep these considerations in mind:
     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.
+    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.

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

@@ -48,7 +48,7 @@ Future searches rank the most relevant memories for the query.
 When you switch to `infer=False`, Mem0 stores your payload exactly as provided, so duplicates can land. Mixing both modes for the same fact can save it twice.
 </Warning>
 
-You trigger this pipeline with a single `add` call—no manual orchestration needed.
+You trigger this pipeline with a single `add` call: no manual orchestration needed.
 
 ## Add with Mem0 Platform
 
@@ -169,7 +169,7 @@ For full list of supported fields, required formats, and advanced options, see t
 | --- | --- | --- |
 | Add behavior | ADD-only; memories accumulate | ADD-only; you control storage |
 | Rate limits | Managed quotas per workspace | Limited by your hardware and provider APIs |
-| Dashboard visibility | Yes — inspect memories visually | Inspect via CLI, logs, or custom UI |
+| Dashboard visibility | Yes: inspect memories visually | Inspect via CLI, logs, or custom UI |
 
 ## Put it into practice
 

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

@@ -152,7 +152,7 @@ client.delete_all(user_id="*")
 # Delete all memories across every agent in the project
 client.delete_all(agent_id="*")
 
-# Full project wipe — all four filters must be explicitly set to "*"
+# Full project wipe: all four filters must be explicitly set to "*"
 client.delete_all(user_id="*", agent_id="*", app_id="*", run_id="*")
 ```
 
@@ -166,7 +166,7 @@ client.deleteAll({ userId: "*" })
   .then(result => console.log(result))
   .catch(error => console.error(error));
 
-// Full project wipe — all four filters must be explicitly set to "*"
+// Full project wipe: all four filters must be explicitly set to "*"
 client.deleteAll({ userId: "*", agentId: "*", appId: "*", runId: "*" })
   .then(result => console.log(result))
   .catch(error => console.error(error));
@@ -191,7 +191,7 @@ memory.delete_all(user_id="alice")
 </CodeGroup>
 
 <Note>
-  The OSS JavaScript SDK does not yet expose deletion helpers—use the REST API or Python SDK when self-hosting.
+  The OSS JavaScript SDK does not yet expose deletion helpers: use the REST API or Python SDK when self-hosting.
 </Note>
 
 ## Use cases recap

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

@@ -70,7 +70,7 @@ m.search("What are Alice's hobbies?", filters={"user_id": "alice"})
 
 | Capability | Mem0 Platform | Mem0 OSS |
 | --- | --- | --- |
-| **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`) |
+| **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 |
@@ -121,7 +121,7 @@ from mem0 import Memory
 
 m = Memory()
 
-# Simple search — entity IDs go in `filters`
+# Simple search: entity IDs go in `filters`
 related_memories = m.search("Should I drink coffee or tea?", filters={"user_id": "alice"})
 
 # Search with additional metadata filters (combine entity + metadata in the same dict)
@@ -136,7 +136,7 @@ import { Memory } from 'mem0ai/oss';
 
 const memory = new Memory();
 
-// Simple search — entity IDs go inside `filters`
+// Simple search: entity IDs go inside `filters`
 const relatedMemories = memory.search("Should I drink coffee or tea?", {
     filters: { userId: "alice" },
 });
@@ -203,7 +203,7 @@ client.search("query", filters={
 
 *OSS:*
 ```python
-# Get memories from a specific agent session — entity IDs combined in filters
+# Get memories from a specific agent session: entity IDs combined in filters
 m.search("query", filters={
     "user_id": "alice",
     "agent_id": "chatbot",
@@ -238,11 +238,11 @@ client.search("preferences", filters={
 - **Use natural language**: Mem0 understands intent, so describe what you're looking for naturally
 - **Scope with user ID**: Always provide `user_id` to scope search to relevant memories
   - **Platform API**: Use `filters={"user_id": "alice"}`
-  - **OSS**: Use `user_id="alice"` as parameter
+  - **OSS**: Use `filters={"user_id": "alice"}` (passing `user_id` as a top-level kwarg raises `ValueError` in v3)
 - **Combine filters**: Use AND/OR logic to create precise queries (Platform)
 - **Consider wildcard filters**: Use wildcard filters (e.g., `run_id: "*"`) for broader matches
 - **Tune parameters**: Adjust `top_k` for result count, `threshold` for relevance cutoff
-- **Enable reranking**: Use `rerank=True` (default) when you have a reranker configured
+- **Enable reranking**: Use `rerank=True` (default is `False`) when you have a reranker configured
 
 <Callout type="tip" icon="plug">
   **MCP Alternative**: With <Link href="/platform/mem0-mcp">Mem0 MCP</Link>, AI agents can search their own memories proactively when needed.

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

@@ -127,7 +127,7 @@ memory.update(
 </CodeGroup>
 
 <Note>
-  OSS JavaScript SDK does not expose `update` yet—use the REST API or Python SDK when self-hosting.
+  OSS JavaScript SDK does not expose `update` yet: use the REST API or Python SDK when self-hosting.
 </Note>
 
 ## Tips
@@ -148,7 +148,7 @@ memory.update(
 | Update call | `client.update(memory_id, {...})` | `memory.update(memory_id, data=...)` |
 | Batch updates | `client.batch_update` (up to 1000 memories) | Script your own loop or bulk job |
 | Dashboard visibility | Inspect updates in the UI | Inspect via logs or custom tooling |
-| Immutable handling | Returns descriptive error | Raises exception—delete and re-add |
+| Immutable handling | Returns descriptive error | Raises exception: delete and re-add |
 
 ## Put it into practice
 

docs/core-concepts/memory-types.mdx

@@ -60,7 +60,7 @@ import os
 
 from mem0 import Memory
 
-memory = Memory(api_key=os.environ["MEM0_API_KEY"])
+memory = Memory()
 
 # Sticky note: conversation memory
 memory.add(
@@ -72,8 +72,7 @@ memory.add(
 # Later in the session, pull long-term + session context
 results = memory.search(
     "Any hotel preferences?",
-    user_id="alex",
-    run_id="trip-planning-2025",
+    filters={"user_id": "alex", "run_id": "trip-planning-2025"},
 )
 ```
 
@@ -98,7 +97,7 @@ results = memory.search(
 | Org | Configured globally | Long-term | Shared knowledge | Needs owner to keep current |
 
 <Warning>
-  Avoid storing secrets or unredacted PII in user or org memories—Mem0 is retrievable by design. Encrypt or hash sensitive values first.
+  Avoid storing secrets or unredacted PII in user or org memories: Mem0 is retrievable by design. Encrypt or hash sensitive values first.
 </Warning>
 
 ## Put it into practice

docs/docs.json

@@ -123,8 +123,7 @@
                     "icon": "arrow-right",
                     "pages": [
                       "migration/platform-v2-to-v3",
-                      "migration/oss-to-platform",
-                      "migration/api-changes"
+                      "migration/oss-to-platform"
                     ]
                   },
                   {
@@ -136,20 +135,6 @@
                   }
                 ]
               },
-              {
-                "tab": "OpenClaw",
-                "groups": [
-                  {
-                    "group": "Agent Harness",
-                    "icon": "robot",
-                    "pages": [
-                      "integrations/openclaw",
-                      "integrations/hermes",
-                      "integrations/pi-agent"
-                    ]
-                  }
-                ]
-              },
               {
                 "tab": "Open Source",
                 "groups": [
@@ -273,7 +258,8 @@
                               "components/embedders/models/lmstudio",
                               "components/embedders/models/together",
                               "components/embedders/models/langchain",
-                              "components/embedders/models/aws_bedrock"
+                              "components/embedders/models/aws_bedrock",
+                              "components/embedders/models/fastembed"
                             ]
                           }
                         ]
@@ -533,6 +519,8 @@
                       "api-reference/organization/get-org",
                       "api-reference/organization/get-org-members",
                       "api-reference/organization/add-org-member",
+                      "api-reference/organization/update-org-member",
+                      "api-reference/organization/remove-org-member",
                       "api-reference/organization/delete-org"
                     ]
                   },
@@ -545,6 +533,9 @@
                       "api-reference/project/get-project",
                       "api-reference/project/get-project-members",
                       "api-reference/project/add-project-member",
+                      "api-reference/project/update-project",
+                      "api-reference/project/update-project-member",
+                      "api-reference/project/remove-project-member",
                       "api-reference/project/delete-project"
                     ]
                   },
@@ -569,8 +560,7 @@
                     "pages": [
                       "changelog/highlights",
                       "changelog/sdk",
-                      "changelog/platform",
-                      "changelog/openclaw"
+                      "changelog/platform"
                     ]
                   }
                 ]
@@ -624,6 +614,14 @@
     ]
   },
   "redirects": [
+    {
+      "source": "/changelog/openclaw",
+      "destination": "/changelog/sdk"
+    },
+    {
+      "source": "/components/rerankers/models/llm",
+      "destination": "/components/rerankers/models/llm_reranker"
+    },
     {
       "source": "/migration/breaking-changes",
       "destination": "/"
@@ -632,6 +630,10 @@
       "source": "/migration/v0-to-v1",
       "destination": "/"
     },
+    {
+      "source": "/migration/api-changes",
+      "destination": "/migration/oss-v2-to-v3"
+    },
     {
       "source": "/platform/features/expiration-date",
       "destination": "/"

docs/integrations/agno.mdx

@@ -73,7 +73,7 @@ client = MemoryClient()
 # Define the agent
 agent = Agent(
     name="Personal Agent",
-    model=OpenAIChat(id="gpt-4"),
+    model=OpenAIChat(id="gpt-5-mini"),
     description="You are a helpful personal agent that helps me with day to day activities."
                 "You can process both text and images.",
     markdown=True

docs/integrations/antigravity.mdx

@@ -1,9 +1,9 @@
 ---
 title: Antigravity
-description: "Add persistent memory to Google Antigravity with the Mem0 plugin — MCP server, lifecycle hooks, and slash commands."
+description: "Add persistent memory to Google Antigravity with the Mem0 plugin: MCP server, lifecycle hooks, and slash commands."
 ---
 
-Add persistent memory to [**Google Antigravity**](https://antigravity.google) (`agy` CLI and Desktop IDE) with the Mem0 plugin. Your agent forgets everything between sessions — Mem0 fixes that by storing decisions, preferences, and learnings so they carry over automatically.
+Add persistent memory to [**Google Antigravity**](https://antigravity.google) (`agy` CLI and Desktop IDE) with the Mem0 plugin. Your agent forgets everything between sessions. Mem0 fixes that by storing decisions, preferences, and learnings so they carry over automatically.
 
 ## Prerequisites
 
@@ -24,7 +24,7 @@ echo 'export MEM0_API_KEY="m0-your-api-key"' >> ~/.bashrc && source ~/.bashrc
 
 ## Installation
 
-**Option A — degit** (recommended):
+**Option A: degit** (recommended):
 
 ```bash
 # Install the plugin (MCP server, hooks, scripts)
@@ -57,7 +57,7 @@ This installs the MCP server, lifecycle hooks, and shared scripts.
 
 ## Lifecycle Hooks
 
-The plugin uses the same shell scripts as Claude Code, Cursor, and Codex — hooks bridge environment variables using `${extensionPath}` (Antigravity's plugin-root token).
+The plugin uses the same shell scripts as Claude Code, Cursor, and Codex: hooks bridge environment variables using `${extensionPath}` (Antigravity's plugin-root token).
 
 | Hook | Event | What it does |
 |------|-------|-------------|
@@ -69,9 +69,9 @@ The plugin uses the same shell scripts as Claude Code, Cursor, and Codex — hoo
 
 ## Troubleshooting
 
-- **No tools appearing** — Restart your Antigravity session after installation
-- **"Connection failed"** — Verify your key is set: `echo $MEM0_API_KEY`
-- **MCP 401 Unauthorized** — If `${MEM0_API_KEY}` interpolation doesn't work in your `agy` version, replace with your literal key in `mcp_config.json`
+- **No tools appearing**: Restart your Antigravity session after installation
+- **"Connection failed"**: Verify your key is set: `echo $MEM0_API_KEY`
+- **MCP 401 Unauthorized**: If `${MEM0_API_KEY}` interpolation doesn't work in your `agy` version, replace with your literal key in `mcp_config.json`
 
 <CardGroup cols={2}>
   <Card title="Mem0 MCP Setup" icon="puzzle-piece" href="/platform/mem0-mcp">

docs/integrations/autogen.mdx

@@ -43,7 +43,7 @@ OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY')
 memory_client = MemoryClient()
 agent = ConversableAgent(
     "chatbot",
-    llm_config={"config_list": [{"model": "gpt-4", "api_key": OPENAI_API_KEY}]},
+    llm_config={"config_list": [{"model": "gpt-5-mini", "api_key": OPENAI_API_KEY}]},
     code_execution_config=False,
     human_input_mode="NEVER",
 )
@@ -99,7 +99,7 @@ For more complex scenarios, you can create multiple agents:
 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}]},
+    llm_config={"config_list": [{"model": "gpt-5-mini", "api_key": OPENAI_API_KEY}]},
     human_input_mode="NEVER"
 )
 

docs/integrations/camel-ai.mdx

@@ -124,9 +124,9 @@ print(response.msgs[0].content)
 
 ## Troubleshooting
 
-- **Missing MEM0_API_KEY** — set `export MEM0_API_KEY="sk-..."` or pass `api_key` into `Mem0Storage`.
-- **No memories returned** — ensure `agent_id`/`user_id` in your query match what you used when writing.
-- **Network errors to Mem0** — if self-hosting, set `MEM0_BASE_URL` to your deployment URL.
+- **Missing MEM0_API_KEY**: set `export MEM0_API_KEY="sk-..."` or pass `api_key` into `Mem0Storage`.
+- **No memories returned**: ensure `agent_id`/`user_id` in your query match what you used when writing.
+- **Network errors to Mem0**: if self-hosting, set `MEM0_BASE_URL` to your deployment URL.
 
 <CardGroup cols={2}>
   <Card

docs/integrations/chatdev.mdx

@@ -1,9 +1,9 @@
 ---
 title: ChatDev
-description: "Add persistent, cloud-managed memory to ChatDev multi-agent workflows with Mem0 — no code required, just YAML configuration."
+description: "Add persistent, cloud-managed memory to ChatDev multi-agent workflows with Mem0: no code required, just YAML configuration."
 ---
 
-Build multi-agent workflows in [ChatDev](https://github.com/OpenBMB/ChatDev) with persistent memory powered by Mem0. ChatDev is a zero-code multi-agent platform where agents, tools, and workflows are defined entirely in YAML. Mem0 integrates as a built-in memory store (`type: mem0`), giving your agents cloud-managed semantic search and cross-session persistence — all without writing any code.
+Build multi-agent workflows in [ChatDev](https://github.com/OpenBMB/ChatDev) with persistent memory powered by Mem0. ChatDev is a zero-code multi-agent platform where agents, tools, and workflows are defined entirely in YAML. Mem0 integrates as a built-in memory store (`type: mem0`), giving your agents cloud-managed semantic search and cross-session persistence, all without writing any code.
 
 ## Overview
 
@@ -16,8 +16,8 @@ In this guide, you'll:
 ## Prerequisites
 
 - **Python 3.12+**
-- **[uv](https://docs.astral.sh/uv/)** — Python package manager
-- **Node.js 18+** and **npm** — only needed if using the web console
+- **[uv](https://docs.astral.sh/uv/)**: Python package manager
+- **Node.js 18+** and **npm**: only needed if using the web console
 - A **Mem0 API key** from <a href="https://app.mem0.ai?utm_source=oss&utm_medium=integration-chatdev" rel="nofollow">app.mem0.ai</a>
 - An **OpenAI API key** (or another LLM provider supported by ChatDev)
 
@@ -61,7 +61,7 @@ memory:
       agent_id: my-agent         # optional: scope memories to an agent
 ```
 
-Mem0 handles all storage, embeddings, and search server-side — no local vector databases or embedding models are needed.
+Mem0 handles all storage, embeddings, and search server-side. No local vector databases or embedding models are needed.
 
 ## Attach Memory to an Agent
 
@@ -85,11 +85,11 @@ nodes:
           write: true
 ```
 
-- **`read: true`** — Agent retrieves relevant memories before generating a response
-- **`write: true`** — Agent stores new memories from user input after each interaction
-- **`top_k`** — Number of memories to retrieve per query
-- **`similarity_threshold`** — Minimum relevance score for retrieved memories. Set to `-1.0` to return all results regardless of score
-- **`retrieve_stage`** — When to retrieve memories. Options: `pre_gen_thinking` (before generation), `gen` (during generation), `post_gen_thinking` (after generation), `finished` (after completion)
+- **`read: true`**: Agent retrieves relevant memories before generating a response
+- **`write: true`**: Agent stores new memories from user input after each interaction
+- **`top_k`**: Number of memories to retrieve per query
+- **`similarity_threshold`**: Minimum relevance score for retrieved memories. Set to `-1.0` to return all results regardless of score
+- **`retrieve_stage`**: When to retrieve memories. Options: `pre_gen_thinking` (before generation), `gen` (during generation), `post_gen_thinking` (after generation), `finished` (after completion)
 
 ## Full Example Workflow
 
@@ -154,7 +154,7 @@ To use the web console, open `http://localhost:5173`, create a new workflow, and
 
 When an agent with Mem0 memory receives input, the following cycle runs automatically:
 
-**1. Retrieve** — Before generating a response, ChatDev queries Mem0 with the user's input using semantic search. Relevant memories are injected into the agent's context in this format:
+**1. Retrieve**: Before generating a response, ChatDev queries Mem0 with the user's input using semantic search. Relevant memories are injected into the agent's context in this format:
 
 ```
 ===== Related Memories =====
@@ -164,11 +164,11 @@ When an agent with Mem0 memory receives input, the following cycle runs automati
 ===== End of Memory =====
 ```
 
-This is why the role prompt in the example references `===== Related Memories =====` — the agent needs to know how to use this injected context.
+This is why the role prompt in the example references `===== Related Memories =====`: the agent needs to know how to use this injected context.
 
-**2. Generate** — The agent produces a response using the retrieved memories as additional context.
+**2. Generate**: The agent produces a response using the retrieved memories as additional context.
 
-**3. Store** — After generation, the user's input is sent to Mem0 via `client.add()`. Mem0's extraction model automatically identifies and stores facts, preferences, and key information. Only user input is stored — agent output is excluded to keep memories clean.
+**3. Store**: After generation, the user's input is sent to Mem0 via `client.add()`. Mem0's extraction model automatically identifies and stores facts, preferences, and key information. Only user input is stored. Agent output is excluded to keep memories clean.
 
 Memories persist in Mem0's cloud across all sessions. The next time the same `user_id` or `agent_id` is used, previous memories are automatically retrieved.
 
@@ -211,23 +211,23 @@ This means retrieval returns memories from **both** the user's scope and the age
 ## Tips and Common Pitfalls
 
 <Info>
-**Indexing delay** — Freshly stored memories may take a few seconds to become searchable. If a memory isn't retrieved immediately after being stored, wait a moment and try again.
+**Indexing delay**: Freshly stored memories may take a few seconds to become searchable. If a memory isn't retrieved immediately after being stored, wait a moment and try again.
 </Info>
 
-- **No memories returned on first run** — This is expected. Memories are stored *after* the agent responds, so the first interaction has no prior context. Memories appear starting from the second interaction onward.
-- **`mem0ai` not installed** — If you see `ImportError: mem0ai is required for Mem0Memory`, run `uv add mem0ai` or `pip install mem0ai` to add the dependency.
-- **Invalid API key** — A wrong or expired `MEM0_API_KEY` will log errors like `Mem0 search failed` or `Mem0 add failed` but won't crash the agent. Check your key at <a href="https://app.mem0.ai?utm_source=oss&utm_medium=integration-chatdev" rel="nofollow">app.mem0.ai</a>.
-- **Pipeline headers in memories** — ChatDev automatically strips internal pipeline headers (e.g., `=== INPUT FROM TASK (user) ===`) before sending text to Mem0, so your memories stay clean.
-- **Clearing test memories** — To delete memories created during testing, use the Mem0 dashboard at <a href="https://app.mem0.ai?utm_source=oss&utm_medium=integration-chatdev" rel="nofollow">app.mem0.ai</a> or the Python SDK: `MemoryClient().delete_all(user_id="your-test-user")`.
+- **No memories returned on first run**: This is expected. Memories are stored *after* the agent responds, so the first interaction has no prior context. Memories appear starting from the second interaction onward.
+- **`mem0ai` not installed**: If you see `ImportError: mem0ai is required for Mem0Memory`, run `uv add mem0ai` or `pip install mem0ai` to add the dependency.
+- **Invalid API key**: A wrong or expired `MEM0_API_KEY` will log errors like `Mem0 search failed` or `Mem0 add failed` but won't crash the agent. Check your key at <a href="https://app.mem0.ai?utm_source=oss&utm_medium=integration-chatdev" rel="nofollow">app.mem0.ai</a>.
+- **Pipeline headers in memories**: ChatDev automatically strips internal pipeline headers (e.g., `=== INPUT FROM TASK (user) ===`) before sending text to Mem0, so your memories stay clean.
+- **Clearing test memories**: To delete memories created during testing, use the Mem0 dashboard at <a href="https://app.mem0.ai?utm_source=oss&utm_medium=integration-chatdev" rel="nofollow">app.mem0.ai</a> or the Python SDK: `MemoryClient().delete_all(user_id="your-test-user")`.
 
 ## Key Features
 
-1. **Zero-Code Integration** — Configure Mem0 entirely through YAML, no Python code required
-2. **Cloud-Managed Storage** — Mem0 handles embeddings, persistence, and search server-side
-3. **Semantic Search** — Retrieve contextually relevant memories, not just keyword matches
-4. **Cross-Session Persistence** — Memories survive across runs, sessions, and restarts
-5. **Multi-Agent Memory Sharing** — Multiple agents can share memories through common `user_id` or `agent_id` scopes
-6. **Intelligent Input Processing** — Only user input is stored; agent output is excluded to prevent noisy memories
+1. **Zero-Code Integration**: Configure Mem0 entirely through YAML, no Python code required
+2. **Cloud-Managed Storage**: Mem0 handles embeddings, persistence, and search server-side
+3. **Semantic Search**: Retrieve contextually relevant memories, not just keyword matches
+4. **Cross-Session Persistence**: Memories survive across runs, sessions, and restarts
+5. **Multi-Agent Memory Sharing**: Multiple agents can share memories through common `user_id` or `agent_id` scopes
+6. **Intelligent Input Processing**: Only user input is stored; agent output is excluded to prevent noisy memories
 
 ## Conclusion
 

docs/integrations/claude-code.mdx

@@ -1,9 +1,9 @@
 ---
 title: Claude Code
-description: "Add persistent memory to Claude Code and Claude Cowork with the Mem0 plugin — MCP server, lifecycle hooks, and SDK skill."
+description: "Add persistent memory to Claude Code and Claude Cowork with the Mem0 plugin: MCP server, lifecycle hooks, and SDK skill."
 ---
 
-Add persistent memory to [**Claude Code**](https://docs.anthropic.com/en/docs/claude-code) (CLI) and **Claude Cowork** (desktop app) with the Mem0 plugin. Your agent forgets everything between sessions — this plugin fixes that by connecting to Mem0's cloud memory layer via MCP, automatically capturing learnings at key lifecycle points, and retrieving relevant context before every response.
+Add persistent memory to [**Claude Code**](https://docs.anthropic.com/en/docs/claude-code) (CLI) and **Claude Cowork** (desktop app) with the Mem0 plugin. Your agent forgets everything between sessions. This plugin fixes that by connecting to Mem0's cloud memory layer via MCP, automatically capturing learnings at key lifecycle points, and retrieving relevant context before every response.
 
 ## Prerequisites
 
@@ -38,7 +38,7 @@ echo $MEM0_API_KEY
 
 ## Installation
 
-### Option A — Plugin Marketplace (Recommended)
+### Option A: Plugin Marketplace (Recommended)
 
 Install the full plugin including MCP server, lifecycle hooks, and SDK skill.
 
@@ -56,7 +56,7 @@ Install the full plugin including MCP server, lifecycle hooks, and SDK skill.
 
 **Claude Cowork desktop app:** Open the Cowork tab, click **Customize** in the sidebar, click **Browse plugins**, and install Mem0.
 
-### Option B — MCP Only
+### Option B: MCP Only
 
 Add the Mem0 MCP server directly with a single command:
 
@@ -70,7 +70,7 @@ npx mcp-add \
 
 This gives you the MCP tools but not the lifecycle hooks or SDK skill.
 
-### Option C — Manual MCP Configuration
+### Option C: Manual MCP Configuration
 
 Add to your Claude Code MCP config (`.mcp.json`):
 
@@ -106,7 +106,7 @@ This runs the setup wizard which:
 3. Installs coding-optimized memory categories
 4. Shows your identity (user ID, project scope, branch)
 
-The onboarding is idempotent — safe to re-run anytime. It auto-triggers on first session in a new project, but you can always invoke it manually.
+The onboarding is idempotent and safe to re-run anytime. It auto-triggers on first session in a new project, but you can always invoke it manually.
 
 ## What's Included
 
@@ -138,9 +138,10 @@ When installed via the plugin marketplace, Mem0 hooks into Claude Code's lifecyc
 
 | Hook | Event | What it does |
 |------|-------|-------------|
+| **Setup** | `Setup` | Installs the mem0 SDK and dependencies (runs on init and maintenance) |
 | **Session start** | `SessionStart` | Loads prior memories and displays status banner |
 | **User prompt** | `UserPromptSubmit` | Searches relevant memories before each message; skips short prompts |
-| **Pre-tool** | `PreToolUse` | Blocks MEMORY.md writes, enforces `user_id`/`app_id` on mem0 tool calls |
+| **Pre-tool (3 handlers)** | `PreToolUse` | Blocks MEMORY.md writes; enforces `user_id`/`app_id` on mem0 tool calls; scans files being read for relevant memory context |
 | **Post-tool** | `PostToolUse` | Tracks stats, scans bash errors for related memories |
 | **Stop** | `Stop` | Stores a session summary when the session ends |
 | **Pre-compact** | `PreCompact` | Stores a summary before the context is compacted |
@@ -167,10 +168,10 @@ You: Add refresh token rotation to the auth system.
 
 ## Troubleshooting
 
-- **"Connection failed"** — Verify `MEM0_API_KEY` is set in your shell: `echo $MEM0_API_KEY`. If empty, add it to your shell profile (see Prerequisites)
-- **No tools appearing** — Restart your Claude Code session after installation
-- **Memories not being captured** — Ensure you installed via the plugin marketplace (Option A) for lifecycle hooks. MCP-only installs require manual memory operations
-- **"Mem0 Inactive" banner every session** — Your API key isn't persisting. Add `export MEM0_API_KEY="m0-..."` to your `~/.zshrc` (or `~/.bashrc`) and run `source ~/.zshrc`
+- **"Connection failed"**: Verify `MEM0_API_KEY` is set in your shell: `echo $MEM0_API_KEY`. If empty, add it to your shell profile (see Prerequisites)
+- **No tools appearing**: Restart your Claude Code session after installation
+- **Memories not being captured**: Ensure you installed via the plugin marketplace (Option A) for lifecycle hooks. MCP-only installs require manual memory operations
+- **"Mem0 Inactive" banner every session**: Your API key isn't persisting. Add `export MEM0_API_KEY="m0-..."` to your `~/.zshrc` (or `~/.bashrc`) and run `source ~/.zshrc`
 
 <CardGroup cols={2}>
   <Card title="Mem0 MCP Setup" icon="puzzle-piece" href="/platform/mem0-mcp">

docs/integrations/codex.mdx

@@ -1,9 +1,9 @@
 ---
 title: Codex
-description: "Add persistent memory to OpenAI Codex with the Mem0 plugin — MCP server, lifecycle hooks, and SDK skill."
+description: "Add persistent memory to OpenAI Codex with the Mem0 plugin: MCP server, lifecycle hooks, and SDK skill."
 ---
 
-Add persistent memory to [**OpenAI Codex**](https://openai.com/index/codex/) with the Mem0 plugin. Codex forgets everything between tasks — this plugin fixes that by connecting to Mem0's cloud memory layer via MCP, automatically capturing learnings at key lifecycle points, and retrieving relevant context before every response.
+Add persistent memory to [**OpenAI Codex**](https://openai.com/index/codex/) with the Mem0 plugin. Codex forgets everything between tasks. This plugin fixes that by connecting to Mem0's cloud memory layer via MCP, automatically capturing learnings at key lifecycle points, and retrieving relevant context before every response.
 
 ## Prerequisites
 
@@ -31,7 +31,7 @@ source ~/.bashrc
 
 ## Installation
 
-### Option A — Plugin Marketplace (Recommended)
+### Option A: Plugin Marketplace (Recommended)
 
 Install the full plugin including MCP server, lifecycle hooks, and SDK skill.
 
@@ -50,16 +50,16 @@ Install the full plugin including MCP server, lifecycle hooks, and SDK skill.
    Or, in the app: restart Codex, open the Plugin Directory, browse the **Mem0 Plugins** marketplace, and install **Mem0**.
 
 <Note>
-  Step 1 is required for the app UI. Mem0 isn't in OpenAI's curated directory yet, so **without `codex plugin marketplace add`, Mem0 won't appear in the Codex app's Plugin Directory** — searching for it returns nothing. Adding the marketplace surfaces it (under **Created by you**) and makes it installable.
+  Step 1 is required for the app UI. Mem0 isn't in OpenAI's curated directory yet, so **without `codex plugin marketplace add`, Mem0 won't appear in the Codex app's Plugin Directory**: searching for it returns nothing. Adding the marketplace surfaces it (under **Created by you**) and makes it installable.
 </Note>
 
 <Info>
   Do not combine with Option B. The plugin manifest auto-registers the `mem0` MCP server, so adding both will create a duplicate registration.
 </Info>
 
-### Option B — Direct MCP
+### Option B: Direct MCP
 
-The fastest way to connect Codex to Mem0 — no plugin, no marketplace. Add the MCP server with a single command:
+The fastest way to connect Codex to Mem0 needs no plugin or marketplace. Add the MCP server with a single command:
 
 ```bash
 codex mcp add mem0 --url https://mcp.mem0.ai/mcp/ --bearer-token-env-var MEM0_API_KEY
@@ -123,7 +123,7 @@ When installed via the plugin marketplace, Mem0 hooks into Codex's lifecycle to
 |------|-------|-------------|
 | **Session start** | `SessionStart` | Loads prior memories and displays status banner |
 | **User prompt** | `UserPromptSubmit` | Searches relevant memories before each message |
-| **Pre-tool** | `PreToolUse` | Blocks MEMORY.md writes, enforces `user_id`/`app_id` on mem0 tool calls |
+| **Pre-tool (3 handlers)** | `PreToolUse` | Blocks MEMORY.md writes; enforces `user_id`/`app_id` on mem0 tool calls; scans files being read for relevant memory context |
 | **Post-tool** | `PostToolUse` | Tracks stats, scans bash errors for related memories |
 | **Stop** | `Stop` | Stores a session summary when the session ends |
 | **Pre-compact** | `PreCompact` | Stores a summary before the context is compacted |
@@ -149,10 +149,10 @@ You: Add WebSocket support for real-time notification delivery.
 
 ## Troubleshooting
 
-- **"Connection failed"** — Verify `MEM0_API_KEY` is set: `echo $MEM0_API_KEY`
-- **No tools appearing** — Restart your Codex session after installation
-- **Duplicate `mem0` MCP / "tool collision" errors** — You combined Option A with Option B. Remove the `[mcp_servers.mem0]` block from `~/.codex/config.toml`; the plugin registers it automatically
-- **Hooks not firing** — Ensure the plugin is installed via the marketplace (Option A). MCP-only installs do not include hooks
+- **"Connection failed"**: Verify `MEM0_API_KEY` is set: `echo $MEM0_API_KEY`
+- **No tools appearing**: Restart your Codex session after installation
+- **Duplicate `mem0` MCP / "tool collision" errors**: You combined Option A with Option B. Remove the `[mcp_servers.mem0]` block from `~/.codex/config.toml`; the plugin registers it automatically
+- **Hooks not firing**: Ensure the plugin is installed via the marketplace (Option A). MCP-only installs do not include hooks
 
 <CardGroup cols={2}>
   <Card title="Mem0 MCP Setup" icon="puzzle-piece" href="/platform/mem0-mcp">

docs/integrations/cursor.mdx

@@ -1,9 +1,9 @@
 ---
 title: Cursor
-description: "Add persistent memory to Cursor with the Mem0 plugin — MCP server, lifecycle hooks, and SDK skill for context-aware coding."
+description: "Add persistent memory to Cursor with the Mem0 MCP server for context-aware coding."
 ---
 
-Add persistent memory to [**Cursor**](https://cursor.com) with the Mem0 plugin. Your AI assistant forgets everything between sessions — this plugin fixes that by connecting to Mem0's cloud memory layer via MCP, automatically capturing learnings at key lifecycle points, and retrieving relevant context before every response.
+Add persistent memory to [**Cursor**](https://cursor.com) with the Mem0 MCP server. Your AI assistant forgets everything between sessions. Mem0 fixes that by connecting Cursor to Mem0's cloud memory layer via MCP so you can save and retrieve relevant context during coding sessions.
 
 ## Prerequisites
 
@@ -35,13 +35,13 @@ source ~/.bashrc
 
 ## Installation
 
-### Option A — One-Click Deeplink (MCP Only)
+### Option A: One-Click Deeplink (MCP Only)
 
 The fastest way to get started. Click the link below to install the Mem0 MCP server directly in Cursor:
 
 [Install Mem0 MCP in Cursor](cursor://anysphere.cursor-deeplink/mcp/install?name=mem0&config=eyJtY3BTZXJ2ZXJzIjp7Im1lbTAiOnsidXJsIjoiaHR0cHM6Ly9tY3AubWVtMC5haS9tY3AvIiwiaGVhZGVycyI6eyJBdXRob3JpemF0aW9uIjoiVG9rZW4gJHtlbnY6TUVNMF9BUElfS0VZfSJ9fX19)
 
-### Option B — npx (MCP Only)
+### Option B: npx (MCP Only)
 
 ```bash
 npx mcp-add \
@@ -51,7 +51,7 @@ npx mcp-add \
   --clients "cursor"
 ```
 
-### Option C — Manual Configuration (MCP Only)
+### Option C: Manual Configuration (MCP Only)
 
 Add the following to your `.cursor/mcp.json`:
 
@@ -68,21 +68,10 @@ Add the following to your `.cursor/mcp.json`:
 }
 ```
 
-### Option D — Cursor Marketplace (Full Plugin)
-
-Install from the [Cursor Marketplace](https://cursor.com/marketplace) for the complete experience including lifecycle hooks, the Mem0 SDK skill, and automatic memory capture.
-
 <Info icon="check">
   Start a new Cursor session and ask: *"List my mem0 entities"* or *"Search my memories for hello"*. If the `mem0` tools appear and respond, you're all set.
 </Info>
 
-## What's Included
-
-| Component | Marketplace Install | Deeplink / Manual / npx |
-|-----------|:-------------------:|:-----------------------:|
-| MCP Server (9 memory tools) | Yes | Yes |
-| Lifecycle Hooks | Yes | No |
-| Mem0 SDK Skill | Yes | No |
 
 ## Available MCP Tools
 
@@ -100,19 +89,6 @@ Once installed, the following tools are available in every Cursor session:
 | `delete_entities` | Delete a user/agent/app/run entity and its memories |
 | `list_entities` | List users/agents/apps/runs stored in Mem0 |
 
-## Lifecycle Hooks (Marketplace Install)
-
-When installed via the Cursor Marketplace, Mem0 hooks into Cursor's lifecycle:
-
-| Hook | Event | What it does |
-|------|-------|-------------|
-| **Session start** | `sessionStart` | Loads prior memories and displays status banner |
-| **User prompt** | `beforeSubmitPrompt` | Searches relevant memories before each message; skips short prompts |
-| **Pre-tool (2 handlers)** | `preToolUse` | Blocks MEMORY.md writes, enforces `user_id`/`app_id` on mem0 tool calls |
-| **Post-tool (2 handlers)** | `postToolUse` | Tracks stats, scans bash errors for related memories |
-| **Stop** | `stop` | Stores a session summary when the session ends |
-| **Pre-compact** | `preCompact` | Stores a summary before the context is compacted |
-
 ## Example Workflow
 
 ```text
@@ -121,7 +97,7 @@ You: The API endpoint /users is taking 3 seconds. Help me optimize it.
 
 # Cursor agent searches memories, proceeds with investigation.
 # After completing the task, Mem0 stores:
-#   - Learning: "N+1 query in UserService.getAll() — fixed with eager loading"
+#   - Learning: "N+1 query in UserService.getAll(): fixed with eager loading"
 #   - Decision: "Added database index on users.email column"
 #   - Preference: "User prefers query-level fixes over caching"
 
@@ -134,10 +110,9 @@ You: The /orders endpoint is also slow, same pattern as before.
 
 ## Troubleshooting
 
-- **"Connection failed"** — Verify `MEM0_API_KEY` is set: `echo $MEM0_API_KEY`
-- **Duplicate tools** — If you had a previous MCP config for `mem0`, remove it before installing the plugin
-- **No tools appearing** — Go to Cursor Settings > MCP and verify the `mem0` server shows as connected
-- **Hooks not running** — Hooks require the Marketplace install (Option D). Deeplink/manual installs only provide MCP tools.
+- **"Connection failed"**: Verify `MEM0_API_KEY` is set: `echo $MEM0_API_KEY`
+- **Duplicate tools**: If you had a previous MCP config for `mem0`, remove it before installing the plugin
+- **No tools appearing**: Go to Cursor Settings > MCP and verify the `mem0` server shows as connected
 
 <CardGroup cols={2}>
   <Card title="Mem0 MCP Setup" icon="puzzle-piece" href="/platform/mem0-mcp">

docs/integrations/dify.mdx

@@ -21,7 +21,7 @@ Mem0 brings a robust memory layer to Dify AI, empowering your AI agents with per
    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.
+   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.

docs/integrations/google-ai-adk.mdx

@@ -215,7 +215,7 @@ if __name__ == "__main__":
 
 ## Multi-Agent Hierarchy with Shared Memory
 
-Because `memory_service` is passed to the `Runner`, every agent in the hierarchy shares the same memory automatically. Only the root coordinator needs the auto-save callback — ADK fires it once when the full turn completes:
+Because `memory_service` is passed to the `Runner`, every agent in the hierarchy shares the same memory automatically. Only the root coordinator needs the auto-save callback: ADK fires it once when the full turn completes:
 
 ```python
 import asyncio
@@ -295,11 +295,11 @@ if __name__ == "__main__":
 
 ## Key Features
 
-1. **Automatic Memory Injection**: ADK's built-in `load_memory` tool searches Mem0 at the start of each turn and injects relevant memories directly into the agent context — no prompt instructions needed.
+1. **Automatic Memory Injection**: ADK's built-in `load_memory` tool searches Mem0 at the start of each turn and injects relevant memories directly into the agent context. No prompt instructions are needed.
 2. **Automatic Session Saving**: The `save_session_to_memory` callback persists every completed turn to Mem0 without any manual calls.
-3. **Native ADK Integration**: `Mem0MemoryService` implements ADK's `BaseMemoryService` and integrates via the `Runner` — works natively across the entire agent hierarchy.
+3. **Native ADK Integration**: `Mem0MemoryService` implements ADK's `BaseMemoryService` and integrates via the `Runner`. It works natively across the entire agent hierarchy.
 4. **User Scoping**: `user_id` is passed automatically from the ADK session context, ensuring memories are always scoped to the correct user.
-5. **Multi-Agent Support**: A single `Mem0MemoryService` instance shared through the `Runner` gives all agents — coordinators and specialists — access to the same user memory.
+5. **Multi-Agent Support**: A single `Mem0MemoryService` instance shared through the `Runner` gives all agents, coordinators and specialists, access to the same user memory.
 
 ## Configuration Options
 

docs/integrations/langchain-tools.mdx

@@ -98,20 +98,9 @@ add_result = add_tool.invoke(add_input)
 
 ```json Output
 {
-  "results": [
-    {
-      "memory": "Name is Alex",
-      "event": "ADD"
-    },
-    {
-      "memory": "Is a vegetarian", 
-      "event": "ADD"
-    },
-    {
-      "memory": "Is allergic to nuts",
-      "event": "ADD"
-    }
-  ]
+  "message": "Memory processing has been queued for background execution",
+  "status": "PENDING",
+  "event_id": "3a1b2c3d-4e5f-6789-abcd-ef0123456789"
 }
 ```
 </CodeGroup>
@@ -173,23 +162,25 @@ result = search_tool.invoke(search_input)
 ```
 
 ```json Output
-[
-  {
-    "id": "1a75e827-7eca-45ea-8c5c-cfd43299f061",
-    "memory": "Name is Alex",
-    "user_id": "alex", 
-    "hash": "d0fccc8fa47f7a149ee95750c37bb0ca",
-    "metadata": {
-      "food": "vegan"
-    },
-    "categories": [
-      "personal_details"
-    ],
-    "created_at": "2024-11-27T16:53:43.276872-08:00",
-    "updated_at": "2024-11-27T16:53:43.276885-08:00",
-    "score": 0.3810526501504994
-  }
-]
+{
+  "results": [
+    {
+      "id": "1a75e827-7eca-45ea-8c5c-cfd43299f061",
+      "memory": "Name is Alex",
+      "user_id": "alex",
+      "hash": "d0fccc8fa47f7a149ee95750c37bb0ca",
+      "metadata": {
+        "food": "vegan"
+      },
+      "categories": [
+        "personal_details"
+      ],
+      "created_at": "2024-11-27T16:53:43.276872-08:00",
+      "updated_at": "2024-11-27T16:53:43.276885-08:00",
+      "score": 0.3810526501504994
+    }
+  ]
+}
 ```
 </CodeGroup>
 

docs/integrations/langgraph.mdx

@@ -41,7 +41,7 @@ load_dotenv()
 # MEM0_API_KEY = 'your-mem0-key'  # Replace with your actual Mem0 API key
 
 # Initialize LangChain and Mem0
-llm = ChatOpenAI(model="gpt-4")
+llm = ChatOpenAI(model="gpt-5-mini")
 mem0 = MemoryClient()
 ```
 

docs/integrations/openclaw.mdx

@@ -3,7 +3,7 @@ title: OpenClaw
 description: "Add long-term memory to OpenClaw agents using the Mem0 plugin with skills-based memory extraction and recall."
 ---
 
-Add long-term memory to [OpenClaw](https://github.com/openclaw/openclaw) agents with the `@mem0/openclaw-mem0` plugin. Your agent forgets everything between sessions — this plugin fixes that by automatically watching conversations, extracting what matters, and bringing it back when relevant.
+Add long-term memory to [OpenClaw](https://github.com/openclaw/openclaw) agents with the `@mem0/openclaw-mem0` plugin. Your agent forgets everything between sessions. This plugin fixes that by automatically watching conversations, extracting what matters, and bringing it back when relevant.
 
 ## Overview
 
@@ -12,10 +12,10 @@ Add long-term memory to [OpenClaw](https://github.com/openclaw/openclaw) agents
 </Frame>
 
 The plugin provides:
-1. **Triage** — The agent extracts durable facts from conversations using a structured protocol with importance gates and domain overlays
-2. **Recall** — Before each turn, relevant memories are retrieved with reranking and injected into context
-3. **Dream** — Periodic memory consolidation: merges duplicates, resolves conflicts, prunes stale entries
-4. **Agent Tools** — Eight tools for explicit memory operations during conversations
+1. **Triage**: The agent extracts durable facts from conversations using a structured protocol with importance gates and domain overlays
+2. **Recall**: Before each turn, relevant memories are retrieved with reranking and injected into context
+3. **Dream**: Periodic memory consolidation merges duplicates, resolves conflicts, prunes stale entries
+4. **Agent Tools**: Eight tools for explicit memory operations during conversations
 
 Skills mode, `autoRecall`, and `autoCapture` are all enabled by default during `openclaw mem0 init`.
 
@@ -50,7 +50,7 @@ If you prefer the OpenClaw CLI, or are setting up self-hosted / open-source mode
 
 ### Understanding `userId`
 
-The `userId` field is a **string you choose** to uniquely identify the user whose memories are being stored. It is **not** something you look up in the Mem0 dashboard — you define it yourself.
+The `userId` field is a **string you choose** to uniquely identify the user whose memories are being stored. It is **not** something you look up in the Mem0 dashboard: you define it yourself.
 
 Pick any stable, unique identifier for the user. Common choices:
 
@@ -58,7 +58,7 @@ 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 your OS username.
+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>
 
@@ -66,8 +66,8 @@ All memories are scoped to this `userId` — different values create separate me
 
 There are two ways to set up `@mem0/openclaw-mem0` on the Mem0 platform:
 
-- **Chat setup (recommended)** — run the setup inside any OpenClaw chat. No config editing, no API key handling.
-- **Manual config** — edit `openclaw.json` directly.
+- **Chat setup (recommended)**: run the setup inside any OpenClaw chat. No config editing, no API key handling.
+- **Manual config**: edit `openclaw.json` directly.
 
 #### Option 1: Chat Setup (Recommended)
 
@@ -75,7 +75,7 @@ You no longer need manual config editing to get started. Everything happens insi
 
 <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:
+    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
@@ -103,7 +103,7 @@ You no longer need manual config editing to get started. Everything happens insi
 
 That's it. No API key, no config file editing, no environment variables. The plugin is now active with skills-based memory (triage, recall, and dream) running automatically.
 
-<Note>The chat flow uses the same underlying config as manual setup — it writes `apiKey`, `userId`, and `skills` config into `openclaw.json` for you. You can still open the file to inspect or override values afterward.</Note>
+<Note>The chat flow uses the same underlying config as manual setup: it writes `apiKey`, `userId`, and `skills` config into `openclaw.json` for you. You can still open the file to inspect or override values afterward.</Note>
 
 #### Option 2: Manual Config
 
@@ -155,12 +155,12 @@ That's it. No API key, no config file editing, no environment variables. The plu
 </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.
+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. Defaults use OpenAI (`gpt-5-mini` for LLM, `text-embedding-3-small` for embeddings) — requires `OPENAI_API_KEY`. For a fully local setup, use Ollama for both.
+No Mem0 key is needed. Defaults use OpenAI (`gpt-5-mini` for LLM, `text-embedding-3-small` for embeddings), so `OPENAI_API_KEY` is required. For a fully local setup, use Ollama for both.
 
 #### Option 1: Interactive Wizard (Recommended)
 
@@ -189,7 +189,7 @@ The wizard walks you through:
 
 #### Option 2: Non-Interactive Setup
 
-For CI/CD, scripts, or agent-driven setup — pass all options as flags:
+For CI/CD, scripts, or agent-driven setup: pass all options as flags:
 
 ```bash
 # Fully local with Ollama + Qdrant
@@ -234,7 +234,7 @@ Add `--json` for machine-readable output (useful when an LLM agent is driving th
 
 #### Option 3: Manual Config
 
-Minimal config — uses OpenAI defaults:
+Minimal config: uses OpenAI defaults:
 
 ```json5
 {
@@ -287,11 +287,11 @@ All `oss` fields are optional. See [Mem0 OSS docs](/open-source/node-quickstart)
 
 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.
+- **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_add` 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.
+During **auto-recall**, the plugin searches both scopes and presents them separately, with long-term memories first and session memories second. This means the agent has full context.
 
 ## Agent Tools
 
@@ -312,7 +312,7 @@ The `memory_search` and `memory_list` tools accept a `scope` parameter (`"sessio
 
 ## CLI Commands
 
-All commands support `--json` for machine-readable output — useful when an LLM agent drives the CLI programmatically. Run `openclaw mem0 help --json` to discover every command and flag.
+All commands support `--json` for machine-readable output. Use it when an LLM agent drives the CLI programmatically. Run `openclaw mem0 help --json` to discover every command and flag.
 
 ```bash
 # Search all memories (long-term + session)
@@ -350,8 +350,8 @@ openclaw mem0 status --json
 
 | Key | Type | Default | Description |
 |-----|------|---------|-------------|
-| `apiKey` | `string` | — | **Required.** Mem0 API key (supports `${MEM0_API_KEY}`) |
-| `customInstructions` | `string` | *(built-in)* | Extraction rules — what to store, how to format |
+| `apiKey` | `string` | N/A | **Required.** Mem0 API key (supports `${MEM0_API_KEY}`) |
+| `customInstructions` | `string` | *(built-in)* | Extraction rules: what to store, how to format |
 | `customCategories` | `object` | *(12 defaults)* | Category name → description map for tagging |
 
 ### Open-Source Mode Options
@@ -360,15 +360,15 @@ openclaw mem0 status --json
 |-----|------|---------|-------------|
 | `customInstructions` | `string` | *(built-in)* | Extraction prompt for memory processing |
 | `oss.embedder.provider` | `string` | `"openai"` | Embedding provider (`"openai"`, `"ollama"`, etc.) |
-| `oss.embedder.config` | `object` | — | Provider config: `apiKey`, `model`, `baseURL` |
+| `oss.embedder.config` | `object` | N/A | Provider config: `apiKey`, `model`, `baseURL` |
 | `oss.vectorStore.provider` | `string` | `"memory"` | Vector store (`"memory"`, `"qdrant"`, `"chroma"`, etc.) |
-| `oss.vectorStore.config` | `object` | — | Provider config: `host`, `port`, `collectionName`, `dimension` |
+| `oss.vectorStore.config` | `object` | N/A | Provider config: `host`, `port`, `collectionName`, `dimension` |
 | `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.llm.config` | `object` | N/A | Provider config: `apiKey`, `model`, `baseURL`, `temperature` |
+| `oss.historyDbPath` | `string` | N/A | 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 (`gpt-5-mini`).
+Everything inside `oss` is optional: defaults use OpenAI embeddings (`text-embedding-3-small`), in-memory vector store, and OpenAI LLM (`gpt-5-mini`).
 
 ## Plugin Management
 
@@ -466,11 +466,11 @@ The agent can always use memory tools (`memory_add`, `memory_search`, etc.) expl
 
 The plugin never stores API keys, tokens, or secrets as memories. Five independent layers enforce this:
 
-1. **Triage gate** — The extraction prompt rejects values matching known credential patterns (`sk-`, `m0-`, `ghp_`, `AKIA`, `Bearer`, `password=`, `token=`, `secret=`)
-2. **Dream cleanup** — Periodic memory consolidation deletes any memories that slipped through containing credential patterns
-3. **Extraction instructions** — Default extraction rules explicitly instruct the model to store only that a credential was configured, never the value
-4. **Configurable patterns** — Add custom credential patterns via `skills.triage.credentialPatterns`
-5. **CLI redaction** — `openclaw mem0 config show` redacts sensitive fields (`apiKey`, `oss.*.config.apiKey`)
+1. **Triage gate**: The extraction prompt rejects values matching known credential patterns (`sk-`, `m0-`, `ghp_`, `AKIA`, `Bearer`, `password=`, `token=`, `secret=`)
+2. **Dream cleanup**: Periodic memory consolidation deletes any memories that slipped through containing credential patterns
+3. **Extraction instructions**: Default extraction rules explicitly instruct the model to store only that a credential was configured, never the value
+4. **Configurable patterns**: Add custom credential patterns via `skills.triage.credentialPatterns`
+5. **CLI redaction**: `openclaw mem0 config show` redacts sensitive fields (`apiKey`, `oss.*.config.apiKey`)
 
 ### API Key Storage
 
@@ -478,7 +478,7 @@ Plugin config is stored in `~/.openclaw/openclaw.json` with file permissions `0o
 
 ### Telemetry
 
-Anonymous usage telemetry (PostHog) is enabled by default to help improve the plugin. No conversation content or memory values are included — only event counts (recall, capture, tool usage, CLI commands).
+Anonymous usage telemetry (PostHog) is enabled by default to help improve the plugin. No conversation content or memory values are included, only event counts (recall, capture, tool usage, CLI commands).
 
 To opt out, set the environment variable:
 
@@ -488,7 +488,7 @@ export MEM0_TELEMETRY=false
 
 ### System Prompt Context
 
-The plugin injects memory-related instructions into the agent's system context via OpenClaw's `prependSystemContext` mechanism. This includes the memory triage protocol and recalled memories. This is the standard OpenClaw plugin SDK pattern for memory backends — no user-facing prompts are modified.
+The plugin injects memory-related instructions into the agent's system context via OpenClaw's `prependSystemContext` mechanism. This includes the memory triage protocol and recalled memories. This is the standard OpenClaw plugin SDK pattern for memory backends. No user-facing prompts are modified.
 
 <CardGroup cols={2}>
   <Card title="OpenAI Agents SDK" icon="robot" href="/integrations/openai-agents-sdk">

docs/integrations/opencode.mdx

@@ -1,9 +1,9 @@
 ---
 title: OpenCode
-description: "Add persistent memory to OpenCode with the Mem0 plugin — native SDK-backed memory tools, lifecycle hooks, and skills."
+description: "Add persistent memory to OpenCode with the Mem0 plugin: native SDK-backed memory tools, lifecycle hooks, and skills."
 ---
 
-Add persistent memory to [**OpenCode**](https://opencode.ai) with the Mem0 plugin. Your agent forgets everything between sessions — Mem0 fixes that by storing decisions, preferences, and learnings so they carry over automatically.
+Add persistent memory to [**OpenCode**](https://opencode.ai) with the Mem0 plugin. Your agent forgets everything between sessions. Mem0 fixes that by storing decisions, preferences, and learnings so they carry over automatically.
 
 ## Prerequisites
 
@@ -24,21 +24,21 @@ echo 'export MEM0_API_KEY="m0-your-api-key"' >> ~/.bashrc && source ~/.bashrc
 
 ## Installation
 
-### Option A — Plugin Install (Recommended)
+### Option A: Plugin Install (Recommended)
 
 ```bash
 opencode plugin @mem0/opencode-plugin
 ```
 
-**Or let your agent do it** — paste this into OpenCode:
+**Or let your agent do it**: paste this into OpenCode:
 
 ```
 Install @mem0/opencode-plugin by following https://raw.githubusercontent.com/mem0ai/mem0/main/integrations/mem0-plugin/.opencode-plugin/README.md
 ```
 
-This adds the plugin to your `~/.config/opencode/opencode.json`. Restart OpenCode — you get the native memory tools, lifecycle hooks, and all `/mem0-*` slash commands. The memory tools are registered by the plugin itself via the `mem0ai` SDK — no MCP server to configure.
+This adds the plugin to your `~/.config/opencode/opencode.json`. Restart OpenCode. You get the native memory tools, lifecycle hooks, and all `/mem0-*` slash commands. The memory tools are registered by the plugin itself via the `mem0ai` SDK. No MCP server to configure.
 
-### Option B — Standalone MCP Server
+### Option B: Standalone MCP Server
 
 If you only need the memory tools without the plugin's hooks or skills, point OpenCode at Mem0's hosted MCP server directly. Add this to your `opencode.json` (project-level or global at `~/.config/opencode/opencode.json`):
 
@@ -89,7 +89,7 @@ If you only need the memory tools without the plugin's hooks or skills, point Op
 | `session` | this run only (`+ run_id`) | this run |
 | `global` | **all your projects in the workspace** (`app_id: "*"`) | user-wide |
 
-Just ask naturally — e.g. *"search my memories across all my projects"* — and the agent passes `scope: "global"`. For normal questions it stays scoped to the current project automatically.
+Ask naturally, for example, *"search my memories across all my projects"*. The agent passes `scope: "global"`. For normal questions it stays scoped to the current project automatically.
 
 To change the **default** scope (used when no scope is passed), run the `/mem0-scope` skill:
 
@@ -99,13 +99,13 @@ To change the **default** scope (used when no scope is passed), run the `/mem0-s
 /mem0-scope project    # back to repo-only (the default)
 ```
 
-The default persists in `~/.mem0/settings.json` (`default_scope`) and is read fresh on each memory operation, so a change applies immediately — no restart. `delete_all_memories` always requires an explicit `scope: "global"` to delete user-wide, so changing the default can't trigger a cross-project wipe.
+The default persists in `~/.mem0/settings.json` (`default_scope`) and is read fresh on each memory operation, so a change applies immediately. No restart. `delete_all_memories` always requires an explicit `scope: "global"` to delete user-wide, so changing the default can't trigger a cross-project wipe.
 
 The project id (`app_id`) is derived from your git remote (`owner-repo`), falling back to the git repo's root directory name, then the current directory. Launch OpenCode from inside your repo so memories scope to the project rather than your home directory.
 
 ## Lifecycle Hooks
 
-The plugin uses the [mem0ai](https://www.npmjs.com/package/mem0ai) TypeScript SDK directly — pure TypeScript, no Python, no shell scripts.
+The plugin uses the [mem0ai](https://www.npmjs.com/package/mem0ai) TypeScript SDK directly. It is pure TypeScript, no Python, no shell scripts.
 
 | OpenCode Event | Hook | What happens |
 |----------------|------|-------------|
@@ -119,11 +119,11 @@ The plugin uses the [mem0ai](https://www.npmjs.com/package/mem0ai) TypeScript SD
 
 ## Auto-dream (memory consolidation)
 
-The plugin can automatically consolidate stored memories — merging duplicates, dropping stale/sensitive entries, and rewriting vague ones — so your memory set stays clean over time. It runs at most once per session, and only when **all** gates pass:
+The plugin can automatically consolidate stored memories by merging duplicates, dropping stale/sensitive entries, and rewriting vague ones. This keeps your memory set clean over time. It runs at most once per session, and only when **all** gates pass:
 
-- **Time** — at least `minHours` (default 24) since the last consolidation
-- **Sessions** — at least `minSessions` (default 5) sessions since then
-- **Memories** — at least `minMemories` (default 20) stored for the project
+- **Time**: at least `minHours` (default 24) since the last consolidation
+- **Sessions**: at least `minSessions` (default 5) sessions since then
+- **Memories**: at least `minMemories` (default 20) stored for the project
 
 A filesystem lock (`~/.mem0/mem0-dream.lock`) keeps two sessions from consolidating at once. Tune the thresholds with a `dream` block in `~/.mem0/settings.json`, or disable entirely with `MEM0_DREAM=false`:
 
@@ -137,12 +137,12 @@ If auto-dream hasn't run yet, it's almost always because a gate hasn't been met
 
 ## Troubleshooting
 
-- **No tools appearing** — Restart OpenCode after installing
-- **"Connection failed"** — Verify your key is set: `echo $MEM0_API_KEY`
-- **Plugin not loading** — Run `opencode plugin @mem0/opencode-plugin` again, then restart
-- **Hooks not firing** — Hooks require the plugin install (Option A). MCP-only installs don't include hooks.
-- **Auto-dream never runs** — It's gated (time + sessions + memories). Run `/mem0-status` to see which gate is blocking, or `/mem0-dream` to consolidate now.
-- **Wrong project name / memories not found** — The project id comes from your git remote; launch OpenCode from inside the repo (not your home directory). Check the resolved id with `/mem0-status`.
+- **No tools appearing**: Restart OpenCode after installing
+- **"Connection failed"**: Verify your key is set: `echo $MEM0_API_KEY`
+- **Plugin not loading**: Run `opencode plugin @mem0/opencode-plugin` again, then restart
+- **Hooks not firing**: Hooks require the plugin install (Option A). MCP-only installs don't include hooks.
+- **Auto-dream never runs**: It's gated (time + sessions + memories). Run `/mem0-status` to see which gate is blocking, or `/mem0-dream` to consolidate now.
+- **Wrong project name / memories not found**: The project id comes from your git remote; launch OpenCode from inside the repo (not your home directory). Check the resolved id with `/mem0-status`.
 
 <CardGroup cols={2}>
   <Card title="Mem0 MCP Setup" icon="puzzle-piece" href="/platform/mem0-mcp">

docs/integrations/pi-agent.mdx

@@ -3,17 +3,17 @@ title: Pi Agent
 description: "Add persistent memory to Pi Agent with the Mem0 plugin semantic search, auto-capture, and dream consolidation."
 ---
 
-Add persistent memory to [**Pi Agent**](https://pi.dev) with `@mem0/pi-agent-plugin`. Your agent forgets everything between sessions — this plugin fixes that by automatically capturing knowledge from conversations, storing it in Mem0's cloud memory layer, and retrieving relevant context before every response.
+Add persistent memory to [**Pi Agent**](https://pi.dev) with `@mem0/pi-agent-plugin`. Your agent forgets everything between sessions. This plugin fixes that by automatically capturing knowledge from conversations, storing it in Mem0's cloud memory layer, and retrieving relevant context before every response.
 
 ## Overview
 
 The plugin provides:
-1. **Auto-capture** — Extracts durable facts from both user and assistant messages automatically
-2. **Semantic recall** — Retrieves relevant memories via the `mem0_memory` tool before each response
-3. **Dream consolidation** — Periodic maintenance: merges duplicates, resolves contradictions, prunes stale entries
-4. **Monorepo-aware scoping** — Uses git root for project detection, consistent across subdirectories
-5. **Confirmation dialogs** — Destructive commands ask before acting via Pi's built-in UI
-6. **8 skills + 8 commands** — Essential memory management from slash commands and agent-guided workflows
+1. **Auto-capture**: Extracts durable facts from both user and assistant messages automatically
+2. **Semantic recall**: Retrieves relevant memories via the `mem0_memory` tool before each response
+3. **Dream consolidation**: Periodic maintenance: merges duplicates, resolves contradictions, prunes stale entries
+4. **Monorepo-aware scoping**: Uses git root for project detection, consistent across subdirectories
+5. **Confirmation dialogs**: Destructive commands ask before acting via Pi's built-in UI
+6. **8 skills + 8 commands**: Essential memory management from slash commands and agent-guided workflows
 
 ## Prerequisites
 
@@ -43,7 +43,7 @@ source ~/.bashrc
 pi install npm:@mem0/pi-agent-plugin
 ```
 
-That's it. The extension loads automatically on every Pi session. No config files needed — `MEM0_API_KEY` from your environment is picked up automatically.
+That's it. The extension loads automatically on every Pi session. No config files needed: `MEM0_API_KEY` from your environment is picked up automatically.
 
 <Info>
   Start a new Pi session and run `/mem0-status` to verify the connection. You should see your user ID, detected project, and memory count.
@@ -103,9 +103,9 @@ The `mem0_memory` tool is registered with Pi and callable by the agent during co
 |--------|----------------|-------------|
 | `search` | `query` | Semantic search across memories |
 | `add` | `content` | Store a new memory |
-| `get_all` | — | List all memories in scope |
+| `get_all` | N/A | List all memories in scope |
 | `delete` | `memory_id` | Delete a specific memory |
-| `delete_all` | — | Delete all memories in scope |
+| `delete_all` | N/A | Delete all memories in scope |
 
 All actions accept an optional `scope` parameter: `project` (default), `session`, or `global`.
 
@@ -119,7 +119,7 @@ Tool output is truncated to 200 lines / 50KB to prevent context overflow.
 | `/mem0-forget <query>` | Search and delete memories (with confirmation dialog) |
 | `/mem0-search <query>` | Semantic search across memories |
 | `/mem0-tour [scope]` | Browse all memories grouped by category |
-| `/mem0-dream` | Consolidate — merge duplicates, prune stale, resolve contradictions |
+| `/mem0-dream` | Consolidate: merge duplicates, prune stale, resolve contradictions |
 | `/mem0-pin <query>` | Pin a memory to protect from dream pruning (preserves memory ID) |
 | `/mem0-scope <scope>` | Change default scope for this session (project, session, global) |
 | `/mem0-status` | Connection health, identity, and memory count |
@@ -130,7 +130,7 @@ Memories are scoped using Mem0's `user_id`, `app_id`, and `run_id` parameters:
 
 | Scope | Filters | Use Case |
 |-------|---------|----------|
-| `project` | user_id + app_id (git root) | **Default.** Project-specific knowledge — decisions, architecture, config |
+| `project` | user_id + app_id (git root) | **Default.** Project-specific knowledge: decisions, architecture, config |
 | `session` | user_id + app_id + run_id | Ephemeral context for the current session only |
 | `global` | user_id only | All memories across all your projects |
 
@@ -144,11 +144,11 @@ Destructive and mutating commands use Pi's built-in `ctx.ui.confirm()` dialog be
 
 - `/mem0-forget` asks "Delete this memory?" before deleting a single match
 - `/mem0-pin` asks "Pin this memory?" before modifying it
-- Cancelling either operation is always safe — no changes are made
+- Cancelling either operation is always safe. No changes are made
 
 ### Pin
 
-`/mem0-pin` uses Mem0's `update()` API to prepend `[PINNED]` to the memory text. This preserves the original memory ID — no add+delete cycle that would lose history or change the UUID.
+`/mem0-pin` uses Mem0's `update()` API to prepend `[PINNED]` to the memory text. This preserves the original memory ID. There is no add+delete cycle that would lose history or change the UUID.
 
 ### Dream Consolidation
 
@@ -163,16 +163,16 @@ You: I prefer dark mode and concise answers.
 
 # Session 2 (days later)
 You: What do you know about my preferences?
-# Pi retrieves stored memories — no re-explaining needed
+# Pi retrieves stored memories, no re-explaining needed
 ```
 
 ## Troubleshooting
 
-- **"No API key found"** — Verify `MEM0_API_KEY` is set: `echo $MEM0_API_KEY`. If empty, add it to your shell profile (see Prerequisites)
-- **Extension not loading** — Check Pi startup output for errors. Run `pi -e ./src/entry.ts` from the plugin directory for verbose output
-- **Memories not capturing** — Verify `autoCapture` is `true` (default). Check `/mem0-status` for connection health
-- **Wrong project detected** — The plugin uses the git repository root as `app_id`. If not in a git repo, it falls back to the working directory name. Run `/mem0-status` to see the detected project
-- **Dream not triggering** — All three gates must pass (time, sessions, memories). Use `/mem0-dream` to force it manually
+- **"No API key found"**: Verify `MEM0_API_KEY` is set: `echo $MEM0_API_KEY`. If empty, add it to your shell profile (see Prerequisites)
+- **Extension not loading**: Check Pi startup output for errors. Run `pi -e ./src/entry.ts` from the plugin directory for verbose output
+- **Memories not capturing**: Verify `autoCapture` is `true` (default). Check `/mem0-status` for connection health
+- **Wrong project detected**: The plugin uses the git repository root as `app_id`. If not in a git repo, it falls back to the working directory name. Run `/mem0-status` to see the detected project
+- **Dream not triggering**: All three gates must pass (time, sessions, memories). Use `/mem0-dream` to force it manually
 
 <CardGroup cols={2}>
   <Card title="Claude Code Integration" icon="terminal" href="/integrations/claude-code">

docs/integrations/pipecat.mdx

@@ -121,7 +121,7 @@ async def websocket_endpoint(websocket: WebSocket):
     # LLM for response generation
     llm = OpenAILLMService(
         api_key=os.getenv("OPENAI_API_KEY"),
-        model="gpt-3.5-turbo",
+        model="gpt-5-mini",
         system_prompt="You are a helpful assistant that remembers past conversations."
     )
     

docs/integrations/vercel-ai-sdk.mdx

@@ -26,12 +26,12 @@ Install the SDK provider and AI SDK:
 npm install @mem0/vercel-ai-provider ai@^6
 ```
 
-### Peer Dependencies
+### Dependencies
 
-`@mem0/vercel-ai-provider` v3.0.0 requires:
-- `ai` v6+ (`^6.0.199`)
-- `@ai-sdk/provider` v3+ (`^3.0.10`)
-- Provider packages at v3+: `@ai-sdk/openai@^3`, `@ai-sdk/anthropic@^3`, `@ai-sdk/google@^3`, `@ai-sdk/groq@^3`, `@ai-sdk/cohere@^3`
+`@mem0/vercel-ai-provider` bundles `ai`, all `@ai-sdk/*` provider packages, and `@ai-sdk/provider` as regular dependencies: you do **not** need to install them separately. The install command above (`npm install @mem0/vercel-ai-provider ai@^6`) is sufficient.
+
+The only true peer dependency is `zod` (optional):
+- `zod` v3+ (`^3.0.0`): required only if you use Zod schemas in tool definitions
 
 ## Getting Started
 
@@ -205,7 +205,7 @@ const { text, sources } = await generateText({
 });
 
 // sources[0].title === "Mem0 Memories"
-// sources[0].providerMetadata.mem0.memories — array of memory objects
+// sources[0].providerMetadata.mem0.memories: array of memory objects
 console.log(sources);
 ```
 
@@ -305,6 +305,8 @@ These options can be passed per-request when creating a model instance:
 | `rerank` | `boolean` | Enable reranking of results |
 | `page` | `number` | Page number for pagination |
 | `page_size` | `number` | Results per page |
+| `mem0ApiKey` | `string` | Mem0 API key; overrides the `MEM0_API_KEY` env var |
+| `host` | `string` | Custom Mem0 API base URL for self-hosted deployments |
 
 ## Key Features
 
@@ -312,6 +314,7 @@ These options can be passed per-request when creating a model instance:
 - `retrieveMemories()`: Retrieves memory context for prompts as a formatted system prompt string.
 - `getMemories()`: Get memories from your profile in array format.
 - `addMemories()`: Adds user memories to enhance contextual responses.
+- `searchMemories()`: Searches memories and returns the raw results array (semantic search rather than the full retrieval pipeline).
 
 ## Migrating from v2.x
 

docs/introduction.mdx

@@ -177,7 +177,7 @@ mode: "custom"
           Sign up as an agent
         </h3>
         <p className="text-sm text-gray-600 dark:text-zinc-400">
-          For AI agents: mint a Mem0 API key in under five seconds — no email, no dashboard. Four commands to your first memory.
+          For AI agents: mint a Mem0 API key in under five seconds: no email, no dashboard. Four commands to your first memory.
         </p>
       </div>
     </a>

docs/llms.txt

@@ -228,7 +228,6 @@ If the user is on a pre-current major (Python < 2, TS < 3, or Platform `output_f
 - [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.
 - [Server pgvector Image Upgrade](https://docs.mem0.ai/migration/server-pgvector-upgrade) [OSS]: Use when upgrading the self-hosted server Docker image from ankane/pgvector to pgvector/pgvector.
 - [Changelog](https://docs.mem0.ai/changelog/highlights) [Both]: Use when the user asks what shipped recently.
 
@@ -367,6 +366,8 @@ All API Reference docs describe Mem0 Platform REST endpoints (requires API key).
 - [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.
+- [Update Organization Member](https://docs.mem0.ai/api-reference/organization/update-org-member) [Platform]: Use when updating an org member's role.
+- [Remove Organization Member](https://docs.mem0.ai/api-reference/organization/remove-org-member) [Platform]: Use when removing a member from an organization.
 - [Delete Organization](https://docs.mem0.ai/api-reference/organization/delete-org) [Platform]: Use when removing an org.
 
 ### Projects
@@ -375,6 +376,9 @@ All API Reference docs describe Mem0 Platform REST endpoints (requires API key).
 - [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.
+- [Update Project](https://docs.mem0.ai/api-reference/project/update-project) [Platform]: Use when updating project settings.
+- [Update Project Member](https://docs.mem0.ai/api-reference/project/update-project-member) [Platform]: Use when updating a project member's role.
+- [Remove Project Member](https://docs.mem0.ai/api-reference/project/remove-project-member) [Platform]: Use when removing a member from a project.
 - [Delete Project](https://docs.mem0.ai/api-reference/project/delete-project) [Platform]: Use when removing a project.
 
 ### Webhooks
@@ -460,6 +464,7 @@ Everything below is OSS-only provider configuration. Skip this entire section wh
 - [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.
+- [FastEmbed](https://docs.mem0.ai/components/embedders/models/fastembed) [OSS]: Use when embeddings run locally via FastEmbed (ONNX).
 
 ### Vector Databases [OSS]
 - [Vector Database Overview](https://docs.mem0.ai/components/vectordbs/overview) [OSS]: Use when choosing a vector store.
@@ -498,7 +503,5 @@ Everything below is OSS-only provider configuration. Skip this entire section wh
 - [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).
+- [Hugging Face Reranker](https://docs.mem0.ai/components/rerankers/models/huggingface) [OSS]: Use for HF-hosted reranker models.- [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.