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:
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 engine with morsel-driven parallelism
- Columnar storage with type-specific compression
- Cost-based query optimizer with cardinality estimation
- MVCC transactions with snapshot isolation
- Zone maps for intelligent data skipping
Installation
License
Grafeo is licensed under the Apache-2.0 License.