Kimi Cli Memory Options

Best default (validated)     →  agentmemory (rohitg00)
                                MCP stdio, 51 tools, local iii-engine + embeddings, REST + viewer
                                Officially supports Claude Code, Cursor, Gemini CLI, OpenCode,
                                Codex CLI, Hermes, OpenClaw, pi. Kimi CLI not on official list,
                                but standard MCP stdio block should work.

Best minimal local           →  ai-memory-mcp (alphaonedev)
                                Rust binary, single SQLite + FTS5, 97.8% R@5 on LongMemEval,
                                26 MCP tools, WAL mode, 79% smaller TOON output, no API cost.

Best Kimi-native             →  kimi-mneme (claimed by source drafts) — UNVERIFIED
                                ⚠️ Could not be located on GitHub or PyPI in May 2026.
                                Do not include in install plan until existence confirmed.

Best minimal Python          →  rekal (janbjorge)
                                Python 3.11+, single SQLite + FTS5 + sqlite-vec (384-dim),
                                16 MCP tools, simple stdio, primary target Codex CLI / OpenCode.

Best MCP graph route         →  mem0-mcp-selfhosted (elvismdev)
                                Qdrant + optional Neo4j + Ollama, ~11 tools, fully offline.

Best multi-agent             →  HeurChain
                                Confirmed Kimi CLI read/write via MCP SSE in source drafts;
                                Redis + vault, ACT-R decay, BM25 only.

Best temporal reasoning      →  Graphiti (Zep)
                                Neo4j/FalkorDB, fact validity windows, NER pipeline.
                                Operationally heavy; specialized use case.

Avoid                        →  MemNexus, Mem0 Cloud, Zep Cloud (data leaves machine)
                                Letta, Honcho (replace the agent rather than extend it)
                                Raw vector DBs without memory logic (RAG poisoning over time)
                                SSE-only servers for new setups (SSE deprecated in MCP spec March 2025)
                                kimi-memory-mcp (SARPixelPioneer) — AgentSeal 75/100, DeepSeek required

# Terminal 1 — start the server (background or supervisord)
npx @agentmemory/agentmemory

# Verify
curl http://localhost:3111/agentmemory/health
# Viewer
open http://localhost:3113

// ~/.kimi/mcp.json
{
  "mcpServers": {
    "agentmemory": {
      "command": "npx",
      "args": ["-y", "@agentmemory/mcp"],
      "env": {
        "AGENTMEMORY_URL": "http://localhost:3111",
        "AGENTMEMORY_FORCE_PROXY": "1",
        "AGENTMEMORY_TOOLS": "all",
      },
    },
  },
}

# macOS / Linux
curl -fsSL https://raw.githubusercontent.com/alphaonedev/ai-memory-mcp/main/install.sh | sh

# Then add to ~/.kimi/mcp.json:

{
  "mcpServers": {
    "ai-memory": {
      "command": "ai-memory",
      "args": ["mcp"],
    },
  },
}

uv tool install rekal
# or: pip install rekal

// ~/.kimi/mcp.json
{
  "mcpServers": {
    "rekal": {
      "command": "rekal",
      "env": { "REKAL_PROJECT": "kimi-default" },
    },
  },
}

Call memory_build_context with your current task before exploring the codebase.

docker run -d -p 6333:6333 --name qdrant qdrant/qdrant
docker run -d -p 7474:7474 -p 7687:7687 neo4j        # optional, for graph
ollama pull qwen3:14b && ollama pull bge-m3

kimi mcp add --transport stdio mem0 \
  --env MEM0_PROVIDER=ollama \
  --env MEM0_LLM_MODEL=qwen3:14b \
  --env MEM0_USER_ID=artur \
  -- uvx --from git+https://github.com/elvismdev/mem0-mcp-selfhosted.git mem0-mcp-selfhosted

git clone <heurchain-repo> && cd heurchain/docker
cp .env.example .env
docker compose -f docker-compose.standalone.yml up -d --build
kimi mcp add --transport http heurchain http://localhost/sse

npm install -g @mnemo-mcp/cli
mnemo init

npm install -g @hbarefoot/engram
kimi mcp add engram -- engram start --mcp-only

pip install mcp-memory-service
# or: uv pip install mcp-memory-service

{
  "mcpServers": {
    "memory": {
      "command": "memory",
      "args": ["server"],
    },
  },
}

git clone https://github.com/mem0ai/mem0.git ~/mem0
cd ~/mem0/openmemory
echo "EMBEDDING_PROVIDER=ollama" >> .env
echo "OLLAMA_BASE_URL=http://localhost:11434" >> .env
docker-compose up -d
kimi mcp add --transport http openmemory http://localhost:8765/mcp

docker run -p 8100:8100 \
  -e OPENAI_API_KEY=sk-... \
  -e GRAPH_DB_URI=bolt://localhost:7687 \
  zepai/knowledge-graph-mcp

export MEMORY_FILE_PATH="$HOME/.kimi/knowledge-graph.jsonl"
kimi mcp add --transport stdio memory -- npx -y @modelcontextprotocol/server-memory

Kimi CLI
  └── MCP stdio: agentmemory OR ai-memory-mcp OR rekal
        └── Local storage (iii engine / SQLite)

# Option A: agentmemory
npx @agentmemory/agentmemory &
# Add JSON block to ~/.kimi/mcp.json (see section 1)

