# Arbor

> Code navigation MCP server. Fits your entire codebase into an LLM context.

- **Type:** MCP server
- **Install:** `agentstack add mcp-nikita-voronoy-arbor`
- **Verified:** Pending review
- **Seller:** [nikita-voronoy](https://agentstack.voostack.com/s/nikita-voronoy)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [nikita-voronoy](https://github.com/nikita-voronoy)
- **Source:** https://github.com/nikita-voronoy/arbor
- **Website:** https://github.com/nikita-voronoy/arbor#quick-start

## Install

```sh
agentstack add mcp-nikita-voronoy-arbor
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

Fit your entire codebase into an LLM's context window.

  Quick Start •
  Why arbor •
  Configuration •
  Tools •
  Performance •
  Languages

  

  
  
  
  

  

---

## Highlights

- **1M lines of code → 500 lines of context.** arbor builds a symbol graph with tree-sitter and compresses it into token-efficient summaries an LLM can actually use.
- **14 surgical MCP tools.** The LLM sees architecture first, then drills into exactly what it needs — no grep noise, no wasted tokens.
- **Sub-second incremental re-index.** Only changed files are re-analyzed via content hashing. Cold index of a 1M LOC project takes under 10 seconds.
- **15 languages and formats.** Rust, Python, TypeScript, Go, C/C++, C#, Kotlin, plus Terraform, Ansible, SQL, Protobuf, OpenAPI, and Markdown.
- **Zero configuration.** One install command. No config files. Works with any project structure.

```
bevy (1,756 files, 21,863 functions, ~1.1M LOC)
  boot screen:      16 lines   ~400 tokens
  compact skeleton:  552 lines  ~9k tokens
  indexed in:        9.5 seconds
```

## Quick Start

One command — installs arbor and connects it to Claude Code:

**macOS / Linux:**
```bash
curl -fsSL https://raw.githubusercontent.com/nikita-voronoy/arbor/main/scripts/install.sh | bash
```

**Windows (PowerShell):**
```powershell
irm https://raw.githubusercontent.com/nikita-voronoy/arbor/main/scripts/install.ps1 | iex
```

Manual install

```bash
# Build from source
cargo install --git https://github.com/nikita-voronoy/arbor.git arbor-mcp

# Add to Claude Code
claude mcp add arbor -- arbor
```

That's it. Claude will call `boot` → `compact` → `search` → `source` → `callers` as needed.

### CLI mode

```bash
arbor /path/to/project --cli       # Architecture overview
arbor /path/to/project --compact   # Token-optimized skeleton
```

## Configuration Examples

The installer configures everything automatically, but here's what it sets up and how to customize it.

Claude Code (MCP server)

The installer registers arbor as an MCP server:

```bash
claude mcp add arbor -- arbor
```

Verify it's registered:

```bash
claude mcp list
```

PreToolUse hook — steer Claude toward arbor

The installer adds a hook to `~/.claude/settings.json` that nudges Claude to use arbor instead of raw grep/glob:

```json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Grep|Glob",
        "hooks": [
          {
            "type": "command",
            "command": "echo '{\"hookSpecificOutput\":{\"hookEventName\":\"PreToolUse\",\"additionalContext\":\"STOP: Prefer arbor MCP tools (search, source, callers, references, skeleton, compact, boot) over Grep/Glob for code navigation. Fall back to Grep/Glob only for string literals, comments, or regex patterns.\"}}'",
            "statusMessage": "Checking arbor preference..."
          }
        ]
      }
    ]
  }
}
```

This doesn't block grep — it adds context that helps Claude choose the right tool.

CLAUDE.md instructions

The installer appends a block to `~/.claude/CLAUDE.md` that teaches Claude when to use each arbor tool:

```markdown
## Code navigation: use arbor MCP first

