ripwire MCP server
Commit Nov 16, 2026Provides a deterministic call graph and quality gates to help AI coding agents navigate repositories and verify code changes.
Also known as redhat-et/ripwire
- Stars
- 2,545
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 16, 2026
- License
- Apache-2.0
What is ripwire MCP?
ripwire provides a deterministic call graph and quality gates to help AI coding agents navigate repositories and verify code changes.
Summary generated from the project's README
About ripwire MCP server
Providing a deterministic call graph and quality gates for AI coding agents is what ripwire does to help navigate repositories and verify changes. It functions as a local tool that indexes codebases rapidly without requiring API keys, embeddings, index servers, or daemons. Developers can activate its capabilities by simply telling an agent to use it on a specific repository.
This tool helps reduce token consumption by providing ranked-signature task orientation and granular document recall instead of raw file dumps. It includes specific commands like --callers for finding callers, --edit-check to verify public-symbol changes and contract compatibility, and --quality-delta to report on code quality regressions. It supports a wide range of languages including C++, Rust, Python, Go, TypeScript, and many others.
Unlike traditional graph-database MCP servers, ripwire operates as a single offline binary. It is designed to be lightweight, using significantly less CPU and memory during warm runs on large repositories. It serves as a mechanical gate for code hygiene, helping agents identify duplicated routines, incompatible call sites, and forgotten co-changes during the development process.
What you can do with it
- 1Reduce research token costsAn agent can use ranked-signature orientation and granular document recall to avoid reading entire files.
- 2Verify code change compatibilityDevelopers can use the edit-check command to ensure refactors do not break existing call sites.
- 3Enforce code quality standardsAgents can use quality gates to catch duplicated routines or near-identical functions before finishing a task.
Written from the project's README. Every use case is checked against a quote from it.
Configuration
LSAN_OPTIONSRIPWIRE_REPO
Automated checks
Ran Nov 12, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablePass
- Open source license (OSI)Pass
- Commit or release in the last yearPass
- Package name not close to a popular packageNot checked
- Remote endpoint uses HTTPSNot checked
- Destructive tools are labelledNot checked
- No hidden instructions to the modelPass
- No critical advisory in the package or its dependenciesNot checked
README
View on GitHubRip'n Fast. Fewer Tokens. Better Code.
The ripgrep of AI context. A map before your agent reads the repo — and a check on what it writes.
Ranked, deterministic call graph: what to touch, what it breaks, which tests to run. On the edit: blast radius, tests that reach it, twelve quality kinds reporting only what got worse, forgotten co-changes, fields read and written, names that resolve more than one way.
Just want to use it? Install it with the one line below, then start each coding session by telling your agent to use it, for example: "Use ripwire on this repo." That is all most people need: the install also teaches your agent when to reach for each command.
Want every detail? The reference guide near the bottom covers install, commands, output format, exit codes and limits. You do not need it to get started.
For a single developer, this tool is a good lookup accelerator. For an orchestrated fleet, it's load-bearing: it halved the research spend, twice redirected tasks before wasted work, prevented at least one silent-divergence shipped bug, and turned code-quality hygiene from a hope into a per-task mechanical gate. Whole-workflow ~2×; per-lookup 10–25×; and two moments where one call was worth more than the rest of the session's tooling combined.
— the report's bottom line
Field report: what ripwire contributed to a large multi-agent coding engagement
Context, genericized: one orchestrating session directing ~20 sequential/parallel coding agents over a ~1,500-file C++/Metal codebase across two days — a deep architecture audit, then a 14-task feature wave (new subsystems, measurement infrastructure, a search-archive migration), ending in a verified all-on release flip. Every agent was instructed to lead with ripwire for orientation and to close with its quality gates.
The headline numbers
- Roughly half the total token spend of the audit/research phase, saved. This is the operator's whole-phase estimate — it includes everything the research agents did, ordinary file reads and all, which makes it conservative rather than cherry-picked. The per-call factors underneath are much steeper: a single doc-recall call served the relevant sections of a 164KB planning document in ~6K tokens (~25×), and agents that led with the tool ran ~30–40% leaner on tool-call counts than agents doing raw read fan-outs over comparable questions.
- Two tasks had their direction changed by a single call. One task was chartered to activate a steering behavior
the team believed was in production; one
--callersquery returned zero production callers, redirecting the task to the real gap (the data provider that behavior needed had never been wired anywhere). Another task refactored a widely-shared computation;--edit-checkflagged 5 of 6 call sites as incompatible — sites a text search had missed — that would otherwise have silently diverged from the canonical path the day the feature was enabled, surfacing months later as an unexplainable visual bug. - A dozen-plus real code-quality defects fixed, not waived, across ~15 implementing agents — all caught by
--quality-deltaat each agent's "I think I'm done" moment: a 480-token duplicated routine, a fourth private copy of a shared RNG utility, a hand-duplicated cost function, a pair of near-identical functions with a flipped sign (correct at one boundary, quietly wrong at the other), test-fixture duplication across sibling suites, and functions that had quietly absorbed a second job. None of these would have failed a test; all of them are the sediment that rots a codebase under high-velocity multi-agent development. The gate made removing them routine instead of heroic.
Where the value concentrated
- Orientation and recall (the token win). Ranked-signature task orientation and section-granular document recall meant agents started from answers, not file dumps. Recall over planning docs was the orchestrator's single most-used verb — the audit's entire framing came from two calls.
- The contract checker (the shipped-bug preventions). Beyond the 5-of-6 catch above,
--edit-checkgave near-free proof-of-contract on every public-symbol change across the wave — the kind of verification that otherwise simply doesn't happen at agent speed. - The quality gate as a protocol. The measurable effect wasn't any single catch — it was that fifteen different agents, none sharing context, all converged on the same "fix or justify with a written reason" discipline, with an acknowledgments ledger that survived across tasks. Unattended orchestration usually leaks quality; here the leak-check was mechanized.
- Persistent notes. Agents left gotcha notes pinned to symbols mid-wave (a caller-wiring law, an arming-rule invariant), which later agents' lookups surfaced automatically — cheap institutional memory between contexts that never met.
The honest boundary
- The engagement's deepest findings did not come from the tool. A structural capacity ceiling, a mis-derived constant, a floating-point re-association drift of 1 ulp, and a seed-keying bug were all found by bespoke measurement the agents built — baseline worktree diffs over full data fills, multi-arm attribution sweeps, funnels. The tool is a floor for honesty and orientation, not a substitute for measurement design.
- Known false-positive mode, handled by its own documentation: the contract checker's arity heuristic over-counts on defaulted trailing parameters (one task saw "incompatible=18" that were all fine). The tool's own trust-calibration notes say to verify by compiling in exactly this case, and agents that followed them lost nothing.
- For broad, common-word conceptual queries, plain grep-and-read still occasionally won — consistent with the tool's own guidance that it shines on specific technical asks.
Bottom line
For a single developer, this tool is a good lookup accelerator. For an orchestrated fleet, it's load-bearing: it halved the research spend, twice redirected tasks before wasted work, prevented at least one silent-divergence shipped bug, and turned code-quality hygiene from a hope into a per-task mechanical gate. Whole-workflow ~2×; per-lookup 10–25×; and two moments where one call was worth more than the rest of the session's tooling combined.
The model's own report of one engagement, on a version before 0.5; not a controlled measurement. Controlled measurements are in docs/EVALS.md.
Beside those sits a labelled survey of 237 tools that contributed nothing and says so. The two sets are disjoint by construction, so they add rather than nest — a tool that gave a lesson is never counted twice.
Both halves are load-bearing, and they are doing different jobs. The settled results are what make the quality lens trustworthy: McCabe on complexity (1976), Halstead on volume (1977), Spärck Jones on term specificity (1972), Nagappan & Ball on churn. Fifty years of replication means those are not opinions, and a tool that measures your code should be built on the ones that survived.
The recent work is what makes it current: seventeen of the folded papers are from 2026, seven published in the last two months and three in the last thirty days (dates as of 2026-09-08; every row carries its arXiv id, so the claim is checkable rather than atmospheric). Retrieval for coding agents, context-compression cost, placebo-controlled localization — that literature is months old, not decades, and several rows were folded within weeks of the paper appearing.
Neither half alone would be enough. A tool built only on the classics would not know what an agent
needs; one built only on last month's preprints would have nothing underneath it. And the newest row
is a result that failed when it was tested here — which is the point of writing them down. All three counts are re-derived from that document's own tables by
test/readmedriftcheck.sh on every run, which fails if this page and those tables disagree, so the
claim cannot quietly drift. The row-by-row ledger is
docs/LINEAGE.md.
Languages: Rust · C++ · Objective-C/C++ · C · Metal · CUDA · Python · Go · Swift · TypeScript · JavaScript · Java · Ruby · PHP · Lua · Elixir · Dart · Kotlin · GDScript · Clojure · Bash · C# · Protocol Buffers · JSON · TOML · YAML · Markdown — see language support and limits.
Latest: 0.6.10 — more complete --for answers, warm runs on large repositories that use 35 to 67 % less CPU, and about half the peak memory of an index on macOS. Release notes ·
the presentation · the changelog — with thanks to the
contributors named there.
Measured on 48 matched questions across django, webpack and this repository. Across all three,
ripwire indexes in 0.25–0.45 s and 6.6–16.5 MB against that server's 23–52 s and
391–623 MB. The full method, the wins named one by one and the losses included, is in
Against the leading graph-database code-context MCP server
and docs/EVALS.md.
One self-contained binary on your own machine, offline, installed in one line — and the same line installs and activates the task-shaped skills that teach your agent when to reach for it, not just how, for every agent it finds on the machine. If your agent can run shell commands — Claude Code, Codex, Cursor, Windsurf, Gemini, opencode, aider — it is set up the moment the install finishes; the MCP server is the optional second interface. Install it and ask it something before you finish reading this page:
RIPWIRE_REPO=redhat-et/ripwire bash -c "$(curl -fsSL https://raw.githubusercontent.com/redhat-et/ripwire/main/scripts/install.sh)"
export PATH="$HOME/.local/bin:$PATH" # where it installed; the installer prints this line if you need it
cd your-repo
ripwire . --for="<the change you are about to make, in words>"
Every install route (prebuilt, from source, per-agent skills, hooks, the MCP server) is in INSTALL.md.
Reach for the CLI first — it is the cheaper interface. The MCP server is the optional second way in, and its convenience has a cost the shell pipe does not carry: its verb schemas sit in your agent's context every session, whether or not it calls them.
The goal: one question, one complete answer.
Terminality is the objective. Ask the codebase a question and the answer should carry everything you need — no follow-on grep, no three more whole-file reads to fill in what it left out. A call followed by three greps is the same search paid for twice: it does not save you tokens and it does not make the coding faster.
Two jobs, one goal. An agent meeting a codebase does two things, and ripwire is shaped for both:
- Orient —
ripwire .One call gives the ranked map: the main subsystems, the program entry points, the symbols that matter most, and a count of every file the ranking left out. The most important information about a new tree, in as few calls as possible. - Ask —
--for,--expand,--callers,--path, … After that, each question gets a lean answer: as few bytes as it can spend while still answering the question fully, so no follow-up grep is needed.
That is the goal, and not every answer reaches it yet; the stair-steps below are how we get there.
Two things make that reachable in practice, and neither is the destination. Answers are honest about their own limits — a count that cannot be a total is labelled a floor, a zero means "none found" and never "none exists", every truncation is disclosed — so an answer never looks more complete than it is, and the map never degrades the code by guessing. And an answer can be given a token budget, so what one costs is something you ask for rather than discover; where a complete answer will not fit, it says it went over rather than silently dropping the row you needed.
Those two are the stair-steps: honest about what is missing, priced in what it spends. The step they climb toward is a question fully answered in one call, which is not always trivial to reach — and where it is not, the output says so rather than pretending otherwise.
How we measure the climb. A complete answer to every code question is genuinely hard, and it is reached over many releases rather than in one. Until an answer can be complete, it owes you three things: it stays bounded in size, it is fully honest about what it does not know, and it gives you a clue where to look next. So every change is judged on more than "was it right":
- Complete answers: the share of questions answered so you can act without re-checking.
- Honest-partial rate: how often an incomplete answer says what it is missing, instead of sounding confident.
- False-confidence rate: wrong answers that claim to be complete — the worst case, held near zero.
- Next-clue usefulness: for partial and wrong answers, whether following the answer's first suggested next step reaches what the question needed, within one hop. Graded blind.
- Recoverability: for every cut answer, whether following its
next=returns everything that was cut. - Tokens per complete answer: total tokens an agent spends across a scenario, divided by the questions it got fully answered.
- Cut-row recoveries: how often a needed item arrived only through a continuation.
Answering comes first; efficiency is how we get there. We aim for answers about as lean as the leanest tools, but a byte budget is never allowed to cost an answer. We have gone too far toward short answers before and cut information that was needed, so now every size limit has one of two jobs: a runaway guard far above typical answers (it catches an output bug, and says so when it trips), or a stair-step target where anything over it must be explained. A capped answer is always measured against the same answer uncapped, and the one that answers better wins.
A cut is only honest if you can get the rest back. Disclosing a cut is the floor, not the bar: a capped
answer plus the next= it prints must return everything the uncapped answer had. A test that checks this for every
budget option on every command is being built, so that "the answer was cut" always comes with "and here is the rest".
What a budget may spend first. When a budget is tight, ripwire drops bytes that carry no answer before it drops answers: repeated legend text, duplicated paths, bodies whose signature already says what you need. Only then the lowest-ranked rows, each counted. A whole section never disappears without a marker.
Budgets are yours to set, never ours to impose. The defaults and the setups ripwire wrap writes carry no
budget that cuts a typical answer; a budget is a choice the caller makes, with its cost disclosed.
Efficiency is counted per complete answer, across the whole task. Bytes per answer can fall while the task gets more expensive, if the agent then has to ask again. So the efficiency figure is tokens per complete answer over a whole scenario — orient, then the questions that follow — not bytes per call.
Ranking is the tool's best guess; the next= is the safety net — and we measure how often the net is needed. ripwire cannot always know which row answers the question; it goes by ranking. When a needed item appears only after following an answer's next=, the honesty layer saved the answer but the ranking put that item below the cut. We count those per round:
- Recovered through next=: the item was cut but recoverable — one extra call. Driving this down is ranking work.
- Lost: the item was cut with no marker or no working next= — a bug, fixed first.
ripwire MCP questions
How do I start using ripwire with my AI agent?
Install it using the provided one-line command and tell your agent to use it, for example: 'Use ripwire on this repo.'
Does ripwire require an API key or an external index server?
No, it is a zero-dependency, offline tool that does not require an API key, embeddings, or a daemon.
What kind of code quality checks does it perform?
It uses a quality delta feature to report on things like duplicated routines, incompatible call sites, and changes in code complexity.