# Option B: ai-memory-mcp (Rust binary)
curl -fsSL https://raw.githubusercontent.com/alphaonedev/ai-memory-mcp/main/install.sh | sh
# Add JSON block to ~/.kimi/mcp.json (see section 2)

# Option C: rekal
uv tool install rekal
# Add JSON block to ~/.kimi/mcp.json (see section 3)

Kimi CLI
  └── MCP stdio: mcp-memory-service (doobidoo)
        └── SQLite-vec (hybrid storage)
        └── Local dashboard

uv pip install mcp-memory-service
# Configure ~/.kimi/mcp.json with `command = "memory"`

Kimi CLI + Claude Code + OpenClaw + CI/CD bots
  └── MCP SSE: HeurChain
        └── Docker Compose stack (Redis + nginx + vault)

git clone <heurchain-repo> && cd heurchain/docker
cp .env.example .env
docker compose -f docker-compose.standalone.yml up -d --build
kimi mcp add --transport http heurchain http://localhost/sse

Kimi CLI
  └── MCP stdio: mem0-mcp-selfhosted
        ├── Qdrant (vectors)
        ├── Neo4j (knowledge graph)
        └── Ollama (embeddings + LLM)

docker run -d -p 6333:6333 qdrant/qdrant
docker run -d -p 7687:7687 neo4j
ollama pull qwen3:14b && ollama pull bge-m3
kimi mcp add --transport stdio mem0 \
  --env MEM0_PROVIDER=ollama \
  --env MEM0_USER_ID=artur \
  -- uvx --from git+https://github.com/elvismdev/mem0-mcp-selfhosted.git mem0-mcp-selfhosted

Stable project rules      →  AGENTS.md  (project root; global ~/.kimi/AGENTS.md not yet implemented)
Session-level capture     →  SessionStart / PostToolUse hooks → MCP write
On-demand semantic recall →  ai-memory-mcp / agentmemory / rekal (MCP tools)
Knowledge graph (opt-in)  →  mem0-mcp-selfhosted or Graphiti
Codebase index (opt-in)   →  Qdrant + SKILL.md workflow

{
  "id": "uuid",
  "type": "decision",
  "project": "repo-name",
  "repo_root": "/path/to/repo",
  "branch": "main",
  "scope": "backend",
  "title": "Use Alembic for schema changes",
  "content": "Use Alembic migrations instead of ad-hoc SQL files.",
  "source": "kimi-session",
  "confidence": "high",
  "status": "active",
  "superseded_by": null,
  "created_at": "2026-05-15T00:00:00Z",
  "updated_at": "2026-05-15T00:00:00Z",
  "tags": ["database", "migration"]
}

# 1. Verify Kimi CLI feature surface
kimi --version
kimi mcp list
kimi plugin list

# 2. Add stable project memory
# Create AGENTS.md in project root (use /init to auto-generate the skeleton)

# 3. Install one MCP memory server
# Recommended default — ai-memory-mcp (Rust, minimal, validated)
curl -fsSL https://raw.githubusercontent.com/alphaonedev/ai-memory-mcp/main/install.sh | sh
# Add the JSON block from section 2 to ~/.kimi/mcp.json

# 4. Verify memory tools are visible
kimi mcp list
# (Inside Kimi: try memory_save / memory_recall via tool surface)

# 5. (Optional) Add SessionStart hook for explicit memory injection
# ~/.kimi/config.toml:
#   [[hooks]]
#   event = "SessionStart"
#   command = "~/.kimi/hooks/memory-inject.sh"

# 6. (Optional) Evaluate graph memory if semantic search proves insufficient
docker run -d -p 6333:6333 qdrant/qdrant
ollama pull bge-m3
# Add mem0-mcp-selfhosted to ~/.kimi/mcp.json (Blueprint D)

Install ai-memory-mcp first.
  → Rust binary, single SQLite + WAL, 26 MCP tools, 6-factor scoring, TOON output
  → Zero API keys, fully local, benchmarked recall, ~5 minutes from zero to working

Install agentmemory instead if you want maximum tool surface and cross-agent sharing.
  → 51 MCP tools, REST + viewer, local iii-engine + embeddings
  → Set AGENTMEMORY_FORCE_PROXY=1 to avoid the standalone-vs-server split-store bug

Install rekal if you want the absolute simplest Python option.
  → Single SQLite, FTS5 + sqlite-vec, 16 tools, `~/.rekal/memory.db`

Add AGENTS.md per project for stable conventions.

Do not install kimi-mneme until existence and maintenance are confirmed in person.

Install mem0-mcp-selfhosted only when knowledge graphs and entity linking actually matter.
  → Qdrant + Neo4j + Ollama, fully offline, 3-service stack

Use HeurChain only when running multiple agents simultaneously.
  → Confirmed Kimi read/write via SSE; Docker, 4 containers; BM25 only

Use Graphiti only for temporal reasoning on long-lived projects.
  → Fact validity windows; Neo4j + NER pipeline; significant operational overhead

Avoid MemNexus, Mem0 Cloud, Zep Cloud (data leaves machine).
Avoid Letta and Honcho (they replace the agent rather than extend it).
Avoid raw vector DBs without memory logic (RAG poisoning is the natural end state).

Start simple. Add complexity only when the simple setup proves insufficient.