Kage

MCP开发工具

提供方 kage-core

开发工具 未标注 API Key 社区 / 第三方 ClaudeCursorVS CodeWindsurf

A framework for collaborative agent memory. Kage is shared, code-grounded memory for developers and their coding agents: capture a learning once — a bug cause, a decision, a gotcha — and the whole team plus every agent recalls it next time it's relevant. Memory is grounded in you

一句话选型结论

按资料字段整理

Kage 属于开发工具类 MCP 服务器,传输方式未标注,API Key,可直接接入 Claude、Cursor、VS Code 等,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类开发工具 传输方式未标注 鉴权API Key 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

开发工具
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

memoryknowledge graphclaude code

安装与配置

未标注 API Key
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
代码与仓库操作

在对话里直接查代码、提 issue、走 PR,省掉来回切工具。

本地命令与脚本

把构建、测试、格式化这类重复命令交给模型执行。

接口联调与测试

让模型调你的接口、跑一遍用例,快速定位问题。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 已适配 Claude、Cursor、VS Code,换客户端不用重新研究配置。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在开发工具场景里让模型直接调用外部能力的人。
  • 已经在用 Claude、Cursor 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Kage当前 未标注 未标注 未标注 无 未标注
Git 838e2ec1 12 stdio · 本地进程 本地部署 有 2026-05-17
Markitdown MCP 2c653a5f 1 stdio · 本地进程 本地部署 有 2026-05-17
JavaGuide 未标注 stdio · 本地进程 本地部署 有 2026-04-11
awesome-claude-skills 未标注 stdio · 本地进程 本地部署 有 2026-04-26
Context7 831acf40 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

开发工具
字段来自项目仓库与公开索引,中文说明由本站标注
提供方kage-core上游标注的维护方 kage-core
分类开发工具本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式API Key远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · Cross-platform本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

13.7 KB
来自项目仓库与上游目录的原文,未做删改

Kage manages your memory and agents

State an intent. Kage's orchestrator briefs a coding agent from your repo's own memory, runs it
in an isolated git worktree — a single run or a multi-wave goal — and re-runs the checks
itself
rather than trusting the agent's report:```
┌ VERIFIED 3/3 — checks run by Kage, not the agent · build-a-stale-memory-triage-surface-do-n-260818-ec2c
│ "the stale-memory triage surface is built and wired into the review flow"
│ ✓ tests ran npm test --prefix mcp → exit 0 evidence/tests.log
│ ✓ diff-size inspected at most 800 changed lines evidence/diff-size.log
│ ✓ citations inspected every formally cited path exists (directly, or as a unique suffix) in the worktree evidence/citations.log
│ · touched 4 file(s), 212 line(s)
└────────────────────────────────────────────────────────────────


A real receipt from this repo's own run history. Every row is a command Kage ran or a fact
it inspected — never a claim the agent made about itself. `kage merge` only lands the code once
the claim holds, and ratifies what the agent learned, so the next brief, yours or a teammate's,
starts smarter.

That memory is the decisions behind your codebase, the runbook for a tricky deploy, the root
cause of a gnarly bug — captured as your agents work and checked against the actual code, so
what gets reused stays true. It's kept as plain Markdown files in your repo, conformant to the
Google Open Knowledge Format (OKF)
so there's no lock-in, and shared with your whole team through git. No account, no database,
no API key.```bash
npx -y @kage-core/kage-graph-mcp install

Website ·
Docs ·
Live viewer ·
npm ·
Book a demo

Works with Claude Code · Codex · Cursor · Windsurf · Gemini CLI · Cline · Goose ·
Roo Code · Kilo Code · OpenCode · Aider · Claude Desktop · Copilot · OpenClaw · Hermes · any MCP client


Install

One command, inside your repo, then restart your agent. That's the whole setup.```bash
npx -y @kage-core/kage-graph-mcp install


