Rushdb

Rushdb

Graph and vector persistent memory for AI agents — push JSON, get a typed, searchable graph.

81/100Safe BetFree · from $8/moFreemium

RushDB is worth a look if you are building agent memory or GraphRAG and are tired of keeping a vector store and a graph layer in sync by hand — the single SearchQuery that mixes similarity, exact filters, and graph traversal is the real draw. The 2026-06-01 release also made vector search stop stalling behind background indexing, which addresses the classic cold-start annoyance. Go in with open eyes on the meter: writes cost Knowledge Units (0.5 per record, 1 per property, 0.25 per link, 5 per embedding) while reads stay free, so a nested write-heavy workload gets expensive fast. If you want a schema-free operational model and Neo4j under the hood is fine, this is a leaner alternative to

Verified 11d ago · liveness 81/100 · cite: rightaichoice.com/tools/rushdb

Best for
  • AI agent developers needing durable, connected memory across sessions
  • Teams building GraphRAG pipelines that need relationship context
  • Developers building multi-agent coordination with shared state
  • Organizations running fraud detection or transaction monitoring on connected data
Not ideal for
  • Teams that want a pure vector database with no graph relationships
  • Teams that require strict fixed schemas with controlled migrations
  • Projects needing built-in UI components or a full frontend
Visit Website

IntermediateSolo developer: install the SDK (pip install rushdb) and run a first import against a project API key in well under an hour. Agent or GraphRAG team: expect an afternoon to model your first connected dataset and wire Smart Search or SearchQuery into your agent loop. Self-hosted or External Database teams: budget longer, since you provision and operate Neo4j infrastructure alongside RushDB.API · PluginAPI availableVerified 11d ago
Pricing
Free · from $8/mo
FreemiumFree tier4 plans6 hidden costs
Learning curve
Intermediate
Solo developer: install the SDK (pip install rushdb) and run a first import against a project API key in well under an hour. Agent or GraphRAG team: expect an afternoon to model your first connected dataset and wire Smart Search or SearchQuery into your agent loop. Self-hosted or External Database teams: budget longer, since you provision and operate Neo4j infrastructure alongside RushDB.
Runs on
APIPlugin
API available · 7 integrations
Who it's for
AI agent developerGraphRAG engineerData or fraud analyst
Live sentiment
Is Rushdb actually worth it?

We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.

  • Honest verdict, not marketing
  • Real pros & cons from real users
  • Attributed quotes with receipts
Run a free scan

3 free scans · no card needed

Skip it if

Skip RushDB if your pipeline is write-heavy with deeply nested payloads and no relationship queries in return, since every record, property, link, and embedding is metered in Knowledge Units and per-KU overage gets expensive fast.

The 30-second take
Biggest gripe

Going past Pro's included 1M KU costs $10 per million KU, and nested payloads inflate that quickly because each child record and link is charged separately.

Price reality

RushDB sits at the low end for a managed graph-plus-vector memory layer: Free covers 100K KU/month, Start is $8/mo and Pro is $24/mo with 1M KU included, both well under what you would typically spend running Neo4j plus a hosted vector store in parallel. Scale at $73/mo with unlimited KU is aimed at teams whose write volume has outgrown Pro's overage rate. Solo developers and small teams get real production capacity under $25/mo; only high-write enterprises need the custom Enterprise tier for

In short

Rushdb — Graph and vector persistent memory for AI agents — push JSON, get a typed, searchable graph. Best for AI agent developers needing durable, connected memory across sessions, Teams building GraphRAG pipelines that need relationship context, Developers building multi-agent coordination with shared state. Free to start; paid plans from $8/mo.

What's new in Rushdb

Checked 3 days ago

Across the latest 2 updates: 2 changelog entries.

What people actually say about Rushdb — is it worth it?

We scanned public community sources for Rushdb on Sep 23, 2026 and could not establish that the discussion we found is about this tool rather than something else sharing its name. Only 2 of the posts we fetched could be positively tied to Rushdb. Rather than publish a sentiment score built on the wrong subject, we publish nothing here and re-run the scan.

