Log inSubmit server
Kawa Code logo

Kawa Code

Team-aware MCP memory for coding assistants, covering intents, decisions, relevant context, and live coordination around overlapping edits.

InstallRepositoryWebsite
Full README Compare alternatives Embed widget Claim this listing

Install Kawa Code

Pick your client, then add it in one click or paste the config.

STDIONode.js
~/Library/Application Support/Claude/claude_desktop_config.json
claude_desktop_config.json
{
  "mcpServers": {
    "kawa-code": {
      "command": "npx",
      "args": [
        "-y",
        "@kawacode/mcp"
      ]
    }
  }
}

Settings → Developer → Edit Config, merge this into mcpServers, then fully quit and reopen Claude Desktop.

Install not yet sandbox-tested— the server itself is confirmed live (we called its tools/list endpoint). The stdio install command is a separate, ongoing check.

Overview

Kawa Code MCP server connects MCP-compatible coding assistants to the Kawa Code desktop application through a thin stdio adapter. It tracks session-specific intents, records architectural decisions, retrieves task-relevant history, and surfaces overlapping team edits before commit. Use it after identifying the files involved so context retrieval can use the request and active files together. It is suited to teams running parallel AI or human-assisted development across sessions, branches, and machines.

Use cases

  • Resume an unfinished coding task with its recorded intent and decisions
  • Retrieve architecture context for the files involved in a request
  • Check whether teammates are editing overlapping files before changing code
  • Record and review the reasoning behind implementation choices
  • Bootstrap project memory from an existing git history

Key features

  • Session-scoped intent tracking
  • Relevance-based context retrieval
  • Decision history with rationale
  • Live overlap and conflict detection
  • Commit-to-intent linkage
  • Git history inference

Tools20

What Kawa Code lets your agent do. Expand a tool for its parameters.

Verified live~8.6k tokens of context

Security & health

What it can reach and how reliably it runs — from our own checks, not the maintainer’s claims.

ActiveLast checked 2d ago

Recent health check succeeded.

21/21 checks healthy over the last 90d

What it can do

From the 20 tools this server returned when we ran it.

Runs commands · 1Can delete or modify data · 2Handles credentials · 1Makes network requests · 2Read-only tools · 17
Network at startup3 connections
Files written at startupNone
Install scriptsNone
npm provenanceNot published
Package age229 days
Maintainers1

Observed 2026-11-02 in an isolated sandbox. A description of reach, not a security audit.

Supply-chain signal

No high-severity advisories surfaced by our automated scan.

Critical 0High 0Medium 0Low 0

Scanned 3d ago via OSV.dev · @kawacode/mcp (npm)

Adoption & maintenance

Factual signals from GitHub, npm, and our automated checks — not a rating.

npm downloads1kPackage downloads in the last 30 days.
Last commit6d agoMost recent push to the default branch.
Tools exposed20Callable tools this server registers over MCP.

How Kawa Code works

What Kawa Code does

Kawa Code MCP server gives AI coding assistants a shared memory and coordination layer for software repositories. It connects to the Kawa Code desktop app, which handles git operations, storage, and API communication. The server helps an assistant resume work, understand earlier decisions, associate commits with the intent behind them, and identify other sessions editing related code.

Its memory model separates intents from decisions. An intent describes the work unit currently being pursued in a session. Decisions preserve reasoning around forks, trade-offs, abandoned approaches, constraints, discoveries, and dependencies. Several sessions can hold active intents for the same repository without one session taking a lock over the others.

How it works

A typical coding workflow starts with check_active_intent, which reports the current session's focus before code changes. If no intent exists, the assistant confirms the work details with the user and creates one with create_and_activate_intent. After a short exploration identifies the relevant files, get_relevant_context retrieves matching intents and decisions rather than returning all recent activity.

The server also supports team coordination. File- and range-based queries can reveal work in progress, while conflict tools compare overlapping intents or live edits. Resolution context can expose a peer's overlapping code and related reasoning, and the arbiter tools can evaluate overlaps or apply a safe merge in an agent-owned worktree. Completion links the intent to a commit and captures code blocks after a successful commit.

