Skip to main content
Glama

Kimi MCP Server

License: MIT

MCP server (stdio) that bridges Claude / Cursor / any MCP client to Moonshot AI's Kimi Code CLI.

Architecture mirrors @trishchuk/codex-mcp-tool — same patterns, adapted to Kimi's flag surface (--print, --quiet, -r, --continue, --add-dir, --mcp-config-file, --config).

Why

Kimi K2.6 (April 2026) is a 1T-parameter MoE open-weight model with native agent-swarm orchestration, 262k context, and SWE-Bench Pro on par with GPT-5.5. Kimi Code CLI is the reference agent harness. This server lets MCP-aware editors call Kimi as a sub-agent without leaving their primary interface.

Related MCP server: mcacp

Install

npm install -g @trishchuk/kimi-mcp-server

You also need Kimi Code CLI:

curl -LsSf https://code.kimi.com/install.sh | bash
# OR
uv tool install --python 3.13 kimi-cli

Then run kimi once and use /login to authenticate via the Kimi Code platform — or set MOONSHOT_API_KEY.

Configure (Claude Desktop / Cursor / Claude Code)

Minimal — working directory is auto-detected from PWD / INIT_CWD / process.cwd(), just like codex-mcp-tool:

{
  "mcpServers": {
    "kimi": {
      "command": "kimi-mcp"
    }
  }
}

Pin a specific project root only if your client launches the server from somewhere unrelated:

{
  "mcpServers": {
    "kimi": {
      "command": "kimi-mcp",
      "env": { "KIMI_MCP_CWD": "/absolute/path/to/your/project" }
    }
  }
}

You can also override per call via the workingDir argument on ask-kimi, or let the server infer it from @path/to/file references in the prompt — same priority chain as codex-mcp-tool: workingDir arg → KIMI_MCP_CWD → PWD → INIT_CWD → @path inference → process.cwd().

Tools

Tool

What it does

ask-kimi

Main entry — file analysis (@path), session resume, MCP passthrough

brainstorm

Structured ideation (divergent / convergent / SCAMPER / design-thinking / lateral / auto)

batch-kimi

Sequential or parallel atomic tasks with priority, stop-on-error, structured report

review-changes

Code review of working tree / branch diff / specific commit (collects git diff and prompts Kimi)

list-sessions

List, delete, or clear active conversation sessions

health

Diagnose Kimi CLI installation, auth, and session state

ping / Help / version

Smoke tests + help passthrough

ask-kimi highlights

  • prompt — supports @path/to/file to drop file context (Kimi reads via working dir).

  • model — overrides default_model at runtime via --config. Known: kimi-for-coding, kimi-k2-6, kimi-k2-thinking-turbo, kimi-k2-5, kimi-latest.

  • thinking — toggles thinking mode (writes default_thinking into runtime config).

  • outputFormat — text (default) or stream-json (JSONL of assistant + tool messages, parsed transparently).

  • responseMode — clean (default; final assistant text only) or full (tool calls + stderr log + final).

  • sessionId — workspace-isolated session ID (md5 of repo:head:path). The server tracks the native Kimi session ID returned by the CLI and replays it via kimi -r <id>.

  • continueLatest — sets --continue (resume the most recent session in the cwd).

  • mcpConfigFile — passes --mcp-config-file so Kimi can talk to other MCP servers from inside this process.

  • addDirs — repeats --add-dir for multi-root projects.

  • yolo / afk — approval shortcuts (print mode auto-approves anyway, but useful for documentation/logging).

CLI compatibility

Feature

Kimi CLI

Print / non-interactive

--print (required for MCP); --quiet = --print --output-format text --final-message-only

JSON streaming

--output-format=stream-json, --input-format=stream-json

Sessions

--continue, --session <id>, -r <id>

Configuration

--config-file <path>, --config '<json/toml>'

Workspace

spawn cwd + --add-dir <path> (no --cd flag)

MCP passthrough

--mcp-config-file or kimi mcp add

Exit codes

0 ok, 1 fatal, 75 retryable transient

Environment

Var

Default

Purpose

KIMI_MCP_CWD

—

Override working directory for every tool call

KIMI_SESSION_TTL_MS

86400000 (24h)

Session expiration

KIMI_MAX_SESSIONS

50

Max concurrent sessions

MOONSHOT_API_KEY

—

Forwarded to Kimi CLI for unattended auth

Development

npm install
npm run build       # tsc → dist/
npm run lint        # tsc --noEmit
node dist/index.js  # smoke run on stdio

License

MIT — Taras Trishchuk

