[ RUSHDB 2.0 — ONTOLOGY API · NATIVE VECTOR SEARCH · AGENT SKILLS ]

Memory for agents.Instant.

Write JSON. Get a graph, semantic search, and queryable schema — automatically.
No pipeline. No separate stores. No schema planning.

json input
 
push
graph — auto-linked nodes
MEMORYAGENTACTIONSESSIONSTEPTOPICTAGSSCOREINDEX
vector embeddings
How it works

Push. Structure. Query.

Push data

Any JSON or CSV. Any shape. RushDB parses field names, types, and nested structure on write — nothing to define upfront.

Instant structure

Property names and types become graph nodes. Records sharing a property link automatically — no relationship declarations needed. Vectors indexed server-side on write, or bring your own embeddings.

Query everything

One unified SearchQuery for records, relationships, and schema. Combine semantic similarity and graph traversal in a single call — same shape every time.

DEVELOPER EXPERIENCE

Before and after.

Before
After — RushDB
DATA MODEL

Write Records. Query everything they imply.

One primitive. Relationships, vectors, and queryable schema emerge on write.

EPISODIC MEMORY

Facts and events, stored

Every tool output, conversation turn, and action — written once as a typed Record with automatic graph relationships between them. Retrieve by agent ID, time range, or semantic similarity.

Records + Relationships

SEMANTIC MEMORY

Meaning, auto-embedded

Any string property becomes a searchable vector — embedded server-side on write, no extra step. Query by meaning, not just by value. Bring your own model if you prefer.

Vector Properties + AI Indexes

STRUCTURAL MEMORY

Structure, instantly queryable

A live ontology of every label, property, value range, and relationship — built from your data, fetched in one call. Agents never construct queries blind.

Ontology API

THE TYPICAL STACK

Systems get stitched together

  • Redis for session state
  • Vector DB for search
  • Database for structure

Writes require syncing across systems.

Pipelines require maintenance

  • Embedding
  • Indexing
  • Schema updates

Every change forces a full reprocess.

Data drifts out of sync

  • Structure is partial
  • Relationships are missing
  • Indexes lag behind source data

Queries rely on assumptions instead of actual state.

RushDB makes structure, meaning, and relationships first-class — not outcomes of stitching systems together.

Use cases

Who it’s for.

Every agent action, indexed and retrievable.

Store and retrieve agent state, tool outputs, and conversation history across sessions. Query by agent ID, time range, or semantic similarity — all in one call.

Why RushDB: No separate vector store. Graph links sessions, actions, and context automatically.

Features

What's in the box.

Managed Embeddings

Mark any string property for embedding. RushDB embeds it server-side on every write — no embedding pipeline to run, no backfill jobs to schedule. Switch to your own model at any time by passing pre-computed vectors.

Vector + Graph

Semantic similarity and graph traversal compose in one query. Filter by relationships, rank by meaning — no separate stores to sync.

MCP Server

Add RushDB to any agent with one config block. Your agent can read, write, and semantically search your data mid-conversation — no extra setup, no custom integration.

ACID transactions

Two agents writing simultaneously won't corrupt each other's memory. Every write either fully completes or fully rolls back — no partial states, no silent data loss.

Self-host or Cloud

Run on your own infrastructure with Docker and your Neo4j instance, or use managed cloud with a free tier. No shared infrastructure, no lock-in.

Unified Query API

The same SearchQuery works for records, relationships, labels, properties, and deletes — identically. Learn it once on records. Never learn a separate paradigm for schema discovery, relationship traversal, or cleanup.

ECOSYSTEM

Works where you work.

Direct SDKs for every stack. Native MCP for every agent. Your coding agent learns RushDB from your dependencies, not your docs.

MCP SERVER

One config block. Every MCP agent.

Paste it once. Your agent can read, write, and query RushDB mid-conversation — records, relationships, semantic search, all of it.

mcp.json

WORKS WITH ANY MCP AGENT

AMPAntigravityClaude CodeClawdBotClineCodexCursorDroidGeminiGitHub CopilotGooseKiloKiro CLINous ResearchOpenCodeRooTraeVSCodeWindsurfAMPAntigravityClaude CodeClawdBotClineCodexCursorDroidGeminiGitHub CopilotGooseKiloKiro CLINous ResearchOpenCodeRooTraeVSCodeWindsurf

AGENT SKILLS

Install expertise, not boilerplate.

Your coding agent learns the SearchQuery shape, importJson patterns, and ontology API — loaded when relevant, not dumped into every session.

Works with Claude Code, Cursor, Codex, Copilot, and OpenCode. No manual setup. No prompt files to maintain.

SDKs

Same API, every runtime.

All three share identical query semantics — SearchQuery, importJson, ai.search. Learn the shape once; run it in TypeScript, Python, or plain HTTP.

Ontology API

Agents that know your data
before they query it.

RushDB builds a live ontology from every record you push. Agents read it once per session — and never construct a query blind again.

POST/api/v1/ai/ontology/md

What the agent now knows

✓  Valid filter ranges

Agent knows price ranges from $9.99 to $2,499. It won't filter for price > $10,000 and return empty results.

✓  Real property names

Agent knows the field is "category", not "type" or "productType". No hallucinated field names. No silent query failures.

✓  Traversable relationships

Agent knows CUSTOMER → ORDER → PRODUCT is the real topology. Multi-hop queries built with confidence, not guesswork.

One call. One session. No hallucinated schema.

✕ Before
✓ After
Agent filters price > 50,000 — 0 results, no explanation
Agent knows max price is $2,499 — constructs meaningful range query
Agent queries productType field — doesn't exist, silent fail
Agent queries category — real field, real values
Agent traverses USER → ITEM — relationship doesn't exist
Agent traverses CUSTOMER → ORDER → PRODUCT — exact topology

Fewer empty results. Fewer hallucinations. Agents that explain themselves.

The same SearchQuery that finds records also discovers what labels, properties, and relationships exist — making schema introspection a natural extension of the query you’re already writing. No separate schema API to learn.

Pricing

Simple, predictable pricing.

Pay for what you write — not for servers, nodes, or queries. 1 KU = 1 field written. Reads are always free. Full pricing details →

MonthlyAnnual

Free

FREE

Evaluate RushDB in production conditions

Get started instantly:

  • 100K KU / month

    ~3,000 records with 10 fields each

  • 2 projects

    No time limits, no feature restrictions

  • Full REST API and SDKs
  • Self-hosted & BYOC

    Connect to your own Neo4j or Aura

  • Vector & AI search
  • Community support

Pro

from$24/ mo

Perfect for production applications

Everything in Free, plus:

  • 10M KU / month

    100× Free plan — ~300,000 records with 10 fields each

  • Overage billing

    Continue beyond 10M KU at $3 / M KU

  • Unlimited projects
  • 3 team members

    then $10 / seat

  • Self-hosted & BYOC

Scale

from$73/ mo

For high-volume and data-intensive apps

Everything in Pro, plus:

  • Unlimited KU

    Usage-based — pay only for what you consume

  • Unlimited team members
  • Self-hosted & BYOC
  • SLA guarantee
  • Priority support

FAQ

Frequently asked questions

On the Free plan (100K KU/month), once you reach your limit, writes pause until your next billing period — reads and standard queries always continue. We'll send email notifications at 75%, 90%, and 100% usage.

Give your agent memory.