Skip to content

Latest commit

 

History

History

graph

Folders and files

NameName
Last commit message
Last commit date

parent directory

..
README.md
README.md
 
 
basic_graph.rs
basic_graph.rs
 
 
cypher_queries.rs
cypher_queries.rs
 
 
distributed_cluster.rs
distributed_cluster.rs
 
 
hybrid_search.rs
hybrid_search.rs
 
 

README.md

RuVector Graph Examples

Graph database features including Cypher queries, distributed clustering, and hybrid search.

Examples

File Description
basic_graph.rs Graph creation and traversal
cypher_queries.rs Cypher query language examples
distributed_cluster.rs Multi-node graph clustering
hybrid_search.rs Combined vector + graph search

Quick Start

cargo run --example basic_graph
cargo run --example cypher_queries

Basic Graph Operations

use ruvector_graph::{Graph, Node, Edge};

let mut graph = Graph::new();

// Add nodes with embeddings
let n1 = graph.add_node(Node {
    id: "user:1".to_string(),
    embedding: vec![0.1; 128],
    properties: json!({"name": "Alice"}),
});

let n2 = graph.add_node(Node {
    id: "user:2".to_string(),
    embedding: vec![0.2; 128],
    properties: json!({"name": "Bob"}),
});

// Create relationship
graph.add_edge(Edge {
    from: n1,
    to: n2,
    relation: "KNOWS".to_string(),
    weight: 0.95,
});

Cypher Queries

// Find connected nodes
let query = "MATCH (a:User)-[:KNOWS]->(b:User) RETURN b";
let results = graph.cypher(query)?;

// Pattern matching with vector similarity
let query = "
    MATCH (u:User)
    WHERE vector_similarity(u.embedding, $query_vec) > 0.8
    RETURN u
";
let results = graph.cypher_with_params(query, params)?;

Distributed Clustering

use ruvector_graph::{DistributedGraph, ClusterConfig};

let config = ClusterConfig {
    nodes: vec!["node1:9000", "node2:9000"],
    replication_factor: 2,
    partitioning: Partitioning::Hash,
};

let cluster = DistributedGraph::connect(config)?;

// Data is automatically partitioned
cluster.add_node(node)?;

// Queries are distributed
let results = cluster.query("MATCH (n) RETURN n LIMIT 10")?;

Hybrid Search

Combine vector similarity with graph traversal:

use ruvector_graph::HybridSearch;

let search = HybridSearch::new(graph, vector_index);

// Step 1: Find similar nodes by embedding
// Step 2: Expand via graph relationships
// Step 3: Re-rank by combined score
let results = search.query(HybridQuery {
    embedding: query_vec,
    relation_filter: vec!["KNOWS", "WORKS_WITH"],
    depth: 2,
    top_k: 10,
    vector_weight: 0.6,
    graph_weight: 0.4,
})?;

Graph Algorithms

// PageRank
let scores = graph.pagerank(0.85, 100)?;

// Community detection (Louvain)
let communities = graph.detect_communities()?;

// Shortest path
let path = graph.shortest_path(from, to)?;

// Connected components
let components = graph.connected_components()?;

Use Cases

Use Case Query Pattern
Social Networks (user)-[:FOLLOWS]->(user)
Knowledge Graphs (entity)-[:RELATED_TO]->(entity)
Recommendations Vector similarity + collaborative filtering
Fraud Detection Subgraph pattern matching
Supply Chain Path analysis and bottleneck detection

Performance

  • Index Types: B-tree, hash, vector (HNSW)
  • Caching: LRU cache for hot subgraphs
  • Partitioning: Hash, range, or custom
  • Replication: Configurable factor

Related