LadybugDB vs HelixDB
Two modern embedded graph databases that both fuse graph and vector search — with opposite bets: LadybugDB = columnar + Cypher + NaviX vector search + MIT (the KuzuDB successor). HelixDB = Rust-built hybrid search + native SDK DSLs / Cypher + Apache 2.0. Here's how to choose.
TL;DR verdict
Pick LadybugDB if you want Cypher portability, columnar analytics, peer-reviewed graph+vector search (NaviX), MIT embedding, and agent-ready OpenAPI/MCP. Pick HelixDB if your workload is write-heavy/transactional and you prefer SDK-native queries (TypeScript, Python, Rust, Go — JSON-based) plus Cypher support. For regulated-industry agents (legal/medical/finance), LadybugDB's peer-reviewed retrieval + standards focus usually wins — though both licenses are permissive (MIT vs Apache 2.0).
Head-to-head comparison
| Dimension | 🐞 LadybugDB | 🌀 HelixDB |
|---|---|---|
| Positioning | DuckDB for graphs; KuzuDB successor | Rust-built OLTP graph-vector DB for RAG |
| Storage | Columnar, compressed, vectorized — in-memory, disk, or object storage (CSR on object storage via Icebug / GraphLake) | Row-oriented / custom (Rust); in-memory, disk, or object storage |
| Query language | Cypher (portable, standardizing) | Native SDK DSLs (TS / Python / Rust / Go, JSON-based) + Cypher (openCypher profile); HelixQL/HQL discontinued |
| Vector + full-text search | Native NaviX vector index (VLDB '25): disk-based HNSW with predicate-agnostic filtered search + full-text indices, all queryable in Cypher | Native hybrid vector+graph+full-text (no published index design) |
| Range scans | Yes — ART indexes serve exact + range filters (gt/gte/lt/lte/between) with ordered scans | Yes — range predicates (gt/gte/lt/lte/between) over indexed properties |
| License | MIT (permissive) | Apache 2.0 (permissive open source) |
| Deployment | Embedded zero-deps, server mode (Bolt), ADBC columnar interface; WASM in browser, iOS, Android, any arch with a C compiler; OpenAPI + MCP server | Embedded Rust; local server; managed cloud |
| SDKs | Python, JS/TS (npm), Rust + MCP (PyPI) | TypeScript, Python, Rust, Go — every SDK builds the same JSON operation-tree query (POST /v2/query) |
| Analytics (scans/aggs) | Excellent (columnar) | Good (not columnar-specialized) |
| Talent pool | Large (Cypher everywhere) | Growing (SDK DSLs in mainstream languages + Cypher; no proprietary language to learn) |
| Lineage | VLDB research + 10+ enterprise predecessor | Newer startup project |
| Graph algorithms | 220+ via Icebug (columnar NetworKit fork) on the same CSR data | Thin built-in set; app-side composition |
Setting the record straight
A competitor comparison page claims LadybugDB is "embedded-only, disk-only, no range scans, and wrong for RAG because RAG is OLTP." Every clause is false. The facts:
1. Storage: in-memory, disk, and object storage — including CSR on object storage
LadybugDB traverses CSR whether it lives in native storage, in Parquet files, or in Arrow tables. Relationships can be mounted directly from object storage (S3-compatible) via the open Icebug format (icebug-disk as Parquet CSR, icebug-memory as Arrow CSR for zero-copy) — no import required. The GraphLake vision pairs Iceberg tables with icebug-disk graphs. Storage mode is a workload choice, not a single-process ceiling.
2. Topology: embedded, server (Bolt), ADBC — and a range of devices
LadybugDB runs embedded in-process (zero dependencies, plus WebAssembly for the browser), as a server speaking Bolt, and through ADBC — the Arrow-native columnar interface that hands results to data frames and lakehouse tools without row-by-row conversion. Portable C++ takes it further than embedded-vs-server: the same engine runs WASM in the browser, natively on iOS and Android, and on any architecture with a C compiler. "Embedded by design" never meant "embedded only."
3. Range scans: yes, via ART indexes
LadybugDB's Adaptive Radix Tree (ART) indexes — the same design DuckDB uses for every PRIMARY KEY — keep keys in sorted order, so one index serves exact lookups and range filters with ordered scans in either direction. "What did this agent see between Tuesday and Thursday" is an indexed range scan, not a post-filter.
4. RAG is OLAP, not OLTP — and LadybugDB pairs with your OLTP store
Retrieval over a knowledge graph — multi-hop traversals, vector similarity, aggregations over large candidate sets — is analytical (OLAP) work: scan-heavy, read-mostly, exactly what columnar vectorized engines are built for. High-concurrency transactional writes (OLTP) belong in SQLite or Postgres — and LadybugDB works alongside them just fine, as the analytical brain next to your system of record. Framing RAG as "transactional agent traffic" that needs an OLTP graph engine inverts the workload: agents read far more than they write.
Language check: Cypher vs HelixDB native DSLs (+ Cypher)
Correction Nov 2026, with thanks to the HelixDB team: HelixDB discontinued HelixQL/HQL months ago. You now query HelixDB with native SDK DSLs in TypeScript, Python, Rust, or Go — every SDK builds the same JSON operation-tree query — or with Cypher (an openCypher profile) running against the same graph, transactions, and indexes.
// LadybugDB — standard Cypher, works on Neo4j/Kuzu too
MATCH (u:User {id: $uid})-[:BOUGHT]->(p:Product)<-[:BOUGHT]-(other)-[:BOUGHT]->(rec)
WHERE NOT (u)-[:BOUGHT]->(rec)
RETURN rec.name, count(*) AS score ORDER BY score DESC LIMIT 10;
// HelixDB — native SDK DSL (e.g. TypeScript) + optional Cypher; HelixQL/HQL discontinued
// SDK builders serialize to the same JSON query AST; Cypher runs beside native queries
If you ever need to hire, audit, or migrate, Cypher's portability is a superpower. Every Cypher engineer is productive on LadybugDB day one. HelixDB's SDK-first approach (plus Cypher support) meets app developers where they are instead — pick based on whether you want query-language portability or SDK-native queries.
Graph + vector: LadybugDB's edge is peer-reviewed (NaviX)
"Fused vector+graph retrieval" is contested ground — not HelixDB territory. LadybugDB inherits NaviX (Sehgal & Salihoğlu, VLDB 2025), a native vector index designed specifically for graph DBMSs, from its KuzuDB lineage:
- Disk-based HNSW on the engine's own storage — the index lives on the buffer manager, not in a sidecar, with zero-copy distance computations. Vectors scale past RAM like the rest of the graph.
- Predicate-agnostic filtered search — NaviX's prefiltering-based adaptive algorithm stays fast and robust across selectivity and correlation scenarios: "vector-similar and (seen this week, bought by people you follow)" is one indexed query, not a retrieve-then-filter prayer. That is exactly the shape of agentic RAG queries.
- Queryable in Cypher — vector similarity composes with graph traversals and relational predicates in the same portable query language, via the
vectorextension (QUERY_VECTOR_INDEX).
HelixDB offers built-in hybrid vector+graph+full-text search too — but with no published index design and no public filtered-search benchmarks to inspect. Peer review is the difference between a claim and a result: NaviX is a VLDB paper with a reproducible benchmark harness (mirrored in the LadybugDB repo), and the vector extension docs describe exactly what ships. If vectors matter to your workload, ask every vendor for the paper — or the apology for not having one.
Stability note: HelixDB's license and query language have both changed multiple times
HelixDB is an early-stage, fast-moving project — and its two most load-bearing contracts, the license and the query language, have both been rewritten. That is worth going in with eyes open about:
- License churn: the
helix-dbrepository went GPL-3.0 → AGPL-3.0 (May 2025) → Apache 2.0 (May 2026), with a temporary closed-source period in between that the Helix team has itself described as a mistake made while "new to open source." Today's license, Apache 2.0, is permissive — but terms have changed before, so pin your dependency, read the LICENSE file in the exact tree you ship, and confirm with counsel before embedding it in a regulated product. - Query-language churn: the original HelixQL/HQL text language (
.hxfiles) was deprecated in HelixDB v2 (docs now archived as "legacy"), replaced first by a Rust DSL, then by SDK DSLs in TypeScript, Python, and Go that all serialize to the same JSON query AST — with Cypher (an openCypher profile) later added alongside native queries. Each transition orphaned code written against the previous surface (Helix publishes HQL-to-DSL migration tooling for exactly this reason).
None of this is disqualifying — young databases iterate. But if you build on HelixDB, isolate queries behind a thin access layer, pin SDK/server versions together, and budget for migration when the query surface moves. LadybugDB's counter-bet is stability: Cypher (shared with Neo4j/Kuzu, standardizing through ISO GQL) under MIT — a query language and license that don't move under you. See the HelixDB LICENSE, the archived HelixQL docs, and HelixDB's Cypher guide.
When HelixDB is the better fit
- Your workload is write-heavy transactional graph+vector (high-concurrency OLTP) and you want it in one engine.
- Your stack is TypeScript / Python / Rust / Go and you prefer SDK-native, JSON-based queries (with Cypher available too).
- Apache 2.0 works for you and you don't need columnar analytics.
When LadybugDB wins
- Agentic AI in regulated industries needing auditable, permissively-licensed infra.
- Analytical traversals + aggregations over large graphs (fraud, recommendations, knowledge graphs).
- You want Kuzu/Cypher compatibility, OpenAPI + MCP for agents, and npm/PyPI SDKs.
Ecosystem edge: Icebug, icebug-format, and NetworkX go columnar
A new engine means a thin algorithm library and a bet that app-side glue covers the gap. LadybugDB inherits decades of graph-algorithm research instead:
- Icebug: a columnar fork of NetworKit with 220+ graph algorithms running directly on LadybugDB's CSR data — centrality, communities, paths, embeddings, no export step.
- icebug-format: open Parquet-with-CSR storage — graphs on object storage and in the lakehouse (GraphLake), interoperable with the whole Parquet/Arrow world.
- NetworkX goes columnar too: via the
nx-arrowandnx-ladybugbackends, the same columnar tech reaches Python's most popular graph library — prototype in NetworkX, productionize on LadybugDB.
Try the Cypher-native, MIT-licensed option.
One-command install. Migrate from Kuzu, Neo4j, or HelixDB in minutes.