fix(openclaw): clear security scanner exfiltration warning (#4678)

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Co-authored-by: Saket Aryan <saketaryan2002@gmail.com>

.agents/plugins/marketplace.json

@@ -0,0 +1,20 @@
+{
+  "name": "mem0-plugins",
+  "interface": {
+    "displayName": "Mem0 Plugins"
+  },
+  "plugins": [
+    {
+      "name": "mem0",
+      "source": {
+        "source": "local",
+        "path": "./mem0-plugin"
+      },
+      "policy": {
+        "installation": "AVAILABLE",
+        "authentication": "ON_INSTALL"
+      },
+      "category": "Productivity"
+    }
+  ]
+}

.github/workflows/cd.yml

@@ -7,6 +7,7 @@ on:
 jobs:
   build-n-publish:
     name: Build and publish Python 🐍 distributions 📦 to PyPI and TestPyPI
+    if: startsWith(github.event.release.tag_name, 'v')
     runs-on: ubuntu-latest
     permissions:
       id-token: write

.github/workflows/cli-node-cd.yml

@@ -0,0 +1,43 @@
+name: Publish @mem0/cli 📦 to npm
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build-n-publish:
+    name: Build and publish @mem0/cli 📦 to npm
+    if: startsWith(github.event.release.tag_name, 'cli-node-v')
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    defaults:
+      run:
+        working-directory: cli/node
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          registry-url: 'https://registry.npmjs.org'
+          cache: 'pnpm'
+          cache-dependency-path: cli/node/pnpm-lock.yaml
+
+      - name: Upgrade npm for OIDC trusted publishing
+        run: npm install -g npm@latest
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build
+        run: pnpm run build
+
+      - name: Publish to npm
+        run: npm publish --provenance --access public

.github/workflows/openclaw-cd.yml

@@ -0,0 +1,43 @@
+name: Publish @mem0/openclaw-mem0 📦 to npm
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build-n-publish:
+    name: Build and publish @mem0/openclaw-mem0 📦 to npm
+    if: startsWith(github.event.release.tag_name, 'openclaw-v')
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    defaults:
+      run:
+        working-directory: openclaw
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          registry-url: 'https://registry.npmjs.org'
+          cache: 'pnpm'
+          cache-dependency-path: openclaw/pnpm-lock.yaml
+
+      - name: Upgrade npm for OIDC trusted publishing
+        run: npm install -g npm@latest
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build
+        run: pnpm build
+
+      - name: Publish to npm
+        run: npm publish --provenance --access public

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

@@ -0,0 +1,43 @@
+name: Publish mem0ai 📦 to npm
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build-n-publish:
+    name: Build and publish mem0ai 📦 to npm
+    if: startsWith(github.event.release.tag_name, 'ts-v')
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    defaults:
+      run:
+        working-directory: mem0-ts
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          registry-url: 'https://registry.npmjs.org'
+          cache: 'pnpm'
+          cache-dependency-path: mem0-ts/pnpm-lock.yaml
+
+      - name: Upgrade npm for OIDC trusted publishing
+        run: npm install -g npm@latest
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build
+        run: pnpm run build
+
+      - name: Publish to npm
+        run: npm publish --provenance --access public

.github/workflows/vercel-ai-cd.yml

@@ -0,0 +1,43 @@
+name: Publish @mem0/vercel-ai-provider 📦 to npm
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build-n-publish:
+    name: Build and publish @mem0/vercel-ai-provider 📦 to npm
+    if: startsWith(github.event.release.tag_name, 'vercel-ai-v')
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    defaults:
+      run:
+        working-directory: vercel-ai-sdk
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          registry-url: 'https://registry.npmjs.org'
+          cache: 'pnpm'
+          cache-dependency-path: vercel-ai-sdk/pnpm-lock.yaml
+
+      - name: Upgrade npm for OIDC trusted publishing
+        run: npm install -g npm@latest
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build
+        run: pnpm run build
+
+      - name: Publish to npm
+        run: npm publish --provenance --access public

CONTRIBUTING.md

@@ -61,3 +61,31 @@ make test  # After activating a shell with hatch shell test_XX
 Make sure that all tests pass across all supported Python versions before submitting a pull request.
 
 We look forward to your pull requests and can't wait to see your contributions!
+
+### 🚀 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 |
+|---------|----------|------------|---------|
+| `mem0ai` (Python SDK) | PyPI | `v*` | `v0.1.31` |
+| `mem0-cli` (Python CLI) | PyPI | `cli-v*` | `cli-v0.2.1` |
+| `mem0ai` (TypeScript SDK) | npm | `ts-v*` | `ts-v2.4.6` |
+| `@mem0/cli` (Node CLI) | npm | `cli-node-v*` | `cli-node-v0.1.2` |
+| `@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
+
+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
+
+- **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

cli/cli-spec.json

@@ -10,8 +10,8 @@
     "logoMini": "\u25c6 mem0",
     "tagline": "The Memory Layer for AI Agents",
     "colors": {
-      "brand": "#F1C96C",
-      "accent": "#F5D78E",
+      "brand": "#8b5cf6",
+      "accent": "#a78bfa",
       "success": "#22c55e",
       "error": "#ef4444",
       "warning": "#f59e0b",

cli/node/README.md

@@ -2,10 +2,12 @@
 
 The official command-line interface for [mem0](https://mem0.ai) — the memory layer for AI agents. TypeScript implementation.
 
+> **Built for AI agents.** Pass `--agent` (or `--json`) as a global flag on any command to get structured JSON output optimized for programmatic consumption — sanitized fields, no colors or spinners, and errors as JSON too.
+
 ## Prerequisites
 
 - Node.js **18+**
-- pnpm (`npm install -g pnpm`)
+- pnpm (`npm install -g pnpm`) — for development only
 
 ## Installation
 
@@ -13,22 +15,307 @@ The official command-line interface for [mem0](https://mem0.ai) — the memory l
 npm install -g @mem0/cli
 ```
 
-Or from source:
+## Quick start
 
 ```bash
-cd node
-pnpm install
-pnpm build
-pnpm link --global
+# Interactive setup wizard
+mem0 init
 
-# Now use it like a normal CLI
-mem0 --help
+# Or login via email
+mem0 init --email alice@company.com
+
+# Or authenticate with an existing API key
+mem0 init --api-key m0-xxx
+
+# Add a memory
+mem0 add "I prefer dark mode and use vim keybindings" --user-id alice
+
+# Search memories
+mem0 search "What are Alice's preferences?" --user-id alice
+
+# List all memories for a user
+mem0 list --user-id alice
+
+# Get a specific memory
+mem0 get <memory-id>
+
+# Update a memory
+mem0 update <memory-id> "I switched to light mode"
+
+# Delete a memory
+mem0 delete <memory-id>
 ```
 
-## Running during development
+## Commands
+
+### `mem0 init`
+
+Interactive setup wizard. Prompts for your API key and default user ID.
 
 ```bash
-cd node
+mem0 init
+mem0 init --api-key m0-xxx --user-id alice
+mem0 init --email alice@company.com
+```
+
+If an existing configuration is detected, the CLI asks for confirmation before overwriting. Use `--force` to skip the prompt (useful in CI/CD).
+
+```bash
+mem0 init --api-key m0-xxx --user-id alice --force
+```
+
+| Flag | Description |
+|------|-------------|
+| `--api-key` | API key (skip prompt) |
+| `-u, --user-id` | Default user ID (skip prompt) |
+| `--email` | Login via email verification code |
+| `--code` | Verification code (use with `--email` for non-interactive login) |
+| `--force` | Overwrite existing config without confirmation |
+
+### `mem0 add`
+
+Add a memory from text, a JSON messages array, a file, or stdin.
+
+```bash
+mem0 add "I prefer dark mode" --user-id alice
+mem0 add --file conversation.json --user-id alice
+echo "Loves hiking on weekends" | mem0 add --user-id alice
+```
+
+| Flag | Description |
+|------|-------------|
+| `-u, --user-id` | Scope to a user |
+| `--agent-id` | Scope to an agent |
+| `--messages` | Conversation messages as JSON |
+| `-f, --file` | Read messages from a JSON file |
+| `-m, --metadata` | Custom metadata as JSON |
+| `--categories` | Categories (JSON array or comma-separated) |
+| `--graph / --no-graph` | Enable or disable graph memory extraction |
+| `-o, --output` | Output format: `text`, `json`, `quiet` |
+
+### `mem0 search`
+
+Search memories using natural language.
+
+```bash
+mem0 search "dietary restrictions" --user-id alice
+mem0 search "preferred tools" --user-id alice --output json --top-k 5
+```
+
+| Flag | Description |
+|------|-------------|
+| `-u, --user-id` | Filter by user |
+| `-k, --top-k` | Number of results (default: 10) |
+| `--threshold` | Minimum similarity score (default: 0.3) |
+| `--rerank` | Enable reranking |
+| `--keyword` | Use keyword search instead of semantic |
+| `--filter` | Advanced filter expression (JSON) |
+| `--graph / --no-graph` | Enable or disable graph in search |
+| `-o, --output` | Output format: `text`, `json`, `table` |
+
+### `mem0 list`
+
+List memories with optional filters and pagination.
+
+```bash
+mem0 list --user-id alice
+mem0 list --user-id alice --category preferences --output json
+mem0 list --user-id alice --after 2024-01-01 --page-size 50
+```
+
+| Flag | Description |
+|------|-------------|
+| `-u, --user-id` | Filter by user |
+| `--page` | Page number (default: 1) |
+| `--page-size` | Results per page (default: 100) |
+| `--category` | Filter by category |
+| `--after` | Created after date (YYYY-MM-DD) |
+| `--before` | Created before date (YYYY-MM-DD) |
+| `-o, --output` | Output format: `text`, `json`, `table` |
+
+### `mem0 get`
+
+Retrieve a specific memory by ID.
+
+```bash
+mem0 get 7b3c1a2e-4d5f-6789-abcd-ef0123456789
+mem0 get 7b3c1a2e-4d5f-6789-abcd-ef0123456789 --output json
+```
+
+### `mem0 update`
+
+Update the text or metadata of an existing memory.
+
+```bash
+mem0 update <memory-id> "Updated preference text"
+mem0 update <memory-id> --metadata '{"priority": "high"}'
+echo "new text" | mem0 update <memory-id>
+```
+
+### `mem0 delete`
+
+Delete a single memory, all memories for a scope, or an entire entity.
+
+```bash
+# Delete a single memory
+mem0 delete <memory-id>
+
+# Delete all memories for a user
+mem0 delete --all --user-id alice --force
+
+# Delete all memories project-wide
+mem0 delete --all --project --force
+
+# Preview what would be deleted
+mem0 delete --all --user-id alice --dry-run
+```
+
+| Flag | Description |
+|------|-------------|
+| `--all` | Delete all memories matching scope filters |
+| `--entity` | Delete the entity and all its memories |
+| `--project` | With `--all`: delete all memories project-wide |
+| `--dry-run` | Preview without deleting |
+| `--force` | Skip confirmation prompt |
+
+### `mem0 import`
+
+Bulk import memories from a JSON file.
+
+```bash
+mem0 import data.json --user-id alice
+```
+
+The file should be a JSON array where each item has a `memory` (or `text` or `content`) field and optional `user_id`, `agent_id`, and `metadata` fields.
+
+### `mem0 config`
+
+View or modify the local CLI configuration.
+
+```bash
+mem0 config show              # Display current config (secrets redacted)
+mem0 config get api_key       # Get a specific value
+mem0 config set user_id bob   # Set a value
+```
+
+### `mem0 entity`
+
+List or delete entities (users, agents, apps, runs).
+
+```bash
+mem0 entity list users
+mem0 entity list agents --output json
+mem0 entity delete --user-id alice --force
+```
+
+### `mem0 event`
+
+Inspect background processing events created by async operations (e.g. bulk deletes, large add jobs).
+
+```bash
+# List recent events
+mem0 event list
+
+# Check the status of a specific event
+mem0 event status <event-id>
+```
+
+| Flag | Description |
+|------|-------------|
+| `-o, --output` | Output format: `text`, `json` |
+
+### `mem0 status`
+
+Verify your API connection and display the current project.
+
+```bash
+mem0 status
+```
+
+### `mem0 version`
+
+Print the CLI version.
+
+```bash
+mem0 version
+```
+
+## Agent mode
+
+Pass `--agent` (or its alias `--json`) as a **global flag** on any command to get output designed for AI agent tool loops:
+
+```bash
+mem0 --agent search "user preferences" --user-id alice
+mem0 --agent add "User prefers dark mode" --user-id alice
+mem0 --agent list --user-id alice
+mem0 --agent delete --all --user-id alice --force
+```
+
+Every command returns the same envelope shape:
+
+```json
+{
+  "status": "success",
+  "command": "search",
+  "duration_ms": 134,
+  "scope": { "user_id": "alice" },
+  "count": 2,
+  "data": [
+    { "id": "abc-123", "memory": "User prefers dark mode", "score": 0.97, "created_at": "2026-01-15", "categories": ["preferences"] }
+  ]
+}
+```
+
+What agent mode does differently from `--output json`:
+
+- **Sanitized `data`**: only the fields an agent needs (id, memory, score, etc.) — no internal API noise
+- **No human output**: spinners, colors, and banners are suppressed entirely
+- **Errors as JSON**: errors go to stdout as `{"status": "error", "command": "...", "error": "..."}` with a non-zero exit code
+
+Use `mem0 help --json` to get the full command tree as JSON — useful for agents that need to self-discover available commands.
+
+## Output formats
+
+Control how results are displayed with `--output`:
+
+| Format | Description |
+|--------|-------------|
+| `text` | Human-readable with colors and formatting (default) |
+| `json` | Structured JSON for piping to `jq` (raw API response) |
+| `table` | Tabular format (default for `list`) |
+| `quiet` | Minimal — just IDs or status codes |
+| `agent` | Structured JSON envelope with sanitized fields (set by `--agent`/`--json`) |
+
+## Global flags
+
+These flags are available on all commands:
+
+| Flag | Description |
+|------|-------------|
+| `--json` | Enable agent mode: structured JSON envelope output, no colors or spinners |
+| `--agent` | Alias for `--json` |
+| `--api-key` | Override the configured API key for this request |
+| `--base-url` | Override the configured API base URL for this request |
+| `-o, --output` | Set the output format |
+
+## Environment variables
+
+| Variable | Description |
+|----------|-------------|
+| `MEM0_API_KEY` | API key (overrides config file) |
+| `MEM0_BASE_URL` | API base URL |
+| `MEM0_USER_ID` | Default user ID |
+| `MEM0_AGENT_ID` | Default agent ID |
+| `MEM0_APP_ID` | Default app ID |
+| `MEM0_RUN_ID` | Default run ID |
+| `MEM0_ENABLE_GRAPH` | Enable graph memory (`true` / `false`) |
+
+Environment variables take precedence over values in the config file, which take precedence over defaults.
+
+## Development
+
+```bash
+cd cli/node
 pnpm install
 
 # Development mode (runs TypeScript directly, no build needed)
@@ -39,36 +326,11 @@ pnpm dev search "test" --user-id alice
 # Or build first, then run the compiled JS
 pnpm build
 node dist/index.js --help
-node dist/index.js add "test memory" --user-id alice
 ```
 
-## Quick Start
+## Documentation
 
-```bash
-# Set up your configuration
-mem0 init
-
-# Add a memory
-mem0 add "I prefer dark mode and use vim keybindings" --user-id alice
-
-# Search memories
-mem0 search "What are Alice's preferences?" --user-id alice
-
-# List all memories
-mem0 list --user-id alice
-```
-
-## Environment Variables
-
-| Variable | Description |
-|----------|-------------|
-| `MEM0_API_KEY` | API key (overrides config file) |
-| `MEM0_BASE_URL` | API base URL |
-| `MEM0_USER_ID` | Default user ID |
-| `MEM0_AGENT_ID` | Default agent ID |
-| `MEM0_APP_ID` | Default app ID |
-| `MEM0_RUN_ID` | Default run ID |
-| `MEM0_ENABLE_GRAPH` | Enable graph memory (true/false) |
+Full documentation is available at [docs.mem0.ai/platform/cli](https://docs.mem0.ai/platform/cli).
 
 ## License
 

cli/node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mem0/cli",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "The official CLI for mem0 — the memory layer for AI agents",
   "type": "module",
   "bin": {
@@ -20,6 +20,11 @@
   },
   "license": "Apache-2.0",
   "author": "mem0.ai <founders@mem0.ai>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mem0ai/mem0",
+    "directory": "cli/node"
+  },
   "keywords": ["mem0", "memory", "ai", "agents", "cli"],
   "publishConfig": {
     "access": "public"

cli/node/src/branding.ts

@@ -19,8 +19,8 @@ export const LOGO = `
 export const LOGO_MINI = "◆ mem0";
 export const TAGLINE = "The Memory Layer for AI Agents";
 
-export const BRAND_COLOR = "#F1C96C";
-export const ACCENT_COLOR = "#F5D78E";
+export const BRAND_COLOR = "#8b5cf6";
+export const ACCENT_COLOR = "#a78bfa";
 export const SUCCESS_COLOR = "#22c55e";
 export const ERROR_COLOR = "#ef4444";
 export const WARNING_COLOR = "#f59e0b";

cli/node/tests/branding.test.ts

@@ -39,7 +39,7 @@ afterEach(() => {
 
 describe("branding constants", () => {
   it("has correct brand color", () => {
-    expect(BRAND_COLOR).toBe("#F1C96C");
+    expect(BRAND_COLOR).toBe("#8b5cf6");
   });
 
   it("has correct tagline", () => {

cli/node/tests/cli-integration.test.ts

@@ -44,13 +44,6 @@ describe("CLI Integration — help and version", () => {
     expect(result.stdout).toContain("search");
   });
 
-  it("shows version with --version", () => {
-    const result = run(["--version"]);
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout).toContain("0.1.0");
-  });
-
-
   it("help --json produces valid JSON", () => {
     const result = run(["help", "--json"]);
     expect(result.exitCode).toBe(0);

cli/node/tests/commands.test.ts

@@ -253,13 +253,6 @@ describe("cmdDeleteAll", () => {
   });
 });
 
-describe("cmdVersion", () => {
-  it("shows version", async () => {
-    const { cmdVersion } = await import("../src/commands/utils.js");
-    cmdVersion();
-    expect(output).toContain("0.1.0");
-  });
-});
 
 describe("cmdEntitiesList", () => {
   it("lists users in table mode", async () => {

cli/python/README.md

@@ -1,6 +1,12 @@
-# mem0 CLI
+# mem0 CLI (Python)
 
-The official command-line interface for [mem0](https://mem0.ai) — the memory layer for AI agents.
+The official command-line interface for [mem0](https://mem0.ai) — the memory layer for AI agents. Python implementation.
+
+> **Built for AI agents.** Pass `--agent` (or `--json`) as a global flag on any command to get structured JSON output optimized for programmatic consumption — sanitized fields, no colors or spinners, and errors as JSON too.
+
+## Prerequisites
+
+- Python **3.10+**
 
 ## Installation
 
@@ -18,28 +24,325 @@ pip install mem0-cli
 
 > **Note:** On macOS with Homebrew Python, `pip install` outside a virtual environment will fail with an `externally-managed-environment` error ([PEP 668](https://peps.python.org/pep-0668/)). Use `pipx` instead, or install inside a virtual environment.
 
-## Quick Start
+## Quick start
 
 ```bash
-# Set up your configuration
+# Interactive setup wizard
 mem0 init
 
+# Or login via email
+mem0 init --email alice@company.com
+
+# Or authenticate with an existing API key
+mem0 init --api-key m0-xxx
+
 # Add a memory
 mem0 add "I prefer dark mode and use vim keybindings" --user-id alice
 
 # Search memories
 mem0 search "What are Alice's preferences?" --user-id alice
 
-# List all memories
+# List all memories for a user
 mem0 list --user-id alice
+
+# Get a specific memory
+mem0 get <memory-id>
+
+# Update a memory
+mem0 update <memory-id> "I switched to light mode"
+
+# Delete a memory
+mem0 delete <memory-id>
+```
+
+## Commands
+
+### `mem0 init`
+
+Interactive setup wizard. Prompts for your API key and default user ID.
+
+```bash
+mem0 init
+mem0 init --api-key m0-xxx --user-id alice
+mem0 init --email alice@company.com
+```
+
+If an existing configuration is detected, the CLI asks for confirmation before overwriting. Use `--force` to skip the prompt (useful in CI/CD).
+
+```bash
+mem0 init --api-key m0-xxx --user-id alice --force
+```
+
+| Flag | Description |
+|------|-------------|
+| `--api-key` | API key (skip prompt) |
+| `-u, --user-id` | Default user ID (skip prompt) |
+| `--email` | Login via email verification code |
+| `--code` | Verification code (use with `--email` for non-interactive login) |
+| `--force` | Overwrite existing config without confirmation |
+
+### `mem0 add`
+
+Add a memory from text, a JSON messages array, a file, or stdin.
+
+```bash
+mem0 add "I prefer dark mode" --user-id alice
+mem0 add --file conversation.json --user-id alice
+echo "Loves hiking on weekends" | mem0 add --user-id alice
+```
+
+| Flag | Description |
+|------|-------------|
+| `-u, --user-id` | Scope to a user |
+| `--agent-id` | Scope to an agent |
+| `--messages` | Conversation messages as JSON |
+| `-f, --file` | Read messages from a JSON file |
+| `-m, --metadata` | Custom metadata as JSON |
+| `--categories` | Categories (JSON array or comma-separated) |
+| `--graph / --no-graph` | Enable or disable graph memory extraction |
+| `-o, --output` | Output format: `text`, `json`, `quiet` |
+
+### `mem0 search`
+
+Search memories using natural language.
+
+```bash
+mem0 search "dietary restrictions" --user-id alice
+mem0 search "preferred tools" --user-id alice --output json --top-k 5
+```
+
+| Flag | Description |
+|------|-------------|
+| `-u, --user-id` | Filter by user |
+| `-k, --top-k` | Number of results (default: 10) |
+| `--threshold` | Minimum similarity score (default: 0.3) |
+| `--rerank` | Enable reranking |
+| `--keyword` | Use keyword search instead of semantic |
+| `--filter` | Advanced filter expression (JSON) |
+| `--graph / --no-graph` | Enable or disable graph in search |
+| `-o, --output` | Output format: `text`, `json`, `table` |
+
+### `mem0 list`
+
+List memories with optional filters and pagination.
+
+```bash
+mem0 list --user-id alice
+mem0 list --user-id alice --category preferences --output json
+mem0 list --user-id alice --after 2024-01-01 --page-size 50
+```
+
+| Flag | Description |
+|------|-------------|
+| `-u, --user-id` | Filter by user |
+| `--page` | Page number (default: 1) |
+| `--page-size` | Results per page (default: 100) |
+| `--category` | Filter by category |
+| `--after` | Created after date (YYYY-MM-DD) |
+| `--before` | Created before date (YYYY-MM-DD) |
+| `-o, --output` | Output format: `text`, `json`, `table` |
+
+### `mem0 get`
+
+Retrieve a specific memory by ID.
+
+```bash
+mem0 get 7b3c1a2e-4d5f-6789-abcd-ef0123456789
+mem0 get 7b3c1a2e-4d5f-6789-abcd-ef0123456789 --output json
+```
+
+### `mem0 update`
+
+Update the text or metadata of an existing memory.
+
+```bash
+mem0 update <memory-id> "Updated preference text"
+mem0 update <memory-id> --metadata '{"priority": "high"}'
+echo "new text" | mem0 update <memory-id>
+```
+
+### `mem0 delete`
+
+Delete a single memory, all memories for a scope, or an entire entity.
+
+```bash
+# Delete a single memory
+mem0 delete <memory-id>
+
+# Delete all memories for a user
+mem0 delete --all --user-id alice --force
+
+# Delete all memories project-wide
+mem0 delete --all --project --force
+
+# Preview what would be deleted
+mem0 delete --all --user-id alice --dry-run
+```
+
+| Flag | Description |
+|------|-------------|
+| `--all` | Delete all memories matching scope filters |
+| `--entity` | Delete the entity and all its memories |
+| `--project` | With `--all`: delete all memories project-wide |
+| `--dry-run` | Preview without deleting |
+| `--force` | Skip confirmation prompt |
+
+### `mem0 import`
+
+Bulk import memories from a JSON file.
+
+```bash
+mem0 import data.json --user-id alice
+```
+
+The file should be a JSON array where each item has a `memory` (or `text` or `content`) field and optional `user_id`, `agent_id`, and `metadata` fields.
+
+### `mem0 config`
+
+View or modify the local CLI configuration.
+
+```bash
+mem0 config show              # Display current config (secrets redacted)
+mem0 config get api_key       # Get a specific value
+mem0 config set user_id bob   # Set a value
+```
+
+### `mem0 entity`
+
+List or delete entities (users, agents, apps, runs).
+
+```bash
+mem0 entity list users
+mem0 entity list agents --output json
+mem0 entity delete --user-id alice --force
+```
+
+### `mem0 event`
+
+Inspect background processing events created by async operations (e.g. bulk deletes, large add jobs).
+
+```bash
+# List recent events
+mem0 event list
+
+# Check the status of a specific event
+mem0 event status <event-id>
+```
+
+| Flag | Description |
+|------|-------------|
+| `-o, --output` | Output format: `text`, `json` |
+
+### `mem0 status`
+
+Verify your API connection and display the current project.
+
+```bash
+mem0 status
+```
+
+### `mem0 version`
+
+Print the CLI version.
+
+```bash
+mem0 version
+```
+
+## Agent mode
+
+Pass `--agent` (or its alias `--json`) as a **global flag** on any command to get output designed for AI agent tool loops:
+
+```bash
+mem0 --agent search "user preferences" --user-id alice
+mem0 --agent add "User prefers dark mode" --user-id alice
+mem0 --agent list --user-id alice
+mem0 --agent delete --all --user-id alice --force
+```
+
+Every command returns the same envelope shape:
+
+```json
+{
+  "status": "success",
+  "command": "search",
+  "duration_ms": 134,
+  "scope": { "user_id": "alice" },
+  "count": 2,
+  "data": [
+    { "id": "abc-123", "memory": "User prefers dark mode", "score": 0.97, "created_at": "2026-01-15", "categories": ["preferences"] }
+  ]
+}
+```
+
+What agent mode does differently from `--output json`:
+
+- **Sanitized `data`**: only the fields an agent needs (id, memory, score, etc.) — no internal API noise
+- **No human output**: spinners, colors, and banners are suppressed entirely
+- **Errors as JSON**: errors go to stdout as `{"status": "error", "command": "...", "error": "..."}` with a non-zero exit code
+
+Use `mem0 help --json` to get the full command tree as JSON — useful for agents that need to self-discover available commands.
+
+## Output formats
+
+Control how results are displayed with `--output`:
+
+| Format | Description |
+|--------|-------------|
+| `text` | Human-readable with colors and formatting (default) |
+| `json` | Structured JSON for piping to `jq` (raw API response) |
+| `table` | Tabular format (default for `list`) |
+| `quiet` | Minimal — just IDs or status codes |
+| `agent` | Structured JSON envelope with sanitized fields (set by `--agent`/`--json`) |
+
+## Global flags
+
+These flags are available on all commands:
+
+| Flag | Description |
+|------|-------------|
+| `--json` | Enable agent mode: structured JSON envelope output, no colors or spinners |
+| `--agent` | Alias for `--json` |
+| `--api-key` | Override the configured API key for this request |
+| `--base-url` | Override the configured API base URL for this request |
+| `-o, --output` | Set the output format |
+
+## Environment variables
+
+| Variable | Description |
+|----------|-------------|
+| `MEM0_API_KEY` | API key (overrides config file) |
+| `MEM0_BASE_URL` | API base URL |
+| `MEM0_USER_ID` | Default user ID |
+| `MEM0_AGENT_ID` | Default agent ID |
+| `MEM0_APP_ID` | Default app ID |
+| `MEM0_RUN_ID` | Default run ID |
+| `MEM0_ENABLE_GRAPH` | Enable graph memory (`true` / `false`) |
+
+Environment variables take precedence over values in the config file, which take precedence over defaults.
+
+## Development
+
+```bash
+cd cli/python
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+
+# Run during development
+python -m mem0_cli --help
+mem0 add "test memory" --user-id alice
 ```
 
 ## Releasing
 
 1. Update `version` in `pyproject.toml`
-2. Create a GitHub Release with tag `cli-v<version>` (e.g. `cli-v0.2.0`)
+2. Create a GitHub Release with tag `cli-v<version>` (e.g. `cli-v0.2.1`)
 
-For a pre-release, use a beta version like `0.2.0b1` and check the **pre-release** checkbox.
+For a pre-release, use a beta version like `0.2.1b1` and check the **pre-release** checkbox.
+
+## Documentation
+
+Full documentation is available at [docs.mem0.ai/platform/cli](https://docs.mem0.ai/platform/cli).
 
 ## License
 

cli/python/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mem0-cli"
-version = "0.2.0b1"
+version = "0.2.1"
 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.1.0"
+__version__ = "0.2.1"

cli/python/src/mem0_cli/branding.py

@@ -26,8 +26,8 @@ LOGO_MINI = "◆ mem0"
 
 TAGLINE = "The Memory Layer for AI Agents"
 
-BRAND_COLOR = "#F1C96C"  # Golden
-ACCENT_COLOR = "#F5D78E"
+BRAND_COLOR = "#8b5cf6"  # Purple
+ACCENT_COLOR = "#a78bfa"
 SUCCESS_COLOR = "#22c55e"
 ERROR_COLOR = "#ef4444"
 WARNING_COLOR = "#f59e0b"

cli/python/tests/test_cli_integration.py

@@ -83,11 +83,6 @@ class TestCLIIntegration:
         assert "add" in result.stdout
         assert "search" in result.stdout
 
-    def test_version_flag(self):
-        result = _run(["--version"])
-        assert result.returncode == 0
-        assert "0.1.0" in result.stdout
-
     def test_add_help(self):
         result = _run(["add", "--help"])
         assert result.returncode == 0

cli/python/tests/test_commands.py

@@ -30,7 +30,6 @@ from mem0_cli.commands.memory import (
 from mem0_cli.commands.utils import (
     cmd_import,
     cmd_status,
-    cmd_version,
 )
 
 
@@ -742,15 +741,6 @@ class TestStatusCommand:
         assert '"status"' in output
 
 
-class TestVersionCommand:
-    def test_version(self):
-        console, buf = _make_console()
-        with patch("mem0_cli.commands.utils.console", console):
-            cmd_version()
-        output = buf.getvalue()
-        assert "0.1.0" in output
-
-
 class TestImportCommand:
     def test_import_json(self, mock_backend, tmp_path):
         file_path = tmp_path / "import.json"

docs/api-reference/organizations-projects.mdx

@@ -82,7 +82,7 @@ new_project = client.project.create(
 
 ### Update Project Settings
 
-Modify project configuration including custom instructions, categories, and graph settings:
+Modify project configuration including custom instructions, categories, graph settings, and language preferences:
 
 ```python
 # Update project with custom categories
@@ -101,6 +101,9 @@ client.project.update(
 # Enable graph memory for the project
 client.project.update(enable_graph=True)
 
+# Use the input language for memory storage and retrieval
+client.project.update(multilingual=True)
+
 # Update multiple settings at once
 client.project.update(
     custom_instructions="...",
@@ -108,7 +111,8 @@ client.project.update(
         {"personal_info": "User personal information and preferences"},
         {"work_context": "Professional context and work-related information"}
     ],
-    enable_graph=True
+    enable_graph=True,
+    multilingual=True
 )
 ```
 

docs/components/llms/models/google_AI.mdx

@@ -24,6 +24,7 @@ config = {
         "provider": "gemini",
         "config": {
             "model": "gemini-2.0-flash-001",
+            "api_key": "your-gemini-api-key",
             "temperature": 0.2,
             "max_tokens": 2000,
             "top_p": 1.0
@@ -52,6 +53,7 @@ const config = {
         provider: "gemini",
         config: {
             model: "gemini-2.0-flash-001",
+            apiKey: process.env.GOOGLE_API_KEY || '',
             temperature: 0.1
         }
     }

docs/docs.json

@@ -430,6 +430,20 @@
                   }
                 ]
               },
+              {
+                "tab": "Agent Plugins",
+                "groups": [
+                  {
+                    "group": "Coding Agents",
+                    "icon": "terminal",
+                    "pages": [
+                      "integrations/claude-code",
+                      "integrations/cursor",
+                      "integrations/codex"
+                    ]
+                  }
+                ]
+              },
               {
                 "tab": "API Reference",
                 "groups": [

docs/integrations.mdx

@@ -381,4 +381,25 @@ Here are the available integrations for Mem0:
   >
     Build AI agents with persistent memory using Mastra's framework and tools.
   </Card>
+  <Card
+    title="Claude Code"
+    icon="terminal"
+    href="/integrations/claude-code"
+  >
+    Add persistent memory to Claude Code and Cowork with MCP server, lifecycle hooks, and SDK skill.
+  </Card>
+  <Card
+    title="Cursor"
+    icon="i-cursor"
+    href="/integrations/cursor"
+  >
+    Add persistent memory to Cursor with MCP server, lifecycle hooks, and context-aware coding.
+  </Card>
+  <Card
+    title="Codex"
+    icon="robot"
+    href="/integrations/codex"
+  >
+    Add persistent memory to OpenAI Codex with MCP server and skill-based memory protocol.
+  </Card>
 </CardGroup>

docs/integrations/claude-code.mdx

@@ -0,0 +1,156 @@
+---
+title: Claude Code
+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.
+
+## Overview
+
+1. **MCP Server** — Connect to Mem0's remote MCP server for memory tools (add, search, update, delete)
+2. **Lifecycle Hooks** — Automatic memory capture at session start, context compaction, task completion, and session end
+3. **SDK Skill** — Teaches the agent how to integrate the Mem0 SDK into your applications
+4. **Zero local dependencies** — Cloud-hosted MCP server, no local setup required
+
+## Prerequisites
+
+Before setting up Mem0 with Claude Code, ensure you have:
+
+1. A Mem0 Platform account and API key:
+   - [Sign up at app.mem0.ai](https://app.mem0.ai)
+   - [Get your API key](https://app.mem0.ai/dashboard/api-keys) (starts with `m0-`)
+
+2. Claude Code CLI or Claude Cowork desktop app installed
+
+3. Your API key exported in your shell:
+
+```bash
+export MEM0_API_KEY="m0-your-api-key"
+```
+
+## Installation
+
+### Option A — Plugin Marketplace (Recommended)
+
+Install the full plugin including MCP server, lifecycle hooks, and SDK skill:
+
+```
+/plugin marketplace add mem0ai/mem0
+/plugin install mem0@mem0-plugins
+```
+
+**Claude Cowork desktop app:** Open the Cowork tab, click **Customize** in the sidebar, click **Browse plugins**, and install Mem0.
+
+### Option B — MCP Only
+
+Add the Mem0 MCP server directly with a single command:
+
+```bash
+npx mcp-add \
+  --name mem0-mcp \
+  --type http \
+  --url "https://mcp.mem0.ai/mcp" \
+  --clients "claude code"
+```
+
+This gives you the MCP tools but not the lifecycle hooks or SDK skill.
+
+### Option C — Manual MCP Configuration
+
+Add to your Claude Code MCP config (`.mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "mem0": {
+      "type": "http",
+      "url": "https://mcp.mem0.ai/mcp/",
+      "headers": {
+        "Authorization": "Token ${MEM0_API_KEY}"
+      }
+    }
+  }
+}
+```
+
+<Info icon="check">
+  Start a new 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 | Plugin Install | MCP Only |
+|-----------|:--------------:|:--------:|
+| MCP Server (9 memory tools) | Yes | Yes |
+| Lifecycle Hooks | Yes | No |
+| Mem0 SDK Skill | Yes | No |
+
+## Available MCP Tools
+
+Once installed, the following tools are available in every Claude Code session:
+
+| Tool | Description |
+|------|-------------|
+| `add_memory` | Save text or conversation history for a user/agent |
+| `search_memories` | Semantic search across memories with filters |
+| `get_memories` | List memories with filters and pagination |
+| `get_memory` | Retrieve a specific memory by ID |
+| `update_memory` | Overwrite a memory's text by ID |
+| `delete_memory` | Delete a single memory by ID |
+| `delete_all_memories` | Bulk delete all memories in scope |
+| `delete_entities` | Delete a user/agent/app/run entity and its memories |
+| `list_entities` | List users/agents/apps/runs stored in Mem0 |
+
+## Lifecycle Hooks
+
+When installed via the plugin marketplace, Mem0 hooks into Claude Code's lifecycle to automatically manage memory:
+
+### Session Start
+On every new session, the plugin prompts Claude to call `search_memories` to load relevant context from prior sessions. On resumed or post-compaction sessions, it adjusts the prompt accordingly.
+
+### User Prompt
+Before processing each user message, the plugin searches Mem0 for memories relevant to the current prompt and injects them into context. Short prompts (< 20 characters) are skipped to minimize latency.
+
+### Pre-Compaction
+Before context compaction, the plugin prompts Claude to store a comprehensive session summary — including goals, accomplishments, decisions, modified files, and current state — so nothing is lost.
+
+### Task Completed
+After each task completion, the plugin prompts Claude to extract and store key learnings: successful strategies, failed approaches, architectural decisions, and new conventions.
+
+### Session End
+When Claude finishes responding, the plugin prompts for any unstored learnings and captures transcript state via the Mem0 REST API as a background safety net.
+
+## Example Workflow
+
+```text
+# Session 1: Working on a feature
+You: Let's refactor the auth module to use JWT tokens instead of sessions.
+
+# Claude searches memories, finds nothing relevant, proceeds with the work.
+# After completing the task, Mem0 stores:
+#   - Decision: "Migrated auth from sessions to JWT tokens"
+#   - Files modified: auth/middleware.ts, auth/token.ts
+#   - User preference: "Prefers TypeScript, uses ESLint"
+
+# Session 2 (days later): Related work
+You: Add refresh token rotation to the auth system.
+
+# Claude searches memories, retrieves the JWT migration context.
+# Knows the file structure, decisions made, and user preferences.
+# Continues seamlessly without re-explaining the codebase.
+```
+
+## Troubleshooting
+
+- **"Connection failed"** — Verify `MEM0_API_KEY` is set in your shell: `echo $MEM0_API_KEY`
+- **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.
+
+<CardGroup cols={2}>
+  <Card title="Mem0 MCP Setup" icon="puzzle-piece" href="/platform/mem0-mcp">
+    Detailed MCP configuration for all clients
+  </Card>
+  <Card title="Codex Integration" icon="robot" href="/integrations/codex">
+    Add Mem0 memory to OpenAI Codex workflows
+  </Card>
+</CardGroup>

docs/integrations/codex.mdx

@@ -0,0 +1,212 @@
+---
+title: Codex
+description: "Add persistent memory to OpenAI Codex with the Mem0 plugin — MCP server, memory protocol skill, and plugin marketplace support."
+---
+
+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 and using a skill-based memory protocol to automatically retrieve context and store learnings.
+
+## Overview
+
+1. **MCP Server** — Connect to Mem0's remote MCP server for memory tools (add, search, update, delete)
+2. **Memory Protocol Skill** — Instructs the agent to retrieve memories at task start, store learnings on completion, and capture session state before context loss
+3. **Plugin Marketplace** — Install via Codex's repo-level or personal plugin marketplace
+4. **Zero local dependencies** — Cloud-hosted MCP server, no local setup required
+
+## Prerequisites
+
+Before setting up Mem0 with Codex, ensure you have:
+
+1. A Mem0 Platform account and API key:
+   - [Sign up at app.mem0.ai](https://app.mem0.ai)
+   - [Get your API key](https://app.mem0.ai/dashboard/api-keys) (starts with `m0-`)
+
+2. OpenAI Codex access
+
+3. Your API key exported in your shell:
+
+```bash
+export MEM0_API_KEY="m0-your-api-key"
+```
+
+## Installation
+
+### Option A — Repo Marketplace (Recommended for Teams)
+
+Add a `.agents/plugins/marketplace.json` to your repository root:
+
+```json
+{
+  "name": "mem0-plugins",
+  "interface": {
+    "displayName": "Mem0 Plugins"
+  },
+  "plugins": [
+    {
+      "name": "mem0",
+      "source": {
+        "source": "local",
+        "path": "./plugins/mem0"
+      },
+      "policy": {
+        "installation": "AVAILABLE",
+        "authentication": "ON_INSTALL"
+      },
+      "category": "Productivity"
+    }
+  ]
+}
+```
+
+Then in Codex, browse the repo's plugin directory and install Mem0.
+
+### Option B — Personal Marketplace
+
+Add to `~/.agents/plugins/marketplace.json`:
+
+```json
+{
+  "name": "mem0-plugins",
+  "interface": {
+    "displayName": "Mem0 Plugins"
+  },
+  "plugins": [
+    {
+      "name": "mem0",
+      "source": {
+        "source": "local",
+        "path": "/path/to/mem0-plugin"
+      },
+      "policy": {
+        "installation": "AVAILABLE",
+        "authentication": "ON_INSTALL"
+      },
+      "category": "Productivity"
+    }
+  ]
+}
+```
+
+### Option C — Manual MCP Configuration
+
+Add to your Codex MCP config:
+
+```json
+{
+  "mcpServers": {
+    "mem0": {
+      "type": "http",
+      "url": "https://mcp.mem0.ai/mcp/",
+      "headers": {
+        "Authorization": "Token ${MEM0_API_KEY}"
+      }
+    }
+  }
+}
+```
+
+<Info icon="check">
+  Start a new Codex task 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 | Plugin Install | MCP Only |
+|-----------|:--------------:|:--------:|
+| MCP Server (9 memory tools) | Yes | Yes |
+| Memory Protocol Skill | Yes | No |
+| Mem0 SDK Skill | Yes | No |
+
+## Available MCP Tools
+
+Once installed, the following tools are available in every Codex session:
+
+| Tool | Description |
+|------|-------------|
+| `add_memory` | Save text or conversation history for a user/agent |
+| `search_memories` | Semantic search across memories with filters |
+| `get_memories` | List memories with filters and pagination |
+| `get_memory` | Retrieve a specific memory by ID |
+| `update_memory` | Overwrite a memory's text by ID |
+| `delete_memory` | Delete a single memory by ID |
+| `delete_all_memories` | Bulk delete all memories in scope |
+| `delete_entities` | Delete a user/agent/app/run entity and its memories |
+| `list_entities` | List users/agents/apps/runs stored in Mem0 |
+
+## Memory Protocol Skill
+
+Codex uses a skill-based approach instead of lifecycle hooks. When installed via the plugin marketplace, the memory protocol skill instructs the agent to:
+
+### On Every New Task
+1. Call `search_memories` with a query related to the current task to load relevant context
+2. Review returned memories to understand what was learned in prior sessions
+3. Optionally call `get_memories` to browse all stored memories
+
+### After Completing Significant Work
+Store key learnings using `add_memory` with structured metadata:
+
+| What to store | Metadata type |
+|--------------|---------------|
+| Architectural decisions | `{"type": "decision"}` |
+| Strategies that worked | `{"type": "task_learning"}` |
+| Failed approaches | `{"type": "anti_pattern"}` |
+| User preferences observed | `{"type": "user_preference"}` |
+| Environment discoveries | `{"type": "environmental"}` |
+| Conventions established | `{"type": "convention"}` |
+
+### Before Losing Context
+Store a comprehensive session summary including goals, accomplishments, decisions, files modified, and current state with metadata `{"type": "session_state"}`.
+
+## Plugin Manifest
+
+The Codex plugin manifest (`.codex-plugin/plugin.json`) follows the Codex plugin specification:
+
+```json
+{
+  "name": "mem0",
+  "version": "0.1.0",
+  "description": "Mem0 memory layer for AI applications.",
+  "skills": "./skills/",
+  "mcpServers": "./.codex-mcp.json",
+  "interface": {
+    "displayName": "Mem0",
+    "shortDescription": "Persistent memory layer for AI coding workflows",
+    "category": "Productivity",
+    "capabilities": ["Read", "Write"]
+  }
+}
+```
+
+## Example Workflow
+
+```text
+# Task 1: Setting up a new service
+You: Create a REST API for the notifications service using Express and TypeScript.
+
+# Codex searches memories, finds user preferences from prior tasks.
+# After completing the task, Mem0 stores:
+#   - Decision: "Notifications service uses Express + TypeScript + Zod validation"
+#   - Convention: "All API routes follow /api/v1/{resource} pattern"
+#   - Preference: "User prefers explicit error types over generic catch-all"
+
+# Task 2 (days later): Extending the service
+You: Add WebSocket support for real-time notification delivery.
+
+# Codex searches memories, retrieves the architecture decisions and conventions.
+# Follows the same patterns established in the first task.
+```
+
+## Troubleshooting
+
+- **"Connection failed"** — Verify `MEM0_API_KEY` is set in your shell: `echo $MEM0_API_KEY`
+- **No tools appearing** — Restart your Codex session after plugin installation
+- **Plugin not found** — Ensure `.agents/plugins/marketplace.json` is at the repository root and `source.path` points to the correct plugin directory
+- **Skills not loading** — Verify the `skills` field in `plugin.json` points to a valid directory containing `SKILL.md` files
+
+<CardGroup cols={2}>
+  <Card title="Mem0 MCP Setup" icon="puzzle-piece" href="/platform/mem0-mcp">
+    Detailed MCP configuration for all clients
+  </Card>
+  <Card title="Claude Code Integration" icon="terminal" href="/integrations/claude-code">
+    Add Mem0 memory to Claude Code workflows
+  </Card>
+</CardGroup>

docs/integrations/cursor.mdx

@@ -0,0 +1,148 @@
+---
+title: Cursor
+description: "Add persistent memory to Cursor with the Mem0 plugin — MCP server, lifecycle hooks, and SDK skill 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.
+
+## Overview
+
+1. **MCP Server** — Connect to Mem0's remote MCP server for memory tools (add, search, update, delete)
+2. **Lifecycle Hooks** — Automatic memory capture at session start, compaction, and user prompts (Marketplace install)
+3. **SDK Skill** — Teaches the agent how to integrate the Mem0 SDK into your applications
+4. **Zero local dependencies** — Cloud-hosted MCP server, no local setup required
+
+## Prerequisites
+
+Before setting up Mem0 with Cursor, ensure you have:
+
+1. A Mem0 Platform account and API key:
+   - [Sign up at app.mem0.ai](https://app.mem0.ai)
+   - [Get your API key](https://app.mem0.ai/dashboard/api-keys) (starts with `m0-`)
+
+2. Cursor installed ([cursor.com](https://cursor.com))
+
+3. Your API key exported in your shell:
+
+```bash
+export MEM0_API_KEY="m0-your-api-key"
+```
+
+<Warning>
+  Already have `mem0` configured as an MCP server in Cursor? Remove the existing entry from your Cursor MCP settings before installing to avoid duplicate tools.
+</Warning>
+
+## Installation
+
+### 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)
+
+```bash
+npx mcp-add \
+  --name mem0-mcp \
+  --type http \
+  --url "https://mcp.mem0.ai/mcp" \
+  --clients "cursor"
+```
+
+### Option C — Manual Configuration (MCP Only)
+
+Add the following to your `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "mem0": {
+      "url": "https://mcp.mem0.ai/mcp/",
+      "headers": {
+        "Authorization": "Token ${env:MEM0_API_KEY}"
+      }
+    }
+  }
+}
+```
+
+### 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
+
+Once installed, the following tools are available in every Cursor session:
+
+| Tool | Description |
+|------|-------------|
+| `add_memory` | Save text or conversation history for a user/agent |
+| `search_memories` | Semantic search across memories with filters |
+| `get_memories` | List memories with filters and pagination |
+| `get_memory` | Retrieve a specific memory by ID |
+| `update_memory` | Overwrite a memory's text by ID |
+| `delete_memory` | Delete a single memory by ID |
+| `delete_all_memories` | Bulk delete all memories in scope |
+| `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:
+
+### Session Start
+On every new session, the plugin prompts the agent to call `search_memories` to load relevant context from prior sessions.
+
+### User Prompt
+Before processing each user message, the plugin searches Mem0 for relevant memories and injects them into context. Short prompts are skipped to minimize latency.
+
+### Pre-Compaction
+Before context compaction, the plugin captures a comprehensive session summary so nothing is lost when the context window resets.
+
+## Example Workflow
+
+```text
+# Session 1: Debugging a performance issue
+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"
+#   - Decision: "Added database index on users.email column"
+#   - Preference: "User prefers query-level fixes over caching"
+
+# Session 2 (next week): Similar issue
+You: The /orders endpoint is also slow, same pattern as before.
+
+# Agent searches memories, retrieves the optimization learnings.
+# Immediately checks for N+1 queries and missing indexes.
+```
+
+## 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.
+
+<CardGroup cols={2}>
+  <Card title="Mem0 MCP Setup" icon="puzzle-piece" href="/platform/mem0-mcp">
+    Detailed MCP configuration for all clients
+  </Card>
+  <Card title="Claude Code Integration" icon="terminal" href="/integrations/claude-code">
+    Add Mem0 memory to Claude Code workflows
+  </Card>
+</CardGroup>

