mcp-reposkein
About
Deterministic code-graph (GraphRAG) over your repo for LLM agents — local-first, git-native, zero-infra, served via MCP.
Details
- Author
- reposkein
- Categories
- Developer Tools, Other, AI
Jump to
Setup
Install mcp-reposkein in your MCP client (Claude Desktop, Cursor, Windsurf, and others).
Repository: https://github.com/reposkein/reposkein
Follow the installation instructions in the repository README, then restart your MCP client.
🔭 Live demo →— RepoSkein's own graph, rendered as an interactive 3D constellation in your browser.
RepoSkein gives your AI coding agent a map of your codebase — so it navigates structure instead of grepping and guessing.
It usesTree-sitterto build adeterministic Code Property Graphof your repo — files, classes, functions, imports, and call edges — and serves it to anyMCP-capable agent (Claude Code, Cursor, Codex, …). As the agent works, it writes short natural-language summaries onto graph nodes; those summaries areversioned in git alongside the code, so an agent's understanding becomesshared team memorythat the next agent — or teammate — starts from.
Who it's for:developers using AI coding agents on real, large, ornested/polyglotcodebases, who are tired of the agent burning its context window on grep; and teams who want that hard-won understanding to persist and be shared rather than re-derived every session.
- ⚡Zero-infra— no database, no Docker. The graph lives in plain.reposkein/.jsonlfiles, rebuilt from your working tree in seconds.
- 🔒Deterministic— same code → byte-identical graph. No LLM in the construction path.
- 🌐7 languages— Python, TypeScript, JavaScript, Rust, Go, Java, C#.
- 🧩Local-first & git-native— the summaries your agents write are committed and travel with your code.
In a deterministic, no-LLMbenchmark, RepoSkein surfaces the right functions with amean ~8.4× fewer context tokensthan a grep-based agent on structural queries.
- Prerequisites
- Installation
- Usage — working with your agent
- Supported languages
- How it works
- Visualize the graph — the constellation viewer
- MCP tools
- Optional: semantic embeddings
- Optional: Neo4j backend
- Benchmarks
- Build from source
- Documentation
- Contributing
- Acknowledgements
- Contact
- License
- Node.js 18+— to runnpx @reposkein/mcp(the indexer binary is fetched automatically).
- An MCP-capable agent—Claude Code, Cursor, Codex, Zed, etc.
- Agit repositoryto index (RepoSkein installs git hooks and reads git history forget_temporal_context).
- Optional:Docker(only for theembeddings serveror theNeo4j backend);Rust(only tobuild from source).
In the repo you want your agent to understand:
This downloads the indexer for your platform, installs git hooks + the navigation skill,builds the initial code graph, and prints an MCP config block. Then:
- Add the printed config to your agent(e.g. Claude Code's.mcp.json):
{ "mcpServers": { "reposkein": { "command": "reposkein-mcp", "env": { "REPOSKEIN_REPO_PATH": "/path/to/your/repo" } } } }
reposkein-mcp doctor . # ✓ binary ✓ indexed (N nodes) ✓ ready git add .reposkein/meta.json .reposkein/config.toml && git commit -m "add RepoSkein config"
Prefer to let your agent set it up?Install theskillsand tell it torun thereposkein-setupskill— it installs, indexes, and verifies everything:
npx skills add reposkein/reposkein --all
Platforms:prebuilt binaries for macOS (Apple Silicon), Linux (x64/arm64), and Windows (x64). Elsewhere, pointREPOSKEIN_INDEXER_BINat afrom-sourcebuild.
For complex setups — multi-repo workspaces, Neo4j backend, the local embedding server, or wiring up agents besides Claude Code (OpenCode, Cursor, Codex, Continue, Cline, …) — paste this into any MCP-capable agent and it'll walk you through:
Install RepoSkein in this workspace. Readdocs/INSTALL.md(orhttps://github.com/reposkein/reposkein/blob/main/docs/INSTALL.md), walk me through the question tree in §1, then execute §2 onward. If anything fails, troubleshoot via §9 — don't silently skip steps. Confirm withreposkein-mcp doctor .per repo and asemantic_findsmoke test before claiming done.
You ask in plain language; the bundledreposkein-graph-ragskill drives the tools. The natural loop:
- Find where to start—semantic_find("jwt auth validation")ranks the right functions by meaning, no symbol name needed. →"where's the rate limiter?"
- Understand it—get_context_profilereturns the node's callers + callees as ready-to-read prose (hops: 2widens,federated: truespans nested repos).
- Before you change it—impactlists transitive callers (what could break) split from the tests that cover it (what to run). →"what breaks if I changecharge()?"
- What moves with it—get_temporal_contextsurfaces files that historically change together, plus churn and ownership. →"what usually changes with the auth config?"
- Record what you learned—write_semantic_summaryattaches a 1–3 sentence note to the node, landing in.reposkein/summaries/<xx>.jsonlfor you to commit for the next agent/teammate.
- After editing—reindex_filerefreshes the graph for the changed file.
You: Refactor how we validate auth tokens — what's involved? Agent: → semantic_find("validate auth token") → resolves auth.validate_jwt → get_context_profile(auth.validate_jwt) → 3 callers, 2 callees (+ summaries) → impact(auth.validate_jwt) → 6 impacted functions, 4 covering tests → get_temporal_context("src/auth/jwt.py") → co-changes with config/keys.py (conf 0.8) Agent: "validate_jwt is called by the login, refresh, and middleware paths; changing its signature touches 6 functions and 4 tests (test_jwt.py, test_middleware.py, …). Heads up: jwt.py historically changes together with config/keys.py — you'll likely need to update both."
🎥 A short screen recording is on the roadmap — seeDocumentation.
RepoSkein ships two cross-agentAgent Skills—npx skills add reposkein/reposkein --allinstalls both into Claude Code, Cursor, Codex, and 70+ agents:
- reposkein-setup— installs RepoSkein in a repo and verifies it's running (binary → index → MCP reachability). Ask your agent to run it.
- reposkein-graph-rag— teaches your agentwhento use each tool (the loop above).reposkein-mcp initinstalls it automatically for Claude Code.
What resolves — honestly.Every edge carries aresolution(exact/name_match/ambiguous) + confidence, so your agent knows what to trust. Same-file calls,self/thismethods, andimport-followed free-function calls resolveexact. Pythonmodule-alias calls(import foo as f; f.bar()) resolveexactto the target module's function.Cross-file INHERITS/IMPLEMENTS edgesare resolved repo-wide: import-followed bases resolveexact(confidence 1.0); unique same-directory or repo-wide bases resolvename_match(0.8/0.7); ambiguous bases are skipped to avoid false hierarchy edges — and bases that live in afederated child repoare stitched into cross-repo heritage edges at load time. Go'sstruct/interface embedding(type Dog struct { Animal }) is captured as INHERITS. Constructors emit a distinctINSTANTIATESedge (new Foo()in TS/Java/C#,Foo { .. }andFoo::new()in Rust,Foo{}/&Foo{}composite literals in Go, and PythonFoo()whose name resolves to a class) so an agent can askwho creates instances of this type— resolved against the type index and skipped when ambiguous. The graph istype-free by design(deterministic, no compiler in the loop), but it does track types where it can do so soundly from source alone: when a local is assigned a constructor (x = Foo(); x.bar()), thatx.bar()resolvesexacttoFoo.bar(intraprocedural receiver typing). Method calls on receivers itcan'ttrace that way (parameters, fields, return values)resolve by name(≤name_match), and overloaded calls are flaggedambiguous. Go and C# don't emit import edges yet, so their cross-package/namespace calls resolve by name (same-package/-directory callsdoresolve). These limits are inherent to the zero-infra, type-free design; a deeper optional type-aware layer (SCIP) is gated on benchmark evidence.Adding a languageis a well-trodden path — contributions welcome.
Your agent (Claude Code / Cursor / …) ── guided by the reposkein skill │ MCP ▼ @reposkein/mcp semantic_find · get_context_profile · impact · get_temporal_context (TypeScript) read_cypher · write_semantic_summary · init_cpg_skeleton · reindex_file CLI: init · doctor · index · view │ reads ▼ .reposkein/ ← nodes.jsonl + edges.jsonl: derived, git-ignored, rebuilt on demand summaries/<xx>.jsonl: what your agents authored — commit this ▲ writes │ reposkein-indexer Tree-sitter parse → stable IDs → canonical JSONL (Rust) + git hooks that keep the local graph in step with your tree
- Structure is static.The skeleton comes only from parsing — identical code produces a byte-identical graph (a CI-tested invariant), independent of who runs it.
- Meaning is just-in-time.Summaries are written as the agent visits nodes; they're content-hash-stamped (so they flag stale when code changes) and committed to git.
- Derived stays out of git.nodes.jsonlandedges.jsonlare a pure function of your working tree, so committing them buys nothing a re-index cannot rebuild while making every branch that touches code conflict with every other. Onlysummaries/,meta.jsonandconfig.tomlare committed — and the summaries are sharded by a hash of the node id, so two branches summarising different code write different files and never meet in a merge.
- Local-first.The JSONL on disk is the source of truth; the optionalNeo4j backendis a reconstructable projection most users never need.
Got nested repositories (a monorepo of indexed repos)? RepoSkein discovers them, links them withFEDERATES_TO, and stitchescross-repo call, import, and heritage edges(INHERITS/IMPLEMENTSto a base in a child repo) at load time. Passfederated: trueto traverse across repo boundaries. Federation edges are derived at load (never committed), so each repo stays independently deterministic.
Visualize the graph — the constellation viewer
reposkein-mcp view . # opens http://127.0.0.1:<port> in your browser
viewstarts alocal, read-only, zero-infraweb app (React + three.js, bound to127.0.0.1) that renders your.reposkeingraph as an interactive 3D astronomy-styleconstellation. There's no Neo4j and no external service — it reads the JSONL on disk directly and never mutates it.Try the live demo →(RepoSkein viewing its own multi-language graph).
The map isdeterministic: a seeded force layout means the same graph always lays out the same way (cached in IndexedDB for instant reloads), and the layout is render-time only — it never touches the JSONL. Levels of detail map onto an astronomy metaphor —Repository → Directory → File → Symbolbecomegalaxy → constellation → solar-system → star— so you zoom or click to expand a cluster (a brief supernova animation) and click a star to inspect it. Federation galaxies and agent-written summaries render when present.
- Legible— per-edge-type colors + legend, importance-sized stars, adaptive labels, breadcrumb, per-language galaxy coloring, depth fog / bloom / nebula halos.
- Edges encode resolution— color = edge type (CALLS/IMPORTS/INHERITS/IMPLEMENTS/INSTANTIATES), opacity = confidence (exact/name_match/ambiguous), and flow particles show call direction.
- Analytical— one-click lenses (call graph / type hierarchy / imports / tests), an impact overlay (transitive callers + covering tests), a confidence-audit mode (see where the type-free resolver guesses), and a temporal-coupling overlay (git co-change).
- Explorable— ranked search-to-fly, N-hop neighborhood focus, source peek in the detail panel (a path-guarded read-only file slice + an "Open in editor"vscode://link), keyboard nav (/search,fframe-all, arrows to hop neighbors,Escback), a minimap, and PNG screenshot export.
- Guided tour— a cinematic, deterministically-derived flythrough (overview → largest modules → busiest hub → type hierarchy → entry point) with captions.
reposkein-mcp view --export ./site . # write a self-contained static site
--exportbakes the graph intograph-data.js(aswindow.__REPOSKEIN_GRAPH__) and emits aself-contained static site— it works fromfile://or any static host with no server, which is exactly how the live demo above is published. Handy for sharing a snapshot, embedding in docs, or a project landing page.
Thereposkein-mcpCLI addsinit(set up a repo),doctor(health check),index(rebuild the graph), andview(theconstellation viewer;--export <dir>writes a self-contained static site).
By defaultsemantic_findisdeterministic and lexical(BM25F — zero-infra, no keys). You can opt into ahybridtier (lexical + embedding cosine, fused via RRF) for fuzzier queries. It'sdefault-off, vectors are cached in.reposkein/local/embeddings/(gitignored, never committed), and itfalls back to lexicalautomatically on any error. Set env vars on the MCP server andpick one:
A) Voyage AI — cloud, easiest, best for code
REPOSKEIN_EMBED_PROVIDER=voyage VOYAGE_API_KEY=pa-... # optional: REPOSKEIN_EMBED_MODEL=voyage-code-3 # default — code-specialized
Sends document strings (qualified names, signatures, summaries) to Voyage's API. Use B or C if you can't egress code.
B) Ollama — local, off-the-shelf, no key
ollama pull nomic-embed-text # 768-dim (or mxbai-embed-large=1024, bge-m3=1024)
REPOSKEIN_EMBED_PROVIDER=http REPOSKEIN_EMBED_URL=http://127.0.0.1:11434/v1/embeddings REPOSKEIN_EMBED_MODEL=nomic-embed-text REPOSKEIN_EMBED_DIMS=768 # must match the model
C) Voyage's open model, self-hosted — offline + Voyage quality
voyage-4-nano(Apache-2.0) is a custom Qwen3-based model Ollama can't run, so RepoSkein ships a prebuilt server. The image ispublished to GHCR — public and multi-arch (amd64/arm64)— so there's nothing to build:
docker run -p 8080:8080 -v reposkein-hf:/root/.cache/huggingface \ ghcr.io/reposkein/reposkein-embed # auto-picks your architecture; first run downloads the model
REPOSKEIN_EMBED_PROVIDER=http REPOSKEIN_EMBED_URL=http://127.0.0.1:8080/v1/embeddings REPOSKEIN_EMBED_MODEL=voyage-4-nano REPOSKEIN_EMBED_DIMS=1024 # must equal the server's EMBED_DIMS
Everything stays on your machine. The image isCPU-only and runs with no NVIDIA GPUon Apple Silicon / ARM unified-memory, x64 Linux, and Windows (CI builds + smoke-tests both arches). Docker can't use Apple's Metal/MPS — for that, run the server natively withEMBED_DEVICE=mps. Full details (rootdocker compose up, GPU, other models):embed-server/README.md.
REPOSKEIN_EMBED_DIMSon the clientmust matchthe model's output dimension, or cosine scoring is skipped.
The zero-infra JSONL store is the default. Neo4j is an optional projection for very large graphs and raw Cypher at scale:
docker compose --profile neo4j up -d # from the repo root NEO4J_PASSWORD=reposkeintest reposkein-indexer load .
Then setREPOSKEIN_STORE=neo4j+ theNEO4J_env vars on the MCP server. (REPOSKEIN_STORE=auto, the default, uses JSONL when present and falls back to Neo4j only if configured.)
- Track 1 — retrieval efficiency(deterministic, no LLM): RepoSkein vs a grep agent on hand-labeled tasks →mean ~8.4× fewer context tokenson structural queries, at F0.5 = 1.00 vs grep 0.11–0.71.Details.
- Track 2 — end-task(SWE-bench-Verified): a minimal agent loop where theonlydifference is the navigation toolset (RepoSkein vs grep), graded on resolve-rate + tokens + turns. Built + unit-tested; the API+Docker run is opt-in.
Requirements: Rust (stable), Node 24. Docker only for the optional Neo4j backend.
cd indexer && cargo build --release # → indexer/target/release/reposkein-indexer cd ../mcp && npm install && npm run build
Wire it into your agent withcommand: node,args: [".../mcp/dist/index.js"], envREPOSKEIN_REPO_PATH+REPOSKEIN_INDEXER_BIN. Tests:cd indexer && cargo test && cargo clippy --all-targets -- -D warnings;cd mcp && npm test.
indexer/ Rust workspace: core, lang-{python,ts,rust,go,java,csharp}, lang-common, neo4j-io, cli mcp/ @reposkein/mcp — the TypeScript MCP server (tools + graph-store backends) mcp/bench/ benchmarks: retrieval efficiency (Track 1) + end-task SWE-bench harness (Track 2) skills/ reposkein-graph-rag + reposkein-setup — cross-agent skills (skills.sh) embed-server/ one-command local embedding server (voyage-4-nano) for hybrid semantic_find viz/ @reposkein/viz — the 3D constellation viewer SPA (served by reposkein-mcp view)
Contributions are welcome — bug fixes, new languages, docs. SeeCONTRIBUTING.mdfor the dev setup, the determinism invariants you must preserve, and the step-by-step recipe foradding a new language(it's a well-trodden path — Go, Java, and C# were each added the same way). RepoSkein usesConventional Commitsand keeps CI green (determinism gates + clippy + tests).
- Tree-sitter— the parsers behind every language extractor.
- Model Context Protocol— the agent integration standard.
- Voyage AI—voyage-code-3and the open-weightvoyage-4-nanopowering the optional embeddings tier.
- Discovery viaGlama,skills.sh,mcpservers.org, and the awesome-mcp community lists.
- README header bycapsule-render+readme-typing-svg.
- 🐛Bugs / features:open an issue
- 💬Questions / ideas:GitHub Discussions
This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.
A Claude Kubernetes MCP server, built in Go. The server integrates with ArgoCD, GitLab, Claude AI, and Kubernetes to enable advanced control and automation of Kubernetes environments.
The all-seeing guardian for macOS: Battery, Clipboard, TTS, and File System control using Claude desktop
A Model Context Protocol (MCP) server that provides AI assistants (like Claude) with tools to directly interact with PostgreSQL databases securely.
next-devtools-mcp is a MCP server that provides Next.js development tools and utilities for AI coding assistants like Claude and Cursor.
Word search, crossword, and sudoku generator MCP server with printable PDF worksheets, themed word banks, and verifiable LLM evals. Local-first, from the makers of puzzletide.com.
A demonstration server for ActionKit, providing access to Slack actions via Claude Desktop.
MCP server that lets Claude Code agents delegate tasks to agents in other project directories, with parallel dispatch, sessions, and async jobs.
Statistical regression testing for LLM agents: p-value, effect size, and CI on behavior change.
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.