Viability Score

81/100
Safe Bet

How well maintained and how widely used is Rushdb? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this

Recent activity
90
Traction
100
Site health
95
User sentiment
55
What the vendor publishes
60

Last calculated: October 2026

How we score →

Key Features

  • Graph + vector persistent memory
  • No-schema JSON, CSV, event, and document ingestion
  • Automatic graph reconstruction from nested JSON
  • Live schema discovery (fields, values, relationship paths)
  • Vector embeddings, managed or bring-your-own
  • Combined SearchQuery API (similarity + filters + graph)
  • Full-text search combined with semantic search
  • Graph traversal and multi-hop queries
  • ACID transactions on Neo4j
  • REST API
  • TypeScript SDK for browser and Node.js
  • Python SDK with sync and async access
  • Native MCP server with OAuth
  • Agent skills pack for memory, querying, and modelling
  • Smart Search: natural language to inspectable SearchQuery

About Rushdb

FreemiumIntermediateAPI availableAPI · Plugin

RushDB is a context infrastructure layer that turns the operational JSON, CSV, events, or tool output you already produce into connected, searchable records. Instead of running an application database, a cache, a vector store, and hand-written graph logic side by side, you write once through the REST API, TypeScript SDK, Python SDK, or the MCP server, and RushDB decomposes nested objects into linked records, updates a live schema, and generates vector embeddings in the same call. You then serve three workloads from one model: application reads, natural-language agent requests via Smart Search (which generates an inspectable SearchQuery), and aggregations. Query-time structural awareness lets agents inspect actual fields, observed values, and relationship paths before building filters, so they ground their queries in what the data really contains. It runs on Neo4j for ACID transactions and can be used as managed cloud, against an External Database (Neo4j or Aura), or self-hosted; the core is open source. Pricing is metered in Knowledge Units: writes, properties, links, and embeddings consume KU, while standard reads stay free. As of the 2026-06-01 core 2.10.4 release the default embedding model is openai/text-embedding-3-small and the default chat model is openai/gpt-5.6-luna, and core 2.11.0 (2026-07-23) added automatic datetime typing for date-only strings. It fits developers building agent memory, GraphRAG, multi-agent coordination, and connected-data analytics — not teams that want a pure vector store with no relationships, or a fixed schema with controlled migrations.

Behind the Verdict

RushDB's pitch is narrow and honest: it is the persistence layer under your agent or application, not a chat product. The strongest part is the write path. You send the JSON your product already owns — an ACCOUNT with a nested TICKET array, for instance — and RushDB splits nested objects into separate linked records, forms the relationships, registers the live schema with value domains, and generates embeddings, all in one import. That removes the sync code most teams hand-write between an operational database and a vector store, and it is why the 'one model, one API, no synchronization code' framing holds up. The second strong part is read-time awareness. Agents can inspect fields, observed values, and relationship paths before they construct a query, which is a real difference from guessing a filter against an opaque vector index. Smart Search generates an inspectable SearchQuery rather than a black-box answer, so you can see and correct what the model decided. The query surface itself is genuinely combined — similarity search, exact filters, and multi-hop graph traversal in a single call — backed by Neo4j and ACID transactions. Weaknesses are structural, not cosmetic. Everything is metered in Knowledge Units on the write side: 0.5 per record, 1 per property, 0.25 per link, 5 per embedding, and beyond the included allowance Pro charges $10 per million KU. Read-heavy agent recall is cheap; a firehose of nested writes is not. The Free tier caps at 100K KU/month and pauses writes when you hit it (reads continue, with email warnings at 75%, 90%, and 100%). You also inherit Neo4j: self-hosting means managing Neo4j infrastructure yourself, and teams not already on Neo4j take on that operational learning curve. There are no frontend components — you integrate through the API and SDKs. On defaults, the current documentation-backed release sets openai/text-embedding-3-small for embeddings and openai/gpt-5.6-luna for chat, both replaceable with bring-your-own vectors, and core 2.11.0 tightened datetime handling so date-only strings like 2026-07-23 are typed as datetime without configuration. Where it fits: agent memory across sessions and model calls, GraphRAG that needs related entities rather than nearest chunks, multi-agent coordination with shared durable state, and connected-data analytics such as transaction-flow tracing. Where it does not: teams that want a plain vector store with no relationships, teams that need rigid schemas and controlled migrations, and write-heavy pipelines where per-KU pricing will dominate the bill.