docs/openapi.json

@@ -3686,6 +3686,10 @@
 											"type": "object"
 										},
 										"description": "List of custom categories to be used for memory categorization."
+									},
+									"multilingual": {
+										"type": "boolean",
+										"description": "Whether to use the input language for memory storage and retrieval."
 									}
 								}
 							}

mem0-plugin/.codex-mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "mem0": {
+      "url": "https://mcp.mem0.ai/mcp/",
+      "bearer_token_env_var": "MEM0_API_KEY"
+    }
+  }
+}

mem0-plugin/.codex-plugin/plugin.json

@@ -0,0 +1,35 @@
+{
+  "name": "mem0",
+  "version": "0.1.0",
+  "description": "Mem0 memory layer for AI applications. Add persistent memory, personalization, and semantic search to Codex workflows using the Mem0 Platform MCP server.",
+  "author": {
+    "name": "Mem0",
+    "email": "support@mem0.ai"
+  },
+  "homepage": "https://mem0.ai",
+  "repository": "https://github.com/mem0ai/mem0",
+  "license": "Apache-2.0",
+  "skills": "./skills/",
+  "mcpServers": "./.codex-mcp.json",
+  "interface": {
+    "displayName": "Mem0",
+    "shortDescription": "Persistent memory layer for AI coding workflows",
+    "longDescription": "Mem0 adds long-term memory to Codex. Store decisions, user preferences, project context, and session state across conversations. Memories are automatically retrieved via semantic search so Codex always has the right context.",
+    "developerName": "Mem0",
+    "category": "Productivity",
+    "capabilities": [
+      "Read",
+      "Write"
+    ],
+    "websiteURL": "https://mem0.ai",
+    "privacyPolicyURL": "https://mem0.ai/privacy",
+    "termsOfServiceURL": "https://mem0.ai/terms",
+    "defaultPrompt": [
+      "Search my memories for recent project decisions",
+      "Remember that I prefer TypeScript over JavaScript",
+      "What do you know about my coding preferences?"
+    ],
+    "brandColor": "#FBBF24",
+    "logo": "./logo.svg"
+  }
+}

