mem0/cli/CLI_SPECIFICATION.md

mem0 CLI SDK Specification

Complete reference for the mem0 CLI. This document is the authoritative guide for any developer or AI agent working on this SDK.

---

Table of Contents

1. Project Overview
2. Architecture
3. Complete Command Reference
4. API Endpoints
5. Configuration
6. Key Behavioral Patterns
7. Output Modes
8. Agent-Friendly Design Decisions
9. Adding a New Command
10. Adding a New Language Implementation

---

1. Project Overview

What is mem0 CLI?

mem0 CLI is the official command-line interface for mem0 -- the memory layer for AI agents. It lets developers and AI agents add, search, list, update, and delete memories via the mem0 Platform API from the terminal.

Who is it for?

• Developers integrating mem0 into their workflows
• AI agents that need persistent memory (the CLI is designed with --json/--agent global flags and help --json specifically for machine consumption)
• DevOps/CI pipelines that need to manage memories programmatically

Project Structure

The cli/ directory provides the mem0 CLI in two languages with a shared specification for behavioral consistency.

Language	Directory	Package Name	Install Command
TypeScript	node/	@mem0/cli	npm install -g @mem0/cli
Python	python/	mem0-cli	pip install mem0-cli

Both implementations produce a binary named mem0 and provide identical CLI behavior -- same commands, same options, same output formats, same error messages.

Version

Current version: 0.1.0 (defined in cli-spec.json, node/package.json, and python/pyproject.toml).

License

Apache-2.0

---

2. Architecture

Directory Layout

.
├── cli-spec.json                    # Shared CLI specification (source of truth)
├── README.md                        # CLI README
├── SDK_SPECIFICATION.md             # This file
├── python/
│   ├── pyproject.toml               # Python package config (hatchling build)
│   ├── README.md
│   └── src/mem0_cli/
│       ├── __init__.py              # __version__
│       ├── app.py                   # Main Typer app, command registration, helpers
│       ├── config.py                # Config loading/saving, env var overrides
│       ├── branding.py              # Colors, icons, banner, timed_status, print helpers
│       ├── output.py                # Output formatting (text, json, table, quiet)
│       ├── backend/
│       │   ├── __init__.py          # Re-exports get_backend
│       │   ├── base.py              # Abstract Backend ABC, get_backend factory
│       │   └── platform.py          # PlatformBackend (httpx), error classes
│       └── commands/
│           ├── memory.py            # cmd_add, cmd_search, cmd_get, cmd_list, cmd_update, cmd_delete, cmd_delete_all
│           ├── init_cmd.py          # run_init (interactive wizard)
│           ├── config_cmd.py        # cmd_config_show, cmd_config_get, cmd_config_set
│           ├── entities.py          # cmd_entities_list, cmd_entities_delete
│           ├── events_cmd.py        # cmd_event_list, cmd_event_status
│           └── utils.py             # cmd_status, cmd_version, cmd_import
└── node/
    ├── package.json                 # Node package config (tsup build)
    ├── README.md
    └── src/
        ├── index.ts                 # Main Commander.js app, command registration, helpers
        ├── config.ts                # Config loading/saving, env var overrides
        ├── branding.ts              # Colors, icons, banner, timedStatus, print helpers
        ├── output.ts                # Output formatting (text, json, table, quiet)
        ├── state.ts                 # Agent mode flag (setAgentMode, isAgentMode)
        ├── help.ts                  # Rich-style help formatter (panels, command ordering)
        ├── backend/
        │   ├── index.ts             # Re-exports
        │   ├── base.ts              # Backend interface, error classes, getBackend factory
        │   └── platform.ts          # PlatformBackend (native fetch), _buildFilters
        └── commands/
            ├── memory.ts            # cmdAdd, cmdSearch, cmdGet, cmdList, cmdUpdate, cmdDelete, cmdDeleteAll
            ├── init.ts              # runInit (interactive wizard)
            ├── config.ts            # cmdConfigShow, cmdConfigGet, cmdConfigSet
            ├── entities.ts          # cmdEntitiesList, cmdEntitiesDelete
            ├── events.ts            # cmdEventList, cmdEventStatus
            └── utils.ts             # cmdStatus, cmdVersion, cmdImport

How Both CLIs Mirror Each Other

Every command, option, argument, and behavioral pattern is implemented identically in both CLIs. The shared cli-spec.json is the source of truth for:

• All command names, descriptions, and usage strings
• All arguments and options (names, types, defaults, help text, panel grouping)
• API endpoint paths and methods
• Branding constants (colors, icons, logo)
• Config schema (sections, fields, env var mappings)
• Error messages and templates
• Option grouping (Scope, Search, Pagination, Filters, Output, Connection)

Tech Stacks

Concern	Python	Node
CLI framework	Typer >= 0.9.0	Commander.js ^12.0.0
Rich output	Rich >= 13.0.0	chalk ^5.3.0 + cli-table3 ^0.6.4
Spinners	Rich Status	ora ^8.0.0
Boxed panels	Rich Panel	boxen ^7.1.0
HTTP client	httpx >= 0.24.0	Native fetch (Node >= 18)
Build system	Hatchling	tsup ^8.0.0
Test framework	pytest >= 7.0	vitest ^1.5.0
Linter	ruff >= 0.1.0	Biome ^1.7.0
Type checking	(ruff type checks)	TypeScript ^5.4.0
Min runtime	Python >= 3.10	Node >= 18.0.0
Module format	Standard Python package	ESM ("type": "module")
Entrypoint	mem0 = "mem0_cli.app:main"	"bin": { "mem0": "./dist/index.js" }

---

3. Complete Command Reference

3.1 init

Interactive setup wizard for mem0 CLI.

Property	Value
Usage	mem0 init [OPTIONS]
needsBackend	No
needsConfig	No
resolveIds	No
resolveGraph	No
confirmDangerous	No

Options:

