Use Cases

(Customer) -[HAS_IDENTIFIER]→ (Identifier {type: 'email', value: '...'})
(Customer) -[HAS_IDENTIFIER]→ (Identifier {type: 'phone', value: '...'})
(Customer) -[PLACED]→ (Order) -[CONTAINS]→ (Product)
(Customer) -[OPENED]→ (SupportTicket)
(Customer) -[MERGED_INTO]→ (Customer)

// Resolve all profiles sharing any identifier with a customer
MATCH (c:Customer {id: $customerId})-[:HAS_IDENTIFIER]->(id)
      <-[:HAS_IDENTIFIER]-(other:Customer)
WHERE other.id <> $customerId
RETURN DISTINCT other.id, other.name, id.type, id.value

// Full 360 view: orders, tickets, identifiers
MATCH (c:Customer {id: $customerId})
OPTIONAL MATCH (c)-[:PLACED]->(o:Order)
OPTIONAL MATCH (c)-[:OPENED]->(t:SupportTicket)
OPTIONAL MATCH (c)-[:HAS_IDENTIFIER]->(id)
RETURN c, collect(DISTINCT o) AS orders,
       collect(DISTINCT t) AS tickets,
       collect(DISTINCT id) AS identifiers

(Account) -[USES]→ (Email | Phone | Device)
(Account) -[MADE]→ (Transaction) -[TO]→ (Account)
(Account) -[LOCATED_AT]→ (IPAddress)

// Find accounts sharing identifiers with a flagged account
g.V().has('Account', 'id', flaggedId).as('start')
  .out('USES').in('USES')
  .where(neq('start'))
  .dedup()
  .values('id')

// Transaction chains (money mule detection)
g.V().has('Account', 'id', seedId)
  .repeat(outE('MADE').has('amount', gt(1000)).inV().simplePath())
  .times(4).path()

// Risk score: count shared identifiers with known fraudsters
g.V().has('Account', 'id', accountId)
  .out('USES').in('USES')
  .has('id', within(knownFraudIds))
  .dedup().count()

(Service) -[DEPENDS_ON]→ (Service)
(Service) -[RUNS_ON]→ (Host | Container)
(Service) -[USES]→ (Database | Queue | Cache)
(Service) -[OWNED_BY]→ (Team)
(Host) -[IN]→ (AvailabilityZone) -[IN]→ (Region)

// Blast radius: what depends on this service (recursively)?
MATCH path = (downstream)-[:DEPENDS_ON*1..5]->(s:Service {name: $serviceName})
RETURN DISTINCT downstream.name, length(path) AS depth
ORDER BY depth

// Single point of failure: services with only one dependency path
MATCH (s:Service)
WHERE size([(s)-[:DEPENDS_ON]->(dep) | dep]) = 1
RETURN s.name, [(s)-[:DEPENDS_ON]->(dep) | dep.name] AS singleDependency

// Impact of AZ failure
MATCH (h:Host)-[:IN]->(az:AvailabilityZone {name: $azName})
MATCH (svc:Service)-[:RUNS_ON]->(h)
RETURN svc.name, count(h) AS hostsInAZ

(User) -[MEMBER_OF]→ (Group)
(Group) -[MEMBER_OF]→ (Group)          // nested groups
(Group) -[HAS_ROLE]→ (Role)
(Role) -[GRANTS]→ (Permission)
(Permission) -[ON]→ (Resource)
(User) -[DIRECT_GRANT]→ (Permission)   // exceptions

// All permissions for a user (through group/role inheritance)
MATCH (u:User {id: $userId})-[:MEMBER_OF*1..5]->(g:Group)
      -[:HAS_ROLE]->(r:Role)-[:GRANTS]->(p:Permission)-[:ON]->(res)
RETURN DISTINCT res.name, p.action, r.name AS via_role
UNION
MATCH (u:User {id: $userId})-[:DIRECT_GRANT]->(p:Permission)-[:ON]->(res)
RETURN DISTINCT res.name, p.action, 'direct' AS via_role

