# com.kage-core/kage (npm · @kage-core/kage-graph-mcp)

Verified memory for coding agents: claims cited against code, stale withheld, savings receipts.

- Trust score: 60/100 (medium)
- Change this week: +18
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- npm · `@kage-core/kage-graph-mcp`: 60/100 (this document), [markdown](https://verifymcp.io/servers/com-kage-core-kage/kage-core-kage-graph-mcp.md), [page](https://verifymcp.io/servers/com-kage-core-kage/kage-core-kage-graph-mcp)

## Channel facts

- Registry: `npm`
- Package: `@kage-core/kage-graph-mcp`
- Version: `2.3.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Supply Chain Security**: 87/100
  - No malware found by supply-chain analysis.
  - Only part of the dependency tree could be resolved (98 of 102), so this covers what we could see, not the whole tree.
  - No install/post-install scripts declared.
  - Only part of the dependency tree could be resolved (98 of 102), so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (GPL-3.0-only).
  - Actively maintained (last published 9 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 43/100
  - AI-judged instruction clarity (poor).
  - Tool/resource definitions use about 4519 tokens (~68/item across 66 items; 66 tools + 0 resources), lean.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 72/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 17% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add com-kage-core-kage -- npx -y @kage-core/kage-graph-mcp
```

### Codex

```bash
codex mcp add com-kage-core-kage -- npx -y @kage-core/kage-graph-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-kage-core-kage": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@kage-core/kage-graph-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-kage-core-kage --command npx --arg -y --arg @kage-core/kage-graph-mcp
```

### Hermes

```yaml
mcp_servers:
  com-kage-core-kage:
    command: "npx"
    args: ["-y", "@kage-core/kage-graph-mcp"]
```

### Other

```json
{
  "mcpServers": {
    "com-kage-core-kage": {
      "command": "npx",
      "args": [
        "-y",
        "@kage-core/kage-graph-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-03 (score 60, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-02 (score 59, +33)

- [security regression] Provenance: unverified → fail
- [security improvement] Known CVEs: unverified → partial
- [security improvement] Install scripts: unverified → pass
- [security improvement] Malware scan: unverified → pass
- [security] Stability: Stability not yet verified: we do not have a sandbox capture of the MCP schema this version of the package serves yet.
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Capabilities: pass → unverified
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] Dependency health: unverified → partial
- [functional improvement] Stability: unverified → 0.23
- [functional improvement] License: unverified → pass
- [functional] Licence: GPL-3.0-only

### 2026-08-01 (score 26, +17)

- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional regression] Dependency health: partial → unverified
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Tool coverage: unverified → 100

### 2026-07-31 (score 9, +3)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 6, −61)

- [security regression] Known CVEs: partial → unverified
- [security regression] Install scripts: pass → unverified
- [security regression] Provenance: fail → unverified
- [security regression] Malware scan: pass → unverified
- [functional regression] Maintenance: pass → unverified
- [functional regression] Dependency health: partial → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] License: pass → unverified
- [functional] First check of Schema quality: unverified
- [functional] Licence: GPL-3.0-only

### 2026-07-28 (score 67, +25)

- [security regression] Provenance: unverified → fail
- [security improvement] Known CVEs: unverified → partial
- [security improvement] Install scripts: unverified → pass
- [functional improvement] Schema quality: unverified → poor
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] Dependency health: unverified → partial
- [functional improvement] License: unverified → pass
- [functional] Licence: GPL-3.0-only

### 2026-07-27 (score 42)

First indexed and scored.

## MCP tools (66)

### `kage_context` (~175 tokens)

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.

Input parameters:

- `changed_files` (array): Optional changed files for pre-edit or PR risk context
- `limit` (number): Max memory packets to return (default 5)
- `project_dir` (string, required): Absolute path to the project root
- `query` (string, required): The task or question — used for both memory recall and code graph search
- `session_id` (string): Optional active agent session id for memory reconciliation
- `targets` (array): Optional files the agent may edit or explain; used for risk context

### `kage_search` (~138 tokens)

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.

Input parameters:

- `domain` (string): Optional: restrict search to a specific domain. One of: auth, database, payments, deployment, frontend, testing, api-design, email, storage, ai-agents, security, performance, observability, infrastru…
- `query` (string, required): What you are looking for, e.g. 'prisma serverless connection', 'stripe webhook signature', 'JWT refresh token'

### `kage_fetch` (~90 tokens)

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.

Input parameters:

- `domain` (string, required): The domain the node belongs to, e.g. 'database', 'auth', 'payments'
- `node_id` (string, required): The node slug, e.g. 'prisma-serverless-connection-exhaustion'

### `kage_list_domains` (~33 tokens)

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

### `kage_recall` (~142 tokens)

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

Input parameters:

- `docs` (boolean): If true, append a Docs section (<=3 hits) drawn from this repo's own committed documentation.
- `embeddings` (boolean)
- `explain` (boolean)
- `json` (boolean)
- `limit` (number)
- `max_context_tokens` (number)
- `project_dir` (string, required)
- `query` (string, required)
- `structural_hops` (number): If >0, append a bounded N-hop code-graph blast radius seeded from the recalled memory's files.

### `kage_graph` (~55 tokens)

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

Input parameters:

- `limit` (number)
- `project_dir` (string, required)
- `query` (string, required)

### `kage_graph_registry` (~73 tokens)

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.

Input parameters:

- `full` (boolean): Force a full code graph rebuild instead of reusing unchanged graph artifacts.
- `project_dir` (string, required)

### `kage_code_graph` (~72 tokens)

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

Input parameters:

- `json` (boolean)
- `limit` (number)
- `project_dir` (string, required)
- `query` (string)

### `kage_risk` (~94 tokens)

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.

Input parameters:

- `changed_files` (array): Optional PR/branch changed files. If targets is omitted, these are assessed.
- `project_dir` (string, required)
- `targets` (array): File paths to assess

### `kage_dependency_path` (~74 tokens)

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

Input parameters:

- `from` (string, required): Source file path or unique suffix
- `project_dir` (string, required)
- `to` (string, required): Target file path or unique suffix

### `kage_cleanup_candidates` (~54 tokens)

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.

Input parameters:

- `project_dir` (string, required)

### `kage_reviewers` (~85 tokens)

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.

Input parameters:

- `changed_files` (array): Optional PR/branch changed files. If targets is omitted, these are used.
- `project_dir` (string, required)
- `targets` (array): File paths to review

### `kage_contributors` (~48 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_profile` (~50 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_xray` (~47 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_capabilities` (~44 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_context_slots` (~46 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_context_slot_set` (~98 tokens)

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.

Input parameters:

- `content` (string, required)
- `description` (string)
- `label` (string, required)
- `paths` (array)
- `pinned` (boolean)
- `project_dir` (string, required)
- `size_limit` (number)
- `tags` (array)

### `kage_context_slot_delete` (~35 tokens)

Delete a repo-local context slot by label.

Input parameters:

- `label` (string, required)
- `project_dir` (string, required)

### `kage_decisions` (~60 tokens)

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.

Input parameters:

- `project_dir` (string, required)

### `kage_code_index` (~56 tokens)

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.

Input parameters:

- `project_dir` (string, required)

### `kage_structural_index` (~52 tokens)

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.

Input parameters:

- `project_dir` (string, required)

### `kage_docs_search` (~109 tokens)

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.

Input parameters:

- `limit` (number)
- `project_dir` (string, required)
- `query` (string, required)

### `kage_metrics` (~51 tokens)

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.

Input parameters:

- `project_dir` (string, required)

### `kage_memory_access` (~45 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_module_health` (~44 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_graph_insights` (~54 tokens)

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

Input parameters:

- `project_dir` (string, required): Absolute path to the project root

### `kage_workspace` (~77 tokens)

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.

Input parameters:

- `project_dir` (string, required): Workspace root directory to scan for git repos

### `kage_workspace_recall` (~86 tokens)

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.

Input parameters:

- `limit` (number): Max combined hits to return (default 8)
- `project_dir` (string, required): Workspace root directory to scan for git repos
- `query` (string, required): Question or task to recall across repos

### `kage_audit` (~48 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_inbox` (~44 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_refresh` (~106 tokens)

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.

Input parameters:

- `force` (boolean): Persist packet metadata rewrites even on a non-default branch
- `project_dir` (string, required)

### `kage_workflow` (~204 tokens)

Kage memory workflow (this tool performs no action; it returns this loop). 1) Start every task with kage_context (project_dir + the task as query): it validates memory, recalls relevant packets, and queries the code and knowledge graphs in one call. 2) Do the work, preferring repo memory over public context. 3) Capture reusable learnings with kage_learn — bug causes and verified fixes, conventions, decisions, gotchas, run/test/build commands. Wrap anything that must never leave the repo in <private>...</private> tags; private spans are stripped before sharing. 4) After meaningful file changes, call kage_refresh so indexes, graphs, and stale-memory checks stay current. 5) Before finishing a branch, call kage_pr_summarize then kage_pr_check. Recall receipts show estimated tokens saved versus rediscovery; report memory quality with kage_feedback (helpful/wrong/stale).