Researching Rushdb? Get your full AI stack in 60 seconds.

Free, no signup — tell us your goal and get tools matched to your budget & existing stack.

Real-world workflow fit

Concrete scenarios for the personas Rushdb actually fits — and what changes day-one when you adopt it.

AI agent developer

You install the Python or TypeScript SDK, create a client with one project API key, and import the operational JSON your product already emits — accounts, tickets, events — letting nested objects become linked records and the live schema update itself.

Outcome: Your agent calls Smart Search or a SearchQuery for durable state, decisions, and tool output across sessions without you writing sync, embed, or index code.

GraphRAG engineer

You write embeddings once through the SDK (or bring your own vectors) and then issue a single SearchQuery that combines similarity, exact filters, and graph traversal over related entities.

Outcome: Retrieval returns connected evidence instead of isolated chunks, and records from vectorSearch expose a typed score getter so you can rank and threshold results.

Data or fraud analyst

You import transaction, device, merchant, and alert data, inspect the live schema and relationship paths in the dashboard, and run aggregations and multi-hop traversal queries on the connected model.

Outcome: You trace suspicious flows across accounts and devices and get read-time analytics from the same records your applications and agents query.

Use Cases

Models Under the Hood

openai/text-embedding-3-smallopenai/gpt-5.6-luna

as of 2026-09-09

Limitations

  • Pricing is metered in Knowledge Units on writes, which can bite data-heavy applications: each record costs 0.5 KU, each property 1 KU, each link 0.25 KU, and each embedding 5 KU, while standard reads and queries stay free.
  • The Free tier caps at 100K KU/month and pauses writes when you reach it — reads continue, and RushDB emails you at 75%, 90%, and 100% usage.
  • Beyond Pro's included 1M KU, overage is billed at $10 per million KU; Scale moves to usage-based billing at $8 per million KU with unlimited KU.
  • Seat add-ons cost $10/seat on Pro and $25/seat on Scale.
  • Self-hosting means managing Neo4j infrastructure yourself, and teams not already on Neo4j take on that operational overhead.
  • There are no built-in frontend components; you integrate through the API and SDKs.

as of 2026-09-27

Verification history

We have re-verified Rushdb 7 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.

  1. — re-checked, vendor evidence unchanged
  2. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  3. — re-checked, vendor evidence unchanged
  4. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  5. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  6. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it

Showing the 6 most recent of 7 verification passes.

Free to cite with attribution — this page re-verifies continuously.

12-month cost

Project the real annual outlay, including the implied monthly cost when only an annual tier is published.

Annual total
Free
Over 12 months
Effective monthly
Free
Billed monthly

Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.

Plans compared

For each published Rushdb tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.

Free

$0/mo

Ideal for

Developers evaluating RushDB or prototyping an agent memory model who want to stay on the open-source path with no spend.

What this tier adds

Starting tier: 100K KU/month, 2 projects, full REST API and SDKs, vector and AI search, self-hosted and External Database options, community support.

Start

$8/mo

Ideal for

A solo developer shipping a first production agent or application that has outgrown the 100K KU prototype allowance.

What this tier adds

Raises the allowance to 250K KU/month, adds 1 team member, and keeps 2 projects with self-hosted and External Database support.

Pro

$24/mo

Ideal for

A small production team running live agents and applications that need multiple projects and room before overage kicks in.

What this tier adds

Adds 1M KU/month included with overage at $10 per million KU, 10 projects, and 3 team members with extra seats at $10/seat.

Scale

$73/mo

Ideal for