// Who can access a specific resource?
MATCH (p:Permission)-[:ON]->(res:Resource {name: $resourceName})
MATCH (p)<-[:GRANTS]-(r:Role)<-[:HAS_ROLE]-(g:Group)<-[:MEMBER_OF*1..5]-(u:User)
RETURN DISTINCT u.name, r.name AS role, g.name AS via_group

// Trace WHY a user has a permission (full path)
MATCH path = (u:User {id: $userId})-[:MEMBER_OF*1..5]->()
             -[:HAS_ROLE]->()-[:GRANTS]->(p:Permission {action: $action})
             -[:ON]->(res:Resource {name: $resource})
RETURN path

(Document) -[HAS_CHUNK]→ (Chunk {text, embedding})
(Chunk) -[MENTIONS]→ (Entity {name, type, embedding})
(Entity) -[RELATED_TO]→ (Entity)
(Chunk) -[NEXT]→ (Chunk)

// Vector search + graph expansion (GraphRAG retrieval)
CALL neptune.algo.vectors.topKByEmbedding($queryEmbedding, {topK: 5})
YIELD node, score
WHERE 'Chunk' IN labels(node)
WITH node AS chunk, score
MATCH (chunk)-[:MENTIONS]->(e:Entity)-[:RELATED_TO]-(related)
RETURN chunk.text, score, collect(DISTINCT e.name) AS entities,
       collect(DISTINCT related.name) AS related_entities

(Supplier) -[SUPPLIES]→ (RawMaterial)
(RawMaterial) -[USED_IN]→ (Component)
(Component) -[ASSEMBLED_INTO]→ (Product)
(Product) -[SHIPPED_IN]→ (Batch {date, destination})
(Batch) -[DELIVERED_TO]→ (Warehouse | Customer)

// Trace a product back to raw material suppliers
MATCH path = (p:Product {sku: $sku})<-[:ASSEMBLED_INTO]-(:Component)
             <-[:USED_IN]-(:RawMaterial)<-[:SUPPLIES]-(s:Supplier)
RETURN s.name, [n IN nodes(path) | n.name] AS chain

// Recall impact: which customers received affected batches?
MATCH (mat:RawMaterial {id: $recalledMaterialId})-[:USED_IN]->(:Component)
      -[:ASSEMBLED_INTO]->(:Product)-[:SHIPPED_IN]->(b:Batch)
      -[:DELIVERED_TO]->(dest)
RETURN dest.name, b.date, count(*) AS affected_products

// Supplier risk: single-source components
MATCH (c:Component)<-[:USED_IN]-(rm:RawMaterial)<-[:SUPPLIES]-(s:Supplier)
WITH c, count(DISTINCT s) AS supplierCount
WHERE supplierCount = 1
RETURN c.name, supplierCount

(Entity {name, type, confidence}) -[RELATED_TO]→ (Entity)
(Conversation {date, summary}) -[ABOUT]→ (Entity)
(Fact {content, confidence}) -[LEARNED_IN]→ (Conversation)

// Recall everything about an entity
MATCH (e:Entity {name: $name})
OPTIONAL MATCH (e)-[r:RELATED_TO]-(related)
OPTIONAL MATCH (conv:Conversation)-[:ABOUT]->(e)
RETURN e, collect(DISTINCT {entity: related.name, rel: r.type}) AS relationships,
       collect(DISTINCT {date: conv.date, summary: conv.summary}) AS conversations

// Semantic recall (vector similarity)
CALL neptune.algo.vectors.topKByEmbedding($queryEmbedding, {topK: 10})
YIELD node, score
RETURN node.name, node.type, node.description, score

// Business ontology layer
(BusinessEntity {name, definition}) -[HAS_ATTRIBUTE]→ (Attribute {name, type, rules})
(BusinessEntity) -[RELATES_TO {cardinality, rule}]→ (BusinessEntity)
(BusinessEntity) -[MAPPED_TO]→ (DataSource {system, table, field})