- **Instead of grep for a symbol** → use `mcp__arbor__search`
- **Instead of grep for "who calls X"** → use `mcp__arbor__callers`
- **Instead of reading a function's code** → use `mcp__arbor__source`
- **Instead of reading many files** → use `mcp__arbor__boot`, then `mcp__arbor__skeleton` or `mcp__arbor__compact`
- **Instead of reading one file** → use `mcp__arbor__summary`
- **Instead of tracing dependencies** → use `mcp__arbor__dependencies` or `mcp__arbor__impact`
- **To list all types/traits/functions** → use `mcp__arbor__symbols`
- **After making changes** → call `mcp__arbor__reindex`

Start every session with `mcp__arbor__boot`.
```

You can edit `~/.claude/CLAUDE.md` to fine-tune this behavior. For project-specific instructions, add a `CLAUDE.md` in the project root.

Multi-project workspace

arbor auto-detects the project root from the working directory. For monorepos with multiple languages, it indexes all detected facets automatically:

```bash
# Index from repo root — detects Rust + TypeScript + Terraform + Markdown
arbor /path/to/monorepo --compact
```

For separate repos that share types, use the `tunnels` tool to discover cross-project connections.

IDE integration (VS Code / JetBrains)

arbor works through Claude Code's IDE extensions. After installing arbor:

1. Install the [Claude Code extension](https://marketplace.visualstudio.com/items?itemName=anthropic.claude-code) for your IDE
2. arbor is automatically available — Claude will use `boot` and `compact` to understand your project

No additional IDE configuration needed.

Uninstall

**macOS / Linux:**
```bash
curl -fsSL https://raw.githubusercontent.com/nikita-voronoy/arbor/main/scripts/uninstall.sh | bash
```

**Windows (PowerShell):**
```powershell
irm https://raw.githubusercontent.com/nikita-voronoy/arbor/main/scripts/uninstall.ps1 | iex
```

This removes the binary, MCP registration, hooks, and CLAUDE.md instructions.

## How It Works

```mermaid
flowchart LR
    Source[".rs .py .ts .go\n.c .cpp .cs\n.tf .yml .sql"] -- "tree-sitter\nparse" --> Graph["Symbol graph\nfunctions • structs\ncalls • imports"]
    Graph -- "query" --> Tools["MCP tools\nboot • compact\nsearch • refs • impact"]
    Graph -- "persist" --> DB[".arbor/index.bin\n(incremental)"]
