rushdb
ProductSolutionsDevelopersPricingResourcesCompanyGitHub
Sign InStart building

Understand

Context layer

Why shared operational context needs its own infrastructure layer.

Product overview

Create, inspect, retrieve, use, and operate connected context.

Architecture

See the data model, query surfaces, and deployment boundaries.

Build

Ingestion and live schema

Turn evolving payloads into typed, inspectable structure.

Graph and relationships

Preserve known links and review suggested patterns.

Semantic retrieval

Combine similarity, exact filters, and connected records.

Smart Search

Generate inspectable SearchQuery from natural language.

Operate

Query and analytics

Use one query shape across records, schema, and metrics.

Deployment options

Use managed cloud, an External Database, or self-hosted infrastructure.

Security

Review privacy, controls, and deployment posture.

Explore the product →

Primary workflows

Agent context and memory

Durable state, decisions, tool output, and semantic recall.

GraphRAG

Retrieve connected evidence, not only similar chunks.

Applications

Build operational software on connected context.

Operational analytics

Analyze current values, relationships, and change.

Solution patterns

Customer intelligence

Connect customer, product, support, and event data.

Search and discovery

Power semantic, faceted, and connected discovery.

Evidence and compliance

Keep operational evidence connected and inspectable.

Blueprints

Agent systemsConnected applicationsAnalytical systemsAll blueprints
Explore all solutions and blueprints →

Documentation

Concepts, tutorials, deployment, and API guides.

Quickstart

Create a project and run your first query.

TypeScript SDK

Type-safe access for browser and Node.js applications.

Python SDK

Sync and async access for services and data workflows.

MCP server

Expose RushDB operations to MCP-compatible clients.

Agent skills

Install task guidance for memory, querying, and modelling.

Open documentation →

Guides

Evergreen explanations and implementation paths.

Comparisons

Evaluate RushDB against graph, vector, and memory tools.

Blog

Product updates and technical articles.

Architecture

Understand the data path and current boundaries.

Changelog

Follow product and platform releases.

LMPG research

Separate the property-centric implementation from research direction.

Explore resources →

Contact

Discuss product, architecture, or enterprise requirements.

Security

Security, privacy, and responsible disclosure.

Open source

Review the source, open issues, and contribute.

Contact RushDB →
rushdb

Open-source context infrastructure for agents, applications, and analytics, with connected records, live schema, semantic retrieval, and operational queries through one API.

GitHubDiscord

Product

Context layerProduct overviewArchitecturePricingSecurityDeployment

Solutions

Agent contextGraphRAGApplicationsOperational analyticsBlueprint library

Developers

DocsQuick startAPI referenceTypeScript SDKPython SDKMCP serverAgent skills

Resources

GuidesComparisonsBlogChangelogOpen sourceContactSelf-hosting

© 2026 Collect Software Inc.

PrivacyTermsCookies
22nd February 20256 min readRushDB Team
databasegraph databaseneo4jNoSQLdeveloper toolsdockerinstant databasedocker-compose

RushDB

Give your agent a memory.

Push any JSON. Get graph relationships and vector search instantly — no schema, no pipeline, no setup.

Start building free →

FAQ

More Posts

vector searchgraph databasehybrid retrieval

Vector Search Doesn't Understand Data Structure

Embeddings rank similarity but ignore joins, cardinality, and constraints. Learn how RushDB combines semantic retrieval with explicit graph relationships and live schema discovery.

21st July 2026—15 min read
data-pipelines
ai-architecture
graph-database

Why Every AI Stack Grows Into Five Data Pipelines

LLM applications naturally fragment into ETL, embedding, graph sync, search indexing, and metadata pipelines. Learn why this happens and how a single ingestion layer can replace.

19th July 2026—20 min read
ai-agentsschema-discoverygraph-database

Stop Teaching Agents Your Schema

Every new agent needs a prompt explaining your tables and fields. RushDB lets agents fetch a structured snapshot of the live graph at runtime.

15th July 2026—24 min read

Self-Hosted RushDB: Quick Setup

Introduction

RushDB is an instant database that lets you work with any data structure without creating a schema first. You can push any data, and RushDB will automatically connect records, detect data types, and provide high-performance search. You can also create or manage relationships manually for more control.

RushDB helps you focus on your application logic without worrying about a complex schema or table design.


Key Features

  • Zero Configuration – Just push any JSON or CSV; RushDB automatically suggests types, normalizes data, and labels relationships - all on the fly.
  • Graph-Powered Storage – Automatically structures relationships between data.
  • ACID Transactions – Ensures consistency and reliability.
  • Powerful Yet Simple Querying – RushDB eliminates the gap between how you perceive data and how you query it, making data retrieval frictionless and natural - so you can focus on shipping products, not syntax.
  • Self-Hosted or Cloud – Deploy anywhere with ease, or choose RushDB Cloud. Start building in under 30 seconds.
  • SDK-like DX Even for REST API – Enjoy a seamless developer experience with an intuitive, structured API that feels like an SDK, minimizing boilerplate and complexity.

Article Overview

This article explains how to get started with RushDB. We will show two main ways to connect:

  • Cloud: The quickest method to start using RushDB. Ideal for trying out small projects or prototypes.
  • Self-Hosted: Gives you more control and is suitable for production environments.

If you want to explore the Cloud option, follow a few steps in the official docs. This guide will focus on the Self-Hosted setup.

Before You Begin

To run RushDB in Self-Hosted mode, we recommend using Docker. Docker helps you avoid manual installations or OS-related issues.

  1. Make sure Docker is installed
  • For Windows or macOS, download Docker Desktop.
  • For Linux, follow these instructions.
  1. Verify Docker installation
  • Run docker --version in your terminal to confirm Docker is working.