Flag	Type	Required	Default	Help
--api-key	string	No	-	API key (skip prompt).
-u, --user-id	string	No	-	Default user ID (skip prompt).
--email	string	No	-	Login via email verification code.
--code	string	No	-	Verification code (use with --email for non-interactive login).
--force	bool	No	false	Overwrite existing config without confirmation.

Behavior:

Existing config protection:

• If ~/.mem0/config.json exists with an API key, the CLI warns and asks for confirmation before overwriting.
• In non-TTY mode, this is a hard error unless --force is passed.
• --force skips the confirmation in both TTY and non-TTY modes.

Email login flow (when --email is provided):

• Sends a 6-digit verification code to the email via POST /api/v1/auth/email_code/.
• If --code is also provided, verifies immediately (fully non-interactive).
• If --code is not provided, prompts for the code interactively.
• On success: receives API key, org_id, project_id. Saves to config. Creates account if email is new.
• Cannot be combined with --api-key.

API key flow (existing behavior):

• If both --api-key and --user-id are provided, runs non-interactively (no prompts).
• If running in a non-TTY without both flags, prints an error with usage hint and exits.
• Interactive mode: prints banner, prompts for API key (masked with *), prompts for default user ID (default: mem0-cli), validates connection, saves config.
• API key input uses raw terminal mode to echo * for each character typed. Supports backspace and Ctrl+U (clear line).

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

---

3.2 add

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

Property	Value
Usage	mem0 add <text> [OPTIONS]
needsBackend	Yes
needsConfig	Yes
resolveIds	Yes
resolveGraph	Yes
confirmDangerous	No
Output formats	text, json, quiet
Default output	text
API endpoint	POST /v1/memories/

Arguments:

Name	Type	Required	Help
text	string	No	Text content to add as a memory.

Options:

Flag	Type	Default	Panel	Help
-u, --user-id	string	-	Scope	Scope to user.
--agent-id	string	-	Scope	Scope to agent.
--app-id	string	-	Scope	Scope to app.
--run-id	string	-	Scope	Scope to run.
--messages	string	-	-	Conversation messages as JSON.
-f, --file	path	-	-	Read messages from JSON file.
-m, --metadata	string	-	-	Custom metadata as JSON.
--immutable	boolean	false	-	Prevent future updates.
--no-infer	boolean	false	-	Skip inference, store raw.
--expires	string	-	-	Expiration date (YYYY-MM-DD).
--categories	string	-	-	Categories (JSON array or comma-separated).
--graph	boolean	false	Scope	Enable graph memory extraction.
--no-graph	boolean	false	Scope	Disable graph memory extraction.
-o, --output	string	"text"	Output	Output format: text, json, quiet.
--api-key	string	-	Connection	Override API key.
--base-url	string	-	Connection	Override API base URL.

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

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

Examples:

mem0 add "I prefer dark mode" --user-id alice
echo "text" | mem0 add -u alice
mem0 add --file msgs.json -u alice -o json

---

3.3 search

Search memories by semantic query.

Property	Value
Usage	mem0 search <query> [OPTIONS]
needsBackend	Yes
needsConfig	Yes
resolveIds	Yes
resolveGraph	Yes
confirmDangerous	No
Output formats	text, json, table
Default output	text
API endpoint	POST /v2/memories/search/

Arguments:

Name	Type	Required	Help
query	string	Yes	Search query.

Options:

Flag	Type	Default	Panel	Help
-u, --user-id	string	-	Scope	Filter by user.
--agent-id	string	-	Scope	Filter by agent.
--app-id	string	-	Scope	Filter by app.
--run-id	string	-	Scope	Filter by run.
-k, --top-k, --limit	integer	10	Search	Number of results.
--threshold	float	0.3	Search	Minimum similarity score.
--rerank	boolean	false	Search	Enable reranking (Platform only).
--keyword	boolean	false	Search	Use keyword search.
--filter	string	-	Search	Advanced filter expression (JSON).
--fields	string	-	Search	Specific fields to return (comma-separated).
--graph	boolean	false	Search	Enable graph in search.
--no-graph	boolean	false	Search	Disable graph in search.
-o, --output	string	"text"	Output	Output: text, json, table.
--api-key	string	-	Connection	Override API key.
--base-url	string	-	Connection	Override API base URL.

Stdin fallback: If no query argument is provided and stdin is piped, reads query from stdin.

Examples:

mem0 search "preferences" --user-id alice
mem0 search "tools" -u alice -o json -k 5
echo "preferences" | mem0 search -u alice

---

3.4 get

Get a specific memory by ID.

Property	Value
Usage	mem0 get <memory_id> [OPTIONS]
needsBackend	Yes
needsConfig	No
resolveIds	No
resolveGraph	No
confirmDangerous	No
Output formats	text, json
Default output	text
API endpoint	GET /v1/memories/{memory_id}/

Arguments:

Name	Type	Required	Help
memory_id	string	Yes	Memory ID to retrieve.

Options:

Flag	Type	Default	Panel	Help
-o, --output	string	"text"	Output	Output: text, json.
--api-key	string	-	Connection	Override API key.
--base-url	string	-	Connection	Override API base URL.

Examples:

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

---

3.5 list

List memories with optional filters.

Property	Value
Usage	mem0 list [OPTIONS]
needsBackend	Yes
needsConfig	Yes
resolveIds	Yes
resolveGraph	Yes
confirmDangerous	No
Output formats	text, json, table
Default output	table
API endpoint	POST /v2/memories/

Arguments: None.

Options:

Flag	Type	Default	Panel	Help
-u, --user-id	string	-	Scope	Filter by user.
--agent-id	string	-	Scope	Filter by agent.
--app-id	string	-	Scope	Filter by app.
--run-id	string	-	Scope	Filter by run.
--page	integer	1	Pagination	Page number.
--page-size	integer	100	Pagination	Results per page.
--category	string	-	Filters	Filter by category.
--after	string	-	Filters	Created after (YYYY-MM-DD).
--before	string	-	Filters	Created before (YYYY-MM-DD).
--graph	boolean	false	Filters	Enable graph in listing.
--no-graph	boolean	false	Filters	Disable graph in listing.
-o, --output	string	"table"	Output	Output: text, json, table.
--api-key	string	-	Connection	Override API key.
--base-url	string	-	Connection	Override API base URL.

