Real-time recommendations

The strongest recommendation signal is also the oldest: people similar to you, choosing things you haven't seen yet. That's not a trained model — it's a two-hop walk through the behaviour graph, and running it at request time means the suggestion reflects what happened a second ago, not last night.

Collaborative filtering is a two-hop pattern

Walk from a user to the items they engaged with, across to other users who engaged with the same items, out to what those peers chose that the first user hasn't. Aggregate by overlap and rank. It's a pattern match with a `count`, run live — no precompute step recommending yesterday's behaviour.

Blend signals with a WHERE clause, not a pipeline

Purchases, views, wish-lists and category tags are just relationship types. Weighting recency, excluding what's already owned, boosting in-stock items — each is a predicate or an `ORDER BY`, not a feature-store deployment. The recommender stays legible because it's a query you can read.

An experiment graph per surface

Recommendation work wants isolation — an instance per market, storefront or A/B arm. Fast provisioning and per-second billing make a throwaway experiment graph an API call rather than a capacity request, and a quiet one costs storage only.

What co-choosers picked that this user hasn't seen, ranked live.cypher
MATCH (u:User {id: $id})-[:BOUGHT]->(p:Product)
      <-[:BOUGHT]-(peer:User)-[:BOUGHT]->(rec:Product)
WHERE NOT (u)-[:BOUGHT]->(rec)
RETURN rec.name,
       count(DISTINCT peer)             AS peers,
       collect(DISTINCT p.name)[0..3]   AS because
ORDER BY peers DESC
LIMIT 10

Other use cases

Graph memory for AI agents

Give an agent a graph it can traverse instead of a transcript it has to re-read. One instance per agent, per session, or per tenant.

MATCH (a:Agent)-[:REMEMBERS]->(f:Fact)Read more

Knowledge graphs

Model people, documents, systems and the relationships between them, then answer questions that span all of them at once.

MATCH (d:Document)-[:MENTIONS]->(e:Entity)Read more

Multi-tenant graph applications

Give every tenant a real database instead of a tenant_id column. Isolation you can point at, and cost that scales with what each one uses.

CREATE (t:Tenant {id: $tenant})Read more

Dependency & impact analysis

Model what depends on what — services, data, teams — and answer "if this breaks or changes, what's affected?" as a traversal instead of a spreadsheet.

MATCH (s:Service)<-[:DEPENDS_ON*1..]-(affected)Read more

Real-time recommendations

Compute "people like you also chose" live from the behaviour graph at request time — so a purchase a second ago changes the next suggestion.

MATCH (u)-[:BOUGHT]->(p)<-[:BOUGHT]-(peer)Read more

Robotics, hardware & the edge

Model the world a fleet shares — robots, devices, assets, tasks and their dependencies — as one graph the whole fleet can query in real time.

MATCH (r:Robot)-[:CAN_REACH]->(z:Zone)<-[:LOCATED_IN]-(a:Asset)Read more

Start now

~98.7%

token efficiency at 2,000 entities — see the footnotes above

Put your first graph up in a minute.

A free instance takes about a minute and no card. Write two MERGE statements, read them back, and you have a living graph — with provenance on every fact.

Start free View the quickstart

First-graph path

Live

  1. Create a free instance

    No card. Ready in about a minute.

  2. Connect your driver

    bolt+ssc:// URI into the driver you already use.

  3. Write two MERGEs

    That's the entire shape of agent memory.

  4. Point an agent at it

    One MCP config block. No integration code.