The MCP server provides “code graph” integration for AI agents, with coverage across 81 languages and 87 frameworks. The repository emphasizes token reduction, citing “90.6% fewer PR-review tokens,” alongside code-intelligence and knowledge-graph concepts.
🛠️ Key Features
Code graph for AI agents
81 languages supported
87 frameworks supported
Token reduction: 90.6% fewer PR-review tokens
Topics include knowledge-graph, rag, code-graph, and dependency-graph
🚀 Use Cases
Code intelligence for agents operating over code graphs
Knowledge-graph and RAG-based workflows
Dependency-graph and static-analysis related development tooling
⚡ Developer Benefits
Reduced PR-review token usage (90.6%)
Developer-focused tooling themes: developer-tools, mcp, and mcp-server
⚠️ Limitations
README excerpt only includes build/banner rendering notes; no further behavioral limits are stated in provided data.
WORKS WITH · Claude Code · Cursor · Codex · Windsurf · Zed · any MCP client
trace-mcp indexes what your agent keeps re-reading, and serves the answer instead. 72.7% fewer input tokens to review a pull request — median over 60 merged pull requests in open-source repos we don't own.
We change configuration you could change yourself. We do not patch your client's binary, intercept its traffic, or rewrite its files.
bash
npm install -g trace-mcp # MCP server, no app
trace init # wire it into your agent, once per machine
trace add # index the repo you are in
72.7% fewer input tokens to review a pull request — median over 60 merged PRs in six repos that are not ours, 13,595 → 3,291 per pull request. Method and reproduction →
Measured at trace-mcp 3.23.2 (cb8ab30c) on 7 September 2026 — a result from that build, not a claim about the current one. What it set out to measure, the bar it had to clear and the verdict: preregistration.
Cheaper is not the same as better, so the same 60 pull requests were reviewed twice and scored blind. The trace-mcp arm understood the change in 67% of them against 65% for naive file loading, at 0.80 false positives per PR against 0.58. Quality half of the benchmark →
The desktop app: a GPU graph explorer over the same index the MCP server serves.
The problem
AI agents pay repeatedly for work they have already done. Every turn, the agent re-reads the same files, re-traverses the same dependencies, and re-inflates the context window with structure it discovered five steps ago. That repeated work is most of what a long session costs in tokens and latency.
trace-mcp builds a framework-aware graph of your codebase once, then serves it through MCP so the agent reasons from a precomputed structure instead of brute-reading the repo. Ask "what breaks if I change this model?" — instead of 80 Grep calls and 190 file reads, the agent calls get_change_impact once and gets the blast radius across PHP, Vue, migrations, and DI. 88 framework integrations across 81 languages, 182 tools.
The binding constraint is recomputation, not model capability: token bills, latency, and hallucinations all grow with project size instead of with task complexity. trace-mcp closes the recomputation leak. The graph is built once, kept incrementally fresh, and served to every agent that asks — so the same work isn't paid for over and over.
Lower cost — fewer tokens per successful answer, on average and at peak
Lower latency — fewer sequential tool calls, fewer round-trips to the model
Higher accuracy — less noise in context means fewer hallucinations and stronger first-response correctness
Production stability — context growth tracks task complexity rather than repository size
We started with code intelligence, where the repetition is most expensive, and the same engine now indexes markdown knowledge vaults (Obsidian, Logseq, plain MD) as a peer domain. Wikilinks, tags, frontmatter, and embeds become graph edges and symbol metadata; search, find_usages, get_change_impact, and apply_rename work identically over both.
What trace-mcp does for you
You ask
trace-mcp answers
How
"What breaks if I change this model?"
Blast radius across languages + risk score + linked architectural decisions
The actual decision record with reasoning and tradeoffs
query_decisions — searches the decision knowledge graph linked to code
"I'm starting a new task"
Optimal code subgraph + relevant past decisions + dead-end warnings
plan_turn — opening-move router with decision enrichment
"What did we discuss about GraphQL last month?"
Verbatim conversation fragments with file references
search_sessions — FTS5 search across all past session content
"Show me the request flow from URL to rendered page"
Route → Middleware → Controller → Service → View with prop mapping
get_request_flow — framework-aware edge traversal
"Find all untested code in this module"
Symbols classified as "unreached" or "imported but never called in tests"
get_untested_symbols — test-to-source mapping
"What's the impact of this API change on other services?"
Cross-subproject client calls with confidence scores
get_subproject_impact — topology graph traversal
"What notes link to this concept?"
Backlinks across the vault, with section + alias context
find_usages on a note:<basename> symbol
"What breaks if I rename this note?"
Every [[wikilink]] and [text](path.md) that references it
get_change_impact — wikilink-aware reverse graph
Four capabilities that are rare among adjacent tools:
Framework-aware edges — trace-mcp understands that Inertia::render('Users/Show') connects PHP to Vue, that @Injectable() creates a DI dependency, that $user->posts() means a posts table from migrations. 88 framework integrations.
Code-linked decision memory — when you record "chose PostgreSQL for JSONB support", it's linked to src/db/connection.ts::Pool#class. When someone runs get_change_impact on that symbol, they see the decision. MemPalace stores decisions as text; trace-mcp ties them to the dependency graph.
Cross-session intelligence — past sessions are mined for decisions and indexed for search. When you start a new session, get_wake_up gives you orientation in ~300 tokens; plan_turn shows relevant past decisions for your task; get_wake_up { scope: "resume" } carries over structural context from previous sessions.
Code and knowledge in one graph — point trace-mcp at a markdown vault (Obsidian, Logseq, plain MD) and the same engine indexes it: each note becomes a note:<basename> symbol, headings become nested sections, [[wikilinks]] and ![[embeds]] become graph edges, frontmatter and #tags ride on metadata. PageRank, Signal Fusion ranking, embeddings, and rename refactoring all apply unchanged. The agent does not learn a second tool: it is the same graph, holding both the codebase and the notes.
Why agents keep re-reading
AI coding agents recompute the same work every turn — and they're framework-blind while doing it.
They re-read UserController.php, then re-read it again next turn. They don't know that Inertia::render('Users/Show', $data) connects a Laravel controller to resources/js/Pages/Users/Show.vue. They don't know that $user->posts() means the posts table defined three migrations ago. They can't trace a request from URL to rendered pixel — so they trace it again, and again, every session.
The result: 5–15× repeated reads of hot files in a single task, context windows used as scratch databases, and agents that get more expensive the bigger the project gets — instead of more capable.
The solution
trace-mcp builds a cross-language dependency graph from your source code and exposes it through the Model Context Protocol — the plugin format Claude Code, Cursor, Windsurf and other AI coding agents speak. Any MCP-compatible agent gets framework-level understanding out of the box.
Without trace-mcp
With trace-mcp
Agent reads 15 files to understand a feature
get_task_context — optimal code subgraph in one shot
Agent doesn't know which Vue page a controller renders
routes_to → renders_component → uses_prop edges
"What breaks if I change this model?" — agent guesses
get_change_impact traverses reverse dependencies across languages
Schema? Agent needs a running database
Migrations parsed — schema reconstructed from code
Prop mismatch between PHP and Vue? Discovered in production
Detected at index time — PHP data vs. defineProps
Desktop app
trace-mcp ships with an optional Electron desktop app (packages/app) that gives you a visual surface over the same index the MCP server uses. It manages multiple projects, wires up MCP clients, and provides a GPU-accelerated graph explorer — all without opening a terminal.
Projects & clients. The menu window lists indexed projects with live status (Ready / indexing / error) and re-index / remove controls. The MCP Clients tab detects installed clients (Claude Code, Claw Code, Claude Desktop, Cursor, Windsurf, Continue, Junie, JetBrains AI, Codex, AMP, Warp, Factory Droid) and wires trace-mcp into them with one click, including enforcement level (Base / Standard / Max — CLAUDE.md only, + hooks, + tweakcc & agent-behavior rules; Max-tier features are Claude Code–specific). Warp and JetBrains AI require manual paste in the IDE because their config storage is GUI-only.
Per-project overview. Each project opens in its own tabbed window: Overview (files, symbols, edges, coverage, linked services, re-index), Ask (natural-language query over the index), and Graph. Overview also surfaces Most Symbols files, last-indexed timestamp, and the dependency coverage meter.
GPU graph explorer. The Graph tab renders the full dependency graph on the GPU via cosmos.gl — tens of thousands of nodes/edges at interactive frame rates. Filter by Files / Symbols, overlay detected communities, highlight groups, toggle labels/FPS, and step through graph depth. Good for getting a feel for coupling, hotspots, and how a codebase is actually shaped before you dive into tools.
Install on macOS:Download the .dmg — open it and drag trace-mcp to Applications. The button on the site picks Apple Silicon or Intel for you; if you would rather choose yourself, both builds are on the Releases page. The app is signed with a Developer ID and notarized by Apple, so it opens without a warning — if macOS ever does warn you about a trace-mcp build, that warning is real and the download should not be trusted.
Install on Windows: run trace-mcp.Setup.<version>.exe from Releases.
In-app updater stuck on an old build? App versions 3.10.0 and earlier on macOS/Windows can't update themselves — "Check for updates…" shows Cannot set properties of undefined (setting 'autoDownload') and does nothing, a bug fixed in 3.11.0 that the affected builds can't fetch their own way out of. Reinstall by hand: download the .dmg (macOS) or grab the latest trace-mcp.Setup.<version>.exe from Releases (Windows) — or, if you have the CLI installed, run trace-mcp install-app.
The app talks to the same trace-mcp daemon (http://127.0.0.1:3741) that MCP clients use, so anything you index from the app is immediately available to Claude Code / Cursor / etc. If you only want the MCP server and the CLI, you do not need the app at all — npm install -g trace-mcp is the whole install.
How trace-mcp compares
trace-mcp combines code graph navigation, cross-session memory, and real-time code understanding in a single tool. Most adjacent projects solve one of these — trace-mcp unifies all three and is the only one with framework-aware cross-language edges (88 framework integrations) and code-linked decision memory.
vs. token-efficient exploration (Repomix, jCodeMunch, cymbal) — trace-mcp adds framework edges, refactoring, security, and subprojects on top of symbol lookup.
vs. session-memory tools (MemPalace, claude-mem, ConPort) — trace-mcp links decisions to specific symbols/files, so they surface automatically in impact analysis.
vs. RAG / doc-gen (DeepContext, smart-coding-mcp) — trace-mcp answers "show me the execution path, deps, and tests," not "find code similar to this query."
vs. code-graph MCP servers (Serena, Roam-Code) — trace-mcp has the broadest language coverage (81 languages) and is the only one with cross-language framework edges.
AI agents burn tokens recomputing what they already discovered last turn — re-reading files, re-traversing dependencies, re-inflating context. trace-mcp replaces that with precision context: only the symbols, edges, and signatures relevant to the query, served from a graph that was computed once.
Start with the measurement that isn't ours. Everything else in this section is trace-mcp measured on trace-mcp's own repository — the first table row against real responses, everything below it by trace-mcp's own synthetic estimators. The PR review context benchmark is the exception: assembling review context for 60 merged pull requests across six open-source repositories — hono, axios, express, requests, flask, got — cost a median 3,291 input tokens against 13,595 for loading the diff plus every file it touches, 72.7% less, counted with gpt-tokenizer rather than estimated. The base and head SHAs are pinned in benchmarks/pr-context/dataset.json, npx tsx scripts/bench-pr-context.ts re-runs it, and the 56 pull requests where the index did not pay off are published alongside the wins — 13 that cost more than reading the files outright, and 42 where the bundle's token budget did not deliver every changed symbol's body, a shortfall the benchmark could not see until this run made it score delivery rather than listing.
What to expect — by workload:
Workload
Typical reduction
Mixed real-world production (measured tool responses vs. the file reads they replace)
up to 99% less redundant processing — synthetic estimate
Targeted research / planning queries (composite tasks that replace ~10 sequential operations)
up to ~40× on individual calls — synthetic estimate
Non-code workloads (raw text, unstructured data)
Out of scope today
The 68% is the honest number to plan against, and the reason it moved is not that the product got faster. We used to print "~40–50% on average". That figure descended from a counter that scored each call before the tool ran — RAW_COST_ESTIMATES[tool] × 0.15, a constant with no variance — which we found and fixed ourselves in #915. The honest replacements read 29.3%, then 21.1%, then 21.0% as coverage grew to 97.2% of recorded calls. Then we found that three tools carrying 76% of the weight were each priced from one sample, and that four defensible ways of choosing those samples price the same build at 21.0%, 30.7%, 56.0% and 67.4%. So the sampling frame is now generated, frozen and committed before the run that uses it, with every claim about how it was built re-checked against the repository in CI (preregistration). 68% is what the registered frame measures; read the jump from 21% as a change of frame, not a change of product. It weights real o200k_base counts of real responses by 18,329 recorded calls from one machine (per-tool table, generated into docs/_data/response_tokens.json). Three caveats travel with it: the baseline half — what a Read/Grep would have cost instead — is still a hand-written estimate; five of the twenty-three tools measured return more tokens than they replace, and the old counter booked a saving for them anyway; and two more tools (register_edit, reindex) replace no file read at all, so they are now credited zero and counted as overhead — with them on the spend side the all-in figure is 67%. The peaks below (up to 99% on individual structured calls) are a synthetic estimate, per-call, not per-session.
Measured at trace-mcp 3.23.2 (fd3cafc6) on 8 September 2026. Its preregistration publishes it as the first pass of the 25% bar we declared before measuring — and says in the same breath that the pass came from registering a sampling frame, not from shipping a faster product. The prediction written before that run named an interval the result landed above; it was wrong and it stays on the page.
Benchmark: trace-mcp's own codebase (694 files, 3,831 symbols → 929 files, 5,197 symbols in v1.30):
Across 11 structured task categories, recomputation drops by up to ~99% per call when the agent reuses the graph instead of re-reading files. Read that as a peak structured-task result on a well-supported TS/Vue codebase, not a number you should expect on every project. In production, on mixed workloads, expect 68% — the measured figure above, not this synthetic one. Less noise in context also means fewer hallucinations and better first-response accuracy — a quality benefit you don't see in token counts.
Savings scale with project size — argued, not measured. Without trace-mcp the agent reads more wrong files before finding the right one, while graph traversal stays O(relevant edges) rather than O(total files). We have no per-project-size measurement to put behind that, so this README no longer quotes one; the per-session token figure that used to sit here came from the same pre-#915 estimator as the "40–50%".
Composite tasks deliver the biggest wins. A single get_task_context call replaces a chain of ~10 sequential operations (search → get_symbol × 5 → Read × 3 → Grep × 2). That's one round-trip instead of ten, which is where most of the latency saving comes from.
Run it yourself
bash
npx trace-mcp benchmark .
Per-category token savings against your actual repo in ~5 minutes — no install, no signup, all local. It reads an existing index, so run trace-mcp index . first if the project isn't registered yet. Numbers above are from trace-mcp's own TypeScript/Vue codebase (929 files, 5,197 symbols) under structured benchmarks; production reduction on mixed workloads is lower (68% measured, see above), but the per-task patterns hold for any well-supported stack.
This is a synthetic estimate, not measured savings: the "without trace-mcp" side is computed from file sizes in the index, and the "with trace-mcp" side from per-scenario multipliers — not from actual tool calls. It shows the theoretical ceiling. To measure real savings from your own usage, run trace-mcp for a while, then:
bash
trace-mcp analytics savings # real sessions: reads vs. what trace-mcp would have cost
trace-mcp analytics optimize # recommendations based on your actual usage
Estimated using benchmark_project — it walks eleven task categories (symbol lookup, file exploration, text search, find usages, context bundle, batch overhead, impact analysis, call graph traversal, type hierarchy, tests-for, composite task context) over the indexed project. No trace-mcp tool is invoked. Every figure on both sides is a scenario-specific synthetic heuristic, and the heuristics differ per scenario. They draw on three kinds of input, mixed differently in each one:
Real values from the index — file byte_length, symbol source and signature sizes. These carry the baseline for symbol lookup, file exploration, impact analysis and call graph traversal.
Assumed result shapes for operations with no indexed equivalent — e.g. text search and find-usages baselines assume a fixed grep yield (matches × context lines × 80 chars), get_tests_for is assumed to answer in ~400 characters, and the batch-overhead scenario adds fixed per-call MCP framing / hint / metadata token constants.
A fixed fraction of the baseline, between 0.05 and 0.45, where neither of the above applies.
Character counts are converted to tokens by an estimator calibrated against cl100k_base when gpt-tokenizer is installed, and by a fixed chars-per-token ratio of 4.0 otherwise. The result is an upper bound on the reduction, not a measurement of it — the same caveats are printed in the tool output and documented at the top of src/analytics/benchmark.ts.
Reproduce it yourself:
code
# Via CLI (no install)
npx trace-mcp benchmark /path/to/project
# Or via MCP tool
benchmark_project # runs against the current project
Change impact analysis — reverse dependency traversal across languages, enriched with linked architectural decisions
Graph-aware task context — describe a dev task → get the optimal code subgraph (execution paths, tests, types) + relevant past decisions, adapted to bugfix/feature/refactor intent
Call graph & DI tree — bidirectional call graphs with 4-tier resolution confidence, optional LSP enrichment for compiler-grade accuracy, NestJS dependency injection
ORM model context — relationships, schema, metadata for 7 ORMs
Dead code & test gap detection — find untested exports/symbols (with "unreached" vs "imported_not_called" classification), dead code, per-symbol test reach in impact analysis
Security scanning — OWASP Top-10 pattern scanning and taint analysis (source→sink data flow). Exportable MCP-server security context for skill-scan
Semantic search, offline by default — bundled ONNX embeddings work out of the box, no API keys; switch to Ollama/OpenAI for LLM-powered summarisation
Decision memory — mine sessions for decisions, link them to symbols/files, auto-surface in impact analysis
Multi-service subprojects — link graphs across services via API contracts; cross-service impact + service-scoped decisions
CI/PR change impact reports — automated blast radius, risk scoring, test-gap detection, architecture violations on every PR
Knowledge vaults: Obsidian, Logseq, plain markdown — [[wikilinks]], ![[embeds]], [text](path.md), frontmatter (YAML), #tags, ATX headings. Each note becomes a note:<basename> symbol with sections nested inside; wikilinks resolve to references / embeds edges between notes. Mix vault and code in one project — point root at a directory that contains both and run a single find_usages across them.
See your waste first — 5 minutes, no setup, no signup:
bash
npx trace-mcp benchmark .
Indexes the project, runs 11 structured task benchmarks (symbol lookup, impact analysis, call graph, type hierarchy, …), and prints estimated per-task token cost — without trace vs. with. You'll see exactly where your agent recomputes work it could reuse. It is a synthetic estimate computed from your index, not a record of real tool calls (see the Methodology block under “Token reduction” above); for measured savings from your own sessions use trace-mcp analytics savings.
Then wire it into your AI agent:
bash
npm install -g trace-mcp
trace init # one-time global setup (MCP clients, hooks, CLAUDE.md)
trace add # register current project for indexing
init — configures your MCP client (Claude Code, Cursor, Windsurf, Claude Desktop, …), installs the guard hook, adds routing rules to ~/.claude/CLAUDE.md.
add — detects frameworks, creates the per-project index, registers the project. Re-run in every project you want trace to understand.
(The npm package is still called trace-mcp — only the command it installs is shortened. trace-mcp init, trace-mcp add, and every other trace-mcp … invocation keep working.)
All state lives in ~/.trace/ (with automatic fallback from ~/.trace-mcp/) — your project directory stays clean unless you opt into .traceignore or .trace/.config.json.
Using Claude Code or Codex CLI? After npm install -g trace-mcp, skip trace init's client-wiring step and install the plugin directly instead — no git clone needed either way:
bash
# Claude Code
claude plugin install @nikolai-vysotskyi/trace-mcp
# Codex CLI
codex plugin marketplace add nikolai-vysotskyi/trace-mcp
codex plugin install trace-mcp@nikolai-vysotskyi-trace-mcp
> get_project_map to see what frameworks are detected
> get_task_context("fix the login bug") to get full execution context for a task
> get_change_impact on app/Models/User.php to see what depends on it
Indexing a markdown vault (Obsidian / Logseq / plain MD). Point trace add at the vault root — .md/.mdx/.markdown are picked up by default. Each note becomes a note:<basename> symbol, headings nest as sections, [[wikilinks]] and ![[embeds]] resolve to graph edges, frontmatter aliases: make alternate names resolvable, and #tags aggregate so every note carrying #sgr is one find_usages away.
code
> find_usages on note:my-concept // backlinks across the vault
> find_usages on tag:sgr // every note tagged #sgr
> get_change_impact on note:legacy // what breaks if I rename or delete it
> search "schema-guided reasoning" // PageRank + embeddings over the vault
Prefer a GUI? The desktop app handles install, indexing, MCP-client wiring, and re-indexing without touching a terminal.
The project is still trace-mcp. The command is now trace. The rename lives at exactly that boundary and nowhere else — the npm package, this repo, the domain, and the registry entry all keep the trace-mcp name. The reason is ergonomics, the same shape as rg for ripgrep or kubectl for kubernetes — not token savings: the measured saving from the shorter MCP tool prefix is real but small, 66–366 tokens per turn depending on tokenizer and preset, 0.74–1.23% of a tool list that already costs 8k–45k tokens.
The npm package name does not change. It is still trace-mcp, and it always will be — trace on npm is an unrelated package by another author. Install with npm install -g trace-mcp or npx -y trace-mcp@latest.
What does change, and what stays:
Command name — trace <cmd> is the new spelling. trace-mcp <cmd> stays as an alias permanently — on macOS, /usr/bin/trace is Apple's own trace(1), so keep using trace-mcp in scripts, CI, or any PATH you don't control yourself.
MCP client entries — trace init and trace upgrade rename an existing mcpServers["trace-mcp"] entry to mcpServers["trace"] and point it at the new command. Nothing is deleted; an entry left as trace-mcp keeps working, it just costs more tokens.
State directory — ~/.trace/, falling back to ~/.trace-mcp/ when the old one exists and the new one does not. Indexes are not rebuilt.
Project config — .trace.json is read first, .trace-mcp.json after it. Existing files keep working where they are.
Plugin and registry identifiers — unchanged: @nikolai-vysotskyi/trace-mcp for the Claude Code plugin, io.github.nikolai-vysotskyi/trace-mcp in the MCP registry.
One thing init can't do for you. The MCP tool prefix moves too — mcp__trace-mcp__search becomes mcp__trace__search. init migrates the mcpServers entry it owns, but not text you wrote yourself: Claude Code permission allowlists, hook matchers, or your own mcp__trace-mcp__* mentions in CLAUDE.md/AGENTS.md prose. If a hook stops matching or an allowlisted tool starts re-prompting after upgrading, grep your own config for mcp__trace-mcp__ and replace it with mcp__trace__. Everything else above happens automatically the next time you run trace init or trace upgrade — details: Configuration.
Local-first by design
trace-mcp runs entirely on your machine. Nothing about your source code is uploaded, and there is no account to create.
Indexing happens locally. The MCP server is a Node process you run yourself — stdio or http://127.0.0.1:3741.
Index lives in ~/.trace/ (falling back to ~/.trace-mcp/ if that's what you already have), never inside your project and never uploaded. Your repo directory stays clean unless you opt into .traceignore or .trace/.config.json.
Semantic search is offline by default — bundled ONNX embeddings, no API keys, no outbound calls. Switch to Ollama (local) or OpenAI (opt-in) via config.
No telemetry about your code, queries, or usage. The only thing that ever leaves your machine is described below and on the privacy page — nothing else is phoned home.
What your AI client sees is governed by your AI client. trace-mcp returns graph results over MCP; how Claude Code / Cursor / Codex / Windsurf forward them to a model is up to that client's privacy model.
The daemon trusts loopback and nothing else.serve-http is unauthenticated by design: a caller on 127.0.0.1 is already you. A non-loopback --host is therefore refused unless you pass --allow-remote and front the port with your own auth — see Configuration.
To wipe everything, delete ~/.trace/ (or ~/.trace-mcp/ on an install that hasn't migrated yet) — that directory is the whole footprint.
Usage telemetry
trace-mcp sends at most one anonymous ping per day, per install, so we can count active installs: version, OS, MCP client, and aggregate counts. No code, no paths, no IP address, and no per-install identifier beyond a UUID generated locally on your machine. It is suppressed in CI, and its GA4 credentials ship as plaintext in the published bundle so you can verify where the ping goes.
Turn it off with TRACE_MCP_TELEMETRY=off, or with "telemetry": { "usage_ping": false } in ~/.trace/.config.json.
For security-sensitive environments, review SECURITY.md before use.
Getting the most out of trace-mcp
trace-mcp works on three levels to make AI agents use its tools instead of raw file reading:
Level 1: Automatic (works out of the box)
The MCP server provides instructions and tool descriptions with routing hints that tell AI agents when to prefer trace-mcp over native Read/Grep/Glob. This works with any MCP-compatible client — no configuration needed.
Level 2: CLAUDE.md (recommended)
trace-mcp init adds a Code Navigation Policy block to ~/.claude/CLAUDE.md (or your project's CLAUDE.md) that tells the agent which trace-mcp tool to prefer over Read/Grep/Glob for each kind of task. If you skipped init, see System prompt routing for the full block and how to tune enforcement.
Level 3: Hook enforcement (Claude Code only)
For hard enforcement, trace-mcp init installs a PreToolUse guard hook that blocks Read/Grep/Glob on source files and redirects the agent to trace-mcp tools (non-code files, Read-before-Edit, and safe Bash commands pass through). Manage manually with trace-mcp setup-hooks --global / --uninstall. Details: System prompt routing.
Level 4: Max tier — system prompt rewrites + agent behavior rules
Picking Max during trace-mcp init (the default) layers on two more amplifiers:
tweakcc system-prompt rewrites patch Claude Code's core tool descriptions so the model internalizes "use trace-mcp search" instead of "use Grep" from the start. Claude Code only.
agent_behavior: "strict" ships a compact set of discipline rules via MCP instructions — no flattery, disagree on wrong premises, never fabricate, goal-driven execution, 2-strike session hygiene, no drive-by refactors. Cross-client (Claude Code, Cursor, Codex, Windsurf) and auto-updates on npm upgrade trace-mcp without re-running init.
This is the setup for making the same discipline rules apply to every teammate's agent without asking anyone to configure it. Tune or disable via tools.agent_behavior in ~/.trace/.config.json — see Tool exposure & agent behavior.
Decision memory
Decisions, tradeoffs, and discoveries from AI-agent conversations usually vanish when the session ends. trace-mcp captures them and links each decision to the code it's about — so when someone later runs get_change_impact on src/db/connection.ts::Pool#class, the "we chose PostgreSQL for JSONB" decision surfaces automatically.
Mine — mine_sessions scans Claude Code / Claw Code JSONL logs and extracts decisions via pattern matching (0 LLM calls). Types: architecture, tech choice, bug root cause, tradeoff, convention.
Link — each decision attaches to a symbol or file; supports service-scoped decisions for subprojects.
Surface — decisions auto-enrich get_change_impact, plan_turn, and get_wake_up. Temporal validity (valid_from/valid_until) makes "what was true on 2025-01-15?" queries possible.
Search — query_decisions (FTS5 + filters) for decisions; search_sessions for raw conversation content across all past sessions.
bash
trace memory mine # extract decisions from sessions
trace memory search "GraphQL migration"# search past conversations
trace memory timeline --file src/auth.ts # decision history for a file
Full tool list, CLI, temporal validity, service scoping: Decision memory.
Subprojects
A subproject is any repo in your project's ecosystem — microservice, frontend, shared lib, CLI tool. trace links dependency graphs across subprojects: if service A calls an endpoint in service B, changing the endpoint in B shows up as a breaking change for A.
Discovery is automatic. On each index, trace detects subprojects (Docker Compose, flat/grouped workspaces, monolith fallback), parses API contracts (OpenAPI, GraphQL SDL, Protobuf/gRPC), scans code for HTTP client calls (fetch, axios, Http::, requests, http.Get, gRPC stubs, GraphQL ops), and links the calls to known endpoints.
bash
cd ~/projects/my-app && trace add
# → auto-detects user-service (openapi.yaml) and order-service# → links order-service → user-service via /api/users/{id}
trace subproject impact --endpoint=/api/users
# → [order-service] src/services/user-client.ts:42 (axios, confidence: 85%)
External subprojects can be added manually with trace subproject add --repo=... --project=.... MCP tools: get_subproject_graph, get_subproject_impact, get_subproject_clients, subproject_add_repo, subproject_sync.
trace ci-report --base main --head HEAD produces a markdown or JSON report per pull request: summary, blast radius (depth-2 reverse dep traversal), test coverage gaps (per-symbol hasTestReach), risk analysis (30% complexity + 25% churn + 25% coupling + 20% blast radius), architecture violations (auto-detects clean / hexagonal presets), and new dead exports.
Use --fail-on high to block merges on high-risk changes. See .github/workflows/ci.yml for a ready-to-use GitHub Action that runs build → test → impact-report and posts a sticky PR comment on every push.
Pilot program — for teams running LLM in production
If you're shipping AI features in production — internal copilots, customer-facing assistants, RAG over a code or knowledge base — and you're hitting cost, latency, or quality ceilings, we'll run a focused pilot with you.
Format: 2–4 weeks. Minimal integration. One or two real production use cases — not a demo.
What we measure (before / after):
Tokens per successful answer
First-response accuracy (% of queries resolved without retry)
Retries and fallback calls
End-to-end latency
User success rate on a fixed evaluation set
What you get: a clear, before/after report on whether context optimization moves the metrics that matter for your stack — and a path to scale usage with confidence instead of throttling it on cost.
The target is a system that stays predictable as usage grows, not a one-off cost cut: teams usually want to reach reliable production first and expand their LLM footprint after.
Incremental by default — files are content-hashed; unchanged files are skipped on re-index.
Plugin architecture — language plugins (symbol extraction) and integration plugins (semantic edges) are loaded based on project detection, organized into categories: framework, ORM, view, API, validation, state, realtime, testing, tooling.
