RushDB 3.0 review: use cases, pros and cons
RushDB is an open-source Rust database that stores JSON as linked records and keeps an exact catalog of every field, type and value, so an AI agent can check what is stored before it queries. Version 3.0 replaced Neo4j with its own engine, and a filter on an unstored value returns zero rows, not an error. The homepage's 100× accuracy figure has no published method, and several security fixes since 3.0 shipped without advisories.

Ask an AI agent how many orders were paid, and it may filter on "Paid" when the data says "paid". The query runs, finds nothing, and the agent tells you there were no paid orders. I reproduced exactly that on RushDB 3.0.10: zero rows in 4.5 milliseconds, no error. RushDB is an open-source database built around stopping that kind of confident, empty answer.
What is RushDB?
RushDB is an open-source database for applications and AI agents: you send it JSON, it stores the data as linked records, and keeps an exact list of every field, type and value so an agent can check before it queries.
Since version 3.0, released on 28 October 2026, it is a single Rust program under the Apache-2.0 licence. One binary holds the storage engine, the indexes and every network protocol. Each nested object in a JSON document becomes its own record, linked to its parent, so the data ends up as a graph without you designing one. You can then read it with RushDB's own JSON query format, SQL over the PostgreSQL wire protocol, Gremlin, Mongo-style documents or SQL/PGQ. openCypher and ISO GQL are available as release candidates. Vector search, BM25 full-text search and a hybrid of the two run inside the same engine.
The part that makes it different is the catalog. Every write updates a record of which labels exist, how many records carry each property, what types those properties hold and which values are stored, with exact counts. An agent can read that before it writes a filter, which is the whole pitch on the RushDB homepage: "Agents see the data's shape before they query it".
A lot of what you will find about RushDB online is out of date. Directory listings and older write-ups still describe it as an API built on Neo4j. That was true of its first two major versions. Version 3.0 replaced Neo4j with its own engine, does not read a 2.x data directory, and does not accept 2.x REST requests.
The versions this review covers, checked on 16 November 2026:
The engine is at 3.0.10, released on 13 November 2026, the tenth patch release in sixteen days.
The JavaScript SDK (@rushdb/javascript-sdk), the Python SDK (rushdb) and the MCP server (@rushdb/mcp-server) are all at 3.4.1.
The LangChain integrations are langchain-rushdb 0.1.0 for Python and @rushdb/langchain 0.1.1 for JavaScript.
The GitHub repository has 367 stars, and the 2.x line gets security fixes only until 28 October 2027.
How does RushDB store and query data?
RushDB stores every property value of every record as its own key in an embedded B-tree, and updates counters and value lists in the same commit, so the catalog is never a stale snapshot.
The company calls this layout the Labeled Meta-Property Graph (LMPG). In an ordinary graph database a property is just an attribute sitting on a node. In LMPG each property is a typed definition shared by every record that uses it. That is why questions like "which fields does this label have?" or "which values of status exist, and how many of each?" are answered from counters rather than by scanning records. Writes go to a write-ahead log first, then to the store (redb). Readers work on pinned snapshots, so they never block writers. SQL is planned by Apache DataFusion 54.1.0, and the graph languages come from an embedded planner called Grafeo 0.5.42.
Here is what that looks like in practice. I loaded three customers, each with nested orders, as one JSON document per customer:
{"name": "Acme", "plan": "enterprise", "country": "US", "ORDER": [
{"status": "paid", "amount": 120, "placed": "2026-10-02T09:00:00Z"},
{"status": "refunded_full", "amount": 80, "placed": "2026-10-05T10:00:00Z"}
]}Each ORDER object became its own record, linked to its customer. The date string was stored as a datetime without any schema. One of the orders, from an imaginary second service, sent its amount as text ("45.50"). RushDB accepted it and recorded the fact in the catalog, which is where it gets interesting.
{"name": "amount", "type": "number", "recordsCount": 4, "siblingTypes": ["utf8"]}
{"name": "amount", "type": "string", "recordsCount": 1, "siblingTypes": ["int64"]}
{"name": "placed", "type": "datetime", "recordsCount": 5}
{"name": "status", "type": "string", "recordsCount": 5}That is real output from the catalog read, trimmed. With a fixed schema you would have had to pick one type up front, and a plain document store would keep the text without telling anyone. RushDB keeps it and tells you that amount now exists in two types. One more request returns the stored values of status with their counts: paid 2, pending 1, refunded_full 1, refunded_partial 1. There is no "refunded" and no "Paid", and an agent can see that before it filters. That matters because a filter on an unstored value returns zero rows, not an error.
Why did RushDB leave Neo4j?
Because the model RushDB promised could only be emulated on Neo4j, slowly, and the tenant isolation between customers depended on every query remembering a filter.
The founder tells the story in "Time to move on", published on 11 November 2026. For two major versions RushDB was an API on top of Neo4j. To answer "which values does this field hold?", the 2.x code had to walk every matching record, read the value, deduplicate it and only then cut the page. Schema questions, the cheap part of the promise, grew linearly with the data. The 2.x changelog reads, in the founder's words, "like a diary of fighting this": imports hitting a 30-second transaction ceiling, AI schema endpoints that would "block or 408 on large projects".
The second reason is the one I would care about as a customer. In 2.x, every project lived in one shared graph. Isolation between projects was a hidden property on every node, and a code comment quoted in the essay is blunt about it: "an unscoped match would let any token reach another project's property". The founder puts it plainly: "That's not a boundary. That's a convention". In 3.0 a tenant is a five-byte prefix on every key, so a scan physically cannot cross into another tenant, and a request without a tenant scope is refused on a multitenant server.
Two more problems pushed the move. Vector search took the global top results first and filtered by project afterwards, so a busy neighbour could leave you with fewer results than you asked for. And Cypher was the only door in. "For a year, the most common reaction after a demo was some version of: 'Good stuff, Artemiy, but why Neo4j? Why not Postgres, or X, or Y?'" Customers' BI tools spoke SQL, and nobody wanted to adopt Neo4j just to adopt RushDB.
There was a business reason too. The 2.x core was under the Elastic License 2.0 and, as the essay puts it, "a lot of our value was plumbing around somebody else's engine". The 3.0 engine is Apache-2.0, and the paid cloud service is a layer on top of it. The essay is fair to Neo4j throughout. It ends by saying that for graph analytics at scale, "Neo4j is still where I'd start looking".
What are RushDB's main use cases?
RushDB is built for four jobs, which it names as memory for AI agents, a "company brain" that answers across several data sources, search inside an app, and analytics an agent can show its work on.
All four are the same engine used differently: records and links written as data arrives, a catalog read before querying, and search, traversal and counting in one request. The three customers named on the homepage map onto them, though the quotes are the customers' own words and I could not verify their numbers.
Agent memory that can say where a memory came from
An agent stores each chat turn, tool result or fact as a record, scoped by user, agent or session with ordinary fields, and links each fact to the turn that produced it. Recall then returns the source turn alongside the memory. A memory write is just a nested document:
{"user": "u-42", "session": "s-9", "role": "user",
"text": "Ship the order to my office, not home",
"FACT": [{"key": "delivery_address", "value": "office", "user": "u-42"}]}Billboardbug says its routing agents work from "25,062+ behavioral routing trips" kept this way. SymboSystems uses the same pattern for operations agents that react to business events.
A company brain across documents, CRM and billing
Each source lands in its own shape, and RushDB links records across sources on keys they already share, such as an email or a Stripe customer ID. A question like "why did this account churn?" can then filter by account first and rank documents by vector and keyword similarity together. Antifragile AI uses it to trace EU AI Act compliance answers back to "one evidence chain". If you are weighing this against plain retrieval, our look at alternatives to RAG and when to use them covers the trade-offs.
Search and assistants on the records your app already writes
Text and vector indexes live next to the records, so there is no second search engine to keep in sync. Facet counts come from the catalog under the same filter as the results, so the count next to each checkbox always agrees with the list. On a self-hosted engine you supply the embedding vectors yourself; generating them is a cloud feature. For a lighter vector setup, see our guide to a low-storage vector index with LEANN.
Analytics an agent can show its work on
The agent reads labels, fields and value counts, writes SQL against fields that exist, and returns the query with the answer so anyone can rerun it. BI tools connect over the PostgreSQL wire. I joined orders to customers through RushDB's relationship table with a stock psql 18.6 client, logged in with a read-only token:
plan | status | orders
------------+------------------+--------
enterprise | paid | 1
enterprise | pending | 1
enterprise | refunded_full | 1
enterprise | refunded_partial | 1
pro | paid | 1The same rows answer every language. In the SQL view a label is a table, and each relationship type is a table in a rushdb_edges schema.
Should you switch to RushDB?
Switch if your data arrives as changing JSON, relationships between records matter, and agents query it; stay where you are if your data is stable, relational and needs high availability today.
The strongest case is a team about to run Postgres, a vector database, a graph store and the jobs that keep them in sync, just to give an agent memory and search. RushDB replaces that stack with one process and one copy of the data. One RushDB blog post is titled "Why Every AI Stack Grows Into Five Data Pipelines", and the cost it describes is real. RushDB's own FAQ does not ask you to replace PostgreSQL: keep Postgres for stable relational work, and put the data your agents read and write in RushDB.
The company's use cases page also lists where it is the wrong tool, which is more candour than most vendors offer:
Pure transactional workloads such as ledgers and inventory belong in PostgreSQL or CockroachDB.
Time series at very high write rates belong in InfluxDB or TimescaleDB.
Blobs and files belong in S3 with a metadata index.
Flat, stable CRUD with no search needs nothing more than a relational database.
Warehouse analytics over hundreds of millions of rows belong in BigQuery, Redshift or DuckDB.
To that list I would add four cases from the documentation. Do not switch if you need automatic failover, because replication is asynchronous and promotion is manual. Wait if you have a large Cypher codebase: 1,385 of the 2,431 openCypher test scenarios in RushDB's profile pass, about 57%. Think twice if one tenant takes heavy single-record writes, since every write passes through one writer, about 1,015 commits a second with 32 writers on the company's test laptop. And if you run Windows servers, note there is no native build; it runs under WSL 2 or Docker.
Moving from RushDB 2.x is a migration, not an upgrade. You export each project as JSON, ingest it into a 3.x tenant, recreate relationships that nesting does not express, and rebuild vector indexes. For background on when a graph model is worth it at all, our guide to modelling connected data in graph databases is a good primer.
What are the pros and cons of RushDB?
Its strengths are the exact catalog, one binary that speaks many query languages, and tenant isolation built into storage; its weaknesses are youth, a single-node design and benchmark claims that outrun the published evidence.
Here is what RushDB does well:
There is no schema to design or migrate: you write JSON, and types and links are inferred per value.
The catalog of fields, types and values is exact and current on every write, and it can be narrowed to the records a filter matches.
One copy of the data answers SQL, Gremlin, Mongo-style queries, SQL/PGQ and the native JSON format, with Cypher and GQL in testing.
Vector, keyword and hybrid search run under the same filter as the records, so by design a filtered search never comes back short.
Tenants are separate key ranges, and short-lived scoped tokens let an agent read without being able to write.
Releases are signed with Sigstore, ship with checksums and a software bill of materials, and the engine is Apache-2.0.
It is fast on small and medium data: 16,000 linked records loaded in under a second on an ordinary laptop.
Here is where it falls short:
The engine is new: version 3.0 is under three weeks old and has needed ten patch releases, three of them with security fixes.
It runs as a single node, with no automatic failover, and Raft-based clustering is a preview not meant for production.
The company says it is not yet qualified past 30 million records per node, where its own candidate-heavy reads slowed to a 15-second median.
openCypher and GQL are incomplete, so it is no drop-in for Neo4j, and SQL has no multi-statement write transactions.
The self-hosted engine does not generate embeddings, has no dashboard and has no user accounts; those come with the paid cloud.
The documentation already trails the code in places, as the hands-on section below shows.
The headline accuracy figure on its homepage is not backed by a published method.
Does RushDB's 100× accuracy claim hold up?
It holds up only in part: RushDB's own published study shows real gains on changing data, but the homepage's "100× fewer made-up filter values" comes from small local models, and I found no published method behind it.
The homepage says invented filter values fell from 21.3% to 0.2% of questions, measured "with open models (Qwen3 8B and 14B, Qwen3.5 4B) running locally" on BIRD Mini-Dev, a standard set of 498 text-to-SQL questions. I searched every blog post and page RushDB publishes, including the full-text file it publishes for AI tools, and those numbers appear only on the homepage.
The 100× figure has no published method. The study RushDB did publish, on 12 November, is careful and worth reading. It ran Qwen3.5-9B, Qwen3.8-27B and an unnamed frontier model against RushDB 3.0.1. Its summary in "AI agent schema" says current models "rarely invented a filter value on static questions (1.0–2.2% with plain sampling)". Optional catalog lookups brought that to 0.4–1.0%, which the authors call "too few questions to be significant". They also report that "a tool that computed the same answers with plain SQL did as well as RushDB's catalog".
The real advantage shows up when data changes. After stored values were renamed, an agent reading an old schema snapshot gave stale answers on 28–55% of the affected questions, and the live catalog cut that by 41–89%. The near-zero results came from something else: a check that compares the finished query with stored values before it runs. RushDB's grounding article states that this check "exists in our benchmark harness today" and "is not a shipped feature".
So the fair reading is that RushDB makes the right information cheap and current, and the model still has to use it. The homepage itself adds that "large hosted models make few of these mistakes to begin with". The pre-execution check is the part that works without the model's cooperation, which is why I wrote one for this article.
How safe is a self-hosted RushDB?
The defaults are sensible: it listens only on localhost, refuses its default token on a network address, and supports read-only tokens; but several security fixes since 3.0 shipped without advisories, so read the changelog.
The security manual describes two credentials. The boot token has full access to every tenant and defaults to local-token. Capability tokens are signed by your own application with HMAC-SHA256, carry a read or write permission, optionally one tenant, and an expiry. In my test a read-only token was refused on a write over HTTP with 401 {"error":"unauthorized"}, and over the PostgreSQL wire with "the session's credential does not grant write". One detail to know: a PostgreSQL or Bolt session opened before a token expires stays open until it disconnects, so keep agent tokens on HTTP if you want expiry enforced per request.
The changelog shows four fixes worth knowing about:
In 3.0.1, data-access policies masked hidden properties in results, but those hidden values could still decide which records came back and in what order.
In 3.0.6, the setting
--pgwire-port 0, meant to turn the PostgreSQL listener off, instead opened an unencrypted one on a random port that the network guard never checked, on servers listening on the network.In 3.0.10, a delete by filter could remove records of a label the policy denied.
Also in 3.0.10, describing a SQL statement over the PostgreSQL wire could reveal the names and types of hidden tables and columns.
None of these has a GitHub security advisory or a CVE. NVD lists no entries for RushDB, and nothing is in CISA's catalogue of exploited flaws. They matter only if you use policies or expose the database, but the lesson is to run the latest 3.0.x and read each release note.
Two smaller points are worth knowing. The install script checks a SHA-256 file downloaded from the same release as the binary, which catches a corrupted download but not a tampered release. The Sigstore signature catches that, and the script checks it only if cosign is installed; pass --verify-signature to make it mandatory. I verified the 3.0.10 Linux build's signature with Python's sigstore 4.5.1 before running it. On the cloud side, RushDB's security page says plainly that no SOC 2 report has been published and it is not ISO 27001 certified. For the wider question of what agents can do with valid credentials, see our piece on AI agent security when valid access goes wrong.
How do you try RushDB and stop empty answers?
Install the signed binary, start it with your own token and a capability secret, load some JSON, then put a check in front of your agent's queries that refuses filters the catalog says cannot match.
curl -fsSL https://rushdb.com/install.sh | sh -s -- --verify-signature
export RUSHDB_CAPABILITY_SECRET=$(openssl rand -hex 32)
RUSHDB_TOKEN=$(openssl rand -hex 32) rushdb serve --data-dir ./data \
--capability-secret "$RUSHDB_CAPABILITY_SECRET"The engine listens on 127.0.0.1:3000 for HTTP and 5432 for SQL. To guard the queries I wrote rushdb_guard.py, one Python file with no dependencies. It mints a read-only token for the agent and checks every equality filter against the stored values.
export RUSHDB_TOKEN=$(python3 rushdb_guard.py token --scope read --ttl 900)
python3 rushdb_guard.py check --label ORDER \
--where '{"status": "refunded", "CUSTOMER": {"plan": "Enterprise"}}'Against the live engine, both mistakes in that filter were caught, each with the values that actually exist (output trimmed).
"path": "ORDER.status",
"message": "'status' stores no 'refunded'",
"suggestions": ["refunded_full", "refunded_partial"],
"path": "ORDER.CUSTOMER.plan",
"message": "'plan' stores no 'Enterprise'",
"suggestions": ["enterprise"],Given to an agent as its query tool, the same check returns those suggestions instead of an empty result, so the model can retry with real values. It costs about 2.7 milliseconds on a cold check and 0.4 once the catalog is cached.

