Grafeo¶

A fast, lean, embeddable graph database built in Rust¶

Why Grafeo?¶

High Performance

Fastest graph database in our graph-bench suite (includes LDBC-inspired workloads), 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::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	openCypher, 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

GQL first

Grafeo is a GQL-first database: GQL, the ISO/IEC 39075 standard, sets its semantics, and the other languages are translated onto them. Where the languages disagree, each follows its own specification wherever Grafeo's translator can tell the cases apart: Cypher follows openCypher and SQL/PGQ follows SQL:2023. Otherwise GQL's semantics apply, also for Gremlin and GraphQL. On RDF data, SPARQL follows SPARQL 1.1.

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 } }
  }
}

PREFIX foaf: <http://xmlns.com/foaf/0.1/>

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 vectorized execution engine, one thread per query
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.6.1

npm install @grafeo-db/wasm

License¶

Grafeo is licensed under the Apache-2.0 License.