RushDB vs SurrealDB: two different bets on one engine.

Side by side

The same task in both: connect a customer to orders and traverse them.

Both snippets create connected records and read them back through the relationship. The difference is whether the connection comes from statements or from the shape of the data.

-- Create records, then wire edges by hand
CREATE customer:cust1 SET name = 'Acme';
CREATE order:ord1 SET summary = 'Annual plan upgrade';
CREATE order:ord2 SET summary = 'Added 40 seats';

RELATE customer:cust1->placed->order:ord1;
RELATE customer:cust1->placed->order:ord2;

-- Traverse with arrow syntax
SELECT ->placed->order.* FROM customer:cust1;

-- Vector search: define an HNSW index and bring
-- your own embeddings (no built-in generation)

import RushDB from '@rushdb/javascript-sdk'

const db = new RushDB('RUSHDB_API_KEY')

// The payload shape IS the relationship
await db.records.importJson({
  label: 'CUSTOMER',
  data: {
    name: 'Acme',
    ORDER: [
      { summary: 'Annual plan upgrade' },
      { summary: 'Added 40 seats' },
    ],
  },
})

// Traverse through the same JSON contract
const orders = await db.records.find({
  labels: ['ORDER'],
  where: { CUSTOMER: { name: 'Acme' } },
})

Switching

Moving from SurrealDB: the same one-engine promise, without the new language.

Both products bet on one engine for documents, graphs, and vectors. The tax in SurrealDB is SurrealQL fluency and hand-wired RELATE edges. Migration is mechanical: SurrealDB records export as JSON, which is exactly what RushDB ingests — edges become nested structure or explicit relationship writes.

Who this is for

Pick the right tool for the job.

If you need one engine that also runs embedded on the edge or in a desktop app, and your team is comfortable learning SurrealQL, SurrealDB’s single-engine bet is compelling. If you want a server-side API that infers schema from JSON as it arrives, ships managed embeddings, and exposes a live schema and MCP tools built specifically for agents, RushDB is the closer fit.

Comparison table

Data model, graph traversal, and deployment

SurrealDB rows below are sourced from SurrealDB’s own docs and pricing page, checked on the date shown. One caveat carried over from research: SurrealDB’s own pages disagree on the exact license short-name (BSL-1.1 in the LICENSE file vs. "BSL-1.0" on the open-source page), and the implicit default for SCHEMAFULL/SCHEMALESS when neither is specified isn’t documented — both are flagged rather than asserted.

SurrealDB facts sourced from surrealdb.com/docs, surrealdb.com/pricing, and SurrealDB’s GitHub LICENSE file as of the dates shown above; the SurrealQL snippet follows documented CREATE/RELATE/SELECT syntax. Two items are explicitly flagged as unconfirmed in the table above rather than asserted. RushDB facts are drawn from RushDB’s own docs and feature pages linked throughout this site. Report a stale claim to hi@rushdb.com.

Implementation example

Store and recall agent memory over a JSON-shaped API

No new query language to learn — write JSON, index the field you want recalled by meaning, then search.

from rushdb import RushDB

db = RushDB("RUSHDB_API_KEY")

db.ai.indexes.create({
    "label": "MEMORY",
    "propertyName": "output",
})

db.records.create(
    label="MEMORY",
    data={
        "agent_id": "agent-42",
        "kind": "decision",
        "output": "Keep the free plan, but increase Pro onboarding limits after launch feedback.",
        "status": "approved",
    },
)

recall = db.ai.search({
    "labels": ["MEMORY"],
    "propertyName": "output",
    "query": "What did we decide about Pro onboarding?",
    "where": {"agent_id": "agent-42", "status": "approved"},
    "limit": 5,
})

print(recall.data)

Questions developers ask.

Related

Go deeper on the workflow.