Teams with high-volume shared context that have outgrown Pro's 1M KU allowance and need SLA and priority support.

What this tier adds

Adds unlimited KU on usage-based billing at $8 per million KU, 100 projects, 10 team members, extra seats at $25/seat, an SLA guarantee, and priority support.

Hidden costs & gotchas

What the public pricing page doesn't put in bold. Captured from pricing-page footnotes, contract terms, and recurring complaints.

  • Going past Pro's included 1M KU costs $10 per million KU, and nested payloads inflate that quickly because each child record and link is charged separately.
  • Embeddings add 5 KU per record on top of the 0.5 KU record and 1 KU per property, so turning on vectors can multiply your write bill versus storing plain records.
  • Adding teammates is not included on Pro beyond 3 seats: extra seats cost $10/seat, and on Scale extra seats cost $25/seat.
  • The Free tier caps at 100K KU/month and pauses writes at the limit until the next billing period — only reads and standard queries keep running.
  • Vector search, raw Cypher, and deep traversals each cost 5 KU per call, so heavy agent recall patterns consume KU even though standard reads are free.
  • Teams needing SSO, a dedicated instance, or an SLA must move to the Enterprise tier, which is quoted as custom pricing rather than a published rate.

Where the pricing makes sense

The company stage and team size where Rushdb's pricing actually pencils out — and where peers do it cheaper.

RushDB sits at the low end for a managed graph-plus-vector memory layer: Free covers 100K KU/month, Start is $8/mo and Pro is $24/mo with 1M KU included, both well under what you would typically spend running Neo4j plus a hosted vector store in parallel. Scale at $73/mo with unlimited KU is aimed at teams whose write volume has outgrown Pro's overage rate. Solo developers and small teams get real production capacity under $25/mo; only high-write enterprises need the custom Enterprise tier for

Setup time & first value

How long it actually takes to get something useful out of Rushdb — broken out by persona, not the marketing-page minute.

Solo developer: install the SDK (pip install rushdb) and run a first import against a project API key in well under an hour. Agent or GraphRAG team: expect an afternoon to model your first connected dataset and wire Smart Search or SearchQuery into your agent loop. Self-hosted or External Database teams: budget longer, since you provision and operate Neo4j infrastructure alongside RushDB.

Switching to or from Rushdb

How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.

Migrating in
  • →From a plain vector store: import your existing records as JSON so RushDB rebuilds relationships and embeddings in one write instead of a separate sync pipeline.
  • →From hand-written graph logic in application code: move entity and relationship creation into RushDB's nested-JSON import and drop the join and retry code.
  • →From Neo4j directly: point RushDB at your existing Neo4j or Aura instance using the External Database deployment option.
Migrating out
  • ↗To Neo4j: your data already lives on Neo4j, so export or query the underlying graph directly if you outgrow the managed layer.
  • ↗To a dedicated vector store: export embeddings and records from RushDB and reindex them in your vector database of choice.
  • ↗To a self-hosted RushDB: move off managed cloud onto your own Neo4j infrastructure without changing your SDK calls.

Integrations

Neo4jNeo4j AuraOpenAIClaude DesktopCursorModel Context ProtocolGitHub

Resources & Guides

Tutorials & Learning

YouTube returned 6 videos for “Rushdb”, and we withheld 6: 6 could not be judged, because “Rushdb” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Rushdb.

Tools that pair well with Rushdb

Common stack mates teams adopt alongside Rushdb, with the specific reason each pairing earns its keep.

Featured Head-to-Head Comparisons

Alternatives to Rushdb

View all
Mem0

Mem0

AI memory layer that gives agents and apps persistent, cross-session context

FreemiumTry
Distill

Distill

Open-source context intelligence and persistent memory for LLM agents: semantic dedup and deterministic compression in ~12ms with no LLM calls.

FreeTry
Tidb

Tidb

Open-source distributed SQL database unifying transactions, HTAP analytics, and native vector search for AI agents.

FreemiumTry

Frequently Asked Questions

Used Rushdb? Help shape our editorial sentiment research.