mem0-plugin/README.md

@@ -1,6 +1,6 @@
-# Mem0 Plugin for Claude Code, Claude Cowork & Cursor
+# Mem0 Plugin for Claude Code, Claude Cowork, Cursor & Codex
 
-Add persistent memory to your AI workflows. Store, retrieve, and manage memories across sessions using the Mem0 Platform. Works with **Claude Code** (CLI), **Claude Cowork** (desktop app), and **Cursor**.
+Add persistent memory to your AI workflows. Store, retrieve, and manage memories across sessions using the Mem0 Platform. Works with **Claude Code** (CLI), **Claude Cowork** (desktop app), **Cursor**, and **Codex**.
 
 ## Step 1: Set your API key
 
@@ -47,6 +47,65 @@ Claude Code and Claude Cowork share the same plugin system.
 
 This installs the full plugin including the MCP server, lifecycle hooks (automatic memory capture), and the Mem0 SDK skill.
 
+### Codex
+
+**Option A — Repo marketplace** (recommended for teams):
+
+Add the plugin marketplace to your repo root (already included in this repository):
+
+```
+.agents/plugins/marketplace.json
+```
+
+Then in Codex, browse the repo's plugin directory and install Mem0.
+
+**Option B — Personal marketplace**:
+
+Add to `~/.agents/plugins/marketplace.json`:
+
+```json
+{
+  "name": "mem0-plugins",
+  "interface": {
+    "displayName": "Mem0 Plugins"
+  },
+  "plugins": [
+    {
+      "name": "mem0",
+      "source": {
+        "source": "local",
+        "path": "/path/to/mem0/mem0-plugin"
+      },
+      "policy": {
+        "installation": "AVAILABLE",
+        "authentication": "ON_INSTALL"
+      },
+      "category": "Productivity"
+    }
+  ]
+}
+```
+
+**Option C — Manual MCP configuration**:
+
+Add to your Codex MCP config:
+
+```json
+{
+  "mcpServers": {
+    "mem0": {
+      "type": "http",
+      "url": "https://mcp.mem0.ai/mcp/",
+      "headers": {
+        "Authorization": "Token ${MEM0_API_KEY}"
+      }
+    }
+  }
+}
+```
+
+This installs the MCP server and the Mem0 SDK skill. Codex uses the skill-based memory protocol instead of lifecycle hooks.
+
 ### Cursor
 
 > **Already have `mem0` configured as an MCP server?** Remove the existing entry from your Cursor MCP settings before installing to avoid duplicate tools.
