代码智能引擎

System Requirements

No Docker, no Python, no Node.js required — everything is self-contained.

Requirements

• Java 11+ — the ANTLR interpreter runs in a JVM subprocess
• No Rust toolchain needed — grammar plugins are pure config + .g4 files

Prerequisites

Install CMake (required by lbug graph DB)

winget install Kitware.CMake

Install (one-liner)

macOS / Linux:

curl -fsSL https://raw.githubusercontent.com/intuit/infigraph/main/install.sh | bash

Windows (PowerShell):

iwr https://raw.githubusercontent.com/intuit/infigraph/main/install.ps1 -UseBasicParsing | iex

Installation

Uninstall

infigraph uninstall

Removes: - MCP server config from all 11 AI agents - Primary search instructions from ~/.claude/CLAUDE.md

Does NOT delete the binary — remove ~/.local/bin/infigraph and ~/.local/bin/infigraph-mcp manually if desired.

---

Building from Source

Windows (native build)

Build natively on a Windows machine. Cross-compiling from macOS is not currently supported — LadybugDB (lbug) requires C++20 <format> (GCC 13+), but available cross-compilation Docker images ship GCC 9.

```powershell

Install Rust

winget install Rustlang.Rustup

Install Visual Studio Build Tools with C++ workload

winget install Microsoft.VisualStudio.2022.BuildTools

Clone and build

git clone https://github.com/intuit/infigraph.git cd infigraph cargo build --release -p infigraph-cli -p infigraph-mcp

Build for Intel Mac (from ARM64 machine)

cargo build --release --target x86_64-apple-darwin -p infigraph-cli -p infigraph-mcp ```

Setup as Primary Search

After install, register Infigraph as the primary search engine for all AI coding agents:

infigraph install

This does four things: 1. Registers infigraph-mcp as an MCP server for 11 agents: Claude Code, Cursor, VS Code, Codex, Gemini CLI, Zed, OpenCode, Aider, Windsurf, Kiro, GitHub Copilot 2. Writes primary search instructions to ~/.claude/CLAUDE.md so AI agents prefer Infigraph over raw grep/glob 3. Installs Claude Code hooks — enforcement hook (warns on raw search) + session save hooks (auto-save context on compaction) 4. Configures Claude Code allowlist — adds all Infigraph MCP tools to ~/.claude/settings.local.json permissions

Then index your projects: ```bash cd /path/to/project infigraph index

Full reindex (clean rebuild from scratch):

infigraph index --full ```

Every search, symbol lookup, and code navigation now goes through Infigraph's graph — saving 60-80% of tokens versus raw file reads.

SCIP Integration (Compiler-grade Enrichment)

Infigraph natively imports SCIP indexes to enrich the graph with precise compiler-grade symbols, types, and cross-file relationships. SCIP indexers are auto-downloaded — infigraph index detects project languages and fetches the right indexer binaries (with portable runtimes for Node.js, JRE, .NET, Dart, PHP) on first use:

```bash

Quick Start

Usage Examples

Quick start: adding a new language

1. Create a grammar plugin directory:

   ~/.infigraph/grammars/my-lang/
   ├── MyLang_Lexer.g4      # ANTLR lexer grammar
   ├── MyLang_Parser.g4     # ANTLR parser grammar
   └── plugin.toml          # Extension mapping + extraction rules
   

2. Write plugin.toml:

   [language]
   name = "my-lang"
   extensions = [".ml", ".myl"]
   entry_rule = "program"
   lexer = "MyLang_Lexer.g4"
   parser = "MyLang_Parser.g4"
   strip_preprocessor = false   # true if files have #include/#ifdef lines

   [[entities]]
   rule = "functionDecl"        # ANTLR parser rule name
   kind = "Function"            # Symbol kind (Function, Method, Class, Variable, etc.)
   name_child = "identifier"    # Child rule that holds the name
   scope = true                 # Creates a scope (section/function boundary)

   [[entities]]
   rule = "classDecl"
   kind = "Class"
   name_child = "identifier"
   scope = true

   [[relations]]
   rule = "functionCall"
   kind = "Calls"
   target_child = "identifier"

   [[relations]]
   rule = "fieldAccess"
   kind = "Reads"
   target_child = "fieldName"
   condition = "has_token:."    # Only match when DOT token is present
   

3. Index your project — infigraph discovers the plugin automatically:

   infigraph -r /path/to/project index
   

CLI usage

infigraph ingest --schema api_endpoints --data-file endpoints.json infigraph ingest --schema api_endpoints --source ./data/endpoints/

Manual CLI (Optional)

infigraph search "auth"                    # Hybrid search
infigraph query "MATCH (...)"              # Cypher queries
infigraph trace-callers "function_name"   # Who calls this?
infigraph dead-code                        # Find unused functions
infigraph impact "auth.py::authenticate"   # Blast radius

---

CI Check Configuration

Configure quality gates via check.toml:

[security]
enabled = true
max_critical = 0
max_high = 5

[complexity]
enabled = true
threshold = 15
max_violations = 10

[dead_code]
enabled = true
max_dead = 20

Extraction rule reference

Entity mappings ([[entities]])

Relation mappings ([[relations]])

.infigraph/structured-schemas/api_endpoints.toml

schema_id = "api_endpoints" name = "API Endpoints" node_table = "Endpoint"

[[columns]] name = "id" col_type = "STRING" primary = true

[[columns]] name = "url" col_type = "STRING"

[[columns]] name = "method" col_type = "STRING"

[[edges]] name = "HANDLED_BY" from_table = "Endpoint" to_table = "Symbol" from_column = "id" to_column = "handler" resolve_symbol = true # auto-resolves handler names to Symbol nodes

Discovery paths: `.infigraph/structured-schemas/`, `.terragraph/schemas/`, `~/.infigraph/structured-schemas/`

tool: ingest_structured { schema_id: "api_endpoints", data_file: "endpoints.json" }

```

Grammar Plugins (ANTLR)

Infigraph supports runtime-loaded ANTLR grammar plugins. Drop .g4 grammar files + a plugin.toml config into a directory — infigraph parses the language automatically via a JVM subprocess. No Rust compilation needed.

Plugin discovery

Plugins are loaded from two locations: - ~/.infigraph/grammars/*/plugin.toml — user-level (all projects) - <project>/grammars/*/plugin.toml — project-level (per repo)

Project-level plugins take precedence.

Pipeline Plugins

Runtime-extensible pipeline metadata extraction — add new data pipeline formats (dbt, Airflow, custom) without recompiling. Each plugin is a subprocess with JSON IPC.

Full Pipeline Plugins Guide →

Quick overview: - Drop a plugin.toml + extractor binary in ~/.infigraph/pipelines/<name>/ or <project>/pipelines/<name>/ - Infigraph auto-discovers plugins, detects matching documents, extracts metadata via subprocess - Shared PipelineCore table enables cross-plugin dependency graphs and impact analysis - 5 MCP tools: pipeline_plugins, pipeline_deps, pipeline_impact, pipeline_compliance, pipeline_query

Integration

• 82 MCP tools for AI coding agents
• 11 agent auto-configs — Claude Code, Cursor, VS Code, Codex, Gemini CLI, Zed, OpenCode, Aider, Windsurf, Kiro, GitHub Copilot
• Web UI at localhost:9749 with graph explorer, search, route map, multi-repo groups, contracts
• Export — Neo4j Cypher, GraphML, JSON

Architecture: tree-sitter vs grammar plugins

Both backends produce the same Symbol + Relation output. Everything downstream (graph, search, analysis, MCP tools) is backend-agnostic.

Troubleshooting