> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mem0.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Kimi Code

> Add persistent project memory to Kimi Code with automatic capture, automatic recall, Mem0 skills, and tools.

Kimi Code forgets project decisions between sessions. The Mem0 plugin captures completed work, recalls relevant context before a response, and gives Kimi explicit memory tools and skills.

<Info>Current plugin version: `0.3.1`.</Info>

## Prerequisites

1. A Mem0 Platform account and API key:
   * [Sign up at app.mem0.ai](https://app.mem0.ai?utm_source=oss\&utm_medium=integration-kimi)
   * [Get your API key](https://app.mem0.ai/dashboard/api-keys?utm_source=oss\&utm_medium=integration-kimi) (starts with `m0-`)

2. [Kimi Code](https://www.kimi.com/code) with plugin support.

3. Python 3.10+ and Git on your machine.

## Quick start

Export the key in the shell where you start Kimi Code:

```bash theme={null}
export MEM0_API_KEY='your-mem0-api-key'
kimi
```

Inside Kimi Code, install the native plugin bundle and reload the session:

```text theme={null}
/plugins install https://github.com/mem0ai/mem0/tree/main/integrations/kimi-plugin
/reload
```

Run `/plugins info mem0` to confirm that the plugin, MCP server, skills, hooks, and sidekick agent loaded.

## What you get

* **Automatic capture:** Kimi records completed exchanges locally and flushes durable project knowledge to Mem0 in the background.
* **Automatic recall:** Relevant memories are added before Kimi answers the first prompt in a session, if that prompt has at least 20 characters.
* **Explicit search:** Kimi can call `search_memories` when it needs a more specific answer.
* **Six memory skills:** Search, status, remember, forget, pause, and resume use the same memory behavior as the other Mem0 coding-agent plugins.
* **Project scoping:** Memories stay attached to the repository, with separate personal and shared project lanes.
* **Kimi sidekick:** A focused subagent can investigate or implement a bounded task in a separate context. Filesystem isolation depends on the environment Kimi provides.

Credentials are redacted before memory capture. If Mem0 is unavailable, hooks fail open so Kimi can continue its normal work.

## How it works

Kimi's native lifecycle events are translated into the shared Mem0 memory lifecycle:

| Kimi event                           | What Mem0 does                                                                       |
| ------------------------------------ | ------------------------------------------------------------------------------------ |
| `SessionStart`                       | Initializes the project session and recovers pending capture                         |
| `UserPromptSubmit`                   | Records each prompt; searches on the first prompt when it has at least 20 characters |
| `PostToolUse` / `PostToolUseFailure` | Records useful tool results and failures                                             |
| `Stop`                               | Captures the completed exchange                                                      |
| `PreCompact` / `SessionEnd`          | Flushes pending capture in the background                                            |
| `SubagentStart` / `SubagentStop`     | Passes parent context to the Mem0 sidekick and records its lifecycle                 |

## Verify the plugin

In one session, say:

```text theme={null}
Remember exactly: the release codename for this repository is ORCHID-9274.
```

Start a new Kimi session in the same repository and ask:

```text theme={null}
What is the release codename for this repository? Do not infer it from repository files.
```

Kimi should return `ORCHID-9274` from memory.

## Managing the plugin

```text theme={null}
/plugins list
/plugins info mem0
/plugins disable mem0
/plugins enable mem0
/plugins remove mem0
```

Run `/reload` or start a new session after enabling, disabling, or reinstalling the plugin.

## Search and capture

The local `search_memories` tool accepts `query`, `top_k`, `category`, `scope` (`repo`, `dir`, or `mine`), and optional `run_id` with every scope. Use a known session ID to recall memories saved in that session; omit it to search across sessions. See [search scopes](/integrations/claude-code#search-scope) for the shared Python search contract, including legacy repository memory compatibility.

Captured prompts and responses retain their full redacted text without a per-message character cutoff. Large extraction inputs are split across requests without dropping message text; recall output and tool-result previews have separate limits.

## Troubleshooting

| Problem                      | Fix                                                                                |
| ---------------------------- | ---------------------------------------------------------------------------------- |
| Missing API key              | Start Kimi from a shell where `MEM0_API_KEY` is exported.                          |
| Plugin changes do not appear | Run `/plugins reload`, then `/reload` or `/new`.                                   |
| MCP server is disabled       | Run `/plugins mcp enable mem0 mem0`, then `/reload`.                               |
| No memory in a later session | Wait a moment for the background flush, then ask Kimi to search memory explicitly. |
| Remove the plugin            | Run `/plugins remove mem0`.                                                        |

<CardGroup cols={2}>
  <Card title="Cursor" icon="arrow-pointer" href="/integrations/cursor">
    Add the same persistent project memory to Cursor
  </Card>

  <Card title="Claude Code" icon="https://mintcdn.com/mem0/QK-8_hblyHgAr7vt/images/provider-icons/anthropic.svg?fit=max&auto=format&n=QK-8_hblyHgAr7vt&q=85&s=d2a2af9f60f53e9f21d741fe237af0f5" href="/integrations/claude-code" width="16" height="16" data-path="images/provider-icons/anthropic.svg">
    Use Mem0 with Claude Code and its isolated sidekick
  </Card>
</CardGroup>

<Snippet file="star-on-github.mdx" />