feat: add one-click Docker setup for OpenClaw + Mem0

2026-04-01 10:55:50 +05:30
478 changed files with 26615 additions and 40301 deletions
@@ -1,20 +0,0 @@
-{
-  "name": "mem0-plugins",
-  "interface": {
-    "displayName": "Mem0 Plugins"
-  },
-  "plugins": [
-    {
-      "name": "mem0",
-      "source": {
-        "source": "local",
-        "path": "./mem0-plugin"
-      },
-      "policy": {
-        "installation": "AVAILABLE",
-        "authentication": "ON_INSTALL"
-      },
-      "category": "Productivity"
-    }
-  ]
-}
@@ -7,7 +7,6 @@ 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
@@ -39,7 +38,7 @@ jobs:
      #     packages_dir: dist/

      - name: Publish distribution 📦 to PyPI
-        if: startsWith(github.ref, 'refs/tags/v')
+        if: startsWith(github.ref, 'refs/tags')
        uses: pypa/gh-action-pypi-publish@release/v1
        with:
          packages_dir: dist/
@@ -1,46 +0,0 @@
-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: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Build
-        run: pnpm run build
-
-      - name: Publish to npm
-        run: |
-          if [ "${{ github.event.release.prerelease }}" = "true" ]; then
-            PREID=$(node -p "require('./package.json').version.split('-')[1].split('.')[0]")
-            npx npm@latest publish --provenance --access public --tag "$PREID"
-          else
-            npx npm@latest publish --provenance --access public
-          fi
@@ -1,34 +0,0 @@
-name: Publish mem0-cli 🐍 distributions 📦 to PyPI
-
-on:
-  release:
-    types: [published]
-
-jobs:
-  build-n-publish:
-    name: Build and publish mem0-cli 📦 to PyPI
-    if: startsWith(github.event.release.tag_name, 'cli-v')
-    runs-on: ubuntu-latest
-    permissions:
-      id-token: write
-    defaults:
-      run:
-        working-directory: cli/python
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-
-      - name: Install Hatch
-        run: pip install hatch
-
-      - name: Build a binary wheel and a source tarball
-        run: hatch build --clean
-
-      - name: Publish distribution 📦 to PyPI
-        uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          packages-dir: cli/python/dist/
@@ -1,46 +0,0 @@
-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: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Build
-        run: pnpm build
-
-      - name: Publish to npm
-        run: |
-          if [ "${{ github.event.release.prerelease }}" = "true" ]; then
-            PREID=$(node -p "require('./package.json').version.split('-')[1].split('.')[0]")
-            npx npm@latest publish --provenance --access public --tag "$PREID"
-          else
-            npx npm@latest publish --provenance --access public
-          fi
@@ -1,46 +0,0 @@
-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: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Build
-        run: pnpm run build
-
-      - name: Publish to npm
-        run: |
-          if [ "${{ github.event.release.prerelease }}" = "true" ]; then
-            PREID=$(node -p "require('./package.json').version.split('-')[1].split('.')[0]")
-            npx npm@latest publish --provenance --access public --tag "$PREID"
-          else
-            npx npm@latest publish --provenance --access public
-          fi
@@ -1,46 +0,0 @@
-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: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Build
-        run: pnpm run build
-
-      - name: Publish to npm
-        run: |
-          if [ "${{ github.event.release.prerelease }}" = "true" ]; then
-            PREID=$(node -p "require('./package.json').version.split('-')[1].split('.')[0]")
-            npx npm@latest publish --provenance --access public --tag "$PREID"
-          else
-            npx npm@latest publish --provenance --access public
-          fi
@@ -1,580 +0,0 @@
-# AGENTS.md
-
-This file provides context for AI coding assistants (Claude Code, Cursor, GitHub Copilot, Codex, etc.) working with the Mem0 repository.
-
-## Project Overview
-
-**Mem0** ("mem-zero") is an intelligent memory layer for AI agents and assistants. It provides persistent, personalized memory via both a hosted platform API and self-hosted open-source SDKs.
-
- **Repository**: https://github.com/mem0ai/mem0
- **Documentation**: https://docs.mem0.ai
- **License**: Apache-2.0
-
-## Repository Structure
-
-This is a **polyglot monorepo** containing Python and TypeScript packages, CLIs, servers, plugins, documentation, and evaluation tooling.
-
-### Key Directories
-
-| Directory | Description |
-|-----------|-------------|
-| `mem0/` | Core Python SDK (`mem0ai` on PyPI) — memory, LLMs, embeddings, vector stores, graphs, rerankers |
-| `mem0-ts/` | TypeScript SDK (`mem0ai` on npm) — client + OSS memory |
-| `cli/python/` | Python CLI (`mem0-cli` on PyPI) — Typer-based, entry point `mem0` |
-| `cli/node/` | Node CLI (`@mem0/cli` on npm) — Commander-based, entry point `mem0` |
-| `vercel-ai-sdk/` | `@mem0/vercel-ai-provider` — Vercel AI SDK memory provider |
-| `openclaw/` | `@mem0/openclaw-mem0` — OpenClaw plugin for Claude Code / AI editors |
-| `server/` | FastAPI REST server for self-hosted Mem0 (Docker: FastAPI + PostgreSQL/pgvector + Neo4j) |
-| `openmemory/` | Self-hosted memory platform — `api/` (FastAPI + Alembic + MCP server) and `ui/` (Next.js 15 + React 19) |
-| `mem0-plugin/` | AI editor plugins (Claude Code, Cursor, Codex) — MCP server connection, lifecycle hooks, skills |
-| `skills/` | Claude Code skill definitions — `mem0/`, `mem0-cli/`, `mem0-vercel-ai-sdk/` |
-| `docs/` | Documentation site (Mintlify) |
-| `tests/` | Python SDK tests (pytest) |
-| `evaluation/` | Benchmarking framework — LOCOMO evals, experiment runner, score generation |
-| `examples/` | Sample projects — demo apps, Chrome extension, multi-agent patterns |
-| `cookbooks/` | Jupyter notebooks — customer support chatbot, AutoGen integration |
-| `embedchain/` | Legacy Embedchain RAG framework (maintained separately, Poetry-based) |
-| `pr-reviews/` | Pull request review materials |
-
-### Core Package Dependencies
-
-```
-mem0 (Python SDK)          mem0-ts (TypeScript SDK)
-├── mem0/memory/           ├── src/client/        (MemoryClient — hosted)
-├── mem0/llms/             └── src/oss/           (Memory — self-hosted)
-├── mem0/embeddings/           ├── src/llms/
-├── mem0/vector_stores/        ├── src/embeddings/
-├── mem0/graphs/               ├── src/vector_stores/
-└── mem0/reranker/             └── src/graphs/
-
-cli/python/ ──▶ mem0ai (optional, for OSS mode)
-cli/node/   ──▶ mem0ai (npm, for API calls)
-vercel-ai-sdk/ ──▶ ai, @ai-sdk/* providers
-openclaw/   ──▶ mem0ai (npm)
-```
-
-## Development Setup
-
-### Requirements
-
- **Python**: 3.9+ (3.10+ for CLI)
- **Node.js**: v18+ (v20 or v22 recommended)
- **pnpm**: v10+ (`npm install -g pnpm@10`) — used for all TypeScript packages
- **Hatch**: Python build/environment tool (`pip install hatch`)
- **Docker**: Required for `server/` and `openmemory/` development
-
-### Initial Setup
-
-```bash
-# Python SDK
-hatch shell dev_py_3_11           # creates environment with all deps
-pre-commit install                # install git hooks
-
-# TypeScript packages
-cd mem0-ts && pnpm install        # TS SDK
-cd cli/node && pnpm install       # Node CLI
-cd vercel-ai-sdk && pnpm install  # Vercel AI provider
-cd openclaw && pnpm install       # OpenClaw plugin
-```
-
-## Build, Lint, and Test Commands
-
-### Python SDK (`mem0/`)
-
-```bash
-# Environment setup (uses Hatch)
-hatch shell dev_py_3_11           # or dev_py_3_9, dev_py_3_10, dev_py_3_12
-
-# Linting and formatting
-make lint                          # ruff check
-make format                        # ruff format
-make sort                          # isort mem0/
-
-# Tests
-make test                          # pytest tests/
-make test-py-3.9                   # test specific Python version (3.9–3.12)
-
-# Build and publish
-make build                         # hatch build
-make publish                       # hatch publish
-```
-
- **Python:** 3.9, 3.10, 3.11, 3.12
- **Linter/formatter:** Ruff (line length **120**)
- **Import sorting:** isort (`profile = "black"`)
- **Test framework:** pytest (with pytest-mock, pytest-asyncio)
- **Pre-commit hooks:** ruff + isort — run `pre-commit install` before committing
-
-### TypeScript SDK (`mem0-ts/`)
-
-```bash
-cd mem0-ts
-pnpm install
-pnpm run build                     # tsup
-pnpm run test                      # jest (all tests)
-pnpm run test:unit                 # jest --coverage (unit tests only)
-pnpm run test:integration          # jest (integration tests, needs MEM0_API_KEY)
-pnpm run test:ci                   # jest --coverage --ci (CI mode)
-pnpm run test:watch                # jest watch mode
-```
-
- **Node:** 20, 22 (CI-tested)
- **Build:** tsup (CJS + ESM)
- **Test:** jest
- **Formatter:** prettier
-
-### Python CLI (`cli/python/`)
-
-```bash
-cd cli/python
-pip install -e ".[dev]"            # dev install with ruff + pytest
-ruff check .                       # lint
-ruff format .                      # format
-pytest                             # test
-hatch build                        # build
-```
-
- **Python:** 3.10+ (not 3.9)
- **Linter/formatter:** Ruff (line length **100** — different from root SDK)
- **Ruff rules:** E, F, I, W, UP, B, SIM, RUF (ignores E501, B008 for Typer patterns, SIM108)
- **Framework:** Typer + Rich + httpx
- **Entry point:** `mem0 = "mem0_cli.app:main"`
- **Source layout:** `src/mem0_cli/`
- **Optional dependency:** `mem0ai` (for OSS mode, via `[oss]` extra)
-
-### Node CLI (`cli/node/`)
-
-```bash
-cd cli/node
-pnpm install
-pnpm run build                     # tsup
-pnpm run lint                      # biome check src/
-pnpm run lint:fix                  # biome check --write src/
-pnpm run typecheck                 # tsc --noEmit
-pnpm run test                      # vitest run
-pnpm run test:watch                # vitest (watch mode)
-pnpm run dev                       # tsx src/index.ts (development)
-```
-
- **Node:** 18+ required
- **Build:** tsup (ESM)
- **Linter:** Biome (not ESLint, not Ruff)
- **Test:** vitest (not jest)
- **Framework:** Commander + Chalk + ora + cli-table3
-
-### Vercel AI SDK Provider (`vercel-ai-sdk/`)
-
-```bash
-cd vercel-ai-sdk
-pnpm install
-pnpm run build                     # tsup
-pnpm run lint                      # eslint
-pnpm run type-check                # tsc --noEmit
-pnpm run prettier-check            # prettier --check
-pnpm run test                      # jest
-pnpm run test:edge                 # vitest (edge runtime)
-pnpm run test:node                 # vitest (node runtime)
-```
-
- **Build:** tsup (CJS + ESM)
- **Lint:** ESLint + Prettier
- **Test:** jest + vitest (edge/node configs)
-
-### OpenClaw Plugin (`openclaw/`)
-
-```bash
-cd openclaw
-pnpm install
-pnpm run build                     # tsup
-pnpm run test                      # vitest run
-```
-
- **Build:** tsup (ESM)
- **Test:** vitest (with Codecov in CI)
- **Plugin manifest:** `openclaw.plugin.json`
-
-### Server (`server/`)
-
-```bash
-# Docker production build
-cd server
-make build                         # docker build -t mem0-api-server .
-make run_local                     # docker run -p 8000:8000 with .env
-
-# Docker Compose development (FastAPI + PostgreSQL/pgvector + Neo4j)
-cd server
-docker-compose up                  # starts all 3 services
-# mem0 API: localhost:8888
-# PostgreSQL: localhost:8432
-# Neo4j HTTP: localhost:8474, Bolt: localhost:8687
-```
-
- **Framework:** FastAPI with uvicorn (auto-reload in dev)
- **Services:** PostgreSQL with pgvector, Neo4j 5.x with APOC plugin
- **Hot reload:** Dev Dockerfile mounts `server/` and `mem0/` for live changes
-
-### OpenMemory (`openmemory/`)
-
-```bash
-# Full stack via Docker Compose
-cd openmemory
-docker-compose up
-# Qdrant: localhost:6333
-# API (MCP): localhost:8765
-# UI: localhost:3000
-
-# Individual development
-cd openmemory/api && uvicorn main:app --reload       # FastAPI backend
-cd openmemory/ui && npm run dev                       # Next.js frontend
-
-# Tests
-cd openmemory/api && pytest tests/                   # API tests (e.g., test_mcp_server.py)
-```
-
- **API:** FastAPI + Alembic (DB migrations) + MCP server (Model Context Protocol)
- **UI:** Next.js 15, React 19, Radix UI, Redux Toolkit, TailwindCSS, Recharts
- **Vector store:** Qdrant
-
-### Documentation (`docs/`)
-
-```bash
-make docs                          # or: cd docs && mintlify dev
-```
-
- **Framework:** Mintlify
- **API spec:** `docs/openapi.json`
- **Structure:** `api-reference/`, `open-source/`, `platform/`, `integrations/`, `cookbooks/`, `core-concepts/`
-
-### Evaluation (`evaluation/`)
-
-```bash
-cd evaluation
-make run-mem0-add                  # Run mem0 add experiments
-make run-mem0-search               # Run mem0 search experiments
-make run-mem0-plus-add             # With graph memory
-make run-mem0-plus-search          # With graph memory
-make run-rag                       # RAG baseline
-make run-full-context              # Full context baseline
-make run-langmem                   # LangMem comparison
-make run-openai                    # OpenAI comparison
-```
-
-## Core APIs
-
-### Python
-
-| Function / Class | Purpose | Import |
-|-----------------|---------|--------|
-| `Memory` | Self-hosted memory (sync) | `from mem0 import Memory` |
-| `AsyncMemory` | Self-hosted memory (async) | `from mem0 import AsyncMemory` |
-| `MemoryClient` | Hosted platform client (sync) | `from mem0 import MemoryClient` |
-| `AsyncMemoryClient` | Hosted platform client (async) | `from mem0 import AsyncMemoryClient` |
-
-**Key `Memory` / `MemoryClient` methods:**
-
-| Method | Purpose |
-|--------|---------|
-| `add(messages, *, user_id, agent_id, run_id, metadata)` | Store a new memory |
-| `search(query, *, user_id, agent_id, run_id, limit, filters)` | Search memories |
-| `get(memory_id)` | Retrieve a single memory by ID |
-| `get_all(*, user_id, agent_id, run_id, limit)` | List all memories |
-| `update(memory_id, data)` | Update a memory |
-| `delete(memory_id)` | Delete a memory |
-| `delete_all(*, user_id, agent_id, run_id)` | Delete all memories |
-| `history(memory_id)` | Get change history for a memory |
-
-### TypeScript
-
-| Export | Purpose | Import |
-|--------|---------|--------|
-| `MemoryClient` | Hosted platform client | `import { MemoryClient } from 'mem0ai'` |
-| `Memory` | Self-hosted OSS memory | `import { Memory } from 'mem0ai/oss'` |
-
-## Import Patterns
-
-### Python
-
-| What | Import |
-|------|--------|
-| Core memory classes | `from mem0 import Memory, AsyncMemory` |
-| Platform client | `from mem0 import MemoryClient, AsyncMemoryClient` |
-| Configuration | `from mem0.configs.base import MemoryConfig` |
-| LLM providers | `from mem0.llms.<provider> import <ProviderLLM>` |
-| Embedding providers | `from mem0.embeddings.<provider> import <ProviderEmbedding>` |
-| Vector store providers | `from mem0.vector_stores.<provider> import <ProviderVectorStore>` |
-
-### TypeScript
-
-| What | Import |
-|------|--------|
-| Hosted client | `import { MemoryClient } from 'mem0ai'` |
-| OSS memory | `import { Memory } from 'mem0ai/oss'` |
-| Specific providers (OSS) | `import { OpenAIEmbedding } from 'mem0ai/oss'` |
-
-## Coding Standards
-
-### File Naming Conventions
-
- **Python source files:** `snake_case.py` (e.g., `azure_openai.py`, `cohere_reranker.py`)
- **Python test files:** `test_<module>.py` (e.g., `test_memory.py`, `test_main.py`)
- **TypeScript source files:** `snake_case.ts` (e.g., `azure_ai_search.ts`)
- **TypeScript test files:** `<module>.test.ts` (e.g., `memory.test.ts`)
- **Config/manifest files:** `kebab-case` (e.g., `openclaw.plugin.json`, `jest.config.js`)
-
-### Python Conventions
-
- **Provider pattern:** All providers (LLMs, embeddings, vector stores, graphs, rerankers) inherit from a `base.py` abstract class in their directory. Config classes live in `configs.py`.
- **Pydantic v2** for all data models and configuration.
- **Ruff** is the single linting and formatting tool — no black, no flake8.
-  - Root SDK: line length **120**
-  - Python CLI: line length **100** with extended rule set (UP, B, SIM, RUF)
- **isort** with `profile = "black"` for import sorting.
- Ruff excludes `embedchain/` and `openmemory/` from root config.
-
-### TypeScript Conventions
-
- **Build:** tsup across all packages.
- **Package manager:** pnpm everywhere (no npm, no yarn).
- **TypeScript strict mode** across all packages.
- **Linting varies by package:**
-
-| Package | Linter | Formatter | Test Framework |
-|---------|--------|-----------|---------------|
-| `mem0-ts/` | — | Prettier | jest |
-| `cli/node/` | Biome | Biome | vitest |
-| `vercel-ai-sdk/` | ESLint | Prettier | jest + vitest |
-| `openclaw/` | — | — | vitest |
-
-### Type Checking
-
-Always run type checking after modifying TypeScript code:
-
-```bash
-cd <package> && pnpm run typecheck    # or: tsc --noEmit
-```
-
-## Architecture
-
-### Provider Pattern
-
-The SDK uses a consistent plugin architecture across 5 categories. Each category has a `base.py` abstract class and concrete provider implementations:
-
-| Category | Count | Examples |
-|----------|-------|---------|
-| **LLMs** | 24 | OpenAI, Anthropic, AWS Bedrock, Azure OpenAI, Gemini, Groq, Ollama, Together, DeepSeek, vLLM, LiteLLM, LM Studio, xAI |
-| **Vector Stores** | 30 | Qdrant, Pinecone, Chroma, Weaviate, Milvus, MongoDB, Redis, Elasticsearch, pgvector, Supabase, Faiss, S3 Vectors |
-| **Embeddings** | 15 | OpenAI, Azure OpenAI, Gemini, HuggingFace, FastEmbed, Together, AWS Bedrock, Ollama, Vertex AI |
-| **Graph Stores** | 4 | Neo4j, Memgraph, Kuzu, Apache AGE |
-| **Rerankers** | 5 | Cohere, HuggingFace, LLM-based, Sentence Transformer, Zero Entropy |
-
-### Two Usage Modes
-
-Self-hosted `Memory` / `AsyncMemory` classes and hosted-platform `MemoryClient` — both in Python and TypeScript.
-
-### Graph Memory
-
-Optional layer on top of vector memory for relationship-aware retrieval. Configured via the `graph` section of `MemoryConfig`.
-
-### MCP Integration
-
-Model Context Protocol support in multiple places:
-
- **Remote:** MCP server at `mcp.mem0.ai`
- **Local:** MCP server in `openmemory/api/` (FastAPI-based)
- **Plugin:** MCP tools in `mem0-plugin/` — 9 tools: `add_memory`, `search_memories`, `get_memories`, `get_memory`, `update_memory`, `delete_memory`, `delete_all_memories`, `delete_entities`, `list_entities`
-
-### Plugin & Skills System
-
- `mem0-plugin/` provides integrations for Claude Code, Cursor, and Codex via MCP server connections and lifecycle hooks for automatic memory capture.
- `skills/` contains structured skill definitions for AI agents, covering SDK usage, CLI workflows, and Vercel AI SDK patterns.
-
-### Adding a New Provider
-
-To add a new LLM, embedding, vector store, or reranker provider:
-
-1. Create `mem0/<category>/<provider_name>.py`
-2. Inherit from the abstract base class in `mem0/<category>/base.py`
-3. Add configuration to `mem0/<category>/configs.py` (if the category uses one)
-4. Register the provider in `mem0/<category>/__init__.py`
-5. Add tests in `tests/<category>/<provider_name>/`
-6. Add any new dependencies to the appropriate optional group in `pyproject.toml` (never to core `dependencies`)
-7. Follow the exact pattern of existing providers in the same category — match method signatures, error handling, and config structure
-
-## CI/CD
-
-### CI Workflows (automated testing)
-
-| Workflow | File | Triggers | Tests |
-|----------|------|----------|-------|
-| Python SDK | `ci.yml` | Push to main, PRs on `mem0/`, `tests/`, `pyproject.toml` | Ruff lint + pytest on Python 3.10, 3.11, 3.12 |
-| TypeScript SDK | `ts-sdk-ci.yml` | Push to main, PRs on `mem0-ts/` | Prettier + build + jest on Node 20, 22 |
-| Python CLI | `cli-python-ci.yml` | Push to `cli/python/`, PRs, manual | Ruff lint + pytest + hatch build on Python 3.10, 3.11, 3.12 |
-| Node CLI | `cli-node-ci.yml` | Push to `cli/node/`, PRs, manual | Biome lint + tsc + vitest + tsup build on Node 20, 22 |
-| OpenClaw | `openclaw-checks.yml` | Push to `openclaw/`, PRs, manual | tsc + vitest (with Codecov) + tsup build on Node 20, 22 |
-| Embedchain | `ci.yml` (shared) | PRs on `embedchain/` | Ruff + pytest + coverage on Python 3.9–3.12 |
-
-### CD Workflows (automated publishing)
-
-| Workflow | File | Tag Prefix | Target |
-|----------|------|------------|--------|
-| Python SDK | `cd.yml` | `v*` | PyPI (`mem0ai`) |
-| TypeScript SDK | `ts-sdk-cd.yml` | `ts-v*` | npm (`mem0ai`) |
-| Python CLI | `cli-python-cd.yml` | `cli-v*` | PyPI (`mem0-cli`) |
-| Node CLI | `cli-node-cd.yml` | `cli-node-v*` | npm (`@mem0/cli`) |
-| Vercel AI SDK | `vercel-ai-cd.yml` | `vercel-ai-v*` | npm (`@mem0/vercel-ai-provider`) |
-| OpenClaw | `openclaw-cd.yml` | `openclaw-v*` | npm (`@mem0/openclaw-mem0`) |
-
- All publishing uses **OIDC trusted publishing** — no tokens or secrets required.
- First publish of a new npm package must be done manually; OIDC works for subsequent versions.
-
-### Utility Workflows
-
-| Workflow | File | Purpose |
-|----------|------|---------|
-| Issue Labeler | `issue-labeler.yml` | Automatic issue labeling |
-| Stale Bot | `stale.yml` | Marks stale issues and PRs |
-
-## Task Completion Guidelines
-
-These guidelines outline typical artifacts for different task types. Use judgment to adapt based on scope and context.
-
-### Bug Fixes
-
-1. **Unit tests**: Add tests that would fail without the fix (regression tests)
-2. **Implementation**: Fix the bug
-3. **Manual verification**: Run the relevant test suite to confirm the fix
-4. **Lint**: Run the appropriate linter for the package you modified
-
-### New Features
-
-1. **Implementation**: Build the feature following existing patterns
-2. **Unit tests**: Comprehensive test coverage for new functionality
-3. **Documentation**: Update relevant docs in `docs/` for public APIs
-4. **Examples**: Add usage examples if the feature introduces new user-facing behavior
-
-### New Provider (LLM / Embedding / Vector Store / Reranker)
-
-1. **Implementation**: Follow the "Adding a New Provider" steps above
-2. **Tests**: Add unit tests matching the pattern of existing providers
-3. **Configuration**: Add to the appropriate `configs.py` and `__init__.py`
-4. **Dependencies**: Add to the correct optional group in `pyproject.toml`
-5. **Documentation**: Add an integration guide in `docs/integrations/`
-
-### Refactoring / Internal Changes
-
- Unit tests for any changed behavior
- No documentation needed for internal-only changes
- Ensure all existing tests still pass
-
-### When to Deviate
-
-These are guidelines, not rigid rules. Adjust based on:
-
- **Scope**: Trivial fixes (typos, comments) may not need tests
- **Visibility**: Internal changes may not need documentation
- **Context**: Some changes span multiple categories — use judgment
-
-When uncertain about expected artifacts, ask for clarification.
-
-## Contributing Guidelines
-
-### Workflow
-
-1. Fork and clone the repository.
-2. Create a feature branch from `main` (e.g., `feature/my-new-feature`).
-3. Make your changes — add tests, docs, and examples as appropriate.
-4. Run linting and tests for every package you modified (see commands above).
-5. Run `pre-commit install` on first setup — hooks run ruff + isort automatically.
-6. Commit with a clear message following [Conventional Commits](https://www.conventionalcommits.org/) (e.g., `feat:`, `fix:`, `docs:`, `refactor:`).
-7. Push and open a Pull Request against `main`.
-
-### Pull Request Requirements
-
-Every PR must follow the repo's PR template (`.github/PULL_REQUEST_TEMPLATE.md`):
-
-1. **Linked Issue** — Reference the issue with `Closes #<number>`. If no issue exists, create one first or explain why in the description.
-2. **Description** — Explain what the PR does and why it's needed.
-3. **Type of Change** — Check the appropriate box:
-   - Bug fix / New feature / Breaking change / Refactor / Documentation update
-4. **Breaking Changes** — If applicable, describe what breaks and the migration path.
-5. **Test Coverage** — Check what applies:
-   - Added/updated unit tests
-   - Added/updated integration tests
-   - Tested manually (describe how)
-   - No tests needed (explain why)
-6. **Checklist** — All must be checked before merge:
-   - [ ] Code follows the project's style guidelines
-   - [ ] Self-review performed
-   - [ ] Tests added that prove the fix/feature works
-   - [ ] New and existing tests pass locally
-   - [ ] Documentation updated if needed
-
-### PR Description Template
-
-```markdown
-## Linked Issue
-
-Closes #<!-- issue number -->
-
-## Description
-
-<!-- What does this PR do? Why is it needed? -->
-
-## Type of Change
-
- [ ] Bug fix (non-breaking change that fixes an issue)
- [ ] New feature (non-breaking change that adds functionality)
- [ ] Breaking change (fix or feature that would cause existing functionality to change)
- [ ] Refactor (no functional changes)
- [ ] Documentation update
-
-## Breaking Changes
-
-N/A
-
-## Test Coverage
-
- [ ] I added/updated unit tests
- [ ] I added/updated integration tests
- [ ] I tested manually (describe below)
- [ ] No tests needed (explain why)
-
-## Checklist
-
- [ ] My code follows the project's style guidelines
- [ ] I have performed a self-review of my code
- [ ] I have added tests that prove my fix/feature works
- [ ] New and existing tests pass locally
- [ ] I have updated documentation if needed
-```
-
-### General Rules
-
- Follow existing code patterns — don't introduce new frameworks or abstractions without discussion.
- Version bumps go in `pyproject.toml` (Python) or `package.json` (TypeScript).
- For `server/` and `openmemory/` work, use Docker Compose for local development.
- Do NOT use `pip` or `conda` for dependency management — use `hatch` (see `docs/contributing/development.mdx`).
-
-### Contributing Guides
-
-| Task | Guide |
-|------|-------|
-| Code contributions | `docs/contributing/development.mdx` |
-| Documentation contributions | `docs/contributing/documentation.mdx` |
-| PR template | `.github/PULL_REQUEST_TEMPLATE.md` |
-| Bug reports | `.github/ISSUE_TEMPLATE/bug_report.yml` |
-| Feature requests | `.github/ISSUE_TEMPLATE/feature_request.yml` |
-| Documentation issues | `.github/ISSUE_TEMPLATE/documentation_issue.yml` |
-
-## Do NOT
-
- Modify CI/CD workflows without explicit approval.
- Add new Python dependencies to the core `dependencies` list in `pyproject.toml` without discussion — use optional dependency groups instead.
- Commit `.env` files, API keys, or credentials.
- Modify `embedchain/` unless specifically working on that package — it has its own build system (Poetry).
- Skip pre-commit hooks.
- Use npm or yarn in TypeScript packages — this repo uses pnpm exclusively.
- Use `require()` for imports in TypeScript — use ES module `import` syntax.
- Mix up linter configs: root Python SDK uses line-length 120, Python CLI uses 100, Node CLI uses Biome (not ESLint/Ruff).
- Modify `openmemory/` database migrations without understanding the Alembic migration chain.
- Change public APIs without updating documentation in `docs/`.
@@ -1 +0,0 @@
-AGENTS.md
@@ -61,31 +61,3 @@ 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
@@ -266,7 +266,7 @@ config = MemoryConfig(
    graph_store=GraphStoreConfig(provider="neo4j", config={...}),  # optional
    history_db_path="~/.mem0/history.db",
    version="v1.1",
-    custom_instructions="Custom prompt...",
+    custom_fact_extraction_prompt="Custom prompt...",
    custom_update_memory_prompt="Custom prompt..."
 )
 ```
@@ -684,7 +684,7 @@ Conversation: {messages}
 """

 config = MemoryConfig(
-    custom_instructions=custom_extraction_prompt
+    custom_fact_extraction_prompt=custom_extraction_prompt
 )
 memory = Memory(config)
 ```
@@ -41,30 +41,16 @@
 <p align="center">
  <a href="https://mem0.ai/research"><strong>📄 Building Production-Ready AI Agents with Scalable Long-Term Memory →</strong></a>
 </p>
+<p align="center">
+  <strong>⚡ +26% Accuracy vs. OpenAI Memory • 🚀 91% Faster • 💰 90% Fewer Tokens</strong>
+</p>

-## New Memory Algorithm (April 2026)
+> **🎉 mem0ai v1.0.0 is now available!** This major release includes API modernization, improved vector store support, and enhanced GCP integration. [See migration guide →](MIGRATION_GUIDE_v1.0.md)

-| Benchmark | Old | New  | Tokens  | Latency p50  |
-| --- | --- | --- | --- | --- |
-| **LoCoMo** | 71.4 | **91.6** | 7.0K  | 0.88s  |
-| **LongMemEval** | 67.8 | **93.4** | 6.8K  | 1.09s  |
-| **BEAM (1M)** | — | **64.1** | 6.7K  | 1.00s  |
-| **BEAM (10M)** | — | **48.6** | 6.9K  | 1.05s  |
-
-All benchmarks run on the same production-representative model stack. Single-pass retrieval (one call, no agentic loops).
-
-**What changed:**
- **Single-pass ADD-only extraction** -- one LLM call, no UPDATE/DELETE. Memories accumulate; nothing is overwritten.
- **Agent-generated facts are first-class** -- when an agent confirms an action, that information is now stored with equal weight.
- **Entity linking** -- entities are extracted, embedded, and linked across memories for retrieval boosting.
- **Multi-signal retrieval** -- semantic, BM25 keyword, and entity matching scored in parallel and fused.
-
-See the [migration guide](https://docs.mem0.ai/migration/oss-v2-to-v3) for upgrade instructions. The [evaluation framework](https://github.com/mem0ai/memory-benchmarks) is open-sourced so anyone can reproduce the numbers.
-
-## Research Highlights
- **91.6 on LoCoMo** -- +20 points over the previous algorithm
- **93.4 on LongMemEval** -- +26 points, with +53.6 on assistant memory recall
- **64.1 on BEAM (1M)** -- production-scale memory evaluation at 1M tokens
+##  🔥 Research Highlights
+- **+26% Accuracy** over OpenAI Memory on the LOCOMO benchmark
+- **91% Faster Responses** than full-context, ensuring low-latency at scale
+- **90% Lower Token Usage** than full-context, cutting costs without compromise
 - [Read the full paper](https://mem0.ai/research)

 # Introduction
@@ -102,13 +88,6 @@ Install the sdk via pip:
 pip install mem0ai
 ```

-For enhanced hybrid search with BM25 keyword matching and entity extraction, install with NLP support:
-
-```bash
-pip install mem0ai[nlp]
-python -m spacy download en_core_web_sm
-```
-
 Install sdk via npm:
 ```bash
 npm install mem0ai
@@ -130,9 +109,7 @@ See the [CLI documentation](https://docs.mem0.ai/platform/cli) for the full comm

 ### Basic Usage

-Mem0 requires an LLM to function, with `gpt-5-mini` from OpenAI as the default. However, it supports a variety of LLMs; for details, refer to our [Supported LLMs documentation](https://docs.mem0.ai/components/llms/overview).
-
-Mem0 uses `text-embedding-3-small` from OpenAI as the default embedding model. For best results with hybrid search (semantic + keyword + entity boosting), we recommend using at least [Qwen 600M](https://huggingface.co/Alibaba-NLP/gte-Qwen2-1.5B-instruct) or a comparable embedding model. See [Supported Embeddings](https://docs.mem0.ai/components/embedders/overview) for configuration details.
+Mem0 requires an LLM to function, with `gpt-4.1-nano-2025-04-14 from OpenAI as the default. However, it supports a variety of LLMs; for details, refer to our [Supported LLMs documentation](https://docs.mem0.ai/components/llms/overview).

 First step is to instantiate the memory:

@@ -145,13 +122,13 @@ memory = Memory()

 def chat_with_memories(message: str, user_id: str = "default_user") -> str:
    # Retrieve relevant memories
-    relevant_memories = memory.search(query=message, filters={"user_id": user_id}, top_k=3)
+    relevant_memories = memory.search(query=message, user_id=user_id, limit=3)
    memories_str = "\n".join(f"- {entry['memory']}" for entry in relevant_memories["results"])

    # Generate Assistant response
    system_prompt = f"You are a helpful AI. Answer the question based on query and memories.\nUser Memories:\n{memories_str}"
    messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": message}]
-    response = openai_client.chat.completions.create(model="gpt-5-mini", messages=messages)
+    response = openai_client.chat.completions.create(model="gpt-4.1-nano-2025-04-14", messages=messages)
    assistant_response = response.choices[0].message.content

    # Create new memories from the conversation
@@ -28,7 +28,7 @@ mem0 CLI is the official command-line interface for [mem0](https://mem0.ai) -- t
 ### 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)
+- AI agents that need persistent memory (the CLI is designed with `--output json` and `help --json` specifically for machine consumption)
 - DevOps/CI pipelines that need to manage memories programmatically

 ### Project Structure
@@ -79,7 +79,6 @@ Apache-2.0
 │           ├── 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)
@@ -89,7 +88,6 @@ Apache-2.0
        ├── 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
@@ -100,7 +98,6 @@ Apache-2.0
            ├── init.ts              # runInit (interactive wizard)
            ├── config.ts            # cmdConfigShow, cmdConfigGet, cmdConfigSet
            ├── entities.ts          # cmdEntitiesList, cmdEntitiesDelete
-            ├── events.ts            # cmdEventList, cmdEventStatus
            └── utils.ts             # cmdStatus, cmdVersion, cmdImport
 ```

@@ -158,15 +155,9 @@ Interactive setup wizard for mem0 CLI.
 | `-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).
@@ -184,7 +175,6 @@ Interactive setup wizard for mem0 CLI.
 ```bash
 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
 ```
@@ -710,114 +700,7 @@ 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:**
-```json
-{
-  "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:**
-```bash
-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:**
-```json
-{
-  "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:**
-```bash
-mem0 event status evt-abc-123
-mem0 event status evt-abc-123 --output json
-```
-
---
-
-### 3.16 `status`
+### 3.14 `status`

 Check connectivity and authentication.

@@ -838,19 +721,20 @@ Check connectivity and authentication.
 | `--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.
+**Behavior:** If config has a default `user_id` or `agent_id`, validates by making a minimal `POST /v2/memories/` with `page=1&page_size=1`. Otherwise validates via `GET /v1/entities/`. Displays connection status in a boxed panel (text) or JSON envelope.

 **JSON output:**
 ```json
 {
  "status": "success",
  "command": "status",
-  "duration_ms": 112,
  "data": {
    "connected": true,
    "backend": "platform",
-    "base_url": "https://api.mem0.ai"
-  }
+    "base_url": "https://api.mem0.ai",
+    "latency_ms": 245
+  },
+  "duration_ms": 245
 }
 ```

@@ -862,7 +746,7 @@ mem0 status -o json

 ---

-### 3.17 `help`
+### 3.15 `help`

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

@@ -922,9 +806,6 @@ The auth header name is `Authorization` and the scheme is `Token` (not Bearer).
 | 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`)

@@ -1227,8 +1108,6 @@ For `PENDING` events, displays "Processing in background" with the event ID.

 ### 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     |
@@ -1243,16 +1122,12 @@ All commands also support `agent` mode via the global `--json`/`--agent` flag, w
 | 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
+### 7.2 JSON Envelope Format (`formatJsonEnvelope`)

-There are two related envelope formats:
-
-**`formatJsonEnvelope`** — used by `config show`, `status`, and `import` for `--output json`:
+Used by `config show`, `status`, and `import` for structured JSON output:

 ```json
 {
@@ -1266,39 +1141,14 @@ There are two related envelope formats:
 }
 ```

-**`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):
-```json
-{
-  "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.
+- `status`: Always `"success"` (errors go to stderr before exit).
+- `command`: The command name (e.g. `"status"`, `"config show"`, `"import"`).
 - `duration_ms`: Optional, elapsed time in milliseconds.
- `scope`: Optional, active entity scope (omitted if empty).
+- `scope`: Optional, active entity scope.
 - `count`: Optional, result count.
- `error`: Only present when `status` is `"error"`.
- `data`: The primary payload (sanitized in agent mode).
+- `error`: Optional, error message string.
+- `data`: The primary payload.

 ### 7.3 Text Output

@@ -1369,16 +1219,6 @@ Destructive commands (`delete --all`, `delete --entity`, `entity delete`) requir
 - 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.
@@ -2,8 +2,6 @@

 The official command-line interface for [mem0](https://mem0.ai) — the memory layer for AI agents. Works with the Mem0 Platform API. Available in Python and Node.js.

-> **For AI agents:** pass `--agent` (or `--json`) on any command for structured JSON output purpose-built for tool loops — sanitized fields, no colors or spinners, errors as JSON. See [Agent mode](#agent-mode) below.
-
 ## Installation

 ```bash
@@ -57,45 +55,12 @@ mem0 delete <memory-id>
 | `mem0 delete` | Delete a memory, all memories for a scope, or an entity |
 | `mem0 import` | Bulk import memories from a JSON file |
 | `mem0 config` | View or modify CLI configuration |
-| `mem0 entity` | List or delete entities (users, agents, apps, runs) |
-| `mem0 event` | Inspect background processing events (bulk deletes, large add jobs) |
+| `mem0 entities` | List or delete entities (users, agents, apps) |
 | `mem0 status` | Verify API connection and display current project |
 | `mem0 version` | Print the CLI version |

 Run `mem0 <command> --help` for detailed usage on any command.

-## 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
-```
-
-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`:
@@ -103,10 +68,13 @@ 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) |
+| `json` | Structured JSON for piping to `jq` or agent consumption |
 | `table` | Tabular format (default for `list`) |
 | `quiet` | Minimal — just IDs or status codes |
-| `agent` | Structured JSON envelope with sanitized fields (set by `--agent`/`--json`) |
+
+```bash
+mem0 search "preferences" --user-id alice --output json | jq '.data.results[].memory'
+```

 ## Environment variables

@@ -515,8 +515,7 @@
        { "name": "api-key", "flags": ["--api-key"], "type": "string", "default": null, "help": "API key (skip prompt)." },
        { "name": "user-id", "flags": ["-u", "--user-id"], "type": "string", "default": null, "help": "Default user ID (skip prompt)." },
        { "name": "email", "flags": ["--email"], "type": "string", "default": null, "help": "Login via email verification code." },
-        { "name": "code", "flags": ["--code"], "type": "string", "default": null, "help": "Verification code (use with --email for non-interactive login)." },
-        { "name": "force", "flags": ["--force"], "type": "boolean", "default": false, "help": "Overwrite existing config without confirmation." }
+        { "name": "code", "flags": ["--code"], "type": "string", "default": null, "help": "Verification code (use with --email for non-interactive login)." }
      ]
    },
    {
@@ -2,12 +2,10 @@

 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`) — for development only
+- pnpm (`npm install -g pnpm`)

 ## Installation

@@ -15,307 +13,22 @@ The official command-line interface for [mem0](https://mem0.ai) — the memory l
 npm install -g @mem0/cli
 ```

-## Quick start
+Or from source:

 ```bash
-# Interactive setup wizard
-mem0 init
+cd node
+pnpm install
+pnpm build
+pnpm link --global

-# 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>
+# Now use it like a normal CLI
+mem0 --help
 ```

-## Commands
-
-### `mem0 init`
-
-Interactive setup wizard. Prompts for your API key and default user ID.
+## Running during development

 ```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/node
+cd node
 pnpm install

 # Development mode (runs TypeScript directly, no build needed)
@@ -326,11 +39,36 @@ 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
 ```

-## Documentation
+## Quick Start

-Full documentation is available at [docs.mem0.ai/platform/cli](https://docs.mem0.ai/platform/cli).
+```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) |

 ## License

@@ -1,6 +1,6 @@
 {
  "name": "@mem0/cli",
-  "version": "0.2.3",
+  "version": "0.1.0",
  "description": "The official CLI for mem0 — the memory layer for AI agents",
  "type": "module",
  "bin": {
@@ -20,11 +20,6 @@
  },
  "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"
@@ -89,17 +89,11 @@ export interface Backend {

 	deleteEntities(opts: EntityIds): Promise<Record<string, unknown>>;

-	ping(): Promise<Record<string, unknown>>;
-
 	status(opts?: { userId?: string; agentId?: string }): Promise<
 		Record<string, unknown>
 	>;

 	entities(entityType: string): Promise<Record<string, unknown>[]>;
-
-	listEvents(): Promise<Record<string, unknown>[]>;
-
-	getEvent(eventId: string): Promise<Record<string, unknown>>;
 }

 export class AuthError extends Error {
@@ -3,8 +3,6 @@
 */

 import type { PlatformConfig } from "../config.js";
-import { isAgentMode } from "../state.js";
-import { CLI_VERSION } from "../version.js";
 import {
 	APIError,
 	type AddOptions,
@@ -26,9 +24,6 @@ export class PlatformBackend implements Backend {
 		this.headers = {
 			Authorization: `Token ${config.apiKey}`,
 			"Content-Type": "application/json",
-			"X-Mem0-Source": "cli",
-			"X-Mem0-Client-Language": "node",
-			"X-Mem0-Client-Version": CLI_VERSION,
 		};
 	}

@@ -43,14 +38,9 @@ export class PlatformBackend implements Backend {
 			url += `?${qs}`;
 		}

-		const headers = {
-			...this.headers,
-			"X-Mem0-Caller-Type": isAgentMode() ? "agent" : "user",
-		};
-
 		const fetchOpts: RequestInit = {
 			method,
-			headers,
+			headers: this.headers,
 			signal: AbortSignal.timeout(30_000),
 		};
 		if (opts?.json) {
@@ -116,7 +106,6 @@ export class PlatformBackend implements Backend {
 		if (opts.expires) payload.expiration_date = opts.expires;
 		if (opts.categories) payload.categories = opts.categories;
 		if (opts.enableGraph) payload.enable_graph = true;
-		payload.source = "CLI";

 		return (await this._request("POST", "/v1/memories/", {
 			json: payload,
@@ -177,7 +166,6 @@ export class PlatformBackend implements Backend {
 		if (opts.keyword) payload.keyword_search = true;
 		if (opts.fields) payload.fields = opts.fields;
 		if (opts.enableGraph) payload.enable_graph = true;
-		payload.source = "CLI";

 		const result = (await this._request("POST", "/v2/memories/search/", {
 			json: payload,
@@ -188,9 +176,10 @@ export class PlatformBackend implements Backend {
 	}

 	async get(memoryId: string): Promise<Record<string, unknown>> {
-		return (await this._request("GET", `/v1/memories/${memoryId}/`, {
-			params: { source: "CLI" },
-		})) as Record<string, unknown>;
+		return (await this._request("GET", `/v1/memories/${memoryId}/`)) as Record<
+			string,
+			unknown
+		>;
 	}

 	async listMemories(
@@ -228,7 +217,6 @@ export class PlatformBackend implements Backend {
 		});
 		if (apiFilters) payload.filters = apiFilters;
 		if (opts.enableGraph) payload.enable_graph = true;
-		payload.source = "CLI";

 		const result = (await this._request("POST", "/v2/memories/", {
 			json: payload,
@@ -247,7 +235,6 @@ export class PlatformBackend implements Backend {
 		const payload: Record<string, unknown> = {};
 		if (content) payload.text = content;
 		if (metadata) payload.metadata = metadata;
-		payload.source = "CLI";
 		return (await this._request("PUT", `/v1/memories/${memoryId}/`, {
 			json: payload,
 		})) as Record<string, unknown>;
@@ -258,7 +245,7 @@ export class PlatformBackend implements Backend {
 		opts: DeleteOptions = {},
 	): Promise<Record<string, unknown>> {
 		if (opts.all) {
-			const params: Record<string, string> = { source: "CLI" };
+			const params: Record<string, string> = {};
 			if (opts.userId) params.user_id = opts.userId;
 			if (opts.agentId) params.agent_id = opts.agentId;
 			if (opts.appId) params.app_id = opts.appId;
@@ -268,46 +255,50 @@ export class PlatformBackend implements Backend {
 			})) as Record<string, unknown>;
 		}
 		if (memoryId) {
-			return (await this._request("DELETE", `/v1/memories/${memoryId}/`, {
-				params: { source: "CLI" },
-			})) as Record<string, unknown>;
+			return (await this._request(
+				"DELETE",
+				`/v1/memories/${memoryId}/`,
+			)) as Record<string, unknown>;
 		}
 		throw new Error("Either memoryId or --all is required");
 	}

 	async deleteEntities(opts: EntityIds): Promise<Record<string, unknown>> {
-		// v2 endpoint: DELETE /v2/entities/{entity_type}/{entity_id}/
-		const typeMap: [string, string | undefined][] = [
-			["user", opts.userId],
-			["agent", opts.agentId],
-			["app", opts.appId],
-			["run", opts.runId],
-		];
-		const entities = typeMap.filter(([, v]) => v) as [string, string][];
-		if (entities.length === 0) {
+		const params: Record<string, string> = {};
+		if (opts.userId) params.user_id = opts.userId;
+		if (opts.agentId) params.agent_id = opts.agentId;
+		if (opts.appId) params.app_id = opts.appId;
+		if (opts.runId) params.run_id = opts.runId;
+		if (Object.keys(params).length === 0) {
 			throw new Error("At least one entity ID is required for deleteEntities.");
 		}
-		// Delete each provided entity via the v2 path-based endpoint
-		let result: Record<string, unknown> = {};
-		for (const [entityType, entityId] of entities) {
-			result = (await this._request(
-				"DELETE",
-				`/v2/entities/${entityType}/${entityId}/`,
-				{ params: { source: "CLI" } },
-			)) as Record<string, unknown>;
-		}
-		return result;
-	}
-
-	async ping(): Promise<Record<string, unknown>> {
-		return (await this._request("GET", "/v1/ping/")) as Record<string, unknown>;
+		return (await this._request("DELETE", "/v1/entities/", {
+			params,
+		})) as Record<string, unknown>;
 	}

 	async status(
 		opts: { userId?: string; agentId?: string } = {},
 	): Promise<Record<string, unknown>> {
 		try {
-			await this.ping();
+			if (opts.userId || opts.agentId) {
+				const payload: Record<string, unknown> = {};
+				const statusParams: Record<string, string> = {
+					page: "1",
+					page_size: "1",
+				};
+				const apiFilters = this._buildFilters({
+					userId: opts.userId,
+					agentId: opts.agentId,
+				});
+				if (apiFilters) payload.filters = apiFilters;
+				await this._request("POST", "/v2/memories/", {
+					json: payload,
+					params: statusParams,
+				});
+			} else {
+				await this._request("GET", "/v1/entities/");
+			}
 			return { connected: true, backend: "platform", base_url: this.baseUrl };
 		} catch (e) {
 			return {
@@ -344,20 +335,4 @@ export class PlatformBackend implements Backend {
 		}
 		return items;
 	}
-
-	async listEvents(): Promise<Record<string, unknown>[]> {
-		const result = (await this._request("GET", "/v1/events/")) as unknown;
-		if (Array.isArray(result)) return result;
-		return ((result as Record<string, unknown>).results ?? []) as Record<
-			string,
-			unknown
-		>[];
-	}
-
-	async getEvent(eventId: string): Promise<Record<string, unknown>> {
-		return (await this._request("GET", `/v1/event/${eventId}/`)) as Record<
-			string,
-			unknown
-		>;
-	}
 }
@@ -4,7 +4,6 @@

 import chalk from "chalk";
 import ora, { type Ora } from "ora";
-import { getCurrentCommand, isAgentMode } from "./state.js";
 import { CLI_VERSION } from "./version.js";

 export const LOGO = `
@@ -43,7 +42,6 @@ export function sym(fancy: string, plain: string): string {
 }

 export function printBanner(): void {
-	if (isAgentMode()) return;
 	const pad = 3; // horizontal padding each side (matches Rich's padding=(0, 2))
 	const logoLines = LOGO.trimEnd().split("\n");
 	const tagline = `  ${TAGLINE}`;
@@ -77,29 +75,13 @@ export function printBanner(): void {
 }

 export function printSuccess(message: string): void {
-	if (isAgentMode()) return;
 	console.log(`${success(sym("✓", "[ok]"))} ${message}`);
 }

 export function printError(message: string, hint?: string): void {
-	if (isAgentMode()) {
-		const envelope = {
-			status: "error",
-			command: getCurrentCommand(),
-			error: message,
-			data: null,
-		};
-		console.log(JSON.stringify(envelope));
-		return;
-	}
 	console.error(`${error(`${sym("✗", "[error]")} Error:`)} ${message}`);
-	const resolvedHint =
-		hint ??
-		(message.includes("Authentication failed")
-			? `Run ${brand("mem0 init")} to reconfigure your API key · https://app.mem0.ai/dashboard/api-keys`
-			: undefined);
-	if (resolvedHint) {
-		console.error(`  ${dim(resolvedHint)}`);
+	if (hint) {
+		console.error(`  ${dim(hint)}`);
 	}
 }

@@ -108,16 +90,15 @@ export function printWarning(message: string): void {
 }

 export function printInfo(message: string): void {
-	if (isAgentMode()) return;
 	console.error(`${brand(sym("◆", "*"))} ${message}`);
 }

 export function printScope(ids: Record<string, string | undefined>): void {
-	if (isAgentMode()) return;
 	const parts: string[] = [];
 	for (const [key, val] of Object.entries(ids)) {
 		if (val) {
-			parts.push(`${key}=${val}`);
+			const label = key.replace(/_/g, " ").replace("id", "ID").trim();
+			parts.push(`${label}=${val}`);
 		}
 	}
 	if (parts.length > 0) {
@@ -138,14 +119,10 @@ export async function timedStatus<T>(
 	message: string,
 	fn: (ctx: TimedStatusContext) => Promise<T>,
 ): Promise<T> {
-	if (isAgentMode()) {
-		const ctx: TimedStatusContext = { successMsg: "", errorMsg: "" };
-		return fn(ctx);
-	}
 	const ctx: TimedStatusContext = { successMsg: "", errorMsg: "" };
 	const spinner = ora({
 		text: dim(message),
-		color: "yellow",
+		color: "magenta",
 		stream: process.stderr,
 	}).start();
 	const start = performance.now();
@@ -162,7 +139,7 @@ export async function timedStatus<T>(
 		const elapsed = ((performance.now() - start) / 1000).toFixed(2);
 		spinner.stop();
 		if (ctx.errorMsg) {
-			printError(`${ctx.errorMsg} (${elapsed}s)`);
+			console.error(`${error("✗ Error:")} ${ctx.errorMsg} (${elapsed}s)`);
 		}
 		throw err;
 	}
@@ -11,17 +11,15 @@ import {
 	saveConfig,
 	setNestedValue,
 } from "../config.js";
-import { formatAgentEnvelope, formatJsonEnvelope } from "../output.js";
-import { isAgentMode, setCurrentCommand } from "../state.js";
+import { formatJsonEnvelope } from "../output.js";

 const { brand, accent, dim } = colors;

 export function cmdConfigShow(opts: { output?: string } = {}): void {
-	setCurrentCommand("config show");
 	const config = loadConfig();

-	if (opts.output === "agent" || opts.output === "json") {
-		formatAgentEnvelope({
+	if (opts.output === "json") {
+		formatJsonEnvelope({
 			command: "config show",
 			data: {
 				defaults: {
@@ -68,7 +66,6 @@ export function cmdConfigShow(opts: { output?: string } = {}): void {
 }

 export function cmdConfigGet(key: string): void {
-	setCurrentCommand("config get");
 	const config = loadConfig();
 	const value = getNestedValue(config, key);

@@ -76,35 +73,20 @@ export function cmdConfigGet(key: string): void {
 		printError(`Unknown config key: ${key}`);
 	} else {
 		// Redact secrets
-		const displayValue =
-			key.includes("api_key") || key.split(".").pop() === "key"
-				? redactKey(String(value))
-				: String(value);
-		if (isAgentMode()) {
-			formatAgentEnvelope({
-				command: "config get",
-				data: { key, value: displayValue },
-			});
+		if (key.includes("api_key") || key.split(".").pop() === "key") {
+			console.log(redactKey(String(value)));
 		} else {
-			console.log(displayValue);
+			console.log(String(value));
 		}
 	}
 }

 export function cmdConfigSet(key: string, value: string): void {
-	setCurrentCommand("config set");
 	const config = loadConfig();
 	if (setNestedValue(config, key, value)) {
 		saveConfig(config);
 		const display = key.includes("key") ? redactKey(value) : value;
-		if (isAgentMode()) {
-			formatAgentEnvelope({
-				command: "config set",
-				data: { key, value: display },
-			});
-		} else {
-			printSuccess(`${key} = ${display}`);
-		}
+		printSuccess(`${key} = ${display}`);
 	} else {
 		printError(`Unknown config key: ${key}`);
 	}
@@ -12,8 +12,7 @@ import {
 	printSuccess,
 	timedStatus,
 } from "../branding.js";
-import { formatAgentEnvelope, formatJson } from "../output.js";
-import { setCurrentCommand } from "../state.js";
+import { formatJson } from "../output.js";

 const { brand, accent, dim } = colors;

@@ -24,7 +23,6 @@ export async function cmdEntitiesList(
 	entityType: string,
 	opts: { output: string },
 ): Promise<void> {
-	setCurrentCommand("entity list");
 	if (!VALID_TYPES.has(entityType)) {
 		printError(
 			`Invalid entity type: ${entityType}. Use: ${[...VALID_TYPES].join(", ")}`,
@@ -47,13 +45,8 @@ export async function cmdEntitiesList(
 	}
 	const elapsed = (performance.now() - start) / 1000;

-	if (opts.output === "agent" || opts.output === "json") {
-		formatAgentEnvelope({
-			command: "entity list",
-			data: results,
-			count: results.length,
-			durationMs: Math.round(elapsed * 1000),
-		});
+	if (opts.output === "json") {
+		formatJson(results);
 		return;
 	}

@@ -93,12 +86,6 @@ export async function cmdEntitiesDelete(
 		output: string;
 	},
 ): Promise<void> {
-	setCurrentCommand("entity delete");
-	const { isAgentMode } = await import("../state.js");
-	if (isAgentMode() && !opts.force) {
-		printError("Destructive operation requires --force in agent mode.");
-		process.exit(1);
-	}
 	if (!opts.userId && !opts.agentId && !opts.appId && !opts.runId) {
 		printError(
 			"Provide at least one of --user-id, --agent-id, --app-id, --run-id.",
@@ -106,20 +93,27 @@ export async function cmdEntitiesDelete(
 		process.exit(1);
 	}

-	const scopeParts: string[] = [];
-	if (opts.userId) scopeParts.push(`user=${opts.userId}`);
-	if (opts.agentId) scopeParts.push(`agent=${opts.agentId}`);
-	if (opts.appId) scopeParts.push(`app=${opts.appId}`);
-	if (opts.runId) scopeParts.push(`run=${opts.runId}`);
-	const scope = scopeParts.join(", ");
-
 	if (opts.dryRun) {
-		printInfo(`Would delete entity ${scope} and all its memories.`);
+		const scopeParts: string[] = [];
+		if (opts.userId) scopeParts.push(`user=${opts.userId}`);
+		if (opts.agentId) scopeParts.push(`agent=${opts.agentId}`);
+		if (opts.appId) scopeParts.push(`app=${opts.appId}`);
+		if (opts.runId) scopeParts.push(`run=${opts.runId}`);
+		printInfo(
+			`Would delete entity ${scopeParts.join(", ")} and all its memories.`,
+		);
 		printInfo("No changes made.");
 		return;
 	}

 	if (!opts.force) {
+		const scopeParts: string[] = [];
+		if (opts.userId) scopeParts.push(`user=${opts.userId}`);
+		if (opts.agentId) scopeParts.push(`agent=${opts.agentId}`);
+		if (opts.appId) scopeParts.push(`app=${opts.appId}`);
+		if (opts.runId) scopeParts.push(`run=${opts.runId}`);
+		const scope = scopeParts.join(", ");
+
 		const rl = readline.createInterface({
 			input: process.stdin,
 			output: process.stdout,
@@ -154,13 +148,7 @@ export async function cmdEntitiesDelete(
 	}
 	const elapsed = (performance.now() - start) / 1000;

-	if (opts.output === "agent") {
-		formatAgentEnvelope({
-			command: "entity delete",
-			data: { deleted: true },
-			durationMs: Math.round(elapsed * 1000),
-		});
-	} else if (opts.output === "json") {
+	if (opts.output === "json") {
 		formatJson(result);
 	} else if (opts.output !== "quiet") {
 		printSuccess(`Entity deleted with all memories (${elapsed.toFixed(2)}s)`);
@@ -1,169 +0,0 @@
-/**
- * Event commands: list and status.
- */
-
-import boxen from "boxen";
-import Table from "cli-table3";
-import type { Backend } from "../backend/base.js";
-import { colors, printError, printInfo, timedStatus } from "../branding.js";
-import { formatAgentEnvelope, formatJson } from "../output.js";
-import { setCurrentCommand } from "../state.js";
-
-const { brand, accent, success, error: errorColor, warning, dim } = colors;
-
-function statusStyled(status: string): string {
-	switch (status.toUpperCase()) {
-		case "SUCCEEDED":
-			return success("SUCCEEDED");
-		case "PENDING":
-			return accent("PENDING");
-		case "FAILED":
-			return errorColor("FAILED");
-		case "PROCESSING":
-			return warning("PROCESSING");
-		default:
-			return status;
-	}
-}
-
-export async function cmdEventList(
-	backend: Backend,
-	opts: { output: string },
-): Promise<void> {
-	setCurrentCommand("event list");
-	const start = performance.now();
-	let results: Record<string, unknown>[];
-	try {
-		results = await timedStatus("Fetching events...", async () => {
-			return backend.listEvents();
-		});
-	} catch (e) {
-		printError(e instanceof Error ? e.message : String(e));
-		process.exit(1);
-	}
-	const elapsed = (performance.now() - start) / 1000;
-
-	if (opts.output === "agent" || opts.output === "json") {
-		formatAgentEnvelope({
-			command: "event list",
-			data: results,
-			count: results.length,
-			durationMs: Math.round(elapsed * 1000),
-		});
-		return;
-	}
-
-	if (results.length === 0) {
-		console.log();
-		printInfo("No events found.");
-		console.log();
-		return;
-	}
-
-	const table = new Table({
-		head: [
-			accent("Event ID"),
-			accent("Type"),
-			accent("Status"),
-			accent("Latency"),
-			accent("Created"),
-		],
-		colWidths: [12, 14, 14, 10, 22],
-		wordWrap: true,
-		style: { head: [], border: [] },
-	});
-
-	for (const ev of results) {
-		const evId = String(ev.id ?? "").slice(0, 8);
-		const evType = String(ev.event_type ?? "—");
-		const status = String(ev.status ?? "—");
-		const latency = ev.latency as number | undefined;
-		const latencyStr = latency !== undefined ? `${Math.round(latency)}ms` : "—";
-		const created = String(ev.created_at ?? "—")
-			.slice(0, 19)
-			.replace("T", " ");
-		table.push([dim(evId), evType, statusStyled(status), latencyStr, created]);
-	}
-
-	console.log();
-	console.log(table.toString());
-	console.log(
-		`  ${dim(`${results.length} event${results.length !== 1 ? "s" : ""}`)}`,
-	);
-	console.log();
-}
-
-export async function cmdEventStatus(
-	backend: Backend,
-	eventId: string,
-	opts: { output: string },
-): Promise<void> {
-	setCurrentCommand("event status");
-	const start = performance.now();
-	let ev: Record<string, unknown>;
-	try {
-		ev = await timedStatus("Fetching event...", async () => {
-			return backend.getEvent(eventId);
-		});
-	} catch (e) {
-		printError(e instanceof Error ? e.message : String(e));
-		process.exit(1);
-	}
-	const elapsed = (performance.now() - start) / 1000;
-
-	if (opts.output === "agent" || opts.output === "json") {
-		formatAgentEnvelope({
-			command: "event status",
-			data: ev,
-			durationMs: Math.round(elapsed * 1000),
-		});
-		return;
-	}
-
-	const status = String(ev.status ?? "—");
-	const evType = String(ev.event_type ?? "—");
-	const latency = ev.latency as number | undefined;
-	const latencyStr = latency !== undefined ? `${Math.round(latency)}ms` : "—";
-	const created = String(ev.created_at ?? "—")
-		.slice(0, 19)
-		.replace("T", " ");
-	const updated = String(ev.updated_at ?? "—")
-		.slice(0, 19)
-		.replace("T", " ");
-	const results = ev.results as Record<string, unknown>[] | undefined;
-
-	const lines: string[] = [];
-	lines.push(`  ${dim("Event ID:")}     ${eventId}`);
-	lines.push(`  ${dim("Type:")}         ${evType}`);
-	lines.push(`  ${dim("Status:")}       ${statusStyled(status)}`);
-	lines.push(`  ${dim("Latency:")}      ${latencyStr}`);
-	lines.push(`  ${dim("Created:")}      ${created}`);
-	lines.push(`  ${dim("Updated:")}      ${updated}`);
-
-	if (results && results.length > 0) {
-		lines.push("");
-		lines.push(`  ${dim(`Results (${results.length}):`)}`);
-		for (const r of results) {
-			const memId = String(r.id ?? "").slice(0, 8);
-			const data = r.data as Record<string, unknown> | undefined;
-			const memory = data?.memory ? String(data.memory) : "";
-			const evName = String(r.event ?? "");
-			const user = String(r.user_id ?? "");
-			let detail = `${evName}  ${memory}`;
-			if (user) detail += `  ${dim(`(user_id=${user})`)}`;
-			lines.push(`    ${success("·")} ${detail}  ${dim(`(${memId})`)}`);
-		}
-	}
-
-	const content = lines.join("\n");
-	console.log();
-	console.log(
-		boxen(content, {
-			title: brand("Event Status"),
-			titleAlignment: "left",
-			borderColor: "magenta",
-			padding: 1,
-		}),
-	);
-	console.log();
-}
@@ -2,7 +2,6 @@
 * mem0 init — interactive setup wizard.
 */

-import fs from "node:fs";
 import readline from "node:readline";
 import { PlatformBackend } from "../backend/platform.js";
 import {
@@ -13,12 +12,10 @@ import {
 	printSuccess,
 } from "../branding.js";
 import {
-	CONFIG_FILE,
 	DEFAULT_BASE_URL,
 	type Mem0Config,
 	createDefaultConfig,
 	loadConfig,
-	redactKey,
 	saveConfig,
 } from "../config.js";

@@ -41,16 +38,10 @@ async function emailLogin(
 	const url = baseUrl.replace(/\/+$/, "");
 	let codeValue = code;

-	const sourceHeaders = {
-		"Content-Type": "application/json",
-		"X-Mem0-Source": "cli",
-		"X-Mem0-Client-Language": "node",
-	};
-
 	if (!codeValue) {
 		const resp = await fetch(`${url}/api/v1/auth/email_code/`, {
 			method: "POST",
-			headers: sourceHeaders,
+			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify({ email }),
 			signal: AbortSignal.timeout(30_000),
 		});
@@ -91,7 +82,7 @@ async function emailLogin(

 	const verifyResp = await fetch(`${url}/api/v1/auth/email_code/verify/`, {
 		method: "POST",
-		headers: sourceHeaders,
+		headers: { "Content-Type": "application/json" },
 		body: JSON.stringify({ email, code: codeValue.trim() }),
 		signal: AbortSignal.timeout(30_000),
 	});
@@ -202,10 +193,9 @@ async function setupDefaults(config: Mem0Config): Promise<void> {
 	console.log();
 	printInfo("Set default entity IDs (press Enter to skip).\n");

-	const _systemUser = process.env.USER || process.env.USERNAME || "mem0-cli";
 	const userId = await promptLine(
 		`  ${brand("Default User ID")} ${dim("(recommended)")}`,
-		_systemUser,
+		"mem0-cli",
 	);
 	if (userId) config.defaults.userId = userId;
 }
@@ -221,20 +211,10 @@ async function validatePlatform(config: Mem0Config): Promise<void> {
 		});
 		if (status.connected) {
 			printSuccess("Connected to mem0 Platform!");
-			// Cache user_email from ping response for telemetry distinct_id
-			try {
-				const pingData = (await backend.ping()) as Record<string, unknown>;
-				const userEmail = pingData?.user_email as string | undefined;
-				if (userEmail) {
-					config.platform.userEmail = userEmail;
-				}
-			} catch {
-				/* ignore — telemetry ID will fall back to API key hash */
-			}
 		} else {
 			printError(
 				`Could not connect: ${status.error ?? "Unknown error"}`,
-				"Visit https://app.mem0.ai/dashboard/api-keys to get a new key, or run mem0 init again.",
+				"Check your API key and try again.",
 			);
 		}
 	} catch (e) {
@@ -248,7 +228,6 @@ export async function runInit(
 		userId?: string;
 		email?: string;
 		code?: string;
-		force?: boolean;
 	} = {},
 ): Promise<void> {
 	const config = createDefaultConfig();
@@ -268,40 +247,6 @@ export async function runInit(
 		process.exit(1);
 	}

-	// Warn if an existing config with an API key would be overwritten
-	if (
-		!opts.force &&
-		fs.existsSync(CONFIG_FILE) &&
-		savedConfig.platform.apiKey
-	) {
-		console.log(
-			`\n  ${brand("Existing configuration found")} ${dim(`(API key: ${redactKey(savedConfig.platform.apiKey)})`)}`,
-		);
-		if (process.stdin.isTTY) {
-			const rl = readline.createInterface({
-				input: process.stdin,
-				output: process.stdout,
-			});
-			const answer = await new Promise<string>((resolve) => {
-				rl.question(
-					"  Overwrite existing config? This cannot be undone. [y/N] ",
-					resolve,
-				);
-			});
-			rl.close();
-			if (answer.toLowerCase() !== "y") {
-				printInfo("Cancelled. Use --force to skip this check.");
-				process.exit(0);
-			}
-		} else {
-			printError(
-				"Existing config would be overwritten.",
-				"Use --force to overwrite.",
-			);
-			process.exit(1);
-		}
-	}
-
 	// ── Email login flow ──────────────────────────────────────────────────────
 	if (opts.email) {
 		const email = opts.email.trim().toLowerCase();
@@ -323,9 +268,7 @@ export async function runInit(

 		config.platform.apiKey = apiKeyVal;
 		config.platform.baseUrl = baseUrl;
-		config.platform.userEmail = email;
-		config.defaults.userId =
-			opts.userId || process.env.USER || process.env.USERNAME || "mem0-cli";
+		config.defaults.userId = opts.userId || "mem0-cli";

 		saveConfig(config);
 		console.log();
@@ -340,19 +283,6 @@ export async function runInit(

 	// ── API key flow ──────────────────────────────────────────────────────────

-	// Non-TTY: resolve defaults so partial flags work in pipelines / CI
-	if (!process.stdin.isTTY) {
-		if (!opts.apiKey) {
-			printError(
-				"Non-interactive terminal detected and --api-key is required.",
-				"Usage: mem0 init --api-key <key> [--user-id <id>]",
-			);
-			process.exit(1);
-		}
-		opts.userId =
-			opts.userId || process.env.USER || process.env.USERNAME || "mem0-cli";
-	}
-
 	// Non-interactive: both flags provided
 	if (opts.apiKey && opts.userId) {
 		config.platform.apiKey = opts.apiKey;
@@ -363,6 +293,15 @@ export async function runInit(
 		return;
 	}

+	// Non-TTY without full flags: error with usage hint
+	if (!process.stdin.isTTY && (!opts.apiKey || !opts.userId)) {
+		printError(
+			"Non-interactive terminal detected and missing required flags.",
+			"Usage: mem0 init --api-key <key> --user-id <id>",
+		);
+		process.exit(1);
+	}
+
 	printBanner();
 	console.log();
 	printInfo("Welcome! Let's set up your mem0 CLI.\n");
@@ -402,9 +341,7 @@ export async function runInit(

 			config.platform.apiKey = apiKeyVal;
 			config.platform.baseUrl = baseUrl;
-			config.platform.userEmail = email;
-			config.defaults.userId =
-				opts.userId || process.env.USER || process.env.USERNAME || "mem0-cli";
+			config.defaults.userId = opts.userId || "mem0-cli";

 			saveConfig(config);
 			console.log();
@@ -13,7 +13,6 @@ import {
 } from "../branding.js";
 import {
 	formatAddResult,
-	formatAgentEnvelope,
 	formatJson,
 	formatJsonEnvelope,
 	formatMemoriesTable,
@@ -21,18 +20,6 @@ import {
 	formatSingleMemory,
 	printResultSummary,
 } from "../output.js";
-import { isAgentMode, setCurrentCommand } from "../state.js";
-
-/** True only when stdin is an actual pipe or file redirect — never in agent mode. */
-function _stdinIsPiped(): boolean {
-	if (isAgentMode()) return false;
-	try {
-		const stat = fs.fstatSync(0);
-		return stat.isFIFO() || stat.isFile();
-	} catch {
-		return false;
-	}
-}

 export async function cmdAdd(
 	backend: Backend,
@@ -53,7 +40,6 @@ export async function cmdAdd(
 		output: string;
 	},
 ): Promise<void> {
-	setCurrentCommand("add");
 	let msgs: Record<string, unknown>[] | undefined;
 	let content = text;

@@ -78,8 +64,8 @@ export async function cmdAdd(
 			process.exit(1);
 		}
 	}
-	// Read from stdin only if stdin is an actual pipe or file redirect
-	else if (!content && _stdinIsPiped()) {
+	// Read from stdin if piped
+	else if (!content && !process.stdin.isTTY) {
 		content = fs.readFileSync(0, "utf-8").trim();
 	}

@@ -150,43 +136,8 @@ export async function cmdAdd(

 	if (opts.output === "quiet") return;

-	// Deduplicate PENDING entries sharing the same event_id across all output modes
-	const rawResults: Record<string, unknown>[] = Array.isArray(result)
-		? result
-		: ((result.results as Record<string, unknown>[]) ?? [result]);
-	const seenEvents = new Set<string>();
-	const deduped: Record<string, unknown>[] = [];
-	for (const r of rawResults) {
-		if (r.status === "PENDING") {
-			const eid = (r.event_id as string) ?? "";
-			if (eid && seenEvents.has(eid)) continue;
-			if (eid) seenEvents.add(eid);
-		}
-		deduped.push(r);
-	}
-	// Write back so downstream formatters see deduplicated data
-	const dedupedResult: Record<string, unknown> = Array.isArray(result)
-		? (deduped as unknown as Record<string, unknown>)
-		: { ...result, results: deduped };
-
-	if (opts.output === "agent") {
-		const scope: Record<string, string | undefined> = {
-			user_id: opts.userId,
-			agent_id: opts.agentId,
-			app_id: opts.appId,
-			run_id: opts.runId,
-		};
-		formatAgentEnvelope({
-			command: "add",
-			data: deduped,
-			scope,
-			count: deduped.length,
-		});
-		return;
-	}
-
 	if (opts.output === "json") {
-		formatAddResult(dedupedResult, opts.output);
+		formatAddResult(result, opts.output);
 		return;
 	}

@@ -197,18 +148,14 @@ export async function cmdAdd(
 		app_id: opts.appId,
 		run_id: opts.runId,
 	});
-	const count = deduped.length;
-	const allPending = count > 0 && deduped.every((r) => r.status === "PENDING");
-	if (allPending) {
-		printSuccess(
-			`Memory queued — ${count} event${count !== 1 ? "s" : ""} pending`,
-		);
-	} else {
-		printSuccess(
-			`Memory processed — ${count} memor${count === 1 ? "y" : "ies"} extracted`,
-		);
-	}
-	formatAddResult(dedupedResult, opts.output);
+	const results = Array.isArray(result)
+		? result
+		: ((result.results as unknown[]) ?? [result]);
+	const count = results.length;
+	printSuccess(
+		`Memory processed — ${count} memor${count === 1 ? "y" : "ies"} extracted`,
+	);
+	formatAddResult(result, opts.output);
 }

 export async function cmdSearch(
@@ -229,7 +176,6 @@ export async function cmdSearch(
 		output: string;
 	},
 ): Promise<void> {
-	setCurrentCommand("search");
 	if (!query) {
 		printError("No query provided. Pass a query argument or pipe via stdin.");
 		process.exit(1);
@@ -285,23 +231,6 @@ export async function cmdSearch(

 	if (opts.output === "quiet") return;

-	if (opts.output === "agent") {
-		const scope: Record<string, string | undefined> = {
-			user_id: opts.userId,
-			agent_id: opts.agentId,
-			app_id: opts.appId,
-			run_id: opts.runId,
-		};
-		formatAgentEnvelope({
-			command: "search",
-			data: results,
-			scope,
-			count: results.length,
-			durationMs: Math.round(elapsed * 1000),
-		});
-		return;
-	}
-
 	if (opts.output === "json") {
 		formatJson(results);
 	} else if (opts.output === "table") {
@@ -338,7 +267,6 @@ export async function cmdGet(
 	memoryId: string,
 	opts: { output: string },
 ): Promise<void> {
-	setCurrentCommand("get");
 	let result: Record<string, unknown>;
 	try {
 		result = await timedStatus("Fetching memory...", async () => {
@@ -349,11 +277,7 @@ export async function cmdGet(
 		process.exit(1);
 	}

-	if (opts.output === "agent") {
-		formatAgentEnvelope({ command: "get", data: result });
-	} else {
-		formatSingleMemory(result, opts.output);
-	}
+	formatSingleMemory(result, opts.output);
 }

 export async function cmdList(
@@ -372,7 +296,6 @@ export async function cmdList(
 		output: string;
 	},
 ): Promise<void> {
-	setCurrentCommand("list");
 	if (opts.pageSize < 1) {
 		printError("--page-size must be >= 1.");
 		process.exit(1);
@@ -407,19 +330,12 @@ export async function cmdList(

 	if (opts.output === "quiet") return;

-	if (opts.output === "agent" || opts.output === "json") {
-		const scope: Record<string, string | undefined> = {
-			user_id: opts.userId,
-			agent_id: opts.agentId,
-			app_id: opts.appId,
-			run_id: opts.runId,
-		};
-		formatAgentEnvelope({
+	if (opts.output === "json") {
+		formatJsonEnvelope({
 			command: "list",
 			data: results,
-			scope,
 			count: results.length,
-			durationMs: Math.round(elapsed * 1000),
+			scope: { user_id: opts.userId, agent_id: opts.agentId },
 		});
 	} else if (opts.output === "table") {
 		if (results.length > 0) {
@@ -458,7 +374,6 @@ export async function cmdUpdate(
 	text: string | undefined,
 	opts: { metadata?: string; output: string },
 ): Promise<void> {
-	setCurrentCommand("update");
 	let meta: Record<string, unknown> | undefined;
 	if (opts.metadata) {
 		try {
@@ -481,13 +396,7 @@ export async function cmdUpdate(
 	}
 	const elapsed = (performance.now() - start) / 1000;

-	if (opts.output === "agent") {
-		formatAgentEnvelope({
-			command: "update",
-			data: result,
-			durationMs: Math.round(elapsed * 1000),
-		});
-	} else if (opts.output === "json") {
+	if (opts.output === "json") {
 		formatJson(result);
 	} else if (opts.output !== "quiet") {
 		printSuccess(
@@ -501,7 +410,6 @@ export async function cmdDelete(
 	memoryId: string,
 	opts: { output: string; dryRun?: boolean; force?: boolean },
 ): Promise<void> {
-	setCurrentCommand("delete");
 	if (opts.dryRun) {
 		let mem: Record<string, unknown>;
 		try {
@@ -528,13 +436,7 @@ export async function cmdDelete(
 	}
 	const elapsed = (performance.now() - start) / 1000;

-	if (opts.output === "agent") {
-		formatAgentEnvelope({
-			command: "delete",
-			data: { id: memoryId, deleted: true },
-			durationMs: Math.round(elapsed * 1000),
-		});
-	} else if (opts.output === "json") {
+	if (opts.output === "json") {
 		formatJson(result);
 	} else if (opts.output !== "quiet") {
 		printSuccess(
@@ -556,15 +458,16 @@ export async function cmdDeleteAll(
 		output: string;
 	},
 ): Promise<void> {
-	setCurrentCommand("delete-all");
-	const { isAgentMode } = await import("../state.js");
-	if (isAgentMode() && !opts.force) {
-		printError("Destructive operation requires --force in agent mode.");
-		process.exit(1);
-	}
 	if (opts.all) {
 		// Project-wide wipe using wildcard entity IDs
-		// Note: --dry-run is ignored here because the API has no count-before-delete endpoint.
+		if (opts.dryRun) {
+			printInfo("Would delete ALL memories project-wide.");
+			printInfo(
+				"Run without --dry-run to see the actual count of deleted memories.",
+			);
+			printInfo("No changes made.");
+			return;
+		}

 		if (!opts.force) {
 			const readline = await import("node:readline");
@@ -606,13 +509,7 @@ export async function cmdDeleteAll(
 		}
 		const elapsed = (performance.now() - start) / 1000;

-		if (opts.output === "agent") {
-			formatAgentEnvelope({
-				command: "delete-all",
-				data: result,
-				durationMs: Math.round(elapsed * 1000),
-			});
-		} else if (opts.output === "json") {
+		if (opts.output === "json") {
 			formatJson(result);
 		} else if (opts.output !== "quiet") {
 			if (result.message) {
@@ -689,13 +586,7 @@ export async function cmdDeleteAll(
 	}
 	const elapsed = (performance.now() - start) / 1000;

-	if (opts.output === "agent") {
-		formatAgentEnvelope({
-			command: "delete-all",
-			data: result,
-			durationMs: Math.round(elapsed * 1000),
-		});
-	} else if (opts.output === "json") {
+	if (opts.output === "json") {
 		formatJson(result);
 	} else if (opts.output !== "quiet") {
 		if (result.message) {
@@ -6,8 +6,7 @@ import fs from "node:fs";
 import boxen from "boxen";
 import type { Backend } from "../backend/base.js";
 import { colors, printError, printSuccess, timedStatus } from "../branding.js";
-import { formatAgentEnvelope, formatJsonEnvelope } from "../output.js";
-import { setCurrentCommand } from "../state.js";
+import { formatJsonEnvelope } from "../output.js";
 import { CLI_VERSION } from "../version.js";

 const { brand, dim, success, error: errorColor } = colors;
@@ -16,7 +15,6 @@ export async function cmdStatus(
 	backend: Backend,
 	opts: { userId?: string; agentId?: string; output?: string } = {},
 ): Promise<void> {
-	setCurrentCommand("status");
 	const start = performance.now();
 	let result: Record<string, unknown>;
 	try {
@@ -31,13 +29,14 @@ export async function cmdStatus(
 	}
 	const elapsed = (performance.now() - start) / 1000;

-	if (opts.output === "agent" || opts.output === "json") {
-		formatAgentEnvelope({
+	if (opts.output === "json") {
+		formatJsonEnvelope({
 			command: "status",
 			data: {
 				connected: result.connected,
 				backend: result.backend ?? null,
 				base_url: result.base_url ?? null,
+				latency_ms: Math.round(elapsed * 1000),
 			},
 			durationMs: Math.round(elapsed * 1000),
 		});
@@ -57,15 +56,6 @@ export async function cmdStatus(
 	}
 	if (result.error) {
 		lines.push(`  ${errorColor("Error:")}    ${result.error}`);
-		if (String(result.error).includes("Authentication failed")) {
-			lines.push("");
-			lines.push(
-				`  ${dim("Run")} ${brand("mem0 init")} ${dim("to reconfigure your API key")}`,
-			);
-			lines.push(
-				`  ${dim("Get a key at")} ${brand("https://app.mem0.ai/dashboard/api-keys")}`,
-			);
-		}
 	}
 	lines.push(`  ${dim("Latency:")}  ${elapsed.toFixed(2)}s`);

@@ -91,7 +81,6 @@ export async function cmdImport(
 	filePath: string,
 	opts: { userId?: string; agentId?: string; output?: string },
 ): Promise<void> {
-	setCurrentCommand("import");
 	let data: Record<string, unknown>[];
 	try {
 		const raw = fs.readFileSync(filePath, "utf-8");
@@ -136,12 +125,13 @@ export async function cmdImport(
 	const elapsed = (performance.now() - start) / 1000;
 	console.log(); // Clear progress line

-	if (opts.output === "agent" || opts.output === "json") {
-		formatAgentEnvelope({
+	if (opts.output === "json") {
+		formatJsonEnvelope({
 			command: "import",
 			data: {
 				added,
 				failed,
+				duration_s: Number.parseFloat(elapsed.toFixed(2)),
 			},
 			durationMs: Math.round(elapsed * 1000),
 		});
@@ -20,7 +20,6 @@ export const CONFIG_VERSION = 1;
 export interface PlatformConfig {
 	apiKey: string;
 	baseUrl: string;
-	userEmail: string;
 }

 export interface DefaultsConfig {
@@ -31,15 +30,10 @@ export interface DefaultsConfig {
 	enableGraph: boolean;
 }

-export interface TelemetryConfig {
-	anonymousId: string;
-}
-
 export interface Mem0Config {
 	version: number;
 	defaults: DefaultsConfig;
 	platform: PlatformConfig;
-	telemetry: TelemetryConfig;
 }

 export function createDefaultConfig(): Mem0Config {
@@ -55,10 +49,6 @@ export function createDefaultConfig(): Mem0Config {
 		platform: {
 			apiKey: "",
 			baseUrl: DEFAULT_BASE_URL,
-			userEmail: "",
-		},
-		telemetry: {
-			anonymousId: "",
 		},
 	};
 }
@@ -80,7 +70,6 @@ export function loadConfig(): Mem0Config {
 		const plat = data.platform ?? {};
 		config.platform.apiKey = plat.api_key ?? "";
 		config.platform.baseUrl = plat.base_url ?? DEFAULT_BASE_URL;
-		config.platform.userEmail = plat.user_email ?? "";

 		const defaults = data.defaults ?? {};
 		config.defaults.userId = defaults.user_id ?? "";
@@ -88,9 +77,6 @@ export function loadConfig(): Mem0Config {
 		config.defaults.appId = defaults.app_id ?? "";
 		config.defaults.runId = defaults.run_id ?? "";
 		config.defaults.enableGraph = defaults.enable_graph ?? false;
-
-		const telemetry = data.telemetry ?? {};
-		config.telemetry.anonymousId = telemetry.anonymous_id ?? "";
 	}

 	// Environment variable overrides
@@ -128,10 +114,6 @@ export function saveConfig(config: Mem0Config): void {
 		platform: {
 			api_key: config.platform.apiKey,
 			base_url: config.platform.baseUrl,
-			user_email: config.platform.userEmail,
-		},
-		telemetry: {
-			anonymous_id: config.telemetry.anonymousId,
 		},
 	};

@@ -149,7 +131,6 @@ export function redactKey(key: string): string {
 const KEY_MAP: Record<string, [keyof Mem0Config, string]> = {
 	"platform.api_key": ["platform", "apiKey"],
 	"platform.base_url": ["platform", "baseUrl"],
-	"platform.user_email": ["platform", "userEmail"],
 	"defaults.user_id": ["defaults", "userId"],
 	"defaults.agent_id": ["defaults", "agentId"],
 	"defaults.app_id": ["defaults", "appId"],
@@ -158,7 +139,6 @@ const KEY_MAP: Record<string, [keyof Mem0Config, string]> = {
 	// Short-form aliases
 	api_key: ["platform", "apiKey"],
 	base_url: ["platform", "baseUrl"],
-	user_email: ["platform", "userEmail"],
 	user_id: ["defaults", "userId"],
 	agent_id: ["defaults", "agentId"],
 	app_id: ["defaults", "appId"],
@@ -36,7 +36,7 @@ const COMMAND_GROUPS: { panel: string; commands: string[] }[] = [
 	},
 	{
 		panel: "Management",
-		commands: ["init", "status", "import", "help", "entity", "event", "config"],
+		commands: ["init", "status", "import", "help", "entity", "config"],
 	},
 ];

@@ -8,27 +8,21 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
-import { AuthError, type Backend, getBackend } from "./backend/index.js";
-import { colors, printError, printWarning } from "./branding.js";
+import { type Backend, getBackend } from "./backend/index.js";
+import { colors, printError } from "./branding.js";
 import type { Mem0Config } from "./config.js";
-import { loadConfig, saveConfig } from "./config.js";
+import { loadConfig } from "./config.js";
 import { richFormatHelp } from "./help.js";
-import { setAgentMode } from "./state.js";
-import { captureEvent } from "./telemetry.js";
 import { CLI_VERSION } from "./version.js";

 const program = new Command();

-// ── Validated user identity (set by getBackendAndConfig) ─────────────────
-
-let _validatedUserEmail: string | undefined;
-
 // ── Helpers ──────────────────────────────────────────────────────────────

-async function getBackendAndConfig(
+function getBackendAndConfig(
 	apiKey?: string,
 	baseUrl?: string,
-): Promise<{ backend: Backend; config: Mem0Config }> {
+): { backend: Backend; config: Mem0Config } {
 	const config = loadConfig();

 	if (apiKey) config.platform.apiKey = apiKey;
@@ -42,58 +36,11 @@ async function getBackendAndConfig(
 		process.exit(1);
 	}

-	const backend = getBackend(config);
-
-	// Validate the API key upfront with a fast timeout
-	try {
-		const pingData = (await Promise.race([
-			backend.ping(),
-			new Promise<never>((_, reject) =>
-				setTimeout(() => reject(new Error("timeout")), 5000),
-			),
-		])) as Record<string, unknown>;
-
-		const email = pingData?.user_email as string | undefined;
-		if (email) {
-			_validatedUserEmail = email;
-			if (config.platform.userEmail !== email) {
-				config.platform.userEmail = email;
-				try {
-					saveConfig(config);
-				} catch {
-					/* ignore */
-				}
-			}
-		}
-	} catch (e) {
-		if (e instanceof AuthError) {
-			printError(
-				"Invalid or expired API key.",
-				"Run 'mem0 init' or set MEM0_API_KEY environment variable.",
-			);
-			process.exit(1);
-		}
-		// Network error / timeout — warn but proceed
-		printWarning(
-			"Could not validate API key (network issue). Proceeding anyway.",
-		);
-	}
-
-	return { backend, config };
+	return { backend: getBackend(config), config };
 }

-async function getBackendOnly(
-	apiKey?: string,
-	baseUrl?: string,
-): Promise<Backend> {
-	return (await getBackendAndConfig(apiKey, baseUrl)).backend;
-}
-
-function checkAgentMode(): boolean {
-	const rootOpts = program.opts();
-	const isAgent = !!(rootOpts.json || rootOpts.agent);
-	if (isAgent) setAgentMode(true);
-	return isAgent;
+function getBackendOnly(apiKey?: string, baseUrl?: string): Backend {
+	return getBackendAndConfig(apiKey, baseUrl).backend;
 }

 /**
@@ -158,45 +105,18 @@ program
 		console.log(`  ${colors.brand("◆ Mem0")} CLI v${CLI_VERSION}`);
 		process.exit(0);
 	})
-	.option("--json", "Output as JSON for agent/programmatic use.")
-	.option(
-		"--agent",
-		"Output as JSON for agent/programmatic use. (alias: --json)",
-	)
 	.usage("<command> [options]")
 	.helpOption("--help", "Show this message and exit.")
 	.addHelpCommand(false)
 	.configureHelp({ formatHelp: richFormatHelp });

-// ── Telemetry hook ───────────────────────────────────────────────────────
-
-program.hook("preAction", (_thisCommand, actionCommand) => {
-	try {
-		const commandName = actionCommand.name();
-		const parentName = actionCommand.parent?.name();
-		const fullCommand =
-			parentName && parentName !== "mem0"
-				? `${parentName}.${commandName}`
-				: commandName;
-		const isAgent = !!(program.opts().json || program.opts().agent);
-		captureEvent(
-			`cli.${fullCommand}`,
-			{
-				command: fullCommand,
-				is_agent: isAgent,
-			},
-			_validatedUserEmail,
-		);
-	} catch {
-		/* silently swallow */
-	}
-});
-
 // ── Init ──────────────────────────────────────────────────────────────────

 program
 	.command("init")
-	.description("Interactive setup wizard for mem0 CLI.")
+	.description(
+		"Setup wizard for mem0 CLI. Supports email login (--email) or manual API key (--api-key).",
+	)
 	.option("--api-key <key>", "API key (skip prompt).")
 	.option("-u, --user-id <id>", "Default user ID (skip prompt).")
 	.option("--email <email>", "Login via email verification code.")
@@ -204,7 +124,6 @@ program
 		"--code <code>",
 		"Verification code (use with --email for non-interactive login).",
 	)
-	.option("--force", "Overwrite existing config without confirmation.", false)
 	.addHelpText(
 		"after",
 		"\nExamples:\n  $ mem0 init\n  $ mem0 init --api-key m0-xxx --user-id alice\n  $ mem0 init --email you@example.com\n  $ mem0 init --email you@example.com --code 123456",
@@ -216,7 +135,6 @@ program
 			userId: opts.userId,
 			email: opts.email,
 			code: opts.code,
-			force: opts.force,
 		});
 	});

@@ -247,24 +165,17 @@ program
 	)
 	.action(async (text, opts) => {
 		const { cmdAdd } = await import("./commands/memory.js");
-		const isAgent = checkAgentMode();
-		const { backend, config } = await getBackendAndConfig(
-			opts.apiKey,
-			opts.baseUrl,
-		);
+		const { backend, config } = getBackendAndConfig(opts.apiKey, opts.baseUrl);
 		const ids = resolveIds(config, opts);
 		const enableGraph = resolveGraph(config, opts);
-		const output = isAgent ? "agent" : opts.output;
-		await cmdAdd(backend, text, { ...ids, ...opts, enableGraph, output });
+		await cmdAdd(backend, text, { ...ids, ...opts, enableGraph });
 	});

 // ── Memory: search ────────────────────────────────────────────────────────

 program
 	.command("search [query]")
-	.description(
-		"Query your memory store — semantic, keyword, or hybrid retrieval.",
-	)
+	.description("Search memories by semantic query.")
 	.option("-u, --user-id <id>", "Filter by user.")
 	.option("--agent-id <id>", "Filter by agent.")
 	.option("--app-id <id>", "Filter by app.")
@@ -304,14 +215,9 @@ program
 			process.exit(1);
 		}
 		const { cmdSearch } = await import("./commands/memory.js");
-		const isAgent = checkAgentMode();
-		const { backend, config } = await getBackendAndConfig(
-			opts.apiKey,
-			opts.baseUrl,
-		);
+		const { backend, config } = getBackendAndConfig(opts.apiKey, opts.baseUrl);
 		const ids = resolveIds(config, opts);
 		const enableGraph = resolveGraph(config, opts);
-		const output = isAgent ? "agent" : opts.output;
 		await cmdSearch(backend, resolvedQuery, {
 			...ids,
 			topK: opts.topK,
@@ -321,7 +227,7 @@ program
 			filterJson: opts.filter,
 			fields: opts.fields,
 			enableGraph,
-			output,
+			output: opts.output,
 		});
 	});

@@ -339,10 +245,8 @@ program
 	)
 	.action(async (memoryId, opts) => {
 		const { cmdGet } = await import("./commands/memory.js");
-		const isAgent = checkAgentMode();
-		const backend = await getBackendOnly(opts.apiKey, opts.baseUrl);
-		const output = isAgent ? "agent" : opts.output;
-		await cmdGet(backend, memoryId, { output });
+		const backend = getBackendOnly(opts.apiKey, opts.baseUrl);
+		await cmdGet(backend, memoryId, { output: opts.output });
 	});

 // ── Memory: list ──────────────────────────────────────────────────────────
@@ -375,14 +279,9 @@ program
 	)
 	.action(async (opts) => {
 		const { cmdList } = await import("./commands/memory.js");
-		const isAgent = checkAgentMode();
-		const { backend, config } = await getBackendAndConfig(
-			opts.apiKey,
-			opts.baseUrl,
-		);
+		const { backend, config } = getBackendAndConfig(opts.apiKey, opts.baseUrl);
 		const ids = resolveIds(config, opts);
 		const enableGraph = resolveGraph(config, opts);
-		const output = isAgent ? "agent" : opts.output;
 		await cmdList(backend, {
 			...ids,
 			page: opts.page,
@@ -391,7 +290,7 @@ program
 			after: opts.after,
 			before: opts.before,
 			enableGraph,
-			output,
+			output: opts.output,
 		});
 	});

@@ -414,12 +313,10 @@ program
 			resolvedText = fs.readFileSync(0, "utf-8").trim();
 		}
 		const { cmdUpdate } = await import("./commands/memory.js");
-		const isAgent = checkAgentMode();
-		const backend = await getBackendOnly(opts.apiKey, opts.baseUrl);
-		const output = isAgent ? "agent" : opts.output;
+		const backend = getBackendOnly(opts.apiKey, opts.baseUrl);
 		await cmdUpdate(backend, memoryId, resolvedText, {
 			metadata: opts.metadata,
-			output,
+			output: opts.output,
 		});
 	});

@@ -455,8 +352,6 @@ program
 		].join("\n"),
 	)
 	.action(async (memoryId, opts) => {
-		const isAgent = checkAgentMode();
-		const output = isAgent ? "agent" : opts.output;
 		// ── Mutual-exclusion checks ──
 		if (memoryId && opts.all) {
 			printError("Cannot combine <memoryId> with --all. Use one or the other.");
@@ -485,9 +380,9 @@ program
 		// ── Dispatch: single memory ──
 		if (memoryId) {
 			const { cmdDelete } = await import("./commands/memory.js");
-			const backend = await getBackendOnly(opts.apiKey, opts.baseUrl);
+			const backend = getBackendOnly(opts.apiKey, opts.baseUrl);
 			await cmdDelete(backend, memoryId, {
-				output,
+				output: opts.output,
 				dryRun: opts.dryRun,
 				force: opts.force,
 			});
@@ -497,7 +392,7 @@ program
 		// ── Dispatch: --all ──
 		if (opts.all) {
 			const { cmdDeleteAll } = await import("./commands/memory.js");
-			const { backend, config } = await getBackendAndConfig(
+			const { backend, config } = getBackendAndConfig(
 				opts.apiKey,
 				opts.baseUrl,
 			);
@@ -514,7 +409,7 @@ program
 				dryRun: opts.dryRun,
 				all: opts.project,
 				...ids,
-				output,
+				output: opts.output,
 			});
 			return;
 		}
@@ -522,8 +417,8 @@ program
 		// ── Dispatch: --entity ──
 		if (opts.entity) {
 			const { cmdEntitiesDelete } = await import("./commands/entities.js");
-			const backend = await getBackendOnly(opts.apiKey, opts.baseUrl);
-			await cmdEntitiesDelete(backend, { ...opts, output });
+			const backend = getBackendOnly(opts.apiKey, opts.baseUrl);
+			await cmdEntitiesDelete(backend, opts);
 			return;
 		}
 	});
@@ -545,9 +440,7 @@ configCmd
 	)
 	.action(async (opts) => {
 		const { cmdConfigShow } = await import("./commands/config.js");
-		const isAgent = checkAgentMode();
-		const output = isAgent ? "agent" : opts.output;
-		cmdConfigShow({ output });
+		cmdConfigShow({ output: opts.output });
 	});

 configCmd
@@ -559,7 +452,6 @@ configCmd
 	)
 	.action(async (key) => {
 		const { cmdConfigGet } = await import("./commands/config.js");
-		checkAgentMode();
 		cmdConfigGet(key);
 	});

@@ -572,7 +464,6 @@ configCmd
 	)
 	.action(async (key, value) => {
 		const { cmdConfigSet } = await import("./commands/config.js");
-		checkAgentMode();
 		cmdConfigSet(key, value);
 	});

@@ -596,10 +487,8 @@ entityCmd
 	)
 	.action(async (entityType, opts) => {
 		const { cmdEntitiesList } = await import("./commands/entities.js");
-		const isAgent = checkAgentMode();
-		const backend = await getBackendOnly(opts.apiKey, opts.baseUrl);
-		const output = isAgent ? "agent" : opts.output;
-		await cmdEntitiesList(backend, entityType, { output });
+		const backend = getBackendOnly(opts.apiKey, opts.baseUrl);
+		await cmdEntitiesList(backend, entityType, { output: opts.output });
 	});

 entityCmd
@@ -620,54 +509,8 @@ entityCmd
 	)
 	.action(async (opts) => {
 		const { cmdEntitiesDelete } = await import("./commands/entities.js");
-		const isAgent = checkAgentMode();
-		const backend = await getBackendOnly(opts.apiKey, opts.baseUrl);
-		const output = isAgent ? "agent" : opts.output;
-		await cmdEntitiesDelete(backend, { ...opts, output });
-	});
-
-// ── Event subcommands ─────────────────────────────────────────────────────
-
-const eventCmd = program
-	.command("event")
-	.description("Inspect background processing events.")
-	.addHelpCommand(false)
-	.configureHelp({ formatHelp: richFormatHelp });
-
-eventCmd
-	.command("list")
-	.description("List recent background processing events.")
-	.option("-o, --output <format>", "Output: table, json.", "table")
-	.option("--api-key <key>", "Override API key.")
-	.option("--base-url <url>", "Override API base URL.")
-	.addHelpText(
-		"after",
-		"\nExamples:\n  $ mem0 event list\n  $ mem0 event list -o json",
-	)
-	.action(async (opts) => {
-		const { cmdEventList } = await import("./commands/events.js");
-		const isAgent = checkAgentMode();
-		const backend = await getBackendOnly(opts.apiKey, opts.baseUrl);
-		const output = isAgent ? "agent" : opts.output;
-		await cmdEventList(backend, { output });
-	});
-
-eventCmd
-	.command("status <eventId>")
-	.description("Check the status of a specific background event.")
-	.option("-o, --output <format>", "Output: text, json.", "text")
-	.option("--api-key <key>", "Override API key.")
-	.option("--base-url <url>", "Override API base URL.")
-	.addHelpText(
-		"after",
-		"\nExamples:\n  $ mem0 event status <event-id>\n  $ mem0 event status <event-id> -o json",
-	)
-	.action(async (eventId, opts) => {
-		const { cmdEventStatus } = await import("./commands/events.js");
-		const isAgent = checkAgentMode();
-		const backend = await getBackendOnly(opts.apiKey, opts.baseUrl);
-		const output = isAgent ? "agent" : opts.output;
-		await cmdEventStatus(backend, eventId, { output });
+		const backend = getBackendOnly(opts.apiKey, opts.baseUrl);
+		await cmdEntitiesDelete(backend, opts);
 	});

 // ── Utility commands ──────────────────────────────────────────────────────
@@ -681,16 +524,11 @@ program
 	.addHelpText("after", "\nExamples:\n  $ mem0 status\n  $ mem0 status -o json")
 	.action(async (opts) => {
 		const { cmdStatus } = await import("./commands/utils.js");
-		const isAgent = checkAgentMode();
-		const { backend, config } = await getBackendAndConfig(
-			opts.apiKey,
-			opts.baseUrl,
-		);
-		const output = isAgent ? "agent" : opts.output;
+		const { backend, config } = getBackendAndConfig(opts.apiKey, opts.baseUrl);
 		await cmdStatus(backend, {
 			userId: config.defaults.userId || undefined,
 			agentId: config.defaults.agentId || undefined,
-			output,
+			output: opts.output,
 		});
 	});

@@ -708,17 +546,12 @@ program
 	)
 	.action(async (filePath, opts) => {
 		const { cmdImport } = await import("./commands/utils.js");
-		const isAgent = checkAgentMode();
-		const { backend, config } = await getBackendAndConfig(
-			opts.apiKey,
-			opts.baseUrl,
-		);
+		const { backend, config } = getBackendAndConfig(opts.apiKey, opts.baseUrl);
 		const ids = resolveIds(config, opts);
-		const output = isAgent ? "agent" : opts.output;
 		await cmdImport(backend, filePath, {
 			userId: ids.userId,
 			agentId: ids.agentId,
-			output,
+			output: opts.output,
 		});
 	});

@@ -732,9 +565,7 @@ program
 	.option("--json", "Output machine-readable JSON for LLM agents.", false)
 	.addHelpText("after", "\nExamples:\n  $ mem0 help\n  $ mem0 help --json")
 	.action((opts) => {
-		// opts.json is set when `mem0 help --json` is used (subcommand flag).
-		// program.opts().json is set when the root --json global flag was used first.
-		if (opts.json || program.opts().json) {
+		if (opts.json) {
 			// Load spec from parent directory
 			const __dirname = path.dirname(fileURLToPath(import.meta.url));
 			const specPath = path.join(__dirname, "..", "..", "cli-spec.json");
@@ -764,9 +595,7 @@ program
 			console.log(
 				"  add              Add a memory from text, messages, file, or stdin",
 			);
-			console.log(
-				"  search           Query your memory store (semantic, keyword, hybrid)",
-			);
+			console.log("  search           Search memories by semantic query");
 			console.log("  get              Get a specific memory by ID");
 			console.log("  list             List memories with optional filters");
 			console.log("  update           Update a memory's text or metadata");
@@ -776,9 +605,6 @@ program
 			console.log("  import           Import memories from a JSON file");
 			console.log("  config           Manage configuration (show, get, set)");
 			console.log("  entity           Manage entities (list, delete)");
-			console.log(
-				"  event            Inspect background events (list, status)",
-			);
 			console.log("  init             Interactive setup wizard");
 			console.log("  status           Check connectivity and authentication");
 			console.log();
@@ -790,6 +616,16 @@ program
 		}
 	});

+// ── Version ───────────────────────────────────────────────────────────────
+
+program
+	.command("version")
+	.description("Show version.")
+	.action(async () => {
+		const { cmdVersion } = await import("./commands/utils.js");
+		cmdVersion();
+	});
+
 // ── Entrypoint ────────────────────────────────────────────────────────────

 program.parse();
@@ -169,26 +169,17 @@ export function formatAddResult(
 	}

 	console.log();
-	const seenPendingEvents = new Set<string>();
 	for (const r of results) {
 		// Detect async PENDING response
 		if (r.status === "PENDING") {
-			const eventId = (r.event_id as string) ?? "";
-			// Deduplicate PENDING entries with the same event_id
-			if (eventId && seenPendingEvents.has(eventId)) continue;
-			if (eventId) seenPendingEvents.add(eventId);
+			const eventId = ((r.event_id as string) ?? "").slice(0, 8);
 			const icon = accent(sym("⧗", "..."));
 			const parts = [
 				`  ${icon} ${dim("Queued".padEnd(10))}`,
 				"Processing in background",
 			];
+			if (eventId) parts.push(dim(`(event ${eventId})`));
 			console.log(parts.join("  "));
-			if (eventId) {
-				console.log(`  ${dim(`  event_id: ${eventId}`)}`);
-				console.log(
-					`  ${dim(`  → Check status: mem0 event status ${eventId}`)}`,
-				);
-			}
 			continue;
 		}

@@ -247,118 +238,6 @@ export function formatJsonEnvelope(opts: {
 	console.log(JSON.stringify(envelope, null, 2));
 }

-function pick(
-	obj: Record<string, unknown>,
-	keys: string[],
-): Record<string, unknown> {
-	const result: Record<string, unknown> = {};
-	for (const key of keys) {
-		if (key in obj) result[key] = obj[key];
-	}
-	return result;
-}
-
-export function sanitizeAgentData(command: string, data: unknown): unknown {
-	if (data === null || data === undefined) return data;
-
-	switch (command) {
-		case "add": {
-			const items = Array.isArray(data) ? data : [data];
-			return items.map((item) => {
-				const r = item as Record<string, unknown>;
-				if (r.status === "PENDING") return pick(r, ["status", "event_id"]);
-				return pick(r, ["id", "memory", "event"]);
-			});
-		}
-		case "search":
-			return (data as Record<string, unknown>[]).map((r) =>
-				pick(r, ["id", "memory", "score", "created_at", "categories"]),
-			);
-		case "list":
-			return (data as Record<string, unknown>[]).map((r) =>
-				pick(r, ["id", "memory", "created_at", "categories"]),
-			);
-		case "get": {
-			const r = data as Record<string, unknown>;
-			return pick(r, [
-				"id",
-				"memory",
-				"created_at",
-				"updated_at",
-				"categories",
-				"metadata",
-			]);
-		}
-		case "update": {
-			const r = data as Record<string, unknown>;
-			return pick(r, ["id", "memory"]);
-		}
-		case "delete":
-		case "delete-all":
-		case "entity delete":
-			return data;
-		case "entity list":
-			return (data as Record<string, unknown>[]).map((r) => ({
-				name: (r.name ?? r.id) as string,
-				...pick(r, ["type", "count"]),
-			}));
-		case "event list":
-			return (data as Record<string, unknown>[]).map((r) =>
-				pick(r, ["id", "event_type", "status", "latency", "created_at"]),
-			);
-		case "event status": {
-			const ev = data as Record<string, unknown>;
-			const rawResults =
-				(ev.results as Record<string, unknown>[] | undefined) ?? [];
-			const sanitizedResults = rawResults.map((r) => {
-				const nested = r.data as Record<string, unknown> | undefined;
-				return {
-					id: r.id,
-					event: r.event,
-					user_id: r.user_id,
-					memory: nested?.memory ?? null,
-				};
-			});
-			return {
-				...pick(ev, [
-					"id",
-					"event_type",
-					"status",
-					"latency",
-					"created_at",
-					"updated_at",
-				]),
-				results: sanitizedResults,
-			};
-		}
-		default:
-			return data;
-	}
-}
-
-export function formatAgentEnvelope(opts: {
-	command: string;
-	data: unknown;
-	durationMs?: number;
-	scope?: Record<string, string | undefined>;
-	count?: number;
-}): void {
-	const envelope: Record<string, unknown> = {
-		status: "success",
-		command: opts.command,
-	};
-	if (opts.durationMs !== undefined) envelope.duration_ms = opts.durationMs;
-	if (opts.scope) {
-		const filtered = Object.fromEntries(
-			Object.entries(opts.scope).filter(([, v]) => v),
-		);
-		if (Object.keys(filtered).length > 0) envelope.scope = filtered;
-	}
-	if (opts.count !== undefined) envelope.count = opts.count;
-	envelope.data = sanitizeAgentData(opts.command, opts.data);
-	console.log(JSON.stringify(envelope, null, 2));
-}
-
 export function printResultSummary(opts: {
 	count: number;
 	durationSecs?: number;
@@ -370,7 +249,7 @@ export function printResultSummary(opts: {
 	if (opts.scopeIds) {
 		const scopeParts = Object.entries(opts.scopeIds)
 			.filter(([, v]) => v)
-			.map(([k, v]) => `${k}=${v}`);
+			.map(([k, v]) => `${k.replace(/_/g, " ")}=${v}`);
 		if (scopeParts.length > 0) parts.push(scopeParts.join(", "));
 	}
 	if (opts.durationSecs !== undefined)
@@ -1,23 +0,0 @@
-/**
- * Agent mode state — set by the root program option handler,
- * read by commands and branding functions.
- */
-
-let _agentMode = false;
-let _currentCommand = "";
-
-export function isAgentMode(): boolean {
-	return _agentMode;
-}
-
-export function setAgentMode(val: boolean): void {
-	_agentMode = val;
-}
-
-export function getCurrentCommand(): string {
-	return _currentCommand;
-}
-
-export function setCurrentCommand(name: string): void {
-	_currentCommand = name;
-}
@@ -1,153 +0,0 @@
-/**
- * CLI telemetry — anonymous usage tracking via PostHog.
- *
- * Sends fire-and-forget events by spawning a detached child process
- * (telemetry-sender.cjs). The parent CLI process exits immediately;
- * the child handles email resolution, caching, and the HTTP POST.
- *
- * Disable with: MEM0_TELEMETRY=false
- */
-
-import { spawn } from "node:child_process";
-import { createHash, randomUUID } from "node:crypto";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { CONFIG_FILE, loadConfig, saveConfig } from "./config.js";
-import { CLI_VERSION } from "./version.js";
-
-const POSTHOG_API_KEY = "phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX";
-const POSTHOG_HOST = "https://us.i.posthog.com/i/v0/e/";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const SENDER_SCRIPT = path.join(__dirname, "..", "telemetry-sender.cjs");
-
-function isTelemetryEnabled(): boolean {
-	try {
-		return process.env.MEM0_TELEMETRY !== "false";
-	} catch {
-		return true;
-	}
-}
-
-/**
- * Return a persistent per-machine anonymous ID, generating one if needed.
- *
- * Stored in ~/.mem0/config.json under `telemetry.anonymous_id` so that
- * repeat runs on the same machine share one PostHog identity instead of
- * collapsing into a single shared fallback string.
- */
-function getOrCreateAnonymousId(): string {
-	const config = loadConfig();
-	if (config.telemetry.anonymousId) {
-		return config.telemetry.anonymousId;
-	}
-
-	const newId = `cli-anon-${randomUUID().replace(/-/g, "")}`;
-	config.telemetry.anonymousId = newId;
-	try {
-		saveConfig(config);
-	} catch {
-		/* ignore persistence failure — still return the generated ID */
-	}
-	return newId;
-}
-
-/**
- * Return a stable anonymous identifier for the current user.
- *
- * Priority: cached user_email (from /v1/ping/) > MD5(api_key) >
- * persistent per-machine anonymous ID.
- */
-function getDistinctId(): string {
-	try {
-		const config = loadConfig();
-		if (config.platform.userEmail) {
-			return config.platform.userEmail;
-		}
-		if (config.platform.apiKey) {
-			return createHash("md5").update(config.platform.apiKey).digest("hex");
-		}
-	} catch {
-		/* ignore */
-	}
-	try {
-		return getOrCreateAnonymousId();
-	} catch {
-		return `cli-anon-${randomUUID().replace(/-/g, "")}`;
-	}
-}
-
-/**
- * Fire a PostHog event (non-blocking, returns void, never throws).
- * Spawns telemetry-sender.cjs as a detached subprocess.
- *
- * When `preResolvedEmail` is provided (e.g. from an upfront ping
- * validation), it is used directly as the PostHog distinct ID and the
- * subprocess skips its own `/v1/ping/` call.
- */
-export function captureEvent(
-	eventName: string,
-	properties: Record<string, unknown> = {},
-	preResolvedEmail?: string,
-): void {
-	if (!isTelemetryEnabled()) return;
-
-	try {
-		const config = loadConfig();
-		const distinctId = preResolvedEmail || getDistinctId();
-
-		// Detect anonymous → identified transition. If a stored anonymous_id
-		// exists and we just resolved to a real identity, fire a one-shot
-		// $identify event so PostHog stitches the pre-signup history onto
-		// the authenticated profile. Clear the stored id so we don't re-alias.
-		let anonIdToAlias: string | null = null;
-		if (
-			distinctId &&
-			!distinctId.startsWith("cli-anon-") &&
-			config.telemetry.anonymousId
-		) {
-			anonIdToAlias = config.telemetry.anonymousId;
-			config.telemetry.anonymousId = "";
-			try {
-				saveConfig(config);
-			} catch {
-				/* ignore — alias may double-fire next run, harmless */
-			}
-		}
-
-		const payload = {
-			api_key: POSTHOG_API_KEY,
-			distinct_id: distinctId,
-			event: eventName,
-			properties: {
-				source: "CLI",
-				language: "node",
-				cli_version: CLI_VERSION,
-				node_version: process.version,
-				os: process.platform,
-				...properties,
-				$process_person_profile: false,
-				$lib: "posthog-node",
-			},
-		};
-
-		const context = {
-			payload,
-			posthogHost: POSTHOG_HOST,
-			needsEmail: !distinctId || !distinctId.includes("@"),
-			mem0ApiKey: config.platform.apiKey || "",
-			mem0BaseUrl: config.platform.baseUrl || "https://api.mem0.ai",
-			configPath: CONFIG_FILE,
-			anonDistinctIdToAlias: anonIdToAlias,
-		};
-
-		const child = spawn(
-			process.execPath,
-			[SENDER_SCRIPT, JSON.stringify(context)],
-			{ detached: true, stdio: "ignore" },
-		);
-		child.unref();
-	} catch {
-		/* silently swallow */
-	}
-}
@@ -1,129 +0,0 @@
-/**
- * Standalone telemetry sender — runs as a detached child process.
- *
- * Usage: node telemetry-sender.cjs '<json context>'
- *
- * This script is spawned by telemetry.captureEvent() and runs independently
- * of the parent CLI process. It:
- *
- * 1. Resolves the user's email via /v1/ping/ if not already cached
- * 2. Caches the email in ~/.mem0/config.json for future runs
- * 3. Sends the PostHog event
- *
- * All errors are silently swallowed — this process must never produce output
- * or affect the user experience.
- */
-
-"use strict";
-
-const https = require("https");
-const fs = require("fs");
-
-function httpsRequest(url, method, headers, body) {
-	return new Promise((resolve, reject) => {
-		const u = new URL(url);
-		const opts = {
-			hostname: u.hostname,
-			path: u.pathname + u.search,
-			method,
-			headers,
-			timeout: 10000,
-		};
-		const req = https.request(opts, (res) => {
-			let data = "";
-			res.on("data", (chunk) => (data += chunk));
-			res.on("end", () => {
-				try {
-					resolve(JSON.parse(data));
-				} catch {
-					resolve({});
-				}
-			});
-		});
-		req.on("error", reject);
-		req.on("timeout", () => {
-			req.destroy();
-			reject(new Error("timeout"));
-		});
-		if (body) {
-			req.end(body);
-		} else {
-			req.end();
-		}
-	});
-}
-
-async function resolveAndCacheEmail(ctx, payload) {
-	try {
-		const pingUrl = ctx.mem0BaseUrl.replace(/\/+$/, "") + "/v1/ping/";
-		const data = await httpsRequest(pingUrl, "GET", {
-			Authorization: "Token " + ctx.mem0ApiKey,
-			"Content-Type": "application/json",
-		});
-		if (data.user_email) {
-			payload.distinct_id = data.user_email;
-			cacheEmail(ctx.configPath, data.user_email);
-		}
-	} catch {
-		// silently swallow
-	}
-}
-
-function cacheEmail(configPath, email) {
-	if (!configPath) return;
-	try {
-		const raw = fs.readFileSync(configPath, "utf-8");
-		const cfg = JSON.parse(raw);
-		if (!cfg.platform) cfg.platform = {};
-		cfg.platform.user_email = email;
-		fs.writeFileSync(configPath, JSON.stringify(cfg, null, 2));
-	} catch {
-		// silently swallow
-	}
-}
-
-async function sendPosthogEvent(posthogHost, payload) {
-	try {
-		const body = JSON.stringify(payload);
-		await httpsRequest(posthogHost, "POST", {
-			"Content-Type": "application/json",
-			"Content-Length": Buffer.byteLength(body),
-		}, body);
-	} catch {
-		// silently swallow
-	}
-}
-
-async function sendIdentifyEvent(ctx, payload, anonId) {
-	const identifyPayload = {
-		api_key: payload.api_key,
-		event: "$identify",
-		distinct_id: payload.distinct_id,
-		properties: {
-			$anon_distinct_id: anonId,
-			$lib: (payload.properties && payload.properties.$lib) || "posthog-node",
-		},
-	};
-	await sendPosthogEvent(ctx.posthogHost, identifyPayload);
-}
-
-async function main() {
-	const ctx = JSON.parse(process.argv[2]);
-	const payload = ctx.payload;
-
-	if (ctx.needsEmail && ctx.mem0ApiKey) {
-		await resolveAndCacheEmail(ctx, payload);
-	}
-
-	// Fire $identify *after* email resolution so PostHog links the stored
-	// anonymous id directly to the final identity (email, not the api-key
-	// hash). The regular event is sent next so it lands under the merged
-	// profile.
-	if (ctx.anonDistinctIdToAlias) {
-		await sendIdentifyEvent(ctx, payload, ctx.anonDistinctIdToAlias);
-	}
-
-	await sendPosthogEvent(ctx.posthogHost, payload);
-}
-
-main().catch(() => {});
@@ -44,6 +44,13 @@ 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);
@@ -5,7 +5,6 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { createMockBackend } from "./setup.js";
 import type { Backend } from "../src/backend/base.js";
-import { setAgentMode } from "../src/state.js";

 let mockBackend: Backend;

@@ -32,7 +31,6 @@ import { afterEach } from "vitest";
 afterEach(() => {
  console.log = originalLog;
  console.error = originalError;
-  setAgentMode(false);
 });

 describe("cmdAdd", () => {
@@ -86,59 +84,6 @@ describe("cmdAdd", () => {
  });
 });

-describe("cmdAdd deduplicates PENDING", () => {
-  const DUPLICATE_PENDING = {
-    results: [
-      { status: "PENDING", event_id: "evt-dup" },
-      { status: "PENDING", event_id: "evt-dup" },
-    ],
-  };
-
-  it("text shows one pending block", async () => {
-    (mockBackend.add as ReturnType<typeof vi.fn>).mockResolvedValue(DUPLICATE_PENDING);
-    const { cmdAdd } = await import("../src/commands/memory.js");
-    await cmdAdd(mockBackend, "test", {
-      userId: "alice",
-      immutable: false,
-      noInfer: false,
-      enableGraph: false,
-      output: "text",
-    });
-    expect(output.match(/Queued/g)?.length).toBe(1);
-  });
-
-  it("json shows one pending entry", async () => {
-    (mockBackend.add as ReturnType<typeof vi.fn>).mockResolvedValue(DUPLICATE_PENDING);
-    const { cmdAdd } = await import("../src/commands/memory.js");
-    await cmdAdd(mockBackend, "test", {
-      userId: "alice",
-      immutable: false,
-      noInfer: false,
-      enableGraph: false,
-      output: "json",
-    });
-    const data = JSON.parse(output);
-    const pending = data.results.filter((r: Record<string, unknown>) => r.status === "PENDING");
-    expect(pending).toHaveLength(1);
-  });
-
-  it("agent shows one pending entry", async () => {
-    (mockBackend.add as ReturnType<typeof vi.fn>).mockResolvedValue(DUPLICATE_PENDING);
-    setAgentMode(true);
-    const { cmdAdd } = await import("../src/commands/memory.js");
-    await cmdAdd(mockBackend, "test", {
-      userId: "alice",
-      immutable: false,
-      noInfer: false,
-      enableGraph: false,
-      output: "agent",
-    });
-    const data = JSON.parse(output);
-    expect(data.count).toBe(1);
-    expect(data.data).toHaveLength(1);
-  });
-});
-
 describe("cmdSearch", () => {
  it("searches and shows results in text mode", async () => {
    const { cmdSearch } = await import("../src/commands/memory.js");
@@ -253,6 +198,13 @@ 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 () => {
@@ -267,168 +219,3 @@ describe("cmdEntitiesList", () => {
    expect(output).toContain("alice");
  });
 });
-
-describe("cmdEventList", () => {
-  it("lists events in table mode", async () => {
-    const { cmdEventList } = await import("../src/commands/events.js");
-    await cmdEventList(mockBackend, { output: "table" });
-    expect(output).toContain("evt-abc-");
-    expect(output).toContain("ADD");
-    expect(output).toContain("SUCCEEDED");
-  });
-
-  it("lists events in json mode", async () => {
-    const { cmdEventList } = await import("../src/commands/events.js");
-    await cmdEventList(mockBackend, { output: "json" });
-    expect(output).toContain("evt-abc-123-def-456");
-    expect(output).toContain("evt-def-456-ghi-789");
-  });
-
-  it("shows empty message when no events", async () => {
-    (mockBackend.listEvents as ReturnType<typeof vi.fn>).mockResolvedValueOnce([]);
-    const { cmdEventList } = await import("../src/commands/events.js");
-    await cmdEventList(mockBackend, { output: "table" });
-    expect((output + errOutput).toLowerCase()).toContain("no events");
-  });
-});
-
-describe("cmdEventStatus", () => {
-  it("shows event details in text mode", async () => {
-    const { cmdEventStatus } = await import("../src/commands/events.js");
-    await cmdEventStatus(mockBackend, "evt-abc-123-def-456", { output: "text" });
-    expect(output).toContain("evt-abc-123-def-456");
-    expect(output).toContain("SUCCEEDED");
-  });
-
-  it("shows event details in json mode", async () => {
-    const { cmdEventStatus } = await import("../src/commands/events.js");
-    await cmdEventStatus(mockBackend, "evt-abc-123-def-456", { output: "json" });
-    expect(output).toContain("evt-abc-123-def-456");
-    expect(output).toContain("ADD");
-  });
-});
-
-describe("agent mode", () => {
-  it("cmdAdd outputs JSON envelope", async () => {
-    setAgentMode(true);
-    const { cmdAdd } = await import("../src/commands/memory.js");
-    await cmdAdd(mockBackend, "test preference", {
-      userId: "alice",
-      immutable: false,
-      noInfer: false,
-      enableGraph: false,
-      output: "agent",
-    });
-    const parsed = JSON.parse(output.trim());
-    expect(parsed.status).toBe("success");
-    expect(parsed.command).toBe("add");
-    expect(parsed.data).toBeDefined();
-    expect(parsed.scope).toMatchObject({ user_id: "alice" });
-    expect(Object.keys(parsed.data[0]).sort()).toEqual(["event", "id", "memory"].sort());
-  });
-
-  it("cmdSearch outputs JSON envelope", async () => {
-    setAgentMode(true);
-    const { cmdSearch } = await import("../src/commands/memory.js");
-    await cmdSearch(mockBackend, "preferences", {
-      userId: "alice",
-      topK: 10,
-      threshold: 0.3,
-      rerank: false,
-      keyword: false,
-      enableGraph: false,
-      output: "agent",
-    });
-    const parsed = JSON.parse(output.trim());
-    expect(parsed.status).toBe("success");
-    expect(parsed.command).toBe("search");
-    expect(Array.isArray(parsed.data)).toBe(true);
-    expect(parsed.count).toBe(2);
-    const keys = Object.keys(parsed.data[0]);
-    expect(keys).toContain("id");
-    expect(keys).toContain("memory");
-    expect(keys).toContain("score");
-    expect(keys).toContain("created_at");
-    expect(keys).toContain("categories");
-    expect(keys).not.toContain("user_id");
-    expect(keys).not.toContain("agent_id");
-  });
-
-  it("cmdList outputs JSON envelope", async () => {
-    setAgentMode(true);
-    const { cmdList } = await import("../src/commands/memory.js");
-    await cmdList(mockBackend, {
-      userId: "alice",
-      page: 1,
-      pageSize: 100,
-      enableGraph: false,
-      output: "agent",
-    });
-    const parsed = JSON.parse(output.trim());
-    expect(parsed.status).toBe("success");
-    expect(parsed.command).toBe("list");
-    expect(Array.isArray(parsed.data)).toBe(true);
-    expect(parsed.count).toBe(2);
-    expect(Object.keys(parsed.data[0]).sort()).toEqual(["categories", "created_at", "id", "memory"]);
-  });
-
-  it("cmdGet outputs JSON envelope", async () => {
-    setAgentMode(true);
-    const { cmdGet } = await import("../src/commands/memory.js");
-    await cmdGet(mockBackend, "abc-123-def-456", { output: "agent" });
-    const parsed = JSON.parse(output.trim());
-    expect(parsed.status).toBe("success");
-    expect(parsed.command).toBe("get");
-    expect(parsed.data).toBeDefined();
-    expect(parsed.data).toMatchObject({ id: "abc-123-def-456" });
-    expect(Object.keys(parsed.data)).not.toContain("user_id");
-  });
-
-  it("cmdUpdate outputs JSON envelope", async () => {
-    setAgentMode(true);
-    const { cmdUpdate } = await import("../src/commands/memory.js");
-    await cmdUpdate(mockBackend, "abc-123", "Updated text", { output: "agent" });
-    const parsed = JSON.parse(output.trim());
-    expect(parsed.status).toBe("success");
-    expect(parsed.command).toBe("update");
-    expect(parsed.data).toBeDefined();
-  });
-
-  it("cmdDelete outputs JSON envelope", async () => {
-    setAgentMode(true);
-    const { cmdDelete } = await import("../src/commands/memory.js");
-    await cmdDelete(mockBackend, "abc-123", { output: "agent" });
-    const parsed = JSON.parse(output.trim());
-    expect(parsed.status).toBe("success");
-    expect(parsed.command).toBe("delete");
-    expect(parsed.data).toBeDefined();
-  });
-
-  it("cmdEventList outputs JSON envelope", async () => {
-    setAgentMode(true);
-    const { cmdEventList } = await import("../src/commands/events.js");
-    await cmdEventList(mockBackend, { output: "agent" });
-    const parsed = JSON.parse(output.trim());
-    expect(parsed.status).toBe("success");
-    expect(parsed.command).toBe("event list");
-    expect(Array.isArray(parsed.data)).toBe(true);
-    expect(parsed.count).toBe(2);
-    expect(Object.keys(parsed.data[0]).sort()).toEqual(
-      ["created_at", "event_type", "id", "latency", "status"],
-    );
-    expect(Object.keys(parsed.data[0])).not.toContain("updated_at");
-  });
-
-  it("cmdEventStatus outputs JSON envelope", async () => {
-    setAgentMode(true);
-    const { cmdEventStatus } = await import("../src/commands/events.js");
-    await cmdEventStatus(mockBackend, "evt-abc-123-def-456", { output: "agent" });
-    const parsed = JSON.parse(output.trim());
-    expect(parsed.status).toBe("success");
-    expect(parsed.command).toBe("event status");
-    expect(parsed.data).toBeDefined();
-    expect(parsed.data).toMatchObject({ id: "evt-abc-123-def-456" });
-    expect(parsed.data.results[0]).toHaveProperty("memory");
-    expect(parsed.data.results[0]).not.toHaveProperty("data");
-  });
-});
@@ -10,7 +10,6 @@ import {
  formatSingleMemory,
  formatAddResult,
  printResultSummary,
-  sanitizeAgentData,
 } from "../src/output.js";

 let output: string;
@@ -99,18 +98,6 @@ describe("formatAddResult", () => {
    });
    expect(output).toContain("Queued");
  });
-
-  it("deduplicates PENDING entries with same event_id", () => {
-    formatAddResult({
-      results: [
-        { status: "PENDING", event_id: "evt-dup" },
-        { status: "PENDING", event_id: "evt-dup" },
-      ],
-    });
-    // Should show only one PENDING block despite two entries with same event_id
-    expect(output.match(/Queued/g)?.length).toBe(1);
-    expect(output.match(/evt-dup/g)?.length).toBe(2); // event_id line + status hint line
-  });
 });

 describe("printResultSummary", () => {
@@ -126,73 +113,3 @@ describe("printResultSummary", () => {
    expect(output).not.toContain("results");
  });
 });
-
-describe("sanitizeAgentData", () => {
-  it("projects add results", () => {
-    const raw = [{ id: "abc", memory: "test", event: "ADD", metadata: { x: 1 }, categories: ["a"] }];
-    const result = sanitizeAgentData("add", raw) as Record<string, unknown>[];
-    expect(result).toEqual([{ id: "abc", memory: "test", event: "ADD" }]);
-  });
-
-  it("passes through PENDING add items", () => {
-    const raw = [{ status: "PENDING", event_id: "evt-123", noise: "x" }];
-    const result = sanitizeAgentData("add", raw) as Record<string, unknown>[];
-    expect(result).toEqual([{ status: "PENDING", event_id: "evt-123" }]);
-  });
-
-  it("projects search results", () => {
-    const raw = [{ id: "abc", memory: "test", score: 0.9, created_at: "2026-01-01", categories: ["a"], user_id: "u1" }];
-    const result = sanitizeAgentData("search", raw) as Record<string, unknown>[];
-    expect(result[0]).not.toHaveProperty("user_id");
-    expect(result[0]).toHaveProperty("score");
-  });
-
-  it("projects list results", () => {
-    const raw = [{ id: "abc", memory: "test", created_at: "2026-01-01", categories: ["a"], user_id: "u1" }];
-    const result = sanitizeAgentData("list", raw) as Record<string, unknown>[];
-    expect(Object.keys(result[0]).sort()).toEqual(["categories", "created_at", "id", "memory"]);
-  });
-
-  it("projects get result", () => {
-    const raw = { id: "abc", memory: "test", created_at: "2026-01-01", updated_at: "2026-01-02", categories: ["a"], metadata: { k: "v" }, user_id: "u1" };
-    const result = sanitizeAgentData("get", raw) as Record<string, unknown>;
-    expect(result).not.toHaveProperty("user_id");
-    expect(result).toHaveProperty("metadata");
-  });
-
-  it("projects update result", () => {
-    const raw = { id: "abc", memory: "updated", extra: "noise" };
-    const result = sanitizeAgentData("update", raw);
-    expect(result).toEqual({ id: "abc", memory: "updated" });
-  });
-
-  it("projects event list results", () => {
-    const raw = [{ id: "evt-1", event_type: "ADD", status: "SUCCEEDED", graph_status: null, latency: 100, created_at: "2026-01-01", updated_at: "2026-01-02" }];
-    const result = sanitizeAgentData("event list", raw) as Record<string, unknown>[];
-    expect(result[0]).not.toHaveProperty("updated_at");
-    expect(result[0]).not.toHaveProperty("graph_status");
-  });
-
-  it("flattens event status results", () => {
-    const raw = {
-      id: "evt-1", event_type: "ADD", status: "SUCCEEDED",
-      latency: 100, created_at: "2026-01-01", updated_at: "2026-01-02",
-      results: [{ id: "mem-1", event: "ADD", user_id: "alice", data: { memory: "dark mode" } }],
-    };
-    const result = sanitizeAgentData("event status", raw) as Record<string, unknown>;
-    const firstResult = (result.results as Record<string, unknown>[])[0];
-    expect(firstResult).toHaveProperty("memory", "dark mode");
-    expect(firstResult).not.toHaveProperty("data");
-  });
-
-  it("passes through status/config/import commands unchanged", () => {
-    const data = { key: "value", other: "stuff" };
-    for (const cmd of ["status", "import", "config show", "config get", "config set"]) {
-      expect(sanitizeAgentData(cmd, data)).toEqual(data);
-    }
-  });
-
-  it("handles null data", () => {
-    expect(sanitizeAgentData("add", null)).toBeNull();
-  });
-});
@@ -71,42 +71,5 @@ export function createMockBackend(): Backend {
      { name: "alice", count: 5 },
      { name: "bob", count: 3 },
    ]),
-    listEvents: vi.fn().mockResolvedValue([
-      {
-        id: "evt-abc-123-def-456",
-        event_type: "ADD",
-        status: "SUCCEEDED",
-        graph_status: null,
-        latency: 1234.5,
-        created_at: "2026-04-01T10:00:00Z",
-        updated_at: "2026-04-01T10:00:01Z",
-      },
-      {
-        id: "evt-def-456-ghi-789",
-        event_type: "SEARCH",
-        status: "PENDING",
-        graph_status: null,
-        latency: null,
-        created_at: "2026-04-01T10:01:00Z",
-        updated_at: "2026-04-01T10:01:00Z",
-      },
-    ]),
-    getEvent: vi.fn().mockResolvedValue({
-      id: "evt-abc-123-def-456",
-      event_type: "ADD",
-      status: "SUCCEEDED",
-      graph_status: "SUCCEEDED",
-      latency: 1234.5,
-      created_at: "2026-04-01T10:00:00Z",
-      updated_at: "2026-04-01T10:00:01Z",
-      results: [
-        {
-          id: "mem-abc-123",
-          event: "ADD",
-          user_id: "alice",
-          data: { memory: "User prefers dark mode" },
-        },
-      ],
-    }),
  };
 }
@@ -1,12 +1,6 @@
-# mem0 CLI (Python)
+# mem0 CLI

-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+**
+The official command-line interface for [mem0](https://mem0.ai) — the memory layer for AI agents.

 ## Installation

@@ -24,326 +18,22 @@ 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
-# Interactive setup wizard
+# Set up your configuration
 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 for a user
+# List all memories
 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.1`)
-
-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

 Apache-2.0
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"

 [project]
 name = "mem0-cli"
-version = "0.2.3"
+version = "0.1.0"
 description = "The official CLI for mem0 — the memory layer for AI agents"
 readme = "README.md"
 license = "Apache-2.0"
@@ -1,3 +1,3 @@
 """mem0 CLI — the command-line interface for the mem0 memory layer."""

-__version__ = "0.2.3"
+__version__ = "0.1.0"
@@ -2,10 +2,7 @@

 from __future__ import annotations

-import contextlib
 import json as _json
-import os
-import stat as _stat_mod
 import sys
 from pathlib import Path

@@ -13,7 +10,7 @@ import typer
 from rich.console import Console

 from mem0_cli import __version__
-from mem0_cli.branding import BRAND_COLOR, print_error, print_warning
+from mem0_cli.branding import BRAND_COLOR, print_error

 console = Console()
 err_console = Console(stderr=True)
@@ -46,52 +43,7 @@ entity_app = typer.Typer(
    no_args_is_help=True,
    rich_markup_mode="rich",
 )
-
-event_app = typer.Typer(
-    name="event",
-    help="Inspect background processing events.",
-    no_args_is_help=True,
-    rich_markup_mode="rich",
-)
-# entity_app and event_app registered after Memory commands to control panel ordering
-
-
-# ── Validated user identity (set by _get_backend_and_config) ──────────────
-
-_validated_user_email: str | None = None
-
-# ── Telemetry helper ─────────────────────────────────────────────────────
-
-
-def _fire_telemetry(command_name: str, extra: dict | None = None) -> None:
-    """Fire a PostHog telemetry event (non-blocking, never fails)."""
-    try:
-        from mem0_cli.telemetry import capture_event
-
-        props = {"command": command_name}
-        if extra:
-            props.update(extra)
-        capture_event(f"cli.{command_name}", props, pre_resolved_email=_validated_user_email)
-    except Exception:
-        pass
-
-
-@config_app.callback(invoke_without_command=True)
-def _config_callback(ctx: typer.Context) -> None:
-    if ctx.invoked_subcommand:
-        _fire_telemetry(f"config.{ctx.invoked_subcommand}")
-
-
-@entity_app.callback(invoke_without_command=True)
-def _entity_callback(ctx: typer.Context) -> None:
-    if ctx.invoked_subcommand:
-        _fire_telemetry(f"entity.{ctx.invoked_subcommand}")
-
-
-@event_app.callback(invoke_without_command=True)
-def _event_callback(ctx: typer.Context) -> None:
-    if ctx.invoked_subcommand:
-        _fire_telemetry(f"event.{ctx.invoked_subcommand}")
+# entity_app registered after Memory commands to control panel ordering


 # ── Helpers ───────────────────────────────────────────────────────────────
@@ -101,16 +53,9 @@ def _get_backend_and_config(
    api_key: str | None = None,
    base_url: str | None = None,
 ):
-    """Build and return the Platform backend plus the loaded config.
-
-    Validates the API key upfront via ``/v1/ping/`` and caches the
-    resolved user email for telemetry.
-    """
-    global _validated_user_email
-
+    """Build and return the Platform backend plus the loaded config."""
    from mem0_cli.backend import get_backend
-    from mem0_cli.backend.platform import AuthError
-    from mem0_cli.config import load_config, save_config
+    from mem0_cli.config import load_config

    config = load_config()

@@ -127,29 +72,7 @@ def _get_backend_and_config(
        )
        raise typer.Exit(1)

-    backend = get_backend(config)
-
-    # Validate the API key upfront with a fast timeout
-    try:
-        ping_data = backend.ping(timeout=5.0)
-        email = ping_data.get("user_email") if isinstance(ping_data, dict) else None
-        if email:
-            _validated_user_email = email
-            if config.platform.user_email != email:
-                config.platform.user_email = email
-                with contextlib.suppress(Exception):
-                    save_config(config)
-    except AuthError:
-        print_error(
-            err_console,
-            "Invalid or expired API key.",
-            hint="Run 'mem0 init' or set MEM0_API_KEY environment variable.",
-        )
-        raise typer.Exit(1) from None
-    except Exception:
-        print_warning(err_console, "Could not validate API key (network issue). Proceeding anyway.")
-
-    return backend, config
+    return get_backend(config), config


 def _get_backend(
@@ -191,22 +114,9 @@ def _resolve_ids(
    }


-def _stdin_is_piped() -> bool:
-    """Return True only when stdin is an actual pipe or file redirect — not a bare open fd."""
-    from mem0_cli.state import is_agent_mode
-
-    if is_agent_mode():
-        return False
-    try:
-        mode = os.fstat(sys.stdin.fileno()).st_mode
-        return _stat_mod.S_ISFIFO(mode) or _stat_mod.S_ISREG(mode)
-    except Exception:
-        return False
-
-
 def _read_stdin() -> str | None:
-    """Read from stdin if it is an actual pipe or file redirect (not a TTY, not agent mode)."""
-    if _stdin_is_piped():
+    """Read from stdin if it is piped (not a TTY)."""
+    if not sys.stdin.isatty():
        return sys.stdin.read().strip() or None
    return None

@@ -218,26 +128,12 @@ def _read_stdin() -> str | None:
 def main_callback(
    ctx: typer.Context,
    version: bool = typer.Option(False, "--version", help="Show version and exit."),
-    json_agent: bool = typer.Option(
-        False,
-        "--json",
-        "--agent",
-        help="Output as JSON for agent/programmatic use.",
-        is_eager=False,
-    ),
 ) -> None:
-    if json_agent:
-        from mem0_cli.state import set_agent_mode
-
-        set_agent_mode(True)
    if version:
        from mem0_cli.commands.utils import cmd_version

-        _fire_telemetry("version")
        cmd_version()
        raise typer.Exit()
-    if ctx.invoked_subcommand:
-        _fire_telemetry(ctx.invoked_subcommand)


 # ── Memory: add ───────────────────────────────────────────────────────────
@@ -377,7 +273,7 @@ def search(
        None, "--base-url", help="Override API base URL.", rich_help_panel="Connection"
    ),
 ) -> None:
-    """Query your memory store — semantic, keyword, or hybrid retrieval.
+    """Search memories by semantic query.

    Examples:
      mem0 search "preferences" --user-id alice
@@ -642,14 +538,12 @@ def delete(

    # ── Dispatch ─────────────────────────────────────────────────────
    if memory_id is not None:
-        _fire_telemetry("delete", {"delete_mode": "single"})
        from mem0_cli.commands.memory import cmd_delete

        backend = _get_backend(api_key, base_url)
        cmd_delete(backend, memory_id, dry_run=dry_run, force=force, output=output)

    elif all_:
-        _fire_telemetry("delete", {"delete_mode": "all"})
        from mem0_cli.commands.memory import cmd_delete_all

        backend, config = _get_backend_and_config(api_key, base_url)
@@ -657,7 +551,6 @@ def delete(
        cmd_delete_all(backend, force=force, dry_run=dry_run, all_=project, **ids, output=output)

    else:  # --entity
-        _fire_telemetry("delete", {"delete_mode": "entity"})
        from mem0_cli.commands.entities import cmd_entities_delete

        backend = _get_backend(api_key, base_url)
@@ -809,70 +702,6 @@ def entity_delete(
 app.add_typer(entity_app, name="entity", rich_help_panel="Management")


-# ── Event subcommands ─────────────────────────────────────────────────────
-
-
-@event_app.command("list")
-def event_list(
-    output: str = typer.Option(
-        "table", "--output", "-o", help="Output: table, json.", rich_help_panel="Output"
-    ),
-    api_key: str | None = typer.Option(
-        None,
-        "--api-key",
-        help="Override API key.",
-        envvar="MEM0_API_KEY",
-        rich_help_panel="Connection",
-    ),
-    base_url: str | None = typer.Option(
-        None, "--base-url", help="Override API base URL.", rich_help_panel="Connection"
-    ),
-) -> None:
-    """List recent background processing events.
-
-    Examples:
-      mem0 event list
-      mem0 event list -o json
-    """
-    from mem0_cli.commands.events_cmd import cmd_event_list
-
-    backend = _get_backend(api_key, base_url)
-    cmd_event_list(backend, output=output)
-
-
-@event_app.command("status")
-def event_status(
-    event_id: str = typer.Argument(..., help="Event ID to inspect."),
-    output: str = typer.Option(
-        "text", "--output", "-o", help="Output: text, json.", rich_help_panel="Output"
-    ),
-    api_key: str | None = typer.Option(
-        None,
-        "--api-key",
-        help="Override API key.",
-        envvar="MEM0_API_KEY",
-        rich_help_panel="Connection",
-    ),
-    base_url: str | None = typer.Option(
-        None, "--base-url", help="Override API base URL.", rich_help_panel="Connection"
-    ),
-) -> None:
-    """Check the status of a specific background event.
-
-    Examples:
-      mem0 event status <event-id>
-      mem0 event status <event-id> -o json
-    """
-    from mem0_cli.commands.events_cmd import cmd_event_status
-
-    backend = _get_backend(api_key, base_url)
-    cmd_event_status(backend, event_id, output=output)
-
-
-# ── Event subgroup ──
-app.add_typer(event_app, name="event", rich_help_panel="Management")
-
-
 # ── Management commands ───────────────────────────────────────────────────


@@ -886,9 +715,6 @@ def init(
    code: str | None = typer.Option(
        None, "--code", help="Verification code (use with --email for non-interactive login)."
    ),
-    force: bool = typer.Option(
-        False, "--force", help="Overwrite existing config without confirmation."
-    ),
 ) -> None:
    """Interactive setup wizard for mem0 CLI.

@@ -900,7 +726,7 @@ def init(
    """
    from mem0_cli.commands.init_cmd import run_init

-    run_init(api_key=api_key, user_id=user_id, email=email, code=code, force=force)
+    run_init(api_key=api_key, user_id=user_id, email=email, code=code)


 # (entity_app registered at module level, below sub-group definitions)
@@ -1005,7 +831,7 @@ def _build_help_json() -> dict:
            },
        },
        "search": {
-            "description": "Query your memory store — semantic, keyword, or hybrid retrieval.",
+            "description": "Search memories by semantic query.",
            "usage": "mem0 search <query> [OPTIONS]",
            "arguments": {"query": {"description": "Search query.", "required": False}},
            "options": {
@@ -1109,24 +935,6 @@ def _build_help_json() -> dict:
                "value": {"description": "Value to set.", "required": True},
            },
        },
-        "event": {
-            "description": "Inspect background processing events.",
-            "subcommands": {
-                "list": {
-                    "description": "List recent background processing events.",
-                    "usage": "mem0 event list [OPTIONS]",
-                    "options": {"--output, -o": "Output format: table, json."},
-                },
-                "status": {
-                    "description": "Check the status of a specific background event.",
-                    "usage": "mem0 event status <event_id> [OPTIONS]",
-                    "arguments": {
-                        "event_id": {"description": "Event ID to inspect.", "required": True}
-                    },
-                    "options": {"--output, -o": "Output format: text, json."},
-                },
-            },
-        },
        "entity": {
            "description": "Manage entities.",
            "subcommands": {
@@ -1178,7 +986,6 @@ def _build_help_json() -> dict:
        "global_options": {
            "--api-key": "Override API key (env: MEM0_API_KEY).",
            "--base-url": "Override API base URL.",
-            "--json / --agent": "Output as JSON for agent/programmatic use.",
            "--help": "Show help for a command.",
            "--version": "Show version and exit.",
        },
@@ -1208,7 +1015,7 @@ def help(
        console.print("Usage: mem0 <command> [OPTIONS]\n")
        console.print("[bold]Commands:[/]")
        console.print("  add              Add a memory from text, messages, file, or stdin")
-        console.print("  search           Query your memory store (semantic, keyword, hybrid)")
+        console.print("  search           Search memories by semantic query")
        console.print("  get              Get a specific memory by ID")
        console.print("  list             List memories with optional filters")
        console.print("  update           Update a memory's text or metadata")
@@ -1216,7 +1023,6 @@ def help(
        console.print("  import           Import memories from a JSON file")
        console.print("  config           Manage configuration (show, get, set)")
        console.print("  entity           Manage entities (list, delete)")
-        console.print("  event            Inspect background events (list, status)")
        console.print("  init             Interactive setup wizard")
        console.print("  status           Check connectivity and authentication")
        console.print()
@@ -1225,6 +1031,14 @@ def help(
        console.print()


+@app.command(rich_help_panel="Utility")
+def version() -> None:
+    """Show version and exit."""
+    from mem0_cli.commands.utils import cmd_version
+
+    cmd_version()
+
+
 # Register config subgroup here so it appears after help in Management panel
 app.add_typer(config_app, name="config", rich_help_panel="Management")

@@ -1233,14 +1047,4 @@ app.add_typer(config_app, name="config", rich_help_panel="Management")


 def main() -> None:
-    import sys
-
-    # Allow --json/--agent anywhere in the command line (not just before subcommand).
-    _json_flags = {"--json", "--agent"}
-    if any(a in _json_flags for a in sys.argv[1:]):
-        from mem0_cli.state import set_agent_mode
-
-        set_agent_mode(True)
-        sys.argv = [sys.argv[0]] + [a for a in sys.argv[1:] if a not in _json_flags]
-
    app()
@@ -104,12 +104,6 @@ class Backend(ABC):
    @abstractmethod
    def entities(self, entity_type: str) -> list[dict]: ...

-    @abstractmethod
-    def list_events(self) -> list[dict]: ...
-
-    @abstractmethod
-    def get_event(self, event_id: str) -> dict: ...
-

 def get_backend(config: Mem0Config) -> Backend:
    """Return the Platform backend."""
@@ -6,7 +6,6 @@ from typing import Any

 import httpx

-from mem0_cli import __version__
 from mem0_cli.backend.base import Backend
 from mem0_cli.config import PlatformConfig

@@ -22,17 +21,11 @@ class PlatformBackend(Backend):
            headers={
                "Authorization": f"Token {config.api_key}",
                "Content-Type": "application/json",
-                "X-Mem0-Source": "cli",
-                "X-Mem0-Client-Language": "python",
-                "X-Mem0-Client-Version": __version__,
            },
            timeout=30.0,
        )

    def _request(self, method: str, path: str, **kwargs: Any) -> Any:
-        from mem0_cli.state import is_agent_mode
-
-        self._client.headers["X-Mem0-Caller-Type"] = "agent" if is_agent_mode() else "user"
        resp = self._client.request(method, path, **kwargs)
        if resp.status_code == 401:
            raise AuthError("Authentication failed. Your API key may be invalid or expired.")
@@ -93,7 +86,6 @@ class PlatformBackend(Backend):
            payload["categories"] = categories
        if enable_graph:
            payload["enable_graph"] = True
-        payload["source"] = "CLI"

        return self._request("POST", "/v1/memories/", json=payload)

@@ -173,7 +165,6 @@ class PlatformBackend(Backend):
            payload["fields"] = fields
        if enable_graph:
            payload["enable_graph"] = True
-        payload["source"] = "CLI"

        result = self._request("POST", "/v2/memories/search/", json=payload)
        return (
@@ -183,7 +174,7 @@ class PlatformBackend(Backend):
        )

    def get(self, memory_id: str) -> dict:
-        return self._request("GET", f"/v1/memories/{memory_id}/", params={"source": "CLI"})
+        return self._request("GET", f"/v1/memories/{memory_id}/")

    def list_memories(
        self,
@@ -222,7 +213,6 @@ class PlatformBackend(Backend):
            payload["filters"] = api_filters
        if enable_graph:
            payload["enable_graph"] = True
-        payload["source"] = "CLI"

        result = self._request("POST", "/v2/memories/", json=payload, params=params)
        return (
@@ -239,7 +229,6 @@ class PlatformBackend(Backend):
            payload["text"] = content
        if metadata:
            payload["metadata"] = metadata
-        payload["source"] = "CLI"
        return self._request("PUT", f"/v1/memories/{memory_id}/", json=payload)

    def delete(
@@ -253,7 +242,7 @@ class PlatformBackend(Backend):
        run_id: str | None = None,
    ) -> dict:
        if all:
-            params: dict[str, str] = {"source": "CLI"}
+            params: dict[str, str] = {}
            if user_id:
                params["user_id"] = user_id
            if agent_id:
@@ -264,7 +253,7 @@ class PlatformBackend(Backend):
                params["run_id"] = run_id
            return self._request("DELETE", "/v1/memories/", params=params)
        elif memory_id:
-            return self._request("DELETE", f"/v1/memories/{memory_id}/", params={"source": "CLI"})
+            return self._request("DELETE", f"/v1/memories/{memory_id}/")
        else:
            raise ValueError("Either memory_id or --all is required")

@@ -276,37 +265,18 @@ class PlatformBackend(Backend):
        app_id: str | None = None,
        run_id: str | None = None,
    ) -> dict:
-        # v2 endpoint: DELETE /v2/entities/{entity_type}/{entity_id}/
-        type_map = {
-            "user": user_id,
-            "agent": agent_id,
-            "app": app_id,
-            "run": run_id,
-        }
-        entities = {t: v for t, v in type_map.items() if v}
-        if not entities:
+        params: dict[str, str] = {}
+        if user_id:
+            params["user_id"] = user_id
+        if agent_id:
+            params["agent_id"] = agent_id
+        if app_id:
+            params["app_id"] = app_id
+        if run_id:
+            params["run_id"] = run_id
+        if not params:
            raise ValueError("At least one entity ID is required for delete_entities.")
-        # Delete each provided entity via the v2 path-based endpoint
-        result: dict = {}
-        for entity_type, entity_id in entities.items():
-            result = self._request(
-                "DELETE", f"/v2/entities/{entity_type}/{entity_id}/", params={"source": "CLI"}
-            )
-        return result
-
-    def ping(self, timeout: float | None = None) -> dict:
-        """Call the ping endpoint and return the raw response.
-
-        When *timeout* is given it overrides the client-level timeout so that
-        validation pings can fail fast without blocking the user.
-        """
-        if timeout is not None:
-            resp = self._client.get("/v1/ping/", timeout=timeout)
-            if resp.status_code == 401:
-                raise AuthError("Authentication failed. Your API key may be invalid or expired.")
-            resp.raise_for_status()
-            return resp.json()
-        return self._request("GET", "/v1/ping/")
+        return self._request("DELETE", "/v1/entities/", params=params)

    def status(
        self,
@@ -314,9 +284,19 @@ class PlatformBackend(Backend):
        user_id: str | None = None,
        agent_id: str | None = None,
    ) -> dict[str, Any]:
-        """Check connectivity using the ping endpoint."""
+        """Check connectivity by making a lightweight API call."""
        try:
-            self.ping()
+            # If entity IDs are available, validate with a minimal memories list
+            if user_id or agent_id:
+                payload: dict[str, Any] = {}
+                params = {"page": "1", "page_size": "1"}
+                api_filters = self._build_filters(user_id=user_id, agent_id=agent_id)
+                if api_filters:
+                    payload["filters"] = api_filters
+                self._request("POST", "/v2/memories/", json=payload, params=params)
+            else:
+                # No entity IDs — use entities endpoint to validate API key
+                self._request("GET", "/v1/entities/")
            return {"connected": True, "backend": "platform", "base_url": self.base_url}
        except Exception as e:
            return {"connected": False, "backend": "platform", "error": str(e)}
@@ -331,13 +311,6 @@ class PlatformBackend(Backend):
            items = [e for e in items if e.get("type", "").lower() == target_type]
        return items

-    def list_events(self) -> list[dict]:
-        result = self._request("GET", "/v1/events/")
-        return result if isinstance(result, list) else result.get("results", [])
-
-    def get_event(self, event_id: str) -> dict:
-        return self._request("GET", f"/v1/event/{event_id}/")
-

 class AuthError(Exception):
    pass
@@ -43,10 +43,6 @@ def _sym(fancy: str, plain: str) -> str:

 def print_banner(console: Console) -> None:
    """Print the mem0 welcome banner."""
-    from mem0_cli.state import is_agent_mode
-
-    if is_agent_mode():
-        return
    logo_text = Text(LOGO, style=f"bold {BRAND_COLOR}")
    tagline = Text(f"  {TAGLINE}\n", style=f"{ACCENT_COLOR}")

@@ -65,28 +61,11 @@ def print_banner(console: Console) -> None:


 def print_success(console: Console, message: str) -> None:
-    from mem0_cli.state import is_agent_mode
-
-    if is_agent_mode():
-        return
    sym = _sym("✓", "[ok]")
    console.print(f"[{SUCCESS_COLOR}]{sym}[/] {message}")


 def print_error(console: Console, message: str, hint: str | None = None) -> None:
-    from mem0_cli.state import get_current_command, is_agent_mode
-
-    if is_agent_mode():
-        import json as _json
-
-        envelope = {
-            "status": "error",
-            "command": get_current_command(),
-            "error": message,
-            "data": None,
-        }
-        print(_json.dumps(envelope))
-        return
    sym = _sym("✗", "[error]")
    console.print(f"[{ERROR_COLOR}]{sym} Error:[/] {message}")
    if hint:
@@ -94,19 +73,11 @@ def print_error(console: Console, message: str, hint: str | None = None) -> None


 def print_warning(console: Console, message: str) -> None:
-    from mem0_cli.state import is_agent_mode
-
-    if is_agent_mode():
-        return
    sym = _sym("⚠", "[warn]")
    console.print(f"[{WARNING_COLOR}]{sym}[/] {message}")


 def print_info(console: Console, message: str) -> None:
-    from mem0_cli.state import is_agent_mode
-
-    if is_agent_mode():
-        return
    sym = _sym("◆", "*")
    console.print(f"[{BRAND_COLOR}]{sym}[/] {message}")

@@ -118,9 +89,7 @@ def timed_status(console: Console, message: str):
    The spinner and timing output are sent to stderr (via ``_err``) so they
    never contaminate machine-readable stdout.  The *console* parameter is
    kept for backward compatibility but is not used for spinner output.
-    In agent mode the spinner is suppressed entirely.
    """
-    from mem0_cli.state import is_agent_mode

    class _Ctx:
        def __init__(self):
@@ -128,13 +97,6 @@ def timed_status(console: Console, message: str):
            self.error_msg = ""

    ctx = _Ctx()
-    if is_agent_mode():
-        try:
-            yield ctx
-        except Exception:
-            raise
-        return
-
    start = time.perf_counter()
    try:
        with Status(f"[{DIM_COLOR}]{message}[/]", console=_err):
@@ -143,11 +105,6 @@ def timed_status(console: Console, message: str):
        elapsed = time.perf_counter() - start
        if ctx.error_msg:
            print_error(_err, f"{ctx.error_msg} ({elapsed:.2f}s)")
-            if "Authentication failed" in ctx.error_msg:
-                _err.print(
-                    f"  [{DIM_COLOR}]Run [bold]mem0 init[/bold] to reconfigure your API key"
-                    f" · [bold]https://app.mem0.ai/dashboard/api-keys[/bold][/]"
-                )
        raise
    else:
        elapsed = time.perf_counter() - start
@@ -157,14 +114,11 @@ def timed_status(console: Console, message: str):

 def print_scope(console: Console, **ids: str | None) -> None:
    """Show active entity scope if any IDs are set."""
-    from mem0_cli.state import is_agent_mode
-
-    if is_agent_mode():
-        return
    parts = []
    for key, val in ids.items():
        if val:
-            parts.append(f"{key}={val}")
+            label = key.replace("_", " ").replace("id", "ID").strip()
+            parts.append(f"{label}={val}")
    if parts:
        scope_str = ", ".join(parts)
        console.print(f"  [{DIM_COLOR}]Scope: {scope_str}[/]")
@@ -20,17 +20,12 @@ err_console = Console(stderr=True)

 def cmd_config_show(*, output: str = "text") -> None:
    """Display current configuration (secrets redacted)."""
-    from mem0_cli.output import format_agent_envelope
-    from mem0_cli.state import is_agent_mode, set_current_command
-
-    set_current_command("config show")
-    if is_agent_mode():
-        output = "agent"
+    from mem0_cli.output import format_json_envelope

    config = load_config()

-    if output in ("json", "agent"):
-        format_agent_envelope(
+    if output == "json":
+        format_json_envelope(
            console,
            command="config show",
            data={
@@ -89,44 +84,25 @@ def cmd_config_show(*, output: str = "text") -> None:

 def cmd_config_get(key: str) -> None:
    """Get a config value."""
-    from mem0_cli.output import format_agent_envelope
-    from mem0_cli.state import is_agent_mode, set_current_command
-
-    set_current_command("config get")
    config = load_config()
    value = get_nested_value(config, key)

    if value is None:
        print_error(err_console, f"Unknown config key: {key}")
-        return
-
-    display_value = (
-        redact_key(str(value)) if ("api_key" in key or "key" in key.split(".")[-1:]) else str(value)
-    )
-
-    if is_agent_mode():
-        format_agent_envelope(
-            console, command="config get", data={"key": key, "value": display_value}
-        )
    else:
-        console.print(display_value)
+        # Redact secrets
+        if "api_key" in key or "key" in key.split(".")[-1:]:
+            console.print(redact_key(str(value)))
+        else:
+            console.print(str(value))


 def cmd_config_set(key: str, value: str) -> None:
    """Set a config value."""
-    from mem0_cli.output import format_agent_envelope
-    from mem0_cli.state import is_agent_mode, set_current_command
-
-    set_current_command("config set")
    config = load_config()
    if set_nested_value(config, key, value):
        save_config(config)
        display = redact_key(value) if "key" in key else value
-        if is_agent_mode():
-            format_agent_envelope(
-                console, command="config set", data={"key": key, "value": display}
-            )
-        else:
-            print_success(console, f"{key} = {display}")
+        print_success(console, f"{key} = {display}")
    else:
        print_error(err_console, f"Unknown config key: {key}")
@@ -18,7 +18,7 @@ from mem0_cli.branding import (
    print_success,
    timed_status,
 )
-from mem0_cli.output import format_agent_envelope, format_json
+from mem0_cli.output import format_json

 console = Console()
 err_console = Console(stderr=True)
@@ -26,11 +26,6 @@ err_console = Console(stderr=True)

 def cmd_entities_list(backend: Backend, entity_type: str, *, output: str) -> None:
    """List entities of a given type."""
-    from mem0_cli.state import is_agent_mode, set_current_command
-
-    set_current_command("entity list")
-    if is_agent_mode():
-        output = "agent"
    valid_types = {"users", "agents", "apps", "runs"}
    if entity_type not in valid_types:
        print_error(
@@ -47,16 +42,6 @@ def cmd_entities_list(backend: Backend, entity_type: str, *, output: str) -> Non
            raise typer.Exit(1) from None
    _elapsed = _time.perf_counter() - _start

-    if output == "agent":
-        format_agent_envelope(
-            console,
-            command="entity list",
-            data=results,
-            count=len(results),
-            duration_ms=int(_elapsed * 1000),
-        )
-        return
-
    if output == "json":
        format_json(console, results)
        return
@@ -92,39 +77,41 @@ def cmd_entities_delete(
    output: str,
 ) -> None:
    """Delete an entity and all its memories (cascade delete)."""
-    from mem0_cli.state import is_agent_mode, set_current_command
-
-    set_current_command("entity delete")
-    if is_agent_mode():
-        output = "agent"
-        if not force:
-            print_error(err_console, "Destructive operation requires --force in agent mode.")
-            raise typer.Exit(1)
    if not any([user_id, agent_id, app_id, run_id]):
        print_error(
            err_console, "Provide at least one of --user-id, --agent-id, --app-id, --run-id."
        )
        raise typer.Exit(1)

-    scope_parts = []
-    if user_id:
-        scope_parts.append(f"user={user_id}")
-    if agent_id:
-        scope_parts.append(f"agent={agent_id}")
-    if app_id:
-        scope_parts.append(f"app={app_id}")
-    if run_id:
-        scope_parts.append(f"run={run_id}")
-    scope_str = ", ".join(scope_parts)
-
    if dry_run:
-        print_info(console, f"Would delete entity {scope_str} and all its memories.")
+        scope_parts = []
+        if user_id:
+            scope_parts.append(f"user={user_id}")
+        if agent_id:
+            scope_parts.append(f"agent={agent_id}")
+        if app_id:
+            scope_parts.append(f"app={app_id}")
+        if run_id:
+            scope_parts.append(f"run={run_id}")
+        scope = ", ".join(scope_parts)
+        print_info(console, f"Would delete entity {scope} and all its memories.")
        print_info(console, "No changes made (dry run).")
        return

    if not force:
+        scope_parts = []
+        if user_id:
+            scope_parts.append(f"user={user_id}")
+        if agent_id:
+            scope_parts.append(f"agent={agent_id}")
+        if app_id:
+            scope_parts.append(f"app={app_id}")
+        if run_id:
+            scope_parts.append(f"run={run_id}")
+        scope = ", ".join(scope_parts)
+
        confirm = typer.confirm(
-            f"\n  \u26a0  Delete entity {scope_str} AND all its memories? This cannot be undone."
+            f"\n  \u26a0  Delete entity {scope} AND all its memories? This cannot be undone."
        )
        if not confirm:
            print_info(console, "Cancelled.")
@@ -144,25 +131,7 @@ def cmd_entities_delete(
            raise typer.Exit(1) from None
    _elapsed = _time.perf_counter() - _start

-    scope = {
-        k: v
-        for k, v in {
-            "user_id": user_id,
-            "agent_id": agent_id,
-            "app_id": app_id,
-            "run_id": run_id,
-        }.items()
-        if v
-    }
-    if output == "agent":
-        format_agent_envelope(
-            console,
-            command="entity delete",
-            data={"deleted": True},
-            scope=scope or None,
-            duration_ms=int(_elapsed * 1000),
-        )
-    elif output == "json":
+    if output == "json":
        format_json(console, result)
    elif output != "quiet":
        print_success(console, f"Entity deleted with all memories ({_elapsed:.2f}s)")
@@ -1,176 +0,0 @@
-"""Event commands: list and status."""
-
-from __future__ import annotations
-
-import typer
-from rich.console import Console
-from rich.panel import Panel
-from rich.table import Table
-
-from mem0_cli.backend.base import Backend
-from mem0_cli.branding import (
-    ACCENT_COLOR,
-    BRAND_COLOR,
-    DIM_COLOR,
-    ERROR_COLOR,
-    SUCCESS_COLOR,
-    WARNING_COLOR,
-    print_info,
-    timed_status,
-)
-from mem0_cli.output import format_agent_envelope, format_json
-
-console = Console()
-err_console = Console(stderr=True)
-
-_STATUS_STYLE = {
-    "SUCCEEDED": f"[{SUCCESS_COLOR}]SUCCEEDED[/]",
-    "PENDING": f"[{ACCENT_COLOR}]PENDING[/]",
-    "FAILED": f"[{ERROR_COLOR}]FAILED[/]",
-    "PROCESSING": f"[{WARNING_COLOR}]PROCESSING[/]",
-}
-
-
-def _status_styled(status: str) -> str:
-    return _STATUS_STYLE.get(status.upper(), status)
-
-
-def cmd_event_list(backend: Backend, *, output: str = "table") -> None:
-    """List recent background events."""
-    from mem0_cli.state import is_agent_mode, set_current_command
-
-    set_current_command("event list")
-    if is_agent_mode():
-        output = "agent"
-    import time as _time
-
-    _start = _time.perf_counter()
-    with timed_status(err_console, "Fetching events...") as _ts:
-        try:
-            results = backend.list_events()
-        except Exception as e:
-            _ts.error_msg = str(e)
-            raise typer.Exit(1) from None
-
-    _elapsed = _time.perf_counter() - _start
-
-    if output == "agent":
-        format_agent_envelope(
-            console,
-            command="event list",
-            data=results,
-            count=len(results),
-            duration_ms=int(_elapsed * 1000),
-        )
-        return
-
-    if output == "json":
-        format_json(console, results)
-        return
-
-    if not results:
-        console.print()
-        print_info(console, "No events found.")
-        console.print()
-        return
-
-    table = Table(
-        border_style=BRAND_COLOR,
-        header_style=f"bold {ACCENT_COLOR}",
-        row_styles=["", "dim"],
-        padding=(0, 1),
-    )
-    table.add_column("Event ID", style="dim", max_width=10, no_wrap=True)
-    table.add_column("Type", max_width=14)
-    table.add_column("Status", max_width=12)
-    table.add_column("Latency", max_width=10, justify="right")
-    table.add_column("Created", max_width=20)
-
-    for ev in results:
-        ev_id = str(ev.get("id", ""))[:8]
-        ev_type = str(ev.get("event_type", "—"))
-        status = str(ev.get("status", "—"))
-        latency = ev.get("latency")
-        latency_str = f"{latency:.0f}ms" if isinstance(latency, (int, float)) else "—"
-        created = str(ev.get("created_at", "—"))[:19].replace("T", " ")
-        table.add_row(ev_id, ev_type, _status_styled(status), latency_str, created)
-
-    console.print()
-    console.print(table)
-    console.print(f"  [{DIM_COLOR}]{len(results)} event{'s' if len(results) != 1 else ''}[/]")
-    console.print()
-
-
-def cmd_event_status(backend: Backend, event_id: str, *, output: str = "text") -> None:
-    """Get the status of a specific background event."""
-    from mem0_cli.state import is_agent_mode, set_current_command
-
-    set_current_command("event status")
-    if is_agent_mode():
-        output = "agent"
-    import time as _time
-
-    _start = _time.perf_counter()
-    with timed_status(err_console, "Fetching event...") as _ts:
-        try:
-            ev = backend.get_event(event_id)
-        except Exception as e:
-            _ts.error_msg = str(e)
-            raise typer.Exit(1) from None
-
-    _elapsed = _time.perf_counter() - _start
-
-    if output == "agent":
-        format_agent_envelope(
-            console,
-            command="event status",
-            data=ev,
-            duration_ms=int(_elapsed * 1000),
-        )
-        return
-
-    if output == "json":
-        format_json(console, ev)
-        return
-
-    status = str(ev.get("status", "—"))
-    ev_type = str(ev.get("event_type", "—"))
-    latency = ev.get("latency")
-    latency_str = f"{latency:.0f}ms" if isinstance(latency, (int, float)) else "—"
-    created = str(ev.get("created_at", "—"))[:19].replace("T", " ")
-    updated = str(ev.get("updated_at", "—"))[:19].replace("T", " ")
-    results = ev.get("results")
-
-    lines = []
-    lines.append(f"  [{DIM_COLOR}]Event ID:[/]     {event_id}")
-    lines.append(f"  [{DIM_COLOR}]Type:[/]         {ev_type}")
-    lines.append(f"  [{DIM_COLOR}]Status:[/]       {_status_styled(status)}")
-    lines.append(f"  [{DIM_COLOR}]Latency:[/]      {latency_str}")
-    lines.append(f"  [{DIM_COLOR}]Created:[/]      {created}")
-    lines.append(f"  [{DIM_COLOR}]Updated:[/]      {updated}")
-
-    if results:
-        lines.append("")
-        lines.append(f"  [{DIM_COLOR}]Results ({len(results)}):[/]")
-        for r in results:
-            mem_id = str(r.get("id", ""))[:8]
-            data = r.get("data", {})
-            memory = data.get("memory", "") if isinstance(data, dict) else str(data)
-            ev_name = str(r.get("event", ""))
-            user = str(r.get("user_id", ""))
-            detail = f"{ev_name}  {memory}"
-            if user:
-                detail += f"  [{DIM_COLOR}](user_id={user})[/]"
-            lines.append(f"    [{SUCCESS_COLOR}]·[/] {detail}  [{DIM_COLOR}]({mem_id})[/]")
-
-    content = "\n".join(lines)
-    panel = Panel(
-        content,
-        title=f"[{BRAND_COLOR}]Event Status[/]",
-        title_align="left",
-        border_style=BRAND_COLOR,
-        padding=(1, 1),
-    )
-    console.print()
-    console.print(panel)
-    console.print()
@@ -19,7 +19,7 @@ from mem0_cli.branding import (
    print_info,
    print_success,
 )
-from mem0_cli.config import CONFIG_FILE, DEFAULT_BASE_URL, Mem0Config, load_config, save_config
+from mem0_cli.config import DEFAULT_BASE_URL, Mem0Config, save_config

 console = Console()
 err_console = Console(stderr=True)
@@ -108,10 +108,6 @@ def _email_login(
    The caller expects at minimum an ``api_key`` field.
    """
    url = base_url.rstrip("/")
-    _source_headers = {
-        "X-Mem0-Source": "cli",
-        "X-Mem0-Client-Language": "python",
-    }

    with httpx.Client(timeout=30.0) as client:
        # If code is already provided, skip sending — user already has a code
@@ -120,7 +116,6 @@ def _email_login(
            resp = client.post(
                f"{url}/api/v1/auth/email_code/",
                json={"email": email},
-                headers=_source_headers,
            )
            if resp.status_code == 429:
                print_error(err_console, "Too many attempts. Try again in a few minutes.")
@@ -153,7 +148,6 @@ def _email_login(
        resp = client.post(
            f"{url}/api/v1/auth/email_code/verify/",
            json={"email": email, "code": code.strip()},
-            headers=_source_headers,
        )
        if resp.status_code == 429:
            print_error(err_console, "Too many attempts. Try again in a few minutes.")
@@ -175,7 +169,6 @@ def run_init(
    user_id: str | None = None,
    email: str | None = None,
    code: str | None = None,
-    force: bool = False,
 ) -> None:
    """Interactive setup wizard for mem0 CLI.

@@ -191,29 +184,6 @@ def run_init(
        print_error(err_console, "--code requires --email.")
        raise typer.Exit(1)

-    # Warn if an existing config with an API key would be overwritten
-    if not force and CONFIG_FILE.exists():
-        existing = load_config()
-        if existing.platform.api_key:
-            from mem0_cli.config import redact_key
-
-            console.print(
-                f"\n  [{BRAND_COLOR}]Existing configuration found[/] "
-                f"[{DIM_COLOR}](API key: {redact_key(existing.platform.api_key)})[/]"
-            )
-            if sys.stdin.isatty():
-                confirm = typer.confirm("  Overwrite existing config? This cannot be undone.")
-                if not confirm:
-                    print_info(console, "Cancelled. Use --force to skip this check.")
-                    raise typer.Exit(0)
-            else:
-                print_error(
-                    err_console,
-                    "Existing config would be overwritten.",
-                    hint="Use --force to overwrite.",
-                )
-                raise typer.Exit(1)
-
    # ── Email login flow ──────────────────────────────────────────────
    if email:
        if api_key:
@@ -235,10 +205,7 @@ def run_init(
            raise typer.Exit(1)
        config.platform.api_key = api_key_val
        config.platform.base_url = base_url
-        config.platform.user_email = email
-        config.defaults.user_id = (
-            user_id or os.environ.get("USER") or os.environ.get("USERNAME") or "mem0-cli"
-        )
+        config.defaults.user_id = user_id or "mem0-cli"

        save_config(config)

@@ -253,17 +220,6 @@ def run_init(

    # ── API key flow (existing) ───────────────────────────────────────

-    # Non-TTY: resolve defaults so partial flags work in pipelines / CI
-    if not sys.stdin.isatty():
-        if not api_key:
-            print_error(
-                err_console,
-                "Non-interactive terminal detected and --api-key is required.",
-                hint="Run: mem0 init --api-key <key> [--user-id <id>]",
-            )
-            raise typer.Exit(1)
-        user_id = user_id or os.environ.get("USER") or os.environ.get("USERNAME") or "mem0-cli"
-
    # Fully non-interactive when both flags provided
    if api_key and user_id:
        config.platform.api_key = api_key
@@ -273,6 +229,15 @@ def run_init(
        print_success(console, "Configuration saved to ~/.mem0/config.json")
        return

+    # Non-TTY without full flags -> error
+    if not sys.stdin.isatty() and (not api_key or not user_id):
+        print_error(
+            err_console,
+            "Non-interactive terminal detected and required flags missing.",
+            hint="Run: mem0 init --api-key <key> --user-id <id>",
+        )
+        raise typer.Exit(1)
+
    print_banner(console)
    console.print()
    print_info(console, "Welcome! Let's set up your mem0 CLI.\n")
@@ -306,10 +271,7 @@ def run_init(
                raise typer.Exit(1)
            config.platform.api_key = api_key_val
            config.platform.base_url = base_url
-            config.platform.user_email = email_addr
-            config.defaults.user_id = (
-                user_id or os.environ.get("USER") or os.environ.get("USERNAME") or "mem0-cli"
-            )
+            config.defaults.user_id = user_id or "mem0-cli"

            save_config(config)

@@ -369,10 +331,9 @@ def _setup_defaults(config: Mem0Config) -> None:
    console.print()
    print_info(console, "Set default entity IDs (press Enter to skip).\n")

-    _default_user = os.environ.get("USER") or os.environ.get("USERNAME") or "mem0-cli"
    user_id = Prompt.ask(
        f"  [{BRAND_COLOR}]Default User ID[/] [{DIM_COLOR}](recommended)[/]",
-        default=_default_user,
+        default="mem0-cli",
    )
    if user_id:
        config.defaults.user_id = user_id
@@ -392,19 +353,11 @@ def _validate_platform(config: Mem0Config) -> None:
        )
        if status.get("connected"):
            print_success(console, "Connected to mem0 Platform!")
-            # Cache user_email from ping response for telemetry distinct_id
-            try:
-                ping_data = backend.ping()
-                user_email = ping_data.get("user_email") if isinstance(ping_data, dict) else None
-                if user_email:
-                    config.platform.user_email = user_email
-            except Exception:
-                pass
        else:
            print_error(
                err_console,
                f"Could not connect: {status.get('error', 'Unknown error')}",
-                hint="Visit https://app.mem0.ai/dashboard/api-keys to get a new key, then run mem0 init again.",
+                hint="Check your API key and try again.",
            )
    except Exception as e:
        print_error(err_console, f"Connection test failed: {e}")
@@ -3,8 +3,6 @@
 from __future__ import annotations

 import json
-import os
-import stat as _stat_mod
 import sys
 import time as _time
 from pathlib import Path
@@ -22,7 +20,6 @@ from mem0_cli.branding import (
 )
 from mem0_cli.output import (
    format_add_result,
-    format_agent_envelope,
    format_json,
    format_memories_table,
    format_memories_text,
@@ -34,19 +31,6 @@ console = Console()
 err_console = Console(stderr=True)


-def _stdin_is_piped() -> bool:
-    """Return True only when stdin is an actual pipe or file redirect."""
-    from mem0_cli.state import is_agent_mode
-
-    if is_agent_mode():
-        return False
-    try:
-        mode = os.fstat(sys.stdin.fileno()).st_mode
-        return _stat_mod.S_ISFIFO(mode) or _stat_mod.S_ISREG(mode)
-    except Exception:
-        return False
-
-
 def cmd_add(
    backend: Backend,
    text: str | None,
@@ -66,11 +50,6 @@ def cmd_add(
    output: str = "text",
 ) -> None:
    """Add a memory."""
-    from mem0_cli.state import is_agent_mode, set_current_command
-
-    set_current_command("add")
-    if is_agent_mode():
-        output = "agent"
    msgs = None
    content = text

@@ -91,8 +70,8 @@ def cmd_add(
            print_error(err_console, f"Invalid JSON in --messages: {e}")
            raise typer.Exit(1) from None

-    # Read from stdin only if stdin is an actual pipe or file redirect
-    elif not content and _stdin_is_piped():
+    # Read from stdin if no text and stdin is piped
+    elif not content and not sys.stdin.isatty():
        content = sys.stdin.read().strip()

    if not content and not msgs:
@@ -154,61 +133,18 @@ def cmd_add(
    if output == "quiet":
        return

-    # Deduplicate PENDING entries sharing the same event_id across all output modes
-    results_list = result if isinstance(result, list) else result.get("results", [result])
-    seen_events: set[str] = set()
-    deduped: list[dict] = []
-    for r in results_list:
-        if r.get("status") == "PENDING":
-            eid = r.get("event_id", "")
-            if eid and eid in seen_events:
-                continue
-            if eid:
-                seen_events.add(eid)
-        deduped.append(r)
-    # Write back so downstream formatters see deduplicated data
-    if isinstance(result, dict) and "results" in result:
-        result = {**result, "results": deduped}
-    else:
-        result = deduped
-
-    if output == "agent":
-        scope = {
-            k: v
-            for k, v in {
-                "user_id": user_id,
-                "agent_id": agent_id,
-                "app_id": app_id,
-                "run_id": run_id,
-            }.items()
-            if v
-        }
-        format_agent_envelope(
-            console,
-            command="add",
-            data=deduped,
-            scope=scope or None,
-            count=len(deduped),
-        )
-        return
-
    if output == "json":
        format_add_result(console, result, output)
        return

    console.print()
    print_scope(console, user_id=user_id, agent_id=agent_id, app_id=app_id, run_id=run_id)
-    count = len(deduped)
-    all_pending = count > 0 and all(r.get("status") == "PENDING" for r in deduped)
-    if all_pending:
-        print_success(
-            console,
-            f"Memory queued — {count} event{'s' if count != 1 else ''} pending",
-        )
-    else:
-        print_success(
-            console, f"Memory processed — {count} memor{'y' if count == 1 else 'ies'} extracted"
-        )
+    # Count results
+    results = result if isinstance(result, list) else result.get("results", [result])
+    count = len(results) if results else 0
+    print_success(
+        console, f"Memory processed — {count} memor{'y' if count == 1 else 'ies'} extracted"
+    )
    format_add_result(console, result, output)


@@ -230,11 +166,6 @@ def cmd_search(
    output: str = "text",
 ) -> None:
    """Search memories."""
-    from mem0_cli.state import is_agent_mode, set_current_command
-
-    set_current_command("search")
-    if is_agent_mode():
-        output = "agent"
    filters = None
    if filter_json:
        try:
@@ -279,27 +210,6 @@ def cmd_search(
    if output == "quiet":
        return

-    if output == "agent":
-        scope = {
-            k: v
-            for k, v in {
-                "user_id": user_id,
-                "agent_id": agent_id,
-                "app_id": app_id,
-                "run_id": run_id,
-            }.items()
-            if v
-        }
-        format_agent_envelope(
-            console,
-            command="search",
-            data=results,
-            scope=scope or None,
-            count=len(results),
-            duration_ms=int(_elapsed * 1000),
-        )
-        return
-
    if output == "json":
        format_json(console, results)
    elif output == "table":
@@ -326,11 +236,6 @@ def cmd_search(

 def cmd_get(backend: Backend, memory_id: str, *, output: str) -> None:
    """Get a specific memory by ID."""
-    from mem0_cli.state import is_agent_mode, set_current_command
-
-    set_current_command("get")
-    if is_agent_mode():
-        output = "agent"
    with timed_status(err_console, "Fetching memory...") as _ts:
        try:
            result = backend.get(memory_id)
@@ -338,10 +243,7 @@ def cmd_get(backend: Backend, memory_id: str, *, output: str) -> None:
            print_error(err_console, str(e))
            raise typer.Exit(1) from None

-    if output == "agent":
-        format_agent_envelope(console, command="get", data=result)
-    else:
-        format_single_memory(console, result, output)
+    format_single_memory(console, result, output)


 def cmd_list(
@@ -360,11 +262,6 @@ def cmd_list(
    output: str = "table",
 ) -> None:
    """List memories."""
-    from mem0_cli.state import is_agent_mode, set_current_command
-
-    set_current_command("list")
-    if is_agent_mode():
-        output = "agent"
    if page_size < 1:
        print_error(err_console, "--page-size must be >= 1.")
        raise typer.Exit(1)
@@ -395,24 +292,15 @@ def cmd_list(
    if output == "quiet":
        return

-    if output in ("json", "agent"):
-        scope = {
-            k: v
-            for k, v in {
-                "user_id": user_id,
-                "agent_id": agent_id,
-                "app_id": app_id,
-                "run_id": run_id,
-            }.items()
-            if v
-        }
-        format_agent_envelope(
+    if output == "json":
+        from mem0_cli.output import format_json_envelope
+
+        format_json_envelope(
            console,
            command="list",
            data=results,
-            scope=scope or None,
            count=len(results),
-            duration_ms=int(_elapsed * 1000),
+            scope={k: v for k, v in {"user_id": user_id, "agent_id": agent_id}.items() if v},
        )
    elif output == "table":
        if results:
@@ -455,11 +343,6 @@ def cmd_update(
    output: str,
 ) -> None:
    """Update a memory."""
-    from mem0_cli.state import is_agent_mode, set_current_command
-
-    set_current_command("update")
-    if is_agent_mode():
-        output = "agent"
    meta = None
    if metadata:
        try:
@@ -477,14 +360,7 @@ def cmd_update(
            raise typer.Exit(1) from None
    _elapsed = _time.perf_counter() - _start

-    if output == "agent":
-        format_agent_envelope(
-            console,
-            command="update",
-            data=result,
-            duration_ms=int(_elapsed * 1000),
-        )
-    elif output == "json":
+    if output == "json":
        format_json(console, result)
    elif output != "quiet":
        print_success(console, f"Memory {memory_id[:8]} updated ({_elapsed:.2f}s)")
@@ -499,11 +375,6 @@ def cmd_delete(
    output: str,
 ) -> None:
    """Delete a single memory by ID."""
-    from mem0_cli.state import is_agent_mode, set_current_command
-
-    set_current_command("delete")
-    if is_agent_mode():
-        output = "agent"
    if dry_run:
        # Fetch and display what would be deleted
        try:
@@ -524,14 +395,7 @@ def cmd_delete(
            raise typer.Exit(1) from None
    _elapsed = _time.perf_counter() - _start

-    if output == "agent":
-        format_agent_envelope(
-            console,
-            command="delete",
-            data={"id": memory_id, "deleted": True},
-            duration_ms=int(_elapsed * 1000),
-        )
-    elif output == "json":
+    if output == "json":
        format_json(console, result)
    elif output != "quiet":
        print_success(console, f"Memory {memory_id[:8]} deleted ({_elapsed:.2f}s)")
@@ -550,17 +414,13 @@ def cmd_delete_all(
    output: str,
 ) -> None:
    """Delete all memories matching a scope."""
-    from mem0_cli.state import is_agent_mode, set_current_command
-
-    set_current_command("delete-all")
-    if is_agent_mode():
-        output = "agent"
-        if not force:
-            print_error(err_console, "Destructive operation requires --force in agent mode.")
-            raise typer.Exit(1)
    if all_:
        # Project-wide wipe using wildcard entity IDs
-        # Note: --dry-run is ignored here because the API has no count-before-delete endpoint.
+        if dry_run:
+            print_info(console, "Would delete ALL memories project-wide.")
+            print_info(console, "Run without --dry-run to see the actual count.")
+            print_info(console, "No changes made (dry run).")
+            return

        if not force:
            confirm = typer.confirm(
@@ -585,14 +445,7 @@ def cmd_delete_all(
                raise typer.Exit(1) from None
        _elapsed = _time.perf_counter() - _start

-        if output == "agent":
-            format_agent_envelope(
-                console,
-                command="delete-all",
-                data={"deleted": True, "scope": "project"},
-                duration_ms=int(_elapsed * 1000),
-            )
-        elif output == "json":
+        if output == "json":
            format_json(console, result)
        elif output != "quiet":
            if isinstance(result, dict) and "message" in result:
@@ -650,25 +503,7 @@ def cmd_delete_all(
            raise typer.Exit(1) from None
    _elapsed = _time.perf_counter() - _start

-    scope = {
-        k: v
-        for k, v in {
-            "user_id": user_id,
-            "agent_id": agent_id,
-            "app_id": app_id,
-            "run_id": run_id,
-        }.items()
-        if v
-    }
-    if output == "agent":
-        format_agent_envelope(
-            console,
-            command="delete-all",
-            data={"deleted": True},
-            scope=scope or None,
-            duration_ms=int(_elapsed * 1000),
-        )
-    elif output == "json":
+    if output == "json":
        format_json(console, result)
    elif output != "quiet":
        if isinstance(result, dict) and "message" in result:
@@ -35,26 +35,22 @@ def cmd_status(
    output: str = "text",
 ) -> None:
    """Check connectivity and auth."""
-    from mem0_cli.output import format_agent_envelope
-    from mem0_cli.state import is_agent_mode, set_current_command
-
-    set_current_command("status")
-    if is_agent_mode():
-        output = "agent"
+    from mem0_cli.output import format_json_envelope

    _start = _time.perf_counter()
    with timed_status(err_console, "Checking connection...") as _ts:
        result = backend.status(user_id=user_id, agent_id=agent_id)
    _elapsed = _time.perf_counter() - _start

-    if output in ("json", "agent"):
-        format_agent_envelope(
+    if output == "json":
+        format_json_envelope(
            console,
            command="status",
            data={
                "connected": result.get("connected", False),
                "backend": result.get("backend", "?"),
                "base_url": result.get("base_url", ""),
+                "latency_ms": int(_elapsed * 1000),
            },
            duration_ms=int(_elapsed * 1000),
        )
@@ -71,14 +67,6 @@ def cmd_status(
        lines.append(f"  [{DIM_COLOR}]API URL:[/]  {result['base_url']}")
    if result.get("error"):
        lines.append(f"  [{ERROR_COLOR}]Error:[/]    {result['error']}")
-        if "Authentication failed" in str(result["error"]):
-            lines.append("")
-            lines.append(
-                f"  [{DIM_COLOR}]Run [bold]mem0 init[/bold] to reconfigure your API key[/]"
-            )
-            lines.append(
-                f"  [{DIM_COLOR}]Get a key at [bold]https://app.mem0.ai/dashboard/api-keys[/bold][/]"
-            )
    lines.append(f"  [{DIM_COLOR}]Latency:[/]  {_elapsed:.2f}s")

    content = "\n".join(lines)
@@ -108,12 +96,7 @@ def cmd_import(
    output: str = "text",
 ) -> None:
    """Import memories from a JSON file."""
-    from mem0_cli.output import format_agent_envelope
-    from mem0_cli.state import is_agent_mode, set_current_command
-
-    set_current_command("import")
-    if is_agent_mode():
-        output = "agent"
+    from mem0_cli.output import format_json_envelope

    try:
        data = json.loads(Path(file_path).read_text())
@@ -146,13 +129,11 @@ def cmd_import(
            failed += 1
    _elapsed = _time.perf_counter() - _start

-    if output in ("json", "agent"):
-        scope = {k: v for k, v in {"user_id": user_id, "agent_id": agent_id}.items() if v}
-        format_agent_envelope(
+    if output == "json":
+        format_json_envelope(
            console,
            command="import",
-            data={"added": added, "failed": failed},
-            scope=scope or None,
+            data={"added": added, "failed": failed, "duration_s": round(_elapsed, 2)},
            duration_ms=int(_elapsed * 1000),
        )
        return
@@ -27,7 +27,6 @@ CONFIG_VERSION = 1
 class PlatformConfig:
    api_key: str = ""
    base_url: str = DEFAULT_BASE_URL
-    user_email: str = ""


@dataclass
@@ -39,23 +38,16 @@ class DefaultsConfig:
    enable_graph: bool = False


-@dataclass
-class TelemetryConfig:
-    anonymous_id: str = ""
-
-
@dataclass
 class Mem0Config:
    version: int = CONFIG_VERSION
    defaults: DefaultsConfig = field(default_factory=DefaultsConfig)
    platform: PlatformConfig = field(default_factory=PlatformConfig)
-    telemetry: TelemetryConfig = field(default_factory=TelemetryConfig)


 SHORT_KEY_ALIASES: dict[str, str] = {
    "api_key": "platform.api_key",
    "base_url": "platform.base_url",
-    "user_email": "platform.user_email",
    "user_id": "defaults.user_id",
    "agent_id": "defaults.agent_id",
    "app_id": "defaults.app_id",
@@ -84,7 +76,6 @@ def load_config() -> Mem0Config:
        plat = data.get("platform", {})
        config.platform.api_key = plat.get("api_key", "")
        config.platform.base_url = plat.get("base_url", DEFAULT_BASE_URL)
-        config.platform.user_email = plat.get("user_email", "")

        defaults = data.get("defaults", {})
        config.defaults.user_id = defaults.get("user_id", "")
@@ -93,9 +84,6 @@ def load_config() -> Mem0Config:
        config.defaults.run_id = defaults.get("run_id", "")
        config.defaults.enable_graph = defaults.get("enable_graph", False)

-        telemetry = data.get("telemetry", {})
-        config.telemetry.anonymous_id = telemetry.get("anonymous_id", "")
-
    # Environment variable overrides
    env_key = os.environ.get("MEM0_API_KEY")
    if env_key:
@@ -144,10 +132,6 @@ def save_config(config: Mem0Config) -> None:
        "platform": {
            "api_key": config.platform.api_key,
            "base_url": config.platform.base_url,
-            "user_email": config.platform.user_email,
-        },
-        "telemetry": {
-            "anonymous_id": config.telemetry.anonymous_id,
        },
    }

@@ -155,23 +155,16 @@ def format_add_result(console: Console, result: dict | list, output: str = "text
        return

    console.print()
-    seen_pending_events: set[str] = set()
    for r in results:
        # Detect async PENDING response from Platform API
        if r.get("status") == "PENDING":
-            event_id = r.get("event_id", "")
-            # Deduplicate PENDING entries with the same event_id
-            if event_id and event_id in seen_pending_events:
-                continue
-            if event_id:
-                seen_pending_events.add(event_id)
+            event_id = r.get("event_id", "")[:8]
            icon = f"[{ACCENT_COLOR}]{_sym('⧗', '...')}[/]"
            parts = [f"  {icon} [{DIM_COLOR}]{'Queued':<10}[/]"]
            parts.append("[white]Processing in background[/]")
-            console.print("  ".join(parts))
            if event_id:
-                console.print(f"  [{DIM_COLOR}]  event_id: {event_id}[/]")
-                console.print(f"  [{DIM_COLOR}]  → Check status: mem0 event status {event_id}[/]")
+                parts.append(f"[{DIM_COLOR}](event {event_id})[/]")
+            console.print("  ".join(parts))
            continue

        event = r.get("event", "ADD")
@@ -232,100 +225,6 @@ def format_json_envelope(
    console.print_json(json.dumps(envelope, default=str))


-def sanitize_agent_data(command: str, data: Any) -> Any:
-    """Project API response data to minimal relevant fields for agent consumption."""
-
-    def pick(obj: dict, keys: list) -> dict:
-        return {k: obj[k] for k in keys if k in obj}
-
-    if data is None:
-        return data
-
-    if command == "add":
-        items = data if isinstance(data, list) else [data]
-        result = []
-        for item in items:
-            if item.get("status") == "PENDING":
-                result.append(pick(item, ["status", "event_id"]))
-            else:
-                result.append(pick(item, ["id", "memory", "event"]))
-        return result
-
-    if command == "search":
-        return [pick(r, ["id", "memory", "score", "created_at", "categories"]) for r in data]
-
-    if command == "list":
-        return [pick(r, ["id", "memory", "created_at", "categories"]) for r in data]
-
-    if command == "get":
-        return pick(data, ["id", "memory", "created_at", "updated_at", "categories", "metadata"])
-
-    if command == "update":
-        return pick(data, ["id", "memory"])
-
-    if command in ("delete", "delete-all", "entity delete"):
-        return data
-
-    if command == "entity list":
-        result = []
-        for r in data:
-            item = pick(r, ["type", "count"])
-            item["name"] = r.get("name") or r.get("id", "")
-            result.append(item)
-        return result
-
-    if command == "event list":
-        return [pick(r, ["id", "event_type", "status", "latency", "created_at"]) for r in data]
-
-    if command == "event status":
-        ev = data
-        raw_results = ev.get("results") or []
-        sanitized_results = []
-        for r in raw_results:
-            nested = r.get("data") or {}
-            memory = nested.get("memory") if isinstance(nested, dict) else None
-            sanitized_results.append(
-                {
-                    "id": r.get("id"),
-                    "event": r.get("event"),
-                    "user_id": r.get("user_id"),
-                    "memory": memory,
-                }
-            )
-        result = pick(ev, ["id", "event_type", "status", "latency", "created_at", "updated_at"])
-        result["results"] = sanitized_results
-        return result
-
-    # Pass-through: status, import, config show/get/set
-    return data
-
-
-def format_agent_envelope(
-    console: Console,
-    *,
-    command: str,
-    data: Any,
-    duration_ms: int | None = None,
-    scope: dict | None = None,
-    count: int | None = None,
-) -> None:
-    """Output structured JSON envelope for agent/programmatic use (--json/--agent mode)."""
-    envelope: dict[str, Any] = {
-        "status": "success",
-        "command": command,
-    }
-    if duration_ms is not None:
-        envelope["duration_ms"] = duration_ms
-    if scope:
-        filtered = {k: v for k, v in scope.items() if v}
-        if filtered:
-            envelope["scope"] = filtered
-    if count is not None:
-        envelope["count"] = count
-    envelope["data"] = sanitize_agent_data(command, data)
-    console.print_json(json.dumps(envelope, default=str))
-
-
 def print_result_summary(
    console: Console,
    count: int,
@@ -338,7 +237,7 @@ def print_result_summary(
    parts = [f"{count} result{'s' if count != 1 else ''}"]
    if page is not None:
        parts.append(f"page {page}")
-    scope_parts = [f"{k}={v}" for k, v in scope_ids.items() if v]
+    scope_parts = [f"{k.replace('_', ' ')}={v}" for k, v in scope_ids.items() if v]
    if scope_parts:
        parts.append(", ".join(scope_parts))
    if duration_secs is not None:
@@ -1,24 +0,0 @@
-"""Agent mode state — set by the root callback, read by commands and branding."""
-
-from __future__ import annotations
-
-_agent_mode: bool = False
-_current_command: str = ""
-
-
-def is_agent_mode() -> bool:
-    return _agent_mode
-
-
-def set_agent_mode(val: bool) -> None:
-    global _agent_mode
-    _agent_mode = val
-
-
-def get_current_command() -> str:
-    return _current_command
-
-
-def set_current_command(name: str) -> None:
-    global _current_command
-    _current_command = name
@@ -1,146 +0,0 @@
-"""CLI telemetry — anonymous usage tracking via PostHog.
-
-Sends fire-and-forget events to PostHog by spawning a detached subprocess
-(telemetry_sender.py). The parent CLI process exits immediately; the
-subprocess handles email resolution, caching, and the HTTP POST.
-
-Disable with: MEM0_TELEMETRY=false
-"""
-
-from __future__ import annotations
-
-import contextlib
-import hashlib
-import json
-import os
-import platform
-import subprocess
-import sys
-import uuid
-from typing import Any
-
-POSTHOG_API_KEY = "phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX"
-POSTHOG_HOST = "https://us.i.posthog.com/i/v0/e/"
-
-
-def _is_telemetry_enabled() -> bool:
-    val = os.environ.get("MEM0_TELEMETRY", "true").lower()
-    return val not in ("false", "0", "no")
-
-
-def _get_or_create_anonymous_id() -> str:
-    """Return a persistent per-machine anonymous ID, generating one if needed.
-
-    Stored in ~/.mem0/config.json under `telemetry.anonymous_id` so that
-    repeat runs on the same machine share one PostHog identity instead of
-    collapsing into a single shared fallback string.
-    """
-    from mem0_cli.config import load_config, save_config
-
-    config = load_config()
-    if config.telemetry.anonymous_id:
-        return config.telemetry.anonymous_id
-
-    new_id = f"cli-anon-{uuid.uuid4().hex}"
-    config.telemetry.anonymous_id = new_id
-    with contextlib.suppress(Exception):
-        save_config(config)
-    return new_id
-
-
-def _get_distinct_id() -> str:
-    """Return a stable anonymous identifier for the current user.
-
-    Priority: cached user_email (from /v1/ping/) > MD5(api_key) >
-    persistent per-machine anonymous ID.
-    """
-    try:
-        from mem0_cli.config import load_config
-
-        config = load_config()
-        if config.platform.user_email:
-            return config.platform.user_email
-        if config.platform.api_key:
-            return hashlib.md5(config.platform.api_key.encode()).hexdigest()
-    except Exception:
-        pass
-    try:
-        return _get_or_create_anonymous_id()
-    except Exception:
-        return f"cli-anon-{uuid.uuid4().hex}"
-
-
-def capture_event(
-    event_name: str,
-    properties: dict[str, Any] | None = None,
-    pre_resolved_email: str | None = None,
-) -> None:
-    """Fire a PostHog event via a detached subprocess (non-blocking).
-
-    When *pre_resolved_email* is provided (e.g. from an upfront ping
-    validation), it is used directly as the PostHog distinct ID and the
-    subprocess skips its own ``/v1/ping/`` call.
-    """
-    if not _is_telemetry_enabled():
-        return
-
-    try:
-        from mem0_cli import __version__
-        from mem0_cli.config import CONFIG_FILE, load_config, save_config
-        from mem0_cli.state import is_agent_mode
-
-        config = load_config()
-        distinct_id = pre_resolved_email or _get_distinct_id()
-
-        # Detect anonymous → identified transition. If a stored anonymous_id
-        # exists and we just resolved to a real identity, fire a one-shot
-        # $identify event so PostHog stitches the pre-signup history onto
-        # the authenticated profile. Clear the stored id so we don't re-alias.
-        anon_id_to_alias: str | None = None
-        if (
-            distinct_id
-            and not distinct_id.startswith("cli-anon-")
-            and config.telemetry.anonymous_id
-        ):
-            anon_id_to_alias = config.telemetry.anonymous_id
-            config.telemetry.anonymous_id = ""
-            with contextlib.suppress(Exception):
-                save_config(config)
-
-        payload = {
-            "api_key": POSTHOG_API_KEY,
-            "distinct_id": distinct_id,
-            "event": event_name,
-            "properties": {
-                "source": "CLI",
-                "language": "python",
-                "cli_version": __version__,
-                "agent_mode": is_agent_mode(),
-                "python_version": sys.version,
-                "os": sys.platform,
-                "os_version": platform.version(),
-                "$process_person_profile": False,
-                "$lib": "posthog-python",
-                **(properties or {}),
-            },
-        }
-
-        context = {
-            "payload": payload,
-            "posthog_host": POSTHOG_HOST,
-            "needs_email": not distinct_id or "@" not in distinct_id,
-            "mem0_api_key": config.platform.api_key or "",
-            "mem0_base_url": config.platform.base_url or "https://api.mem0.ai",
-            "config_path": str(CONFIG_FILE),
-            "anon_distinct_id_to_alias": anon_id_to_alias,
-        }
-
-        subprocess.Popen(
-            [sys.executable, "-m", "mem0_cli.telemetry_sender", json.dumps(context)],
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-            start_new_session=True,
-            close_fds=True,
-        )
-    except Exception:
-        pass
@@ -1,108 +0,0 @@
-"""Standalone telemetry sender — runs as a detached subprocess.
-
-Usage: python -m mem0_cli.telemetry_sender '<json context>'
-
-This module is spawned by telemetry.capture_event() and runs independently
-of the parent CLI process. It:
-
-1. Resolves the user's email via /v1/ping/ if not already cached
-2. Caches the email in ~/.mem0/config.json for future runs
-3. Sends the PostHog event
-
-All errors are silently swallowed — this process must never produce output
-or affect the user experience.
-"""
-
-from __future__ import annotations
-
-import json
-import sys
-import urllib.request
-
-
-def main() -> None:
-    ctx = json.loads(sys.argv[1])
-    payload = ctx["payload"]
-
-    if ctx.get("needs_email") and ctx.get("mem0_api_key"):
-        _resolve_and_cache_email(ctx, payload)
-
-    # Fire $identify *after* email resolution so PostHog links the stored
-    # anonymous id directly to the final identity (email, not the api-key
-    # hash). The regular event is sent next so it lands under the merged
-    # profile.
-    anon_id = ctx.get("anon_distinct_id_to_alias")
-    if anon_id:
-        _send_identify_event(ctx, payload, anon_id)
-
-    _send_posthog_event(ctx["posthog_host"], payload)
-
-
-def _send_identify_event(ctx: dict, payload: dict, anon_id: str) -> None:
-    """Send a PostHog $identify event aliasing anon_id → payload['distinct_id']."""
-    identify_payload = {
-        "api_key": payload["api_key"],
-        "event": "$identify",
-        "distinct_id": payload["distinct_id"],
-        "properties": {
-            "$anon_distinct_id": anon_id,
-            "$lib": payload.get("properties", {}).get("$lib", "posthog-python"),
-        },
-    }
-    _send_posthog_event(ctx["posthog_host"], identify_payload)
-
-
-def _resolve_and_cache_email(ctx: dict, payload: dict) -> None:
-    """Call /v1/ping/ to get the user's email, update the payload, and cache it."""
-    try:
-        ping_url = ctx["mem0_base_url"].rstrip("/") + "/v1/ping/"
-        req = urllib.request.Request(
-            ping_url,
-            headers={
-                "Authorization": "Token " + ctx["mem0_api_key"],
-                "Content-Type": "application/json",
-            },
-        )
-        resp = urllib.request.urlopen(req, timeout=10)
-        data = json.loads(resp.read())
-        email = data.get("user_email")
-        if email:
-            payload["distinct_id"] = email
-            _cache_email(ctx.get("config_path"), email)
-    except Exception:
-        pass
-
-
-def _cache_email(config_path: str | None, email: str) -> None:
-    """Write user_email into the config file for future runs."""
-    if not config_path:
-        return
-    try:
-        with open(config_path) as f:
-            cfg = json.load(f)
-        cfg.setdefault("platform", {})["user_email"] = email
-        with open(config_path, "w") as f:
-            json.dump(cfg, f, indent=2)
-    except Exception:
-        pass
-
-
-def _send_posthog_event(posthog_host: str, payload: dict) -> None:
-    """POST the event to PostHog."""
-    try:
-        body = json.dumps(payload).encode()
-        req = urllib.request.Request(
-            posthog_host,
-            data=body,
-            headers={"Content-Type": "application/json"},
-        )
-        urllib.request.urlopen(req, timeout=10)
-    except Exception:
-        pass
-
-
-if __name__ == "__main__":
-    import contextlib
-
-    with contextlib.suppress(Exception):
-        main()
@@ -96,43 +96,6 @@ def mock_backend():
        {"name": "alice", "count": 5},
        {"name": "bob", "count": 3},
    ]
-    backend.list_events.return_value = [
-        {
-            "id": "evt-abc-123-def-456",
-            "event_type": "ADD",
-            "status": "SUCCEEDED",
-            "graph_status": None,
-            "latency": 1234.5,
-            "created_at": "2026-04-01T10:00:00Z",
-            "updated_at": "2026-04-01T10:00:01Z",
-        },
-        {
-            "id": "evt-def-456-ghi-789",
-            "event_type": "SEARCH",
-            "status": "PENDING",
-            "graph_status": None,
-            "latency": None,
-            "created_at": "2026-04-01T10:01:00Z",
-            "updated_at": "2026-04-01T10:01:00Z",
-        },
-    ]
-    backend.get_event.return_value = {
-        "id": "evt-abc-123-def-456",
-        "event_type": "ADD",
-        "status": "SUCCEEDED",
-        "graph_status": "SUCCEEDED",
-        "latency": 1234.5,
-        "created_at": "2026-04-01T10:00:00Z",
-        "updated_at": "2026-04-01T10:00:01Z",
-        "results": [
-            {
-                "id": "mem-abc-123",
-                "event": "ADD",
-                "user_id": "alice",
-                "data": {"memory": "User prefers dark mode"},
-            }
-        ],
-    }

    return backend

@@ -83,6 +83,11 @@ 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
@@ -3,7 +3,6 @@
 from __future__ import annotations

 import json
-import typing
 from io import StringIO
 from unittest.mock import patch

@@ -17,7 +16,6 @@ from mem0_cli.commands.config_cmd import (
    cmd_config_show,
 )
 from mem0_cli.commands.entities import cmd_entities_delete, cmd_entities_list
-from mem0_cli.commands.events_cmd import cmd_event_list, cmd_event_status
 from mem0_cli.commands.memory import (
    cmd_add,
    cmd_delete,
@@ -30,6 +28,7 @@ from mem0_cli.commands.memory import (
 from mem0_cli.commands.utils import (
    cmd_import,
    cmd_status,
+    cmd_version,
 )


@@ -177,28 +176,30 @@ class TestAddCommand:
    def test_add_no_content_exits(self, mock_backend):
        console, _buf = _make_console()
        err_console, _err_buf = _make_err_console()
+        # Patch stdin.isatty to return True so it doesn't try to read stdin
        with (
            patch("mem0_cli.commands.memory.console", console),
            patch("mem0_cli.commands.memory.err_console", err_console),
-            patch("mem0_cli.commands.memory._stdin_is_piped", return_value=False),
-            pytest.raises((SystemExit, ClickExit)),
+            patch("mem0_cli.commands.memory.sys") as mock_sys,
        ):
-            cmd_add(
-                mock_backend,
-                None,
-                user_id="alice",
-                agent_id=None,
-                app_id=None,
-                run_id=None,
-                messages=None,
-                file=None,
-                metadata=None,
-                immutable=False,
-                no_infer=False,
-                expires=None,
-                categories=None,
-                output="text",
-            )
+            mock_sys.stdin.isatty.return_value = True
+            with pytest.raises((SystemExit, ClickExit)):
+                cmd_add(
+                    mock_backend,
+                    None,
+                    user_id="alice",
+                    agent_id=None,
+                    app_id=None,
+                    run_id=None,
+                    messages=None,
+                    file=None,
+                    metadata=None,
+                    immutable=False,
+                    no_infer=False,
+                    expires=None,
+                    categories=None,
+                    output="text",
+                )

    def test_add_invalid_metadata_json(self, mock_backend):
        console, _buf = _make_console()
@@ -278,66 +279,6 @@ class TestAddCommand:
        mock_backend.add.assert_called_once()


-class TestAddDeduplicatesPending:
-    """Ensure duplicate PENDING entries with the same event_id are collapsed."""
-
-    DUPLICATE_PENDING: typing.ClassVar[dict] = {
-        "results": [
-            {"status": "PENDING", "event_id": "evt-dup"},
-            {"status": "PENDING", "event_id": "evt-dup"},
-        ]
-    }
-
-    def _run_add(self, mock_backend, output):
-        mock_backend.add.return_value = self.DUPLICATE_PENDING
-        console, buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-        with (
-            patch("mem0_cli.commands.memory.console", console),
-            patch("mem0_cli.commands.memory.err_console", err_console),
-        ):
-            cmd_add(
-                mock_backend,
-                "test",
-                user_id="alice",
-                agent_id=None,
-                app_id=None,
-                run_id=None,
-                messages=None,
-                file=None,
-                metadata=None,
-                immutable=False,
-                no_infer=False,
-                expires=None,
-                categories=None,
-                output=output,
-            )
-        return buf.getvalue()
-
-    def test_text_shows_one_pending(self, mock_backend):
-        raw = self._run_add(mock_backend, "text")
-        assert raw.count("Queued") == 1
-
-    def test_json_shows_one_pending(self, mock_backend):
-        raw = self._run_add(mock_backend, "json")
-        data = json.loads(raw)
-        results = data.get("results", data)
-        pending = [r for r in results if r.get("status") == "PENDING"]
-        assert len(pending) == 1
-
-    def test_agent_shows_one_pending(self, mock_backend):
-        from mem0_cli.state import set_agent_mode
-
-        set_agent_mode(True)
-        try:
-            raw = self._run_add(mock_backend, "agent")
-        finally:
-            set_agent_mode(False)
-        data = json.loads(raw)
-        assert data["count"] == 1
-        assert len(data["data"]) == 1
-
-
 class TestSearchCommand:
    def test_search_text(self, mock_backend):
        console, buf = _make_console()
@@ -677,6 +618,28 @@ class TestDeleteAllCommand:
            run_id="*",
        )

+    def test_delete_all_project_wide_dry_run(self, mock_backend):
+        console, buf = _make_console()
+        err_console, _err_buf = _make_err_console()
+        with (
+            patch("mem0_cli.commands.memory.console", console),
+            patch("mem0_cli.commands.memory.err_console", err_console),
+        ):
+            cmd_delete_all(
+                mock_backend,
+                force=True,
+                all_=True,
+                dry_run=True,
+                user_id=None,
+                agent_id=None,
+                app_id=None,
+                run_id=None,
+                output="text",
+            )
+        output = buf.getvalue()
+        assert "project-wide" in output.lower()
+        mock_backend.delete.assert_not_called()
+
    def test_delete_all_project_wide_async_response(self, mock_backend):
        mock_backend.delete.return_value = {"message": "Memories deletion started..."}
        console, buf = _make_console()
@@ -741,6 +704,15 @@ 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"
@@ -916,28 +888,6 @@ class TestEntitiesDeleteCommand:
        output = buf.getvalue()
        assert "deleted" in output.lower()

-    def test_delete_entity_agent_id(self, mock_backend):
-        console, buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-        with (
-            patch("mem0_cli.commands.entities.console", console),
-            patch("mem0_cli.commands.entities.err_console", err_console),
-        ):
-            cmd_entities_delete(
-                mock_backend,
-                user_id=None,
-                agent_id="bot1",
-                app_id=None,
-                run_id=None,
-                force=True,
-                output="text",
-            )
-        mock_backend.delete_entities.assert_called_once_with(
-            user_id=None, agent_id="bot1", app_id=None, run_id=None
-        )
-        output = buf.getvalue()
-        assert "deleted" in output.lower()
-
    def test_delete_entity_no_id_exits(self, mock_backend):
        console, _buf = _make_console()
        err_console, _err_buf = _make_err_console()
@@ -1074,388 +1024,3 @@ class TestEnableGraph:
            )
        call_kwargs = mock_backend.list_memories.call_args
        assert call_kwargs.kwargs.get("enable_graph") is True
-
-
-class TestEventCommands:
-    def test_event_list_table(self, mock_backend):
-        console, buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-        with (
-            patch("mem0_cli.commands.events_cmd.console", console),
-            patch("mem0_cli.commands.events_cmd.err_console", err_console),
-        ):
-            cmd_event_list(mock_backend, output="table")
-        out = buf.getvalue()
-        assert "evt-abc-" in out
-        assert "ADD" in out
-        assert "SUCCEEDED" in out
-
-    def test_event_list_json(self, mock_backend):
-        console, buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-        with (
-            patch("mem0_cli.commands.events_cmd.console", console),
-            patch("mem0_cli.commands.events_cmd.err_console", err_console),
-        ):
-            cmd_event_list(mock_backend, output="json")
-        out = buf.getvalue()
-        assert "evt-abc-123-def-456" in out
-        assert "evt-def-456-ghi-789" in out
-
-    def test_event_list_empty(self, mock_backend):
-        mock_backend.list_events.return_value = []
-        console, buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-        with (
-            patch("mem0_cli.commands.events_cmd.console", console),
-            patch("mem0_cli.commands.events_cmd.err_console", err_console),
-        ):
-            cmd_event_list(mock_backend, output="table")
-        out = buf.getvalue()
-        assert "No events" in out
-
-    def test_event_status_text(self, mock_backend):
-        console, buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-        with (
-            patch("mem0_cli.commands.events_cmd.console", console),
-            patch("mem0_cli.commands.events_cmd.err_console", err_console),
-        ):
-            cmd_event_status(mock_backend, "evt-abc-123-def-456", output="text")
-        out = buf.getvalue()
-        assert "evt-abc-123-def-456" in out
-        assert "SUCCEEDED" in out
-
-    def test_event_status_json(self, mock_backend):
-        console, buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-        with (
-            patch("mem0_cli.commands.events_cmd.console", console),
-            patch("mem0_cli.commands.events_cmd.err_console", err_console),
-        ):
-            cmd_event_status(mock_backend, "evt-abc-123-def-456", output="json")
-        out = buf.getvalue()
-        assert "evt-abc-123-def-456" in out
-        assert "ADD" in out
-
-
-class TestAgentMode:
-    """Tests for --json/--agent mode: structured JSON envelope output."""
-
-    def setup_method(self):
-        """Enable agent mode before each test."""
-        from mem0_cli.state import set_agent_mode
-
-        set_agent_mode(True)
-
-    def teardown_method(self):
-        """Reset agent mode after each test."""
-        from mem0_cli.state import set_agent_mode
-
-        set_agent_mode(False)
-
-    # ── add ──────────────────────────────────────────────────────────────────
-
-    def test_add_agent_mode_envelope(self, mock_backend):
-        console, buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-        with (
-            patch("mem0_cli.commands.memory.console", console),
-            patch("mem0_cli.commands.memory.err_console", err_console),
-        ):
-            cmd_add(
-                mock_backend,
-                "I prefer dark mode",
-                user_id="alice",
-                agent_id=None,
-                app_id=None,
-                run_id=None,
-                messages=None,
-                file=None,
-                metadata=None,
-                immutable=False,
-                no_infer=False,
-                expires=None,
-                categories=None,
-                output="text",  # will be overridden to "agent"
-            )
-        raw = buf.getvalue()
-        data = json.loads(raw)
-        assert data["status"] == "success"
-        assert data["command"] == "add"
-        assert "data" in data
-        assert isinstance(data["data"], list)
-        assert data["count"] == 1
-        assert set(data["data"][0].keys()) == {"id", "memory", "event"}
-
-    def test_add_agent_mode_scope(self, mock_backend):
-        console, buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-        with (
-            patch("mem0_cli.commands.memory.console", console),
-            patch("mem0_cli.commands.memory.err_console", err_console),
-        ):
-            cmd_add(
-                mock_backend,
-                "test",
-                user_id="bob",
-                agent_id="agent1",
-                app_id=None,
-                run_id=None,
-                messages=None,
-                file=None,
-                metadata=None,
-                immutable=False,
-                no_infer=False,
-                expires=None,
-                categories=None,
-                output="text",
-            )
-        data = json.loads(buf.getvalue())
-        assert data["scope"]["user_id"] == "bob"
-        assert data["scope"]["agent_id"] == "agent1"
-
-    # ── search ───────────────────────────────────────────────────────────────
-
-    def test_search_agent_mode_envelope(self, mock_backend):
-        console, buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-        with (
-            patch("mem0_cli.commands.memory.console", console),
-            patch("mem0_cli.commands.memory.err_console", err_console),
-        ):
-            cmd_search(
-                mock_backend,
-                "dark mode",
-                user_id="alice",
-                agent_id=None,
-                app_id=None,
-                run_id=None,
-                top_k=10,
-                threshold=0.3,
-                rerank=False,
-                keyword=False,
-                filter_json=None,
-                fields=None,
-                output="text",
-            )
-        data = json.loads(buf.getvalue())
-        assert data["status"] == "success"
-        assert data["command"] == "search"
-        assert isinstance(data["data"], list)
-        assert data["count"] == 2
-        assert "duration_ms" in data
-        assert set(data["data"][0].keys()) == {"id", "memory", "score", "created_at", "categories"}
-
-    # ── list ─────────────────────────────────────────────────────────────────
-
-    def test_list_agent_mode_envelope(self, mock_backend):
-        console, buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-        with (
-            patch("mem0_cli.commands.memory.console", console),
-            patch("mem0_cli.commands.memory.err_console", err_console),
-        ):
-            cmd_list(
-                mock_backend,
-                user_id="alice",
-                agent_id=None,
-                app_id=None,
-                run_id=None,
-                page=1,
-                page_size=100,
-                category=None,
-                after=None,
-                before=None,
-                output="table",  # will be overridden to "agent"
-            )
-        data = json.loads(buf.getvalue())
-        assert data["status"] == "success"
-        assert data["command"] == "list"
-        assert isinstance(data["data"], list)
-        assert data["count"] == 2
-        assert data["scope"]["user_id"] == "alice"
-        assert set(data["data"][0].keys()) == {"id", "memory", "created_at", "categories"}
-
-    # ── get ──────────────────────────────────────────────────────────────────
-
-    def test_get_agent_mode_envelope(self, mock_backend):
-        console, buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-        with (
-            patch("mem0_cli.commands.memory.console", console),
-            patch("mem0_cli.commands.memory.err_console", err_console),
-        ):
-            cmd_get(mock_backend, "abc-123-def-456", output="text")
-        data = json.loads(buf.getvalue())
-        assert data["status"] == "success"
-        assert data["command"] == "get"
-        assert isinstance(data["data"], dict)
-        assert data["data"]["id"] == "abc-123-def-456"
-        assert "memory" in data["data"]
-        assert set(data["data"].keys()) >= {"id", "memory"}
-
-    # ── update ───────────────────────────────────────────────────────────────
-
-    def test_update_agent_mode_envelope(self, mock_backend):
-        console, buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-        with (
-            patch("mem0_cli.commands.memory.console", console),
-            patch("mem0_cli.commands.memory.err_console", err_console),
-        ):
-            cmd_update(mock_backend, "abc-123", "Updated content", metadata=None, output="text")
-        data = json.loads(buf.getvalue())
-        assert data["status"] == "success"
-        assert data["command"] == "update"
-        assert isinstance(data["data"], dict)
-        assert "memory" in data["data"]
-        assert "duration_ms" in data
-
-    # ── delete ───────────────────────────────────────────────────────────────
-
-    def test_delete_agent_mode_envelope(self, mock_backend):
-        console, buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-        with (
-            patch("mem0_cli.commands.memory.console", console),
-            patch("mem0_cli.commands.memory.err_console", err_console),
-        ):
-            cmd_delete(mock_backend, "abc-123-def-456", output="text")
-        data = json.loads(buf.getvalue())
-        assert data["status"] == "success"
-        assert data["command"] == "delete"
-        assert data["data"]["id"] == "abc-123-def-456"
-        assert data["data"]["deleted"] is True
-        assert "duration_ms" in data
-
-    # ── event list ───────────────────────────────────────────────────────────
-
-    def test_event_list_agent_mode_envelope(self, mock_backend):
-        console, buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-        with (
-            patch("mem0_cli.commands.events_cmd.console", console),
-            patch("mem0_cli.commands.events_cmd.err_console", err_console),
-        ):
-            cmd_event_list(mock_backend, output="table")
-        data = json.loads(buf.getvalue())
-        assert data["status"] == "success"
-        assert data["command"] == "event list"
-        assert isinstance(data["data"], list)
-        assert data["count"] == 2
-        assert "duration_ms" in data
-        assert set(data["data"][0].keys()) == {
-            "id",
-            "event_type",
-            "status",
-            "latency",
-            "created_at",
-        }
-
-    # ── event status ─────────────────────────────────────────────────────────
-
-    def test_event_status_agent_mode_envelope(self, mock_backend):
-        console, buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-        with (
-            patch("mem0_cli.commands.events_cmd.console", console),
-            patch("mem0_cli.commands.events_cmd.err_console", err_console),
-        ):
-            cmd_event_status(mock_backend, "evt-abc-123-def-456", output="text")
-        data = json.loads(buf.getvalue())
-        assert data["status"] == "success"
-        assert data["command"] == "event status"
-        assert isinstance(data["data"], dict)
-        assert data["data"]["id"] == "evt-abc-123-def-456"
-        assert "duration_ms" in data
-        assert set(data["data"]["results"][0].keys()) == {"id", "event", "user_id", "memory"}
-        assert "data" not in data["data"]["results"][0]
-
-    # ── error handling ───────────────────────────────────────────────────────
-
-    def test_error_in_agent_mode_produces_json_to_stdout(self, mock_backend):
-        """Errors in agent mode must emit a JSON envelope to stdout, not stderr."""
-        from io import StringIO
-
-        mock_backend.get.side_effect = Exception("Memory not found")
-        console, _buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-
-        captured_stdout = StringIO()
-        with (
-            patch("mem0_cli.commands.memory.console", console),
-            patch("mem0_cli.commands.memory.err_console", err_console),
-            patch("sys.stdout", captured_stdout),
-            pytest.raises((SystemExit, ClickExit)),
-        ):
-            cmd_get(mock_backend, "bad-id", output="text")
-
-        stdout_output = captured_stdout.getvalue()
-        # The error JSON envelope must be on stdout
-        error_data = json.loads(stdout_output)
-        assert error_data["status"] == "error"
-        assert "error" in error_data
-        assert error_data["data"] is None
-
-    def test_branding_suppressed_in_agent_mode(self, mock_backend):
-        """Scope line and success message must be absent in agent mode output."""
-        console, buf = _make_console()
-        err_console, _err_buf = _make_err_console()
-        with (
-            patch("mem0_cli.commands.memory.console", console),
-            patch("mem0_cli.commands.memory.err_console", err_console),
-        ):
-            cmd_add(
-                mock_backend,
-                "branding test",
-                user_id="alice",
-                agent_id=None,
-                app_id=None,
-                run_id=None,
-                messages=None,
-                file=None,
-                metadata=None,
-                immutable=False,
-                no_infer=False,
-                expires=None,
-                categories=None,
-                output="text",
-            )
-        output = buf.getvalue()
-        # Must be valid JSON only — no human-readable branding
-        data = json.loads(output)
-        assert data["status"] == "success"
-        # "Scope:" and "Memory processed" must NOT appear in the raw output
-        assert "Scope:" not in output
-        assert "Memory processed" not in output
-        assert "spinner" not in output.lower()
-
-    def test_no_spinner_in_agent_mode(self, mock_backend):
-        """timed_status must not emit spinner output in agent mode."""
-        err_buf = StringIO()
-        err_console_buf = Console(file=err_buf, force_terminal=False, no_color=True, width=120)
-        console, _buf = _make_console()
-        with (
-            patch("mem0_cli.commands.memory.console", console),
-            patch("mem0_cli.commands.memory.err_console", err_console_buf),
-        ):
-            cmd_search(
-                mock_backend,
-                "query",
-                user_id="alice",
-                agent_id=None,
-                app_id=None,
-                run_id=None,
-                top_k=5,
-                threshold=0.3,
-                rerank=False,
-                keyword=False,
-                filter_json=None,
-                fields=None,
-                output="text",
-            )
-        # The err_buf captures what would have been spinner/timing noise
-        # In agent mode it should be empty (no status lines printed)
-        err_output = err_buf.getvalue()
-        assert "Searching" not in err_output
@@ -11,7 +11,6 @@ from mem0_cli.output import (
    format_memories_table,
    format_memories_text,
    format_single_memory,
-    sanitize_agent_data,
 )


@@ -130,153 +129,8 @@ class TestAddResult:
        output = buf.getvalue()
        assert output.strip() == ""

-    def test_format_add_result_deduplicates_pending_by_event_id(self):
-        console, buf = _make_console()
-        result = {
-            "results": [
-                {"status": "PENDING", "event_id": "evt-dup"},
-                {"status": "PENDING", "event_id": "evt-dup"},
-            ]
-        }
-        format_add_result(console, result, "text")
-        output = buf.getvalue()
-        # Should show only one PENDING block despite two entries with same event_id
-        assert output.count("evt-dup") == 2  # event_id line + status hint line
-        assert output.count("Queued") == 1
-
    def test_format_add_result_empty(self):
        console, buf = _make_console()
        format_add_result(console, {"results": []}, "text")
        output = buf.getvalue()
        assert "No memories extracted" in output
-
-
-class TestSanitizeAgentData:
-    def test_add_projects_fields(self):
-        raw = [
-            {
-                "id": "abc",
-                "memory": "test",
-                "event": "ADD",
-                "metadata": {"x": 1},
-                "categories": ["a"],
-            }
-        ]
-        result = sanitize_agent_data("add", raw)
-        assert result == [{"id": "abc", "memory": "test", "event": "ADD"}]
-
-    def test_add_pending_passthrough(self):
-        raw = [{"status": "PENDING", "event_id": "evt-123", "metadata": "noise"}]
-        result = sanitize_agent_data("add", raw)
-        assert result == [{"status": "PENDING", "event_id": "evt-123"}]
-
-    def test_search_projects_fields(self):
-        raw = [
-            {
-                "id": "abc",
-                "memory": "test",
-                "score": 0.9,
-                "created_at": "2026-01-01",
-                "categories": ["a"],
-                "user_id": "u1",
-                "agent_id": None,
-            }
-        ]
-        result = sanitize_agent_data("search", raw)
-        assert result == [
-            {
-                "id": "abc",
-                "memory": "test",
-                "score": 0.9,
-                "created_at": "2026-01-01",
-                "categories": ["a"],
-            }
-        ]
-
-    def test_list_projects_fields(self):
-        raw = [
-            {
-                "id": "abc",
-                "memory": "test",
-                "created_at": "2026-01-01",
-                "categories": ["a"],
-                "user_id": "u1",
-            }
-        ]
-        result = sanitize_agent_data("list", raw)
-        assert result == [
-            {"id": "abc", "memory": "test", "created_at": "2026-01-01", "categories": ["a"]}
-        ]
-
-    def test_get_projects_fields(self):
-        raw = {
-            "id": "abc",
-            "memory": "test",
-            "created_at": "2026-01-01",
-            "updated_at": "2026-01-02",
-            "categories": ["a"],
-            "metadata": {"k": "v"},
-            "user_id": "u1",
-        }
-        result = sanitize_agent_data("get", raw)
-        assert "user_id" not in result
-        assert "id" in result and "memory" in result
-
-    def test_update_projects_fields(self):
-        raw = {"id": "abc", "memory": "updated", "extra": "noise"}
-        result = sanitize_agent_data("update", raw)
-        assert result == {"id": "abc", "memory": "updated"}
-
-    def test_event_list_projects_fields(self):
-        raw = [
-            {
-                "id": "evt-1",
-                "event_type": "ADD",
-                "status": "SUCCEEDED",
-                "graph_status": None,
-                "latency": 100.0,
-                "created_at": "2026-01-01",
-                "updated_at": "2026-01-02",
-            }
-        ]
-        result = sanitize_agent_data("event list", raw)
-        assert result == [
-            {
-                "id": "evt-1",
-                "event_type": "ADD",
-                "status": "SUCCEEDED",
-                "latency": 100.0,
-                "created_at": "2026-01-01",
-            }
-        ]
-        assert "updated_at" not in result[0]
-        assert "graph_status" not in result[0]
-
-    def test_event_status_flattens_results(self):
-        raw = {
-            "id": "evt-1",
-            "event_type": "ADD",
-            "status": "SUCCEEDED",
-            "latency": 100.0,
-            "created_at": "2026-01-01",
-            "updated_at": "2026-01-02",
-            "results": [
-                {"id": "mem-1", "event": "ADD", "user_id": "alice", "data": {"memory": "dark mode"}}
-            ],
-        }
-        result = sanitize_agent_data("event status", raw)
-        assert result["results"][0] == {
-            "id": "mem-1",
-            "event": "ADD",
-            "user_id": "alice",
-            "memory": "dark mode",
-        }
-        assert "data" not in result["results"][0]
-
-    def test_passthrough_commands(self):
-        for cmd in ("status", "import", "config show", "config get", "config set"):
-            data = {"key": "value", "other": "stuff"}
-            assert sanitize_agent_data(cmd, data) == data
-
-    def test_none_data(self):
-        assert sanitize_agent_data("add", None) is None
@@ -10,7 +10,7 @@ description: "REST APIs for memory management, search, and entity operations"
 Mem0 provides a comprehensive REST API for integrating advanced memory capabilities into your applications. Create, search, update, and manage memories across users, agents, and custom entities with simple HTTP requests.

 <Info>
-**Quick start:** Get your API key from the <a href="https://app.mem0.ai/dashboard/api-keys" rel="nofollow">Mem0 Dashboard</a> and make your first memory operation in minutes.
+**Quick start:** Get your API key from the [Mem0 Dashboard](https://app.mem0.ai/dashboard/api-keys) and make your first memory operation in minutes.
 </Info>

 ---
@@ -87,7 +87,7 @@ All API requests require authentication using Token-based authentication. Includ
 Authorization: Token <your-api-key>
 ```

-Get your API key from the <a href="https://app.mem0.ai/dashboard/api-keys" rel="nofollow">Mem0 Dashboard</a>.
+Get your API key from the [Mem0 Dashboard](https://app.mem0.ai/dashboard/api-keys).

 <Warning>
 **Keep your API key secure.** Never expose it in client-side code or public repositories. Use environment variables and server-side requests only.
@@ -47,6 +47,8 @@ Provide at least one message or direct memory string. Most callers supply `messa
 | `messages` | array | No* | Conversation turns for Mem0 to infer memories from. Each object should include `role` and `content`. |
 | `metadata` | object | Optional | Custom key/value metadata (e.g., `{"topic": "preferences"}`). |
 | `infer` | boolean (default `true`) | Optional | Set to `false` to skip inference and store the provided text as-is. |
+| `async_mode` | boolean (default `true`) | Optional | Controls asynchronous processing. Most clients leave this enabled. |
+| `output_format` | string (default `v1.1`) | Optional | Response format. `v1.1` wraps results in a `results` array. |

 > \* Provide at least one `messages` entry to describe what you are storing. For scoped memories, include `user_id`. You can also attach `agent_id`, `app_id`, `run_id`, `project_id`, or `org_id` to refine ownership.

@@ -81,3 +83,20 @@ Successful requests return an array of events queued for processing. Each event
 ```
 </CodeGroup>

+## Graph relationships
+
+Add Memories can enrich the knowledge graph on write. Set `enable_graph: true` to create entity nodes and relationships for the stored memory. Use this when you want downstream `get_all` or search calls to traverse connected entities.
+
+<CodeGroup>
+```json Graph-aware request
+{
+  "user_id": "alice",
+  "messages": [
+    { "role": "user", "content": "I met with Dr. Lee at General Hospital." }
+  ],
+  "enable_graph": true
+}
+```
+</CodeGroup>
+
+The response follows the same format, and related entities become available in [Graph Memory](/platform/features/graph-memory) queries.
@@ -62,7 +62,8 @@ To retrieve graph memory relationships between entities, pass `output_format="v1
 memories = client.get_all(
    filters={
        "user_id": "alex"
-    }
+    },
+    output_format="v1.1"
 )
 ```

@@ -32,7 +32,7 @@ Example with the mem0 Python package:

 ```python
 from mem0 import MemoryClient
-client = MemoryClient(api_key="your-api-key")
+client = MemoryClient(org_id='YOUR_ORG_ID', project_id='YOUR_PROJECT_ID')
 ```

  </Tab>
@@ -41,7 +41,10 @@ client = MemoryClient(api_key="your-api-key")

 ```javascript
 import { MemoryClient } from "mem0ai";
-const client = new MemoryClient({ apiKey: "your-api-key" });
+const client = new MemoryClient({
+  organizationId: "YOUR_ORG_ID",
+  projectId: "YOUR_PROJECT_ID"
+});
 ```

  </Tab>
@@ -79,7 +82,7 @@ new_project = client.project.create(

 ### Update Project Settings

-Modify project configuration including custom instructions, categories, graph settings, and language preferences:
+Modify project configuration including custom instructions, categories, and graph settings:

 ```python
 # Update project with custom categories
@@ -95,8 +98,8 @@ client.project.update(
    custom_instructions="..."
 )

-# Use the input language for memory storage and retrieval
-client.project.update(multilingual=True)
+# Enable graph memory for the project
+client.project.update(enable_graph=True)

 # Update multiple settings at once
 client.project.update(
@@ -105,7 +108,7 @@ client.project.update(
        {"personal_info": "User personal information and preferences"},
        {"work_context": "Professional context and work-related information"}
    ],
-    multilingual=True
+    enable_graph=True
 )
 ```

@@ -165,11 +168,11 @@ All project methods are available in async mode:
 from mem0 import AsyncMemoryClient

 async def manage_project():
-    client = AsyncMemoryClient(api_key="your-api-key")
+    client = AsyncMemoryClient(org_id='YOUR_ORG_ID', project_id='YOUR_PROJECT_ID')

    # All methods support async/await
    project_info = await client.project.get()
-    await client.project.update(multilingual=True)
+    await client.project.update(enable_graph=True)
    members = await client.project.get_members()

 # To call the async function properly
@@ -1,90 +1,13 @@
 ---
-title: "SDK & Tools"
-description: "Release notes for the Mem0 Python SDK, TypeScript SDK, Vercel AI SDK, CLI, and editor plugins."
+title: "Product Updates"
+description: "Latest releases, bug fixes, and improvements for the Mem0 Python and TypeScript SDKs."
 mode: "wide"
 ---

+ 
 <Tabs>
 <Tab title="Python">

-<Update label="2026-04-14" description="v2.0.0">
-
-**Major Release** — Python SDK with V3 memory pipeline, ADD-only extraction, and cleaned-up API surface.
-
-**New Features:**
- **Single-Pass Extraction:** Replaced 2-LLM-call pipeline with additive extraction using `ADDITIVE_EXTRACTION_PROMPT`. Memories accumulate via `linked_memory_ids` — no more UPDATE/DELETE events ([#4805](https://github.com/mem0ai/mem0/pull/4805))
- **Hybrid Search:** Combined semantic + BM25 keyword matching + entity boost with additive scoring. Native `keyword_search()` added to 15 vector store adapters (Qdrant, Elasticsearch, OpenSearch, Azure AI Search, Weaviate, Redis, PGVector, Pinecone, Databricks, MongoDB, Milvus, Baidu, Upstash, Azure MySQL, Vertex AI) ([#4805](https://github.com/mem0ai/mem0/pull/4805))
- **Entity Extraction & Linking:** spaCy-based entity extraction with second vector collection (`{collection}_entities`) for cross-memory relationship retrieval. Optional dependency: `pip install mem0ai[nlp]` ([#4805](https://github.com/mem0ai/mem0/pull/4805))
- **Batch Operations:** Batch embedding, batch persist, and batch entity linking (8-phase pipeline) for both sync `Memory` and async `AsyncMemory` at full parity ([#4805](https://github.com/mem0ai/mem0/pull/4805))
- **Message Persistence:** SQLite-based rolling window (10 messages per session scope) for LLM context ([#4805](https://github.com/mem0ai/mem0/pull/4805))
- **Valkey Cluster Mode:** Added `cluster_mode` parameter for Valkey Cluster Mode Enabled (CME) deployments ([#4759](https://github.com/mem0ai/mem0/pull/4759))
- **V3 API Endpoints:** `MemoryClient.add()` now posts to `/v3/memories/add/`; `MemoryClient.get_all()` posts to `/v3/memories/` and returns a paginated envelope `{"count": int, "next": str | None, "previous": str | None, "results": [...]}` ([#4856](https://github.com/mem0ai/mem0/pull/4856))
- **Default model:** `gpt-5-mini` is now the default across `OpenAILLM`, `OpenAIStructuredLLM`, `AzureOpenAILLM`, `AzureOpenAIStructuredLLM`, and `LiteLLM` fallback ([#4829](https://github.com/mem0ai/mem0/pull/4829))
-
-**Breaking Changes:**
- **`add()` returns ADD-only events** — No more `"UPDATE"` or `"DELETE"` events. Memories accumulate; nothing is overwritten ([#4805](https://github.com/mem0ai/mem0/pull/4805))
- **`search()` default `threshold` is now `0.1`** — Pass `threshold=0.0` for previous behavior ([#4805](https://github.com/mem0ai/mem0/pull/4805))
- **`search()` `score` is now a combined multi-signal score** — The top-level `score` fuses semantic similarity, BM25 keyword match, and entity boost into one value. Absolute numbers shift versus the old raw cosine score; retune any hard thresholds against representative queries. Per-signal scores are not exposed on the response ([#4805](https://github.com/mem0ai/mem0/pull/4805), [#4836](https://github.com/mem0ai/mem0/pull/4836))
- **`search()` default `rerank` is now `False`** — Pass `rerank=True` for previous behavior ([#4805](https://github.com/mem0ai/mem0/pull/4805))
- **`top_k` default changed 100 → 20** in `Memory.get_all()` and `Memory.search()` (sync + async). Pass `top_k=100` explicitly to restore the old behavior ([#4843](https://github.com/mem0ai/mem0/pull/4843))
- **Entity ID validation:** `user_id` / `agent_id` / `run_id` are trimmed; empty-string and whitespace-only values now raise `ValueError` ([#4843](https://github.com/mem0ai/mem0/pull/4843))
- **Search params validation:** `threshold` must be a number in `[0, 1]`; `top_k` must be a non-negative integer — invalid inputs raise `ValueError` ([#4843](https://github.com/mem0ai/mem0/pull/4843))
- **`messages` in `Memory.add()` rejects invalid types:** Passing `None` or non-`(str | dict | list)` values raises `Mem0ValidationError` (`error_code="VALIDATION_003"`) ([#4843](https://github.com/mem0ai/mem0/pull/4843))
- **`qdrant-client>=1.12.0` required** — Upgrade from `>=1.9.1` ([#4805](https://github.com/mem0ai/mem0/pull/4805))
- **`org_id` and `project_id` removed** — Removed from `MemoryClient` constructor and all method signatures ([#4740](https://github.com/mem0ai/mem0/pull/4740))
- **Graph Memory Removed (OSS):** `mem0/memory/graph_memory.py`, `memgraph_memory.py`, `kuzu_memory.py`, `apache_age_memory.py`, and `mem0/graphs/` (Neo4j / Memgraph / Kuzu / Apache AGE / Neptune drivers) deleted — ~4,000 lines. Graph memory is no longer supported in the OSS SDK; graph drivers (neo4j, memgraph, kuzu, etc.) can be uninstalled. Use the Platform API for graph features. Remove `enable_graph` and `graph_store` from your config ([#4805](https://github.com/mem0ai/mem0/pull/4805))
- **`enable_graph` removed from Client SDK** — Graph memory is now a project-level setting on the Platform. Remove `enable_graph` from `MemoryClient.add()` / `search()` / `get_all()` / `update_project()` calls ([#4776](https://github.com/mem0ai/mem0/pull/4776))
- **`custom_fact_extraction_prompt` renamed to `custom_instructions`** — Update config and memory module references ([#4740](https://github.com/mem0ai/mem0/pull/4740))
- **Typed option classes** — Added Pydantic v2 typed classes: `AddMemoryOptions`, `SearchMemoryOptions`, `GetAllMemoryOptions`, `DeleteAllMemoryOptions`, `UpdateMemoryOptions`, `ProjectUpdateOptions` ([#4740](https://github.com/mem0ai/mem0/pull/4740))
-
-**Security:**
- **FAISS:** Prevent arbitrary code execution via pickle deserialization in `FAISS` vector store ([#4833](https://github.com/mem0ai/mem0/pull/4833))
-
-**Bug Fixes:**
- **V3 migration crashes:** Fixed crashes in the v3 migration path; entity linking on OSS is now functional across Qdrant and Milvus backends ([#4836](https://github.com/mem0ai/mem0/pull/4836))
- **Qdrant entity store:** Entity store now shares the existing Qdrant client when using embedded mode (`path=...`), eliminating RocksDB lock contention between the main and entity collections ([#4836](https://github.com/mem0ai/mem0/pull/4836))
- **Reranker:** Fixed incorrect use of SentenceTransformer for cross-encoder reranker models — switched to CrossEncoder API for proper scoring ([#4806](https://github.com/mem0ai/mem0/pull/4806))
- **S3 Vectors:** Handle `vector=None` in `update()` to prevent boto3 validation error when `event=NONE` ([#4594](https://github.com/mem0ai/mem0/pull/4594))
- **LLMs:** Made OpenAI `store` parameter opt-in to prevent leaking to non-OpenAI backends like Google Gemini ([#4757](https://github.com/mem0ai/mem0/pull/4757))
- **LLMs:** Forward `response_format` to Azure OpenAI API to prevent JSON parsing failures ([#4689](https://github.com/mem0ai/mem0/pull/4689))
- **Core:** Guard `temp_uuid_mapping` lookups against LLM-hallucinated IDs with safe `.get()` and warnings ([#4674](https://github.com/mem0ai/mem0/pull/4674))
- **Client:** Prevent `MemoryClient.feedback()` telemetry TypeError by merging feedback data into single payload ([#4795](https://github.com/mem0ai/mem0/pull/4795))
-
-**Improvements:**
- **Telemetry:** Sample OSS hot-path events at 10% via PostHog `before_send` hook to reduce event volume ([#4771](https://github.com/mem0ai/mem0/pull/4771))
-
-See the [OSS v1 to v2 migration guide](https://docs.mem0.ai/migration/oss-v1-to-v2) and [Platform migration guide](https://docs.mem0.ai/migration/platform-v2-to-v3) for upgrade instructions.
-
-</Update>
-
-<Update label="2026-04-06" description="v1.0.11">
-
-**New Features & Updates:**
- **SDK:** Added `multilingual` parameter to project update ([#4314](https://github.com/mem0ai/mem0/pull/4314))
-
-**Bug Fixes:**
- **LLMs:** Fixed Groq model configuration ([#4700](https://github.com/mem0ai/mem0/pull/4700))
- **Core:** Prevented thread and memory leaks from PostHog telemetry ([#4535](https://github.com/mem0ai/mem0/pull/4535))
- **Vector Stores:** Used `DatetimeRange` for datetime string values in Qdrant range filters ([#4659](https://github.com/mem0ai/mem0/pull/4659))
- **Configs:** Added missing `ConfigDict` to vector store configs (Elasticsearch, MongoDB, Neptune, OpenSearch, PGVector, Supabase, Valkey) ([#4656](https://github.com/mem0ai/mem0/pull/4656))
-
-</Update>
-
-<Update label="2026-04-01" description="v1.0.10">
-
-**New Features & Updates:**
- **LLMs:** Added MiniMax provider support for AWS Bedrock ([#4609](https://github.com/mem0ai/mem0/pull/4609))
-
-**Bug Fixes:**
- **Configs:** Migrated CassandraConfig and AzureMySQLConfig to pydantic v2 ConfigDict ([#4646](https://github.com/mem0ai/mem0/pull/4646))
- **LLMs:** Forward `response_format` to OpenAI-compatible API for DeepSeek ([#4635](https://github.com/mem0ai/mem0/pull/4635))
- **LLMs:** Forward `response_format` to OpenAI-compatible API for vLLM ([#4608](https://github.com/mem0ai/mem0/pull/4608))
- **Vector Stores:** Only list authorized collections when listing MongoDB collections ([#3888](https://github.com/mem0ai/mem0/pull/3888))
- **Core:** Reset graph database in `Memory.reset()` ([#4185](https://github.com/mem0ai/mem0/pull/4185))
- **Core:** Make `AsyncMemory.from_config` a regular classmethod ([#4183](https://github.com/mem0ai/mem0/pull/4183))
-
-</Update>
-
 <Update label="2026-03-28" description="v1.0.9">

 **New Features & Updates:**
@@ -893,73 +816,6 @@ See the [OSS v1 to v2 migration guide](https://docs.mem0.ai/migration/oss-v1-to-
 </Tab>

 <Tab title="TypeScript">
-<Update label="2026-04-14" description="v3.0.0">
-
-**Major Release** — TypeScript SDK with V3 memory pipeline, camelCase parameters, and cleaned-up API surface.
-
-**V3 Memory Pipeline (OSS):**
- **Single-Pass Extraction:** Additive extraction pipeline aligned with Python SDK — memories accumulate, no UPDATE/DELETE events ([#4805](https://github.com/mem0ai/mem0/pull/4805))
- **Entity Extraction & Linking:** New `entity_extraction.ts` module (720+ lines) with cross-memory relationship retrieval ([#4805](https://github.com/mem0ai/mem0/pull/4805))
- **Message Persistence:** SQLite-based message history via new `SQLiteManager.ts` with rolling window for LLM context ([#4805](https://github.com/mem0ai/mem0/pull/4805))
- **Batch Embeddings:** `embedBatch()` support in OpenAI and Azure embedding providers ([#4805](https://github.com/mem0ai/mem0/pull/4805))
- **Scoring & Lemmatization:** New `scoring.ts` and `lemmatization.ts` utilities for hybrid search ([#4805](https://github.com/mem0ai/mem0/pull/4805))
- **New Prompts:** `prompts/index.ts` (592+ lines) with additive extraction prompt aligned with Python SDK ([#4805](https://github.com/mem0ai/mem0/pull/4805))
- **V3 API Endpoints:** `MemoryClient.add()` now posts to `/v3/memories/add/`; `MemoryClient.getAll()` posts to `/v3/memories/` with paginated envelope `{ count, next, previous, results }` ([#4856](https://github.com/mem0ai/mem0/pull/4856))
- **Default model:** `gpt-5-mini` is now the default in `OpenAI`, `OpenAIStructured`, and `Azure` LLM providers ([#4829](https://github.com/mem0ai/mem0/pull/4829))
-
-**Breaking Changes:**
- **Graph Memory Removed (OSS):** `graph_memory.ts` (675 lines), `graphs/tools.ts` (267 lines), `graphs/utils.ts` (116 lines), `graphs/configs.ts` (30 lines) deleted. Graph memory is no longer supported in the OSS SDK — use Platform API for graph features ([#4805](https://github.com/mem0ai/mem0/pull/4805))
- **camelCase Parameters (Client SDK):** All user-facing parameters converted from snake_case to camelCase. Mapping is transparent at API boundary via `camelToSnakeKeys()` / `snakeToCamelKeys()` ([#4776](https://github.com/mem0ai/mem0/pull/4776))
-  ```typescript
-  // Before
-  client.add(messages, { user_id: "alice", top_k: 5 });
-  // After
-  client.add(messages, { userId: "alice", topK: 5 });
-  ```
- **Per-Method Option Types:** Replaced monolithic `MemoryOptions` with typed interfaces: `AddMemoryOptions`, `SearchMemoryOptions`, `GetAllMemoryOptions`, `DeleteAllMemoryOptions` ([#4740](https://github.com/mem0ai/mem0/pull/4740))
- **Removed Deprecated Parameters:** `org_id`, `project_id`, `api_version`, `output_format`, `async_mode`, `enable_graph`, `limit` removed from client method signatures. `ClientOptions` reduced to `{ apiKey, host }` only ([#4740](https://github.com/mem0ai/mem0/pull/4740))
- **`limit` renamed to `topK` (OSS):** Update all search calls ([#4740](https://github.com/mem0ai/mem0/pull/4740))
- **`topK` default changed 100 → 20** in `Memory.getAll()` and `Memory.search()`. Pass `topK: 100` explicitly to restore the old behavior ([#4843](https://github.com/mem0ai/mem0/pull/4843))
- **Entity ID validation:** `userId` / `agentId` / `runId` are trimmed; empty-string and whitespace-only values now throw ([#4843](https://github.com/mem0ai/mem0/pull/4843))
- **Search params validation:** `threshold` must be in `[0, 1]`; `topK` must be a non-negative integer — invalid inputs throw ([#4843](https://github.com/mem0ai/mem0/pull/4843))
- **`messages` in `Memory.add()` is required:** Passing `undefined` or `null` now throws ([#4843](https://github.com/mem0ai/mem0/pull/4843))
- **`customPrompt` renamed to `customInstructions` (OSS):** Update memory and vector store configurations ([#4740](https://github.com/mem0ai/mem0/pull/4740))
- **`enableGraph` removed (OSS):** Config option removed — graph memory no longer available in OSS ([#4776](https://github.com/mem0ai/mem0/pull/4776))
-
-**New Features:**
- **LLMs:** Added DeepSeek LLM provider with OpenAI-compatible integration using custom baseURL to `api.deepseek.com` ([#4613](https://github.com/mem0ai/mem0/pull/4613))
- **Entity store isolation:** `MemoryVectorStore` now uses a dedicated `_entities.db` file, preventing entity/memory store collisions ([#4829](https://github.com/mem0ai/mem0/pull/4829), [#4841](https://github.com/mem0ai/mem0/pull/4841))
- **Payload backward compatibility:** Legacy camelCase payload keys normalized to snake_case on read ([#4841](https://github.com/mem0ai/mem0/pull/4841))
-
-**Bug Fixes:**
- **V3 migration:** Fixed crashes in the OSS migration path; entity linking works end-to-end ([#4836](https://github.com/mem0ai/mem0/pull/4836))
- **PGVector init race:** `PGVector.initialize()` now memoises the in-flight init promise ([#4841](https://github.com/mem0ai/mem0/pull/4841))
- **Redis module detection:** Handles both node-redis v4+ and legacy `moduleList` response shapes ([#4841](https://github.com/mem0ai/mem0/pull/4841))
- **Config:** Fixed `ConfigManager.mergeConfig()` to only include `graphStore` when explicitly provided by user, preventing default Neo4j connection attempts ([#4776](https://github.com/mem0ai/mem0/pull/4776))
- **LLMs:** Config manager now falls back to `userConf.url` for `baseURL` — prevents custom LLM providers (Ollama, LMStudio) from silently connecting to OpenAI ([#4761](https://github.com/mem0ai/mem0/pull/4761))
-
-**Improvements:**
- **Telemetry:** Sample OSS hot-path events at 10% to reduce PostHog event volume ([#4771](https://github.com/mem0ai/mem0/pull/4771))
-
-See the [TypeScript SDK migration guide](https://docs.mem0.ai/migration/ts-v2-to-v3) for upgrade instructions.
-
-</Update>
-
-<Update label="2026-04-06" description="v2.4.6">
-
-**New Features & Updates:**
- **Client:** Added `multilingual` parameter to project update types ([#4314](https://github.com/mem0ai/mem0/pull/4314))
-
-</Update>
-
-<Update label="2026-04-01" description="v2.4.5">
-
-**Bug Fixes:**
- **OSS:** Replace `.single()` with `.maybeSingle()` in SupabaseDB.get() to handle missing rows ([#4599](https://github.com/mem0ai/mem0/pull/4599))
- **Embeddings:** Pass dimensions parameter to OpenAI embeddings API ([#4632](https://github.com/mem0ai/mem0/pull/4632))
- **OSS:** Extract JSON from chatty LLM responses in fact retrieval ([#4533](https://github.com/mem0ai/mem0/pull/4533))
-
-</Update>

 <Update label="2026-03-28" description="v2.4.4">

@@ -1260,152 +1116,352 @@ See the [TypeScript SDK migration guide](https://docs.mem0.ai/migration/ts-v2-to

 </Tab>

-<Tab title="CLI">
+<Tab title="Platform">

-<Update label="2026-04-11" description="Python v0.2.3 / Node v0.2.3">
+<Update label="2025-07-23" description="">

 **Bug Fixes:**
- **Telemetry:** Replaced shared `"anonymous-cli"` fallback with a persistent per-machine random hash (`cli-anon-<uuid>`), so anonymous CLI users are counted individually in PostHog instead of collapsing into one identity ([#4789](https://github.com/mem0ai/mem0/pull/4789))
- **Telemetry:** Added PostHog `$identify` event on first authenticated run to stitch pre-signup anonymous history onto the authenticated user profile ([#4789](https://github.com/mem0ai/mem0/pull/4789))
+- **Memory:** Fixed ADD functionality
+
+</Update>
+
+<Update label="2025-07-19" description="">
+
+**New Features:**
+- **UI:** Added Settings UI and latency display
+- **Performance:** Neo4j query optimization
+
+**Bug Fixes:**
+- **OpenMemory:** Fixed OMM raising unnecessary exceptions
+
+</Update>
+
+<Update label="2025-07-18" description="">

 **Improvements:**
- **API:** All API calls now include `source=CLI` in request bodies (POST/PUT) and query params (GET/DELETE) for server-side attribution ([#4789](https://github.com/mem0ai/mem0/pull/4789))
+- **UI:** Updated Event UI
+- **Performance:** Fixed N+1 query issue in semantic_search_v2 by optimizing MemorySerializer field selection
+
+**Bug Fixes:**
+- **Memory:** Fixed duplicate memory index sentry error

 </Update>

-<Update label="2026-04-06" description="Python v0.2.2 / Node v0.2.2">
+<Update label="2025-07-17" description="">

 **New Features:**
- **Telemetry:** Added PostHog telemetry and source tracking to both Python and Node CLIs ([#4699](https://github.com/mem0ai/mem0/pull/4699))
- **Validation:** API key validated upfront via `/v1/ping/` on startup — fail-fast with a helpful error instead of cryptic 401s ([#4701](https://github.com/mem0ai/mem0/pull/4701))
-
-**Bug Fixes:**
- **CD:** Fixed OIDC trusted publishing with `npx npm@latest` ([#4724](https://github.com/mem0ai/mem0/pull/4724))
- **CD:** Removed npm self-upgrade from CD workflows ([#4723](https://github.com/mem0ai/mem0/pull/4723))
-
-</Update>
-
-<Update label="2026-04-03" description="Python v0.2.1 / Node v0.2.1">
-
-**New Features:**
- **Docs:** Comprehensive README with installation, usage examples, and purple branding ([#4680](https://github.com/mem0ai/mem0/pull/4680))
-
-**Bug Fixes:**
- **npm:** Added `repository` field to Node packages for npm provenance ([#4671](https://github.com/mem0ai/mem0/pull/4671))
- **CD:** Added CD workflows for Node SDK packages with OIDC trusted publishing ([#4670](https://github.com/mem0ai/mem0/pull/4670))
-
-</Update>
-
-<Update label="2026-04-02" description="Python v0.2.0 / Node v0.1.1">
-
-**New Features:**
- **`event` commands:** `mem0 event list` shows recent background processing events in a table; `mem0 event status <id>` shows full detail including nested memory results ([#4649](https://github.com/mem0ai/mem0/pull/4649))
- **`--json` / `--agent` flag:** Root-level flag switches all command output to a structured JSON envelope for programmatic/agent consumption. Envelope format: `{"status", "command", "duration_ms", "scope", "count", "data"}` ([#4649](https://github.com/mem0ai/mem0/pull/4649))
- **Agent output sanitization:** Raw API responses projected to only relevant fields per command (e.g., `add` → `{id, memory, event}`, `search` → `{id, memory, score, created_at, categories}`) ([#4649](https://github.com/mem0ai/mem0/pull/4649))
- **Email login:** Added email verification code login to `mem0 init` ([#4623](https://github.com/mem0ai/mem0/pull/4623))
- **Brand update:** Updated color palette from purple to golden ([#4664](https://github.com/mem0ai/mem0/pull/4664))
- **CI/CD:** Added CI pipelines and CD workflows for both CLIs ([#4640](https://github.com/mem0ai/mem0/pull/4640), [#4653](https://github.com/mem0ai/mem0/pull/4653))
-
-**Bug Fixes:**
- **Node:** Fixed critical `MODULE_NOT_FOUND` crash on `status`, `import`, and all commands when installed globally — replaced runtime `createRequire` with build-time version injection ([#4636](https://github.com/mem0ai/mem0/pull/4636))
- **Node:** API errors now show full response detail instead of bare "Bad Request" ([#4636](https://github.com/mem0ai/mem0/pull/4636))
- **Python:** Fixed double error printing on all commands ([#4636](https://github.com/mem0ai/mem0/pull/4636))
- **`status` command:** Replaced heavyweight `/v1/entities/` check with dedicated `GET /v1/ping/` endpoint ([#4649](https://github.com/mem0ai/mem0/pull/4649))
- **`add` command:** Deduplicated PENDING results from API; changed misleading count message ([#4649](https://github.com/mem0ai/mem0/pull/4649))
- **`init` command:** Partial flags now work in non-TTY; warns before overwriting existing config; added `--force` flag ([#4649](https://github.com/mem0ai/mem0/pull/4649))
- **`delete` command:** Fixed entity delete via v2 API for all entity types ([#4649](https://github.com/mem0ai/mem0/pull/4649))
+- **UI:** New Settings Page
+- **Memory:** Duplicate memories entities support

 **Improvements:**
- Tables now show full UUIDs (was truncated to 8 chars, making `mem0 get <id>` fail) ([#4636](https://github.com/mem0ai/mem0/pull/4636))
- Search table includes Score column ([#4636](https://github.com/mem0ai/mem0/pull/4636))
- `config get api_key` short-form aliases added ([#4636](https://github.com/mem0ai/mem0/pull/4636))
- Client-side validation for `--expires`, `--page-size`, `--page`, `--top-k`, `--threshold`, and empty content ([#4636](https://github.com/mem0ai/mem0/pull/4636))
- `printInfo` / `printScope` moved to stderr to avoid contaminating JSON piping ([#4636](https://github.com/mem0ai/mem0/pull/4636))
+- **Performance:** Optimized semantic search and get_all APIs by eliminating N+1 queries

 </Update>

-<Update label="2026-03-26" description="Python v0.1.0 / Node v0.1.0">
+<Update label="2025-07-16" description="">

-**Initial Release — Official Mem0 CLI**
+**New Features:**
+- **Database:** Implemented read replica routing with enhanced logging and app-specific DB routing

-A full-featured command-line interface for Mem0, available in both Python and Node.js:
+**Improvements:**
+- **Performance:** Improved query performance in search v2 and get all v2 endpoints

- **Install:** `pip install mem0-cli` (Python) or `npm install -g @mem0/cli` (Node.js)
- **Full command suite:** `add`, `search`, `list`, `get`, `update`, `delete`, `import`, `config`, `init`, `status`, `entity`
- **Interactive setup:** `mem0 init` with API key entry and user ID configuration
- **Works everywhere:** Platform (Mem0 Cloud) and self-hosted OSS modes
- **Scriptable:** `-o json` flag for CI/CD pipelines and automation
- **Dual SDK:** Same commands, same experience across Python and Node.js
- **Shared spec:** Both implementations driven by a single `cli-spec.json` ensuring identical behavior ([#4575](https://github.com/mem0ai/mem0/pull/4575))
+**Bug Fixes:**
+- **API:** Fixed pagination for get all API
+
+</Update>
+
+<Update label="2025-07-12" description="">
+
+**Bug Fixes:**
+- **Graph:** Fixed social graph bugs and connection issues
+
+</Update>
+
+<Update label="2025-07-11" description="">
+
+**Improvements:**
+- **Rate Limiting:** New rate limit for V2 Search
+
+**Bug Fixes:**
+- **Slack:** Fixed Slack rate limit error with backend improvements
+
+</Update>
+
+<Update label="2025-07-10" description="">
+
+**Improvements:**
+- **Performance:** 
+  - Changed connection pooling time to 5 minutes
+  - Separated graph lambdas for better performance
+
+</Update>
+
+<Update label="2025-07-09" description="">
+
+**Improvements:**
+- **Graph:** Graph Optimizations V2 and memory improvements
+
+</Update>
+
+<Update label="2025-07-08" description="">
+
+**New Features:**
+- **Database:** Added read replica support for improved database performance
+- **UI:** Implemented UI changes for Users Page
+- **Feedback:** Enabled feedback functionality
+
+**Bug Fixes:**
+- **Serializer:** Fixed GET ALL Serializer
+
+</Update>
+
+<Update label="2025-07-05" description="">
+
+**New Features:**
+- **UI:** User Page Revamp and New Users Page
+
+</Update>
+
+<Update label="2025-07-04" description="">
+
+**New Features:**
+- **Users:** New Users Page implementation
+- **Tools:** Added script to backfill memory categories
+
+**Bug Fixes:**
+- **Filters:** Fixed Filters Get All functionality
+
+</Update>
+
+<Update label="2025-07-03" description="">
+
+**Improvements:**
+- **Graph:** Graph Memory optimization
+- **Memory:** Fixed exact memories and semantically similar memories retrieval
+
+</Update>
+
+<Update label="2025-07-02" description="">
+
+**Improvements:**
+- **Categorization:** Refactored categorization logic to utilize Gemini 2.5 Flash and improve message handling
+
+</Update>
+
+<Update label="2025-07-01" description="">
+
+**Bug Fixes:**
+- **Memory:** Fixed old_memory issue in Async memory addition lambda
+- **Events:** Fixed missing events
+
+</Update>
+
+<Update label="2025-06-30" description="">
+
+**Improvements:**
+- **Graph:** Improvements to graph memory and added user to LTM-STM
+
+</Update>
+
+<Update label="2025-06-28" description="">
+
+**New Features:**
+- **Graph:** Added support for SQS in graph memory addition
+- **Testing:** Added Locust load testing script and Grafana Dashboard
+
+</Update>
+
+<Update label="2025-06-27" description="">
+
+**Improvements:**
+- **Rate Limiting:** Updated rate limiting for ADD API to 1000/min
+- **Performance:** Improved Neo4j performance
+
+</Update>
+
+<Update label="2025-06-26" description="">
+
+**New Features:**
+- **Memory:** Edit Memory From Drawer functionality
+- **API:** Added Topic Suggestions API Endpoint
+
+</Update>
+
+<Update label="2025-06-25" description="">
+
+**New Features:**
+- **Group Chat:** Group-Chat v2 with Actor-Aware Memories
+- **Memory:** Editable Metadata in Memories
+- **UI:** Memory Actions Badges
+
+</Update>
+
+<Update label="2025-06-19" description="">
+
+**New Features:**
+- **Rate Limiting:** Implemented comprehensive rate limiting system
+
+**Improvements:**
+- **Performance:** Added performance indexes for memory stats query
+
+**Bug Fixes:**
+- **Search:** Fixed search events not respecting top-k parameter
+
+</Update>
+
+<Update label="2025-06-18" description="">
+
+**New Features:**
+- **Memory Management:** Implemented OpenAI Batch API for Memory Cleaning with fallback
+- **Playground:** Added Claude 4 support on Playground
+
+**Improvements:**
+- **Memory:** Added ability to update memory metadata
+
+</Update>
+
+<Update label="2025-06-17" description="">
+
+**New Features:**
+- **UI:** New Memories Page UI design
+
+</Update>
+
+<Update label="2025-06-16" description="">
+
+**Improvements:**
+- **Infrastructure:** Migrated to Application Load Balancer (ALB)
+
+</Update>
+
+<Update label="2025-06-13" description="">
+
+**Improvements:**
+- **Memory Management:** Enhanced Memory Management with Cosine Similarity Fallback
+
+</Update>
+
+<Update label="2025-06-11" description="">
+
+**New Features:**
+- **OMM:** Added OMM Script and UI functionality
+
+**Improvements:**
+- **API:** Added filters validation to semantic_search_v2 endpoint
+
+</Update>
+
+<Update label="2025-06-09" description="">
+
+**New Features:**
+- **Intercom:** Set Intercom events for ADD and SEARCH operations
+- **OpenMemory:** Added Posthog integration and feedback functionality
+- **MCP:** New JavaScript MCP Server with feedback support
+
+**Improvements:**
+- **Structured Data:** Enhanced structured data handling in memory management
+
+</Update>
+
+<Update label="2025-06-06" description="">
+
+**New Features:**
+- **OAuth:** Added Mem0 OAuth integration
+- **OMM:** Added OMM-Mem0 sync for deleted memories
+
+</Update>
+
+<Update label="2025-06-05" description="">
+
+**New Features:**
+- **Filters:** Implemented Wildcard Filters and refactored filter logic in V2 Views
+
+</Update>
+
+<Update label="2025-06-02" description="">
+
+**New Features:**
+- **OpenMemory Cloud:** Added OpenMemory Cloud support
+- **Structured Data:** Added 'structured_attributes' field to Memory model
+
+</Update>
+
+<Update label="2025-05-30" description="">
+
+**New Features:**
+- **Projects:** Added version and enable_graph to project views
+- **OpenMemory:** Added Postgres support for OpenMemory
+
+</Update>
+
+<Update label="2025-05-19" description="">
+
+**Bug Fixes:**
+- **Core:** Fixed unicode error in user_id, agent_id, run_id and app_id

 </Update>

 </Tab>

-<Tab title="Plugins">
+<Tab title="Vercel AI SDK">

-<Update label="2026-04-02" description="mem0-plugin v1.0.0">
-
-**Mem0 Plugin for Claude Code, Cursor, and Codex**
-
-The unified Mem0 plugin for AI development environments:
-
- **9 MCP memory tools:** `add_memory`, `search_memories`, `get_memories`, `get_memory`, `update_memory`, `delete_memory`, `delete_all_memories`, `delete_entities`, `list_entities` — all via `mcp.mem0.ai`
- **Lifecycle hooks:** Automatic memory capture at session start, context compaction, task completion, and session end
- **Cloud MCP server:** Managed endpoint replaces local MCP and Smithery setup
- **Streamable HTTP transport:** New MCP transport protocol for real-time streaming
- **Codex-specific skill:** Dedicated skill in `mem0-plugin/skills/mem0-codex` for Codex workflows
- **Supported editors:** Claude Code, Claude Cowork, Cursor, Codex
-
-</Update>
-
-<Update label="2025-12-26" description="Vercel AI SDK v2.0.5">
+<Update label="2025-12-26" description="v2.0.5">
 **Bug Fix:**
- Removed unnecessary dependencies to make the package lighter.
+- **Vercel AI SDK:** Removed unnecessary dependencies to make the package lighter.
 </Update>

-<Update label="2025-09-25" description="Vercel AI SDK v2.0.3 – v2.0.4">
-**New Features:**
- Added file support for multimodal capabilities with memory context (v2.0.3)
-
+<Update label="2025-09-25" description="v2.0.4">
 **Bug Fix:**
- Fixed version parameter to use V2 for addition (v2.0.4)
+- **Vercel AI SDK:** Fixed version parameter in the AI SDK to use V2 for addition.
 </Update>

-<Update label="2025-09-03" description="Vercel AI SDK v2.0.2">
+<Update label="2025-09-25" description="v2.0.3">
+**New Features:**
+- **Vercel AI SDK:** Added file support for multimodal capabilities with memory context
+</Update>
+
+<Update label="2025-09-03" description="v2.0.2">
 **Bug Fix:**
- Fixed streaming response in the AI SDK.
+- **Vercel AI SDK:** Fixed streaming response in the AI SDK.
 </Update>

-<Update label="2025-08-05" description="Vercel AI SDK v2.0.0 – v2.0.1">
+<Update label="2025-08-05" description="v2.0.1">
 **New Features:**
- Migration to AI SDK V5 (v2.0.0)
- Added `host` param to the config (v2.0.1)
+- **Vercel AI SDK:** Added a new param `host` to the config.
 </Update>

-<Update label="2025-06-15" description="Vercel AI SDK v1.0.6">
+<Update label="2025-08-05" description="v2.0.0">
 **New Features:**
- Added `filter_memories` param.
+- **Vercel AI SDK:** Migration to AI SDK V5.
 </Update>

-<Update label="2025-05-23" description="Vercel AI SDK v1.0.5">
+<Update label="2025-06-15" description="v1.0.6">
 **New Features:**
- Added support for Google provider.
+- **Vercel AI SDK:** Added param `filter_memories`.
 </Update>

-<Update label="2025-05-10" description="Vercel AI SDK v1.0.3 – v1.0.4">
+<Update label="2025-05-23" description="v1.0.5">
 **New Features:**
- Added support for `output_format` param (v1.0.4)
+- **Vercel AI SDK:** Added support for Google provider.
+</Update>

+<Update label="2025-05-10" description="v1.0.4">
+**New Features:**
+- **Vercel AI SDK:** Added support for new param `output_format`.
+</Update>
+
+<Update label="2025-05-08" description="v1.0.3">
 **Improvements:**
- Added graceful failure handling when services are down (v1.0.3)
+- **Vercel AI SDK:** Added support for graceful failure in cases services are down.
 </Update>

-<Update label="2025-05-01" description="Vercel AI SDK v1.0.1">
+<Update label="2025-05-01" description="v1.0.1">
 **New Features:**
- Added support for graph memories.
+- **Vercel AI SDK:** Added support for graph memories
 </Update>

 </Tab>

 </Tabs>
+
@@ -1,102 +0,0 @@
---
-title: "Highlights"
-description: "Major product launches, headline features, and milestones for Mem0."
-mode: "wide"
---
-
-<Update label="2026-04-14" description="Mem0 SDK v2.0.0 / v3.0.0">
-
-**New Memory Algorithm — State-of-the-Art Accuracy at 90% Lower Cost**
-
-Ground-up rewrite of the memory pipeline with 20+ point benchmark improvements:
-
- **LoCoMo:** 71.4 → **91.6** (+20) — multi-turn conversation recall
- **LongMemEval:** 67.8 → **93.4** (+26) — long-term memory across sessions
- **BEAM (1M tokens):** **64.1** — production-scale memory evaluation
- **Agent memories are first-class** — Previous algorithm: 46% on assistant recall. New: **100%**
- **Temporal reasoning works** — "Where did I live before SF?" Previous: 51%. New: **93%**
- **90% fewer tokens** — Under 7K tokens per retrieval vs 25K+ for full-context approaches
- **ADD-only extraction** — Memories accumulate; nothing is overwritten or deleted
- **Hybrid retrieval** — Semantic + BM25 keyword + entity boost, scored in parallel
- **Entity linking** — Entities extracted, embedded, and linked across memories
-
-Breaking changes: Graph memory removed from OSS, `search()` defaults changed, deprecated params removed. See [migration guide](/migration/oss-v2-to-v3).
-
-</Update>
-
-<Update label="2026-04-06" description="Mem0 Skill Graph">
-
-**Mem0 Skill Graph — In-Context Documentation for AI Agents**
-
-AI coding agents in Claude Code, Cursor, and Codex can now access Mem0 knowledge directly in their workflow — no doc searching required. Three interconnected skills launched:
-
- **mem0 Core Skill** — Complete Python and TypeScript SDK reference, REST API patterns, and integration guides for LangChain, CrewAI, Autogen, and more
- **mem0-cli Skill** — Terminal command reference, configuration walkthroughs, and CI/CD recipes
- **mem0-vercel-ai-sdk Skill** — Vercel AI SDK provider API, memory-augmented generation patterns, and multi-provider setup
-
-</Update>
-
-<Update label="2026-04-06" description="Mem0 CLI v0.2.2">
-
-**Official Mem0 CLI — Now on PyPI and npm**
-
-A full-featured command-line interface for Mem0, available in both Python and Node.js:
-
- **Install:** `pip install mem0-cli` or `npm install -g @mem0/cli`
- **Full command suite** — `add`, `search`, `list`, `get`, `update`, `delete`, `import`, `config`, `init`, `status`, `entity`, `event`
- **Interactive setup** — `mem0 init` with email verification or direct API key entry
- **Works everywhere** — Platform (Mem0 Cloud) and self-hosted OSS modes
- **Scriptable** — `--json` flag for CI/CD pipelines and automation
- **Dual SDK** — Same commands, same experience across Python and Node.js
-
-</Update>
-
-<Update label="2026-04-06" description="OpenClaw v1.0.4">
-
-**OpenClaw Plugin — Production-Ready**
-
-The OpenClaw Mem0 plugin went from initial release to production-ready in one week (v1.0.0 → v1.0.4):
-
- **Skills-based memory architecture** — New extraction pipeline with skill-loader, batched extraction, and domain-aware memory triage
- **Dream gate** — Automatic memory consolidation during idle periods for higher-quality long-term recall
- **Interactive CLI** — `openclaw mem0 init`, `status`, `config`, `import`, and `event` commands
- **Unified tool naming** — `memory_add` and `memory_delete` replace 4 legacy tools, matching the platform API
- **Security hardened** — Path traversal protection, pinned dependencies, 329 tests across 10 files
-
-</Update>
-
-<Update label="2026-04-02" description="Mem0 Plugin for AI Editors">
-
-**Mem0 Plugin for Claude Code, Cursor, and Codex**
-
-Launched a unified Mem0 plugin across three major AI development environments — Claude Code and Cursor first (March 25), then Codex (April 2):
-
- **9 MCP memory tools** — add, search, get, update, delete, bulk delete, entity management via `mcp.mem0.ai`
- **Lifecycle hooks** — Automatic memory capture at session start, context compaction, task completion, and session end
- **Cloud MCP server** — Managed endpoint replaces local MCP and Smithery setup
- **Streamable HTTP transport** — New MCP transport protocol for real-time streaming
- **Codex-specific skill** — Dedicated skill in `mem0-plugin/skills/mem0-codex` for Codex workflows
-
-</Update>
-
-<Update label="2026-03-21" description="New Providers">
-
-**Apache AGE, Turbopuffer, MiniMax, and pgvector for Node.js**
-
-Major expansion of the provider ecosystem:
-
- **Apache AGE** — New graph store support, bringing the total to 4 graph store backends (Neo4j, Memgraph, Kuzu, Apache AGE)
- **Turbopuffer** — New vector database provider for Python SDK
- **MiniMax** — New LLM provider with dedicated AWS Bedrock support
- **pgvector for Node.js** — PostgreSQL vector support added to the TypeScript OSS SDK
- **Reasoning models** — `reasoning_effort` parameter for OpenAI o1/o3-style models
-
-</Update>
-
-<Update label="2026-03-14" description="Mem0 Platform Skill">
-
-**Mem0 Platform Skill on skills.sh**
-
-First skill launch — a dedicated Mem0 skill providing platform API reference, quickstart patterns, and integration examples directly inside agent sessions. Available on [skills.sh](https://skills.sh) for any compatible AI coding agent.
-
-</Update>
@@ -1,199 +0,0 @@
---
-title: "OpenClaw"
-description: "Release notes for the OpenClaw plugin and agent harness."
-mode: "wide"
---
-
-<Update label="2026-04-11" description="v1.0.6">
-
-**Bug Fixes:**
- **Telemetry:** Replaced shared `"anonymous-openclaw"` fallback with a persistent per-machine random hash (`openclaw-anon-<uuid>`), so anonymous plugin users are counted individually in PostHog ([#4790](https://github.com/mem0ai/mem0/pull/4790))
- **Telemetry:** Added PostHog `$identify` event on first authenticated run to stitch anonymous history onto the authenticated profile ([#4790](https://github.com/mem0ai/mem0/pull/4790))
- **Telemetry:** Fixed event loss on short-lived CLI invocations — added `beforeExit` handler to flush queued events before the process exits ([#4790](https://github.com/mem0ai/mem0/pull/4790))
- **Telemetry:** Added lazy `/v1/ping/` email resolution so users who configure API key outside `mem0 init` show as their email in PostHog, not an md5 hash ([#4790](https://github.com/mem0ai/mem0/pull/4790))
- **Telemetry:** Unified CLI event prefix from `openclaw.<cmd>` to `openclaw.cli.<cmd>` on the needsSetup branch to match the authenticated branch ([#4790](https://github.com/mem0ai/mem0/pull/4790))
-
-**Improvements:**
- **API:** Added `source: "OPENCLAW"` to all provider calls (`add`, `search`, `getAll`) across tools, CLI commands, recall, and the OSS backend adapter ([#4790](https://github.com/mem0ai/mem0/pull/4790))
-
-</Update>
-
-<Update label="2026-04-07" description="v1.0.5">
-
-**Bug Fixes:**
- **Init interactive choice bug**: Fixed number selection in `openclaw mem0 init` — entering 1/2/3 now correctly selects the corresponding option (was broken by readline prefill concatenating with user input)
- **OSS pgvector crash** ([#4727](https://github.com/mem0ai/mem0/issues/4727)): Fixed "Client has already been connected" cascade when using pgvector in OSS mode. The warmup call swallowed errors leaving a half-initialized pg client; concurrent recall/capture then all hit `client.connect()` on the same client. Fix: let warmup errors propagate (so `initPromise` resets and retries with a fresh Memory + fresh pg client) and build fresh config objects per attempt instead of mutating shared state.
-
-**Removed:**
- **`orgId` / `projectId` config parameters**: Removed from config schema, CLI (`config show/get/set`), init display, and providers. The API key is project-scoped, so separate org/project IDs are unnecessary and could cause access errors if mismatched.
- **`enableGraph` config parameter**: Removed from all config surfaces, providers, backend, and tools. Graph memory is being deprecated — removing the flag avoids unnecessary exposure.
-
-</Update>
-
-<Update label="2026-04-04" description="v1.0.4">
-
-**New Features:**
- **Interactive init flow**: `openclaw mem0 init` with interactive menu (email verification or direct API key). Non-interactive modes: `--api-key`, `--email`, `--email --code`
- **`memory_add` tool**: Replaces `memory_store` — name now matches `mem0` CLI and platform API
- **`memory_delete` tool**: Unified delete — single ID, search-then-delete, bulk, entity cascade. Replaces `memory_forget` and `memory_delete_all`
- **CLI subcommands**: `openclaw mem0 init`, `openclaw mem0 status`, `openclaw mem0 config show`, `openclaw mem0 config set`
- **`import` CLI command**: Bulk-import memories from a JSON file with `--user-id` and `--agent-id` overrides
- **`event list` / `event status` CLI commands**: Monitor background processing events
- **`fs-safe.ts` module**: Isolated filesystem wrappers in a separate entry point
- **`backend/` module**: `PlatformBackend` with direct HTTP API access for CLI commands
- **Plugin manifest**: Added `contracts.tools`, `configSchema`, and `uiHints` to `openclaw.plugin.json`
- **Test suite**: 329 tests across 10 test files
-
-**Changes:**
- **Modular architecture**: Extracted tools into `tools/` directory (6 files) and CLI into `cli/commands.ts`
- **Code splitting**: tsup builds with `splitting: true` and two entry points
- **Skills updated**: All SKILL.md files reference new tool names (`memory_add`, `memory_delete`)
- **Auto-recall timeout**: Recall wrapped in 8-second `Promise.race`
- **Auto-capture fire-and-forget**: `provider.add()` runs in background via `.then()/.catch()`
- **Auto-capture minimum content gate**: Skips extraction when total user content is fewer than 50 chars
-
-**Removed:**
- `memory_store` tool — replaced by `memory_add`
- `memory_forget` tool — replaced by `memory_delete`
- `memory_delete_all` tool — merged into `memory_delete`
- `memory_history` tool and `history` CLI command — deprecated
-
-</Update>
-
-<Update label="2026-04-03" description="v1.0.3">
-
-**Bug Fixes:**
- **Security**: Added `safePath()` containment helper to `readSkillFile` and `readDomainOverlay` in `skill-loader.ts` — prevents directory traversal
- **Noise filter**: Reverted incorrect `After-Compaction` regex rename back to `Post-Compaction`
-
-**Changes:**
- **Supply-chain hardening**: Pinned `mem0ai` dependency to exact `2.3.0` (was `^2.3.0`)
-
-**Tests:**
- 12 new tests covering `safePath`, `readSkillFile`, `readDomainOverlay`, and `loadSkill` with traversal inputs
-
-</Update>
-
-<Update label="2026-04-02" description="v1.0.2">
-
-**Bug Fixes:**
- **Security**: Removed `resolveEnvVars()` and `resolveEnvVarsDeep()` from `config.ts` — plugin-side env resolution was redundant and triggered static analysis warnings ([#4676](https://github.com/mem0ai/mem0/pull/4676))
-
-</Update>
-
-<Update label="2026-04-02" description="v1.0.1">
-
-**New Features:**
- **CD workflow**: Added continuous deployment workflow with OIDC trusted publishing ([#4672](https://github.com/mem0ai/mem0/pull/4672))
- **Plugin configuration manifest**: Added `compat` and `build` metadata to `package.json` ([#4667](https://github.com/mem0ai/mem0/pull/4667))
- **LICENSE**: Added Apache-2.0 license file ([#4667](https://github.com/mem0ai/mem0/pull/4667))
-
-**Bug Fixes:**
- **Dream gate**: Fixed cheap-first ordering, session isolation, and verified completion ([#4666](https://github.com/mem0ai/mem0/pull/4666))
- **Graceful startup**: Plugin now starts gracefully when no API key is configured ([#4669](https://github.com/mem0ai/mem0/pull/4669))
-
-</Update>
-
-<Update label="2026-04-01" description="v1.0.0">
-
-**New Features:**
- **Skills-based memory architecture**: New skill-loader and skill-based extraction pipeline with batched extraction ([#4624](https://github.com/mem0ai/mem0/pull/4624))
- **Dream gate**: Memory consolidation and dream-cycle processing during idle periods
- **Enhanced recall**: New `recall.ts` module with improved recall logic and skill-aware retrieval
- **Memory triage skill**: Domain-aware memory triage with companion domain support and recall protocol
- **Memory dream skill**: Skill for memory consolidation during idle periods
- **Plugin configuration**: Added `openclaw.plugin.json` manifest and `scripts/configure.py` setup helper
-
-**Changes:**
- Extraction pipeline refactored to use skills-based architecture for more contextual and higher quality memory capture
-
-</Update>
-
-<Update label="2026-03-26" description="v0.4.1">
-
-**New Features:**
- **Improved extraction quality**: Enhanced noise filtering, deduplication, and better extraction instructions
-
-**Bug Fixes:**
- **Credential detection**: Improved detection of credentials, API keys, and secrets in extraction instructions (#4552)
- **Standalone timestamps**: Prevented extraction of standalone timestamps as memories (#4550)
-
-</Update>
-
-<Update label="2026-03-16" description="v0.4.0">
-
-**New Features:**
- **Non-interactive trigger filtering**: Skips recall and capture for `cron`, `heartbeat`, `automation`, and `schedule` triggers
- **Subagent hallucination prevention**: Detects ephemeral subagent sessions and routes recall to parent namespace
- **Dynamic recall thresholding**: Memories scoring less than 50% of top result are dropped
- **SQLite resilience**: Init error recovery with automatic retry for OSS mode
- **`disableHistory` config option**: New `oss.disableHistory` flag
- 78 unit tests covering filtering, isolation, trigger filtering, subagent detection, and SQLite resilience
-
-**Changes:**
- Auto-recall threshold raised from 0.5 to 0.6 for stricter precision
- Recall candidate pool increased to `topK * 2` for better filtering headroom
- Relaxed extraction instructions: related facts kept together to preserve context
-
-**Bug Fixes:**
- **Concurrent session race condition**: Lifecycle hooks now use `ctx.sessionKey` directly instead of a shared mutable variable
-
-</Update>
-
-<Update label="2026-03-12" description="v0.3.1">
-
-**New Features:**
- **Message filtering pipeline**: Multi-stage noise removal before extraction
- **Broad recall for new sessions**: Short or new-session prompts trigger secondary broad search
- **Client-side threshold filtering**: Safety net that drops low-relevance results
- **Temporal anchoring**: Extraction instructions now include current date
- 55 unit tests covering filtering and isolation helpers
-
-**Changes:**
- Extraction window expanded from last 10 to last 20 messages
- Rewritten custom extraction instructions for conciseness and deduplication
- Refactored monolithic `index.ts` (1772 lines) into 6 focused modules
-
-</Update>
-
-<Update label="2026-03-10" description="v0.3.0">
-
-**Bug Fixes:**
- Updated `mem0ai` dependency with sqlite3 to better-sqlite3 migration (#4270)
-
-</Update>
-
-<Update label="2026-03-09" description="v0.2.0">
-
-**New Features:**
- Per-agent memory isolation for multi-agent setups via `agentId`
- "Understanding userId" section in docs
-
-**Changes:**
- Updated config examples to use concrete `userId` values instead of placeholders
-
-**Bug Fixes:**
- Migrated platform search to Mem0 v2 API
-
-</Update>
-
-<Update label="2026-02-19" description="v0.1.2">
-
-**New Features:**
- Source field for openclaw memory entries
-
-**Bug Fixes:**
- Auto-recall injection and auto-capture message drop
-
-</Update>
-
-<Update label="2026-02-02" description="v0.1.0">
-
-**New Features:**
- Initial release of the OpenClaw Mem0 plugin
- Platform mode (Mem0 Cloud) and open-source mode support
- Auto-recall: inject relevant memories before each turn
- Auto-capture: store facts after each turn
- Configurable `topK`, `threshold`, and `apiVersion` options
-
-</Update>
@@ -1,290 +0,0 @@
---
-title: "Platform"
-description: "Release notes for the Mem0 hosted platform — backend, dashboard, billing, and infrastructure changes."
-mode: "wide"
---
-
-<Update label="2025-07-23" description="">
-
-**Bug Fixes:**
- **Memory:** Fixed ADD functionality
-
-</Update>
-
-<Update label="2025-07-19" description="">
-
-**New Features:**
- **UI:** Added Settings UI and latency display
- **Performance:** Neo4j query optimization
-
-**Bug Fixes:**
- **OpenMemory:** Fixed OMM raising unnecessary exceptions
-
-</Update>
-
-<Update label="2025-07-18" description="">
-
-**Improvements:**
- **UI:** Updated Event UI
- **Performance:** Fixed N+1 query issue in semantic_search_v2 by optimizing MemorySerializer field selection
-
-**Bug Fixes:**
- **Memory:** Fixed duplicate memory index sentry error
-
-</Update>
-
-<Update label="2025-07-17" description="">
-
-**New Features:**
- **UI:** New Settings Page
- **Memory:** Duplicate memories entities support
-
-**Improvements:**
- **Performance:** Optimized semantic search and get_all APIs by eliminating N+1 queries
-
-</Update>
-
-<Update label="2025-07-16" description="">
-
-**New Features:**
- **Database:** Implemented read replica routing with enhanced logging and app-specific DB routing
-
-**Improvements:**
- **Performance:** Improved query performance in search v2 and get all v2 endpoints
-
-**Bug Fixes:**
- **API:** Fixed pagination for get all API
-
-</Update>
-
-<Update label="2025-07-12" description="">
-
-**Bug Fixes:**
- **Graph:** Fixed social graph bugs and connection issues
-
-</Update>
-
-<Update label="2025-07-11" description="">
-
-**Improvements:**
- **Rate Limiting:** New rate limit for V2 Search
-
-**Bug Fixes:**
- **Slack:** Fixed Slack rate limit error with backend improvements
-
-</Update>
-
-<Update label="2025-07-10" description="">
-
-**Improvements:**
- **Performance:** 
-  - Changed connection pooling time to 5 minutes
-  - Separated graph lambdas for better performance
-
-</Update>
-
-<Update label="2025-07-09" description="">
-
-**Improvements:**
- **Graph:** Graph Optimizations V2 and memory improvements
-
-</Update>
-
-<Update label="2025-07-08" description="">
-
-**New Features:**
- **Database:** Added read replica support for improved database performance
- **UI:** Implemented UI changes for Users Page
- **Feedback:** Enabled feedback functionality
-
-**Bug Fixes:**
- **Serializer:** Fixed GET ALL Serializer
-
-</Update>
-
-<Update label="2025-07-05" description="">
-
-**New Features:**
- **UI:** User Page Revamp and New Users Page
-
-</Update>
-
-<Update label="2025-07-04" description="">
-
-**New Features:**
- **Users:** New Users Page implementation
- **Tools:** Added script to backfill memory categories
-
-**Bug Fixes:**
- **Filters:** Fixed Filters Get All functionality
-
-</Update>
-
-<Update label="2025-07-03" description="">
-
-**Improvements:**
- **Graph:** Graph Memory optimization
- **Memory:** Fixed exact memories and semantically similar memories retrieval
-
-</Update>
-
-<Update label="2025-07-02" description="">
-
-**Improvements:**
- **Categorization:** Refactored categorization logic to utilize Gemini 2.5 Flash and improve message handling
-
-</Update>
-
-<Update label="2025-07-01" description="">
-
-**Bug Fixes:**
- **Memory:** Fixed old_memory issue in Async memory addition lambda
- **Events:** Fixed missing events
-
-</Update>
-
-<Update label="2025-06-30" description="">
-
-**Improvements:**
- **Graph:** Improvements to graph memory and added user to LTM-STM
-
-</Update>
-
-<Update label="2025-06-28" description="">
-
-**New Features:**
- **Graph:** Added support for SQS in graph memory addition
- **Testing:** Added Locust load testing script and Grafana Dashboard
-
-</Update>
-
-<Update label="2025-06-27" description="">
-
-**Improvements:**
- **Rate Limiting:** Updated rate limiting for ADD API to 1000/min
- **Performance:** Improved Neo4j performance
-
-</Update>
-
-<Update label="2025-06-26" description="">
-
-**New Features:**
- **Memory:** Edit Memory From Drawer functionality
- **API:** Added Topic Suggestions API Endpoint
-
-</Update>
-
-<Update label="2025-06-25" description="">
-
-**New Features:**
- **Group Chat:** Group-Chat v2 with Actor-Aware Memories
- **Memory:** Editable Metadata in Memories
- **UI:** Memory Actions Badges
-
-</Update>
-
-<Update label="2025-06-19" description="">
-
-**New Features:**
- **Rate Limiting:** Implemented comprehensive rate limiting system
-
-**Improvements:**
- **Performance:** Added performance indexes for memory stats query
-
-**Bug Fixes:**
- **Search:** Fixed search events not respecting top-k parameter
-
-</Update>
-
-<Update label="2025-06-18" description="">
-
-**New Features:**
- **Memory Management:** Implemented OpenAI Batch API for Memory Cleaning with fallback
- **Playground:** Added Claude 4 support on Playground
-
-**Improvements:**
- **Memory:** Added ability to update memory metadata
-
-</Update>
-
-<Update label="2025-06-17" description="">
-
-**New Features:**
- **UI:** New Memories Page UI design
-
-</Update>
-
-<Update label="2025-06-16" description="">
-
-**Improvements:**
- **Infrastructure:** Migrated to Application Load Balancer (ALB)
-
-</Update>
-
-<Update label="2025-06-13" description="">
-
-**Improvements:**
- **Memory Management:** Enhanced Memory Management with Cosine Similarity Fallback
-
-</Update>
-
-<Update label="2025-06-11" description="">
-
-**New Features:**
- **OMM:** Added OMM Script and UI functionality
-
-**Improvements:**
- **API:** Added filters validation to semantic_search_v2 endpoint
-
-</Update>
-
-<Update label="2025-06-09" description="">
-
-**New Features:**
- **Intercom:** Set Intercom events for ADD and SEARCH operations
- **OpenMemory:** Added Posthog integration and feedback functionality
- **MCP:** New JavaScript MCP Server with feedback support
-
-**Improvements:**
- **Structured Data:** Enhanced structured data handling in memory management
-
-</Update>
-
-<Update label="2025-06-06" description="">
-
-**New Features:**
- **OAuth:** Added Mem0 OAuth integration
- **OMM:** Added OMM-Mem0 sync for deleted memories
-
-</Update>
-
-<Update label="2025-06-05" description="">
-
-**New Features:**
- **Filters:** Implemented Wildcard Filters and refactored filter logic in V2 Views
-
-</Update>
-
-<Update label="2025-06-02" description="">
-
-**New Features:**
- **OpenMemory Cloud:** Added OpenMemory Cloud support
- **Structured Data:** Added 'structured_attributes' field to Memory model
-
-</Update>
-
-<Update label="2025-05-30" description="">
-
-**New Features:**
- **Projects:** Added version and enable_graph to project views
- **OpenMemory:** Added Postgres support for OpenMemory
-
-</Update>
-
-<Update label="2025-05-19" description="">
-
-**Bug Fixes:**
- **Core:** Fixed unicode error in user_id, agent_id, run_id and app_id
-
-</Update>
-
@@ -24,7 +24,6 @@ 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
@@ -53,7 +52,6 @@ const config = {
        provider: "gemini",
        config: {
            model: "gemini-2.0-flash-001",
-            apiKey: process.env.GOOGLE_API_KEY || '',
            temperature: 0.1
        }
    }
@@ -21,7 +21,7 @@ os.environ["OPENAI_API_KEY"] = "your-api-key"

 # Initialize a LangChain model directly
 openai_model = ChatOpenAI(
-    model="gpt-5-mini",
+    model="gpt-4.1-nano-2025-04-14",
    temperature=0.2,
    max_tokens=2000
 )
@@ -16,7 +16,7 @@ config = {
    "llm": {
        "provider": "litellm",
        "config": {
-            "model": "gpt-5-mini",
+            "model": "gpt-4.1-nano-2025-04-14",
            "temperature": 0.2,
            "max_tokens": 2000,
        }
@@ -20,7 +20,7 @@ config = {
    "llm": {
        "provider": "openai",
        "config": {
-            "model": "gpt-5-mini",
+            "model": "gpt-4.1-nano-2025-04-14",
            "temperature": 0.2,
            "max_tokens": 2000,
        }
@@ -86,7 +86,7 @@ config = {
    "llm": {
        "provider": "openai_structured",
        "config": {
-            "model": "gpt-5-mini",
+            "model": "gpt-4.1-nano-2025-04-14",
            "temperature": 0.0,
        }
    }
@@ -91,7 +91,7 @@ config = {
    "llm": {
        "provider": "openai",
        "config": {
-            "model": "gpt-5-mini"
+            "model": "gpt-4.1-nano-2025-04-14"
        }
    },
    "reranker": {
@@ -189,7 +189,7 @@ for i, prompt in enumerate(prompts):
    config["reranker"]["config"]["scoring_prompt"] = prompt
    memory = Memory.from_config(config)

-    results = memory.search("test query", filters={"user_id": "test_user"})
+    results = memory.search("test query", user_id="test_user")
    print(f"Prompt {i+1} results: {results}")
 ```

@@ -35,7 +35,7 @@ config = {
    "llm": {
        "provider": "openai",
        "config": {
-            "model": "gpt-5-mini"
+            "model": "gpt-4.1-nano-2025-04-14"
        }
    },
    "reranker": {
@@ -95,7 +95,7 @@ messages = [
 memory.add(messages, user_id="bob")

 # Search with reranking
-results = memory.search("What is the user's profession?", filters={"user_id": "bob"})
+results = memory.search("What is the user's profession?", user_id="bob")

 for result in results['results']:
    print(f"Memory: {result['memory']}")
@@ -175,7 +175,7 @@ queries = [

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

@@ -111,7 +111,7 @@ messages = [
 memory.add(messages, user_id="david")

 # Search with LLM reranking
-results = memory.search("What programming topics is the user studying?", filters={"user_id": "david"})
+results = memory.search("What programming topics is the user studying?", user_id="david")

 for result in results['results']:
    print(f"Memory: {result['memory']}")
@@ -283,12 +283,12 @@ for result in results["results"]:
 def safe_llm_rerank_search(query, user_id, max_retries=3):
    for attempt in range(max_retries):
        try:
-            return m.search(query, filters={"user_id": user_id}, rerank=True)
+            return m.search(query, user_id=user_id, rerank=True)
        except Exception as e:
            print(f"Attempt {attempt + 1} failed: {e}")
            if attempt == max_retries - 1:
                # Fall back to vector search
-                return m.search(query, filters={"user_id": user_id}, rerank=False)
+                return m.search(query, user_id=user_id, rerank=False)

 # Use the safe function
 results = safe_llm_rerank_search("What are my preferences?", "alice")
@@ -376,19 +376,19 @@ class RobustLLMReranker:
        # Try primary LLM reranker
        for attempt in range(max_retries):
            try:
-                return self.primary.search(query, filters={"user_id": user_id}, rerank=True)
+                return self.primary.search(query, user_id=user_id, rerank=True)
            except Exception as e:
                print(f"Primary reranker attempt {attempt + 1} failed: {e}")

        # Try fallback reranker
        if self.fallback:
            try:
-                return self.fallback.search(query, filters={"user_id": user_id}, rerank=True)
+                return self.fallback.search(query, user_id=user_id, rerank=True)
            except Exception as e:
                print(f"Fallback reranker failed: {e}")

        # Final fallback: vector search only
-        return self.primary.search(query, filters={"user_id": user_id}, rerank=False)
+        return self.primary.search(query, user_id=user_id, rerank=False)

 # Usage
 primary_config = {
@@ -101,7 +101,7 @@ messages = [
 memory.add(messages, user_id="charlie")

 # Search with local reranking
-results = memory.search("What books does the user like?", filters={"user_id": "charlie"})
+results = memory.search("What books does the user like?", user_id="charlie")

 for result in results['results']:
    print(f"Memory: {result['memory']}")
@@ -86,7 +86,7 @@ messages = [
 memory.add(messages, user_id="alice")

 # Search with reranking
-results = memory.search("What Italian food does the user like?", filters={"user_id": "alice"})
+results = memory.search("What Italian food does the user like?", user_id="alice")

 for result in results['results']:
    print(f"Memory: {result['memory']}")
@@ -153,7 +153,7 @@ def measure_reranker_performance(config, queries, user_id):
    latencies = []
    for query in queries:
        start_time = time.time()
-        results = memory.search(query, filters={"user_id": user_id})
+        results = memory.search(query, user_id=user_id)
        latency = time.time() - start_time
        latencies.append(latency)

@@ -191,7 +191,7 @@ class CachedReranker:

    @lru_cache(maxsize=1000)
    def search_cached(self, query_hash, user_id):
-        return self.memory.search(query, filters={"user_id": user_id})
+        return self.memory.search(query, user_id=user_id)

    def search(self, query, user_id):
        query_hash = hashlib.md5(f"{query}_{user_id}".encode()).hexdigest()
@@ -15,7 +15,7 @@ Mem0 supports LangChain as a provider for vector store integration. LangChain pr
 ```python Python
 import os
 from mem0 import Memory
-from langchain_chroma import Chroma
+from langchain_community.vectorstores import Chroma
 from langchain_openai import OpenAIEmbeddings

 # Initialize a LangChain vector store
@@ -72,7 +72,7 @@ m.add(messages, user_id="alice", metadata={"category": "movies"})
 ### Search Memories

 ```python
-results = m.search("What kind of movies does Alice like?", filters={"user_id": "alice"})
+results = m.search("What kind of movies does Alice like?", user_id="alice")
 ```

 ### Features
@@ -36,7 +36,7 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})

 # Search memories
-results = m.search(query="sci-fi recommendations", filters={"user_id": "alice"})
+results = m.search(query="sci-fi recommendations", user_id="alice")
 ```

 ### Config
@@ -50,25 +50,4 @@ Here are the parameters available for configuring Valkey:
 | `hnsw_m` | Number of bi-directional links for HNSW | `16` |
 | `hnsw_ef_construction` | Size of dynamic candidate list for HNSW | `200` |
 | `hnsw_ef_runtime` | Size of dynamic candidate list for search | `10` |
-| `cluster_mode` | Enable cluster mode for Valkey cluster (CME) deployments | `false` |
 | `distance_metric` | Distance metric for vector similarity | `cosine` |
-
-## Cluster Mode
-
-To use Valkey with cluster mode enabled (CME), set `cluster_mode` to `true`:
-
-```python
-config = {
-    "vector_store": {
-        "provider": "valkey",
-        "config": {
-            "collection_name": "memories",
-            "valkey_url": "valkey://cluster-endpoint:6379",
-            "embedding_model_dims": 1536,
-            "cluster_mode": True
-        }
-    }
-}
-```
-
-When cluster mode is enabled, the connector uses `ValkeyCluster` instead of the standalone client, which handles `MOVED`/`ASK` redirections automatically. Search queries are coordinated across all shards by the valkey-search module's built-in coordinator. See the [valkey-search documentation](https://github.com/valkey-io/valkey-search) for details on cluster mode behavior.
@@ -60,7 +60,7 @@ class PersonalAITutor:
        """
        # Start a streaming response request to the AI
        response = self.client.responses.create(
-            model="gpt-5-mini",
+            model="gpt-4.1-nano-2025-04-14",
            instructions="You are a personal AI Tutor.",
            input=question,
            stream=True
@@ -81,7 +81,7 @@ class PersonalAITutor:
        :param user_id: Optional user ID to filter memories.
        :return: List of memories.
        """
-        return self.memory.get_all(filters={"user_id": user_id})
+        return self.memory.get_all(user_id=user_id)

 # Instantiate the PersonalAITutor
 ai_tutor = PersonalAITutor()
@@ -57,7 +57,7 @@ m = Memory.from_config(config)
 m.add("I'm visiting Paris", user_id="john")

 # Retrieve memories
-memories = m.get_all(filters={"user_id": "john"})
+memories = m.get_all(user_id="john")
 ```

 ## Key Points
@@ -47,7 +47,7 @@ ${memoriesStr}`;
  ];
  
  const response = await openaiClient.chat.completions.create({
-    model: "gpt-5-mini",
+    model: "gpt-4.1-nano-2025-04-14",
    messages: messages
  });
  
@@ -45,7 +45,7 @@ Before you begin, follow these steps to set up the demo application:
   OPENAI_API_KEY=your_openai_api_key
   MEM0_API_KEY=your_mem0_api_key
   ```
-   You can obtain your `MEM0_API_KEY` by signing up at <a href="https://app.mem0.ai/dashboard/api-keys" rel="nofollow">Mem0 API Dashboard</a>.
+   You can obtain your `MEM0_API_KEY` by signing up at [Mem0 API Dashboard](https://app.mem0.ai/dashboard/api-keys).

 5. Start the development server:
   ```bash
@@ -36,7 +36,7 @@ config = {
    "llm": {
        "provider": "openai",
        "config": {
-            "model": "gpt-5-mini",
+            "model": "gpt-4.1-nano-2025-04-14",
            "temperature": 0.1,
            "max_tokens": 2000,
        }
@@ -77,7 +77,7 @@ class PersonalTravelAssistant:

        # Generate response using Responses API
        response = self.client.responses.create(
-            model="gpt-5-mini",
+            model="gpt-4.1-nano-2025-04-14",
            input=prompt
        )

@@ -89,11 +89,11 @@ class PersonalTravelAssistant:
        return answer

    def get_memories(self, user_id):
-        memories = self.memory.get_all(filters={"user_id": user_id})
+        memories = self.memory.get_all(user_id=user_id)
        return [m['memory'] for m in memories['results']]

    def search_memories(self, query, user_id):
-        memories = self.memory.search(query, filters={"user_id": user_id})
+        memories = self.memory.search(query, user_id=user_id)
        return [m['memory'] for m in memories['results']]

 # Usage example
@@ -143,7 +143,7 @@ class PersonalTravelAssistant:

        # Generate response using gpt-4.1-nano
        response = self.client.chat.completions.create(
-            model="gpt-5-mini",
+            model="gpt-4.1-nano-2025-04-14"2025-04-14",
            messages=self.messages
        )
        answer = response.choices[0].message.content
@@ -126,15 +126,16 @@ async def search_memories(
    print(f"Finding memories related to: {query}")
    results = await mem0_client.search(
        query,
-        filters={"user_id": USER_ID},
-        top_k=5,
+        user_id=USER_ID,
+        limit=5,
        threshold=0.7,  # Higher threshold for more relevant results
+        
    )
-
+    
    # Format and return the results
    if not results.get('results', []):
        return "I don't have any relevant memories about this topic."
-
+    
    memories = [f"• {result['memory']}" for result in results.get('results', [])]
    return "Here's what I remember that might be relevant:\n" + "\n".join(memories)
 ```
@@ -160,7 +161,7 @@ def create_memory_voice_agent():
            Use the search_memories tool when you need context from past conversations or user asks you to recall something.
            """,
        ),
-        model="gpt-5-mini",
+        model="gpt-4.1-nano-2025-04-14",
        tools=[save_memories, search_memories],
    )
    
@@ -341,15 +342,16 @@ async def search_memories(
    print(f"Finding memories related to: {query}")
    results = await mem0_client.search(
        query,
-        filters={"user_id": USER_ID},
-        top_k=5,
+        user_id=USER_ID,
+        limit=5,
        threshold=0.7,  # Higher threshold for more relevant results
+        
    )
-
+    
    # Format and return the results
    if not results.get('results', []):
        return "I don't have any relevant memories about this topic."
-
+    
    memories = [f"• {result['memory']}" for result in results.get('results', [])]
    return "Here's what I remember that might be relevant:\n" + "\n".join(memories)

@@ -366,7 +368,7 @@ def create_memory_voice_agent():
            Use the search_memories tool when you need context from past conversations or user asks you to recall something.
            """,
        ),
-        model="gpt-5-mini",
+        model="gpt-4.1-nano-2025-04-14",
        tools=[save_memories, search_memories],
    )
    
@@ -62,7 +62,7 @@ mem0_client = MemoryClient(api_key="your-mem0-key")

 def chat(user_input, user_id):
    # Retrieve relevant memories
-    memories = mem0_client.search(user_input, filters={"user_id": user_id}, top_k=5)
+    memories = mem0_client.search(user_input, user_id=user_id, limit=5)
    context = "\\n".join(m["memory"] for m in memories["results"])

    # Call LLM with memory context
@@ -123,7 +123,7 @@ ollama_chat = OpenAI(base_url=f"{OLLAMA_URL}/v1", api_key="ollama")

 def chat(user_input, user_id):
    # Retrieve relevant memories
-    memories = memory.search(user_input, filters={"user_id": user_id}, top_k=5)
+    memories = memory.search(user_input, user_id=user_id, limit=5)
    context = "\n".join(m["memory"] for m in memories["results"])

    # Call LLM with memory context (Ollama via OpenAI-compatible API)
@@ -319,7 +319,7 @@ print([m["memory"] for m in memories["results"]])
  </Tab>
  <Tab title="Open Source">
 ```python
-memories = memory.get_all(filters={"user_id": "max"})
+memories = memory.get_all(user_id="max")
 print([m["memory"] for m in memories["results"]])
 # Output: ["Max wants to run marathon under 4 hours", "hey", "lol ok", "cool thanks", "gtg bye"]
 ```
@@ -397,7 +397,7 @@ print([m["memory"] for m in memories["results"]])
 chat("hey how's it going", user_id="max")
 chat("I prefer trail running over roads", user_id="max")

-memories = memory.get_all(filters={"user_id": "max"})
+memories = memory.get_all(user_id="max")
 print([m["memory"] for m in memories["results"]])
 # Output: ["Max wants to run marathon under 4 hours", "Max prefers trail running over roads"]
 ```
@@ -446,7 +446,7 @@ Retrieve agent style alongside user memories:
  <Tab title="Platform">
 ```python
 # Get coach personality
-agent_memories = mem0_client.search("coaching style", filters={"agent_id": "ray_coach"})
+agent_memories = mem0_client.search("coaching style", agent_id="ray_coach")
 # Output: ["Max wants direct, data-driven feedback. Skip motivational language."]

 # Store conversations with agent_id
@@ -459,7 +459,7 @@ mem0_client.add([
  <Tab title="Open Source">
 ```python
 # Get coach personality
-agent_memories = memory.search("coaching style", filters={"agent_id": "ray_coach"})
+agent_memories = memory.search("coaching style", agent_id="ray_coach")
 # Output: ["Max wants direct, data-driven feedback. Skip motivational language."]

 # Store conversations with agent_id
@@ -706,13 +706,13 @@ memory.add(
 <Tabs>
  <Tab title="Platform">
 ```python
-memories = mem0_client.search("training plan", filters={"user_id": "max"}, top_k=5)
+memories = mem0_client.search("training plan", user_id="max", limit=5)
 # Gets: marathon goal, trail preference, ankle injury (if still valid)
 ```
  </Tab>
  <Tab title="Open Source">
 ```python
-memories = memory.search("training plan", filters={"user_id": "max"}, top_k=5)
+memories = memory.search("training plan", user_id="max", limit=5)
 # Gets: marathon goal, trail preference, ankle injury (if still valid / not pruned)
 ```
  </Tab>
@@ -806,7 +806,7 @@ mem0_client.update(goal_memory["id"], "Max wants to run sub-3:45 marathon")
  <Tab title="Open Source">
 ```python
 # Find the old memory
-memories = memory.get_all(filters={"user_id": "max"})
+memories = memory.get_all(user_id="max")
 goal_memory = [m for m in memories["results"] if "sub-4" in m["memory"]][0]

 # Update it
@@ -38,7 +38,7 @@ client = MemoryClient(api_key="your-api-key")
 ```

 <Note>
-Replace `your-api-key` with your actual Mem0 API key from the <a href="https://app.mem0.ai" rel="nofollow">dashboard</a>. Without proper API authentication, memory operations will fail.
+Replace `your-api-key` with your actual Mem0 API key from the [dashboard](https://app.mem0.ai). Without proper API authentication, memory operations will fail.
 </Note>

 ---
@@ -17,7 +17,7 @@ from mem0 import MemoryClient
 client = MemoryClient(api_key="m0-...")
 ```

-Grab an API key from the <a href="https://app.mem0.ai/" rel="nofollow">Mem0 dashboard</a> to get started.
+Grab an API key from the <Link href="https://app.mem0.ai/">Mem0 dashboard</Link> to get started.

 ## Store and Retrieve Scoped Memories

@@ -20,7 +20,7 @@ client = MemoryClient(api_key="your-api-key")
 ```

 <Note>
-Your API key needs export permissions to download memory data. Check your project settings on the <a href="https://app.mem0.ai" rel="nofollow">dashboard</a> if export operations fail with authentication errors.
+Your API key needs export permissions to download memory data. Check your project settings on the [dashboard](https://app.mem0.ai) if export operations fail with authentication errors.
 </Note>

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

 <Note>
-Ensure you have your Mem0 API key from the <a href="https://app.mem0.ai" rel="nofollow">Mem0 Dashboard</a> and your Gemini API key from the [Google AI Studio](https://ai.studio/app/api-keys).
+Ensure you have your Mem0 API key from the [Mem0 Dashboard](https://app.mem0.ai) and your Gemini API key from the [Google AI Studio](https://ai.studio/app/api-keys).
 </Note>

 ## Gemini Memory Agent
@@ -41,7 +41,7 @@ Set up your environment variables:
 - `MEM0_API_KEY`: Your Mem0 Platform API key
 - `OPENAI_API_KEY`: Your OpenAI API key

-You can obtain your Mem0 Platform API key from the <a href="https://app.mem0.ai" rel="nofollow">Mem0 Platform</a>.
+You can obtain your Mem0 Platform API key from the [Mem0 Platform](https://app.mem0.ai).

 ## Complete Implementation

@@ -83,7 +83,7 @@ class MultiAgentLearningSystem:

    def __init__(self, student_id: str):
        self.student_id = student_id
-        self.llm = OpenAI(model="gpt-5-mini", temperature=0.2)
+        self.llm = OpenAI(model="gpt-4.1-nano-2025-04-14", temperature=0.2)

        # Memory context for this student
        self.memory_context = {"user_id": student_id, "app": "learning_assistant"}
@@ -357,7 +357,7 @@ Based on our previous session, I remember we covered Vision Language Models and
 ## Help & Resources

 - [LlamaIndex Agent Workflows](https://docs.llamaindex.ai/en/stable/use_cases/agents/)
- <a href="https://app.mem0.ai/" rel="nofollow">Mem0 Platform</a>
+- [Mem0 Platform](https://app.mem0.ai/)

 ---

@@ -22,10 +22,10 @@ import os
 from llama_index.llms.openai import OpenAI

 os.environ["OPENAI_API_KEY"] = "<your-openai-api-key>"
-llm = OpenAI(model="gpt-5-mini")
+llm = OpenAI(model="gpt-4.1-nano-2025-04-14")
 ```

-Initialize the Mem0 client. You can find your API key <a href="https://app.mem0.ai/dashboard/api-keys" rel="nofollow">here</a>. Read about Mem0 [Open Source](https://docs.mem0.ai/open-source/overview).
+Initialize the Mem0 client. You can find your API key [here](https://app.mem0.ai/dashboard/api-keys). Read about Mem0 [Open Source](https://docs.mem0.ai/open-source/overview).
 ```python
 os.environ["MEM0_API_KEY"] = "<your-mem0-api-key>"

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

 ## Resources

- [Mem0 Documentation](https://docs.mem0.ai/introduction)
- <a href="https://app.mem0.ai/dashboard" rel="nofollow">Mem0 Dashboard</a>
+- [Mem0 Documentation](https://docs.mem0.ai)
+- [Mem0 Dashboard](https://app.mem0.ai/dashboard)
 - [API Reference](https://docs.mem0.ai/api-reference)

 ---
--- a/Show More
+++ b/Show More