✨ Core Capabilities

• Zero-Friction Ingest: Push arbitrary nested JSON / CSV; RushDB performs BFS normalization into a labeled meta property graph (LMPG)
• Unified Search DTO: One JSON structure for filtering, traversing, grouping (groupBy), aggregating, vector similarity & introspection (records / labels / properties / values / relationships)
• Property‑Centric Indexing: Properties become first-class nodes ("HyperProperties") enabling dynamic schema discovery & integrity checks
• Vector & Hybrid Search: Embed, store, and query semantic similarity side‑by‑side with structured predicates
• Aggregation & Grouping: aggregate + groupBy for pivot tables, KPIs and multi-key rollups without pre-modeling
• Self‑Describing Graph: Auto-discover labels, properties, value ranges and relationship topology for UI generation & AI agents
• Incremental Complexity: Start with naïve data push; evolve into deep traversals & analytical queries—no migrations
• Polyglot SDKs: TypeScript/JavaScript, Python & REST all share identical semantics

💼 Use Cases

1. AI Memory & Agentic Trails Persist multi-turn conversations, reasoning chains and tool outputs. Property overlap inference auto-connects sessions, enabling retrieval, summarization and context window reconstruction without manual relationship modeling.

2. Small Team → Big Ambition Ship PoCs / MVPs fast: push raw data now, refine model later. Avoid schema migration churn while scaling query sophistication and data volume.

3. Search & Intelligence over Connected Catalogs Product catalogs, knowledge bases (RAG), fraud patterns, biotech entities: traverse, filter, vector match, aggregate & group in one DTO—no separate systems for metadata vs content.

4. Make Flat Data Breathe Turn CSV/JSON dumps into a navigable graph in minutes. BFS import + property linking + lightweight aliasing gives relationship intelligence without hand-curating edges.

5. Fullstack Apps without CRUD Boilerplate "What you see is what you push": nested create mirrors nested query. Auto-discovered labels/properties power dynamic forms, filters and analytics—no ORMs, no bespoke resolver layer.

6. Operational + Analytical Unification Real-time user-facing features and exploratory analytics run on the same query surface—no ETL lag or duplicated modeling.

7. Adaptive Schema Exploration for AI Agents Agents enumerate labels, properties & value distributions programmatically to self-orient and generate safe follow-up queries.

🧪 Architecture: LMPG & HyperProperties

Traditional property graphs bind you to early labeling, manual relationship planning, and separate APIs for schema vs data. RushDB’s Labeled Meta Property Graph (LMPG) model inverts this: properties are elevated to graph nodes (HyperProperties) capturing:

Data Observability

One JSON SearchQuery can retrieve perspectives (records, labels, properties, value ranges, relationships) sharing identical filter semantics. This unified projection removes the “N+1 inspection” pattern and enables:

• Schema drift detection (compare property sets over time)
• Automatic filter UI generation (value domains & type inference)
• Programmatic cataloging for governance & AI agents

Data Integrity

HyperProperties enable soft constraints without rigid upfront schemas:

• Type cohesion scoring & anomaly flagging
• Optional uniqueness & frequency analysis guiding index strategy
• Automatic relationship inference via shared property linkage (reduces orphan edges)
• Consistent vector dimension enforcement at ingestion

Query Semantics & Data Model

Let G = (R, P, E_rp, E_pp) where R are record nodes, P are property (HyperProperty) nodes. Edges encode (record ↔ property assignments) and (property ↔ property co-occurrence). Query evaluation leverages property-level adjacency to: (a) prune traversal (perforating execution), (b) derive emergent schema, (c) compose multi-perspective responses in a single pass.

This yields sub-linear schema introspection relative to naïve per-aspect scans because shared filter evaluation is amortized across all requested perspectives.

Example: Single DTO, Multiple Perspectives

