Basket analysis and recommendations from one connected graph.

Product and purchase relationships live outside the operational database.

Which products are frequently bought together, which customers are trending toward higher lifetime value, and which browsing sessions preceded a purchase are all relationship questions. Flat order-line tables answer them only after significant manual joins, usually rebuilt in a batch job or spreadsheet that is already stale by the time a merchandising or recommendation decision needs it.

Graph intelligence on ingest

Incoming data becomes queryable graph context.

An ORDER record with a nested ITEM array referencing PRODUCT records lands connected on write, so a basket query never needs to reassemble order lines after the fact. RushDB infers price, quantity, and category types from the payload, links each ITEM to its ORDER and PRODUCT automatically, and can suggest CO_PURCHASED-style relationships once enough order history accumulates.

Suggested relationship analysis requires an LLM configured for the project. Suggestions stay in draft form until you approve them, so inferred domain meaning never mutates the graph silently. You can also add explicit relationships through the SDK or API.

Data model

One flexible graph for the workflow.

Start with the payload shape your product already produces. RushDB stores it as Records, infers typed properties, and keeps nested or approved domain relationships queryable.

{
  "orderId": "ord-7741",
  "customerId": "cust-330",
  "ITEM": [
    { "productId": "sku-mug-01", "qty": 1 },
    { "productId": "sku-notebook-04", "qty": 2 }
  ]
}

Working example

Find frequently co-purchased products in one query.

Once orders and products are connected, a basket-analysis query traverses purchase relationships directly instead of aggregating a flat order-line export.

ORDER ord-7741
  customerId: "cust-330"
  ITEM: [
    { productId: "sku-mug-01", qty: 1 },
    { productId: "sku-notebook-04", qty: 2 }
  ]

{
  "labels": ["PRODUCT"],
  "where": { "productId": "sku-mug-01" },
  "relatedTo": { "label": "PRODUCT", "via": "CO_PURCHASED" }
}

{
  "product": "sku-mug-01",
  "frequently_bought_with": ["sku-notebook-04", "sku-coaster-02"]
}

TypeScript SDK

Push order data, then query product relationships directly.

This works today over JSON pushed through the SDK. Native source connectors (MongoDB, Postgres, API or CDC pipelines) are on the roadmap — not required to use this pattern now.

from rushdb import RushDB

db = RushDB('RUSHDB_API_KEY')

schema = db.ai.get_schema_markdown({'labels': ['PRODUCT', 'ORDER', 'CUSTOMER']}).data

db.records.import_json(
    label='ORDER',
    data={
        'orderId': 'ord-7741',
        'customerId': 'cust-330',
        'ITEM': [
            {'productId': 'sku-mug-01', 'qty': 1},
            {'productId': 'sku-notebook-04', 'qty': 2},
        ],
    },
)

basket = db.records.find({'labels': ['PRODUCT'], 'where': {'productId': 'sku-mug-01'}})

Implementation blueprint

Build the e-commerce analytics graph.

Use this sequence to connect catalog, order, and customer data for basket analysis and recommendations.

Relevant docs

Read the exact primitives behind this pattern.

These links point to the RushDB docs pages that map directly to this blueprint: ingestion, labels, properties, values, SearchQuery, relationships, semantic search, MCP, or deployment.

How it works

Build the smallest useful workflow first.

Know where it fits.

Questions developers ask.