// Business rules and policies
(Rule {name, condition, action}) -[APPLIES_TO]→ (BusinessEntity)
(Policy {name, type}) -[CONSTRAINS]→ (BusinessEntity | Attribute)
(Policy) -[OWNED_BY]→ (Team)

// Governance and lineage
(Definition) -[APPROVED_BY]→ (Steward)
(Definition) -[VERSION {date, status}]→ (Definition)
(DataSource) -[FEEDS]→ (BusinessEntity)

// Agent reasoning: resolve a business term to its definition and rules
MATCH (e:BusinessEntity {name: $term})
OPTIONAL MATCH (e)-[:HAS_ATTRIBUTE]->(attr)
OPTIONAL MATCH (r:Rule)-[:APPLIES_TO]->(e)
OPTIONAL MATCH (p:Policy)-[:CONSTRAINS]->(e)
RETURN e.name, e.definition,
       collect(DISTINCT {attr: attr.name, type: attr.type}) AS attributes,
       collect(DISTINCT {rule: r.name, condition: r.condition}) AS rules,
       collect(DISTINCT {policy: p.name, type: p.type}) AS policies

// Trace data lineage: where does this business entity's data come from?
MATCH (e:BusinessEntity {name: $entityName})<-[:FEEDS]-(ds:DataSource)
RETURN ds.system, ds.table, ds.field

// Cross-domain entity resolution: find related entities across business domains
// (Neptune openCypher does not support shortestPath(); use a variable-length
//  path and take min(length(path)) to approximate shortest distance.)
MATCH path = (e:BusinessEntity {name: $term})-[:RELATES_TO*1..3]-(related)
WITH related, min(length(path)) AS distance
RETURN DISTINCT related.name, related.definition, distance
ORDER BY distance

// Policy enforcement: check if an agent action is allowed
MATCH (e:BusinessEntity {name: $entityName})
MATCH (p:Policy)-[:CONSTRAINS]->(e)
WHERE p.type = 'compliance'
RETURN p.name, p.condition, p.action AS required_action

// Governed vocabulary: all terms in a business domain
MATCH (e:BusinessEntity)-[:RELATES_TO*0..2]-(root:BusinessEntity {domain: $domain})
RETURN DISTINCT e.name, e.definition
ORDER BY e.name

(User) -[PURCHASED]→ (Product)
(User) -[RATED {score}]→ (Product)
(User) -[VIEWED]→ (Product)
(User) -[FOLLOWS]→ (User)
(Product) -[IN_CATEGORY]→ (Category)
(Product) -[SIMILAR_TO {score}]→ (Product)

// Collaborative filtering: products bought by users who bought the same things I did
MATCH (me:User {id: $userId})-[:PURCHASED]->(p:Product)<-[:PURCHASED]-(other:User)
      -[:PURCHASED]->(rec:Product)
WHERE NOT (me)-[:PURCHASED]->(rec)
RETURN rec.name, count(other) AS score
ORDER BY score DESC
LIMIT 10

// Category-aware recommendations: products in categories I buy from
MATCH (me:User {id: $userId})-[:PURCHASED]->(:Product)-[:IN_CATEGORY]->(cat:Category)
      <-[:IN_CATEGORY]-(rec:Product)
WHERE NOT (me)-[:PURCHASED]->(rec)
RETURN rec.name, cat.name, count(*) AS relevance
ORDER BY relevance DESC
LIMIT 10

// Social recommendations: what my friends bought that I haven't
MATCH (me:User {id: $userId})-[:FOLLOWS]->(friend:User)-[:PURCHASED]->(rec:Product)
WHERE NOT (me)-[:PURCHASED]->(rec)
RETURN rec.name, collect(DISTINCT friend.name) AS recommended_by, count(friend) AS strength
ORDER BY strength DESC
LIMIT 10