repo2graph

MCP文档知识

提供方 未标注

文档知识 stdio · 本地进程 未标注 社区 / 第三方 Claude DesktopClaudeCursorVS Code
查看接入方式

当智能体搜索代码库时,要么将整个文件塞入上下文,要么因猜测了不同的词汇而完全错过代码。repo2graph 转而构建真实的调用图,并据此决定返回什么——这样你就能在固定的 token 预算内获得实际源码,且调用方和被调用方已附带在内。

一句话选型结论

按资料字段整理

repo2graph 属于文档知识类 MCP 服务器,stdio · 本地进程,鉴权方式未标注,可直接接入 Claude Desktop、Claude、Cursor 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类文档知识 传输方式stdio · 本地进程 鉴权未标注 部署方式本地部署
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

文档知识
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

记忆

安装与配置

stdio · 本地进程 未标注
客户端在本机拉起子进程,数据不出本机
uvx repo2graph demo # bundled example repo, five questions answered uvx repo2graph build . -o .r2g # index your own code uvx repo2graph rag "how does routing work" -o .r2g # a cited, budget-bounded context pack

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Node.js 等运行时,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
文档检索问答

在你的文档库里按问题找答案。

知识库读写

把新资料写进知识库,随用随取。

内容整理

把零散资料归纳成结构化笔记。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在文档知识场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
repo2graph当前 未标注 stdio · 本地进程 本地部署 有 未标注
dify 未标注 stdio · 本地进程 本地部署 有 2026-04-11
open-webui 未标注 stdio · 本地进程 本地部署 有 2026-04-11
JeecgBoot 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Cherry Studio 未标注 未标注 未标注 无 2026-05-17
mempalace 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

文档知识
字段来自项目仓库与公开索引,中文说明由本站标注
提供方未标注上游标注的维护方 未标注
分类文档知识本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式未标注远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

14.6 KB
来自项目仓库与上游目录的原文,未做删改

repo2graph

Cited, token-bounded answers about a codebase, for coding agents and CI.

Ask a repository a question and get back the source that answers it. Every block is headed
[cite: path:start-end], and the whole reply fits under a token ceiling that the tool enforces.
One tree-sitter pass records who calls whom, who imports what, and which files keep changing
together in git. Retrieval starts from BM25 matches and follows those links.

It needs no model, no API key, no language server and no database. Building, querying and the
MCP server make no network calls; the only exceptions are rag --answer (opt-in, sends the pack
to an LLM), repo2graph github and a rag/query target given as a GitHub spec (both clone a
repository), and --vectors/embed (download the embedding model on first use). Parsers are part of that promise:
tree-sitter-language-pack is pinned below 1.0 so every grammar arrives compiled into the
installed wheel, rather than being downloaded on first parse — see
SECURITY.md. Use it from the CLI, as an MCP server in Claude Code or Cursor, or as a GitHub Action.

Try it```bash

uvx repo2graph demo # bundled example repo, five questions answered
uvx repo2graph build . -o .r2g # index your own code
uvx repo2graph rag "how does routing work" -o .r2g # a cited, budget-bounded context pack


Give an agent the same thing over MCP:```bash
claude mcp add repo2graph -- uvx --from "repo2graph[mcp]" repo2graph-mcp .

Cursor, Claude Desktop and other clients: docs/mcp.md. Step-by-step with expected
output: demo in docs/cli.md. What it produces on
thirteen well-known repositories — Django, FastAPI, React, Kubernetes, Linux and others, each at a
pinned commit with the command to reproduce it: examples/.

In VS Code, the extension in editors/vscode/ (a preview, built from
source) shows the callers, callees, base classes and co-changed files of the symbol at the cursor,
through the same MCP server.

Is it better than grep?

On cross-file structural questions, yes. On single-file lexical queries, no — grep is the
better tool.
Both halves are measured on 40 lexical and 40 structural questions about Flask,
requests, FastAPI and Hono that repo2graph was not tuned against, scored against the
definitions that answer them, every retriever held to the same token budget
(method, full tables and diagnosis; raw rows in
results_holdout_final.json).

Where repo2graph wins: cross-file structural questions

