GraphQLite is an MIT-licensed SQLite extension, written in C, that adds graph database capabilities to SQLite through the Cypher query language and built-in graph algorithms, and it is aimed at developers and data teams who want to store and query connected data inside an ordinary SQLite database rather than operating a separate graph server.

What it is

GraphQLite is an extension for SQLite, the single-file embedded relational database. It adds a graph data model and a Cypher query surface on top of a regular SQLite database, so nodes, edges and their properties can be stored and queried next to ordinary relational data. The project is implemented in C and sits in the SQLite extension ecosystem, with bindings for Python and Rust and a raw SQL interface, and it is validated against the official openCypher Technology Compatibility Kit.

The problem it solves is the split between relational storage and graph workloads. Instead of introducing another database process, another deployment unit and another set of credentials, GraphQLite keeps the graph in the same file-based SQLite database the application already uses, with no server required. It replaces the separate graph database that would otherwise be needed to run Cypher traversals and graph algorithms: the README frames it as combining the simplicity of a single-file, zero-config embedded database with Cypher's expressive power for modelling relationships.

Key capabilities

• Cypher query support covering MATCH, CREATE, MERGE, SET, DELETE, WITH, UNWIND and RETURN.
• Built-in graph algorithms including PageRank, Louvain community detection, Dijkstra shortest paths, BFS/DFS and connected components, exposed through calls such as g.pagerank() and g.dijkstra("alice", "bob").
• A Python graph API built on Graph(":memory:"), with upsert_node(...), upsert_edge(...) and g.query(...) accepting Cypher strings.
• openCypher TCK validation across 3,876 scenarios at 97.7 percent passing overall, with expressions at 98.0 percent (2,599 scenarios), clauses at 97.2 percent (1,247 scenarios) and use cases at 100 percent.
• Reported 100 percent conformance for booleans, strings, null handling, CREATE/SET/DELETE/REMOVE, UNION and SKIP/LIMIT.
• Zero configuration: the extension works with any SQLite database and requires no server process.
• Multiple bindings for Python, Rust and raw SQL, plus a conformance runner invoked with angreal test tck.

Who uses it and how

• Python teams building GraphRAG pipelines, following the examples/llm-graphrag sample that ingests the HotpotQA dataset with ingest.py and answers questions through rag.py.
• Engineers working on knowledge graphs and community detection, where Louvain and PageRank run in-process against data already held in SQLite.
• Rust developers who want Cypher queries and graph analytics from an application that already depends on SQLite, adding the crate with cargo add graphqlite.
• SQL practitioners who work directly through the sqlite3 shell, using tutorials such as examples/sql/01_getting_started.sql.
• Embedded and local-first applications that need graph relationships and relational tables to live in one file rather than across two systems.

Getting started

Install the binding that matches the stack — brew install graphqlite on macOS and Linux, pip install graphqlite for Python, or cargo add graphqlite for Rust — and then create a graph over any SQLite database. Full tutorials, how-to guides and API reference are published at https://colliery-io.github.io/graphqlite/.

How it compares

Among the tools named in the facts, GraphQLite carries the neo4j topic alongside the wider graph-database and knowledge-graph topics, which places it squarely in the Cypher ecosystem. Its distinguishing characteristic as described is deployment shape rather than query language: it is an SQLite extension that runs with any SQLite database and requires no server, whereas the comparison implied by those topics is a standalone graph database.

When to use it — and when not to

Choose it when graph queries and graph analytics need to sit next to relational data in a single embedded file, and when an MIT-licensed C extension with Python and Rust bindings fits the stack — a self-hoster operates no extra service, but does own the SQLite database file and its backups. Do not choose it if the workload demands complete openCypher conformance: overall coverage is 97.7 percent, and the remaining gaps concentrate in DST-aware timezone arithmetic, nested existential subqueries and multi-row MERGE, tracked in docs/testing/semantic-coverage-matrix.md. The repository shows 501 stars, 29 forks and 2 open issues with activity as of September 2026, so it is a focused project rather than a large ecosystem, and teams that need the guarantees of a dedicated graph server should look elsewhere.

brew install graphqlite       # macOS/Linux (Homebrew)
pip install graphqlite        # Python
cargo add graphqlite          # Rust

from graphqlite import Graph

g = Graph(":memory:")
g.upsert_node("alice", {"name": "Alice", "age": 30}, label="Person")
g.upsert_node("bob", {"name": "Bob", "age": 25}, label="Person")
g.upsert_edge("alice", "bob", {"since": 2020}, rel_type="KNOWS")

# Query with Cypher
results = g.query("MATCH (a:Person)-[:KNOWS]->(b) RETURN a.name, b.name")

# Built-in graph algorithms
g.pagerank()
g.louvain()
g.dijkstra("alice", "bob")

# SQL tutorials
sqlite3 < examples/sql/01_getting_started.sql

# GraphRAG with HotpotQA dataset
cd examples/llm-graphrag
uv sync && uv run python ingest.py
uv run python rag.py "Were Scott Derrickson and Ed Wood of the same nationality?"