---

Schnellstart

curl -fsSL https://raw.githubusercontent.com/rush-db/rushdb/main/install.sh | sh
rushdb up

Das Skript prüft die Prüfsumme des Releases (und seine Sigstore-Signatur, wenn cosign installiert ist) und installiert das rushdb-Binary nach ~/.rushdb/bin. rushdb up startet einen dauerhaften Knoten auf http://127.0.0.1:3000 mit den Daten in ./.rushdb und dem lokalen Token local-token.

Schreib ein verschachteltes JSON-Dokument. Jedes verschachtelte Objekt wird zu einem eigenen Datensatz, der mit seinem Elternteil verknüpft ist:

export RUSHDB_TOKEN=local-token
curl -s http://127.0.0.1:3000/protocol/v1/execute \
  -H "Authorization: Bearer $RUSHDB_TOKEN" -H 'Content-Type: application/json' \
  -d '{"protocolVersion":1,"operation":{"kind":"ingest","ingest":{"kind":"documents","label":"COMPANY",
       "documents":{"name":"Acme","DEPARTMENT":[
         {"name":"Engineering","headcount":12,"EMPLOYEE":[{"name":"Ada","role":"Staff Engineer"},{"name":"Linus","role":"Engineer"}]},
         {"name":"Sales","headcount":4,"EMPLOYEE":[{"name":"Grace","role":"Account Executive"}]}]}}}}'

Dann finde die Engineers bei Acme. Der Filter folgt Beziehungen, indem er die verknüpften Labels nennt:

curl -s http://127.0.0.1:3000/protocol/v1/execute \
  -H "Authorization: Bearer $RUSHDB_TOKEN" -H 'Content-Type: application/json' \
  -d '{"protocolVersion":1,"operation":{"kind":"query","query":{"kind":"records","query":{
       "labels":["EMPLOYEE"],
       "predicate":{"role":{"$contains":"Engineer"},"DEPARTMENT":{"COMPANY":{"name":"Acme"}}}}}}}'

Weiter geht es mit dem Quickstart.

Frag ab, wie du willst

Dieselben Datensätze antworten über jede Schnittstelle.

SQL über das PostgreSQL-Wire-Protokoll, mit psql oder jedem PostgreSQL-Treiber. Labels sind Tabellen:

PGPASSWORD=$RUSHDB_TOKEN psql "host=127.0.0.1 port=5432 user=rushdb dbname=rushdb sslmode=disable" \
  -c "SELECT name, headcount FROM department ORDER BY headcount DESC"

Cypher über HTTP oder über Bolt mit den Neo4j-Treibern (rushdb up --languages sql,cypher --bolt-port 7687):

MATCH (d:DEPARTMENT)-->(e:EMPLOYEE)
RETURN d.name AS department, count(e) AS people ORDER BY people DESC

Die SDKs im Direct Mode (npm install @rushdb/javascript-sdk):

import RushDB from '@rushdb/javascript-sdk'

const db = new RushDB(process.env.RUSHDB_TOKEN, { direct: true, engineUrl: 'http://127.0.0.1:3000' })

const engineers = await db.records.find({
  labels: ['EMPLOYEE'],
  where: { role: { $contains: 'Engineer' }, DEPARTMENT: { COMPANY: { name: 'Acme' } } },
  orderBy: { name: 'asc' }
})
console.log(engineers.data.map((employee) => employee.data.name)) // [ 'Ada', 'Linus' ]

Gremlin, SQL/PGQ GRAPH_TABLE, Mongo-artige Dokumente und ISO GQL nutzen denselben HTTP-Endpunkt. Siehe Abfragesprachen.

Was drin ist

Fähigkeit	Bedeutung
Kein Schema zu entwerfen	Schreib JSON in beliebiger Form. Typen werden pro Wert abgeleitet, verschachtelte Objekte werden zu verknüpften Datensätzen, und die Engine führt einen exakten, abfragbaren Katalog der Labels, Eigenschaften und Beziehungen.
Eigenschaften sind erstklassig	Der Labeled Meta-Property Graph (LMPG) speichert jede Eigenschaft als typisierte Definition, die sich die nutzenden Datensätze teilen. Schema-Erkennung, Wertebereiche und Facetten ergeben sich so aus dem Speicherlayout selbst.
Viele Abfragesprachen	Eine native JSON-Abfragesprache, SQL, Gremlin, SQL/PGQ, Mongo-artige Dokumente sowie openCypher und ISO GQL als Release Candidates.
Suche	Vektorindizes (exakt und HNSW) über die Vektoren, die du lieferst, BM25-Volltextindizes und hybride Suche, die beides kombiniert.
Dauerhaft und transaktional	Write-Ahead-Log, MVCC-Snapshots, Transaktionen über mehrere Anweisungen, Backups mit Point-in-Time-Restore und Streaming-Replikation auf schreibgeschützte Follower.
Standardprotokolle	HTTP, das PostgreSQL-Wire-Protokoll, gRPC und Bolt aus einem Prozess.
Mandantenfähigkeit	Optionale Fail-closed-Mandanten mit je eigenem Keyspace.
Ein Binary	rushdb serve startet den Server, rushdb up einen lokalen Knoten. Kein weiterer Dienst zu betreiben.

