Struct KnowledgeGraph 

pub struct KnowledgeGraph {
    pub relationship_hierarchy: Option<RelationshipHierarchy>,
    /* private fields */
}

Knowledge graph containing entities and their relationships

Fields

relationship_hierarchy: Option<RelationshipHierarchy>

Hierarchical organization of relationships (Phase 3.1)

Implementations

impl KnowledgeGraph

pub fn new() -> Self

Create a new empty knowledge graph

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

Add a document to the knowledge graph

pub fn add_entity(&mut self, entity: Entity) -> Result<NodeIndex>

Add an entity to the knowledge graph

pub fn add_relationship(&mut self, relationship: Relationship) -> Result<()>

Add a relationship between entities

pub fn add_chunk(&mut self, chunk: TextChunk) -> Result<()>

Add a chunk to the knowledge graph

pub fn get_entity(&self, id: &EntityId) -> Option<&Entity>

Get an entity by ID

pub fn get_document(&self, id: &DocumentId) -> Option<&Document>

Get a document by ID

pub fn get_chunk(&self, id: &ChunkId) -> Option<&TextChunk>

Get a chunk by ID

pub fn get_entity_mut(&mut self, id: &EntityId) -> Option<&mut Entity>

Get a mutable reference to an entity by ID

pub fn get_chunk_mut(&mut self, id: &ChunkId) -> Option<&mut TextChunk>

Get a mutable reference to a chunk by ID

pub fn entities(&self) -> impl Iterator<Item = &Entity>

Get all entities

pub fn entities_mut(&mut self) -> impl Iterator<Item = &mut Entity>

Get all entities (mutable)

pub fn documents(&self) -> impl Iterator<Item = &Document>

Get all documents

pub fn documents_mut(&mut self) -> impl Iterator<Item = &mut Document>

Get all documents (mutable)

pub fn chunks(&self) -> impl Iterator<Item = &TextChunk>

Get all chunks

pub fn chunks_mut(&mut self) -> impl Iterator<Item = &mut TextChunk>

Get all chunks (mutable)

pub fn get_neighbors( &self, entity_id: &EntityId, ) -> Vec<(&Entity, &Relationship)>

Get neighbors of an entity

pub fn get_all_relationships(&self) -> Vec<&Relationship>

Get all relationships in the graph

pub fn load_from_json(file_path: &str) -> Result<Self>

Load knowledge graph from JSON file

pub fn save_to_json(&self, file_path: &str) -> Result<()>

Save knowledge graph to JSON file with optimized format for entities and relationships

pub fn find_entities_by_name(&self, name: &str) -> impl Iterator<Item = &Entity>

Find entities by name (case-insensitive partial match)

pub fn get_entity_by_id(&self, id: &str) -> Option<&Entity>

Get entity by ID (string version for compatibility)

pub fn get_entity_relationships( &self, entity_id: &str, ) -> impl Iterator<Item = &Relationship>

Get entity relationships

pub fn find_relationship_path( &self, entity1: &str, entity2: &str, _max_depth: usize, ) -> Vec<String>

Find relationship path between two entities (simplified BFS)

pub fn entity_count(&self) -> usize

Count entities in the graph

pub fn relationship_count(&self) -> usize

Count relationships in the graph

pub fn document_count(&self) -> usize

Count documents in the graph

pub fn relationships(&self) -> impl Iterator<Item = &Relationship>

Get all relationships as an iterator

pub fn clear_entities_and_relationships(&mut self)

Clear all entities and relationships while preserving documents and chunks

This is useful for rebuilding the graph from scratch without reloading documents.

pub fn dynamic_weight( &self, relationship: &Relationship, query_embedding: Option<&[f32]>, query_concepts: &[String], ) -> f32

Calculate dynamic weight for a relationship based on query context (Phase 2.2)

Combines multiple factors:

• Base weight: relationship.confidence
• Semantic boost: similarity between relationship and query embeddings
• Temporal boost: relevance of temporal range
• Conceptual boost: matching query concepts in relationship type

Arguments

• relationship - The relationship to weight
• query_embedding - Optional embedding vector for the query
• query_concepts - Concepts extracted from the query

Returns

Dynamic weight value (typically 0.0-2.0, can be higher with strong matches)

pub async fn build_relationship_hierarchy( &mut self, num_levels: usize, ollama_client: Option<OllamaClient>, ) -> Result<()>

Build hierarchical organization of relationships (Phase 3.1)

Creates multi-level clusters of relationships using recursive community detection and LLM-generated summaries for efficient retrieval.

Arguments

• num_levels - Number of hierarchy levels to create (default: 3)
• ollama_client - Optional Ollama client for generating cluster summaries

Returns

Result containing the built hierarchy or an error

Example

use graphrag_core::{KnowledgeGraph, ollama::OllamaClient};

let mut graph = KnowledgeGraph::new();
// ... build graph ...

let ollama = OllamaClient::new("http://localhost:11434", "llama3.2");
graph.build_relationship_hierarchy(3, Some(ollama)).await.unwrap();

Trait Implementations

impl Clone for KnowledgeGraph

fn clone(&self) -> KnowledgeGraph

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KnowledgeGraph

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for KnowledgeGraph

fn default() -> Self

Returns the “default value” for a type.