Versorgt AI Coding Agents mit einer Live-Codebase-Map, die durch Graphen verifiziert wird. Sie enthält Call Graphs und Dependency-Analysen, um Breaking Changes zu verhindern.
Auch bekannt als Eilodon/CALM, calm, @eilodon/calm-mcp
- Stars
- 17
- Tools
- 5
- Downloads, 30 Tage
- 294
- Neueste Version
- 0.8.0
- Letzter Commit
- 13. Nov. 2026
- Lizenz
- MIT
Was ist CALM MCP?
Versorgt AI Coding Agents mit einer Live-Codebase-Map, die durch Graphen verifiziert wird. Sie enthält Call Graphs und Dependency-Analysen, um Breaking Changes zu verhindern. Er stellt 5 Tools bereit, etwa review_symbol, debug_symbol, onboard_area.
Zusammenfassung generiert aus dem README des Projekts
Über CALM MCP server
CALM bietet AI Coding Agents eine Live-Map der Codebase, die durch Graphen verifiziert wird, um Breaking Changes bei Edits zu vermeiden. Im Gegensatz zu Tools, die auf einfachen Text-Suchen basieren, nutzt dieser MCP server echte Call Graphs und Dependency-Analysen, um die Vernetzung von Funktionen und Symbolen aufzuzeigen. Er unterstützt 24 Sprachen via Tree-sitter-Parsing, wobei 13 Sprachen direkt Call Graphs liefern und 12 weitere compiler-verifizierte Edges bieten, sofern Tools wie rust-analyzer, gopls oder clangd verfügbar sind.
Der Server ist für Local-first-Development konzipiert, läuft auf deiner Maschine und hält das gesamte Code-Indexing sowie die Suche privat. Er lässt sich via stdio in verschiedene MCP Clients integrieren, darunter Claude Code, Cursor, VS Code, Windsurf und JetBrains AI Assistant. Das System verfügt über Safety Gates, die Edits an kritischen Hub-Symbolen verweigern können, bis der Agent die Caller explizit geprüft hat. Zudem gibt es einen Fitness Report, um Code-Komplexität und Architektur-Verstöße zu überwachen.
Was du damit machen kannst
- 1Breaking Changes verhindernEin Agent kann alle Caller einer Funktion prüfen, bevor er deren Signatur ändert, um sicherzustellen, dass keine Abhängigkeiten unterbrochen werden.
- 2Komplexe Dependencies navigierenEin Entwickler kann eine KI bitten, die Beziehungen zwischen spezifischen Symbolen mithilfe von Call- und Import-Edges abzubilden.
- 3Codebase Health überwachenNutze den Fitness Report, um Dead Code oder Verletzungen von Architektur-Grenzen innerhalb eines Projekts zu identifizieren.
- 4Präzises Code-ReadingEin Agent kann gezielt den Body einer Funktion abrufen, anstatt eine gesamte große Datei lesen zu müssen.
Geschrieben aus dem README des Projekts. Jeder Use Case wurde gegen ein Zitat daraus geprüft.
So installierst du CALM MCP
Formate geprüft am 10. Nov. 2026Zu Cursor hinzufügenZu Goose hinzufügenCALM MCP in Claude Code installieren
$ claude mcp add calm -- npx -y @eilodon/calm-mcpCALM MCP in Cursor installieren
~/.cursor/mcp.json
{
"mcpServers": {
"calm": {
"command": "npx",
"args": [
"-y",
"@eilodon/calm-mcp"
]
}
}
}CALM MCP in VS Code installieren
.vscode/mcp.json
{
"servers": {
"calm": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@eilodon/calm-mcp"
]
}
}
}CALM MCP in VS Code CLI installieren
$ code --add-mcp '{"name":"calm","type":"stdio","command":"npx","args":["-y","@eilodon/calm-mcp"]}'CALM MCP in Claude Desktop installieren
claude_desktop_config.json
{
"mcpServers": {
"calm": {
"command": "npx",
"args": [
"-y",
"@eilodon/calm-mcp"
]
}
}
}CALM MCP in Codex installieren
$ codex mcp add calm -- npx -y @eilodon/calm-mcpCALM MCP in Codex config.toml installieren
~/.codex/config.toml
[mcp_servers.calm] command = "npx" args = ["-y", "@eilodon/calm-mcp"]
CALM MCP in Gemini CLI installieren
$ gemini mcp add -s user calm npx -- -y @eilodon/calm-mcpCALM MCP in Gemini settings.json installieren
~/.gemini/settings.json
{
"mcpServers": {
"calm": {
"command": "npx",
"args": [
"-y",
"@eilodon/calm-mcp"
]
}
}
}CALM MCP tools 5
Erkannt aus dem READMEreview_symboldebug_symbolonboard_areareview_prcalm_workflow
| review_symbol | — | |
| debug_symbol | — | |
| onboard_area | — | |
| review_pr | — | |
| calm_workflow | — |
Automatisierte Checks
Geluften am 12. Nov. 2026Vollständiger Bericht →Unsere automatisierten Checks bestanden. Das ist kein Security-Audit: Lies den Code und gib dem Server nur den minimal notwendigen Zugriff. Wie die Checks funktionieren
- Source Repository verknüpft und erreichbarBestanden
- Open Source Lizenz (OSI)Bestanden
- Commit oder Release im letzten JahrBestanden
- Package-Name ähnelt keinem populären PackageBestanden
- Remote Endpoint nutzt HTTPSNicht geprüft
- Destruktive Tools sind markiertBestanden
- Keine versteckten Anweisungen an das ModellBestanden
- Keine kritischen Advisories im Paket oder seinen AbhängigkeitenBestanden
README
Auf GitHub ansehenCALM — Coding Agent Liveness Map
A live, graph-verified map of your codebase — so an AI coding agent can edit with its eyes open instead of grepping in the dark.
Real call graphs instead of vector-similarity guesses. Compiler-verified edges wherever a compiler is available. Hard safety gates on the write path itself, not just warnings an agent is free to scroll past. Measured claims in this README are tied either to a current CALM snapshot or to benchmark artifacts; repo-specific values change as the codebase changes.
New here? Quick start gets you running in under a minute — no clone, no Rust toolchain, works with Claude Code, VS Code, Cursor, Windsurf/Devin Desktop, Codex, Antigravity, and JetBrains. Comparing tools in this category? Jump straight to Proof, not promises. Want the internals? docs/architecture.md covers multi-tier indexing, the SCIP/LSP overlay system, the concurrency model, and the sanitization layer in full.
| Coverage | 24 languages parsed · 13 with full call graphs by default (6 zero-config + 7 more via the default tier0-5 bundle) · 12 with a formal/compiler-verified upgrade path when the provider/toolchain is available |
| Safety | the only one in the published five-server benchmark that refused an unconfirmed edit to a verified hub symbol |
| Efficiency | task-specific token savings versus a naive read-the-files baseline; see the benchmark artifacts |
The problem
An AI agent that edits code without knowing who calls the function it's about to change will, sooner or later:
- Delete "dead code" that a dozen other files still call.
- Change a signature and miss half its call sites.
- Refactor a symbol it assumed was minor — and discover, after breaking the build, that it was the hub the whole module leaned on.
None of that is a reasoning failure. It's a visibility failure: the agent never had a map. Give it one, and the guessing stops.
Why "CALM"
Most coding agents operate the way anyone would in an unfamiliar codebase with only grep: no sense of what's wired to what, no way to know if touching this function ripples into fourteen others. That's not confidence — it's fast guessing.
CALM stands for Coding Agent Liveness Map. Liveness, because the map is never a stale snapshot — it watches the filesystem, reindexes incrementally as files change, and reports in every response how fresh it currently is (scanning → parsing → building_edges → ready). Map, because it's an actual graph — call edges, import edges, hub/coreness metrics — not a flat text index pretending to be one. Hand an agent a live, trustworthy map of the terrain, and it stops flailing. It gets calm.
What you get
- The agent stops guessing who depends on what.
callers/callees/edit_contextshow every known caller before a change ships. Full tree-sitter call graphs cover 13 languages out of the box: Python, TypeScript, JavaScript, Java, Rust, and Go with zero configuration, plus C, C++, C#, Ruby, PHP, Shell, and R via the defaulttier0-5grammar bundle. Eleven more (Kotlin, Swift, Scala, Dart, Lua, Elixir, Haskell, OCaml, Zig, PowerShell, Groovy) parse behind opt-in--features lang-Xbuild flags — 24 languages parsed in total (see multi-tier indexing). - Edits that can't silently break things. Every write is hash-verified against the exact line range and syntax-checked before it ever touches disk. Hub and high-fan-in symbols hard-refuse a write until the agent has reviewed the callers and explicitly confirmed — a policy only a tool with a real dependency graph can enforce, and one the published competitor benchmark found no other server enforcing.
- Every edge tells you how much to trust it. Call edges are confidence-graded (
textual → inferred → resolved → formal), and when your compiler can double-check the graph, CALM asks it to: SCIP overlays (rust-analyzer,scip-go— including multi-modulego.workworkspaces —scip-python,scip-ruby, and more) and live LSP overlays (gopls,clangd) can upgrade best-guess edges to compiler-verified ground truth across 12 supported language integrations when their provider/toolchain is available; unavailable providers sit out without changing the base behavior. - A codebase that grades itself.
fitness_reportturns hub concentration, dead code, complexity, and architecture-boundary violations into a queryable, CI-enforceable signal instead of a one-off audit — andremember/recallkeep decisions and gotchas available across sessions. - Plays well with others, and stays on your machine. A cross-process edit lock and single-writer indexing model mean two editor sessions on the same repo don't corrupt each other's writes or double-index — under the shared daemon, sessions can even see each other coming. No code leaves your machine for indexing, search, or editing; the default embedding model is vendored into the binary at build time and needs no runtime network when those weights are valid; if they are unavailable, a runtime fallback download is allowed by default and can be disabled for strict offline operation. MIT-licensed. (One more opt-in exception: building with
--features oteland settingOTEL_EXPORTER_OTLP_ENDPOINTexports span attributes — file paths, symbol names, tool names, timing, never source bodies — to your own collector. Off by default; see docs/architecture.md and usehttps://collectors only.)
Where CALM fits
"Code intelligence for AI agents" is a real category now, built up by open-source pioneers — Aider, Serena, Sourcegraph/Cody, and others — that proved an agent works better with real code structure under it than with grep and good intentions. CALM builds on that foundation with a different center of gravity: most tools in the category inform the read path — better search, better navigation, better context. CALM also guards the write path. The same graph that answers "who calls this?" enforces "you don't change it until you've looked": hub/high-risk edits require fresh pre-edit context plus explicit confirmation grounded in a real caller; the policy can be widened to every edit, and every write is hash- and syntax-verified before it lands.
The trade-off is stated plainly: CALM's full-call-graph tier out of the box is 13 languages, not the 40+ some pure-LSP tools reach — though with 24 languages parsed and 12 carrying a compiler-verified upgrade path when their providers are available, the gap is narrower than it looks. What the trade buys is the part most distinctly CALM's own: confidence-graded edges, hard pre-edit gates, and a codebase that grades its own health — each backed by a number you can reproduce yourself (Proof, not promises).
Is CALM the right fit?
Good fit: agents that edit code directly, not just answer questions about it · single-repo codebases in a Tier-0/Tier-0.5 language · projects running multiple MCP clients (see supported clients below) against the same repo · local-first users who don't want to depend on an embedding API.
Not the fit today: multi-repo/cross-repo enterprise search — tools purpose-built for that scale (Sourcegraph/Cody among them) will serve you better · a language nowhere in CALM's current 24-language tree-sitter set.
Quick start
Supported clients — CALM works with any MCP client that speaks stdio; these are wired up or documented today:
| Client | Modes | Fastest install |
|---|---|---|
| Claude Code | CLI · Web · IDE | claude mcp add --transport stdio calm -- npx -y @eilodon/calm-mcp serve |
| VS Code | IDE (native MCP / Copilot Agent mode) | code --add-mcp '{"name":"calm","command":"npx","args":["-y","@eilodon/calm-mcp","serve"]}' |
| Cursor | IDE · Cloud (Background Agent) | Add to Cursor → |
| Windsurf / Devin Desktop | IDE · Cloud | edit ~/.codeium/windsurf/mcp_config.json |
| Codex (OpenAI) | CLI · IDE | codex mcp add calm -- npx -y @eilodon/calm-mcp serve |
| Antigravity (Google) | CLI · IDE | edit ~/.gemini/config/mcp_config.json |
| JetBrains AI Assistant | IDE | via UI settings |
Full walkthrough for every client above, including exact global-config snippets for the ones that need one — docs/mcp-client-setup.md. Running inside a devcontainer/Codespace where stdio forwarding doesn't reach? See docs/http-transport.md (advanced, remote-dev only, opt-in, loopback by default).
Using CALM on your own project — no clone, no Rust toolchain:
{
"mcpServers": {
"calm": {
"command": "npx",
"args": ["-y", "@eilodon/calm-mcp", "serve"]
}
}
}
Drop that into .mcp.json (Claude Code/Cursor) or .vscode/mcp.json (VS Code uses a top-level "servers" key instead of "mcpServers", same shape otherwise) at your project root. Claude Code plugin instead: /plugin marketplace add Eilodon/CALM then /plugin install calm@CALM.
Prefer a native binary over npx? curl -fsSL https://raw.githubusercontent.com/Eilodon/CALM/main/scripts/install.sh | sh, then run calm setup from inside your project — it writes the same MCP config automatically, pointing at the binary you just installed. Add calm setup --npx instead to write the portable npx entry (shareable/committable — teammates and CI don't need the binary). It pins to this binary's own version by default for reproducible cold installs; pass --track latest to always resolve npm's newest release instead.
Developing on CALM itself (this repo):
# 1. Build the binary
cargo build --release -p calm-cli
# 2. Initialize config for your project
calm init --project-root .
# 3. Build the index (embeds symbols too, if semantic search is enabled in config.json)
calm index --project-root .
# 4. Run the MCP server over stdio — incremental reindex kicks in automatically if an index already exists
calm serve --project-root .
This repo ships ready-made config for Claude Code (.mcp.json), Cursor (.cursor/mcp.json), and VS Code (.vscode/mcp.json) — all three point at scripts/mcp-launcher.sh, a shared launcher that finds an already-built binary, downloads a checksum-verified prebuilt release if you're on a matching git tag, or builds from source if nothing is available yet. Clone the repo and it just works — no manual build step required first.
Note:
calm serveautomatically adds.calm/to.gitignoreon startup so the index database never gets committed.
Example: an agent's actual workflow
agent: repo_overview()
→ current files/symbols and `indexing_phase=ready` are reported live
agent: "I need to change getUserByEmail"
→ locate("getUserByEmail") # find the file + symbol metadata
→ source("getUserByEmail") # read just the function body, not the whole file
→ edit_context("getUserByEmail") # MANDATORY before any edit
→ the live caller count and risk assessment determine whether the agent reviews callers before touching the signature
→ edit_symbol("getUserByEmail", expected_hash=..., new_text=...)
→ risk_assessment=high, is_hub=true, no confirm:true → refused, with an explanation
→ edit_symbol(..., confirm=true, reason="checked getUserByToken, still returns the same shape")
# reason must cite a real caller edit_context returned — writes for real, reindexes immediately
→ diff_impact(staged=true) # verifies blast radius before commit
Proof, not promises
The table below is a CALM snapshot observed on 2026-08-12 from this checkout. Re-run repo_overview() and fitness_report() to refresh it; repo-specific values change as the codebase changes. Benchmark ratios are task-specific and remain in the benchmark artifacts:
| Metric | Measured value |
|---|---|
| Codebase indexed | 366 files, 6,050 symbols — 15 language families present in this repo alone |
Hub concentration (hub_pct) |
7.38% — 271 hub symbols (gate: ≤ 20%) |
Dead-code rate (dead_code_pct, coverage-aware) |
5.04% (gate: ≤ 10%) |
Hotspot risk (hotspot_risk, churn × complexity, worst file) |
0.90 — currently above gate (≤ 0.80), fitness_report() reports FAIL — being investigated rather than hidden or threshold-relaxed; see fitness_report/calm fitness-check |
Edge coverage (edge_coverage_pct) |
72.39% of symbols have at least one call edge (gate: ≥ 60%) |
High-complexity functions (high_complexity_pct) |
2.8% (gate: ≤ 15%) |
Architecture fit (avg_distance, Martin/OOD) |
0.28 average distance from the main sequence (gate: ≤ 1.00) |
Ambiguous symbol boundaries (boundary_ambiguous_count) |
0 (gate: ≤ 0) |
Architecture boundary violations (boundary_violations) |
0 (gate: ≤ 0) — the watcher → tools import previously flagged here was fixed by relocating the shared RwLockExt/LockExt traits it needed out of tools/common.rs into their own sync_ext module |
Config drift (config_drift_count) |
0 (gate: ≤ 0) — the current docs/config path declarations resolve cleanly |
| Token efficiency vs. a naive read-the-files baseline | Benchmark-specific; see methodology rather than treating one task's ratio as a repo-wide constant |
| Full test suite (default features) | see Testing below |
Benchmarked against four other live MCP servers
benchmarks/b11_extended_competitor_ab/ installs and calls four established open-source code-intelligence MCP servers — CodeGraph, Semble, grepai, and Serena — against an isolated git worktree of this repo, 5 repeats per task, with a correctness oracle for every task. The goal isn't a leaderboard; it's checking CALM's claims against real, running prior art instead of a marketing page.
What the runs showed: CALM matched the best result on caller-recall and blast-radius tasks, and was the only one of the five servers whose pre-edit safety gate actually refused a risky, unconfirmed edit rather than merely being able to describe the risk after the fact. Not every number flatters: on one token-efficiency task CALM's compression ratio was the lowest of the five — correctness stayed at the ceiling there too, and the number is published as measured. That is this project's standing benchmark policy: unflattering results ship alongside good ones (benchmarks/README.md). Full methodology, every task, and the raw per-tool numbers live in the benchmark's own README.
Language coverage, measured not asserted
benchmarks/resolution/ runs a tier-distribution baseline (resolved / inferred / textual / ambiguous split — no oracle, one real OSS repo per language) across the 19 newly-added or Tier-0.5 languages, reported as-is: Kotlin (89.6%) and OCaml (86.3%) land mostly in the ambiguous tier from common short method-name collisions; Dart produces symbols but zero call edges — a documented limitation of that tree-sitter grammar, not a bug; Tier-2 type inference is wired only for the original Tier-0 languages so far. Full per-language table in the benchmark's own README.
How CALM works
Full technical detail lives in docs/architecture.md — including the design philosophy behind why every response carries suggested_next and why the risky steps are hard-gated instead of just recommended. Section-by-section summary:
- Multi-tier indexing — 13 languages with full call graphs by default, 11 more parsed behind opt-in grammar features, 24 in total.
- A call graph you can actually trust — every edge is labeled by confidence (
resolved/inferred/formal/textual); SCIP and LSP overlays can upgrade edges to compiler-grade ground truth across 12 supported integrations when their providers/toolchains are available; unavailable providers sit out. - Search that actually finds things — FTS5 + semantic embeddings fused via Reciprocal Rank Fusion, plus real grep/glob straight off disk for files the indexer never parses.
- Editing with an actual safety net — hash-verified writes, syntax validation before anything touches disk, and a three-part gate (fresh
edit_context,confirm:true, a groundedreason) on hub/high-risk symbols. - Concurrency & reliability — a shared daemon, cross-process edit lock, and single-instance indexing lock mean multiple editor sessions on one repo don't corrupt or duplicate work.
- The codebase grading itself — 11 fitness metrics, coverage-aware dead-code detection, declared architecture boundaries, doc-drift detection.
- An agent that remembers, and knows when it's stuck — durable cross-session notes, git co-change mining, a stuck-loop signal.
- Safe by default — credential-shaped content is redacted in
source/understand, prompt-injection-shaped content is flagged, andscan_textcovers external text; local-first by default with an explicit embedding fallback.
Crate layout
crates/calm-core/— the index engine:tree-sitterparsing, SQLite schema, the multi-tier resolver (conservative → inferred → formal/Stack-Graphs, SCIP, or LSP), graph algorithms (coreness, hub detection), FTS5/semantic search, analysis (hotspots, coverage, codeowners, diff-impact, dead-code), fitness metrics, gitignore management.crates/calm-server/— the MCP server (rmcpover stdio or a unix-socket daemon), exposing 40 tools plus the incremental file watcher.crates/calm-cli/— the CLI:calm init,calm index,calm serve,calm connect,calm setup,calm fitness-check,calm guard,calm doctor.
CLI reference
calm init --project-root . # writes .calm/config.json with defaults
calm index --project-root . # one-shot full index (Scanning → Parsing → BuildingEdges → Ready)
# also embeds symbols+chunks if semantic_search.enabled=true
calm serve --project-root . # MCP server over stdio + incremental reindex + file watcher
calm serve --project-root . --listen unix:/path/to/daemon.sock # run as a shared daemon (opt-in)
calm connect --project-root . # lightweight forwarder to an already-running daemon (opt-in, Unix)
calm serve --project-root /project --db-path /data/index.db # separate DB path (container deployment)
calm serve --project-root . --preset orient # register only the "orient" phase's tools
calm doctor --project-root . # validates config, DB (symbols/files/metrics history), git
calm setup --project-root . # writes/merges MCP config (.mcp.json/.cursor/.vscode) pointing at this binary
calm fitness-check --project-root . # CI gate, exits 1 on failure
calm fitness-check --project-root . --json # JSON output
calm fitness-check --project-root . --config thresholds.toml # custom thresholds
calm guard --project-root . # pre-commit/CI gate on the staged diff, exits 1 if aggregate risk >= --fail-on (default: high)
calm guard --project-root . --fail-on medium --json # stricter threshold, machine-readable output
calm guard --project-root . --base origin/main # review this branch/PR against a base ref instead of the staged diff
calm guard --project-root . --commits HEAD~3..HEAD # raw commit range, passed straight through to git diff
calm value-report --project-root . # real counts from .calm/audit.log: risky edits blocked, risk distribution on what was applied
calm value-report --project-root . --json # machine-readable output
calm scip-run --project-root . --lang go # force one SCIP provider to run now, bypassing refresh policy
calm scip-run --project-root . # --lang omitted = run every provider ("rust,go,python,javascript,java,csharp,php,ruby,c")
calm index --project-root . --scip-file build/index.scip --sub-root services/api # ingest a pre-built SCIP index (CI/sandboxed, no external indexer install needed)
CALM MCP Fragen
Wie füge ich CALM MCP zu Claude Code hinzu?
Führe claude mcp add calm -- npx -y @eilodon/calm-mcp in deinem Terminal aus. Füge --scope user hinzu, damit der Server in jedem Projekt verfügbar ist.
Wie füge ich CALM MCP zu Cursor hinzu?
Öffne ~/.cursor/mcp.json und füge den Server unter mcpServers hinzu, mit der Cursor-Config aus dem Installationsabschnitt oben.
Welche Tools bietet CALM MCP?
Er stellt 5 Tools bereit, darunter review_symbol, debug_symbol, onboard_area, review_pr, calm_workflow.
Welche Sprachen unterstützt CALM?
CALM parst insgesamt 24 Sprachen, wobei 13 Sprachen wie Python, TypeScript, JavaScript, Java, Rust und Go direkt Call Graphs unterstützen.
Wie stellt CALM die Edit-Sicherheit sicher?
Jeder Schreibvorgang wird per Hash gegen den exakten Zeilenbereich verifiziert und auf Syntax geprüft. Bei High-Risk-Symbolen muss der Agent die Caller prüfen, bevor eine Änderung erlaubt wird.
Verlässt mein Code während des Indexing meine Maschine?
Nein, CALM ist Local-first; kein Code verlässt deine Maschine für das Indexing, die Suche oder das Editieren.