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.

2. 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.

• 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:

3. 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:

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

4. Access RushDB

• RushDB will be available at http://localhost:3000.
• Go there to open the RushDB Dashboard.

4. 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

5. Use the token in your code
   Below is an example using Python and JavaScript/TypeScript SDKs.

typescript

python

import RushDB from '@rushdb/javascript-sdk';

const db = new RushDB("YOUR_API_TOKEN", {
  url: "http://localhost:3000",
});

await db.records.createMany("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

2. 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

3. 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

4. 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

5. 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