Grafeo - High-Performance Graph Database - Grafeo Skip to content Grafeo Grafeo - High-Performance Graph Database Initializing search GrafeoDB/grafeo Home Getting Started User Guide Architecture Reference Community Grafeo GrafeoDB/grafeo Home Home Table of contents A fast, lean, embeddable graph database built in Rust Why Grafeo? Quick Start Features Dual Data Model Support Query Languages Architecture Highlights Installation License Getting Started User Guide Architecture Reference Community Table of contents A fast, lean, embeddable graph database built in Rust Why Grafeo? Quick Start Features Dual Data Model Support Query Languages Architecture Highlights Installation License Grafeo¶ A fast, lean, embeddable graph database built in Rust¶ Get Started View on GitHub 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¶ PythonRust uv add grafeo
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']}")
cargo add grafeo
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: LPG (Labeled Property Graph)RDF (Resource Description Framework) Nodes with labels and properties Edges with types and properties Properties supporting rich data types Ideal for social networks, knowledge graphs, application data Triples: subject-predicate-object statements SPO/POS/OSP indexes for 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 GQLCypherGremlinGraphQLSPARQL MATCH (me:Person {name: 'Alix'})-[:KNOWS]->(friend)-[:KNOWS]->(fof)
WHERE fof <> me
RETURN DISTINCT fof.name
MATCH (me:Person {name: 'Alix'})-[:KNOWS]->(friend)-[:KNOWS]->(fof)
WHERE fof <> me
RETURN DISTINCT fof.name
g.V().has('name', 'Alix').out('KNOWS').out('KNOWS').
where(neq('me')).values('name').dedup()
{
Person(name: "Alix") {
friends { friends { name } }
}
}
SELECT DISTINCT ?fofName WHERE {
?me foaf:name "Alix" .
?me foaf:knows ?friend .
?friend foaf:knows ?fof .
?fof foaf:name ?fofName .
FILTER(?fof != ?me)
}
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¶ PythonNode.jsGoRustC#DartWASM uv add grafeo
npm install @grafeo-db/js
go get github.com/GrafeoDB/grafeo/crates/bindings/go
cargo add grafeo
dotnet add package GrafeoDB
# pubspec.yaml
dependencies:
grafeo: ^0.5.21
npm install @grafeo-db/wasm
License¶ Grafeo is licensed under the Apache-2.0 License. 2026-03-15 2026-01-27 Back to top Next Getting Started Copyright © 2026 S.T. Grond - Apache-2.0 License

Grafeo represents a high-performance graph database solution developed in Rust, designed for embeddability and versatility. The core development, spearheaded by S.T. Grond, leverages Rust’s memory safety and performance characteristics to deliver a database engine optimized for graph-related operations. Grafeo’s architecture incorporates several key elements intended to maximize efficiency and flexibility.

A central aspect of Grafeo’s design is its dual data model support, accommodating both Labeled Property Graphs (LPG) and Resource Description Framework (RDF) triples. The LPG model, utilizing nodes and edges with associated properties, is well-suited for applications such as social network analysis and general knowledge graph construction. Conversely, the RDF model, conforming to W3C standards, is specifically designed for semantic web applications, linked data projects, and ontology management, utilizing subject-predicate-object triples with SPO and POS/OSP indexes. This dual support grants developers the freedom to select the model that best aligns with the specific domain and requirements of their projects.

The database offers support for a multitude of query languages, acknowledging the diverse needs of users and developers. These include GQL (the default, a standard ISO-compliant language), Cypher (compatible with Neo4j), Gremlin (part of the Apache TinkerPop family), GraphQL, SPARQL (W3C standard for RDF queries), and SQL/PGQ (a SQL dialect focused on graph operations). The availability of multiple languages dramatically broadens the applicability of Grafeo and allows for integration within existing workflows.

Key architectural highlights include a push-based execution engine facilitating parallelism, column-oriented storage with type-specific compression for optimized data storage, a cost-based query optimizer estimating query cardinality, and MVCC transactions—providing robust and reliable transaction management. Additionally, Grafeo incorporates zone maps for intelligent data skipping, intended to significantly improve query performance by strategically avoiding unnecessary data access.

From a development perspective, Grafeo provides extensive binding support across various programming languages: Python (through PyO3), Node.js/TypeScript (using napi-rs), Go (with CGO), C (via FFI), C# (.NET 8 P/Invoke), Dart (using dart:ffi), and WebAssembly (wasm-bindgen). This extensive ecosystem facilitates seamless integration within existing projects regardless of the primary development language. Furthermore, the database has been designed to integrate with popular AI tools, including LangChain, LlamaIndex, and MCP, as well as offering interactive notebook widgets and browser-based graph visualization capabilities via WebAssembly.

The system is engineered for both embedded and standalone deployments. Its embedded capability provides developers with the ability to incorporate Grafeo directly into applications and, critically, minimizes the need for external dependencies. Alternatively, Grafeo can operate as a standalone server, providing REST APIs and a web UI for comprehensive management and querying. The use of memory-safe Rust, coupled with optional allocators like jemalloc or mimalloc and potential use of C libraries for performance enhancements, guarantees a robust and reliable system while maintaining memory safety. Full ACID transaction compliance, utilizing MVCC-based snapshot isolation, further strengthens Grafeo’s suitability for production environments.