### `kage_pr_summarize` (~49 tokens)

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.

Input parameters:

- `project_dir` (string, required)

### `kage_pr_check` (~59 tokens)

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.

Input parameters:

- `project_dir` (string, required)

### `kage_memory_reconcile` (~65 tokens)

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.

Input parameters:

- `limit` (number)
- `project_dir` (string, required)
- `session_id` (string)

### `kage_quality` (~45 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_memory_lifecycle` (~50 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_memory_timeline` (~49 tokens)

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

Input parameters:

- `days` (number)
- `project_dir` (string, required)

### `kage_memory_lineage` (~39 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_memory_audit` (~53 tokens)

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

Input parameters:

- `limit` (number)
- `project_dir` (string, required)

### `kage_memory_handoff` (~45 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_supersede` (~63 tokens)

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

Input parameters:

- `packet_id` (string, required)
- `project_dir` (string, required)
- `reason` (string)
- `replacement_packet_id` (string, required)

### `kage_conflicts` (~53 tokens)

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.

Input parameters:

- `project_dir` (string, required)

### `kage_benchmark` (~61 tokens)

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

Input parameters:

- `mode` (string)
- `project_dir` (string, required)
- `sizes` (array)
- `top_k` (number)

### `kage_benchmark_compare` (~62 tokens)

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.

