GrapeRoot

Compounding Context for AI Coding Assistants

Website · Docs · Benchmarks · Discord

🌐 Read this in your language: English · 中文 · Español · हिंदी · Français · Deutsch · 日本語 · 한국어 · Português · Русский · العربية · Türkçe · Bahasa Indonesia

What is GrapeRoot?

GrapeRoot is an open-source context engine that sits between you and your AI coding assistant. It builds a semantic graph of your codebase — files, symbols, imports, call chains — and pre-loads exactly the right code into every prompt before your AI sees it.

The result: your AI spends tokens reasoning, not exploring.

You run: dgc /path/to/project
              ↓
1. Project scanned → semantic graph built (files, symbols, imports)
2. You ask a question
3. Graph identifies the relevant files → packs them into context
4. AI gets your question + the right code already loaded
5. Fewer turns, fewer tokens, better answers

Token savings compound across a session. The graph remembers which files were read, edited, and queried — each turn gets cheaper.

Other Tools vs GrapeRoot

Other tools (CodeGraph, code-graph-mcp, and similar) give your AI a graph and let it explore:

You ask a question
  → AI calls search_symbol / get_callers / trace_route
  → AI reads results, decides what else to look up
  → AI calls more tools
  → AI finally has enough context to answer

Your AI spends turns exploring before it can reason.

GrapeRoot pre-loads the right context before your AI sees your question:

You ask a question
  → Graph identifies relevant files automatically
  → Files packed into the prompt
  → AI answers immediately

No exploration. No extra tool calls. Your AI starts reasoning from turn one.

Results

Benchmarked across multiple real-world codebases (7,700+ files) and 50+ engineering prompts:

Cost reduction by task type

Savings compound across a session — a token avoided on turn 3 also skips cache re-billing on every subsequent turn. Quality stays equal or improves on every task type above.

Full benchmark methodology and results: graperoot.dev/benchmarks

Supported AI Tools

Supported Languages

TypeScript · JavaScript · Python · Go · Swift · Rust · Java · Kotlin · Scala · C# · Ruby · PHP

Install

macOS / Linux:

curl -sSL https://raw.githubusercontent.com/kunal12203/Codex-CLI-Compact/main/install.sh | bash
source ~/.zshrc   # or ~/.bashrc / ~/.profile

Windows (PowerShell):

irm https://raw.githubusercontent.com/kunal12203/Codex-CLI-Compact/main/install.ps1 | iex

Windows (Scoop):

scoop bucket add dual-graph https://github.com/kunal12203/scoop-dual-graph
scoop install dual-graph

Prerequisites: Python 3.10+, Node.js 18+, and one of the supported AI tools. The installer detects missing tools and offers to install them automatically.

Usage

Important: Always use dgc (not claude directly) to ensure the MCP server is running.

Claude Code

dgc                                      # scan current directory, launch Claude
dgc /path/to/project                     # scan a specific project
dgc /path/to/project "fix the login bug" # start with a prompt

OpenAI Codex CLI

dg                              # scan current directory
dg /path/to/project             # scan a specific project
dg /path/to/project "add tests" # start with a prompt

MiniMax

Set MINIMAX_API_KEY, then select either supported model: MiniMax-M3 or MiniMax-M2.7. The minimax alias uses MiniMax-M3.

export MINIMAX_API_KEY="your-api-key"
dg --model=minimax /path/to/project
dg --model=minimax-m3 /path/to/project
dg --model=minimax-m2.7 /path/to/project

MINIMAX_REGION selects the endpoint region and defaults to global_en. MINIMAX_API_MODE selects the compatible API mode and defaults to openai; set it to anthropic to use the Anthropic-compatible endpoint. The launcher uses a 1,000,000-token context window for MiniMax-M3 and a 204,800-token context window for MiniMax-M2.7.

MINIMAX_REGION=cn_zh dg --model=minimax-m3 /path/to/project
MINIMAX_API_MODE=anthropic dgc --model=minimax-m2.7 /path/to/project

Interactive Picker (new in v3.9.99)

graperoot          # shows directory confirm + arrow-key tool picker
graperoot .        # same, picks from current directory
graperoot --version   # print current version
graperoot --update    # force self-update

OpenCode

dgo                             # scan current directory
dgo /path/to/project            # scan a specific project
dgo /path/to/project "refactor" # start with a prompt

All Tools via graperoot

graperoot . --cursor          # Cursor
graperoot . --gemini          # Gemini CLI
graperoot . --opencode        # OpenCode
graperoot . --copilot         # GitHub Copilot
graperoot . --openclaw        # OpenClaw
graperoot . --kilocode        # Kilocode
graperoot . --mimocode        # MiMo Code
graperoot . --kiro            # Kiro CLI
graperoot . --command-code    # Command Code
graperoot /path --gemini "add tests"   # specific project + prompt

Windows

dgc .                          # from inside the project directory
dgc "D:\projects\my-app"       # any drive, any path
dg "C:\work\backend"           # Codex CLI
dgc --gemini "D:\projects\app" # Gemini CLI on Windows

How It Works

1. Graph scan — on first run, GrapeRoot extracts files, functions, classes, and import relationships into a local graph stored in .dual-graph/.
2. Context retrieval — each time you ask a question, the graph ranks the most relevant files and packs them into the prompt before your AI sees it.
3. Session memory — files you've read, edited, or queried are weighted higher in future turns. Context compounds.
4. MCP tools — your AI can still drill deeper via graph-aware tools (graph_read, graph_retrieve, graph_neighbors) when it needs to explore.

All processing is local. No code leaves your machine.

Data & Files

All data lives in <project>/.dual-graph/ (auto-added to .gitignore):