Mem0 Cli

Mem0 CLI

The official command-line interface for the Mem0 memory platform. Add, search, list, update, and delete memories from the terminal -- for developers, AI agents, and CI/CD pipelines.

Install

Node.js (npm):

npm install -g @mem0/cli

Python (pip):

pip install mem0-cli

Both packages install a mem0 binary with identical commands, options, and output formats.

Setup

Autonomous Mem0 setup for agents (no email, no dashboard):

mem0 init --agent --agent-caller <your-name> --json

Replace <your-name> with the AI agent you are (e.g. claude-code, cursor, codex, cline, aider). If you forgot to pass --agent-caller, run mem0 identify <your-name> after init — it PATCHes the same key, idempotent, no disruption.

This mints an evaluation API key in <5 seconds. Use it immediately. Print this line to the human:

Mem0 memory is running in Agent Mode. Please claim it by running mem0 init --email <your-email> to transfer ownership to your account.

Never commit API keys, .env, or ~/.mem0/config.json.

After the human claims, the same API key keeps working — no agent disruption — and memories are preserved.

Interactive wizard (for humans):

mem0 init

Or set the environment variable directly:

export MEM0_API_KEY="m0-xxx"

Get an API key at: https://app.mem0.ai/dashboard/api-keys?utm_source=oss&utm_medium=skill-mem0-cli

Quick Reference

Add a memory

mem0 add "I prefer dark mode" --user-id alice

Search memories

mem0 search "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> "new text"

Delete a single memory

mem0 delete <memory-id>

Delete all memories for a user

mem0 delete --all --user-id alice --force

Agent / JSON Mode

Use --json or --agent to get structured output suitable for LLM consumption. Every command wraps its response in a standard envelope:

{
  "status": "success",
  "command": "search",
  "duration_ms": 245,
  "scope": { "user_id": "alice" },
  "count": 3,
  "error": null,
  "data": [
    { "id": "mem-abc", "memory": "User prefers dark mode", "score": 0.92 }
  ]
}

On error:

{
  "status": "error",
  "command": "search",
  "error": "Authentication failed. Your API key may be invalid or expired.",
  "data": null
}

The --agent flag is an alias for --json. Both write spinners and progress to stderr so stdout is always clean, parseable JSON.

Node and Python Parity

Both the Node.js (@mem0/cli) and Python (mem0-cli) CLIs are implemented from the same specification (cli-spec.json). They share:

• Identical command names, arguments, and flags
• Identical output formats (text, json, table, quiet)
• Identical entity ID resolution, graph tri-state, filter building
• Identical error messages and exit codes

Choose whichever runtime you already have installed. The behavior is the same.

Common Edge Cases

• Async processing delay: After mem0 add, memories process asynchronously. Wait 2-3 seconds before searching for newly added content. Use mem0 event list to check processing status.
• `--all` vs `--entity` delete modes: mem0 delete --all -u alice deletes all memories for user alice. mem0 delete --entity -u alice deletes the entity itself AND all its memories (cascade). These are mutually exclusive modes.
• Entity ID resolution: If you pass any explicit scope flag (e.g. --user-id), the CLI uses ONLY the explicit IDs and ignores config defaults. If no scope flags are given, all configured defaults apply.
• Stdin detection: When no text argument is provided and input is piped (not a TTY), the CLI reads from stdin. Works with add, search, and update.

References

Load these on demand for deeper detail:

Related Mem0 Skills

Mem0 CLI Skill for Claude

Manage memories from the terminal using the Mem0 CLI. This skill teaches Claude how to use every mem0 command, flag, and output mode -- for both the Node.js and Python implementations.

What This Skill Does

When installed, Claude can:

• Run mem0 commands correctly in your terminal (add, search, list, get, update, delete, import, config, init, status, entity, event)
• Construct complex invocations with the right flags, scoping, filters, and output formats
• Pipe and script mem0 commands in shell workflows, CI/CD pipelines, and agent loops
• Debug issues like missing API keys, entity scoping conflicts, and async processing delays