```

1. **Index** — tree-sitter parses source files into ASTs. arbor extracts functions, structs, traits, enums, calls, imports, and type references.
2. **Persist** — the graph is saved to `.arbor/`. On re-index, only changed files are re-analyzed (xxh3 content hashing).
3. **Serve** — 14 MCP tools let the LLM explore the graph at any granularity.
4. **Resolve** — cross-file call edges are resolved in a second pass after all files are indexed.

## MCP Tools

| Tool | What it does |
|------|-------------|
| **`boot`** | Get a compact boot screen overview of the project (~170 tokens): project type, file/function/struct counts, top-level modules, key public types. Call this first. |
| **`skeleton`** | Get a compact skeleton showing all symbols (functions, structs, traits, enums) organized by file. Optionally filter by path prefix and control depth. |
| **`compact`** | Get a ultra-compact token-optimized skeleton. Uses abbreviated tags (fn/st/tr/en) and compressed signatures. Best for large codebases where full skeleton is too verbose. |
| **`references`** | Find all references to a symbol: definitions, calls, imports, type refs, implementations. Returns file locations and reference kinds. |
| **`dependencies`** | Get transitive dependencies of a symbol. Direction 'outgoing' (default) shows what it depends on; 'incoming' shows what depends on it. |
| **`impact`** | Impact analysis: find everything that would be affected if the given symbol changes. Shows all transitive dependents. |
| **`search`** | Fuzzy search for symbols by name substring. Set sig=true to search in signatures instead (e.g. find all functions taking `Palace` as a parameter). Results ranked: exact > prefix > contains. |
| **`source`** | Show the source code of a symbol (function, struct, trait, etc.) by name. Returns the actual implementation with line numbers. Use this instead of reading whole files when you know the symbol name. |
| **`callers`** | Find all functions that call a given symbol. Returns caller names with file locations. Simpler than 'references' when you just need to know who calls what. |
| **`summary`** | Get a rich summary of a single file: all symbols with signatures, visibility, and call relationships. More detailed than skeleton for a specific file. |
| **`symbols`** | List all symbols of a given kind across the project. Kinds: fn, struct, trait, enum, macro, module, or 'all'. Useful for getting a project-wide view of types, traits, or entry points. |
| **`implementations`** | Find all types that implement a given trait. Returns implementor names with file locations. |
| **`reindex`** | Re-index the project from scratch. Use after significant file changes. |
| **`tunnels`** | Show cross-project tunnels: shared types and symbols that connect different wings (projects) in a multi-project palace. |

## Performance

Tested on real-world projects (Apple Silicon, parallel parsing with rayon):

| Project | Files | Functions | LOC | Index time | Compact output |
|---------|------:|----------:|----:|:----------:|:--------------:|
| **arbor** | 57 | 244 | 12k | 0.4s | 141 lines |
| **tokio** | 776 | 6,901 | 314k | 2.9s | 623 lines |
| **bevy** | 1,756 | 21,863 | 1.1M | 9.5s | 552 lines |
| **dotnet/runtime** | 37,581 | 522,691 | 28M | 29s | 561 lines |

Incremental re-index (only changed files) is typically **<100ms**.

Token efficiency: arbor vs grep + file reads

arbor's MCP tools return structured, compressed output — dramatically fewer tokens than raw grep + file reads for the same information.

## Supported Languages

| Language | Functions | Structs | Traits | Enums | Calls | Imports |
|----------|:---------:|:-------:|:------:|:-----:|:-----:|:-------:|
| Rust | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Python | ✓ | ✓ | — | — | ✓ | ✓ |
| TypeScript | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| JavaScript | ✓ | ✓ | — | — | ✓ | ✓ |
| Go | ✓ | ✓ | — | — | ✓ | ✓ |
| C | ✓ | ✓ | — | ✓ | ✓ | ✓ |
| C++ | ✓ | ✓ | — | ✓ | ✓ | ✓ |
| C# | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Kotlin | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Java | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |

Non-code formats

| Format | What it indexes |
|--------|----------------|
| Ansible | roles, tasks, handlers, variables, templates, playbooks |
| Terraform | resources, variables, outputs, modules, data sources |
| SQL | tables, columns, foreign keys |
| Protobuf | messages, services, RPCs |
| OpenAPI | endpoints, schemas |
| Markdown | documents, sections, links |

Architecture

```mermaid
graph TB
    subgraph arbor-mcp["arbor-mcp"]
        MCP["MCP server(rmcp over stdio)"]
        CLI["CLI entry point"]
        H["14 tool handlers"]
    end

    subgraph arbor-analyzers["arbor-analyzers"]
        TS["tree-sitter10 languages"]
        IAC["Ansible / Terraform"]
        SCH["SQL / Protobuf / OpenAPI"]
        DOC["Markdown"]
    end

    subgraph arbor-core["arbor-core"]
        G["Graph(Node, EdgeKind)"]
        Q["Query enginesearch / refs / impact"]
        SK["Skeletonboot / compact"]
    end

    subgraph arbor-persist["arbor-persist"]
        ST["Store (bincode)"]
        FH["FileHashes (xxh3)"]
    end

    DET["arbor-detectFacet detection"]

    MCP --> H
    H --> Q
    H --> SK
    arbor-analyzers --> G
    DET --> arbor-analyzers
    G --> ST
    FH --> arbor-analyzers
```

## License

MIT — see [LICENSE](LICENSE).

---

  Built with tree-sitter and MCP

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [nikita-voronoy](https://github.com/nikita-voronoy)
- **Source:** [nikita-voronoy/arbor](https://github.com/nikita-voronoy/arbor)
- **License:** MIT
- **Homepage:** https://github.com/nikita-voronoy/arbor#quick-start

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: flagged — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-nikita-voronoy-arbor
- Seller: https://agentstack.voostack.com/s/nikita-voronoy
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.