A local, read-only index and MCP server that gives your coding agent a repository’s callers, call paths, history, and memory, with a confidence label on every answer.
Claude Code ·Codex ·OpenCode ·Cursor ·Gemini CLI ·Goose ·VS Code ·Zed ·+ 70 more via npx @rag-rat/skills
Index once, then query with provenance. No change to how you already work.
Point rag-rat at a repo. It parses every file with tree-sitter and embeds it locally; source stays read-only, and everything lands in one SQLite database.
Callers, callees, imports, and type references become a real graph. Run the optional SCIP oracle to upgrade edges to compiler-grade truth.
Your agent asks where, why, who-calls, and what-breaks, and gets answers with provenance through 47 tools, with no change to how you work.
Findings become typed, source-anchored memories that survive refactors and resurface for the next agent and the next session.
Every coding harness already has grep and file reads. rag-rat adds the layer they don't: source-anchored rationale, with the receipts.
Callers, callees, and imports across six languages, with a label on every edge for how it was resolved, so a guess reads as a guess.
See the blast radius of a change before an agent makes it: callers, tests, and the notes that apply.
The why behind the code, not just the what, and kept strictly apart from current source.
Typed, source-anchored notes that outlive the exact lines they describe and resurface for the next session.
Drops into your agent over MCP with no workflow change: local-first, offline, and read-only on your source.
Run a fleet of agents at once, each in its own git worktree of the same repo. They share one index and one memory graph instead of each rebuilding its own.
Every worktree of a repo resolves to the same consolidated store, keyed off the main worktree, so nothing is re-indexed per branch.
Each worktree sees its own uncommitted edits in query results, and a branch switch reuses rows instead of triggering a reindex.
One watcher and one writer per worktree, enforced with file locks, plus a worktree-safe gc that prunes rows no live commit still holds.
Point an MCP query at a linked worktree by path; memories anchored on an in-flight branch re-anchor themselves when it merges.
Memories rot: the code moves under them, an invariant gets superseded, a load-bearing function ships with no note at all. dream is the maintenance loop that keeps the layer honest, and keeps a human in the loop.
Load-bearing symbols (by the same PageRank as important_symbols) that carry no memory, so the next agent to touch them gets nothing.
A memory citing a path or anchor that no longer resolves. Every finding gets a stable id you can review, deterministically, at no cost.
Checks each memory against current source reality: has the code drifted from what it claims? It labels the memory current or diverged, and only proposes; it never changes a memory itself.
Rewrites a verbose note into a tight three-to-four-sentence summary. Both passes run a small model on a GPU you control, only when there is pending work.
Fully deterministic until you opt in, and off by default. Nothing is deleted automatically: you, or an agent over MCP, accept or dismiss each finding, and settled verdicts don’t come back. Run it on demand or on a nightly schedule. Configure dream
rag-rat labels what it returns so an agent can judge it instead of trusting it, the thing grep and a raw vector search can't give you.
Every edge and answer is labeled by how it was resolved, from a compiler-verified fact down to a best-guess name match.
A partial or stale index says so, out loud, instead of quietly returning less than the whole picture.
The raw source, call paths, and history come attached, so an agent can judge the answer instead of trusting it.
Grounded in the open milestones on GitHub. Building means in active development; planned means designed and queued. Every item links to its tracking issue.
GitHub and GitLab ship today; Bitbucket, Jira, and OAuth device-flow login are next: one provider-neutral mirror of every issue and PR. #597
Signed per-device logs and end-to-end-encrypted streams so repo memories move between your own machines, with no server and no cloud. #406
npx @rag-rat/setup to install the binary and register rag-rat across ~9 agents in a single step. #545
A cheap, always-on tier that resolves Rust calls by receiver type, closer to compiler accuracy without running the full oracle. #567
Turn closed issues and their fixing diffs into typed decision records (root cause, decision, outcome) anchored to the symbols they touched. #113
A SourceKit-LSP oracle backend for compiler-grade Swift edges, on top of the existing tree-sitter baseline. #637
Reindex exactly the paths your edits touch, the moment they change, for freshness that never leans only on the file watcher. #661
Public, read-only memory streams so a repo can publish what it knows about itself for any agent to subscribe to. #407
Measured on real repositories, not toys.
62,903 files · 3.49 GiB peak RSS · SCIP-oracle precision 92.8% (C) / 81.7% (Rust). See the benchmarks
rag-rat is structure and provenance, not another text search.
| Capability | Grep + file reads | Vector / semantic search | rag-rat |
|---|---|---|---|
| Finds code by meaning | ○ | ● | ● |
| Callers, callees, and impact surface | ○ | ○ | ● |
| Confidence + coverage on every result | ○ | ○ | ● |
| Git and issue/PR rationale | ○ | ○ | ● |
| Memory that survives refactors | ○ | ○ | ● |
| Fully local, source never leaves your machine | ● | varies | ● |
It’s the retrieval half. RAG is retrieve, then augment, then generate; rag-rat does the retrieve and augment (structured, provenance-labeled context from the code graph, git and issue history, and memory) and hands it to your coding agent, which does the generating. So it’s the backend you build a code-RAG workflow on, not an embed-and-chat pipeline of its own. The name is a wink.
No. rag-rat reads your source read-only and writes only its own local SQLite database. Embeddings run locally by default; you can optionally offload bulk embedding to a GPU you control.
A write-time clone check fingerprints functions as they are written and warns when they are exact or near-duplicates of code already in the repo, so the agent reuses instead of rewriting. It is read-only and a silent no-op until the index is ready.
Yes. find_callers, trace_callees, and impact_surface return the call paths, tests, and memories around a symbol (the blast radius) before anything changes.
Yes. Typed, source-anchored memories (invariants, decisions, risks) persist across sessions and agents, survive refactors, and resurface automatically in later queries.
A one-step plugin for Claude Code, Codex, and OpenCode, plus npx @rag-rat/skills to install it into 70+ agents including Cursor, VS Code, Zed, and Goose.
Install the plugin, then open your repo and say “Set up rag-rat in this repo.” The setup skill scans the project, previews the config, and indexes only after you confirm.
claude plugin marketplace add cq27-dev/rag-rat
claude plugin install rag-rat@rag-ratcodex plugin marketplace add cq27-dev/rag-rat
codex plugin add rag-rat@rag-rat# MCP + hooks (add -g for a global install)
opencode plugin @rag-rat/plugin-opencode
# the skills ship separately
npx @rag-rat/skills# no Rust toolchain needed
npx @rag-rat/bin --help