For repositories without recorded history, infer_history can bootstrap intents and decisions from git history. It first supports an estimate-only run so the user can review token and cost information. The operation is asynchronous and can resume after interruption.

Setup and configuration

The runtime requires Node.js 18 or newer and the Kawa Code desktop app running locally. Install the package through an MCP client using npx -y @kawacode/mcp, or install it globally with npm and configure the kawacode-mcp command. A project-level .mcp.json using the stdio transport can be committed for team use.

Claude Code can add the server with its MCP command. Cursor can use a global installation and an entry in ~/.cursor/mcp.json. The server is also intended for the Kawa Code application, its IDE extensions, Claude Code, Cursor, and other MCP-compatible assistants.

History inference optionally accepts the user's Anthropic API key. The GitHub CLI adds richer pull-request, review, and issue data tiers; without it, those tiers are skipped.

Tools and capabilities

  • Retrieve relevant past intents and decisions using a request, active files, relevance threshold, and result caps.
  • Create, activate, resume, update, complete, and list repository intents.
  • Inspect decisions, expand a decision's rationale and consequences, and edit in-session decisions.
  • Find intents associated with files or line ranges and detect potential conflicts with other sessions.
  • Resolve or evaluate live code overlaps, including safe-tier application in an agent-owned worktree.
  • Bootstrap repository context from git history with an estimate and approval step.

Limitations and notes

The desktop application is required because the MCP package acts as an IPC adapter rather than owning git, storage, or API operations. Context retrieval is intended for a request whose relevant files have already been identified; vague early calls can produce weaker matches.

The retired pre-edit decision hook should not be newly configured. Live edit coordination is provided through the Stop-hook collision signal and related coordination tools. Agents sharing one checkout can overwrite one another without a git conflict being recorded, so parallel agents should use separate git worktrees.

Automatic overlap resolution writes only in an agent-owned worktree. On a human checkout, or when a peer holds the relevant file-set lock, the arbiter remains advisory. History inference can cost time and money, and rerunning it blindly is guarded when existing intents are present or when the repository is not on its default branch.

Read the full README View source on GitHub

Reviews

No reviews yet — be the first to share how it worked for you.

Frequently Asked Questions about Kawa Code

Kawa Code is an MCP server that connects AI coding assistants to the Kawa Code desktop app. Its main tools track and resume intents, retrieve relevant prior context, record decisions, inspect team work, and detect or help resolve overlapping code edits across repository sessions.

Install it through an MCP client with `npx -y @kawacode/mcp`, or install `@kawacode/mcp` globally and configure the `kawacode-mcp` command. Node.js 18 or newer and the Kawa Code desktop app must be available.

Yes, Kawa Code works with Cursor. Install the package globally with npm, then add a `kawacode-mcp` server entry to `~/.cursor/mcp.json`; the Kawa Code desktop app must also be running.

Kawa Code uses `get_relevant_context` with the user's request and, preferably, the active files identified during initial exploration. `maxIntents`, `maxDecisions`, and `minRelevance` shape the returned results, which include relevant intents and summary-level decisions.

Yes, Kawa Code detects potential conflicts between sessions and live overlapping edits. File and range queries, intent conflict detection, and collision-resolution tools help identify related work before commit; automatic safe-tier application is limited to agent-owned worktrees.

Related MCP servers

All in Knowledge & Memory All alternatives
Add a badge to your READMEShow it’s listed — live SVG, Markdown or HTML.

AllMCPs Directory Badge

Full Badge Customizer

Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.

Badge Style:
Live Dynamic SVG PreviewKawa Code AllMCPs Directory Badge
Markdown (GitHub README)
[![AllMCPs](https://allmcps.com/api/badge/kawa-code?style=directory)](https://allmcps.com/mcp/kawa-code)
HTML Embed
<a href="https://allmcps.com/mcp/kawa-code"><img src="https://allmcps.com/api/badge/kawa-code?style=directory" alt="Kawa Code on AllMCPs" /></a>