Examples:

mem0 list -u alice
mem0 list --category prefs --after 2024-01-01 -o json

---

3.6 update

Update a memory's text or metadata.

Property	Value
Usage	mem0 update <memory_id> [text] [OPTIONS]
needsBackend	Yes
needsConfig	No
resolveIds	No
resolveGraph	No
confirmDangerous	No
Output formats	text, json, quiet
Default output	text
API endpoint	PUT /v1/memories/{memory_id}/

Arguments:

Name	Type	Required	Help
memory_id	string	Yes	Memory ID to update.
text	string	No	New memory text.

Options:

Flag	Type	Default	Panel	Help
-m, --metadata	string	-	-	Update metadata (JSON).
-o, --output	string	"text"	Output	Output: text, json, quiet.
--api-key	string	-	Connection	Override API key.
--base-url	string	-	Connection	Override API base URL.

Stdin fallback: If no text argument is provided and no --metadata flag is set and stdin is piped, reads text from stdin.

Examples:

mem0 update abc-123 "new text"
mem0 update abc-123 --metadata '{"key":"val"}'
echo "new text" | mem0 update abc-123

---

3.7 delete

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

Property	Value
Usage	mem0 delete [memory_id] [OPTIONS]
needsBackend	Yes
needsConfig	Yes
resolveIds	Yes
resolveGraph	No
confirmDangerous	Yes
Output formats	text, json, quiet
Default output	text
API endpoint	DELETE /v1/memories/{memory_id}/ (single), DELETE /v1/memories/ (--all), DELETE /v1/entities/ (--entity)

Arguments:

Name	Type	Required	Help
memory_id	string	No	Memory ID to delete (omit when using --all or --entity).

Options:

Flag	Type	Default	Panel	Help
--all	boolean	false	-	Delete all memories matching scope filters.
--entity	boolean	false	-	Delete the entity itself and all its memories (cascade).
--project	boolean	false	-	With --all: delete ALL memories project-wide.
--dry-run	boolean	false	-	Show what would be deleted without deleting.
--force	boolean	false	-	Skip confirmation.
-u, --user-id	string	-	Scope	Scope to user.
--agent-id	string	-	Scope	Scope to agent.
--app-id	string	-	Scope	Scope to app.
--run-id	string	-	Scope	Scope to run.
-o, --output	string	"text"	Output	Output: text, json, quiet.
--api-key	string	-	Connection	Override API key.
--base-url	string	-	Connection	Override API base URL.

Three modes (mutually exclusive):

1. Single memory: mem0 delete <memory_id> -- deletes one memory by ID. Cannot combine with --all or --entity.
2. Bulk delete: mem0 delete --all [scope] -- deletes all memories matching scope filters. Use --project with --all to wipe all memories project-wide (sends wildcard * entity IDs). Cannot combine with <memory_id> or --entity.
3. Entity cascade: mem0 delete --entity [scope] -- deletes the entity itself and all its memories. Cannot combine with <memory_id> or --all.

If none of <memory_id>, --all, or --entity is provided, the command prints a usage hint and exits with an error.

Dry-run behavior:

• Single: fetches the memory via GET, displays it, then prints "No changes made."
• --all: lists matching memories and displays the count, then prints "No changes made."
• --entity: shows the scope that would be affected without deleting.

Confirmation: Without --force, prompts the user with "[y/N]" confirmation. With --all --project, the prompt warns about entire project wipe.

--all --project wildcard behavior: Sends DELETE /v1/memories/ with query params user_id=*&agent_id=*&app_id=*&run_id=*. The API typically returns an async response with a message field (deletion happens in background). The CLI detects this and prints "Deletion started. Memories will be removed in the background."

Examples:

mem0 delete abc-123-def-456              # single memory
mem0 delete --all -u alice --force        # all memories for user
mem0 delete --all --project --force       # project-wide wipe
mem0 delete --entity -u alice --force     # entity + all its memories
mem0 delete abc-123 --dry-run             # preview single delete

---

3.8 import

Import memories from a JSON file.

Property	Value
Usage	mem0 import <file_path> [OPTIONS]
needsBackend	Yes
needsConfig	Yes
resolveIds	Yes
resolveGraph	No
confirmDangerous	No
Output formats	text, json
Default output	text
API endpoint	POST /v1/memories/ (per item)

Arguments:

Name	Type	Required	Help
file_path	string	Yes	JSON file to import.

Options:

Flag	Type	Default	Panel	Help
-u, --user-id	string	-	Scope	Override user ID.
--agent-id	string	-	Scope	Override agent ID.
-o, --output	string	"text"	Output	Output: text, json.
--api-key	string	-	Connection	Override API key.
--base-url	string	-	Connection	Override API base URL.

File format: JSON array (or single object) where each item has memory, text, or content field for the text, plus optional user_id, agent_id, and metadata fields.

Behavior: Iterates through items, calling backend.add() for each. CLI-provided --user-id and --agent-id override per-item values. Displays progress indicator (every 10 items in Node, Rich progress bar in Python). Reports added and failed counts.

JSON output envelope:

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

Examples:

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

---

3.9 config show

Display current configuration (secrets redacted).

Property	Value
Usage	mem0 config show [OPTIONS]
needsBackend	No
needsConfig	No

Options:

Flag	Type	Default	Help
-o, --output	string	"text"	Output: text, json.

Behavior: Loads config (file + env vars), displays as table (text) or JSON envelope. API keys are always redacted using redact_key().

Examples:

mem0 config show
mem0 config show -o json

---

3.10 config get

Get a configuration value.

Property	Value
Usage	mem0 config get <key>
needsBackend	No
needsConfig	No

Arguments:

Name	Type	Required	Help
key	string	Yes	Config key (e.g. platform.api_key).

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

Behavior: Prints the value to stdout. API keys are redacted. Unknown keys print an error.

Examples:

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

---

3.11 config set

Set a configuration value.

