LadybugDB v0.22.1
Home / Compare / LadybugDB vs HelixDB
Comparison · Updated 2026

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
PositioningDuckDB for graphs; KuzuDB successorRust-built OLTP graph-vector DB for RAG
StorageColumnar, 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 languageCypher (portable, standardizing)Native SDK DSLs (TS / Python / Rust / Go, JSON-based) + Cypher (openCypher profile); HelixQL/HQL discontinued
Vector + full-text searchNative NaviX vector index (VLDB '25): disk-based HNSW with predicate-agnostic filtered search + full-text indices, all queryable in CypherNative hybrid vector+graph+full-text (no published index design)
Range scansYes — ART indexes serve exact + range filters (gt/gte/lt/lte/between) with ordered scansYes — range predicates (gt/gte/lt/lte/between) over indexed properties
LicenseMIT (permissive)Apache 2.0 (permissive open source)
DeploymentEmbedded zero-deps, server mode (Bolt), ADBC columnar interface; WASM in browser, iOS, Android, any arch with a C compiler; OpenAPI + MCP serverEmbedded Rust; local server; managed cloud
SDKsPython, 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 poolLarge (Cypher everywhere)Growing (SDK DSLs in mainstream languages + Cypher; no proprietary language to learn)
LineageVLDB research + 10+ enterprise predecessorNewer startup project
Graph algorithms220+ via Icebug (columnar NetworKit fork) on the same CSR dataThin 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:

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:

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

When LadybugDB wins

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:

Try the Cypher-native, MIT-licensed option.

One-command install. Migrate from Kuzu, Neo4j, or HelixDB in minutes.