It creates `.agent_memory/`, builds the code graph, writes the `AGENTS.md` / `CLAUDE.md`
policy that tells agents to use Kage, auto-detects and wires your agents, and configures
`.gitignore` + the packet merge driver. Requires Node.js 18+. No account, no API key.

**Or just ask your agent to set it up.** Paste this into Claude Code, Cursor, or any coding agent:

> Set up Kage (verified memory for coding agents, https://github.com/kage-core/Kage)
> in this repo: run `npx -y @kage-core/kage-graph-mcp install`, then tell me to restart you.

Other ways (plugin · per-agent · memory-only)```bash
# Claude Code / Codex plugin
/plugin marketplace add kage-core/Kage      # then: /plugin install kage@kage

# wire a single agent (run `kage setup list` for all supported)
kage setup claude-code --project . --write

# memory store only, no agent wiring
kage init --project .

# confirm the harness is live
kage setup verify-agent --agent claude-code --project .

Delegate work (the orchestrator)```bash

kage room --project . # talk to Kage; it briefs and hires agents for you
kage dispatch "<intent>" --agent claude # one delegated run, briefed from repo memory
kage runs --project . # what every run is doing right now
kage review --project . # read a finished run's claim and diff
kage merge <run-id> --project . # land the code and ratify what it learned


Every run works in its own git worktree. The checks that decide the verdict on the receipt
above — tests, diff size, citations — are commands **Kage** runs itself, never the agent&#x27;s
self-report.

- **The app.** `kage app --project ` starts (or reuses) the local daemon and opens the
  same room, runs board, and memory view in a UI. From a checkout, `npm start --prefix shell`
  runs it as a native window — a thin Electron shell with no HTML of its own, it just loads the
  daemon&#x27;s own page — and `npm run dmg --prefix shell` builds a macOS `.dmg` (arm64 only;
  Windows/Linux packaging isn&#x27;t built yet).
- **From your phone.** The daemon can also bind to your machine&#x27;s LAN address, gated by a
  pairing secret required on every request, reads included. Today that means setting
  `&quot;lan&quot;: true` in `.agent_memory/config.json` by hand — there&#x27;s no `--lan` flag or app toggle
  yet.
- **Add a project without a terminal.** `kage projects add  --agent claude` registers
  another repo the same way the app&#x27;s &quot;+&quot; button does, then `kage app --project ` opens it.```bash
kage app --project &lt;dir&gt;
kage projects add &lt;dir&gt; --agent claude

Desktop app

A thin native shell (macOS, arm64 only) over the same daemon the CLI runs — dock presence,
a global hotkey, native notifications. Download the latest .dmg from
GitHub releases (look for a
Kage-.dmg asset).

Unsigned builds show macOS's "unidentified developer" prompt on first launch —
right-click the app in Finder and choose Open once. Once installed, it checks for
updates on launch and every 4 hours and installs on restart; ad-hoc (unsigned) builds
can't self-install and notify you instead, linking back to the releases page.

Prefer the CLI? The one-line install works everywhere the app doesn't need to:```bash
npx -y @kage-core/kage-graph-mcp install


## What is Kage

Kage is an orchestrator for coding agents, built on a memory layer. As your agent works, it captures what it learns
(decisions, bug fixes, conventions, how the code fits together) as
**Open Knowledge Format (OKF)**
concept files committed in your repo under `.agent_memory/`. The next session (yours or a
teammate&#x27;s) starts already knowing it, instead of re-reading or re-asking.

Three things make it different from other memory tools:

- **It&#x27;s collaborative.** The knowledge one person (or their agent) figures out becomes the
  whole team&#x27;s. Memory is shared through git, so a teammate&#x27;s next session starts with what
  you just learned, not a blank slate.
- **It&#x27;s standard &amp; git-native.** Memory is a conformant OKF bundle — plain Markdown in your
  repo, reviewed in the same PR as the code, readable by any OKF tool — not locked in one
  machine or a vendor&#x27;s cloud. Your knowledge stays yours.
- **It&#x27;s verified.** Every memory cites the code it&#x27;s about, and Kage checks those citations
  against your actual files at write time, at recall time, and when a diff changes the code.
  Memory that no longer matches the code is withheld, so the agent never acts on a stale claim.

## Kage called it. Google standardized it.

From day one, Kage kept agent memory as plain files in your repo — no cloud, no database, no
lock-in, while everyone else was building memory clouds. In June 2026, Google Cloud shipped
the **Open Knowledge Format**: knowledge as Markdown in git, vendor-neutral, no account — the
exact thesis Kage already ran on. So Kage **adopted OKF as its standard, and supercharges it**
with the layer OKF deliberately leaves out:

- **Verification** — OKF stores what you wrote down; Kage checks every concept against your
  real code and refuses hallucinated citations at write time.
- **Freshness** — OKF has no notion of staleness; Kage catches drift the moment your code
  changes and withholds memory that&#x27;s no longer true.
- **Code-grounding** — a deterministic code graph anchors each concept to the exact symbols it
  describes — the layer OKF leaves to tooling.

The trust metadata rides in OKF-legal `x-kage-*` fields, so a Kage bundle stays 100%
conformant and opens in any OKF consumer, including Google&#x27;s own visualizer.
**OKF standardizes the store; Kage is the verification and freshness layer Google left out.**

## How it works

Once installed, it&#x27;s ambient. You don&#x27;t run anything by hand:

1. **Recall before acting.** At the start of a task (and the moment the agent opens a file),
   Kage surfaces the relevant verified memory for it. Stale or deleted memory is left out.
2. **Capture as it works.** Durable learnings become packets. A memory that cites a file
   which doesn&#x27;t exist is rejected on the spot, so hallucinations never enter storage.
3. **Stay honest as the code moves.** When a diff changes code that a memory cites, that
   memory is flagged at commit/PR time (`kage pr check`) and withheld from recall until it&#x27;s
   re-verified or replaced, so knowledge can&#x27;t quietly rot.

Watch it happen in the **local dashboard** (`kage viewer`): packets, the memory↔code graph,
trust gates, and live events stream in as the agent works. Wrap anything in
`…` and it&#x27;s never stored.

`kage viewer`: the memory engine underneath the orchestrator above — your
team&#x27;s decisions, runbooks, and bug fixes (purple), kept in the repo and linked to the code they
are about (blue).

## Why Kage

Most memory tools (claude-mem,
agentmemory, mem0, Zep) store memory per-machine
or in a cloud you don&#x27;t own, and never re-check it against the code. Kage keeps it in your
repo and verifies it, so it stays your team&#x27;s and stays true as the code changes.

| | Kage | claude-mem | mem0 / Zep |
|---|---|---|---|
| Automatic capture + session-start recall | ✓ | ✓ | via SDK |
| Hallucinated citations **rejected at write time** | ✓ | — | — |
| Stale memory **withheld at recall** (cited files deleted/changed, TTL, reported) | ✓ | — | — |
| **Diff-time stale-catch**, warned before the PR when your change breaks a memory | ✓ | — | — |
| Memory reviewed in git, same PR as the code (plain files, no DB) | ✓ | SQLite + cloud | hosted API |
| Codify memory into team `SKILL.md` files agents auto-load | ✓ (`kage skills`) | — | — |
| Cross-machine sync | ✓ your own git remote | their cloud | their cloud |
| Account / API key required | none | cloud optional | yes |

## Features

- **Truth Report.** `kage scan` reads any repo in ~60s and surfaces its highest-risk
  knowledge gaps: undocumented hot files, untested hot paths, complexity hotspots,
  unresolved code debt, and bus-factor-1 files, plus duplicate implementations, dead
  exports, and doc lies when they exist. Every finding cited to `file:line`. Zero setup,
  nothing generated, runs before you install anything.
- **Savings receipts.** `kage gains` keeps a per-repo value ledger (tokens + $ the agent
  didn&#x27;t have to re-spend), every number traceable to a logged event; the agent relays it
  after each recall.
- **Team skills.** `kage skills` turns durable, verified procedures into
  `.claude/skills//SKILL.md` files agents auto-load, committed and shared, no cloud.
- **Personal memory &amp; sync.** `kage learn --personal` keeps cross-machine notes in
  `~/.kage/memory`, recalled as a clearly separated lower-trust section and synced over your
  own git remote.
- **Self-healing session loop.** Uncaptured sessions are auto-distilled into pending drafts
  you review; `kage resume` opens each session with a &quot;previously…&quot; digest; `kage repair`
  fixes broken packets and indexes in one command.

## Benchmarks

- **18% faster than grep at equal correctness** on real code-navigation tasks (N=3 suite,
  same agent/model; reproduce with `kage benchmark --project . --compare`).
- **LongMemEval-S retrieval:** 98.72% R@10 / 99.79% R@20 / 0.909 MRR — ahead of plain BM25
  at every depth except R@5, where BM25 edges it (96.60% vs 96.17%; full table in
  benchmarks/LONGMEMEVAL.md). The retrieval path itself is
  dependency-free: BM25 + sparse lexical scoring, no embeddings, no network.
- **Memory Correctness Under Change:** 0% stale-served (memory whose code was deleted or
  changed is withheld), vs 100% for capture-everything stores.
- **Trust benchmark:** 100/100, covering hallucination rejection, stale exclusion, and live
  grounding (`kage benchmark --trust --project .`).

Methodology, commands, and caveats: docs/BENCHMARKS.md.

## Daily commands```bash
kage recall &quot;how do I run tests&quot; --project .
kage verify --project .        # check citations against current code
kage pr check --project .      # stale-catch + graph freshness gate
kage gains --project .         # what Kage saved you
kage viewer --project .        # local dashboard
kage okf migrate --project .   # render memory as a Google OKF bundle

Full CLI and MCP reference: docs.
Delegating work to coding agents (dispatch → verified claim → merge): docs/DELEGATION.md.

Storage

Everything lives in .agent_memory/: packets/ is durable repo memory (git-tracked OKF Markdown);
graph/, code_graph/, structural/, and indexes/ are rebuildable with kage refresh;
reports/ holds the value ledger and health reports. Capture scans for secrets and PII
before writing.

Standard format — Open Knowledge Format (OKF). Kage's memory is an
OKF bundle:
plain Markdown concept files with YAML frontmatter, readable by any OKF consumer
(including Google's visualizer). Run kage okf migrate to render the store as an OKF
bundle under .agent_memory/okf/. Kage adds the lifecycle OKF leaves out — grounding,
verification, and freshness — carried in OKF-legal x-kage-* fields, and can import
any third-party OKF bundle. The round-trip is lossless. See OKF_STANDARD.md.

Development```bash

cd mcp
npm install
npm test
npm run build
```

Contributing & community

Kage is built in the open and we'd love your help. Four runtime dependencies (the
retrieval core uses none), no account, no cloud — it's a friendly codebase to jump into.

  • CONTRIBUTING.md — dev setup, project layout, conventions.
  • ROADMAP.md — where Kage is headed, and where to plug in.
  • Good first issues ·
    Help wanted — scoped places to start.
  • Discussions — questions, ideas, show-and-tell.

By participating you agree to our Code of Conduct.

License

GPL-3.0-only. See LICENSE. Releases before the GPL switch were MIT.

常见问题

7 问
答案由本站依据条目字段整理,不引用上游原文
Kage 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

Kage 怎么在 Claude、Cursor、VS Code 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Kage 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Kage 需要 API Key 吗?

资料标注需要API Key认证,使用前准备好对应凭据,并按最小权限配置。

Kage 支持哪些客户端?

资料标注支持 Claude、Cursor、VS Code、Windsurf、Codex、Zed;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Kage 能提供哪些能力?

资料显示能力标签包括 memory、knowledge graph、claude code、agents、team。具体工具清单以官方文档为准。

Kage 需要什么运行环境?

运行时为 Cross-platform。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。