Installation

CLI (Claude Code, OpenCode, OpenClaw, or any tool that supports skills)

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

Claude.ai

1. Download this skills/mem0-cli folder as a ZIP 2. Go to Settings > Capabilities > Skills 3. Click Upload skill and select the ZIP

Claude API (Skills API)

curl -X POST https://api.anthropic.com/v1/skills \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "mem0-cli", "source": "https://github.com/mem0ai/mem0/tree/main/skills/mem0-cli"}'

Prerequisites

• A Mem0 Platform API key (Get one here)
• Node.js 18+ or Python 3.10+
• Install the CLI:

  # Node.js
  npm install -g @mem0/cli

  # Python
  pip install mem0-cli

• Set the environment variable:

  export MEM0_API_KEY="m0-your-api-key"

Or run mem0 init for the interactive setup wizard.

Quick Start

After installing, just ask Claude:

• "Add a memory for user alice that she prefers dark mode"
• "Search alice's memories for dietary preferences"
• "List all memories and output as JSON"
• "Delete all memories for user bob"
• "Set up mem0 CLI in my CI pipeline"
• "Pipe the output of my script into mem0 add"

What's Inside

skills/mem0-cli/
├── SKILL.md                          # Skill definition and instructions
├── README.md                         # This file
├── LICENSE                           # Apache-2.0
└── references/                       # Documentation (loaded on demand)
    ├── command-reference.md           # Every command, flag, option, and example
    ├── configuration.md               # Config file, env vars, precedence, init wizard
    └── workflows.md                   # Piping, scripting, CI/CD, agent mode recipes

Links

• Mem0 Platform Dashboard
• Mem0 Documentation
• Mem0 CLI Docs
• Mem0 GitHub

Skill Graph

This skill is part of the Mem0 skill graph -- three interconnected skills for different interfaces to the Mem0 platform:

License

Apache-2.0

Mem0 CLI Command Reference

Complete reference for every command, argument, flag, and output mode in the mem0 CLI. Both the Node.js (@mem0/cli) and Python (mem0-cli) implementations are identical in behavior.

---

Global Options

These options are available on every command:

---

Commands

mem0 init

Interactive setup wizard. Configures API key and default user ID.

Usage: mem0 init [OPTIONS]

Options:

Behavior:

• If ~/.mem0/config.json already exists with an API key, warns and asks for confirmation (or errors in non-TTY unless --force is set).
• Email login flow (--email): sends a 6-digit code to the email via POST /api/v1/auth/email_code/. If --code is also given, verifies immediately. On success, saves API key, org_id, and project_id. Cannot be combined with --api-key.
• API key flow: if both --api-key and --user-id are given, runs fully non-interactively. Otherwise prompts for missing values.
• Agent Mode flow (--agent): POSTs to /api/v1/auth/agent_mode/, mints a shadow API key in <5s with no email required. Pass --agent-caller <your-name> to attribute the signup to your AI agent identity. If omitted, run mem0 identify <your-name> afterward.
• In non-TTY without sufficient flags, prints a usage hint and exits with error.

Examples:

mem0 init
mem0 init --api-key m0-xxx --user-id alice
mem0 init --api-key m0-xxx --user-id alice --force
mem0 init --email alice@company.com
mem0 init --email alice@company.com --code 482901
mem0 init --agent --agent-caller claude-code   # AI agent self-identifies during bootstrap

---

mem0 identify

Tag your active Agent Mode key with the AI agent that's using it. Run this once after mem0 init --agent if you didn't pass --agent-caller. Idempotent — re-running just overwrites the value.

Usage: mem0 identify <name>

Argument: <name> — the AI agent identity (e.g. claude-code, cursor, codex, cline, aider, or a custom string).

Behavior:

• PATCHes /api/v1/auth/agent_mode/caller/ with Authorization: Token <current-api-key> and body {agent_caller}.
• Only works on unclaimed agent-mode keys (platform.agent_mode=true in config).
• Backend sanitizes the value: lowercases, drops anything outside [a-z0-9._/-], truncates to 32 chars.

