
# 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](https://docs.rushdb.com/quick-start/configuring-dashboard).
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](https://www.docker.com/get-started/).
- For Linux, follow [these instructions](https://www.docker.com/get-started/).

2. **Verify Docker installation**
- Run `docker --version` in your terminal to confirm Docker is working.
```bash
$ docker --version
Docker version 27.3.1, build ce12230
```

## Self-Hosted with Neo4j Aura

RushDB stores data in [Neo4j](https://neo4j.com/). 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](https://neo4j.com/product/auradb/) and create a free instance.\
For more details, see [Neo4j Aura docs](https://neo4j.com/docs/aura/classic/platform/create-account/) or this [Medium article](https://medium.com/@_jalakoo_/getting-started-with-neo4j-6bbeece974e3).

2. **Get your Neo4j credentials**
- After creating your Aura instance, note the `username`, and `password`.
![Neo4j Aura Instance username & password](https://rushdb-public.s3.eu-central-1.amazonaws.com/blog/rushdb-selfhosted-quick-setup/neo4j-aura-instance.png)

- 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](https://rushdb-public.s3.eu-central-1.amazonaws.com/blog/rushdb-selfhosted-quick-setup/neo4j-aura-instance-url.png)

3. **Run RushDB in Docker**\
Replace the sample values with your credentials:
    ```bash
    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](https://rushdb-public.s3.eu-central-1.amazonaws.com/blog/rushdb-selfhosted-quick-setup/rushdb-container-added.png)

    You also can run some RushDB CLI commands inside docker container.\
    [Learn more in the docs](https://docs.rushdb.com/quick-start/local-platform-setup#cli-commands)

3. **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](https://docs.rushdb.com/quick-start/local-platform-setup)

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

```sdk
from rushdb import RushDB

db = RushDB(
   "YOUR_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
                     }
                  ]
               }
            ]
         }
      ]
   }
)
___SPLIT___
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):**
```bash
docker network create rushdb-service
```

