Create, understand, retrieve, use, and operate context.

01 · Connect your data

Turn incoming data into queryable graph context.

RushDB infers property types as data arrives. Nested payloads become linked records immediately. Flat sources can be analyzed for reviewable relationship patterns after import.

• Accept real payloads

  Use nested JSON, arrays of records, or CSV-shaped imports instead of forcing every source through a hand-built staging model.

• Keep structure queryable

  Nested objects become records connected by default parent-child relationships, so the source structure survives the import.

• Evolve flat imports safely

  When separate flat sources need joins, suggested patterns stay reviewable before they become durable graph relationships.

Import nested records in one call.

from rushdb import RushDB

db = RushDB('RUSHDB_API_KEY')

db.records.import_json({
    'label': 'COMPANY',
    'data': {
        'name': 'Acme Corp',
        'DEPARTMENT': [
            {'name': 'Engineering', 'headcount': 42},
            {'name': 'Design', 'headcount': 12},
        ],
    },
})

03 · Managed embeddings

Keep searchable text indexed as records change.

Define an embedding index for the label and string property you want to retrieve by meaning. Use managed embeddings for the shortest path or external vectors for model control.

• Index only useful text

  Choose the specific property that should be recalled by meaning, such as an agent output, document body, or product description.

• Backfill stays attached

  Managed indexes can generate vectors for existing records and keep updated values searchable as records change.

• Model control remains possible

  External indexes let teams supply their own vectors when compliance, local inference, or domain models matter.

Create an index, then search with plain text.

from rushdb import RushDB

db = RushDB('RUSHDB_API_KEY')

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

recall = db.records.vector_search({
    'labels': ['MEMORY'],
    'propertyName': 'output',
    'query': 'What pricing decision affected revenue?',
    'limit': 10,
})

05 · Smart Search

Ask in natural language. Inspect the query that actually ran.

Smart Search uses the project schema to translate a natural-language request into SearchQuery, executes that query, and returns both the records and the generated query. It is a query-generation surface, not a synonym for vector similarity.

• Schema-grounded generation

  RushDB uses the labels, properties, and relationship structure available in the project instead of relying on a generic prompt alone.

• Visible SearchQuery

  The generated SearchQuery is attached to the SDK result so callers can explain which labels and filters produced the records.

• Refinable context

  Pass currentQuery when a user refines an existing dashboard or query-builder state rather than starting from an empty request.

Return the generated query with the records.

from rushdb import RushDB

db = RushDB('RUSHDB_API_KEY')

results = db.ai.search(
    'Show open checkout incidents for enterprise accounts'
)

print(results.search_query)
print(results.warnings)
print(results.total)
print(results.data)

07 · Schema API

Let agents inspect real structure before they query.

RushDB exposes a live snapshot of project structure as compact Markdown or structured JSON. Applications can inject it into agent context or use it to build controlled interfaces.

• Grounded tool calls

  Agents can read the current data shape before they call search, aggregation, or relationship traversal tools.

• Dynamic filters

  Applications can build filter chips, numeric sliders, and date ranges from schema output instead of hardcoding UI options.

• Less prompt maintenance

  As records arrive and the schema evolves, the agent reloads schema instead of relying on stale hand-written schema notes.

Load compact schema context at session start.

from rushdb import RushDB

db = RushDB('RUSHDB_API_KEY')

schema = db.ai.get_schema_markdown({
    'labels': ['ORDER', 'USER', 'PRODUCT'],
})

print(schema.data)

09 · Deployment options

Choose where the graph and the API run.

RushDB supports managed cloud, External Database, and self-hosted deployment models. Choose the operational boundary that matches your application.

• Managed for speed

  Use RushDB Cloud when the priority is getting a project live without operating Neo4j or the RushDB service.

• External Database for data control

  Keep graph data in your own Neo4j or Aura instance while the RushDB API layer remains managed.

• Self-host for full control

  Run the API, metadata database, graph store, and embedding configuration yourself when infrastructure policy requires it.

Start a self-hosted stack with Docker Compose.

import RushDB from '@rushdb/javascript-sdk'

// Same API surface — point the SDK at your self-hosted instance
const db = new RushDB('RUSHDB_API_KEY', {
  url: 'http://your-rushdb-server.com/api/v1',
})