Testing turned up two things the documentation gets wrong or leaves out. RushDB's filtering page says a plain ISO date string will not match a datetime field unless you write $eq. On 3.0.10 it matched either way. And value search matches numbers by how they print, so searching for the text "120" finds the number 120, even though the filter {"amount": "120"} matches nothing. The script checks each value's type for that reason. Its 20 tests pass on Python 3.10, 3.11 and 3.12: 15 against a stand-in server and 5 against the real 3.0.10 engine.
For scale, on an Intel Core i5-10210U laptop RushDB loaded 16,000 linked records (customers, tickets and orders) in 0.92 seconds from one client. A full catalog read took 0.7 milliseconds. These are small records on one machine, not a benchmark, and they are not comparable with the company's own 10-field test set.
How much does RushDB cost?
The engine is free under Apache-2.0; RushDB Cloud has a free tier and paid plans from $49 a month, priced mainly by storage, as of 16 November 2026.
The cloud pricing changed on 11 November, when RushDB dropped its "Knowledge Units" meter. The founder's pricing post admits: "Nobody could predict them, me included". The plans now are Free (1 GB, about 370,000 records, three projects), Pro at $49 a month with 20 GB, Team at $199 a month with 100 GB, SSO and an audit log, and Enterprise by contract. Paid plans start with a spending cap at twice the plan fee; at the cap, writes pause while reads keep working. The cheapest paid plan rose from $10 to $49, so small users of the old tiers pay more. What the cloud adds over self-hosting is managed embeddings, natural-language search, relationship suggestions, a hosted MCP server with OAuth, a dashboard and team access.
Is RushDB worth adopting now?
For a new agent project with messy, connected JSON, yes, as a second database next to Postgres; for production systems that need failover or a mature Cypher engine, not yet.
RushDB's idea is sound and easy to test: the database should tell an agent what it holds, exactly and currently, before the agent guesses. The engine delivers that, and the company is unusually open about its gaps, from the 57% Cypher score to the 30-million-record ceiling. Treat the 100× figure as marketing until a method is published, keep a pre-execution check in front of your agent until RushDB ships its own, and give every agent a short-lived read-only token. If your agents already talk to tools through MCP, as in our GA4 MCP server guide, RushDB's MCP server slots into the same workflow. The empty answer from the opening paragraph is the cheapest bug to prevent and one of the most expensive to trust.
Frequently asked questions
Is RushDB a vector database?
It includes one, but the vectors live on ordinary records. The engine offers exact and HNSW vector indexes, BM25 full-text and hybrid search, all under the same filter as a records query. The self-hosted engine stores and searches vectors you supply; RushDB Cloud can generate embeddings for you. In 3.0, approximate (ANN) search supports cosine similarity only.
Can Claude, ChatGPT or Cursor use RushDB?
Yes, through the RushDB MCP server (@rushdb/mcp-server 3.4.1), which works with any MCP client. It connects to RushDB Cloud with an API key, or to a self-hosted engine in direct mode. Its discovery-first workflow tells the agent to read the schema with getSchemaMarkdown before it queries. RushDB Cloud also hosts an MCP server with OAuth.
Can I import a Neo4j database into RushDB?
RushDB 3 cannot read a Neo4j store directly, so export your data as JSON documents, load it with the ingest operation, then recreate the relationships that nesting does not express. For queries, RushDB speaks Bolt 5.0, and the official Neo4j Python (6.4) and JavaScript (6.2) drivers were tested against it by hand, but its Cypher support is still a release candidate.
How do you back up a self-hosted RushDB?
The binary includes online base backups, point-in-time restore from an archived write-ahead log, and asynchronous streaming replication to read-only followers. Backups hold data but no secrets. RushDB does not encrypt snapshot or archive files, so encrypt them at rest yourself, and take a base backup before replacing the binary on an upgrade.