grep structurally cannot traverse dependency edges, compute reverse call closures, or follow
cross-module delegation. On questions whose evidence provably spans a cross-file graph edge:

Budget repo2graph lexical search alone grep, then read around hits
2,000 tokens 29% 24% 14%
4,000 tokens 60% 48% 21%
8,000 tokens 79% 55% 38%

The graph is what does it, and that is the comparison that matters: expansion adds +5/+12/+24 pp
over the same retriever with expansion switched off. Against grep the margin is +15/+39/+41 pp —
it widens with budget rather than closing, because grep has no edge to follow however much room
it is given. It also gets there for fewer tokens than grep at every budget, by 7, 7 and 398
mean tokens, because a cited definition is a smaller thing to return than a window around every
textual hit.

Where grep wins: single-file lexical questions

Budget repo2graph grep, then read around hits
2,000 tokens 17% 28%
4,000 tokens 29% 48%
8,000 tokens 45% 59%

On purely lexical questions where the evidence sits in a single file, text search is grep's
optimum, and this gap is real: −11/−19/−14 pp. We have not closed it. The remaining cause looks
like vocabulary mismatch rather than ranking — a question that says "datetime" does not match
code that says "timestamp" — which is why the
dense-vector path closes it to −2 pp at 8,000
tokens and more BM25 tuning has not. That path needs a downloaded model, so it is opt-in
(pip install "repo2graph[rag]") and the zero-dependency default stays the default.
That extra pulls PyTorch, which on Linux brings the NVIDIA CUDA wheels (several GB); the model is
fetched from Hugging Face on first use and its own licence and training data are yours to review
before you adopt it. Once it is cached, set HF_HUB_OFFLINE=1 so later runs make no request.

If that is too much to carry — on a CI runner, say — pip install "repo2graph[rag-static]" and
--embed-backend static get dense retrieval without torch: model2vec is a token→vector table
plus mean pooling, so inference is numpy, and it costs ~60 MB of packages and a ~31 MB model.
It is a different model (256-dim against 384), not a cheaper way to run the same one, so expect
it to retrieve differently — the figures above are the rag backend's. Pass the same
--embed-backend on the query side as you did to embed: the recorded model id is prefixed per
backend, so a mismatch is refused rather than silently fused.

Where repo2graph wins for agents: fewer turns

In simulated agent workflows (search → read → answer, via scripts/agent_eval.py). No
model is in the loop — the "agent" is a deterministic policy over real ripgrep and a real index:

Task set Method Success Mean turns Mean tokens Precision per read
Structural (40) repo2graph 40% 1.9 2,590 12.0%
Structural (40) ripgrep 10% 2.5 586 29.0%
Lexical (40) repo2graph 20% 1.4 2,070 21.7%
Lexical (40) ripgrep 18% 3.0 740 89.1%

Four times the structural success rate, and it reaches an answer in one or two turns where grep
needs three. The turn count is the number that moved most — structural went 3.1 to 1.9 — because
sharper seed ranking puts the answer in the first pack more often, and a turn saved is worth
more to an agent than a token saved. It is not cheap: 4.4× grep's tokens on the structural set and
2.8× on the lexical one, and grep wins precision per read on both. repo2graph buys recall and
turns with context; the budget-matched comparison is the single-shot tables above.

For completeness, the 35+10 question set this page used to report — visible since the first
version of these tables and therefore a regression set, not evidence — now reads 44/63/80%
lexical against grep's 35/61/72%, and 60/80/100% structural against grep's 20/20/70%. Those are
the better-looking numbers, which is exactly why the held-out set is the one quoted above.

What it does do that grep doesn't:

  • Relationships in one hop. repo_neighbours returns a symbol's callers, callees, base
    classes and defining file, each with a line number. Every edge carries a confidence: a name
    that could mean several definitions is marked ambiguous and priced at 1/n, not guessed.
  • A hard ceiling. The pack is measured, clamped and re-measured before it's returned
    (12k tokens max over MCP), so an agent can't flood its own context through this tool.
  • Reverse closures from the graph. repo_blast_radius walks what depends on a symbol,
    bounded by hop count and visit cap, with a citation per edge.

