Codegraph Rust

AI coding assistants are powerful, but they're flying blind. They see files one at a time, grep for patterns, and burn tokens trying to understand your architecture. Every conversation starts from zero.

What if your AI assistant already knew your codebase?

1. Graph + Embeddings = True Understanding

Most semantic search tools create embeddings and call it a day. CodeGraph builds areal knowledge graph:

Your Code → Build Context → AST + FastML → LSP Resolution → Enrichment → Graph + Embeddings ↓ ↓ ↓ ↓ ↓ ↓ Packages Nodes/edges Type-aware API surface Graph Semantic Features Fast patterns linking Module graph traversal search Targets Spans Definitions Dataflow/Docs (hybrid)

When you search, you don't just get "similar code"—you get code with itsrelationships intact. The function that matches your query, plus what calls it, what it depends on, and where it fits in the architecture.

- Module nodes and module-level import/containment edges for cross-file navigation
- Rust-local dataflow edges (defines,uses,flows_to,returns,mutates) for impact analysis
- Document/spec nodes linked to backticked symbols inREADME.md,docs//.md, andschema//.surql
- Architecture signals (package cycles + optional boundary violations)

Indexing is tiered so you can choose between speed/storage and graph richness. The default isfast.

- fast: disables build context, LSP, enrichment, module linking, dataflow, docs/contracts, and architecture; filters outUses/Referencesedges.
- balanced: enables build context, LSP symbols, enrichment, module linking, and docs/contracts; filters outReferencesedges.
- full: enables all analyzers and LSP definitions; no edge filtering.

CodeGraph implements agents usingRigthe default and recommended choice (legacyreactandlatsimplemented with autoagents still work). Selectable at runtime viaCODEGRAPH_AGENT_ARCHITECTURE=rig:

Why Rig is Default:The Rig-based backend delivers the best performance with modern thinking and reasoning models. It is a native Rust implementation that supports internal sub-architectures and provides features likeTrue Token StreamingandAutomatic Recovery.

Internal Rig Sub-Architectures:When using therigbackend, the system automatically maps theconsolidated agentic toolsto the most effective reasoning strategy:

- LATS (Tree Search): Deep multi-path exploration for complex, non-linear tasks.

- Automatically used for:agentic_architecture(structure),agentic_quality, andagentic_context(question).

- Automatically used for:agentic_context(search/builder),agentic_impact, andagentic_architecture(api_surface).

Agents can start with lightweight project context so their first tool calls are not blind. Enable via env:

- CODEGRAPH_ARCH_BOOTSTRAP=true— includes a brief directory/structure bootstrap + contents of README.md and CLAUDE.md+AGENTS.md or GEMINI.md (if present) in the agent’s initial context.
- CODEGRAPH_ARCH_PRIMER="<primer text>"— optional custom primer injected into startup instructions (e.g., areas to focus on).

Why? Faster, more relevant early steps, fewer wasted graph/semantic queries, and better architecture answers on large repos.

- Bootstrap is small (top directories summary), not a replacement for graph queries.
- Uses the same project selection as indexing (CODEGRAPH_PROJECT_IDor current working directory).

# Use Rig for best performance with thinking and reasoning models (recommended) CODEGRAPH_AGENT_ARCHITECTURE=rig ./codegraph start stdio # Use default ReAct for traditional instruction models ./codegraph start stdio # Use LATS for complex analysis CODEGRAPH_AGENT_ARCHITECTURE=lats ./codegraph start stdio

All architectures use the same 4 consolidated agentic tools (backed by 6 internal graph analysis tools) and tier-aware prompting—only the reasoning strategy differs.

Here's something clever: CodeGraph automatically adjusts its behavior based on the LLM's context window that you configured for the codegraph agent.

Running a small local model? Get focused, efficient queries.

Using GPT-5.1 or Claude with 200K context? Get comprehensive, exploratory analysis.

Using grok-4-1-fast-reasoning with 2M context? Get detailed analysis with intelligent result management.

The Agent only uses the amount of steps that it requires to produce the answer so tool execution times vary based on the query and amount of data indexed in the database.

During development the agent used 3-6 steps on average to produce answers for test scenarios.

The Agent is stateless it only has conversational memory for the span of tool execution it does not accumulate context/memory over multiple chained tool calls this is already handled by your client of choice, it accumulates that context so codegraph needs to just provide answers.

Hard cap:Maximum 8 steps regardless of tier (10 with env override). This prevents runaway costs and context overflow while still allowing thorough analysis.

Same tool, automatically optimized for your setup.

CodeGraph includes multi-layer protection against context overflow—preventing expensive failures when tool results exceed your model's limits.

- Each tool result is limited based on your configured context window
- Large results (e.g., dependency trees with 1000+ nodes) are intelligently truncated
- Truncated results include_truncated: truemetadata so the agent knows data was cut
- Array results keep the most relevant items that fit within limits

- Monitors total accumulated context across multi-step reasoning
- Fails fast with clear error message if accumulated tool results exceed safe threshold
- Threshold: 80% of context window × 4 (conservative estimate for token overhead)

# CRITICAL: Set this to match your agent's LLM context window CODEGRAPH_CONTEXT_WINDOW=128000 # Default: 128K # Per-tool result limit derived automatically: context_window × 2 bytes # Accumulation limit derived automatically: context_window × 4 × 0.8 bytes

Why this matters:Without these guards, a singleagentic_impactquery on a large codebase could return 6M+ tokens—far exceeding most models' limits and causing expensive failures.

We don't pick sides in the "embeddings vs keywords" debate. CodeGraph combines:

- 70% vector similarity(semantic understanding)
- 30% lexical search(exact matches matter)
- Graph traversal(relationships and context)
- Optional reranking(cross-encoder precision)

The result? You findhandleUserAuthwhen you search for "login logic"—but also when you search for "handleUserAuth".

When you connect CodeGraph to Claude Code, Cursor, or any MCP-compatible agent:

Before:Your AI reads files one by one, grepping around, burning tokens on context-gathering.

After:Your AI callsagentic_impact({"query": "UserService"})and instantly knows what breaks if you refactor it.

This isn't incremental improvement. It's the difference between an AI thatsearchesyour code and one thatunderstandsit.

CodeGraph shifts thecognitive load(search + relevance + dependency reasoning) into CodeGraph’s agentic tools, so your code agent can spend its context budget onmaking the change, notdiscovering what to change.

agentic_impactreturns structured output (file paths, line numbers, and bounded snippets/highlights) plus analysis:

Key insight:The agentic tools don't just call one function. Theyreason*about which graph operations to perform, chain them together, and synthesize results. A singleagentic_impactcall might:
- Search for the target component semantically
- Get its direct dependencies
- Trace transitive dependencies
- Check for circular dependencies
- Calculate coupling metrics
- Identify hub nodes that might be affected
- Synthesize all findings into an actionable answer