RushDB
Push any JSON. Get graph relationships and vector search instantly — no schema, no pipeline, no setup.
Start building free →FAQ
Embeddings rank similarity but ignore joins, cardinality, and constraints. Learn how RushDB combines semantic retrieval with explicit graph relationships and live schema discovery.
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.
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.
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.
RushDB is perfect for modern SaaS applications requiring fast, schema-less data ingestion and querying.
With its graph-powered structure, RushDB simplifies working with interconnected datasets, making it ideal for AI-driven applications.
RushDB efficiently stores and retrieves large-scale IoT data and searchable content with built-in indexing.
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.
from rushdb import RushDB
db = RushDB("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)
query = {
"labels": ["COMPANY"],
"where": {
"name": {"$contains": "Goog"},
"rating": {"$gte": 4}
}
}
records = db.records.find(query)
RushDB takes raw input data and automatically structures it into a connected graph, allowing for seamless navigation across relationships.
/* 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.
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:
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)
# deleteById Relationship
project.detach(employee)
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.
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:
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
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:
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()
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.
query = {
"where": {
"color": "red"
}
}
records = db.records.find(query)
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.
# 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"
}
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.
# 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)
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.
records table view
records graph view
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.
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.
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.