2. **Start Neo4j:**
```bash
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:**
```bash
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:
```yaml
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:
```bash
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](https://docs.docker.com/compose/install/)

## 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](https://docs.rushdb.com/)
- [Neo4j Aura Free Tier](https://neo4j.com/product/auradb/)
- [Docker Setup and Installation](https://www.docker.com/get-started/)
- [Docker Compose Documentation](https://docs.docker.com/compose/install/)
- [RushDB GitHub Issues](https://github.com/rush-db/rushdb/issues)

Learn how to run RushDB in self-hosted mode using Docker with either Neo4j Aura or a local container.

Self-Hosted RushDB: Quick Setup


# Introducing RushDB: Zero-Config Instant Database for Modern Apps & AI Era

In today's fast-paced development landscape, managing databases shouldn't slow you down. **RushDB** is a **zero-config, graph-powered instant database** designed to streamline data ingestion, normalization, and querying. Built for **modern apps, AI, and DS/ML workflows**, it offers automatic schema handling, ACID compliance, and a seamless developer experience.

Forget rigid schemas and manual indexing - RushDB lets you **push raw JSON or CSV**, automatically structures relationships, and optimizes queries **on the fly**. Whether you're building SaaS, AI models, or large-scale data applications, RushDB accelerates your workflow so you can focus on innovation, not infrastructure.

## Why RushDB?

Traditional databases slow teams down with complex setup, rigid schemas, and manual optimizations. We've seen firsthand how data management creates unnecessary friction, delaying feature development and forcing engineers to wrestle with infrastructure instead of shipping great products.

RushDB removes these barriers entirely by blending the best of both worlds - the freedom of writing data like MongoDB and the structured flattening of SQL. It automates data normalization, optimizes queries on the fly, and eliminates the need for manual indexing or schema design. The result? A frictionless developer experience that lets you focus on building, scaling, and delivering value—without getting stuck in database operations.

### How RushDB Unlocks Developer Productivity

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

## Use Cases
### SaaS & Apps
RushDB is perfect for modern SaaS applications requiring **fast, schema-less data ingestion and querying**.

### AI & ML Research
With its **graph-powered** structure, RushDB simplifies working with interconnected datasets, making it ideal for **AI-driven applications**.

### IoT & Search Engines
RushDB efficiently stores and retrieves **large-scale IoT data** and **searchable content** with built-in indexing.

## Key Features
### 1. Accepts Any JSON, JSONB, and CSV Data
RushDB allows developers to push raw JSON or CSV data without worrying about schema definitions. RushDB **automatically normalizes data** and structures it as a graph, making queries fast and intuitive.

#### Create Record

```sdk
from rushdb import RushDB

db = RushDB("API_TOKEN")

data = {
    "name": "Google LLC",
    "address": "1600 Amphitheatre Parkway, Mountain View, CA 94043, USA",
    "foundedAt": "1998-09-04T00:00:00.000Z",
    "rating": 4.9
}

record = db.records.create("COMPANY", data)
___SPLIT___
const db = new RushDB('API_TOKEN');

const data = {
    name: 'Google LLC',
    address: '1600 Amphitheatre Parkway, Mountain View, CA 94043, USA',
    foundedAt: '1998-09-04T00:00:00.000Z',
    rating: 4.9
}

const record = await db.records.create("COMPANY", data)
```

#### Query Records

```sdk
query = {
    "labels": ["COMPANY"],
    "where": {
        "name": {"$contains": "Goog"},
        "rating": {"$gte": 4}
    }
}

records = db.records.find(query)
___SPLIT___
const records = await db.records.find({
    labels: ['COMPANY'],
    where: {
        name: { $contains: 'Goog' },
        rating: { $gte : 4 }
    }
})
```

[Learn more in the docs](https://docs.rushdb.com/basic-concepts/records#search)

### 2. Automatic Data Normalization and Type Inference
RushDB takes raw input data and **automatically structures it** into a connected graph, allowing for seamless navigation across relationships.

#### Example JSON data

```json
/* ORDER */
{
  "total": 109.98,                           <-- PROPERTY total:`number`
  "status": "processing",                    <-- PROPERTY status:`string`
  "placedAt": "2025-02-15T09:35:26+00:00",   <-- PROPERTY placedAt:`datatime`
  "SHIPPING": {                              <-- RECORD :SHIPPING
    "address": "123 Main St, City, Country", <-- PROPERTY address:`string`
    "method": "express",                     <-- PROPERTY method:`string`
    "cost": 9.99                             <-- PROPERTY cost:`number`
  }
}
```

Above payload will be automatically normalized into separate **flat** Records. And relationship between ORDER and SHIPPING will be created automatically.

[Learn more in the docs](https://docs.rushdb.com/advanced/properties)

### 3. Relationships
RushDB automatically creates relationships between Records based on JSON input, which is normalized into separate flat Records.

However, relationship creation isn't limited to data loading. You can also establish relationships between existing Records, providing a powerful tool to add more meaning to your data.

Managing Relationships:

```sdk
project = db.records.create(
    "PROJECT", {"name": "Secret Project", "budget": 1000000}
)

employee = db.records.create(
    "EMPLOYEE", {"name": "Nikola Tesla"}
)

options = RelationshipOptions(type="HAS_EMPLOYEE")

# create Relationship
project.attach(employee, options)

# delete Relationship
project.detach(employee)
___SPLIT___
const project = await db.records.create('PROJECT', {
    name: 'Secret Project',
    budget: 1000000
})

const employee = await db.records.create('EMPLOYEE', {
    name: 'Nikola Tesla'
})

// create Relationship
await project.attach(employee, { type: 'HAS_EMPLOYEE' })

// delete Relationship
await project.detach(employee)
```

[Learn more in the docs](https://docs.rushdb.com/basic-concepts/properties#how-it-works)

### 4. Query Smarter, Not Harder
Effortlessly find exactly what you need. With automated, on-the-fly data normalization, you can query complex, deeply interconnected data without workarounds or unnecessary overhead - just clear, intuitive access to your data.
#### Examples

```sdk
db.records.find(
    {
        "labels": ["COMPANY"],
        "where": {
            "stage": "seed",
            "address": {"$contains": "USA"},
            "foundedAt": {"$lte": {"$year": 2000}},
            "rating": {
                "$or": [{"$lt": 2.5}, {"$gte": 4.5}]
            },
            "EMPLOYEE": {
                "$relation": {"type": "HIRED", "direction": "out"},
                "$alias": "$employee",
                "salary": {
                    "$gte": 500_000
                }
            },
        },
        "aggregate": {
            "employees": {
                "fn": "collect",
                "alias": "$employee",
                "limit": 10
            }
        },
        "skip": 0,
        "limit": 100
    }
)
___SPLIT___
await db.records.find({
  labels: ['COMPANY'],
  where: {
    stage: 'seed',
    address: { $contains: 'USA' },
    foundedAt: {
      $lte: { $year: 2000 }
    },
    rating: {
      $or: [{ $lt: 2.5 }, { $gte: 4.5 }]
    },
    EMPLOYEE: {
      $relation: { type: 'HIRED', direction: 'out' },
      $alias: '$employee',
      salary: {
        $gte: 500_000
      }
    }
  },
  aggregate: {
    employees: {
      fn: 'collect',
      alias: '$employee',
      limit: 10
    }
  },
  skip: 0,
  limit: 100
})
```

Under the hood, RushDB transforms this into an optimized and powerful Cypher query. The query engine allows developers to think about data naturally, the way we intuitively use and perceive it, while RushDB handles the complexity behind the scenes:

```cypher
MATCH (record:__RUSHDB__LABEL__RECORD__:COMPANY { __RUSHDB__KEY__PROJECT__ID__: $projectId })

WHERE (any(value IN record.stage WHERE value = "seed"))
AND (any(value IN record.address WHERE value =~ "(?i).*USA.*"))
AND (any(value IN record.foundedAt WHERE apoc.convert.fromJsonMap(`record`.`__RUSHDB__KEY__PROPERTIES__META__`).`foundedAt` = "datetime" AND datetime(value) <= datetime({year: 2000})))
AND ((any(value IN record.rating WHERE value < 2.5) OR any(value IN record.rating WHERE value >= 4.5)))

ORDER BY record.`__RUSHDB__KEY__ID__`
DESC SKIP 0 LIMIT 100

OPTIONAL MATCH (record)-[:HIRED]->(record1:EMPLOYEE) WHERE (any(value IN record1.salary WHERE value >= 500000))
WITH record, record1
WHERE record IS NOT NULL AND record1 IS NOT NULL

WITH record,
apoc.coll.sortMaps(collect(DISTINCT record1 {
    .*, __RUSHDB__KEY__LABEL__: [label IN labels(record1) WHERE label <> "__RUSHDB__LABEL__RECORD__"][0]
}), "__RUSHDB__KEY__ID__")[0..10] AS `employees`

RETURN collect(DISTINCT record {
    __RUSHDB__KEY__ID__: record.__RUSHDB__KEY__ID__,
    __RUSHDB__KEY__PROPERTIES__META__: record.__RUSHDB__KEY__PROPERTIES__META__,
    __RUSHDB__KEY__LABEL__: [label IN labels(record) WHERE label <> "__RUSHDB__LABEL__RECORD__"][0],
    `employees`
}) AS records
```

[Learn more in the docs](https://docs.rushdb.com/advanced/querying-data)

### 5. Transactions
RushDB is fully ACID-compliant, providing robust tools to ensure data consistency and reliability. With the Transactions API, you can execute multiple operations confidently - either every request completes successfully, or all changes are rolled back, maintaining data integrity.

Working with transactions in RushDB is seamless:

```sdk
tx = db.transactions.begin()

try:
    # Create some Records
    item = db.records.create(
        "ITEM",
        {"title": "Nike Air Max 270", "price": 150},
        transaction=tx,
    )

    owner = db.records.create(
        "OWNER",
        {"name": "Jane Smith", "email": "janesmith@example.com"},
        transaction=tx
    )

    options = RelationshipOptions(type="OWN", direction="out")

    # create Relationship
    owner.attach(item, options, transaction=tx)

    # Simulate an error
    raise ValueError("Simulated error")

    # Commit the Transaction if all operations succeed
    tx.commit();

except ValueError:
    #  If any records or relationships creation failed, roll back the entire operation
    transaction.rollback()
___SPLIT___
const tx = await db.tx.begin();

try {
  // Create some Records
  const item = await db.records.create('ITEM', {
    title: 'Nike Air Max 270',
    price: 150
  }, tx);

  const owner = await db.records.create('OWNER', {
    name: 'Jane Smith',
    email: 'janesmith@example.com',
  }, tx);

  // create Relationship
  await owner.attach(item, {
    type: 'OWN',
    direction: 'out',
  }, tx);

  // Simulate an error
  throw new Error('Simulated error')

  // Commit the Transaction if all operations succeed
  await tx.commit();
} catch (e) {
  // If any Records or Relationships creation failed, roll back the entire operation
  await tx.rollback();
}
```

[Learn more in the docs](https://docs.rushdb.com/basic-concepts/transactions)

### 6. Properties: Lightweight Connectors That Unify Your Data

Minimal data overhead, maximum impact—RushDB’s **Properties** system enables developers to build best-in-class search experiences while unlocking deeper insights from their data.

Properties act as intelligent containers that links Records, connecting fields with the same name and type across different data entities. For example, if multiple Records - regardless of Label - share a `color` property with the value `red`, RushDB will automatically surface all relevant Records. It’s like querying across multiple SQL tables by a common field and value, but without the complexity.

This makes **Properties** a powerful tool for data discovery, search, and seamless cross-entity relationships.

#### Example

```sdk
query = {
    "where": {
        "color": "red"
    }
}

records = db.records.find(query)
___SPLIT___
const records = await db.records.find({
    where: {
        color: 'red'
    }
})
```

Moreover, with the Properties API, building advanced search experiences is straightforward. Developers can seamlessly query related Records across different entities without complex joins or manual indexing. Whether you're implementing faceted search, dynamic filtering, or personalized recommendations, RushDB ensures your data remains connected and instantly accessible.

```sdk
# Property `name` [string]
db.properties.values(
  "0192397b-8579-7ce2-a899-01c59bad63f8"
)
# Response
{
  "values": [
    "Eleanor Whitaker",
    "Marcus Donovan",
    "Priya Kapoor",
    "Julian Alvarez"
  ],
  "type": "string"
}

# Property \`size\` [number]
db.properties.values(
  "019412c0-2051-71fe-bc9d-26117b52c119"
)
# Response
{
  "min": 5.5,
  "max": 12.5,
  "values": [5.5, 6, 6.5, 7, 7.5, 8, 8.5, ...],
  "type": "number"
}
___SPLIT___
// Property `name` [string]
await db.properties.values(
  '0192397b-8579-7ce2-a899-01c59bad63f8'
)
// Response
{
  values: [
    'Eleanor Whitaker',
    'Marcus Donovan',
    'Priya Kapoor',
    'Julian Alvarez'
  ],
  type: 'string'
}

// Property \`size\` [number]
await db.properties.values(
  '019412c0-2051-71fe-bc9d-26117b52c119'
)
// Response
{
  min: 5.5,
  max: 12.5,
  values: [5.5, 6, 6.5, 7, 7.5, 8, 8.5, ...],
  type: 'number'
}
```

[Learn more in the docs](https://docs.rushdb.com/basic-concepts/properties)

### 7. A Universal API for the Entire Platform

RushDB is built with a **query-centric** design, ensuring that most endpoints follow a consistent request format. This unified approach enhances developer experience by minimizing the learning curve - master one request structure, and you can apply it across the entire platform.

At the core of RushDB are three key entities: **Record, Property, and Label**. All of them can be queried using the same **SearchQuery**, eliminating the need for backend data gymnastics. This means you can focus on building products without worrying about complex data handling - just query once and get exactly what you need, every time.

```sdk
# Same DTO to rule them all
query = {
    "where": {
        "$or": [{"stage": "seed"}, {stage: "roundA"}],
        "EMPLOYEE": {
                "salary": {
                "$gte": 500_000
            }
        }
    }
}

# Find Labels of Records that match the criteria
labels = db.labels.find(query)

# Find Records that match the criteria
records = db.properties.find(query)

# Find Properties of Records that match the criteria
properties = db.labels.find(query)
___SPLIT___
// Same DTO to rule them all
const query = {
  where: {
    $or: [{ stage: 'seed' }, { stage: 'roundA' }],
    EMPLOYEE: {
      salary: {
        $gte: 500_000
      }
    }
  }
}

// Find Labels of Records that match the criteria
const labels = await db.labels.find(query)

// Find Records that match the criteria
const records = await db.records.find(query)

// Find Properties of Records that match the criteria
const properties = await db.properties.find(query)
```

### 8. Powerful Dashboard: Control, Explore, and Query with Ease

RushDB comes with a **feature-rich Dashboard** that gives you full control over your data, projects, and API access—all in an intuitive, developer-friendly UI. Whether you're a developer or a data-driven team, the dashboard makes exploring and managing your data effortless.

#### **Key Features:**

- **Intelligent Data Querying** – A seamless UI that fetches value variations for each filter, enabling precise searches—even for non-developers. Find exactly what you need with sniper precision.
- **Graph View for Natural Exploration** – Visualize relationships the way you think about data, not just how it’s stored. Navigate your graph intuitively, without writing queries.
- **Project-Based Isolation** – Each project is fully self-contained, allowing you to manage multiple independent datasets effortlessly.
- **Instant Data Import** – Upload JSON or JSONB directly from the UI—no coding required. The fastest way to get started and familiarize yourself with RushDB.
- **SearchQuery Preview** – Build queries visually with UI filters and easily reuse the generated configuration in your applications.
- **More Features Coming Soon!** – We're continuously improving the dashboard to make data management even more seamless.

![RushDB Dashboard Graph View](https://rushdb-public.s3.eu-central-1.amazonaws.com/blog/rushdb-the-zero-config-database-for-modern-apps-and-ai-solutions/dashboard-preview-2.png)
> records table view

![RushDB Dashboard Records](https://rushdb-public.s3.eu-central-1.amazonaws.com/blog/rushdb-the-zero-config-database-for-modern-apps-and-ai-solutions/dashboard-preview-1.png)
> records graph view

### 9. Effortless Integration with REST API & SDKs

RushDB offers a **powerful, intuitive REST API** that seamlessly integrates with your applications. The API is designed with **developer productivity** in mind, ensuring smooth interaction with your database using minimal code. Whether you're building a complex enterprise app or a lightweight microservice, the provided SDKs streamline operations, offering straightforward methods for creating, querying, and managing your graph data. The **SDK-level experience** allows developers to effortlessly connect to RushDB via popular programming languages, providing rich documentation and comprehensive examples to minimize friction during integration.

### 10. Flexible Deployment Options: Cloud or Self-Hosted

RushDB is available in both **cloud** and **self-hosted setups**, giving you full control over your infrastructure while ensuring scalability and reliability. With the **cloud** version, you can quickly deploy and scale your database without worrying about maintenance, offering a fully managed, secure environment. Alternatively, the **self-hosted** version allows you to run RushDB on your own hardware, giving you the flexibility to customize configurations, maintain complete data control, and integrate with your existing infrastructure.

## Conclusion

RushDB empowers developers by combining the best of both worlds—**zero-configuration graph databases** with **best-in-class developer experience**. Whether you're working with a cloud or self-hosted setup, RushDB offers unmatched flexibility, scalability, and ease of use, making it the go-to solution for modern applications. With an intuitive REST API and seamless SDK integration, you can focus on building innovative products, leaving the complexities of database management to RushDB.


RushDB is a zero-config, graph-powered instant database with bulk semi-structured data ingestion, automatic normalization, and powerful querying.