@@ -86,15 +145,17 @@ After installing, confirm the MCP server is connected:
 
 ## What's included
 
-| Component | Claude Code / Cowork | Cursor (Marketplace) | Cursor (Deeplink/Manual) |
-|-----------|:--------------------:|:--------------------:|:------------------------:|
-| MCP Server | Yes | Yes | Yes |
-| Lifecycle Hooks | Yes | Yes | No |
-| Mem0 SDK Skill | Yes | Yes | No |
+| Component | Claude Code / Cowork | Cursor (Marketplace) | Cursor (Deeplink/Manual) | Codex |
+|-----------|:--------------------:|:--------------------:|:------------------------:|:-----:|
+| MCP Server | Yes | Yes | Yes | Yes |
+| Lifecycle Hooks | Yes | Yes | No | No |
+| Mem0 SDK Skill | Yes | Yes | No | Yes |
+| Memory Protocol Skill | No | No | No | Yes |
 
 - **MCP Server** — Connects to the Mem0 remote MCP server (`mcp.mem0.ai`), providing tools to add, search, update, and delete memories. No local dependencies required.
-- **Lifecycle Hooks** — Automatic memory capture at key points: session start, context compaction, task completion, and session end.
+- **Lifecycle Hooks** — Automatic memory capture at key points: session start, context compaction, task completion, and session end. (Claude Code/Cursor only)
 - **Mem0 SDK Skill** — Guides the AI on how to integrate the Mem0 SDK (Python & TypeScript) into your applications.