Deployment

Wo	Wie
Docker	docker run -p 127.0.0.1:3000:3000 -v rushdb:/data -e RUSHDB_TOKEN=change-me rushdb/rushdb
Docker Compose	deploy/templates/docker-compose, mit einer HTTPS-Variante hinter Caddy
Kubernetes	Helm-Chart: helm install rushdb oci://ghcr.io/rush-db/charts/rushdb --set auth.token=...
Linux-VM	cloud-init für DigitalOcean, Hetzner, AWS, GCP, Azure; systemd-Unit
Plattformen	Fly.io, Render, Coolify, Dokploy

Weitere Installationswege

Methode	Befehl	Hinweise
Installationsskript	curl -fsSL https://raw.githubusercontent.com/rush-db/rushdb/main/install.sh | sh	Linux (glibc 2.28+) und macOS, x86-64 und arm64. sh -s -- --version v3.0.0 legt ein Release fest.
Homebrew	brew install rush-db/tap/rushdb	macOS und Linux. brew services start rushdb startet es im Hintergrund.
Docker	rushdb/rushdb	linux/amd64 und linux/arm64; auch ghcr.io/rush-db/rushdb.
Cargo	cargo binstall rushdb-server oder cargo install rushdb-server --locked	binstall lädt das Release-Binary, install kompiliert (braucht einen C++-Compiler).
Release-Archiv	GitHub releases	Archive mit SHA-256-Prüfsummen, SBOM und Sigstore-Signaturen.
Quellcode	cargo build --release -p rushdb-server --bin rushdb	Siehe Installation.

Windows wird nicht nativ unterstützt; nutze WSL 2 oder Docker. Lies Sicherheit, bevor du einen Knoten über Loopback hinaus erreichbar machst.

Status

Bereich	Status
Natives Protokoll, SQL, Gremlin-Text-Traversals, Mongo-artige Dokumente	Stabil
SQL/PGQ GRAPH_TABLE	Stabil, nur lesend
openCypher, ISO GQL, Bolt	Release Candidate, explizit zu aktivieren: Die externen Konformitätssuiten laufen nicht vollständig durch (Details)
PostgreSQL-Wire	SQL-Lesezugriffe und Schreibvorgänge mit einer Anweisung; geprüft mit psql, node-postgres, psycopg und tokio-postgres, nicht mit jedem Client oder ORM
Replikation	Asynchrones Streaming auf schreibgeschützte Follower; Promotion ist manuell, ohne automatisches Failover
Raft, Storage-Sharding	Vorschau, nicht für Produktion: Raft läuft in einem Prozess mit Zustand im Speicher; Commits über mehrere Shards sind nicht absturzatomar

Das Handbuch dokumentiert die genauen Grenzen jeder Schnittstelle.

Verbinden

Schnittstelle	Standard	Aktivieren
Natives HTTP-Protokoll	127.0.0.1:3000, POST /protocol/v1/execute	immer an
PostgreSQL-Wire	127.0.0.1:5432	an mit sql (Standard)
gRPC (rushdb.v1.Database/Execute)	aus	--grpc-port
Bolt 5.0	aus	--bolt-port mit cypher

Die SDKs für JavaScript und Python, der MCP-Server und die Agent Skills arbeiten im Direct Mode mit einer selbst gehosteten Engine.

Selbst gehostete Engine und RushDB Cloud

Diese Engine ist der Teil von RushDB, den du selbst hostest. Sie erzeugt keine Embeddings, hostet kein Dashboard und verwaltet keine Benutzer: Das kommt mit RushDB Cloud, dem verwalteten Dienst, der diese Engine betreibt und das Dashboard, verwaltete Embeddings und die KI-Funktionen (Suche in natürlicher Sprache, Vorschläge für Beziehungsmuster) ergänzt. Die SDKs und der MCP-Server funktionieren mit beidem: Gib ihnen einen RushDB-Cloud-API-Key oder richte sie direkt auf deine Engine (direct: true, engineUrl). Dann funktioniert alles außer den Cloud-Funktionen, die sie mit CloudOnlyError ablehnen.

Dokumentation

• Handbuch: Einstieg, Datenmodell, Abfragen, Sprachen, Suche, Betrieb und Referenztabellen.
• docs.rushdb.com: Tutorials, die SDKs und der MCP-Server.
• Upgrade von RushDB 2.x: 2.x war der Neo4j-basierte Stack und liegt jetzt auf dem 2.x-Branch dieses Repositorys.

Versionen

• RushDB 3.x (main): die aktuelle Version.
• RushDB 2.x (Legacy): der Neo4j-basierte Stack, auf dem 2.x-Branch und im Image rushdb/platform. Nur noch Sicherheitsfixes bis 2027-10-28.

Mitwirken

Siehe CONTRIBUTING.md. Das Quality Gate:

cargo test --workspace --no-fail-fast --locked
cargo clippy --workspace --all-targets --locked
cargo fmt --all -- --check
scripts/check-quality-bar.sh

• Sicherheitsrichtlinie
• Release-Prozess
• Verhaltenskodex
• Changelog

Lizenziert unter Apache-2.0.