Property	Value
Usage	mem0 config set <key> <value>
needsBackend	No
needsConfig	No

Arguments:

Name	Type	Required	Help
key	string	Yes	Config key (e.g. platform.api_key).
value	string	Yes	Value to set.

Type coercion: Boolean fields accept true/1/yes (case-insensitive) as true, anything else as false. Integer fields are parsed via parseInt. String fields are stored as-is.

Examples:

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

---

3.12 entity list

List all entities of a given type.

Property	Value
Usage	mem0 entity list <entity_type>
needsBackend	Yes
needsConfig	No
resolveIds	No
resolveGraph	No
confirmDangerous	No
Output formats	table, json
Default output	table
API endpoint	GET /v1/entities/

Arguments:

Name	Type	Required	Choices	Help
entity_type	string	Yes	users, agents, apps, runs	Entity type to list.

Behavior: Calls GET /v1/entities/ which returns ALL entity types, then filters client-side using the type map: users -> user, agents -> agent, apps -> app, runs -> run. Displays a table with "Name / ID" and "Created" columns.

Options:

Flag	Type	Default	Panel	Help
-o, --output	string	"table"	Output	Output: table, json.
--api-key	string	-	Connection	Override API key.
--base-url	string	-	Connection	Override API base URL.

Examples:

mem0 entity list users
mem0 entity list agents -o json

---

3.13 entity delete

Delete an entity and ALL its memories (cascade). Also accessible via mem0 delete --entity.

Property	Value
Usage	mem0 entity delete [OPTIONS]
needsBackend	Yes
needsConfig	No
resolveIds	No
resolveGraph	No
confirmDangerous	Yes
Output formats	text, json, quiet
Default output	text
API endpoint	DELETE /v1/entities/

Arguments: None.

Options:

Flag	Type	Default	Panel	Help
-u, --user-id	string	-	Scope	User ID.
--agent-id	string	-	Scope	Agent ID.
--app-id	string	-	Scope	App ID.
--run-id	string	-	Scope	Run ID.
--dry-run	boolean	false	-	Show what would be deleted without deleting.
--force	boolean	false	-	Skip confirmation.
-o, --output	string	"text"	Output	Output: text, json, quiet.
--api-key	string	-	Connection	Override API key.
--base-url	string	-	Connection	Override API base URL.

Validation: 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

---

3.14 event list

List recent background processing events.

Property	Value
Usage	mem0 event list [OPTIONS]
needsBackend	Yes
needsConfig	Yes
resolveIds	No
resolveGraph	No
confirmDangerous	No
Output formats	text (table), json
Default output	table
API endpoint	GET /v1/events/

Options:

Flag	Type	Default	Panel	Help
-o, --output	string	"table"	Output	Output: text, json.
--api-key	string	-	Connection	Override API key.
--base-url	string	-	Connection	Override API base URL.

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

JSON output envelope:

{
  "status": "success",
  "command": "event list",
  "count": 3,
  "duration_ms": 87,
  "data": [
    { "id": "evt-abc", "event_type": "ADD", "status": "SUCCEEDED", "latency": 412.0, "created_at": "2026-01-01T10:00:00Z" }
  ]
}

Examples:

mem0 event list
mem0 event list --output json

---

3.15 event status

Get the status and results of a specific background event.

Property	Value
Usage	mem0 event status <event_id> [OPTIONS]
needsBackend	Yes
needsConfig	Yes
resolveIds	No
resolveGraph	No
confirmDangerous	No
Output formats	text, json
Default output	text
API endpoint	GET /v1/events/{event_id}/

Arguments:

Name	Type	Required	Help
event_id	string	Yes	Event ID to inspect.

Options:

Flag	Type	Default	Panel	Help
-o, --output	string	"text"	Output	Output: text, json.
--api-key	string	-	Connection	Override API key.
--base-url	string	-	Connection	Override API base URL.

Behavior: Fetches the event by ID and displays: Event ID, Type, Status (color-coded), Latency, Created, Updated, and a numbered list of result memories (event type, memory text, user_id, truncated memory ID). Displayed in a boxed panel (text) or JSON envelope.

JSON output envelope:

{
  "status": "success",
  "command": "event status",
  "duration_ms": 65,
  "data": {
    "id": "evt-abc",
    "event_type": "ADD",
    "status": "SUCCEEDED",
    "latency": 412.0,
    "created_at": "2026-01-01T10:00:00Z",
    "updated_at": "2026-01-01T10:00:01Z",
    "results": [
      { "id": "mem-xyz", "event": "ADD", "user_id": "alice", "memory": "User prefers dark mode" }
    ]
  }
}

Examples:

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

---

3.16 status

Check connectivity and authentication.

Property	Value
Usage	mem0 status [OPTIONS]
needsBackend	Yes
needsConfig	Yes
resolveIds	No
resolveGraph	No
confirmDangerous	No

Options:

Flag	Type	Default	Panel	Help
-o, --output	string	"text"	Output	Output: text, json.
--api-key	string	-	Connection	Override API key.
--base-url	string	-	Connection	Override API base URL.

Behavior: Validates connectivity by calling GET /v1/ping/. Displays connection status in a boxed panel (text) or JSON envelope. The ping endpoint is lightweight and does not require any entity scope.

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

---

3.17 help

Show help. Use --json for machine-readable output (for LLM agents).

Property	Value
Usage	mem0 help [OPTIONS]
needsBackend	No
needsConfig	No

Options:

Flag	Type	Default	Help
--json	boolean	false	Output machine-readable JSON for LLM agents.

Behavior:

• Without --json: prints a human-readable summary of all commands.
• With --json: Node outputs the entire cli-spec.json file. Python outputs a hand-built JSON object describing all commands, arguments, options, and global options.

Examples:

mem0 help
mem0 help --json

---

4. API Endpoints

Base URL

Default: https://api.mem0.ai (configurable via --base-url, MEM0_BASE_URL, or platform.base_url in config).

Authentication

All requests include the header:

Authorization: Token <api_key>