$ docker --version
Docker version 27.3.1, build ce12230

Self-Hosted with Neo4j Aura

RushDB stores data in Neo4j. One simple option is Neo4j Aura, the cloud version of Neo4j. It has a free tier for small use.

Steps to set up:

  1. Register an account on Neo4j Aura
    Go to Neo4j Aura and create a free instance.
    For more details, see Neo4j Aura docs or this Medium article.

  2. Get your Neo4j credentials

  • After creating your Aura instance, note the username, and password. Neo4j Aura Instance username & password

  • After you download the credentials, the instance will be mounted, and you can copy instance URI or find it in the downloaded credentials from previous step: Neo4j instance url

  1. Run RushDB in Docker
    Replace the sample values with your credentials:

    docker run -p 3000:3000 \
      --name rushdb \
      -e NEO4J_URL='neo4j+s://1234567.databases.neo4j.io' \
      -e NEO4J_USERNAME='neo4j' \
      -e NEO4J_PASSWORD='password' \
      rushdb/platform
    

    NEO4J_URL, NEO4J_USERNAME, and NEO4J_PASSWORD must match your Aura instance settings.

    After installation, if you're using Docker Desktop, you can see installed container here: RushDB Container

    You also can run some RushDB CLI commands inside docker container.
    Learn more in the docs

  2. Access RushDB

  • RushDB will be available at http://localhost:3000.
  • Go there to open the RushDB Dashboard.
  1. Create a project and get an API token
  • In the Dashboard, make a new user, and a new project.
  • Copy the generated API token for later use.
    Learn more in the docs
  1. Use the token in your code
    Below is an example using Python and JavaScript/TypeScript SDKs.
from rushdb import RushDB

db = RushDB(
   "RUSHDB_API_TOKEN",
   base_url="http://localhost:3000"
)

db.records.create_many(
   "COMPANY",
   {
      "name": "Google LLC",
      "address": "1600 Amphitheatre Parkway, Mountain View, CA 94043, USA",
      "foundedAt": "1998-09-04T00:00:00.000Z",
      "rating": 4.9,
      "DEPARTMENT": [
         {
            "name": "Research & Development",
            "description": "Innovating advanced technologies for AI and cloud computing.",
            "PROJECT": [
               {
                  "name": "Bard AI",
                  "description": "A cutting-edge model for language understanding.",
                  "active": True,
                  "budget": 1200000000,
                  "EMPLOYEE": [
                     {
                        "name": "Jeff Dean",
                        "position": "Head of AI Research",
                        "email": "jeff@google.com",
                        "salary": 3000000
                     }
                  ]
               }
            ]
         }
      ]
   }
)

Local Neo4j Container

If you do not want to use Neo4j Aura, you can launch Neo4j locally:

  1. Create a Docker network (optional, for easy linking):
docker network create rushdb-service
  1. Start Neo4j:
docker run -d --name neo4j \
  --network rushdb-service \
  -p 7474:7474 \
  -p 7687:7687 \
  -e NEO4J_ACCEPT_LICENSE_AGREEMENT=yes \
  -e NEO4J_AUTH=neo4j/password \
  -e NEO4J_PLUGINS='["apoc"]' \
  --health-cmd="wget --no-verbose --tries=1 --spider localhost:7474 || exit 1" \
  --health-interval=5s \
  --health-retries=30 \
  --health-start-period=10s \
  neo4j:5.25.1
  1. Run RushDB:
docker run -d --name rushdb \
  --network rushdb-service \
  -p 3000:3000 \
  -e NEO4J_URL=bolt://neo4j \
  -e NEO4J_USERNAME=neo4j \
  -e NEO4J_PASSWORD=password \
  rushdb/platform
  1. Docker Compose (recommended)\
  • You can use a docker-compose.yml file to run both Neo4j and RushDB together:
version: '3.8'
services:
  rushdb:
    image: rushdb/platform
    container_name: rushdb
    depends_on:
      neo4j:
        condition: service_healthy
    ports:
      - "3000:3000"
    environment:
      - NEO4J_URL=bolt://neo4j
      - NEO4J_USERNAME=neo4j
      - NEO4J_PASSWORD=password
  neo4j:
    image: neo4j:5.25.1
    healthcheck:
      test: [ "CMD-SHELL", "wget --no-verbose --tries=1 --spider localhost:7474 || exit 1" ]
      interval: 5s
      retries: 30
      start_period: 10s
    ports:
      - "7474:7474"
      - "7687:7687"
    environment:
      - NEO4J_ACCEPT_LICENSE_AGREEMENT=yes
      - NEO4J_AUTH=neo4j/password
      - NEO4J_PLUGINS=["apoc"]
  • Then start everything with:
docker-compose up -d
  1. Check RushDB Dashboard:
  • By default, RushDB is on http://localhost:3000.
  • You can create a project, generate a token, and use it the same way as before.

Learn more how to set up Docker Compose

Conclusion

In this article, we learned how to run RushDB Self-Hosted in two ways:

  • With Neo4j Aura (a hosted cloud database with a free tier)
  • With a local Neo4j container (complete control in your environment)

Self-hosting is useful for full-scale projects and production scenarios. You have more flexibility and can customize your environment. For smaller or hobby projects, you can try RushDB Cloud, which is the fastest way to start with RushDB without managing Neo4j yourself.

Useful Links

  • Official RushDB Documentation
  • Neo4j Aura Free Tier
  • Docker Setup and Installation
  • Docker Compose Documentation
  • RushDB GitHub Issues