I like the ambition and the open-source spirit behind your project! Open-source graph databases are fantastic.
That said, I’d encourage you to consider leveraging existing projects rather than starting from scratch. There are already mature, local / in-browser graph databases that could benefit from your skills and vision.
For example:
- Kuzu https://github.com/kuzudb/kuzu:
This project had very active development but was recently archived (as of October 10, 2025). Continuiing or forking it could be a game-changer for the community.
- Cozodb https://www.cozodb.org/ It’s very feature-rich and actively seeking contributors. Your expertise could help push it even further.
I do get the appeal of building something from the ground up; it’s incredibly rewarding. But achieving production readiness is seriously challenging and time-consuming. These projects are already years ahead in scope, so contributing to them could accelerate your impact and save you from reinventing the wheel.
Thanks for the suggestions! I'm familiar with both.
Different category though - this is a SQLite extension, not a standalone database. The value prop is:
Zero friction - If you're already using SQLite (Python scripts, mobile apps, embedded systems), just .load graph_extension and you have graph capabilities
Mix SQL + Cypher - Join your relational tables with graph traversals in the same query
Works everywhere SQLite works - Serverless functions, Raspberry Pi, iOS apps, wherever
Leverage SQLite's ecosystem - All existing tools, bindings, deployment patterns just work
Kuzu and CozoDB are excellent if you want a dedicated graph database. But if you've already got SQLite (which is everywhere), this lets you add graph features without rearchitecting.
Think of it like SQLite's FTS5 extension for full-text search - you're not competing with Elasticsearch, you're giving SQLite users a lightweight option that fits their existing workflow.
Thanks! As a Postgres user first, I really appreciate that comparison. Apache AGE does great work.
Graph databases are crucial for AI memory, especially paired with vector databases. Graph for relationships, vectors for semantic similarity - particularly powerful for embedded systems and robotics where you need lightweight, on-device reasoning.
they're definitely on the roadmap but not in the alpha yet. The syntax like CREATE CONSTRAINT ON (n:Person) ASSERT n.email IS UNIQUE is designed to work, and we've got the error handling infrastructure in place, but the actual enforcement logic is planned for v0.2.0 and beyond. Same goes for relationship constraints - the foundation's there with schema validation, but the complex constraint types are coming in future versions.
Indices are similar - we've got the query planner logic ready to use them, and label indexing is partially implemented as a foundation. Property indexes are definitely planned, with basic support in v0.2.0 and composite indexes following in v0.4.0. The current alpha focuses on getting the core Cypher operations (CREATE/MATCH) solid before layering on the optimization features.
The roadmap shows:
v0.2.0 (Q1 2026): Property indexes and basic constraints
v0.4.0 (Q3 2026): Advanced indexing (composite, spatial)
v1.0.0 (2027): Full constraint support
For now, you can enforce constraints at the application level or use raw SQLite constraints on the backing tables if you need that functionality immediately. The alpha is really about proving the core graph operations work end-to-end before adding the enterprise features.
So you're doing the planning and execution which results in what? Some direct calls into sqlite that create tables? Under the hood is this using tables in a conventional manner where there are adjacency lists or just edges and vertexes or ... ?
I'm looking at `graphFindEdgesByType` and it says they're done with SQL queries - are you effectively transpiling some of the Cypher or just have routines that build queries as needed?
The storage model is just regular SQLite tables. When you create a graph, it makes two backing tables:
my_graph_nodes -- id, labels (JSON array), properties (JSON object)
my_graph_edges -- id, source, target, edge_type, properties (JSON object)
It's an edge list, not adjacency lists.
Query processing is not transpiling Cypher directly. There's a pipeline:
Cypher → AST → Logical Plan → Physical Plan (optimizer) → Iterators → SQL queries
The iterators generate SQL on-the-fly to fetch from those backing tables. Basically the Volcano model.
graphFindEdgesByType is Actually deprecated and is a no-op now. The comment says "edge lookups are done via SQL queries." They used to have in-memory structures but moved to just generating SQL like:
SELECT e.target, e.id, e.edge_type
FROM my_graph_edges e
WHERE e.source = 123 AND e.edge_type = 'KNOWS'
So it's "build SQL queries as needed during execution" rather than "transpile the whole Cypher query upfront."
Nothing says weekend project like writing a Cypher planner from scratch in C99. We also recently launched AgentML -> check it out https://github.com/agentflare-ai/agentml (ALSO MIT)
I agree but LLMs are very good at generating XML. Additionally SCXML which AgentML extends has been around and finalized for over 15 years. So generating AgentML works incredibly well.
I get your point, however I wonder how much better they are than JSON when using structured output endpoints, which is likely what you would want to use with such a format.
Good question - we're working on case studies for this.
My theory: models are heavily trained on HTML/XML and many use XML tags in their own system prompts, so they're naturally fluent in that syntax. Makes nested structures more reliable in our testing.
Structured output endpoints help JSON a lot though.
I like the ambition and the open-source spirit behind your project! Open-source graph databases are fantastic.
That said, I’d encourage you to consider leveraging existing projects rather than starting from scratch. There are already mature, local / in-browser graph databases that could benefit from your skills and vision.
For example:
- Kuzu https://github.com/kuzudb/kuzu: This project had very active development but was recently archived (as of October 10, 2025). Continuiing or forking it could be a game-changer for the community.
- Cozodb https://www.cozodb.org/ It’s very feature-rich and actively seeking contributors. Your expertise could help push it even further.
I do get the appeal of building something from the ground up; it’s incredibly rewarding. But achieving production readiness is seriously challenging and time-consuming. These projects are already years ahead in scope, so contributing to them could accelerate your impact and save you from reinventing the wheel.
Thanks for the suggestions! I'm familiar with both. Different category though - this is a SQLite extension, not a standalone database. The value prop is:
Zero friction - If you're already using SQLite (Python scripts, mobile apps, embedded systems), just .load graph_extension and you have graph capabilities Mix SQL + Cypher - Join your relational tables with graph traversals in the same query Works everywhere SQLite works - Serverless functions, Raspberry Pi, iOS apps, wherever Leverage SQLite's ecosystem - All existing tools, bindings, deployment patterns just work
Kuzu and CozoDB are excellent if you want a dedicated graph database. But if you've already got SQLite (which is everywhere), this lets you add graph features without rearchitecting.
Think of it like SQLite's FTS5 extension for full-text search - you're not competing with Elasticsearch, you're giving SQLite users a lightweight option that fits their existing workflow.
This reminds me of the apache age postgres extension as well. Very cool work
Thanks! As a Postgres user first, I really appreciate that comparison. Apache AGE does great work.
Graph databases are crucial for AI memory, especially paired with vector databases. Graph for relationships, vectors for semantic similarity - particularly powerful for embedded systems and robotics where you need lightweight, on-device reasoning.
https://ladybugdb.com/ is a fork of Kuzu.
What kind of constraints can you add?
Could I put a unique constraint on property `id` of all nodes with label X?
Could I put a constraint that edges of kind A must always go from nodes with label X to nodes with label Y?
What kind of indices can you add?
Will SQLite use them when you do a Cypher query?
Will your Cypher query planner take them into account?
So on constraints:
they're definitely on the roadmap but not in the alpha yet. The syntax like CREATE CONSTRAINT ON (n:Person) ASSERT n.email IS UNIQUE is designed to work, and we've got the error handling infrastructure in place, but the actual enforcement logic is planned for v0.2.0 and beyond. Same goes for relationship constraints - the foundation's there with schema validation, but the complex constraint types are coming in future versions.
Indices are similar - we've got the query planner logic ready to use them, and label indexing is partially implemented as a foundation. Property indexes are definitely planned, with basic support in v0.2.0 and composite indexes following in v0.4.0. The current alpha focuses on getting the core Cypher operations (CREATE/MATCH) solid before layering on the optimization features.
The roadmap shows: v0.2.0 (Q1 2026): Property indexes and basic constraints v0.4.0 (Q3 2026): Advanced indexing (composite, spatial) v1.0.0 (2027): Full constraint support
For now, you can enforce constraints at the application level or use raw SQLite constraints on the backing tables if you need that functionality immediately. The alpha is really about proving the core graph operations work end-to-end before adding the enterprise features.
I have an ELI5 question...
So you're doing the planning and execution which results in what? Some direct calls into sqlite that create tables? Under the hood is this using tables in a conventional manner where there are adjacency lists or just edges and vertexes or ... ?
I'm looking at `graphFindEdgesByType` and it says they're done with SQL queries - are you effectively transpiling some of the Cypher or just have routines that build queries as needed?
Thanks!
Great Question!
The storage model is just regular SQLite tables. When you create a graph, it makes two backing tables: my_graph_nodes -- id, labels (JSON array), properties (JSON object) my_graph_edges -- id, source, target, edge_type, properties (JSON object) It's an edge list, not adjacency lists.
Query processing is not transpiling Cypher directly. There's a pipeline: Cypher → AST → Logical Plan → Physical Plan (optimizer) → Iterators → SQL queries The iterators generate SQL on-the-fly to fetch from those backing tables. Basically the Volcano model.
graphFindEdgesByType is Actually deprecated and is a no-op now. The comment says "edge lookups are done via SQL queries." They used to have in-memory structures but moved to just generating SQL like: SELECT e.target, e.id, e.edge_type FROM my_graph_edges e WHERE e.source = 123 AND e.edge_type = 'KNOWS'
So it's "build SQL queries as needed during execution" rather than "transpile the whole Cypher query upfront."
Nothing says weekend project like writing a Cypher planner from scratch in C99. We also recently launched AgentML -> check it out https://github.com/agentflare-ai/agentml (ALSO MIT)
This will also be used in the yet to be released `memlite` which is our first wasm component for AgentML
Interesting, yet the xml syntax feels quite verbose vs JSON for example.
I agree but LLMs are very good at generating XML. Additionally SCXML which AgentML extends has been around and finalized for over 15 years. So generating AgentML works incredibly well.
I get your point, however I wonder how much better they are than JSON when using structured output endpoints, which is likely what you would want to use with such a format.
That's a fair point. We're considering adding JSON as a first-class citizen alongside XML - similar to OpenAPI supporting both JSON and YAML.
But you're right that structured output endpoints make JSON generation more reliable, so supporting both formats long-term makes sense.
I'm also curious if you know if anyone has any definitive test sets on this? Kind of like how Simon Willison uses the bird on the bicycle?
Good question - we're working on case studies for this.
My theory: models are heavily trained on HTML/XML and many use XML tags in their own system prompts, so they're naturally fluent in that syntax. Makes nested structures more reliable in our testing.
Structured output endpoints help JSON a lot though.