+- **Memory Protocol Skill** — Codex-specific skill that instructs the agent to retrieve relevant memories at task start, store learnings on completion, and capture session state before context loss. Replaces lifecycle hooks on platforms that don't support them.
 
 ## MCP Tools
 

mem0-plugin/skills/mem0-codex/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: mem0-codex
+description: >
+  Mem0 persistent memory integration for Codex. Automatically retrieve relevant
+  memories at the start of each task, store key learnings when tasks complete,
+  and capture session state before context is lost. Use the mem0 MCP tools
+  (add_memory, search_memories, get_memories, etc.) for all memory operations.
+---
+
+# Mem0 Memory Protocol for Codex
+
+You have access to persistent memory via the mem0 MCP tools. Follow this protocol to maintain context across sessions.
+
+## On every new task
+
+1. Call `search_memories` with a query related to the current task or project to load relevant context.
+2. Review returned memories to understand what has been learned in prior sessions.
+3. If appropriate, call `get_memories` to browse all stored memories for this user.
+
+## After completing significant work
+
+Extract key learnings and store them using the `add_memory` tool:
+
+- **Decisions made** -> Include metadata `{"type": "decision"}`
+- **Strategies that worked** -> Include metadata `{"type": "task_learning"}`
+- **Failed approaches** -> Include metadata `{"type": "anti_pattern"}`
+- **User preferences observed** -> Include metadata `{"type": "user_preference"}`
+- **Environment/setup discoveries** -> Include metadata `{"type": "environmental"}`
+- **Conventions established** -> Include metadata `{"type": "convention"}`
+
+Memories can be as detailed as needed -- include full context, reasoning, code snippets, file paths, and examples. Longer, searchable memories are more valuable than vague one-liners.
+
+## Before losing context
+
+If context is about to be compacted or the session is ending, store a comprehensive session summary:
+
+```
+## Session Summary
+
+### User's Goal
+[What the user originally asked for]
+
+### What Was Accomplished
+[Numbered list of tasks completed]
+
+### Key Decisions Made
+[Architectural choices, trade-offs discussed]
+
+### Files Created or Modified
+[Important file paths with what changed]
+
+### Current State
+[What is in progress, pending items, next steps]
+```
+
+Include metadata: `{"type": "session_state"}`
+
+## Memory hygiene
+
+- Do NOT write to MEMORY.md or any file-based memory. Use mem0 MCP tools exclusively.
+- Only store genuinely useful learnings. Skip trivial interactions.
+- Use specific, searchable language in memory content.

mem0-ts/package.json

@@ -68,6 +68,11 @@
       "!src/community/**"
     ]
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mem0ai/mem0",
+    "directory": "mem0-ts"
+  },
   "keywords": [
     "mem0",
     "api",

mem0-ts/src/client/mem0.types.ts

@@ -167,6 +167,7 @@ export interface PromptUpdatePayload {
   exclusion_prompt?: string;
   memory_depth?: string | null;
   usecase_setting?: string | number;
+  multilingual?: boolean;
   [key: string]: any;
 }
 

mem0/client/main.py

@@ -676,6 +676,7 @@ class MemoryClient:
         exclusion_prompt: Optional[str] = None,
         memory_depth: Optional[str] = None,
         usecase_setting: Optional[str] = None,
+        multilingual: Optional[bool] = None,
     ) -> Dict[str, Any]:
         """Update the project settings.
 
@@ -689,6 +690,7 @@ class MemoryClient:
             exclusion_prompt: Exclusion prompt for the project
             memory_depth: Memory depth for the project
             usecase_setting: Usecase setting for the project
+            multilingual: Whether to use the input language for memory storage and retrieval
 
         Returns:
             Dictionary containing the API response.
@@ -718,6 +720,7 @@ class MemoryClient:
             and exclusion_prompt is None
             and memory_depth is None
             and usecase_setting is None
+            and multilingual is None
         ):
             raise ValueError(
                 "Currently we only support updating custom_instructions or "
@@ -736,6 +739,7 @@ class MemoryClient:
                 "exclusion_prompt": exclusion_prompt,
                 "memory_depth": memory_depth,
                 "usecase_setting": usecase_setting,
+                "multilingual": multilingual,
             }
         )
         response = self.client.patch(
@@ -756,6 +760,7 @@ class MemoryClient:
                 "exclusion_prompt": exclusion_prompt,
                 "memory_depth": memory_depth,
                 "usecase_setting": usecase_setting,
+                "multilingual": multilingual,
                 "sync_type": "sync",
             },
         )
@@ -1554,6 +1559,7 @@ class AsyncMemoryClient:
         retrieval_criteria: Optional[List[Dict[str, Any]]] = None,
         enable_graph: Optional[bool] = None,
         version: Optional[str] = None,
+        multilingual: Optional[bool] = None,
     ) -> Dict[str, Any]:
         """Update the project settings.
 
@@ -1563,6 +1569,7 @@ class AsyncMemoryClient:
             retrieval_criteria: New retrieval criteria for the project
             enable_graph: Enable or disable the graph for the project
             version: Version of the project
+            multilingual: Whether to use the input language for memory storage and retrieval
 
         Returns:
             Dictionary containing the API response.
@@ -1588,6 +1595,7 @@ class AsyncMemoryClient:
             and retrieval_criteria is None
             and enable_graph is None
             and version is None
+            and multilingual is None
         ):
             raise ValueError(
                 "Currently we only support updating custom_instructions or custom_categories or retrieval_criteria, so you must provide at least one of them"
@@ -1600,6 +1608,7 @@ class AsyncMemoryClient:
                 "retrieval_criteria": retrieval_criteria,
                 "enable_graph": enable_graph,
                 "version": version,
+                "multilingual": multilingual,
             }
         )
         response = await self.async_client.patch(
@@ -1616,6 +1625,7 @@ class AsyncMemoryClient:
                 "retrieval_criteria": retrieval_criteria,
                 "enable_graph": enable_graph,
                 "version": version,
+                "multilingual": multilingual,
                 "sync_type": "async",
             },
         )

