Kage MCP server

Read from the package source without running it. The installed server may list more.

• kage_audit

  Audit whether repo memory and code intelligence are trustworthy: validation, memory inbox, structured context coverage, code graph precision, graph links, and concrete recommendations.

• kage_benchmark

  Return Kage proof metrics, or set mode=memory_quality / memory_scale for synthetic memory retrieval benchmarks.

• kage_benchmark_compare

  Compare the same task on the same repo with and without Kage. Reports estimated baseline discovery tokens/steps versus Kage recall/code-graph context, with evidence and caveats.

• kage_branch_overlay

  Build and return branch overlay metadata: branch, head, merge-base, changed files, and pending packet IDs.

• kage_capabilities

  Return an evidence-backed Kage memory-system capability audit across repo memory, collaboration/session proof, benchmarks, and dashboard/viewer readiness.

• kage_capturewrite action

  Create a repo-local Kage memory packet immediately. Org/global promotion still requires explicit human review. Capture is rejected if every referenced path is missing from the repo; set allow_missing_paths to record anyway.

• kage_cleanup_candidates

  Find conservative cleanup candidates from Kage's code graph. Reports unreferenced source files, unused exports, and internal-looking unused symbols with confidence and reasons; never auto-deletes.

• kage_code_graph

  Query the source-derived codebase graph: files, symbols, imports, calls, routes, tests, package scripts. This is generated from code, not learned memory.

• kage_code_indexwrite action

  Write external code index artifacts consumed by the code graph. Prefers SCIP when scip-typescript and scip are installed, then falls back to the built-in LSP-compatible symbol index.

• kage_compact

  Consolidate repo memory: prune dead citations, deprecate hard-stale packets, and surface near-duplicate clusters to merge (via kage_supersede). Defaults to a dry run; pass dry_run=false to apply pruning/deprecation. Duplicate merging stays an agent decision — no hosted LLM is used.

• kage_conflicts

  List repo-local memory packet pairs that contradict each other (same cited path, same subject, opposing claim). Resolve each with kage_supersede, or keep both intentionally.

• kage_context

  Primary kage entry point. Validates memory health, recalls relevant packets, and queries both the code graph and knowledge graph — all in one call. Call this at the start of every task instead of calling kage_validate, kage_recall, kage_code_graph, and kage_graph separately.

• kage_context_slot_deletewrite action

  Delete a repo-local context slot by label.

• kage_context_slot_setwrite action

  Create or update a repo-local pinned context slot. Use for durable, high-signal repo guidance that should always be included without loading all memory.

• kage_context_slots

  List repo-local pinned context slots. Pinned slots are small, reviewable facts that Kage includes in recall/context before task-specific memory.

• kage_contributors

  Build local contributor profiles from git history: commits, recent activity, touched files, modules, ownership silos, hotspot ownership, and commit category mix.

• kage_decisions

  Summarize Kage why-memory for a repo: decisions, gotchas, runbooks, conventions, code explanations, path coverage, weak/stale memory, and important code paths that still lack decision memory.

• kage_dependency_path

  Find how two files are connected in Kage's source-derived code graph. Reports direct dependency direction, reverse impact direction, or undirected graph connection.

• kage_distill

  Distill stored observations for one session into repo-local memory candidates. Org/global promotion still requires explicit human review.

• kage_docs_search

  Search this repo's OWN committed documentation (README, docs/**, *.md, common doc dirs — including any framework/API docs checked into the repo). BM25 over heading-anchored chunks from .agent_memory/indexes/docs-index.json. Returns ranked doc hits with doc_path, heading, line, and snippet. This indexes only files on disk in the project, never the internet.

• kage_feedback

  Record usefulness feedback on an approved repo-local memory packet: helpful, wrong, or stale.

• kage_fetch

  Fetch the full content of a specific node from the kage knowledge graph. Use after kage_search to get the complete fix, pattern, or decision.

• kage_graph

  Query the repo-local Kage knowledge graph. Returns typed, evidence-backed graph facts from entities, edges, and episodes.

