Grafeo – A fast, lean, embeddable graph database built in Rust

Why Grafeo?¶

High Performance

Fastest graph database tested on the LDBC Social Network Benchmark, both embedded and as a server, with a lower memory footprint than other in-memory databases. Built in Rust with vectorized execution, adaptive chunking and SIMD-optimized operations.

Multi-Language Queries

GQL, Cypher, Gremlin, GraphQL, SPARQL and SQL/PGQ. Choose the query language that fits the project and expertise level.

LPG & RDF Support

Dual data model support for both Labeled Property Graphs and RDF triples. Choose the model that fits the domain.

Vector Search

HNSW-based similarity search with quantization (Scalar, Binary, Product). Combine graph traversal with semantic similarity.

Embedded or Standalone

Embed directly into applications with zero external dependencies, or run as a standalone server with REST API and web UI. From edge devices to production clusters.

Rust Core

Core database engine written in Rust with no required C dependencies. Optional allocators (jemalloc/mimalloc) and TLS use C libraries for performance. Memory-safe by design with fearless concurrency.

ACID Transactions

Full ACID compliance with MVCC-based snapshot isolation. Reliable transactions for production workloads.

Multi-Language Bindings

Python (PyO3), Node.js/TypeScript (napi-rs), Go (CGO), C (FFI), C# (.NET 8 P/Invoke), Dart (dart:ffi) and WebAssembly (wasm-bindgen). Use Grafeo from the language of choice.

Ecosystem

AI integrations (LangChain, LlamaIndex, MCP), interactive notebook widgets, browser-based graphs via WebAssembly, standalone server with web UI and benchmarking tools.

Quick Start¶

import grafeo
# Create an in-memory database
db = grafeo.GrafeoDB()
# Create nodes and edges
db.execute("""
INSERT (:Person {name: 'Alix', age: 30})
INSERT (:Person {name: 'Gus', age: 25})
""")
db.execute("""
MATCH (a:Person {name: 'Alix'}), (b:Person {name: 'Gus'})
INSERT (a)-[:KNOWS {since: 2024}]->(b)
""")
# Query the graph
result = db.execute("""
MATCH (p:Person)-[:KNOWS]->(friend)
RETURN p.name, friend.name
""")
for row in result:
print(f"{row['p.name']} knows {row['friend.name']}")

use grafeo::GrafeoDB;
fn main() -> Result<(), grafeo_common::utils::error::Error> {
// Create an in-memory database
let db = GrafeoDB::new_in_memory();
// Create a session and execute queries
let mut session = db.session();
session.execute(r#"
INSERT (:Person {name: 'Alix', age: 30})
INSERT (:Person {name: 'Gus', age: 25})
"#)?;
session.execute(r#"
MATCH (a:Person {name: 'Alix'}), (b:Person {name: 'Gus'})
INSERT (a)-[:KNOWS {since: 2024}]->(b)
"#)?;
// Query the graph
let result = session.execute(r#"
MATCH (p:Person)-[:KNOWS]->(friend)
RETURN p.name, friend.name
"#)?;
for row in result.rows {
println!("{:?}", row);
}
Ok(())
}

Features¶

Dual Data Model Support¶

Grafeo supports both major graph data models with optimized storage for each:

Nodeswith labels and propertiesEdgeswith types and propertiesPropertiessupporting rich data types- Ideal for social networks, knowledge graphs, application data

Triples: subject-predicate-object statementsSPO/POS/OSP indexesfor efficient querying- W3C standard compliance

• Ideal for semantic web, linked data, ontologies

Query Languages¶

Choose the query language that fits the project:

| Language | Data Model | Style | |---|---|---| GQL (default) | LPG | ISO standard, declarative pattern matching | Cypher | LPG | Neo4j-compatible, ASCII-art patterns | Gremlin | LPG | Apache TinkerPop, traversal-based | GraphQL | LPG, RDF | Schema-driven, familiar to web developers | SPARQL | RDF | W3C standard for RDF queries | SQL/PGQ | LPG | SQL:2023 GRAPH_TABLE for SQL-native graph queries |

Architecture Highlights¶

Push-based execution enginewith morsel-driven parallelismColumnar storagewith type-specific compressionCost-based query optimizerwith cardinality estimationMVCC transactionswith snapshot isolationZone mapsfor intelligent data skipping

Installation¶

License¶

Grafeo is licensed under the Apache-2.0 License.