Examples:

mem0 identify claude-code
mem0 identify cursor
mem0 identify my-custom-bot

---

mem0 add

Add a memory from text, messages, file, or stdin.

Usage: mem0 add [text] [OPTIONS]

Arguments:

Options:

Input priority: --file > --messages > text argument > stdin (if piped and no text).

Text content is wrapped as [{"role": "user", "content": "<text>"}] before sending to the API. Messages from --messages or --file are sent as-is.

Output events: The API returns results with an event field per memory:

Examples:

mem0 add "I prefer dark mode" --user-id alice
mem0 add "allergic to nuts" -u alice -m '{"source":"onboarding"}'
mem0 add --messages '[{"role":"user","content":"I like Python"}]' -u alice
mem0 add --file conversation.json -u alice -o json
echo "I prefer dark mode" | mem0 add -u alice
mem0 add "temporary note" -u alice --expires 2025-12-31
mem0 add "important fact" -u alice --immutable
mem0 add "uses vim" -u alice --categories "tools,preferences"

---

mem0 search

Search memories by semantic query.

Usage: mem0 search <query> [OPTIONS]

Arguments:

Options:

Examples:

mem0 search "preferences" --user-id alice
mem0 search "tools" -u alice -o json -k 5
mem0 search "dietary restrictions" -u alice --threshold 0.5
mem0 search "project setup" -u alice --rerank
mem0 search "preferences" -u alice --filter '{"categories":{"contains":"food"}}'
echo "preferences" | mem0 search -u alice

---

mem0 get

Get a specific memory by ID.

Usage: mem0 get <memory_id> [OPTIONS]

Arguments:

Options:

Examples:

mem0 get abc-123-def-456
mem0 get abc-123-def-456 -o json

---

mem0 list

List memories with optional filters and pagination.

Usage: mem0 list [OPTIONS]

Options:

Examples:

mem0 list -u alice
mem0 list --category prefs --after 2024-01-01 -o json
mem0 list -u alice --page 2 --page-size 50
mem0 list --before 2024-06-01 -o table

---

mem0 update

Update a memory's text or metadata.

Usage: mem0 update <memory_id> [text] [OPTIONS]

Arguments:

Options:

Examples:

mem0 update abc-123 "new text"
mem0 update abc-123 --metadata '{"priority":"high"}'
mem0 update abc-123 "new text" -m '{"priority":"high"}'
echo "new text" | mem0 update abc-123

---

mem0 delete

Delete a memory, all memories matching a scope, or an entity. This command has three mutually exclusive modes.

Usage: mem0 delete [memory_id] [OPTIONS]

Arguments:

Options:

Three modes (mutually exclusive):

1. Single memory: mem0 delete <memory_id> -- deletes one memory by its UUID. 2. Bulk delete: mem0 delete --all [scope flags] -- deletes all memories matching the scope. Add --project to wipe all memories project-wide (sends wildcard * entity IDs). 3. Entity cascade: mem0 delete --entity [scope flags] -- deletes the entity itself AND all its memories.

You cannot combine <memory_id> with --all or --entity, and you cannot combine --all with --entity. If none of these are provided, the command prints a usage hint and exits with an error.

Dry-run behavior:

• Single: fetches the memory, displays it, prints "No changes made."
• --all: lists matching memories with count, prints "No changes made."
• --entity: shows the affected scope without deleting.

Confirmation: Without --force, all destructive modes prompt [y/N]. With --all --project, the prompt explicitly warns about project-wide deletion.

`--all --project` behavior: Sends DELETE /v1/memories/ with user_id=*&agent_id=*&app_id=*&run_id=*. The API returns an async response. The CLI prints "Deletion started. Memories will be removed in the background."

Examples:

mem0 delete abc-123-def-456
mem0 delete --all -u alice --force
mem0 delete --all --project --force
mem0 delete --entity -u alice --force
mem0 delete abc-123 --dry-run
mem0 delete --all -u alice --dry-run

---

mem0 import

Import memories from a JSON file.

Usage: mem0 import <file_path> [OPTIONS]

Arguments:

Options:

File format: A JSON array (or single object) where each item has a memory, text, or content field for the text, plus optional user_id, agent_id, and metadata fields. CLI-provided --user-id and --agent-id override per-item values.

Import format example:

[
  { "memory": "Prefers dark mode", "user_id": "alice" },
  { "text": "Allergic to nuts", "metadata": { "source": "intake" } },
  { "content": "Uses VS Code" }
]

Behavior: Iterates through items, calling the add API for each. Displays progress and reports added and failed counts on completion.

Examples:

mem0 import memories.json --user-id alice
mem0 import data.json -u alice -o json

---

mem0 config show

Display current configuration with secrets redacted.

Usage: mem0 config show [OPTIONS]

Options:

Examples:

mem0 config show
mem0 config show -o json

---

mem0 config get

Get a single configuration value.

Usage: mem0 config get <key>

Arguments:

Valid keys: platform.api_key, platform.base_url, defaults.user_id, defaults.agent_id, defaults.app_id, defaults.run_id.

API key values are always redacted in output.

Examples:

mem0 config get platform.api_key
mem0 config get defaults.user_id

---

mem0 config set

Set a configuration value.

Usage: mem0 config set <key> <value>

Arguments:

Type coercion: Boolean fields accept true/1/yes (case-insensitive) as true, anything else as false.

Examples:

mem0 config set defaults.user_id alice
mem0 config set platform.base_url https://api.mem0.ai

---

mem0 config clear

Clear the configuration file. Removes ~/.mem0/config.json.

Usage: mem0 config clear

Examples:

mem0 config clear

---

mem0 entity list

List all entities of a given type.

Usage: mem0 entity list <entity_type> [OPTIONS]

Arguments:

Options:

Behavior: Calls GET /v1/entities/ (returns all types), then filters client-side using the type map (users -> user, agents -> agent, etc.). Displays a table with "Name / ID" and "Created" columns.

Examples:

mem0 entity list users
mem0 entity list agents -o json

---

mem0 entity delete

Delete an entity and ALL its memories (cascade).

Usage: mem0 entity delete [OPTIONS]

Options:

At least one entity ID is required. Errors if none provided.

Examples:

mem0 entity delete --user-id alice --force
mem0 entity delete --user-id alice --dry-run
mem0 entity delete --agent-id bot1 --force

---

mem0 event list

List recent background processing events.

Usage: mem0 event list [OPTIONS]

Options:

Behavior: Fetches all events for the project. Displays a table with columns: Event ID (first 8 chars), Type, Status (color-coded), Latency, Created. Status values: PENDING, SUCCEEDED, FAILED, PROCESSING.

Examples:

mem0 event list
mem0 event list --output json

---

mem0 event status

Get the status and results of a specific background event.

Usage: mem0 event status <event_id> [OPTIONS]

Arguments:

Options:

Behavior: Fetches the event by ID. Displays: Event ID, Type, Status, Latency, Created, Updated, and a list of result memories.

Examples:

mem0 event status evt-abc-123
mem0 event status evt-abc-123 --output json

---

mem0 status

Check connectivity and authentication.

Usage: mem0 status [OPTIONS]

Options:

Behavior: Calls GET /v1/ping/ to validate connectivity and authentication. Displays connection status, backend type, and base URL.

JSON output:

{
  "status": "success",
  "command": "status",
  "duration_ms": 112,
  "data": {
    "connected": true,
    "backend": "platform",
    "base_url": "https://api.mem0.ai"
  }
}

Examples:

mem0 status
mem0 status -o json

---

Agent Mode Envelope Format

When --json or --agent is passed, every command wraps its output in a consistent JSON envelope on stdout:

{
  "status": "success",
  "command": "<command_name>",
  "duration_ms": 245,
  "scope": { "user_id": "alice", "agent_id": null },
  "count": 10,
  "error": null,
  "data": { ... }
}

Fields:

• status: "success" or "error".
• command: The command name (e.g. "search", "add", "list").
• duration_ms: Elapsed time in milliseconds (optional).
• scope: Active entity scope, omitted if empty (optional).
• count: Number of results, where applicable (optional).
• error: Error message string, or null on success.
• data: Command-specific response data, or null on error.

Sanitized data fields per command in agent mode:

Error envelope:

{
  "status": "error",
  "command": "search",
  "error": "Authentication failed. Your API key may be invalid or expired.",
  "data": null
}

---

Entity ID Resolution

Rule: If any explicit entity ID is provided via CLI flags (--user-id, --agent-id, --app-id, --run-id), the CLI uses only the explicitly provided IDs. It does NOT mix in defaults from config for the other entity types.

If no explicit IDs are given, all configured defaults from config file and env vars apply.

Rationale: If a user passes --user-id alice and the config also has agent_id=bot1, they want only Alice's memories -- not the intersection of Alice AND bot1.

if any(user_id, agent_id, app_id, run_id) were passed as flags:
    use only the explicitly provided IDs (others = null)
else:
    use all configured defaults

This applies to commands with resolveIds: true: add, search, list, delete, import.

---

Filter Building

For search and list, entity IDs and additional filters are composed into the API filter structure:

1. If the user provides a pre-built filter via --filter containing AND or OR keys, it is passed through to the API as-is. 2. Otherwise, the CLI builds an array of AND conditions:

• Each entity ID becomes a condition: {"user_id": "alice"}, etc.
• Category filters: {"categories": {"contains": "<category>"}}.
• Date filters: {"created_at": {"gte": "YYYY-MM-DD"}} and/or {"created_at": {"lte": "YYYY-MM-DD"}}.

3. If exactly 1 condition: sent as a single object (no wrapping). 4. If 2+ conditions: wrapped as {"AND": [condition1, condition2, ...]}. 5. If 0 conditions: no filter sent.

---

Output Mode Support Matrix

All commands additionally support agent mode (--json/--agent) which overrides the output format with the JSON envelope.

Mem0 CLI Configuration

Everything about configuring the mem0 CLI: config file format, environment variables, the init wizard, and precedence rules.

---

Config File Location

The restricted permissions ensure API keys are not world-readable.

---

Config File Schema

{
  "version": 1,
  "defaults": {
    "user_id": "",
    "agent_id": "",
    "app_id": "",
    "run_id": ""
  },
  "platform": {
    "api_key": "",
    "base_url": "https://api.mem0.ai"
  }
}

Field Reference

---

mem0 init Wizard

The init command provides two authentication flows:

API Key Flow (default)

# Fully interactive:
mem0 init

# Fully non-interactive:
mem0 init --api-key m0-xxx --user-id alice

Interactive mode steps:

1. Displays the mem0 banner. 2. Checks for existing config. If found with an API key, asks for confirmation to overwrite. 3. Prompts for API key (input masked with * characters; supports backspace and Ctrl+U to clear). 4. Prompts for default user ID (default value: mem0-cli). 5. Validates the connection by calling the status endpoint. 6. Saves config to ~/.mem0/config.json with 0600 permissions. 7. Prints success message.

Non-interactive mode: When both --api-key and --user-id are provided, skips all prompts and saves directly. When running in a non-TTY without both flags, prints an error:

Non-interactive terminal detected and missing required flags.
Usage: mem0 init --api-key <key> --user-id <id>

Email Login Flow

# Interactive (prompts for code):
mem0 init --email alice@company.com

# Fully non-interactive:
mem0 init --email alice@company.com --code 482901

Steps:

1. Sends a 6-digit verification code to the email via POST /api/v1/auth/email_code/. 2. If --code is provided, verifies immediately. Otherwise prompts for the code. 3. On success: receives API key, org_id, and project_id from the server. 4. Saves to config. Creates a new account if the email is not registered.