• kage_graph_insights

  Return deterministic code graph intelligence: central files, dependency cycles, import communities, and short entry flows. Use to orient agents before broad architectural edits.

• kage_graph_registry

  Build a signed graph-registry manifest for generated memory graph, code graph, indexes, metrics, audit, inbox, source packet IDs, packet hashes, and repo git state.

• kage_graph_visual

  Export the repo-local Kage knowledge graph as Mermaid flowchart text for visual inspection.

• kage_inbox

  Return an actionable memory review inbox: pending packets, stale packets, duplicates, missing structured context, validation issues, and recommended actions.

• kage_install_policy

  Install or update the repo AGENTS.md policy that tells coding agents to use Kage automatically.

• kage_learn

  Capture an actual reusable learning from the current session as repo-local memory. Prefer this over diff proposal when the agent knows what was learned. Capture is rejected if every referenced path is missing from the repo; set allow_missing_paths to record anyway (e.g. a file you are about to create).

• kage_learning_ledger

  Return an agent-facing ledger that classifies observed session events into save, ignore, needs-evidence, or already-distilled memory decisions.

• kage_list_domains

  List all domains in the kage knowledge graph with their node counts and top tags. Use to orient before searching.

• kage_memory_access

  Report which repo-local memory packets have actually been recalled recently. This uses local ignored access telemetry and does not mutate shareable packet files.

• kage_memory_audit

  Return the repo-local audit trail for explicit memory mutations: capture, feedback, review, supersede, deprecate, and delete.

• kage_memory_handoff

  Return a teammate/agent handoff queue by combining memory inbox, lifecycle, audit, timeline, and lineage into concrete next actions.

• kage_memory_lifecycle

  Return a repo-local memory lifecycle report: healthy, hot, cold, stale, disputed, ungrounded, pending, generated, and concrete review actions.

• kage_memory_lineage

  Return memory supersession chains so agents can use current replacement packets and keep retired memory as audit history.

• kage_memory_reconcile

  Return agent-owned memory reconciliation work when source files linked to existing memory changed. Agents must update, supersede, or mark stale memory before final handoff.

• kage_memory_timeline

  Return recent repo-memory activity for teammate handoff: added, updated, pending, and deprecated packets with review actions.

• kage_metrics

  Return concise Kage adoption and quality metrics: code graph counts, language/parser coverage, memory graph evidence coverage, pending/approved packets, validation state, and readiness score.

• kage_module_health

  Return local module health scorecards from Kage's code graph, test signals, cleanup candidates, git churn, and ownership concentration.

• kage_observe

  Store an automatic local observation event from an agent session. Observations are privacy-scanned, deduplicated, and never published automatically.

• kage_pr_check

  Check whether repo memory, code graph, memory graph, and stale-memory state are ready for merge. Leads with a human summary of team memories invalidated by the current change — relay it to the developer.

• kage_pr_summarizewrite action

  Create a PR/branch memory summary from local git diff metadata and write repo-local change memory. Use when a branch is ready to hand off.

• kage_profile

  Return a compact project profile for agent orientation: repo totals, languages, top code+memory concepts, key files, memory focus, run commands, and next actions.

• kage_propose_from_diffwrite action

  Create or update a branch review summary and repo-local change-memory packet from local git status and diff metadata. Org/global promotion still requires explicit human review.

• kage_quality

  Return memory quality metrics: useful memory ratio, duplicate burden, stale/wrong feedback, evidence coverage, path grounding, and review queue size.

• kage_recall

  Recall repo-local Kage memory from .agent_memory packets. Returns an agent-ready context block plus ranked packet summaries.

• kage_refresh

  Rebuild repo indexes, code graph, memory graph, metrics, and stale-memory metadata. Agents should run this after meaningful file/content changes before PR checks; push-only or same-tree commits do not need another refresh. On non-default git branches metadata-only packet rewrites are skipped (quiet refresh) to avoid merge conflicts; pass force to persist them anyway.

• kage_registry_recommend

  Recommend documentation packs, skills, and optional MCPs for this repo based on its package metadata. Recommendations never install anything automatically.