How it compares with Serena, Aider's repo map, CodeGraphContext, code-graph-rag, Sourcegraph,
Cursor's index and Claude Code's own search, and with the dependency-graph tools Madge,
dependency-cruiser and CodeSee, including when to use those instead:
docs/comparison.md. Looking for a Sourcetrail alternative? It is not
a drop-in replacement — there is no interactive desktop UI — and
the comparison says what it does instead.

Five questions to start with

Ask your repo What the graph adds
Where is authentication enforced? the guard itself, plus the routes that call it (--framework-edges names each endpoint)
What calls ? CALLS edges into it, each with a confidence score
What tests cover ? IMPORTS edges from the test module back to the code under test
What would be affected by changing ? the definition, then its direct callers from the CALLS edges into it (explain node)
Trace from route to persistence. the handler and its callees one hop at a time, each block cited to file and line

GitHub Action```yaml

  • uses: actions/checkout@v4
    with: { fetch-depth: 0 } # full history, so CO_CHANGE edges are meaningful

  • uses: Srinivasan-78/repo2graph@v4
    with:
    git-history: "500"
    commit-branch: graph # optional: publish graph.html to a browsable branch


`@v4` follows every 4.x release; pin an exact tag (`@v4.1.0`) to upgrade by hand. The Action never
calls an LLM. Inputs and outputs: docs/cli.md.

## Commands

| Command | Does |
|---|---|
| `repo2graph build  -o .r2g` | Parse a repo into a graph and chunks (`--incremental`, `--git-history N`, `--framework-edges`) |
| `repo2graph query "" -o .r2g` | BM25 search plus one graph hop |
| `repo2graph rag "" -o .r2g` | Budget-bounded, cited context pack (`--answer` sends it to an LLM: opt-in, the only path that sends code anywhere) |
| `repo2graph explain ` | Why an edge exists, or why a block was retrieved |
| `repo2graph github  -o ` | Fetch, build and clean up without a local clone |
| `repo2graph demo` | Index a bundled example and answer the five questions above |
| `repo2graph map`, `repo2graph stats`, `repo2graph index-status`, `repo2graph embed` | Re-render `graph.html`, report counts and freshness, add optional dense vectors |
| `repo2graph diff` | What changed structurally between two builds: symbols added, removed and renamed, edges, and whose callers changed |
| `repo2graph doctor`, `repo2graph bug-report`, `repo2graph explain-path`, `repo2graph completion` | Diagnose setup, build a privacy-safe bug bundle, say why a path is (not) indexed, shell completion |
| `repo2graph-mcp ` | stdio MCP server: `repo_map`, `repo_search`, `repo_neighbours`, `repo_blast_radius`, and five more |

Full flags: docs/cli.md. Python API: docs/python-api.md.
Build cost up to 50,000 files: benchmarks/perf/README.md.

## What it can't do

- **Resolve calls by type.** Calls are matched by name, scoped by class, file, imports and
  directory. `x.get()` on a receiver of unknown type is recorded as a low-confidence guess, not a
  fact. For exact references, use a language-server tool, or hand `build --scip index.scip` a
  SCIP index (from `scip-python`, `scip-typescript`, ...)
  to make the calls and bases it covers exact; see
  docs/architecture.md.
- **See dynamic dispatch, reflection or computed imports.** A missing edge doesn't prove that no
  call exists.
- **Cross language boundaries** (Python calling C++ through bindings).
- **See a route that is registered by a call.** `build --framework-edges` links
  decorator-declared routes to their handlers (FastAPI, Flask, Starlette, Sanic, NestJS) and adds
  a node per endpoint, so `GET /users/{id}` is a thing you can ask about. Express, Hono and
  Django's `urlpatterns` register with a call instead — `app.get("/x", handler)` — where the
  handler is an argument and often an inline function, and those get no edge.

Symbols, calls and classes are extracted for Python, JS, TS, TSX, Go, Rust, Java, Ruby, C, C++,
C#, PHP, Kotlin, Swift, Scala, Bash, Lua, Objective-C and HCL (Terraform), plus the `` blocks
of Vue and Svelte components and the code cells of Jupyter notebooks. Every other file is still
indexed as text. The
specific cases that defeat it — reflection dispatch, string-keyed registries, barrel re-exports —
are pinned as known failures in the
synthetic regression suite, and
per-language coverage is scored, unevenly, in
docs/architecture.md §4.

**Two of those nineteen are benchmarked on real repositories**: Python (Flask, requests,
FastAPI) and TypeScript (Hono). Treat the rest as parsed-and-unmeasured. That is not a formality —
the retrieval benchmark found two parse gaps in the *one* TypeScript repository as soon as it
looked, one of which was hiding
Hono's entire public API, and neither would have
been visible without a real repository to ask questions about.

## Status

The 3.x CLI, MCP tools and output schema follow semver. Default paths run locally, send no telemetry and exclude secrets from agent replies
unconditionally (what never leaves your machine,
how credential files are excluded,
reporting a vulnerability). A Dockerfile for
read-only, non-root local builds is provided (.github/SECURITY.md).

## Platform & Environment Requirements

| Environment | Status | Details |
|---|---|---|
| **Python** | 3.10 – 3.14 | Tested across Linux, macOS, and Windows in CI (15 cells). Python 3.15+ is untested. Note that 3.10 reached end of life in October 2026; it remains the supported floor, but upgrading is recommended. |
| **Linux (glibc)** | Supported (glibc ≥ 2.34) | Precompiled `tree-sitter-language-pack` grammar wheels require glibc ≥ 2.34 (Ubuntu 22.04+, Debian 12+, RHEL 9+, Amazon Linux 2023+). |
| **Legacy Linux** | Unsupported wheels | RHEL 8, CentOS 8, Amazon Linux 2, Debian 11, and Ubuntu 20.04 ship glibc < 2.34. Wheels fail to load; use a glibc 2.34+ container or compile grammars from source. |
| **Alpine / musl** | Unsupported wheels | Precompiled grammar wheels are not distributed for musl libc. Use a glibc container or build with a C toolchain. |
| **macOS / Windows** | Fully supported | Tested on macOS 12+ (Apple Silicon & Intel) and Windows 10/11 (UTF-8 & CP1252 codepages). |

Run `repo2graph doctor` to diagnose environment and platform support.

## Security & Maintenance Posture

- **Single maintainer:** repo2graph is developed and maintained by a single author (@Srinivasan-78).
- **Automated gates:** Pull requests must pass automated CI checks (ruff, mypy, multi-OS test matrix, synthetic regression benchmarks).
- **Review policy:** Pull requests require 0 third-party review approvals to merge to `main`.
- **Commit signing:** Commit signing is not currently enforced on `main`.
- **Integrity:** Releases are published to PyPI with provenance attestations. `uv.lock` pins every dependency by hash for CI and contributors (`uv sync --frozen`); a plain `pip install repo2graph` resolves its own versions within the ranges in `pyproject.toml` and does not read it.

## Contributing```bash
git clone https://github.com/Srinivasan-78/repo2graph && cd repo2graph
python3 -m venv .venv && .venv/bin/pip install -e ".[dev]"
make lint format-check typecheck test

Branch from develop. Start with .github/CONTRIBUTING.md and
docs/architecture.md. The most useful contribution right now is new
questions for the retrieval benchmark, especially on repositories
you know well. All docs: architecture, CLI,
MCP, Python API, comparison.

MIT licensed.

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
repo2graph 怎么安装?

在客户端按下面的安装命令接入:uvx repo2graph demo # bundled example repo, five questions answered uvx repo2graph build . -o .r2g # index your own code uvx repo2graph rag "how does routing work" -o .r2g # a cited, budget-bounded context pack。装完在客户端配置里引用同一个包或端点。

repo2graph 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

repo2graph 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

repo2graph 需要 API Key 吗?

资料没有标注鉴权方式,是否需要密钥取决于服务本身,接入前按官方文档确认。

repo2graph 支持哪些客户端?

资料标注支持 Claude Desktop、Claude、Cursor、VS Code、Gemini CLI、Codex;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

repo2graph 能提供哪些能力?

资料显示能力标签包括 记忆。具体工具清单以官方文档为准。

repo2graph 需要什么运行环境?

属于本地进程,需要在本机装好运行环境。

repo2graph 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。