Available Tools

14 tools
ask-kimiB
Destructive

Execute Kimi Code CLI with file analysis (@syntax), session resume, MCP passthrough, and safety controls.

Inputs: prompt (required), cd, afk, plan, +23 more.

batch-kimiA
Destructive

Delegate multiple atomic tasks to Kimi for batch processing. Ideal for repetitive operations, mass refactoring, and automated transformations.

Inputs: tasks (required), yolo, model, timeout, +4 more. Returns: total, failed, results, skipped, +1 more

bg-kimiA
Destructive

Run Kimi CLI as a detached background task. Subactions: start (returns taskId), status, tail (log output), stop, remove, list. Use for long-running autonomous work — the MCP call returns immediately and you poll status later.

Inputs: action (required), cd, plan, yolo, +15 more.

brainstormA

Generate creative ideas using structured frameworks with domain context and feasibility analysis.

Inputs: prompt (required), cd, afk, yolo, +8 more.

delegate-kimiA
Destructive

Delegate an implementation task to Kimi in an isolated git worktree. Kimi runs autonomously (--yolo) on a fresh branch, optionally looping against a test command. Returns a taskId; later 'collect' to grab the diff. Safe: changes are sandboxed, caller reviews & applies.

Inputs: task, model, action, taskId, +7 more.

digest-kimiA
Read-only

Ingest many files at once and answer a focused question. Uses Kimi's 262K context to swallow whole modules / docs that don't fit in the caller's context. Walks directories, filters by extension, truncates oversized files, caps total payload. Returns a concentrated brief.

Inputs: paths (required), question (required), model, shape, +7 more.

healthA
Read-onlyIdempotent

Check Kimi CLI installation, authentication, and session health

Inputs: verbose, sessionId. Returns: issues, status, kimiCli, sessions

HelpA
Read-onlyIdempotent

Show Kimi CLI help output

Inputs: no named parameters.

list-sessionsB
Destructive

List active conversation sessions with metadata, or manage them (delete/clear)

Inputs: action, sessionId. Returns: stats, action, sessions

metricsA
Read-onlyIdempotent

Expose Prometheus-formatted metrics for Kimi MCP server

Inputs: no named parameters.

pingC
Read-onlyIdempotent

Echo

Inputs: prompt.

plan-kimiA
Read-only

Generate a structured implementation plan using Kimi's --plan mode. Use BEFORE coding to get steps, files-to-touch, risks, and open questions. Distinct from ask-kimi: uses --plan flag (different system prompt) and parses structured output.

Inputs: goal (required), model, format, timeout, +4 more.

review-changesA
Read-onlyIdempotent

Run a code review against the current repository using Kimi (collects git diff + structured review prompt).

Inputs: base, model, title, commit, +5 more.

versionA
Read-onlyIdempotent

Display version and system information

Inputs: no named parameters. Returns: nodeJs, kimiCli, platform, mcpServer

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 14 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: from single queries (ask-kimi) to batch processing, code review, brainstorming, background tasks, planning, file ingestion, sandboxed delegation, session management, and server info. No two tools overlap in functionality.

    Naming Consistency3/5

    Most tools use lowercase with hyphens (e.g., ask-kimi, batch-kimi), but there are inconsistencies: some are single words (ping, health, version), 'Help' is capitalized, and patterns vary between verb-noun and noun-verb. The naming is readable but not fully consistent.

    Tool Count5/5

    With 14 tools, the server provides a comprehensive interface to the Kimi CLI, covering core interactions (query, batch, planning, code review, brainstorming), background tasks, file digestion, sandboxed delegation, and management. The count feels well-scoped for its purpose.

    Completeness4/5

    The tool surface covers the major workflows expected from a CLI-based coding assistant: interactive queries, batch processing, code review, planning, brainstorming, file ingestion, and sandboxed execution. Minor gaps might include a direct file-editing tool, but the existing tools enable comprehensive automation.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server that provides file operations and Moonshot API-powered tools (reasoning, code review, testing, research, web search, agent) for Kimi K2.5, requiring only a Moonshot API key.
      199 npm
      1
      MIT
    • A
      license
      B
      quality
      D
      maintenance
      Windows-first MCP bridge for Kimi Code CLI, exposing code analysis, editing, sessions, and diagnostics as tools for AI agents.
      6
      MIT
    • A
      license
      B
      quality
      C
      maintenance
      Bridges Codex Desktop with Kimi Code CLI, enabling direct control of AI coding sessions via MCP tools for prompt, status, cancel, and CLI operations.
      1
      MIT