Your AI agent wastes thousands of tokens reading files over and over.
Give it a code graph instead.

Install • CLI • MCP Server • Graph Server • Languages

StakGraph parses source code into a graph of functions, classes, endpoints, data models, tests, and their relationships -- using tree-sitter, instantly, with zero config.

1. CLI -- install in 10 seconds, point at any file or directory
2. MCP server -- plug into Cursor, Claude Code, Windsurf, OpenCode
3. Graph server -- Neo4j-backed querying, embedding, and visualization

Install

curl -fsSL https://raw.githubusercontent.com/stakwork/stakgraph/refs/heads/main/install.sh | bash

Pre-built binaries for Linux (x86_64, aarch64), macOS (Intel, Apple Silicon), and Windows.

CLI

Point stakgraph at a file, directory, or git scope to inspect code structure instead of raw text.

Most useful commands

Parse a file and print extracted nodes:

stakgraph mcp/src/index.ts
stakgraph cli/src/main.rs --stats

Get a compact repo overview:

stakgraph overview .

Search for endpoints, functions, models, or tests:

stakgraph search GET --type Endpoint mcp/src
stakgraph search batch_process --context ast/src

Inspect structural git changes:

stakgraph changes diff --last 5 mcp/src/
stakgraph changes list cli/src

Trace dependencies forward or backward:

stakgraph deps batch_process ast/src
stakgraph impact --name cn cli/

Useful flags:

stakgraph <path> --json        # machine-readable output
stakgraph <path> --type Class  # filter node types
stakgraph <path> --name main   # print a single named node
stakgraph completions zsh      # shell completions

What it extracts

StakGraph understands the semantic structure of code, not just syntax:

| Node Type | Examples | | ------------- | ----------------------------------------------------- | | Function | Functions, methods, handlers, callbacks | | Endpoint | HTTP routes (GET /users, POST /api/v1/login) | | Request | HTTP client calls to external services | | DataModel | Structs, interfaces, types, enums, schemas | | Class | Classes with method ownership | | Trait | Interfaces, abstract classes, protocols | | Test | Unit tests, integration tests, E2E tests (classified) | | Import | Module imports with resolution |

And the relationships between them:

| Edge Type | Meaning | | -------------- | ----------------------------------- | | Calls | Function A calls Function B | | Handler | Endpoint handled by Function | | Contains | File/Module contains Function/Class | | Operand | Class owns Method | | Implements | Class implements Trait | | ParentOf | Class inheritance |

Languages

16 languages with framework-aware parsing:

| Language | Frameworks | | -------------- | ------------------------- | | TypeScript | React, Express, Nest.js | | JavaScript | React, Express | | Python | FastAPI, Django, Flask | | Go | Gin, Echo, net/http | | Rust | Axum, Actix, Rocket | | Ruby | Rails (routes, ERB, HAML) | | Java | Spring Boot | | Kotlin | Spring, Ktor | | Swift | Vapor | | C# | ASP.NET | | PHP | Laravel | | C / C++ | | | Angular | Components, services | | Svelte | Components | | Bash | | | TOML | Config parsing |

MCP Server

The MCP server exposes StakGraph's graph intelligence to AI agents running in Cursor, Claude Code, Windsurf, OpenCode, or any MCP-compatible editor.

Tools

| Tool | What it does | | ------------------------- | ------------------------------------------------------------------------------- | | stakgraph_search | Fulltext or vector (semantic) search across the codebase graph | | stakgraph_map | Visual map of code relationships from any node (configurable depth & direction) | | stakgraph_code | Retrieve actual code from a subtree | | stakgraph_shortest_path | Find shortest path between two nodes in the graph | | stakgraph_rules_files | Fetch rules/instructions files (.cursorrules, AGENTS.md, etc.) |

Built-in agents

• Explore Agent -- AI-driven codebase exploration using the "zoom pattern" (Overview → Files → Functions → Dependencies). Configurable LLM provider (Anthropic, OpenAI, Google, OpenRouter).
• Describe Agent -- Generates descriptions for undocumented nodes and stores embeddings for semantic search.
• Docs Agent -- Summarizes documentation and rules files across the repo.
• Mocks Agent -- Scans for 3rd-party service integrations and records mock coverage.

Gitree: Feature knowledge from git history

Gitree extracts feature-level knowledge from PR and commit history using LLM analysis:

yarn gitree process <owner> <repo>     # extract features from PR history
yarn gitree summarize-all              # generate docs for all features
yarn gitree search-clues "auth flow"   # semantic search across architectural clues

Builds a knowledge base of Features, PRs, Commits, and Clues (architectural insights like patterns, conventions, gotchas, data flows). Links them to code entities in the graph.

Graph Server

For full-scale codebase indexing, StakGraph runs as an HTTP server backed by Neo4j:

docker-compose up    # starts Neo4j + StakGraph server on port 7799

Ingest repositories

# Parse one or more repos into the graph
export REPO_URL="https://github.com/org/backend.git,https://github.com/org/frontend.git"
cargo run --bin index

Endpoints and requests are linked across repos -- a POST /api/users endpoint in the backend connects to the fetch("/api/users") request in the frontend.

Query the graph

The graph stores 21 node types and 13 edge types. Query with Cypher, search with fulltext or vector similarity, or use the MCP tools.

Vector search

Code is embedded using BGE-Small-EN-v1.5 (384 dimensions) via fastembed. Weighted pooling prioritizes function signatures. Search semantically across the entire codebase:

POST /search
{ "query": "user authentication middleware", "limit": 10 }

API endpoints

| Endpoint | Description | | --------------------- | --------------------------------------- | | POST /process | Parse and index a repository | | POST /embed_code | Generate embeddings for code | | GET /search | Fulltext or vector search | | GET /map | Relationship map from a node | | GET /shortest_path | Path between two nodes | | GET /tests/coverage | Test coverage analysis | | POST /ingest_async | Background repo ingestion with webhooks |

Architecture

stakgraph/
├── ast/          # Core Rust library: tree-sitter parsing → graph of nodes & edges
├── cli/          # CLI binary: parse, summarize, diff
├── lsp/          # LSP integration for precise symbol resolution
├── standalone/   # Axum HTTP server wrapping the ast library
├── mcp/          # TypeScript MCP server with agents, gitree, vector search
└── shared/       # Shared types

The ast crate is the engine. It takes source files, runs tree-sitter queries to extract nodes, resolves cross-file calls (optionally via LSP), and produces a graph. The graph can be:

• In-memory (ArrayGraph) -- used by the CLI, fast, no dependencies
• Neo4j (Neo4jGraph) -- persistent, queryable, used by the server

Contributing

cargo test                # run tests
USE_LSP=1 cargo test      # run tests with LSP resolution

You may need to install LSPs:

# TypeScript
npm install -g typescript typescript-language-server
Go
go install golang.org/x/tools/gopls@latest
Rust
rustup component add rust-analyzer
Python
pip install python-lsp-server

github.com/stakwork/stakgraph