Struct GraphRAG 

pub struct GraphRAG { /* private fields */ }

Main GraphRAG system

This is the primary entry point for using GraphRAG. It orchestrates all components: knowledge graph, retrieval, generation, and caching.

Examples

use graphrag_core::{GraphRAG, Config};

let config = Config::default();
let mut graphrag = GraphRAG::new(config)?;
graphrag.initialize()?;

// Add documents
graphrag.add_document_from_text("Your document text")?;

// Build knowledge graph
graphrag.build_graph()?;

// Query
let answer = graphrag.ask("Your question?")?;
println!("Answer: {}", answer);

Implementations

impl GraphRAG

pub fn new(config: Config) -> Result<Self>

Create a new GraphRAG instance with the given configuration

pub fn default_local() -> Result<Self>

Create a Zero-Config local GraphRAG instance Uses: Candle (MiniLM) for embeddings, Memory/LanceDB for storage, Ollama for LLM

pub fn builder() -> GraphRAGBuilder

Create a builder for configuring GraphRAG

Example

use graphrag_core::GraphRAG;

let graphrag = GraphRAG::builder()
    .with_output_dir("./workspace")
    .with_chunk_size(512)
    .build()?;

pub fn initialize(&mut self) -> Result<()>

Initialize the GraphRAG system.

When auto_save.enabled = true and a base_dir is configured, attempts to load an existing graph from the workspace on disk before starting fresh. This means a second run reuses the previously built graph automatically.

pub fn save_to_workspace(&self) -> Result<()>

Save the current knowledge graph to the configured workspace on disk. No-op when auto_save.enabled = false or base_dir is not set.

pub fn add_document_from_text(&mut self, text: &str) -> Result<()>

Add a document from text content

pub fn add_document(&mut self, document: Document) -> Result<()>

Add a document to the system

pub fn clear_graph(&mut self) -> Result<()>

Clear all entities and relationships from the knowledge graph

This method preserves documents and text chunks but removes all extracted entities and relationships. Useful for rebuilding the graph from scratch without reloading documents.

pub async fn build_graph(&mut self) -> Result<()>

Build the knowledge graph from added documents

This method implements dynamic pipeline selection based on the configured approach:

• Semantic (config.approach = “semantic”): Uses LLM-based entity extraction with gleaning for high-quality results. Requires Ollama to be enabled.
• Algorithmic (config.approach = “algorithmic”): Uses pattern-based entity extraction (regex + capitalization) for fast, resource-efficient processing.
• Hybrid (config.approach = “hybrid”): Combines both approaches with weighted fusion.

The selection is controlled by config.approach and mapped from TomlConfig’s [mode] section.

pub async fn ask_with_reasoning(&mut self, query: &str) -> Result<String>

Query the system associated with reasoning (Query Decomposition) This splits the query into sub-queries, gathers context for all of them, and synthesizes an answer.

pub async fn ask(&mut self, query: &str) -> Result<String>

Query the system for relevant information

pub async fn ask_explained(&mut self, query: &str) -> Result<ExplainedAnswer>

Query the system and return an explained answer with reasoning trace

Unlike ask(), this method returns detailed information about:

• Confidence score
• Source references
• Step-by-step reasoning
• Key entities used

Example

use graphrag_core::prelude::*;

let mut graphrag = GraphRAG::quick_start("Your document text").await?;
let explained = graphrag.ask_explained("What is the main topic?").await?;

println!("Answer: {}", explained.answer);
println!("Confidence: {:.0}%", explained.confidence * 100.0);

for step in &explained.reasoning_steps {
    println!("Step {}: {}", step.step_number, step.description);
}

for source in &explained.sources {
    println!("Source: {} (relevance: {:.0}%)",
        source.id, source.relevance_score * 100.0);
}

pub async fn query_internal(&mut self, query: &str) -> Result<Vec<String>>

Internal query method (public for CLI access to raw results)

pub fn config(&self) -> &Config

Get a reference to the current configuration

pub fn is_initialized(&self) -> bool

Check if system is initialized

pub fn has_documents(&self) -> bool

Check if documents have been added

pub fn has_graph(&self) -> bool

Check if graph has been built

pub fn knowledge_graph(&self) -> Option<&KnowledgeGraph>

Get a reference to the knowledge graph

pub fn get_entity(&self, entity_id: &str) -> Option<&Entity>

Get entity details by ID

pub fn get_entity_relationships(&self, entity_id: &str) -> Vec<&Relationship>

Get all relationships involving an entity

pub fn get_chunk(&self, chunk_id: &str) -> Option<&TextChunk>

Get chunk by ID

pub fn knowledge_graph_mut(&mut self) -> Option<&mut KnowledgeGraph>

Get a mutable reference to the knowledge graph

pub fn from_config_file<P: AsRef<Path>>(path: P) -> Result<Self>

Create GraphRAG from a config file (auto-detect format: TOML, JSON5, YAML, JSON)

This method automatically detects the config file format based on the file extension and loads it appropriately.

Supported formats:

• .toml - TOML format
• .json5 - JSON5 format (requires json5-support feature)
• .yaml, .yml - YAML format
• .json - JSON format

Examples

use graphrag_core::GraphRAG;

// Auto-detect format from extension
let graphrag = GraphRAG::from_config_file("config/templates/symposium_zero_cost.graphrag.json5")?;

pub async fn from_config_and_document<P1, P2>( config_path: P1, document_path: P2, ) -> Result<Self>

where P1: AsRef<Path>, P2: AsRef<Path>,

Complete workflow: load config + process document + build graph

This is the most convenient method for getting started with GraphRAG. It:

1. Loads the config file (auto-detecting the format)
2. Initializes the GraphRAG system
3. Loads and processes the document
4. Builds the knowledge graph

After this method completes, the GraphRAG instance is ready to answer queries.

Examples

use graphrag_core::GraphRAG;

// Complete workflow in one call
let mut graphrag = GraphRAG::from_config_and_document(
    "config/templates/symposium_zero_cost.graphrag.json5",
    "docs-example/Symposium.txt"
).await?;

// Ready to query
let answer = graphrag.ask("What is Socrates' view on love?").await?;
println!("Answer: {}", answer);

pub async fn quick_start(text: &str) -> Result<Self>

Quick start: Create a ready-to-query GraphRAG instance from text in one call

This is the simplest way to get started with GraphRAG. It:

1. Creates a new instance with default or hierarchical configuration
2. Initializes all components
3. Processes your text document
4. Builds the knowledge graph

After this call, you can immediately use ask() to query the system.

Example: Hello World in 5 lines

use graphrag_core::prelude::*;

let mut graphrag = GraphRAG::quick_start("Your document text here").await?;
let answer = graphrag.ask("What is this document about?").await?;
println!("{}", answer);

Configuration

• With hierarchical-config feature: Uses layered config (defaults → user → project → env)
• Without: Uses sensible defaults optimized for local Ollama setup

pub async fn quick_start_with_config<F>( text: &str, configure: F, ) -> Result<Self>

where F: FnOnce(GraphRAGBuilder) -> GraphRAGBuilder,

Quick start with custom configuration

Like quick_start(), but allows you to customize the configuration using the builder pattern before processing the document.

Example

use graphrag_core::prelude::*;

let mut graphrag = GraphRAG::quick_start_with_config(
    "Your document text",
    |builder| builder
        .with_chunk_size(256)
        .with_ollama_enabled(true)
).await?;