• kage_review_artifactwrite action

  Create a Markdown review artifact summarizing pending memory packets for PR or human review.

• kage_reviewers

  Suggest reviewers for target or changed files from local git authorship, recent edits, and code-graph co-change ownership. Does not contact GitHub or external services.

• kage_risk

  Assess modification risk for files using Kage's code graph plus local git history: dependents, impact surface, churn, ownership, co-change partners, and test gaps. Use before editing hotspot or shared files.

• kage_search

  Search the kage community knowledge graph for gotchas, patterns, configs, and architectural decisions across auth, database, payments, deployment, frontend, testing, and more. Returns node summaries ranked by relevance.

• kage_session_replay

  Return a privacy-preserving replay digest for observed agent sessions: timeline, touched paths, commands, durable candidates, and distill actions without raw transcript text.

• kage_sessions

  Summarize local agent observation sessions, durable capture candidates, and next distillation actions without exposing raw transcript replay.

• kage_setup_agent

  Generate MCP/setup instructions for Codex, Claude Code, Cursor, Windsurf, Gemini CLI, OpenCode, Cline, Goose, Roo Code, Kilo Code, Claude Desktop, Aider, or generic MCP.

• kage_setup_doctor

  Audit Kage setup across supported agents, including Claude Code ambient hook readiness when applicable.

• kage_structural_index

  Build the complete cache-backed structural index for large repos. This covers all supported source/config/doc files and writes .agent_memory/structural artifacts separate from learned memory.

• kage_supersede

  Mark one repo-local memory packet as superseded by a replacement packet and write bidirectional lineage edges.

• kage_validate

  Validate repo-local Kage memory packets, pending packets, generated indexes, and sensitive-content checks.

• kage_verify_agent

  Verify that Kage is truly active for the current agent: config, repo policy, indexes, recall, code graph, and this live MCP tool reachability.

• kage_verify_citations

  Verify that a memory packet's cited file paths still exist and that the memory is not stale, before trusting it. Pass an id to check one packet, or omit to audit all approved repo memory. Returns grounding and staleness for each.

• kage_workspace

  Summarize a local multi-repo workspace: discovered git repos, Kage memory coverage, code graph counts, package dependencies, route contracts, topic/event contracts, and cross-repo co-change links between repos. Use when a task spans multiple sibling repos.

• kage_workspace_recall

  Recall Kage memory across every indexed repo in a local workspace and rank the combined hits. Use for cross-repo teammate knowledge and shared context.

• kage_xray

  Return a first-use Repo X-Ray: code structure layers for entry points, core files, risk, tests, memory overlay, and knowledge gaps.

• Code scan11 source files scanned25/25
• –Live reliabilityno gateway calls yet and no remote to proben/a
• –Tool poisoningtools not inspected (local package is not executed); not countedn/a
• Auth qualitylocal package, no credentials required12/15
• Maintenancelast push 29 days ago15/15
• Maintainer identityregistry namespace matches repository owner7/10

Safety score

91/100

higher than 85% of 48,255 servers

Tools

65

the typical server has 7

Tools that change things

11%

typical: 0%. Fewer write tools means less an agent can break

GitHub stars

33

more than 92% of 28,688 servers

Downloads a week

100

more than 63% of 12,191 servers with a package

Kage: common questions

Is Kage MCP server safe?

Yes, by our scan: it is graded A (91/100). Read the Kage safety report

How do I install Kage?

It runs on your machine. Copy the Claude Code, Cursor, VS Code or Claude Desktop config from the install section.

Does Kage need an API key?

Not as far as the registry entry and our scan can tell: no credentials are declared or required.

Is Kage maintained?

The last commit was 67 days ago (2026-08-29). The latest release is v2.3.0.

What can I use instead of Kage?

Servers from other publishers that do the same job: color-space MCP server, Deja Vu MCP server and Nautilus Compass Memory MCP server. Compare all Kage alternatives.

How does Kage compare with other MCP servers?

safety score 91/100 (higher than 85% of 48,255 servers); tools 65 (the typical server has 7); tools that change things 11% (typical: 0%. Fewer write tools means less an agent can break). Full comparison.