CI License: MIT

Local-first code intelligence for AI agents. Built in Rust. Single static binary, ~5 MB. Tree-sitter knowledge graph in SQLite, served over MCP.

CodeGraph parses your codebase with tree-sitter, stores every symbol, edge, and file in a local SQLite database (FTS5), and exposes the graph to AI agents — Claude Code, Cursor, Codex CLI, opencode, Hermes — over the Model Context Protocol (MCP).

Agents that consult the graph instead of grepping the filesystem make fewer tool calls, explore faster, and stay within context.

• One binary. Rust + statically-linked SQLite + native tree-sitter grammars. No Node runtime, no .wasm, no node_modules.
• Small. ~5 MB stripped (vs ~140 MB for the previous TypeScript build).
• Fast. Parses a 139-file TypeScript project in ~190 ms (release, parallel).
• Local. Index lives in .codegraph/db.sqlite next to your code. Nothing leaves the machine.
• Multi-agent. A single codegraph install configures Claude Code, Cursor, Codex, opencode, Hermes and Antigravity CLI in one go.
• Live. Built-in file watcher keeps the index in sync while the MCP server serves your agent.

curl -fsSL https://raw.githubusercontent.com/Cleboost/codegraph-rs/main/scripts/install.sh | sh

irm https://raw.githubusercontent.com/Cleboost/codegraph-rs/main/scripts/install.ps1 | iex

yay -S codegraph-rs-bin

git clone https://github.com/Cleboost/codegraph-rs
cd codegraph-rs
cargo build --release -p codegraph
# binary at target/release/codegraph

cargo install --git https://github.com/Cleboost/codegraph-rs codegraph

# 1. Init, index, and configure your agents in one step
cd ~/code/my-project
codegraph init
# 2. Use it
codegraph query UserService
codegraph context "auth middleware"

Your agent now has tools like codegraph_search, codegraph_callers, codegraph_impact, codegraph_context available over MCP. The file watcher keeps the index fresh while you edit.

Global flag --path <dir> overrides the workspace root.

15 languages with full tree-sitter extraction:

TypeScript · TSX · JavaScript · Python · Go · Rust · Java · C · C++ · C# · Ruby · PHP · Scala · Swift · Lua

Each language emits:

• Declaration nodes (functions, classes, structs, interfaces, traits, enums...)
• contains edges (parent → child)
• calls edges (resolved by name-matcher post-pass)
• imports edges (raw imports captured for further resolution)

Coming back from the TypeScript version: Kotlin (blocked on upstream tree-sitter grammar upgrade), Dart, Pascal, Luau, and text-based extractors for Svelte/Vue/Liquid/DFM.

Agents see nine tools through the MCP server:

Read the server instructions that ship with the binary — they tell your agent when to reach for which tool.

crates/
 codegraph-core/ NodeKind / EdgeKind / Node / Edge / Error
 codegraph-db/ rusqlite (bundled) + FTS5 + migrations
 codegraph-extract/ tree-sitter native + per-language extractors
 codegraph-resolve/ imports + name-matching + (later) frameworks
 codegraph-graph/ callers / callees / impact radius (BFS)
 codegraph-context/ markdown + JSON context formatters
 codegraph-mcp/ hand-rolled JSON-RPC 2.0 server over stdio
 codegraph-installer/ Claude / Cursor / Codex / opencode / Hermes targets
 codegraph/ CLI binary (clap) + file watcher (notify)

Pipeline:

files → ignore::WalkBuilder → rayon parse pool (tree-sitter)
 ↓
 batched DB transactions (rusqlite WAL)
 ↓
 ReferenceResolver (name-matcher, frameworks)
 ↓
 GraphTraverser ← ContextBuilder
 ↓
 MCP server / CLI commands

Full design in docs/PLAN.md. One spec per crate in docs/specs/.

A .codegraph/ directory is created next to your project:

.codegraph/
 db.sqlite SQLite v1 (WAL mode, FTS5)
 .gitignore Pre-filled so the index is never committed
 version Codegraph version that created the directory

Add a .codegraphignore file at the workspace root to exclude additional paths beyond your .gitignore. Same syntax.

This project is a from-scratch Rust rewrite of the previous TypeScript implementation. The old binary embedded a Node.js runtime, 20+ tree-sitter WASM grammars, and a native SQLite addon — about 140 MB on disk, with a multi-second cold start.

The Rust port:

• Drops the Node runtime → static binary
• Replaces WASM grammars with statically-linked tree-sitter C libraries
• Bundles SQLite as a static C library (no system dependency)
• Parses in parallel via rayon
• Builds with lto="fat", codegen-units=1, strip, panic=abort

Result: ~5 MB stripped, sub-second startup, ×ばつ faster indexing on the same workspace.

• Framework-aware route extraction (Express, Laravel, Rails, FastAPI, Django, Spring, Axum, ...)
• Additional grammars (Kotlin, Dart, Pascal, Luau, Svelte/Vue/Liquid)
• Eval harness for accuracy regression testing

cargo build --workspace
cargo test --workspace
cargo clippy --workspace --all-targets -- -D warnings
cargo fmt --all

Per-crate test runs:

cargo test -p codegraph-db
cargo test -p codegraph-extract
cargo test -p codegraph-installer

MIT. See LICENSE.

• The original TypeScript implementation by @colbymchenry.
• tree-sitter and all language grammar authors.
• rusqlite, notify, clap, tokio, rayon, ignore.