Struct RelationshipGraph 

pub struct RelationshipGraph { /* private fields */ }

Relationship graph for entity context

Implementations

impl RelationshipGraph

pub fn new() -> RelationshipGraph

Create a new empty relationship graph.

pub fn from_entity_store(store: &EntityStore) -> RelationshipGraph

Build graph from entity store

pub fn add_node(&mut self, node: GraphNode)

Add a node to the graph

pub fn add_edge(&mut self, edge: GraphEdge)

Add an edge to the graph

pub fn add_relationship(&mut self, rel: &Relationship)

Add relationship as edge

pub fn get_node(&self, name: &str) -> Option<&GraphNode>

Get node by name

pub fn get_neighbors(&self, name: &str) -> Vec<&GraphNode>

Get all neighbors of a node

pub fn get_edges(&self, name: &str) -> Vec<&GraphEdge>

Get edges for a node

pub fn find_path(&self, from: &str, to: &str) -> Option<Vec<String>>

Find shortest path between two entities using BFS

pub fn get_entity_context( &self, entity: &str, max_depth: usize, ) -> EntityContext

Get all context related to an entity (traverses graph)

pub fn search(&self, query: &str, limit: usize) -> Vec<&GraphNode>

Find entities most relevant to a query (by name matching)

pub fn stats(&self) -> GraphStats

Get graph statistics

pub fn get_impact_set(&self, entity: &str, depth: usize) -> Vec<ImpactedEntity>

Get entities that would be impacted by changes to a given entity. Traverses the graph to find dependent entities up to a specified depth.

pub fn find_clusters(&self) -> Vec<EntityCluster>

Find clusters of related entities using connected component analysis

pub fn suggest_related(&self, entities: &[&str]) -> Vec<SuggestedEntity>

Suggest related entities given a set of entities. Uses co-occurrence and relationship analysis.

pub fn get_central_nodes(&self, limit: usize) -> Vec<&GraphNode>

Get the most central nodes in the graph (by connectivity)

pub fn spectral_clusters(&self, k: usize) -> Vec<EntityCluster>

Find semantic communities within connected components using spectral clustering.

Unlike find_clusters which only finds connected components, this method discovers tightly-coupled groups within a connected component by analyzing the graph’s spectral properties (Fiedler vector of the Laplacian).

Arguments

• k - Number of clusters to find. If the graph has fewer natural clusters, fewer may be returned.

pub fn spectral_central_nodes(&self, limit: usize) -> Vec<(&GraphNode, f32)>

Compute spectral centrality for all nodes.

Returns nodes sorted by spectral centrality (highest first). Nodes with high centrality are structural bridges between communities — important for understanding cross-cutting concerns in the codebase.

This complements get_central_nodes which uses degree centrality. Spectral centrality captures structural position rather than just connection count.

pub fn connectivity(&self) -> f32

Compute the algebraic connectivity of this graph.

This is the second-smallest eigenvalue of the Laplacian, measuring how well-connected the graph is:

• 0 = disconnected (multiple components)
• Small = bottleneck exists (near-disconnection)
• Large = well-connected

Useful for monitoring knowledge graph health as entities accumulate.

pub fn sparsify(&mut self, epsilon: f32)

Prune redundant edges using spectral sparsification.

Removes edges that are structurally redundant (many alternative paths exist) while preserving edges that are critical for connectivity (bridges, bottlenecks).

Arguments

• epsilon - Approximation quality. 0.3 = aggressive pruning (~30% edges removed), 0.1 = conservative (~10% removed). The sparsified graph preserves spectral properties within (1 ± epsilon) of the original.

Trait Implementations

impl Debug for RelationshipGraph

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

Formats the value using the given formatter.

impl Default for RelationshipGraph

fn default() -> RelationshipGraph

Returns the “default value” for a type.

impl RelationshipGraphT for RelationshipGraph

fn get_node(&self, name: &str) -> Option<&GraphNode>

Get a node by name.

fn get_neighbors(&self, name: &str) -> Vec<&GraphNode>

Get all neighbor nodes.

fn get_edges(&self, name: &str) -> Vec<&GraphEdge>

Get all edges for a node.

fn search(&self, query: &str, limit: usize) -> Vec<&GraphNode>

Search for nodes matching a query string.

fn find_path(&self, from: &str, to: &str) -> Option<Vec<String>>

Find the shortest path between two nodes.