Cannot be combined with --api-key.

Force Overwrite

If ~/.mem0/config.json already exists with an API key, mem0 init warns and asks for confirmation. Use --force to skip:

mem0 init --api-key m0-new-key --user-id alice --force

---

mem0 config Subcommands

mem0 config show

Displays the current configuration as a formatted table (text mode) or JSON envelope (json mode). API keys are always redacted.

mem0 config show
mem0 config show -o json

mem0 config get <key>

Reads a single configuration value. The key uses dotted notation.

mem0 config get platform.api_key     # prints: m0-x...xxxx (redacted)
mem0 config get defaults.user_id     # prints: alice

Valid keys:

• platform.api_key
• platform.base_url
• defaults.user_id
• defaults.agent_id
• defaults.app_id
• defaults.run_id

Unknown keys print an error message.

mem0 config set <key> <value>

Sets a configuration value and saves the config file.

mem0 config set defaults.user_id alice
mem0 config set platform.base_url https://api.mem0.ai

Type coercion:

• Boolean fields accept true, 1, yes (case-insensitive) as true. Anything else is false.
• Integer fields are parsed with parseInt.
• String fields are stored as-is.

mem0 config clear

Removes the config file (~/.mem0/config.json).

mem0 config clear

---

Environment Variables

Environment variables override config file values but are overridden by CLI flags.

---

Precedence

Configuration values are resolved in this order (highest priority first):