Input parameters:

- `project_dir` (string, required)
- `task` (string, required)

### `kage_setup_agent` (~76 tokens)

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.

Input parameters:

- `agent` (string, required)
- `project_dir` (string, required)
- `write` (boolean)

### `kage_setup_doctor` (~36 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_verify_agent` (~57 tokens)

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

Input parameters:

- `agent` (string, required)
- `project_dir` (string, required)

### `kage_graph_visual` (~42 tokens)

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

Input parameters:

- `limit` (number)
- `project_dir` (string, required)

### `kage_branch_overlay` (~40 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_learn` (~194 tokens)

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).

Input parameters:

- `allow_missing_paths` (boolean)
- `discovery_tokens` (number): Approximate token cost of producing this knowledge (exploration + reasoning). Stored on the packet so recall receipts can report replay value; a conservative per-type default is estimated when omitte…
- `evidence` (string)
- `graph_nodes` (array)
- `learning` (string, required)
- `paths` (array)
- `project_dir` (string, required)
- `stack` (array)
- `tags` (array)
- `title` (string)
- `type` (string)
- `verified_by` (string)

### `kage_capture` (~138 tokens)

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.

Input parameters:

- `allow_missing_paths` (boolean)
- `body` (string, required)
- `graph_nodes` (array): Code-graph node references (symbol/route/file) this memory is about.
- `paths` (array)
- `project_dir` (string, required)
- `stack` (array)
- `summary` (string)
- `tags` (array)
- `title` (string, required)
- `type` (string)

### `kage_verify_citations` (~75 tokens)

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.

Input parameters:

- `id` (string)
- `project_dir` (string, required)

### `kage_compact` (~89 tokens)

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.

Input parameters:

- `dry_run` (boolean)
- `project_dir` (string, required)

### `kage_observe` (~124 tokens)

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

Input parameters:

- `agent` (string)
- `command` (string)
- `exit_code` (number)
- `metadata` (object)
- `path` (string)
- `project_dir` (string, required)
- `session_id` (string)
- `summary` (string)
- `text` (string)
- `timestamp` (string)
- `tool` (string)
- `type` (string, required)

### `kage_distill` (~48 tokens)

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

Input parameters:

- `project_dir` (string, required)
- `session_id` (string, required)

### `kage_sessions` (~40 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_learning_ledger` (~61 tokens)

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

Input parameters:

- `limit` (number)
- `project_dir` (string, required)
- `session_id` (string)

### `kage_session_replay` (~65 tokens)

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

Input parameters:

- `limit` (number)
- `project_dir` (string, required)
- `session_id` (string)

### `kage_feedback` (~50 tokens)

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

Input parameters:

- `kind` (string, required)
- `packet_id` (string, required)
- `project_dir` (string, required)

### `kage_install_policy` (~37 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_validate` (~36 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_registry_recommend` (~44 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_review_artifact` (~35 tokens)

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

Input parameters:

- `project_dir` (string, required)

### `kage_propose_from_diff` (~50 tokens)

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.

Input parameters:

- `project_dir` (string, required)

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/com-kage-core-kage/kage-core-kage-graph-mcp#diagnostics

## Score history

- 2026-08-03: 60
- 2026-08-02: 59
- 2026-08-01: 26
- 2026-07-31: 9
- 2026-07-30: 6
- 2026-07-29: 67
- 2026-07-28: 67
- 2026-07-27: 42

## Links

- npm package: https://www.npmjs.com/package/@kage-core/kage-graph-mcp
- Socket report: https://socket.dev/npm/package/@kage-core/kage-graph-mcp
- Repository: https://github.com/kage-core/Kage
- Changelog RSS feed: https://verifymcp.io/servers/com-kage-core-kage/kage-core-kage-graph-mcp/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-kage-core-kage/kage-core-kage-graph-mcp/changelog.json
- HTML version of this page: https://verifymcp.io/servers/com-kage-core-kage/kage-core-kage-graph-mcp