The auth header name is Authorization and the scheme is Token (not Bearer).

Timeout

30 seconds for all requests (Python: httpx.Client(timeout=30.0), Node: AbortSignal.timeout(30_000)).

Endpoint Reference

Operation	Method	Path	Request Body	Query Params
Add memory	POST	/v1/memories/	JSON payload	-
Search	POST	/v2/memories/search/	JSON payload	-
Get memory	GET	/v1/memories/{memory_id}/	-	-
List memories	POST	/v2/memories/	JSON payload	page, page_size
Update memory	PUT	/v1/memories/{memory_id}/	JSON payload	-
Delete memory	DELETE	/v1/memories/{memory_id}/	-	-
Delete all	DELETE	/v1/memories/	-	entity ID params
List entities	GET	/v1/entities/	-	-
Delete entities	DELETE	/v1/entities/	-	entity ID params
List events	GET	/v1/events/	-	-
Get event	GET	/v1/events/{event_id}/	-	-
Ping (status)	GET	/v1/ping/	-	-

How Filters Are Built (_buildFilters / _build_filters)

Both CLIs use an identical filter-building algorithm:

1. If the caller passed a pre-built filter structure containing AND or OR keys (e.g. from --filter), use it directly.
2. Otherwise, build an array of AND conditions:
   • Each entity ID becomes {"user_id": "..."}, {"agent_id": "..."}, etc.
   • Extra filters (category, date ranges) are appended as additional conditions.
3. If exactly 1 condition: return it directly (no wrapping).
4. If 2+ conditions: return {"AND": [condition1, condition2, ...]}.
5. If 0 conditions: return undefined/None.

Category filter format: {"categories": {"contains": "<category>"}}

Date filter format: {"created_at": {"gte": "YYYY-MM-DD"}} and/or {"created_at": {"lte": "YYYY-MM-DD"}}. If both after and before are set, they merge into one created_at object: {"created_at": {"gte": "...", "lte": "..."}}.

How Pagination Works

For the list command (and search internally):

• page and page_size are sent as query parameters (not in the POST body).
• Filters and enable_graph are sent in the POST body.
• Default: page=1, page_size=100.

Response Normalization

Both CLIs handle inconsistent API response formats:

# For search and list, the API may return:
result = [...]              # Direct array
result = {"results": [...]} # Wrapped in results key
result = {"memories": [...]} # Wrapped in memories key

# Normalization logic (identical in both CLIs):
if isinstance(result, list):
    return result
else:
    return result.get("results", result.get("memories", []))

Error Handling

HTTP errors are mapped to typed exceptions:

HTTP Status	Error Class	Message Template
401	AuthError	"Authentication failed. Your API key may be invalid or expired."
404	NotFoundError	"Resource not found: {path}"
400	APIError	"Bad request to {path}: {detail}" (detail extracted from response JSON .detail field)
204	(success)	Returns {} (empty object)
Other	Generic Error	"HTTP {status}: {statusText}"

---

5. Configuration

Config File Location

• Directory: ~/.mem0/ (created with permissions 0700)
• File: ~/.mem0/config.json (written with permissions 0600)

Config Precedence (highest to lowest)

1. CLI flags (--api-key, --base-url, --user-id, etc.)
2. Environment variables (MEM0_API_KEY, etc.)
3. Config file (~/.mem0/config.json)
4. Defaults (hardcoded)

Environment Variables

Variable	Config Path	Type	Default
MEM0_API_KEY	platform.api_key	string	""
MEM0_BASE_URL	platform.base_url	string	"https://api.mem0.ai"
MEM0_USER_ID	defaults.user_id	string	""
MEM0_AGENT_ID	defaults.agent_id	string	""
MEM0_APP_ID	defaults.app_id	string	""
MEM0_RUN_ID	defaults.run_id	string	""
MEM0_ENABLE_GRAPH	defaults.enable_graph	boolean	false

Boolean parsing for MEM0_ENABLE_GRAPH: Accepted truthy values are "true", "1", "yes" (case-insensitive). Everything else is false.

Config File JSON Schema

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

Field	Type	Default	Description
version	integer	1	Config schema version.
defaults.user_id	string	""	Default user ID for scoping.
defaults.agent_id	string	""	Default agent ID for scoping.
defaults.app_id	string	""	Default app ID for scoping.
defaults.run_id	string	""	Default run ID for scoping.
defaults.enable_graph	boolean	false	Default graph memory extraction.
platform.api_key	string	""	API key for mem0 Platform.
platform.base_url	string	"https://api.mem0.ai"	Base URL for API requests.

Config Key Map (for config get/config set)

The dotted key paths map to internal config objects as follows:

Dotted Key	Section	Field
platform.api_key	platform	apiKey / api_key
platform.base_url	platform	baseUrl / base_url
defaults.user_id	defaults	userId / user_id
defaults.agent_id	defaults	agentId / agent_id
defaults.app_id	defaults	appId / app_id
defaults.run_id	defaults	runId / run_id
defaults.enable_graph	defaults	enableGraph / enable_graph

API Key Redaction

The redact_key/redactKey function:

• Empty string: returns "(not set)"
• Length <= 8: returns first 2 chars + "***"
• Length > 8: returns first 4 chars + "..." + last 4 chars

---

6. Key Behavioral Patterns

These patterns are the contract both CLIs must follow. Any new implementation must replicate them exactly.

6.1 Entity ID Resolution

Function: _resolve_ids (Python) / resolveIds (Node)

Rule: If any explicit entity ID is provided via CLI flags, only use the explicitly provided IDs. Do NOT mix in defaults for other entity types (which would over-filter). If no explicit IDs are provided, fall back to all configured defaults.

if any(user_id, agent_id, app_id, run_id):
    # Only use what was explicitly passed; others become None
    return {user_id or None, agent_id or None, app_id or None, run_id or None}
else:
    # Fall back to all configured defaults
    return {config.user_id or None, config.agent_id or None, ...}

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

6.2 Graph Tri-State Resolution

Rule: --no-graph > --graph > config default.