// Pseudocode: obtain records + property stats + grouped aggregations
const result = await db.records.find({
  labels: ['TRANSACTION'],
  where: { status: 'posted', amount: { $gte: 100 } },
  aggregate: { total: { fn: 'sum', field: 'amount', alias: '$record' } },
  groupBy: ['$record.category']
})
// Parallel: db.properties.find({ same filter })

For deeper architectural exposition see the blog article on LMPG.

🚀 Quick Start

1. Get an API Key (Cloud) or Run Locally

RushDB Cloud: create a project at https://app.rushdb.com → copy API key. Self-host (requires Neo4j 5.25.1+ with APOC & GDS):

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

2. Ingest Nested Data

Python

from rushdb import RushDB

db = RushDB("RUSHDB_API_KEY")

# Push any nested JSON - RushDB normalizes it into a graph
db.records.create_many(
   "COMPANY",
   {
      "name": "Google LLC",
      "rating": 4.9,
      "DEPARTMENT": [
         {
            "name": "Research & Development",
            "PROJECT": [
               {
                  "name": "Bard AI",
                  "budget": 1200000000,
                  "EMPLOYEE": [
                     {
                        "name": "Jeff Dean",
                        "position": "Head of AI Research",
                     }
                  ],
               }
            ],
         }
      ],
   },
)

# Traverse relationships with intuitive nested queries
employees = db.records.find({
   "labels": ["EMPLOYEE"],
   "where": {
      "position": {"$contains": "AI"},
      "PROJECT": {"DEPARTMENT": {"COMPANY": {"rating": {"$gte": 4}}}},
   },
})

TypeScript/JavaScript

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

const db = new RushDB("RUSHDB_API_KEY");

// Push data with automatic relationship creation
await db.records.importJson({
   label: "COMPANY",
   payload: {
      name: 'Google LLC',
      rating: 4.9,
      DEPARTMENT: [{
         name: 'Research & Development',
         PROJECT: [{
            name: 'Bard AI',
            EMPLOYEE: [{
               name: 'Jeff Dean',
               position: 'Head of AI Research',
            }]
         }]
      }]
   }
});

// Simple queries that traverse complex relationships
const aiExperts = await db.records.find({
  labels: ['EMPLOYEE'],
  where: {
    position: { $contains: 'AI' },
    PROJECT: { DEPARTMENT: { COMPANY: { rating: { $gte: 4 } } } },
  },
});

💡 Unified Search DTO

One structure for all perspectives & operations:

interface SearchQuery {
  labels?: string[];     // Filter by record labels
  where?: WhereClause;   // Filter by properties and relationships
  limit?: number;        // Maximum records to return
  skip?: number;         // Records to skip (pagination)
  orderBy?: OrderByClause; // Sorting configuration
  aggregate?: AggregateClause; // Data aggregation
}

Benefits:

• Learn once—identical across SDKs & REST
• Automatic schema / property / relationship discovery
• AI & tooling friendliness (introspect before generating follow-up queries)
• Operational + analytical reuse (no ETL / view duplication)

🛠️ Self-Hosting

Requirements

• Neo4j 5.25.1+
• APOC plugin
• Graph Data Science plugin (for vector similarity & advanced aggregates)

Minimal Docker Compose

version: '3.8'
services:
  rushdb:
    image: rushdb/platform
    container_name: rushdb
    ports:
      - "3000:3000"
    environment:
      - NEO4J_URL=neo4j+s://your-instance.neo4j.io
      - NEO4J_USERNAME=neo4j
      - NEO4J_PASSWORD=password
      - RUSHDB_LOGIN=admin
      - RUSHDB_PASSWORD=secure-password

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", "graph-data-science"]

CLI (container exec)

# Create user
rushdb create-user admin@example.com securepassword123
# Update password
rushdb update-password admin@example.com newsecurepassword456

📚 Key Docs

🤝 Contributing

See CONTRIBUTING.md. Issues & PRs welcome.

📄 License

Need something not supported yet? Open an issue—design discussions are welcome.