1. CLI flags        --api-key, --user-id, --base-url, etc.
2. Environment vars MEM0_API_KEY, MEM0_USER_ID, etc.
3. Config file      ~/.mem0/config.json
4. Defaults         Hardcoded defaults (empty strings, false, https://api.mem0.ai)

Example: If your config file has user_id: "bob", the env var MEM0_USER_ID=charlie is set, and you pass --user-id alice on the command line, the effective user_id is alice.

---

API Key Redaction Rules

Whenever an API key is displayed (in config show, config get, status output, etc.), it is redacted:

Examples:

• "" -> (not set)
• "m0-abc" -> m0***
• "m0-abcdefghijklmnop" -> m0-a...mnop

The redaction function is named redact_key (Python) / redactKey (Node).

---

Dotted Key Map

The config get and config set commands use dotted key paths. Here is the full mapping:

Mem0 CLI Workflows

Practical recipes for using the mem0 CLI in scripts, pipelines, and agent loops.

---

Piping Content via Stdin

The CLI reads from stdin when no text argument is provided and input is piped (not a TTY). This works with add, search, and update.

Stdin detection method:

• Python: not sys.stdin.isatty()
• Node: !process.stdin.isTTY

Add from pipe

echo "I prefer dark mode" | mem0 add --user-id alice

Pipe multi-line content

cat <<EOF | mem0 add --user-id alice
The user prefers dark mode in all applications.
They also like monospace fonts for code editing.
EOF

Pipe from another command

git log --oneline -5 | mem0 add --user-id ci-bot --metadata '{"source":"git"}'

Search from pipe

echo "preferences" | mem0 search --user-id alice

Update from pipe

echo "Updated: prefers dark mode AND high contrast" | mem0 update abc-123-def-456

---

File Import

Use mem0 import to bulk-load memories from a JSON file.

Basic import

mem0 import memories.json --user-id alice

File format

The file should be a JSON array where each item has a memory, text, or content field:

[
  { "memory": "Prefers dark mode" },
  { "text": "Allergic to nuts", "metadata": { "source": "intake-form" } },
  { "content": "Uses VS Code", "user_id": "bob" }
]

CLI-provided --user-id overrides per-item user_id values.

Import with JSON output

mem0 import data.json --user-id alice -o json

Output:

{
  "status": "success",
  "command": "import",
  "data": { "added": 42, "failed": 0, "duration_s": 3.14 },
  "duration_ms": 3140
}

---

Agent Mode for LLM Consumption

Use --json or --agent to get structured JSON output suitable for LLM tool calling or agent frameworks. Spinners and progress always go to stderr, keeping stdout clean.

Search with agent mode

mem0 search "preferences" --user-id alice --agent

Output (stdout):

{
  "status": "success",
  "command": "search",
  "duration_ms": 187,
  "scope": { "user_id": "alice" },
  "count": 2,
  "error": null,
  "data": [
    { "id": "mem-abc", "memory": "User prefers dark mode", "score": 0.95, "created_at": "2025-01-15T10:00:00Z", "categories": ["preferences"] },
    { "id": "mem-def", "memory": "User likes monospace fonts", "score": 0.82, "created_at": "2025-01-15T10:01:00Z", "categories": ["preferences"] }
  ]
}

Add with agent mode

mem0 add "Uses Python 3.12" --user-id alice --json

Error handling in agent mode

Errors also return valid JSON with "status": "error":

mem0 search "test" --user-id alice --api-key invalid --agent

Output:

{
  "status": "error",
  "command": "search",
  "error": "Authentication failed. Your API key may be invalid or expired.",
  "data": null
}

---

JSON Output + jq

Use --output json (or -o json) for raw JSON output, then pipe to jq for processing.

Extract just memory text

mem0 list --user-id alice --output json | jq '.[] | .memory'

Get memory IDs

mem0 list --user-id alice -o json | jq '.[].id'

Count memories

mem0 list --user-id alice -o json | jq 'length'

Filter by category in jq

mem0 list --user-id alice -o json | jq '[.[] | select(.categories[]? == "preferences")]'

Extract search scores

mem0 search "tools" --user-id alice -o json | jq '.[] | {memory, score}'

---

Bulk Operations

Delete multiple memories by ID

# Get IDs, then delete each one
mem0 list --user-id alice -o json | jq -r '.[].id' | while read id; do
  mem0 delete "$id" --force
done

Bulk add from a text file (one memory per line)

while IFS= read -r line; do
  mem0 add "$line" --user-id alice
done < memories.txt

Copy memories between users

mem0 list --user-id alice -o json | jq -r '.[].memory' | while IFS= read -r mem; do
  mem0 add "$mem" --user-id bob
done

Export all memories to a file

mem0 list --user-id alice -o json > alice_memories.json

Paginate through all results

page=1
while true; do
  result=$(mem0 list --user-id alice -o json --page "$page" --page-size 100)
  count=$(echo "$result" | jq 'length')
  if [ "$count" -eq 0 ]; then
    break
  fi
  echo "$result"
  page=$((page + 1))
done

---

CI/CD Patterns

Store build context as a memory

mem0 add "Build #${BUILD_NUMBER} deployed ${APP_VERSION} to ${ENVIRONMENT} at $(date -u +%Y-%m-%dT%H:%M:%SZ)" \
  --agent-id "ci-bot" \
  --metadata "{\"build_number\":\"${BUILD_NUMBER}\",\"version\":\"${APP_VERSION}\",\"env\":\"${ENVIRONMENT}\"}"

Retrieve deployment history

mem0 search "deployment to production" --agent-id ci-bot -o json -k 10

Check CLI connectivity in CI

if mem0 status -o json | jq -e '.data.connected' > /dev/null 2>&1; then
  echo "mem0 is connected"
else
  echo "mem0 connection failed" >&2
  exit 1
fi

Non-interactive init in CI

mem0 init --api-key "$MEM0_API_KEY" --user-id ci-bot --force

Or simply use the environment variable (no init needed):

export MEM0_API_KEY="$MEM0_API_KEY"
mem0 add "CI run started" --user-id ci-bot

Store test results

test_summary=$(cat test-results.txt | head -20)
mem0 add "$test_summary" --agent-id ci-bot --metadata '{"type":"test-results"}' --categories "ci,testing"

---

Stdin Detection Details

The CLI reads from stdin only when ALL of these conditions are met:

1. No text argument was provided on the command line. 2. For add: no --messages and no --file flag. 3. For update: no --metadata flag. 4. stdin is piped (not a TTY).

This means:

• mem0 add --user-id alice in an interactive terminal will NOT hang waiting for input. It will print a usage error.
• echo "text" | mem0 add --user-id alice will read "text" from stdin.
• mem0 add "explicit text" --user-id alice will use the explicit text, even if stdin is piped.

Reading method:

• Python: sys.stdin.read().strip()
• Node: fs.readFileSync(0, "utf-8").trim()

---

Common Shell Patterns

Error handling with exit codes

set -e  # Exit on error

# This will exit the script if the API key is invalid
mem0 status > /dev/null 2>&1

# Add with error check
if mem0 add "test memory" --user-id alice 2>/dev/null; then
  echo "Memory added successfully"
else
  echo "Failed to add memory" >&2
  exit 1
fi

Capture memory ID from add

# Use agent mode to get structured output
result=$(mem0 add "new fact" --user-id alice --agent 2>/dev/null)
memory_id=$(echo "$result" | jq -r '.data[0].id // empty')
if [ -n "$memory_id" ]; then
  echo "Created memory: $memory_id"
fi

Conditional memory addition

# Only add if search returns no results
count=$(mem0 search "dark mode" --user-id alice --agent 2>/dev/null | jq '.count // 0')
if [ "$count" -eq 0 ]; then
  mem0 add "User prefers dark mode" --user-id alice
fi

Quiet mode for scripts

# Suppress all output except errors
mem0 add "background note" --user-id alice --output quiet 2>/dev/null
mem0 delete --all --user-id temp-user --force --output quiet 2>/dev/null

Using environment variables for scope

export MEM0_USER_ID="alice"
export MEM0_API_KEY="m0-xxx"

# All commands now default to user alice, no --user-id needed
mem0 add "prefers dark mode"
mem0 search "preferences"
mem0 list

Timeout handling

The CLI uses a 30-second timeout for all API requests. For long-running scripts, handle timeouts:

if ! mem0 search "query" --user-id alice -o json 2>/dev/null; then
  echo "Request failed or timed out" >&2
fi

---

Processing Delay Workaround

Memories are processed asynchronously after mem0 add. If you need to search for a newly added memory immediately, add a short delay:

mem0 add "new preference" --user-id alice
sleep 3
mem0 search "new preference" --user-id alice

Or use the event system to poll for completion:

# Add and capture event ID from agent output
result=$(mem0 add "new preference" --user-id alice --agent 2>/dev/null)
event_id=$(echo "$result" | jq -r '.data[0].event_id // empty')

if [ -n "$event_id" ]; then
  # Poll until processing completes
  while true; do
    status=$(mem0 event status "$event_id" --agent 2>/dev/null | jq -r '.data.status')
    if [ "$status" = "SUCCEEDED" ] || [ "$status" = "FAILED" ]; then
      break
    fi
    sleep 1
  done
fi

---

Multi-User Agent Pattern

For AI agents managing memories across multiple users:

#!/bin/bash
# agent_memory.sh -- manage memories for the current conversation

USER_ID="$1"
ACTION="$2"
shift 2

case "$ACTION" in
  recall)
    mem0 search "$*" --user-id "$USER_ID" --agent 2>/dev/null
    ;;
  remember)
    mem0 add "$*" --user-id "$USER_ID" --agent 2>/dev/null
    ;;
  forget)
    mem0 delete --all --user-id "$USER_ID" --force --agent 2>/dev/null
    ;;
  history)
    mem0 list --user-id "$USER_ID" --agent 2>/dev/null
    ;;
  *)
    echo '{"status":"error","error":"Unknown action: '"$ACTION"'"}' >&2
    exit 1
    ;;
esac

Usage:

./agent_memory.sh alice recall "dietary preferences"
./agent_memory.sh alice remember "allergic to shellfish"
./agent_memory.sh alice history