mem0/client/project.py

@@ -399,6 +399,7 @@ class Project(BaseProject):
         custom_categories: Optional[List[str]] = None,
         retrieval_criteria: Optional[List[Dict[str, Any]]] = None,
         enable_graph: Optional[bool] = None,
+        multilingual: Optional[bool] = None,
     ) -> Dict[str, Any]:
         """
         Update project settings.
@@ -408,6 +409,7 @@ class Project(BaseProject):
             custom_categories: New categories for the project
             retrieval_criteria: New retrieval criteria for the project
             enable_graph: Enable or disable the graph for the project
+            multilingual: Whether to use the input language for memory storage and retrieval
 
         Returns:
             Dictionary containing the API response.
@@ -424,11 +426,12 @@ class Project(BaseProject):
             and custom_categories is None
             and retrieval_criteria is None
             and enable_graph is None
+            and multilingual is None
         ):
             raise ValueError(
                 "At least one parameter must be provided for update: "
                 "custom_instructions, custom_categories, retrieval_criteria, "
-                "enable_graph"
+                "enable_graph, multilingual"
             )
 
         payload = self._prepare_params(
@@ -437,6 +440,7 @@ class Project(BaseProject):
                 "custom_categories": custom_categories,
                 "retrieval_criteria": retrieval_criteria,
                 "enable_graph": enable_graph,
+                "multilingual": multilingual,
             }
         )
         response = self._client.patch(
@@ -452,6 +456,7 @@ class Project(BaseProject):
                 "custom_categories": custom_categories,
                 "retrieval_criteria": retrieval_criteria,
                 "enable_graph": enable_graph,
+                "multilingual": multilingual,
                 "sync_type": "sync",
             },
         )
@@ -716,6 +721,7 @@ class AsyncProject(BaseProject):
         custom_categories: Optional[List[str]] = None,
         retrieval_criteria: Optional[List[Dict[str, Any]]] = None,
         enable_graph: Optional[bool] = None,
+        multilingual: Optional[bool] = None,
     ) -> Dict[str, Any]:
         """
         Update project settings.
@@ -725,6 +731,7 @@ class AsyncProject(BaseProject):
             custom_categories: New categories for the project
             retrieval_criteria: New retrieval criteria for the project
             enable_graph: Enable or disable the graph for the project
+            multilingual: Whether to use the input language for memory storage and retrieval
 
         Returns:
             Dictionary containing the API response.
@@ -741,11 +748,12 @@ class AsyncProject(BaseProject):
             and custom_categories is None
             and retrieval_criteria is None
             and enable_graph is None
+            and multilingual is None
         ):
             raise ValueError(
                 "At least one parameter must be provided for update: "
                 "custom_instructions, custom_categories, retrieval_criteria, "
-                "enable_graph"
+                "enable_graph, multilingual"
             )
 
         payload = self._prepare_params(
@@ -754,6 +762,7 @@ class AsyncProject(BaseProject):
                 "custom_categories": custom_categories,
                 "retrieval_criteria": retrieval_criteria,
                 "enable_graph": enable_graph,
+                "multilingual": multilingual,
             }
         )
         response = await self._client.patch(
@@ -769,6 +778,7 @@ class AsyncProject(BaseProject):
                 "custom_categories": custom_categories,
                 "retrieval_criteria": retrieval_criteria,
                 "enable_graph": enable_graph,
+                "multilingual": multilingual,
                 "sync_type": "async",
             },
         )

mem0/configs/vector_stores/elasticsearch.py

@@ -1,7 +1,7 @@
 from collections.abc import Callable
 from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 
 class ElasticsearchConfig(BaseModel):
@@ -63,3 +63,5 @@ class ElasticsearchConfig(BaseModel):
                 f"Please input only the following fields: {', '.join(allowed_fields)}"
             )
         return values
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)

mem0/configs/vector_stores/mongodb.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict, Optional
 
-from pydantic import BaseModel, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 
 class MongoDBConfig(BaseModel):
@@ -23,3 +23,5 @@ class MongoDBConfig(BaseModel):
                 f"Please provide only the following fields: {', '.join(allowed_fields)}."
             )
         return values
+
+    model_config = ConfigDict(arbitrary_types_allowed=False)

mem0/configs/vector_stores/neptune.py

@@ -5,7 +5,7 @@ This module provides configuration settings for integrating with Amazon Neptune
 as a vector store backend for Mem0's memory layer.
 """
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class NeptuneAnalyticsConfig(BaseModel):
@@ -22,6 +22,4 @@ class NeptuneAnalyticsConfig(BaseModel):
     collection_name: str = Field("mem0", description="Default name for the collection")
     endpoint: str = Field("endpoint", description="Graph ID for the runtime")
 
-    model_config = {
-        "arbitrary_types_allowed": False,
-    }
+    model_config = ConfigDict(arbitrary_types_allowed=False)

mem0/configs/vector_stores/opensearch.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict, Optional, Type, Union
 
-from pydantic import BaseModel, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 
 class OpenSearchConfig(BaseModel):
@@ -39,3 +39,5 @@ class OpenSearchConfig(BaseModel):
                 f"Extra fields not allowed: {', '.join(extra_fields)}. Allowed fields: {', '.join(allowed_fields)}"
             )
         return values
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)

mem0/configs/vector_stores/pgvector.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict, Optional
 
-from pydantic import BaseModel, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 
 class PGVectorConfig(BaseModel):
@@ -50,3 +50,5 @@ class PGVectorConfig(BaseModel):
                 f"Extra fields not allowed: {', '.join(extra_fields)}. Please input only the following fields: {', '.join(allowed_fields)}"
             )
         return values
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)

mem0/configs/vector_stores/supabase.py

@@ -1,7 +1,7 @@
 from enum import Enum
 from typing import Any, Dict, Optional
 
-from pydantic import BaseModel, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 
 class IndexMethod(str, Enum):
@@ -42,3 +42,5 @@ class SupabaseConfig(BaseModel):
                 f"Extra fields not allowed: {', '.join(extra_fields)}. Please input only the following fields: {', '.join(allowed_fields)}"
             )
         return values
+
+    model_config = ConfigDict(arbitrary_types_allowed=False)

mem0/configs/vector_stores/valkey.py

@@ -1,15 +1,31 @@
-from pydantic import BaseModel
+from typing import Any, Dict
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 
 class ValkeyConfig(BaseModel):
     """Configuration for Valkey vector store."""
 
-    valkey_url: str
-    collection_name: str
-    embedding_model_dims: int
-    timezone: str = "UTC"
-    index_type: str = "hnsw"  # Default to HNSW, can be 'hnsw' or 'flat'
-    # HNSW specific parameters with recommended defaults
-    hnsw_m: int = 16  # Number of connections per layer (default from Valkey docs)
-    hnsw_ef_construction: int = 200  # Search width during construction
-    hnsw_ef_runtime: int = 10  # Search width during queries
+    valkey_url: str = Field(..., description="Valkey server URL (e.g., redis://localhost:6379)")
+    collection_name: str = Field(..., description="Name of the index / collection")
+    embedding_model_dims: int = Field(..., description="Dimensions of the embedding model")
+    timezone: str = Field("UTC", description="Timezone for timestamp handling")
+    index_type: str = Field("hnsw", description="Index type: 'hnsw' (default) or 'flat'")
+    hnsw_m: int = Field(16, description="HNSW: number of connections per layer")
+    hnsw_ef_construction: int = Field(200, description="HNSW: search width during index construction")
+    hnsw_ef_runtime: int = Field(10, description="HNSW: search width during queries")
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_extra_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        allowed_fields = set(cls.model_fields.keys())
+        input_fields = set(values.keys())
+        extra_fields = input_fields - allowed_fields
+        if extra_fields:
+            raise ValueError(
+                f"Extra fields not allowed: {', '.join(extra_fields)}. "
+                f"Please input only the following fields: {', '.join(allowed_fields)}"
+            )
+        return values
+
+    model_config = ConfigDict(arbitrary_types_allowed=False)

mem0/vector_stores/qdrant.py

@@ -1,8 +1,10 @@
 import logging
+import re
 from typing import Optional
 
 from qdrant_client import QdrantClient
 from qdrant_client.models import (
+    DatetimeRange,
     Distance,
     FieldCondition,
     Filter,
@@ -139,6 +141,23 @@ class Qdrant(VectorStoreBase):
         ]
         self.client.upsert(collection_name=self.collection_name, points=points)
 
+    # ISO 8601 datetime pattern for detecting datetime strings in range filters
+    _ISO_DATETIME_RE = re.compile(
+        r"^\d{4}-\d{2}-\d{2}"  # date part
+        r"([T ]\d{2}:\d{2}(:\d{2})?"  # optional time part
+        r"(\.\d+)?"  # optional fractional seconds
+        r"(Z|[+-]\d{2}:?\d{2})?"  # optional timezone
+        r")?$"
+    )
+
+    @staticmethod
+    def _is_datetime_range(range_kwargs: dict) -> bool:
+        """Check if all values in range kwargs are ISO datetime strings."""
+        return all(
+            isinstance(v, str) and Qdrant._ISO_DATETIME_RE.match(v)
+            for v in range_kwargs.values()
+        )
+
     def _build_field_condition(self, key: str, value) -> Optional[FieldCondition]:
         """
         Build a single FieldCondition from a key-value filter pair.
@@ -177,6 +196,13 @@ class Qdrant(VectorStoreBase):
                     f"Use AND to combine them as separate conditions."
                 )
             range_kwargs = {op: value[op] for op in range_ops if op in value}
+            if self._is_datetime_range(range_kwargs):
+                try:
+                    return FieldCondition(key=key, range=DatetimeRange(**range_kwargs))
+                except (ValueError, TypeError) as e:
+                    raise ValueError(
+                        f"Invalid datetime value in range filter for field '{key}': {e}"
+                    ) from e
             return FieldCondition(key=key, range=Range(**range_kwargs))
         elif "eq" in value:
             return FieldCondition(key=key, match=MatchValue(value=value["eq"]))

openclaw/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 All notable changes to the `@mem0/openclaw-mem0` plugin will be documented in this file.
 
