Rushdb
Graph + vector persistent memory for AI agents — push JSON, get a typed, searchable graph.
RushDB is a strong pick if you want graph-aware AI memory without stitching together vector store, graph DB, and sync code. The no-schema JSON ingest and single SearchQuery API are genuinely useful. Be ready for Neo4j under the hood and per-KU write pricing — standard reads stay free, but writes cost based on connected context created.
Verified 6d ago · liveness 62/100 · cite: rightaichoice.com/tools/rushdb
- AI agent developers needing durable, connected memory across sessions
- Teams building GraphRAG pipelines that need relationship context, not just similar chunks
- Developers building multi-agent coordination systems with shared state
- Organizations needing fraud detection or transaction monitoring on connected data
- Users seeking a pure vector database without 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 you need a pure vector store without graph relationships, prefer a rigid schema with strict migrations, or have write-heavy workloads where per-KU pricing will bite hard.
Every write operation consumes Knowledge Units: 0.5 per record, 1 per property, 0.25 per link, and 5 per embedding — so data-heavy apps can burn through the free 100K KU/month quickly.
RushDB's free tier (100K KU/month) suits prototyping, while paid plans start at $8/mo (250K KU) and scale to $73/mo for high volume. Compared to vector-only stores like Pinecone or managed graph DBs, it bundles graph+vector, but per-KU write pricing is steeper for write-heavy apps. For read-heavy AI workloads, reads are free, making it cost-effective for agent memory.
In short
Rushdb — Graph + 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, not just similar chunks, Developers building multi-agent coordination systems 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 feature updates.
RushDB core 2.11.0: date-only strings auto-typed as datetime; embedding index cold-start; vectorSearch score getter
Date-only strings now auto-type as datetime, embedding index creation no longer requires property pre-existence, and the JS SDK vectorSearch exposes a score getter.
RushDB core 2.10.4: faster vector search and default model updates
Vector search no longer stalls behind indexing; default embedding model is openai/text-embedding-3-small and default chat model is openai/gpt-5.6-luna.
What people actually say about Rushdb — is it worth it?
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
1 mentions across 1 source (Hacker News) · researched Jul 3, 2026.
- +Zero-schema setup: push JSON without defining tables or migrations.
- +Automatic graph reconstruction infers relationships from nested data.
- +Built-in vector embeddings for semantic search out of the box.
- +Combines graph traversal, FTS, and vector search in one query interface.
- +Offers both cloud and self-hosted open-source deployment options.
- −Extremely limited community feedback as of early 2025.
- −No third-party benchmarks or performance data available.
- −Documentation maturity unknown; no user guides or tutorials found.
- −Potential vendor lock-in due to proprietary schema layer on Neo4j.
- −Query performance for complex graph traversals not validated.
- • 'Knowledge units' pricing is vague; overspending possible if writes spike.
- • Self-hosting requires managing Neo4j infrastructure underneath.
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: August 2026
How we score →Key Features
- Graph + vector persistent memory for AI agents
- No-schema JSON/CSV ingestion with automatic graph reconstruction
- Live schema discovery — inspect fields, values, paths before querying
- Vector embeddings (managed or BYO) with default openai/text-embedding-3-small
- Graph traversal and multi-hop queries
- Full-text search combined with semantic search in one query
- Combined SearchQuery API for similarity, filters, and graph connections
- ACID transactions (Neo4j)
- REST API
- TypeScript SDK
- Python SDK (sync and async)
- Native MCP server with OAuth for Claude Desktop and Cursor
- Agent skills — task guidance for memory, querying, and modelling
- Dashboard with query lab and visualization
About Rushdb
RushDB is a graph and vector database designed as a persistent memory layer for AI agents, applications, and analytics. Instead of running a separate graph DB, vector store, and sync pipeline, you push operational JSON, CSV, events, or tool output via REST API or SDKs, and RushDB automatically builds connected entities, live schema, relationships, and vector embeddings in one write. No schema design, no migrations, no hand-written sync code. Developers query the same connected model for application reads, natural-language agent requests, and aggregations — using one query shape. Built on Neo4j, RushDB supports ACID transactions and offers deployment options including managed cloud, External Database (Neo4j/Aura), or self-hosted. It ships TypeScript and Python SDKs, a REST API, and a native MCP server for tools like Claude Desktop and Cursor. The dashboard lets you query and visualize data, inspect live schema, and run a query lab. A native MCP server with OAuth and agent skills (task guidance for memory, querying, and modelling) makes it easy to plug into AI workflows. Key capabilities include live schema discovery — the system inspects fields, value domains, and relationship paths before you construct queries — so agents can build grounded filters instead of guessing. Semantic retrieval combines similarity search, exact filters, and graph traversal in a single call. Recent updates (August 2026) improved reliability: date-only strings auto-type as datetime, embedding index creation no longer requires property pre-existence, and the default embedding model is openai/text-embedding-3-small with default chat model openai/gpt-5.6-luna. RushDB positions itself as 'context infrastructure' — one layer that replaces the copy-and-sync sprawl of application DB, cache, vector store, and graph logic. It's built for developers building AI agents that need durable memory, teams implementing GraphRAG with relationship context, and organizations needing transaction monitoring
Behind the Verdict
RushDB earns its keep when your AI agent needs durable, connected memory — not just similar chunk recall. The core pitch is one queryable model: push JSON, get typed graph + vectors + live schema in a single write, then query by meaning, relationship, or both in one call. That kills the classic pain of syncing a vector store with a graph DB and hand-written join logic. In practice, the no-schema ingestion is the standout: nested JSON becomes linked records automatically, and query-time structural awareness means your agent can inspect actual fields and values before filtering — no guessing. Where it shines: agent context and memory, GraphRAG (retrieve connected evidence, not just similar chunks), multi-agent shared state, and operational analytics on connected data. The SDKs (TypeScript and Python) plus REST API and MCP server make integration straightforward. Recent updates in 2.11.0 fixed real annoyances: date-only strings auto-typing as datetime and embedding index cold-start without property pre-existence — both quality-of-life wins for production use. The default embedding model is openai/text-embedding-3-small and default chat model is openai/gpt-5.6-luna, reflecting a shift to newer models. But RushDB isn't for everyone. If you just need vector similarity over documents, a pure vector database like Pinecone or Qdrant will be simpler and cheaper. If you need strict schema migrations and fixed types, the live-schema approach (which evolves automatically) might feel too loose. And high-volume write workloads can get pricey — KU (Knowledge Unit) billing charges per record, property, link, and embedding; reads are free, but writes accumulate fast. Free tier: 100K KU/month, then writes pause until next cycle. Paid tiers start at $8/mo (Start) and $24/mo (Pro), with
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.
Building a customer support bot that needs to remember past tickets and resolutions.
Outcome: You push ticket JSON via the Python SDK; RushDB auto-links ACCOUNT→TICKET, creates embeddings, and the bot can query 'customers reporting onboarding issues' to retrieve connected evidence in one call.
Building a knowledge base that needs both semantic search and relationship context.
Outcome: You import documents with nested entities; RushDB creates a typed graph with links and vectors, so retrieval returns related chunks and their relationships, not just nearest neighbors.
Monitoring transaction flows to detect suspicious patterns.
Outcome: You push transaction events; RushDB traces connections across accounts, devices, and merchants, enabling real-time graph traversal to flag fraud rings.
Use Cases
- Persist customer support ticket history and resolutions across sessions for instant agent recall.
- 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 not just nearest chunks but also related entities and relationships.
- Keep AI agent state, decisions, and tool outputs available across model calls and sessions.
- Store and query GraphRAG knowledge bases with relationship-aware retrieval.
Models Under the Hood
as of 2026-08-21
Limitations
- Pricing is based on knowledge units (KU) written, which can be limiting for data-heavy applications: each record costs 0.5 KU, each property 1 KU, each link 0.25 KU, and embeddings 5 KU per record.
- Free tier caps at 100K KU/month; writes pause when the limit is reached.
- Self-hosted option requires managing Neo4j infrastructure.
- No built-in frontend components; you integrate via API/SDKs.
- The platform depends on Neo4j, so teams not already using it face additional operational overhead.
as of 2026-08-12
Verification history
We have re-verified Rushdb 4 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-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
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
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 prototyping a context model or evaluating RushDB with up to 100K KU/month and 2 projects.
What this tier adds
Starting tier: 100K KU/month, 2 projects, full API/SDKs, self-hosted, community support.
Start
$8/mo
Pro
$24/mo
Ideal for
Production applications and agents needing 1M KU/month, more projects, and team collaboration.
What this tier adds
Adds 750K more KU, overage billing at $10/M KU, 10 projects, 3 team members, SSO.
Scale
$73/mo
Ideal for
High-volume shared context workloads needing unlimited KU and up to 10 team members.
What this tier adds
Unlimited KU at $8/M KU usage-based, 100 projects, 10 team members, SLA guarantee, 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's free tier (100K KU/month) suits prototyping, while paid plans start at $8/mo (250K KU) and scale to $73/mo for high volume. Compared to vector-only stores like Pinecone or managed graph DBs, it bundles graph+vector, but per-KU write pricing is steeper for write-heavy apps. For read-heavy AI workloads, reads are free, making it cost-effective for agent memory.
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.
For a developer: install SDK, create project, import JSON — first query in under 10 minutes. Non-developers: add a day to learn API/SDK basics; dashboard helps but no UI builder.
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 Pinecone + Neo4j: Export your vectors and graph data, then import as JSON into RushDB; it will rebuild the graph and embeddings automatically.
- ↗To Neo4j directly: RushDB data lives in Neo4j; you can export via Cypher queries or use the External Database option.
Integrations
Resources & Guides
Tutorials & Learning
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
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.
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.
Alternatives to Rushdb
View allFrequently Asked Questions
Used Rushdb? Help shape our editorial sentiment research.