Rushdb
Graph and vector persistent memory for AI agents — push JSON, get a typed, searchable graph.
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
- 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
- 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
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
3 free scans · no card needed
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.
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.
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 agoAcross the latest 2 updates: 2 changelog entries.
RushDB core 2.11.0: date-only strings auto-typed as datetime; embedding index cold-start; vectorSearch score getter
Date-only strings like 2026-07-23 now auto-type as datetime, creating an embedding index no longer requires the property to exist, and the JS SDK vectorSearch exposes a typed score getter.
RushDB core 2.10.4: faster vector search and default model updates
Vector search no longer stalls behind background indexing, provider embedding calls now have strict timeouts with backfill retries, and defaults became openai/text-embedding-3-small and openai/gpt-5.6-luna.
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
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
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
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.
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.
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.
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
- Persist customer support ticket history and resolutions across sessions so agents recall past context instantly.
- Maintain sales deal context and account relationships so agents remember every interaction.
- Trace suspicious transaction flows across accounts, devices, merchants, and alerts in real time.
- Coordinate multi-agent incident response by sharing durable graph memory during a live SaaS incident.
- Build RAG applications that retrieve related entities and relationships, not just nearest chunks.
- Keep agent state, decisions, and tool output available across model calls and sessions.
- Store and query GraphRAG knowledge bases with relationship-aware retrieval.
- Serve application reads, grounded natural-language requests, and analytics aggregates from the same connected records.
Models Under the Hood
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.
- — re-checked, vendor evidence unchanged
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-checked, vendor evidence unchanged
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — 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.
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.
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.
- →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.
- ↗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
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.
Official links
Tools that pair well with Rushdb
Common stack mates teams adopt alongside Rushdb, with the specific reason each pairing earns its keep.
Mem0
AI memory layer that gives agents and apps persistent, cross-session context
Distill
Open-source context intelligence and persistent memory for LLM agents: semantic dedup and deterministic compression in ~12ms with no LLM calls.
Tidb
Open-source distributed SQL database unifying transactions, HTAP analytics, and native vector search for AI agents.
Featured Head-to-Head Comparisons
Rushdb vs Spider Cloud
If you need persistent memory that keeps AI agents contextually aware across sessions, RushDB is the clear choice with its graph+vector combination and MCP support. If your agents need live data from the web to ground their responses, Spider Cloud provides a fast, low-cost, and AI-friendly scraping foundation. They are complementary rather than competitive; both may be used together in a production AI stack.
Rushdb vs Temporal Ai
Choose Temporal AI if your primary need is durable, fault-tolerant orchestration of long-running workflows or AI agents that survive crashes and require human oversight. Choose Rushdb if you need a persistent memory layer for AI agents that stores structured, relationship-rich data across sessions—think GraphRAG or multi-agent coordination. They address different layers: Temporal handles execution reliability, Rushdb handles data memory.
Rushdb vs Presto Voice
Presto Voice is a niche, enterprise-grade drive-thru voice AI solution for large QSR chains, delivering measurable revenue lift (6% monthly avg.) but requiring a custom quote. RushDB is a developer-friendly graph+vector memory layer for AI agents, offered on a freemium model with flexible integration. Choose Presto Voice if you operate a chain of drive-thrus and want to automate orders and upsell; choose RushDB if you build AI agents that need persistent, relationship-aware memory across sessions.
Alternatives to Rushdb
View allFrequently Asked Questions
Used Rushdb? Help shape our editorial sentiment research.