+## [1.0.3] - 2026-04-03
+
+### Fixed
+- **Path traversal vulnerability**: Added `safePath()` containment helper to `readSkillFile` and `readDomainOverlay` in `skill-loader.ts` — prevents directory traversal via `config.domain` or the exported `loadSkill` API
+- **Noise filter regression**: Reverted incorrect `After-Compaction` regex rename back to `Post-Compaction` so the filter correctly matches real upstream compaction audit messages
+- **Cosmetic revert**: Restored `// Over-fetch for ranking` comment in `recall.ts` (was changed to work around a false-positive scanner match on the substring `fetch`)
+
+### Changed
+- **Supply-chain hardening**: Pinned `mem0ai` dependency to exact `2.3.0` (was `^2.3.0`)
+
+### Added
+- **Path traversal tests**: 12 new tests covering `safePath`, `readSkillFile`, `readDomainOverlay`, and `loadSkill` with traversal inputs
+
+## [1.0.2] - 2026-04-02
+
+### Fixed
+- **Security scanner warning**: Removed `resolveEnvVars()` and `resolveEnvVarsDeep()` from `config.ts` — OpenClaw already resolves `${VAR}` in `openclaw.json` before passing config to the plugin, so plugin-side env resolution was redundant and triggered the "credential harvesting" static analysis warning ([#4676](https://github.com/mem0ai/mem0/pull/4676))
+
+## [1.0.1] - 2026-04-02
+
+### Added
+- **CD workflow**: Added continuous deployment workflow for `@mem0/openclaw-mem0` with OIDC trusted publishing ([#4672](https://github.com/mem0ai/mem0/pull/4672))
+- **Plugin configuration manifest**: Added `compat` and `build` metadata to `package.json` specifying minimum gateway version and OpenClaw SDK compatibility (`>=2026.3.24-beta.2`) ([#4667](https://github.com/mem0ai/mem0/pull/4667))
+- **LICENSE**: Added Apache-2.0 license file to the package ([#4667](https://github.com/mem0ai/mem0/pull/4667))
+
+### Fixed
+- **Dream gate correctness**: Fixed cheap-first ordering, session isolation, and verified completion in the dream gate memory consolidation pipeline ([#4666](https://github.com/mem0ai/mem0/pull/4666))
+- **Graceful startup without API key**: Plugin now starts gracefully when no API key is configured instead of crashing on init ([#4669](https://github.com/mem0ai/mem0/pull/4669))
+
 ## [1.0.0] - 2026-04-01
 
 ### Added

openclaw/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2023] [Taranjeet Singh]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

openclaw/config.ts

@@ -4,33 +4,10 @@
 
 import type { Mem0Config, Mem0Mode } from "./types.ts";
 
-// ============================================================================
-// Env Var Resolution
-// ============================================================================
-
-function resolveEnvVars(value: string): string {
-  return value.replace(/\$\{([^}]+)\}/g, (_, envVar) => {
-    const envValue = process.env[envVar];
-    if (!envValue) {
-      throw new Error(`Environment variable ${envVar} is not set`);
-    }
-    return envValue;
-  });
-}
-
-function resolveEnvVarsDeep(obj: Record<string, unknown>): Record<string, unknown> {
-  const result: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (typeof value === "string") {
-      result[key] = resolveEnvVars(value);
-    } else if (value && typeof value === "object" && !Array.isArray(value)) {
-      result[key] = resolveEnvVarsDeep(value as Record<string, unknown>);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
+// NOTE: No process.env access in this module. OpenClaw resolves ${VAR}
+// syntax in openclaw.json before passing pluginConfig to register().
+// Plugin-side env var resolution was removed to clear OpenClaw's
+// security scanner warning ("credential harvesting" pattern).
 
 // ============================================================================
 // Default Custom Instructions & Categories
@@ -200,18 +177,16 @@ export const mem0ConfigSchema = {
     // The plugin should register successfully and log a setup message.
     const needsSetup = mode === "platform" && (typeof cfg.apiKey !== "string" || !cfg.apiKey);
 
-    // Resolve env vars in oss config
+    // OpenClaw resolves ${VAR} in pluginConfig before register() — no plugin-side expansion needed
     let ossConfig: Mem0Config["oss"];
     if (cfg.oss && typeof cfg.oss === "object" && !Array.isArray(cfg.oss)) {
-      ossConfig = resolveEnvVarsDeep(
-        cfg.oss as Record<string, unknown>,
-      ) as unknown as Mem0Config["oss"];
+      ossConfig = cfg.oss as Mem0Config["oss"];
     }
 
     return {
       mode,
       apiKey:
-        typeof cfg.apiKey === "string" ? resolveEnvVars(cfg.apiKey) : undefined,
+        typeof cfg.apiKey === "string" ? cfg.apiKey : undefined,
       userId:
         typeof cfg.userId === "string" && cfg.userId ? cfg.userId : "default",
       orgId: typeof cfg.orgId === "string" ? cfg.orgId : undefined,

openclaw/index.ts

@@ -95,8 +95,6 @@ const memoryPlugin = {
   register(api: OpenClawPluginApi) {
     const cfg = mem0ConfigSchema.parse(api.pluginConfig);
 
-    // If API key is missing, register successfully but skip all memory operations.
-    // This prevents install from failing and gives the user a clear setup message.
     if (cfg.needsSetup) {
       api.logger.warn(
         "openclaw-mem0: API key not configured. Memory features are disabled.\n" +

openclaw/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@mem0/openclaw-mem0",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "type": "module",
   "description": "Mem0 memory backend for OpenClaw — platform or self-hosted open-source",
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mem0ai/mem0",
+    "directory": "openclaw"
+  },
   "keywords": [
     "openclaw",
     "plugin",
@@ -21,7 +26,8 @@
   },
   "files": [
     "dist",
-    "openclaw.plugin.json"
+    "openclaw.plugin.json",
+    "skills"
   ],
   "scripts": {
     "build": "tsup",
@@ -29,12 +35,20 @@
   },
   "dependencies": {
     "@sinclair/typebox": "0.34.47",
-    "mem0ai": "^2.3.0"
+    "mem0ai": "2.3.0"
   },
   "openclaw": {
     "extensions": [
       "./dist/index.js"
-    ]
+    ],
+    "compat": {
+      "pluginApi": ">=2026.3.24-beta.2",
+      "minGatewayVersion": "2026.3.24-beta.2"
+    },
+    "build": {
+      "openclawVersion": "2026.3.24-beta.2",
+      "pluginSdkVersion": "2026.3.24-beta.2"
+    }
   },
   "devDependencies": {
     "@types/node": "^22.15.0",

openclaw/pnpm-lock.yaml

@@ -12,8 +12,8 @@ importers:
         specifier: 0.34.47
         version: 0.34.47
       mem0ai:
-        specifier: ^2.3.0
-        version: 2.4.0(@anthropic-ai/sdk@0.40.1)(@azure/identity@4.13.0)(@azure/search-documents@12.2.0)(@cloudflare/workers-types@4.20260313.1)(@google/genai@1.45.0)(@langchain/core@0.3.80(openai@4.104.0(ws@8.19.0)(zod@3.25.76)))(@mistralai/mistralai@1.15.1)(@qdrant/js-client-rest@1.13.0(typescript@5.9.3))(@supabase/supabase-js@2.99.1)(@types/jest@29.5.14)(@types/pg@8.11.0)(better-sqlite3@12.8.0)(cloudflare@4.5.0)(groq-sdk@0.3.0)(neo4j-driver@5.28.3)(ollama@0.5.18)(pg@8.11.3)(redis@4.7.1)(ws@8.19.0)
+        specifier: 2.3.0
+        version: 2.3.0(@anthropic-ai/sdk@0.40.1)(@azure/identity@4.13.0)(@azure/search-documents@12.2.0)(@cloudflare/workers-types@4.20260313.1)(@google/genai@1.45.0)(@langchain/core@0.3.80(openai@4.104.0(ws@8.19.0)(zod@3.25.76)))(@mistralai/mistralai@1.15.1)(@qdrant/js-client-rest@1.13.0(typescript@5.9.3))(@supabase/supabase-js@2.99.1)(@types/jest@29.5.14)(@types/pg@8.11.0)(better-sqlite3@12.8.0)(cloudflare@4.5.0)(groq-sdk@0.3.0)(neo4j-driver@5.28.3)(ollama@0.5.18)(pg@8.11.3)(redis@4.7.1)(ws@8.19.0)
     devDependencies:
       '@types/node':
         specifier: ^22.15.0
@@ -1466,8 +1466,8 @@ packages:
   md5@2.3.0:
     resolution: {integrity: sha512-T1GITYmFaKuO91vxyoQMFETst+O71VUPEU3ze5GNzDm0OWdP8v1ziTaAEPUr/3kLsY3Sftgz242A1SetQiDL7g==}
 
-  mem0ai@2.4.0:
-    resolution: {integrity: sha512-b1V8KXUse8ySvio8D0bRHOvgxa9BlmP4g4bjtEnA3uILcu+2PAtcAiHDPdBxUIeoxTxAeJM+0wBGaMIps4bIaw==}
+  mem0ai@2.3.0:
+    resolution: {integrity: sha512-9e0B9hgM7nxnKDD6zmSRkfkrQ2sa9tGdpZE3CPsp7eIu18soYbXvm9YT08mllCYuiW+EdEW7L/+DNCphOfvkKQ==}
     engines: {node: '>=18'}
     peerDependencies:
       '@anthropic-ai/sdk': ^0.40.1
@@ -3543,7 +3543,7 @@ snapshots:
       crypt: 0.0.2
       is-buffer: 1.1.6
 
-  mem0ai@2.4.0(@anthropic-ai/sdk@0.40.1)(@azure/identity@4.13.0)(@azure/search-documents@12.2.0)(@cloudflare/workers-types@4.20260313.1)(@google/genai@1.45.0)(@langchain/core@0.3.80(openai@4.104.0(ws@8.19.0)(zod@3.25.76)))(@mistralai/mistralai@1.15.1)(@qdrant/js-client-rest@1.13.0(typescript@5.9.3))(@supabase/supabase-js@2.99.1)(@types/jest@29.5.14)(@types/pg@8.11.0)(better-sqlite3@12.8.0)(cloudflare@4.5.0)(groq-sdk@0.3.0)(neo4j-driver@5.28.3)(ollama@0.5.18)(pg@8.11.3)(redis@4.7.1)(ws@8.19.0):
+  mem0ai@2.3.0(@anthropic-ai/sdk@0.40.1)(@azure/identity@4.13.0)(@azure/search-documents@12.2.0)(@cloudflare/workers-types@4.20260313.1)(@google/genai@1.45.0)(@langchain/core@0.3.80(openai@4.104.0(ws@8.19.0)(zod@3.25.76)))(@mistralai/mistralai@1.15.1)(@qdrant/js-client-rest@1.13.0(typescript@5.9.3))(@supabase/supabase-js@2.99.1)(@types/jest@29.5.14)(@types/pg@8.11.0)(better-sqlite3@12.8.0)(cloudflare@4.5.0)(groq-sdk@0.3.0)(neo4j-driver@5.28.3)(ollama@0.5.18)(pg@8.11.3)(redis@4.7.1)(ws@8.19.0):
     dependencies:
       '@anthropic-ai/sdk': 0.40.1
       '@azure/identity': 4.13.0

openclaw/skill-loader.test.ts

@@ -0,0 +1,70 @@
+/**
+ * Tests for path traversal prevention in skill-loader.
+ */
+import { describe, it, expect } from "vitest";
+import { safePath, loadSkill } from "./skill-loader.ts";
+
+// ---------------------------------------------------------------------------
+// safePath — path containment
+// ---------------------------------------------------------------------------
+describe("safePath", () => {
+  it("rejects parent directory traversal", () => {
+    expect(safePath("../../etc/passwd")).toBeNull();
+  });
+
+  it("rejects deep traversal", () => {
+    expect(safePath("../../../etc/shadow")).toBeNull();
+  });
+
+  it("rejects traversal in nested segment", () => {
+    expect(safePath("valid", "../../etc")).toBeNull();
+  });
+
+  it("rejects bare '..' as segment", () => {
+    expect(safePath("..")).toBeNull();
+  });
+
+  it("accepts valid skill paths", () => {
+    expect(safePath("memory-triage", "SKILL.md")).not.toBeNull();
+  });
+
+  it("accepts valid domain overlay paths", () => {
+    expect(safePath("memory-triage", "domains", "companion.md")).not.toBeNull();
+  });
+
+  it("returns null for empty segments that resolve to skills root with subpath escape", () => {
+    // path.resolve("skills", "", "../../etc") still escapes
+    expect(safePath("", "../../etc")).toBeNull();
+  });
+
+  it("rejects traversal disguised with valid prefix", () => {
+    expect(safePath("memory-triage/../../etc/passwd")).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// loadSkill — integration tests for traversal prevention
+// ---------------------------------------------------------------------------
+describe("loadSkill path traversal", () => {
+  it("returns null for traversal skillName", () => {
+    expect(loadSkill("../../etc/passwd")).toBeNull();
+  });
+
+  it("returns null for deep traversal skillName", () => {
+    expect(loadSkill("../../../..")).toBeNull();
+  });
+
+  it("loads a valid skill", () => {
+    const result = loadSkill("memory-triage");
+    expect(result).not.toBeNull();
+    expect(result?.prompt).toBeTruthy();
+  });
+
+  it("blocks domain traversal while loading valid skill", () => {
+    // Valid skill name, malicious domain — should load skill but skip the overlay
+    const result = loadSkill("memory-triage", { domain: "../../etc/passwd" });
+    // Should still succeed (skill itself is valid), domain overlay is just skipped
+    expect(result).not.toBeNull();
+    expect(result?.prompt).toBeTruthy();
+  });
+});

openclaw/skill-loader.ts

@@ -110,10 +110,26 @@ function resolveSkillsDir(): string {
 }
 
 const SKILLS_DIR = resolveSkillsDir();
+const RESOLVED_SKILLS_DIR = path.resolve(SKILLS_DIR);
+
+/**
+ * Resolve path segments under SKILLS_DIR and verify the result doesn't escape.
+ * Returns null if the resolved path is outside the skills directory (path traversal).
+ * Note: path.resolve follows symlinks lexically; the skills directory is
+ * package-owned so symlink escape is not a practical concern.
+ */
+export function safePath(...segments: string[]): string | null {
+  const resolved = path.resolve(SKILLS_DIR, ...segments);
+  if (resolved !== RESOLVED_SKILLS_DIR &&
+      !resolved.startsWith(RESOLVED_SKILLS_DIR + path.sep)) {
+    return null;
+  }
+  return resolved;
+}
 
 function readSkillFile(skillName: string): string | null {
-  // Skills use OpenClaw directory format: <skill-name>/SKILL.md
-  const filePath = path.join(SKILLS_DIR, skillName, "SKILL.md");
+  const filePath = safePath(skillName, "SKILL.md");
+  if (!filePath) return null;
   try {
     return fs.readFileSync(filePath, "utf-8");
   } catch {
@@ -127,8 +143,8 @@ function readSkillFile(skillName: string): string | null {
  * The `applies_to` frontmatter field is checked for backward compatibility.
  */
 function readDomainOverlay(domain: string, targetSkill: string): string | null {
-  // Domain overlays are stored inside the target skill's directory
-  const filePath = path.join(SKILLS_DIR, targetSkill, "domains", `${domain}.md`);
+  const filePath = safePath(targetSkill, "domains", `${domain}.md`);
+  if (!filePath) return null;
   try {
     const content = fs.readFileSync(filePath, "utf-8");
     const parsed = parseSkillFile(content);

server/main.py

@@ -124,6 +124,11 @@ class MemoryCreate(BaseModel):
     prompt: Optional[str] = Field(None, description="Custom prompt to use for fact extraction.")
 
 
+class MemoryUpdate(BaseModel):
+    text: str = Field(..., description="New content to update the memory with.")
+    metadata: Optional[Dict[str, Any]] = Field(None, description="Metadata to update.")
+
+
 class SearchRequest(BaseModel):
     query: str = Field(..., description="Search query.")
     user_id: Optional[str] = None
@@ -199,18 +204,18 @@ def search_memories(search_req: SearchRequest, _api_key: Optional[str] = Depends
 
 
 @app.put("/memories/{memory_id}", summary="Update a memory")
-def update_memory(memory_id: str, updated_memory: Dict[str, Any], _api_key: Optional[str] = Depends(verify_api_key)):
+def update_memory(memory_id: str, updated_memory: MemoryUpdate, _api_key: Optional[str] = Depends(verify_api_key)):
     """Update an existing memory with new content.
-    
+
     Args:
         memory_id (str): ID of the memory to update
-        updated_memory (str): New content to update the memory with
-        
+        updated_memory (MemoryUpdate): New content and optional metadata to update the memory with
+
     Returns:
         dict: Success message indicating the memory was updated
     """
     try:
-        return MEMORY_INSTANCE.update(memory_id=memory_id, data=updated_memory)
+        return MEMORY_INSTANCE.update(memory_id=memory_id, data=updated_memory.text, metadata=updated_memory.metadata)
     except Exception as e:
         logging.exception("Error in update_memory:")
         raise HTTPException(status_code=500, detail=str(e))

tests/test_server_auth.py

@@ -94,7 +94,7 @@ class TestAuthDisabled:
         assert resp.status_code == 200
 
     def test_update_memory_without_key(self):
-        resp = self.client.put("/memories/mem-1", json={"data": "updated"})
+        resp = self.client.put("/memories/mem-1", json={"text": "updated"})
         assert resp.status_code == 200
 
     def test_history_without_key(self):
@@ -276,7 +276,7 @@ class TestAuthEnabled:
         assert resp.status_code == 200
 
     def test_update_memory_with_key(self):
-        resp = self._authed("PUT", "/memories/mem-1", json={"data": "updated"})
+        resp = self._authed("PUT", "/memories/mem-1", json={"text": "updated"})
         assert resp.status_code == 200
 
     def test_history_with_key(self):
@@ -346,7 +346,7 @@ class TestAuthenticatedCRUDFlow:
         self.mock.search.assert_called_once()
 
         # 5. Update
-        resp = self._authed("PUT", "/memories/mem-1", json={"data": "updated content"})
+        resp = self._authed("PUT", "/memories/mem-1", json={"text": "updated content"})
         assert resp.status_code == 200
         self.mock.update.assert_called_once()
 

tests/test_server_params.py

@@ -505,3 +505,59 @@ class TestCallSignatureMatch:
         assert resp.status_code == 200
         _, kwargs = mock_memory.search.call_args
         assert kwargs["query"] == "food"
+
+
+# ===========================================================================
+# MemoryUpdate: text and metadata forwarding (fix for #3933)
+# ===========================================================================
+
+class TestUpdateMemory:
+    """Verify that PUT /memories/{id} extracts text and metadata from the
+    request body and forwards them correctly to Memory.update()."""
+
+    def test_text_forwarded_as_data(self, client, mock_memory):
+        resp = client.put("/memories/mem-1", json={"text": "Likes tennis"})
+        assert resp.status_code == 200
+        _, kwargs = mock_memory.update.call_args
+        assert kwargs["data"] == "Likes tennis"
+
+    def test_metadata_forwarded(self, client, mock_memory):
+        resp = client.put("/memories/mem-1", json={
+            "text": "Likes tennis",
+            "metadata": {"category": "sports"},
+        })
+        assert resp.status_code == 200
+        _, kwargs = mock_memory.update.call_args
+        assert kwargs["metadata"] == {"category": "sports"}
+
+    def test_metadata_omitted_passes_none(self, client, mock_memory):
+        resp = client.put("/memories/mem-1", json={"text": "Likes tennis"})
+        assert resp.status_code == 200
+        _, kwargs = mock_memory.update.call_args
+        assert kwargs["metadata"] is None
+
+    def test_missing_text_returns_422(self, client):
+        """text is required — omitting it should fail validation."""
+        resp = client.put("/memories/mem-1", json={"metadata": {"k": "v"}})
+        assert resp.status_code == 422
+
+    def test_dict_not_passed_as_data(self, client, mock_memory):
+        """Regression test for #3933: the entire dict must NOT be passed as data."""
+        resp = client.put("/memories/mem-1", json={"text": "updated content"})
+        assert resp.status_code == 200
+        _, kwargs = mock_memory.update.call_args
+        assert isinstance(kwargs["data"], str)
+
+
+class TestUpdateOpenAPISchema:
+    """Verify the MemoryUpdate schema appears in the OpenAPI docs."""
+
+    def test_update_schema_includes_text(self, client):
+        schema = client.get("/openapi.json").json()
+        update_props = schema["components"]["schemas"]["MemoryUpdate"]["properties"]
+        assert "text" in update_props
+
+    def test_update_schema_includes_metadata(self, client):
+        schema = client.get("/openapi.json").json()
+        update_props = schema["components"]["schemas"]["MemoryUpdate"]["properties"]
+        assert "metadata" in update_props

tests/vector_stores/test_qdrant.py

@@ -6,6 +6,7 @@ from unittest.mock import MagicMock, patch
 
 from qdrant_client import QdrantClient
 from qdrant_client.models import (
+    DatetimeRange,
     Distance,
     FieldCondition,
     Filter,
@@ -814,3 +815,111 @@ class TestQdrantEnhancedFilters(unittest.TestCase):
         self.assertIsNotNone(result.must_not)
         # Deduplicated: NOT wins, $not is skipped — exactly 1 entry
         self.assertEqual(len(result.must_not), 1)
+
+
+class TestQdrantDatetimeRangeFilters(unittest.TestCase):
+    """Tests for datetime range filter support (issue #4591)."""
+
+    def setUp(self):
+        self.client_mock = MagicMock(spec=QdrantClient)
+        self.qdrant = Qdrant(
+            collection_name="test_collection",
+            embedding_model_dims=128,
+            client=self.client_mock,
+        )
+
+    def test_iso_datetime_gte_lte_uses_datetime_range(self):
+        """ISO datetime strings in range filters should use DatetimeRange."""
+        cond = self.qdrant._build_field_condition(
+            "created_at", {"gte": "2025-01-01T00:00:00Z", "lte": "2025-12-31T23:59:59Z"}
+        )
+        self.assertIsInstance(cond, FieldCondition)
+        self.assertIsInstance(cond.range, DatetimeRange)
+        self.assertIsNotNone(cond.range.gte)
+        self.assertIsNotNone(cond.range.lte)
+
+    def test_iso_date_only_uses_datetime_range(self):
+        """Date-only strings (YYYY-MM-DD) should also use DatetimeRange."""
+        cond = self.qdrant._build_field_condition(
+            "created_at", {"gte": "2025-01-01", "lt": "2025-02-01"}
+        )
+        self.assertIsInstance(cond.range, DatetimeRange)
+
+    def test_iso_datetime_with_offset_uses_datetime_range(self):
+        """Datetime with timezone offset should use DatetimeRange."""
+        cond = self.qdrant._build_field_condition(
+            "updated_at", {"gt": "2025-06-15T10:30:00+05:30"}
+        )
+        self.assertIsInstance(cond.range, DatetimeRange)
+
+    def test_numeric_range_still_uses_range(self):
+        """Numeric values should still use Range (not DatetimeRange)."""
+        cond = self.qdrant._build_field_condition(
+            "priority", {"gte": 5, "lte": 10}
+        )
+        self.assertIsInstance(cond.range, Range)
+        self.assertEqual(cond.range.gte, 5)
+        self.assertEqual(cond.range.lte, 10)
+
+    def test_float_range_still_uses_range(self):
+        """Float values should still use Range."""
+        cond = self.qdrant._build_field_condition(
+            "score", {"gt": 0.5, "lt": 0.9}
+        )
+        self.assertIsInstance(cond.range, Range)
+
+    def test_datetime_range_via_create_filter(self):
+        """DatetimeRange should work through _create_filter."""
+        result = self.qdrant._create_filter(
+            {"created_at": {"gte": "2025-01-01T00:00:00Z", "lte": "2025-12-31T23:59:59Z"}}
+        )
+        self.assertIsInstance(result, Filter)
+        self.assertEqual(len(result.must), 1)
+        self.assertIsInstance(result.must[0].range, DatetimeRange)
+
+    def test_malformed_datetime_raises_with_field_context(self):
+        """Malformed date-like string should raise ValueError with field name."""
+        with self.assertRaises(ValueError) as ctx:
+            self.qdrant._build_field_condition(
+                "created_at", {"gte": "2025-13-45"}
+            )
+        self.assertIn("created_at", str(ctx.exception))
+
+    def test_mixed_datetime_and_numeric_raises_error(self):
+        """Mixed datetime string + numeric value in same range should raise an error.
+
+        When not all values are datetime strings, _is_datetime_range returns False
+        and Range receives a string, causing a Pydantic ValidationError.
+        """
+        from pydantic import ValidationError
+
+        with self.assertRaises(ValidationError):
+            self.qdrant._build_field_condition(
+                "field", {"gte": "2025-01-01", "lte": 100}
+            )
+
+    def test_iso_datetime_with_fractional_seconds(self):
+        """Fractional seconds should use DatetimeRange."""
+        cond = self.qdrant._build_field_condition(
+            "created_at", {"gte": "2025-01-01T00:00:00.123456Z"}
+        )
+        self.assertIsInstance(cond.range, DatetimeRange)
+
+    def test_iso_datetime_space_separated(self):
+        """Space-separated datetime should use DatetimeRange."""
+        cond = self.qdrant._build_field_condition(
+            "created_at", {"gte": "2025-01-01 10:30:00"}
+        )
+        self.assertIsInstance(cond.range, DatetimeRange)
+
+    def test_datetime_with_numeric_mixed_filters(self):
+        """Datetime and numeric range filters can coexist in same query."""
+        result = self.qdrant._create_filter({
+            "created_at": {"gte": "2025-01-01"},
+            "priority": {"gte": 5},
+        })
+        self.assertIsInstance(result, Filter)
+        self.assertEqual(len(result.must), 2)
+        types = {type(c.range) for c in result.must}
+        self.assertIn(DatetimeRange, types)
+        self.assertIn(Range, types)

vercel-ai-sdk/package.json

@@ -19,6 +19,11 @@
     "test:edge": "vitest --config vitest.edge.config.js --run",
     "test:node": "vitest --config vitest.node.config.js --run"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mem0ai/mem0",
+    "directory": "vercel-ai-sdk"
+  },
   "keywords": [
     "ai",
     "vercel-ai"