if opts.no_graph: return false
if opts.graph: return true
return config.defaults.enable_graph

This is resolved in the main app file (not in the command handlers) before calling the command function.

6.3 Category Parsing

Rule: Try JSON parse first, fallback to comma-split.

if categories:
    try:
        cats = JSON.parse(categories)  # e.g. '["a","b"]'
    except:
        cats = categories.split(",").map(s => s.trim())  # e.g. "a, b"

6.4 Stdin Detection

Rule: Read from stdin if no text argument is provided AND stdin is piped (not a TTY).

• add: If no text, no --messages, no --file, and stdin is piped -> read content from stdin.
• search: If no query argument and stdin is piped -> read query from stdin.
• update: If no text argument and no --metadata and stdin is piped -> read text from stdin.

Detection method:

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

Reading method:

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

6.5 Filter Building (_buildFilters)

Detailed algorithm (see Section 4 for full description):

1. If extraFilters has AND or OR key -> return it as-is (pre-built filter).
2. Collect AND conditions from entity IDs.
3. Append extra filters (category, date ranges).
4. 0 conditions -> undefined/None.
5. 1 condition -> return that single object.
6. 2+ conditions -> {"AND": [...]}.

6.6 API Response Normalization

All search and listMemories/list_memories calls normalize the response:

if Array.isArray(result): return result
return result.results ?? result.memories ?? []

This handles both direct array responses and wrapped {results: [...]} or {memories: [...]} formats.

6.7 Config File Permissions

• Config directory (~/.mem0/): created with mode 0o700 (owner read+write+execute only).
• Config file (~/.mem0/config.json): written with mode 0o600 (owner read+write only).
• Python uses os.chmod() with stat.S_IRWXU (dir) and stat.S_IRUSR | stat.S_IWUSR (file).
• Node uses fs.mkdirSync(..., { mode: 0o700 }) and fs.chmodSync(file, 0o600).

6.8 Timed Status Pattern

Every API call is wrapped in a spinner + timing pattern:

Python:

with timed_status(err_console, "Adding memory...") as ts:
    result = backend.add(...)

Uses Rich Status context manager on stderr. On success, prints ts.success_msg with elapsed time. On error, prints ts.error_msg with elapsed time.

Node:

result = await timedStatus("Adding memory...", async (ctx) => {
    return backend.add(...);
});

Uses ora spinner on stderr. On success, prints ctx.successMsg with elapsed time. On error, prints ctx.errorMsg with elapsed time.

Both use performance.now() / time.perf_counter() for timing. Elapsed time is formatted as {seconds:.2f}s.

Key: Spinners and timing messages always go to stderr so they never contaminate machine-readable stdout.

6.9 Error Hierarchy

AuthError    (HTTP 401) -> "Authentication failed. Your API key may be invalid or expired."
NotFoundError (HTTP 404) -> "Resource not found: {path}"
APIError     (HTTP 400) -> "Bad request to {path}: {detail}"

For HTTP 400, the CLI attempts to extract a detail field from the JSON response body. If parsing fails, falls back to resp.statusText/resp.text.

HTTP 204 is treated as success with empty body ({}).

Any other non-OK response throws a generic error with "HTTP {status}: {statusText}".

6.10 delete --all --project Wildcard Behavior

When delete --all --project is used, the CLI sends wildcard entity IDs (user_id=*, agent_id=*, app_id=*, run_id=*) to DELETE /v1/memories/. The API typically returns an asynchronous response with a message field (the deletion happens in the background). The CLI detects the message key in the response and prints "Deletion started. Memories will be removed in the background." instead of a success count.

6.11 Non-Interactive Init

When both --api-key and --user-id are provided to mem0 init:

1. Sets config values directly (no prompts).
2. Validates the platform connection.
3. Saves config to disk.
4. Prints success message.

When running in a non-TTY (piped input) without both flags, prints an error with usage hint:

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

6.12 Add Result Event Display

The format_add_result function handles the API response from POST /v1/memories/:

The response is either a direct array or {results: [...]}. Each result item has an event field:

Event	Icon	Label
ADD	+	Added
UPDATE	~	Updated
DELETE	-	Deleted
NOOP	.	No change
PENDING	hourglass	Queued (async)

For PENDING events, displays "Processing in background" with the event ID.

---

7. Output Modes

7.1 Supported Modes Per Command

All commands also support agent mode via the global --json/--agent flag, which wraps output in a structured JSON envelope with sanitized fields.

Command	text	json	table	quiet
add	Y	Y	-	Y
search	Y	Y	Y	-
get	Y	Y	-	-
list	Y	Y	Y (default)	-
update	Y	Y	-	Y
delete	Y	Y	-	Y
import	Y	Y	-	-
config show	Y	Y	-	-
config get	(raw value)	-	-	-
config set	(success msg)	-	-	-
entity list	-	Y	Y (default)	-
entity delete	Y	Y	-	Y
event list	Y (table)	Y	-	-
event status	Y	Y	-	-
status	Y	Y	-	-
help	Y	Y (--json)	-	-

7.2 JSON Envelope Format

There are two related envelope formats:

formatJsonEnvelope — used by config show, status, and import for --output json:

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

formatAgentEnvelope — used by all commands in agent mode (--json/--agent). Same structure, but data is passed through sanitizeAgentData(command, data) to project only the most relevant fields:

Command	Fields in data
add	[{id, memory, event}] or [{status, event_id}] for PENDING
search	[{id, memory, score, created_at, categories}]
list	[{id, memory, created_at, categories}]
get	{id, memory, created_at, updated_at, categories, metadata}
update	{id, memory}
delete	(raw API response)
entity list	[{name, type, count}]
event list	[{id, event_type, status, latency, created_at}]
event status	{id, event_type, status, latency, created_at, updated_at, results: [{id, event, user_id, memory}]}
status/config/import	(pass-through)

Error envelopes (on non-zero exit):

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

Fields:

• status: "success" or "error".
• command: The command name.
• duration_ms: Optional, elapsed time in milliseconds.
• scope: Optional, active entity scope (omitted if empty).
• count: Optional, result count.
• error: Only present when status is "error".
• data: The primary payload (sanitized in agent mode).

7.3 Text Output

• formatMemoriesText: Numbered list with memory text, score, ID (first 8 chars), created date, and category, separated by . in dim color.
• formatSingleMemory: Boxed panel (boxen/Rich Panel) showing memory text, ID, created date, updated date, metadata, and categories.
• formatAddResult: Event-based output with icons (+, ~, -, .) and labels.

7.4 Table Output

Uses cli-table3 (Node) or rich.table.Table (Python) with columns:

• ID (first 8 chars, dim)
• Memory (truncated to 60 chars with "...")
• Category (first category from array)
• Created (YYYY-MM-DD)

7.5 Quiet Mode

Commands that support --output quiet (add, update, delete, entity delete) produce no stdout output in quiet mode. The operation still executes. Exit code indicates success/failure.

7.6 Error Output

• Errors always go to stderr. Both CLIs use a separate stderr console:
  • Python: Console(stderr=True) for print_error calls.
  • Node: console.error() in printError, spinner on process.stderr stream.
• Data always goes to stdout. JSON output, table output, and text output all go to stdout.

7.7 Unicode Symbol Degradation

The _sym/sym function selects symbols based on terminal capability:

Condition	Fancy Symbol	Plain Fallback
!stdout.isTTY or NO_COLOR env set	-	Used
Interactive TTY with color	Used	-

Symbol	Fancy	Plain
Success	checkmark	[ok]
Error	X	[error]
Warning	warning triangle	[warn]
Info	diamond	*

7.8 Result Summary Footer

After list/search results, a summary line is printed in dim:

  10 results . page 1 . user id=alice . 0.45s

Format: {count} result(s) . page {n} . {scope} . {elapsed}s

7.9 Date Formatting

All dates are normalized to YYYY-MM-DD format for display. The formatting handles ISO 8601 strings with Z timezone suffix by replacing it with +00:00 before parsing.

---

8. Agent-Friendly Design Decisions

Why --dry-run exists on destructive commands

The delete command (all modes) and entity delete support --dry-run. This lets AI agents preview the effect of a destructive operation before committing. For delete <id>, it fetches the memory and displays it. For delete --all, it lists matching memories and shows the count. For delete --entity / entity delete, it shows the scope that would be affected.

Why --force exists

Destructive commands (delete --all, delete --entity, entity delete) require interactive confirmation by default. The --force flag skips this confirmation, which is essential for:

• AI agents (non-interactive)
• CI/CD pipelines
• Scripting

Why --json/--agent global flags exist

The --json and --agent flags (aliases of each other) activate agent mode globally. When set:

1. All output becomes a structured JSON envelope ({status, command, duration_ms, scope, count, data}).
2. The data field is sanitized via sanitizeAgentData — only the most relevant fields are included per command, reducing noise for agents parsing the output.
3. All human-readable output (spinners, colors, banners, timing lines) is suppressed.
4. Errors are emitted as JSON to stdout with a non-zero exit code, not to stderr as text.

This is distinct from --output json, which returns the raw API response without sanitization.

Why --output json is on every command

Every data-returning command supports --output json (or --json for help). This enables machine consumption by AI agents and scripts. JSON output goes to stdout while human-readable spinners/timing go to stderr, so piping mem0 list -o json | jq . works cleanly.

Why stdin is supported

Commands add, search, and update can read from stdin when piped. This enables composability:

echo "I prefer dark mode" | mem0 add -u alice
cat query.txt | mem0 search -u alice
echo "updated text" | mem0 update abc-123

Why help --json exists

The help --json command outputs the complete CLI specification in machine-readable JSON. AI agents can call this once to discover all available commands, their arguments, options, and valid values -- enabling self-documenting tool use.

Why errors go to stderr

All error messages, warnings, spinners, and timing information go to stderr. This means --output json produces only valid JSON on stdout, with no interleaved human-readable messages. An AI agent can safely parse stdout as JSON.

---

9. Adding a New Command

Step-by-step guide for adding a new command to both CLIs.

Step 1: Add to cli-spec.json

Add a new entry to the commands array with all required fields:

{
  "name": "my-command",
  "description": "What this command does.",
  "usage": "mem0 my-command <arg> [OPTIONS]",
  "needsBackend": true,
  "needsConfig": true,
  "resolveIds": true,
  "resolveGraph": false,
  "confirmDangerous": false,
  "outputFormats": ["text", "json"],
  "defaultOutput": "text",
  "arguments": [
    {
      "name": "arg",
      "type": "string",
      "required": true,
      "help": "Argument description."
    }
  ],
  "options": [
    {
      "name": "user_id",
      "flags": ["--user-id", "-u"],
      "type": "string",
      "help": "Scope to user.",
      "panel": "Scope"
    },
    {
      "name": "output",
      "flags": ["--output", "-o"],
      "type": "string",
      "default": "text",
      "help": "Output format.",
      "panel": "Output"
    }
  ],
  "apiEndpoint": "myEndpoint"
}

If the command calls a new API endpoint, also add it to api.endpoints.

Step 2: Add Backend Method (if new API endpoint)

Python (python/src/mem0_cli/backend/base.py and platform.py):

1. Add abstract method to Backend ABC in base.py.
2. Implement in PlatformBackend in platform.py.

Node (node/src/backend/base.ts and platform.ts):

1. Add method signature to Backend interface in base.ts.
2. Implement in PlatformBackend class in platform.ts.

Step 3: Add Command Handler

Python (python/src/mem0_cli/commands/): Create a function cmd_my_command(backend, ...) in the appropriate commands file. Follow the patterns:

• Use timed_status(err_console, "...") for API calls.
• Use print_error(err_console, ...) for errors.
• Use format_json(console, ...) for JSON output.
• Raise typer.Exit(1) on errors.

Node (node/src/commands/): Create an async function cmdMyCommand(backend, ...). Follow the patterns:

• Use await timedStatus("...", async () => { ... }) for API calls.
• Use printError(...) for errors.
• Use formatJson(...) for JSON output.
• Call process.exit(1) on errors.

Step 4: Register in App Entrypoint

Python (python/src/mem0_cli/app.py):

@app.command(name="my-command")
def my_command(
    arg: str = typer.Argument(..., help="..."),
    output: str = typer.Option("text", "--output", "-o", help="...", rich_help_panel="Output"),
    api_key: str | None = typer.Option(None, "--api-key", help="...", rich_help_panel="Connection"),
    base_url: str | None = typer.Option(None, "--base-url", help="...", rich_help_panel="Connection"),
) -> None:
    """Command description."""
    from mem0_cli.commands.my_module import cmd_my_command
    backend, config = _get_backend_and_config(api_key, base_url)
    ids = _resolve_ids(config, ...)
    cmd_my_command(backend, arg, **ids, output=output)

Node (node/src/index.ts):

program
  .command("my-command <arg>")
  .description("Command description.")
  .option("-o, --output <format>", "Output format.", "text")
  .option("--api-key <key>", "Override API key.")
  .option("--base-url <url>", "Override API base URL.")
  .action(async (arg, opts) => {
    const { cmdMyCommand } = await import("./commands/my-module.js");
    const { backend, config } = getBackendAndConfig(opts.apiKey, opts.baseUrl);
    const ids = resolveIds(config, opts);
    await cmdMyCommand(backend, arg, { ...ids, output: opts.output });
  });

Step 5: Add Help Examples

Both CLIs include examples in the help text:

• Python: In the docstring of the Typer command function.
• Node: Via .addHelpText("after", "\nExamples:\n $ mem0 ...").

Step 6: Add to Help Display and Command Order

Node (node/src/help.ts):

1. Add "my-command" to COMMAND_ORDER array (determines display order in --help).
2. Add option-to-panel mappings in OPTION_PANELS["my-command"].

Python: Options are assigned to panels via rich_help_panel="..." on each typer.Option(). The help command's _build_help_json() function needs a new entry.

Step 7: Add to help Command Output

Python (python/src/mem0_cli/app.py):

1. Add entry in _build_help_json() dict.
2. Add line in the help command's human-readable output.

Node (node/src/index.ts): Add line in the help command's human-readable output listing.

Step 8: Add Tests

• Python: Add tests in python/tests/.
• Node: Add tests in node/src/__tests__/ or similar.

Step 9: Update This Specification

Add the command to the Complete Command Reference (Section 3) with all arguments, options, behavior notes, and examples.

---

10. Adding a New Language Implementation

To add a new language implementation (e.g., Go, Rust, Ruby), you need to replicate the exact behavioral contract defined in cli-spec.json and this document. Here is what is required:

10.1 Core Modules to Implement

Module	Purpose
config	Load ~/.mem0/config.json, apply env var overrides, enforce precedence. Implement load_config, save_config, ensure_config_dir, redact_key, get_nested_value, set_nested_value.
backend/base	Define the Backend interface/trait with all 8 methods: add, search, get, list_memories, update, delete, delete_entities, status, entities. Define error types: AuthError, NotFoundError, APIError.
backend/platform	Implement PlatformBackend with HTTP client. Must implement _build_filters logic exactly. Must handle response normalization. Must set Authorization: Token <key> header. 30s timeout.
branding	Implement print helpers (print_success, print_error, print_warning, print_info, print_scope), print_banner, timed_status pattern, sym function for Unicode degradation. Colors must match the hex values in cli-spec.json.
output	Implement format_memories_text, format_memories_table, format_single_memory, format_add_result, format_json, format_json_envelope, print_result_summary. Date formatting to YYYY-MM-DD. ID truncation to 8 chars. Memory text truncation to 60 chars in tables.
commands/	Implement all command handlers matching the exact behavior described in Section 3.
app/main	CLI entrypoint with all commands registered. Implement resolve_ids, resolve_graph, stdin detection, and the getBackendAndConfig helper.
help	Implement help formatter with grouped option panels (Scope, Search, Pagination, Filters, Output, Connection). Implement help --json output.

10.2 Behavioral Checklist

Every new implementation MUST:

• Read and respect cli-spec.json for all command names, descriptions, argument names, option flags, and defaults
• Implement config precedence: CLI flags > env vars > config file > defaults
• Implement entity ID resolution (explicit IDs only vs. all defaults)
• Implement graph tri-state (--no-graph > --graph > config default)
• Implement category parsing (JSON first, comma-split fallback)
• Implement stdin detection and reading for add, search, update
• Implement _build_filters with AND/OR structure
• Implement response normalization (array vs {results} vs {memories})
• Set config directory permissions to 0700 and file to 0600
• Implement timed status with spinner on stderr + elapsed time
• Implement error hierarchy (AuthError 401, NotFoundError 404, APIError 400)
• Implement delete --all --project with wildcard * entity IDs and async response handling
• Implement non-interactive init when both --api-key and --user-id provided
• Implement --dry-run on delete (all modes) and entity delete
• Implement --force on delete --all, delete --entity, and entity delete
• Send errors to stderr, data to stdout
• Implement Unicode symbol degradation for non-TTY/NO_COLOR
• Implement JSON envelope format for status, config show, import
• Support --output on all data-returning commands
• Implement help --json for machine-readable command discovery
• Implement masked API key input during init (echo * per character)
• Implement confirmation prompts for dangerous commands (unless --force)
• Binary must be named mem0

10.3 Package Metadata

Follow the naming conventions:

• Package description: "The official CLI for mem0 -- the memory layer for AI agents"
• Author: mem0.ai <founders@mem0.ai>
• License: Apache-2.0
• Keywords: mem0, memory, ai, agents, cli

10.4 Testing

Conformance tests should verify:

• All commands from cli-spec.json are registered
• All options from cli-spec.json are accepted
• Config precedence is correct
• Entity ID resolution matches the spec
• Filter building produces correct structures
• Output modes produce expected formats
• Error codes are mapped correctly
• Stdin reading works for supported commands