TigerGraph GraphRAG v2.0

On 1 July 2026, TigerGraph released GraphRAG v2.0, a major update to their open-source GraphRAG framework. The release introduces three capabilities that shift GraphRAG from a retrieval pattern to a autonomous reasoning layer: an agentic chat engine, external MCP tool integration, and structure-aware document chunking.

Agentic Chat Engine

The headline feature is the agentic chat engine, which operates in two modes:

Planner mode decomposes a user query into a retrieval plan before executing any search. Given a complex question — "What is our aggregate supply chain exposure to the new EU battery regulations across all Asian suppliers?" — the planner identifies the entities involved (suppliers, regulations, components, products), the relationships to traverse (supplies, regulated-by, contains), and the order of operations. It then executes each retrieval step and assembles the results into a coherent context window for the LLM.

Reactive mode starts with an initial retrieval, evaluates whether the returned context is sufficient to answer the question, and iteratively expands the search along graph edges until it has enough evidence. This is analogous to how a human researcher reads an initial result, identifies gaps, and follows references.

Feature	Planner Mode	Reactive Mode
Query approach	Decompose-then-retrieve	Retrieve-then-evaluate-then-expand
Best for	Known-complex queries with clear structure	Exploratory queries where the path is uncertain
Latency	Higher initial latency, fewer iterations	Lower initial latency, may need more iterations
Determinism	Fully deterministic plan	Path-dependent

The Retrieval Plan in GSQL

The planner's decomposition maps directly onto a compiled GSQL query. Because TigerGraph compiles GSQL to C++ at install time, the agentic engine can execute each planned retrieval step as a pre-installed query rather than interpreting Cypher-style pattern matching at runtime:

CREATE QUERY supply_chain_exposure(STRING supplierCountry) FOR GRAPH enterprise {
  // Step 1: anchor on the regulation entity
  Start = {Regulation.*};
  Batteries = SELECT b
    FROM Start:r -(REGULATES)- Battery:b
    WHERE r.name == "EU Critical Minerals Regulation"
    ACCUM b.@exposure = 1;

  // Step 2: traverse supplier → component → product chains
  Suppliers = SELECT s
    FROM Batteries:b -(CONTAINS)- Component:c -(SUPPLIED_BY)- Supplier:s
    WHERE s.country == supplierCountry
    ACCUM s.@productCount += 1;

  // Step 3: aggregate exposure for the context window
  PRINT Suppliers {s.name, s.country, s.@productCount};
}

Each SELECT block is a single retrieval step. The planner decides the order of blocks and which branches to prune; the compiled query executes them without per-step LLM orchestration. This separation is what lets planner mode stay deterministic while the LLM only assembles the final context window.

MCP Tool Integration

GraphRAG v2.0 integrates with the Model Context Protocol, allowing the chat engine to invoke external tools during the retrieval process. The agentic engine can call out to:

• External knowledge bases and document stores via vector search
• Enterprise APIs (CRM, ERP, ticketing systems) to enrich graph context
• Code execution environments for dynamic analysis
• Web search for current-events grounding

Each MCP tool is registered with a schema describing its inputs, outputs, and cost profile. The planner selects tools based on the retrieval plan; the reactive engine discovers tools as needed based on context gaps.

A tool registration in the v2.0 runtime looks like this:

{
  "name": "vector_search",
  "description": "Semantic search over indexed document chunks",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": {"type": "string"},
      "top_k": {"type": "integer", "default": 5},
      "collection": {"type": "string"}
    },
    "required": ["query"]
  },
  "cost": {"perCall": 0.002, "currency": "USD"},
  "maxCallsPerPlan": 4
}

The maxCallsPerPlan budget is enforced by the planner, preventing the agentic engine from burning through external API calls on open-ended explorations. Cost profiles let the planner prefer cheap local retrieval over expensive external lookups when the retrieval plan has multiple viable branches.

Structure-Aware Document Chunking

Previous GraphRAG implementations used fixed-size or semantic-similarity chunking, which frequently splits document sections across chunk boundaries, losing the structural context that graphs need. V2.0 introduces structure-aware chunking that respects document hierarchy:

# Example configuration for structure-aware chunking
{
  "chunking": {
    "strategy": "structure_aware",
    "boundaries": ["h1", "h2", "h3", "table", "list"],
    "min_chunk_size": 256,
    "max_chunk_size": 2048,
    "preserve_tables": true,
    "preserve_code_blocks": true
  }
}

Chunks align with document sections, tables, and code blocks, ensuring that entities extracted from a chunk have the correct section-level context. This improves entity disambiguation and relationship extraction quality, particularly for technical documentation where meaning depends on section context.

Deployment Architecture

V2.0 introduces an additive prompt customisation system that allows enterprise teams to inject domain-specific instructions into each stage of the retrieval pipeline without forking the codebase. Prompts can be configured per graph, per user role, or per retrieval mode.

The release also includes a knowledge graph compatibility check and repair tool that automatically detects and fixes schema drift when graph structure changes between indexing runs — a practical improvement for production deployments where graph schemas evolve.

The repair flow is declarative: the tool compares the current schema against the schema captured at index time, then emits remediation steps:

$ graphrag schema-check --graph enterprise --baseline .graphrag/schema-2026-07-01.json

[WARN] relationship SUPPLIED_BY: source label changed from Supplier -> Vendor
       → 274 indexed chunks reference the old label
[INFO] relationship REGULATES: endpoint cardinality changed 1:1 -> 1:N
       → no chunk impact
[FIX]  proposed: apply relabel SUPPLIED_BY.source in 274 chunks
       run: graphrag schema-repair --graph enterprise --apply relabel-7f3c

Because the tool operates on the graph schema, not on document content, it does not require a full re-index. Teams can run it as a pre-flight check in CI before rolling a new ingestion batch, catching drift before it silently degrades retrieval quality.

Enterprise Value

For teams already running GraphRAG in production, v2.0's agentic engine changes the operational model from "ask the right question" to "describe the goal." The planner and reactive modes handle retrieval strategy selection, reducing the need for query engineering. The MCP integration extends reach beyond the knowledge graph without leaving the GraphRAG execution context.

The release is available at github.com/tigergraph/graphrag under a permissive license, with documentation covering migration from v1.x and configuration guides for the new agentic modes.

For a broader survey of how TigerGraph's agentic approach fits into the GraphRAG landscape, see GraphRAG Variants Compared (2026). On the operational side, the schema-repair and monitoring patterns complement the deployment guidance in Deploying GraphRAG in Production. And for the MCP protocol that the agentic engine uses to reach external tools, see MCP Servers: The Future of AI Integration.