Kawa Code

What the Kawa Code MCP server does

The Kawa Code MCP server gives MCP-compatible coding assistants access to team-aware project memory. It helps an agent recover the context behind ongoing work instead of requiring the developer to restate architecture and constraints in every session. Memory is available across sessions, branches, and machines through the Kawa Code application.

The system records intent and architectural decisions, including trade-offs, abandoned approaches, and the reasoning behind a choice. It also associates commits with the intent that led to them, adding an explanation of why a change was made alongside the change itself.

Another use is coordination before integration. Kawa Code can indicate that a teammate is currently editing overlapping files or lines in a working copy, before either change reaches a commit. Relevance-based retrieval limits returned context to information related to the current task.

How it works

The package runs as an MCP server using standard input and output. It communicates with the Kawa Code desktop application through Huginn IPC over a Unix socket or named pipe. Kawa Code then performs Git operations, stores project information, and communicates with the Kawa API for team synchronization and encryption.

The Kawa Code MCP server is therefore not a standalone Git or storage service. The desktop application must be running, and the package depends on that application for its underlying operations. Code blocks are encrypted on the client before synchronization; the README states that Kawa cloud services cannot decrypt team code.

For code migrations or rewrites, decisions remain scoped to their repositories. A developer can recall relevant context from a source repository, inspect important decisions in detail, classify which findings apply to the new stack, and record the portable decisions in the target repository. This preserves useful constraints and negative knowledge without automatically copying every stack-specific workaround.

Setup and configuration

Node.js 18 or newer is required. Install the package through an MCP client with npx -y @kawacode/mcp, or install it globally with npm and configure the kawacode-mcp command. A project-level .mcp.json using a stdio server is recommended when the configuration should be committed for a team.

Claude Code can register the server with claude mcp add -s user kawa-intents -- npx -y @kawacode/mcp. Cursor can use a global installation and an entry in ~/.cursor/mcp.json. The Kawa Code desktop app must be running for the adapter to work.

An optional Claude Code PreToolUse hook runs before Edit or Write. It can surface prior reasoning associated with the files being changed and recommend proceeding silently, reviewing advisory context, or investigating an upstream decision. The check can be disabled with KAWA_PRE_EDIT_CHECK=off; local JSONL telemetry can be disabled with KAWA_PRE_EDIT_TELEMETRY=off.

Tools and capabilities

The Kawa Code MCP server supports capabilities for:

• Retrieving relevant project context with get_relevant_context.
• Expanding a selected decision with get_decision_detail.
• Recording decisions, including fork decisions that supersede earlier choices, with record_decision.
• Detecting active overlap in files or lines before commits.
• Associating commits with the intent behind them.
• Feeding decision history into repository migration and rewrite workflows.

History inference can use an Anthropic API key supplied as a parameter to inference tools. Installing GitHub CLI is optional and adds access to richer sources such as pull request descriptions, review comments, and issue discussions; without it, the README says some history tiers are skipped.

Limitations and notes

Kawa Code requires both Node.js 18 or newer and the Kawa Code desktop app. The MCP package itself is a thin adapter, so it does not independently provide the Git, storage, or cloud API functionality.

The pre-edit hook is specific to Claude Code configuration. A forced edit provides a one-off escape hatch and acknowledges surfaced decisions in a session cache; that cache resets when the Kawa Code daemon restarts. Telemetry is local, stored in daily-rotated files under ~/.kawa-code/logs, with defaults retaining 30 days and limiting total size to 100 MB.

The project is source-available under the Kawa Code Source Available License. The README does not identify an environment variable required to start the MCP server.