Cypher Query Examples

// Find all agents and their types
MATCH (a:Agent)
RETURN a.id, a.name, labels(a) as types, a.active
ORDER BY a.createdAt DESC
LIMIT 20

// Find members (Person nodes that are also Party and Agent)
MATCH (p:Person:Party:Agent)
WHERE p.active = true
RETURN p.id, p.name, p.email, p.did
ORDER BY p.name

// Find legal entities with their jurisdiction
MATCH (o:Organization:Party)
RETURN o.id, o.name, o.jurisdiction, o.entityType, o.ein
ORDER BY o.name

// Get all personas for a specific member
MATCH (p:Person {email: $email})
OPTIONAL MATCH (p)-[:HAS_PERSONA]->(persona:Persona)
OPTIONAL MATCH (persona)-[:PLAYS]->(role:Role)
OPTIONAL MATCH (persona)-[:IN_CONTEXT]->(ctx:Context)
RETURN
  p.name as member,
  persona.displayName as persona,
  role.name as role,
  ctx.name as context,
  persona.active as active

// Create persona for member in a specific context
MATCH (p:Person {id: $partyId})
MATCH (r:Role {id: $roleId})
MATCH (c:Context {id: $contextId})
CREATE (persona:Persona:PartyRoleContext {
  id: randomUUID(),
  partyId: $partyId,
  roleId: $roleId,
  contextId: $contextId,
  displayName: $displayName,
  active: true,
  createdAt: datetime()
})
CREATE (p)-[:HAS_PERSONA]->(persona)
CREATE (persona)-[:PLAYS]->(r)
CREATE (persona)-[:IN_CONTEXT]->(c)
RETURN persona

// Find which persona is currently active for a user
MATCH (m:Member {privyUserId: $userId})
OPTIONAL MATCH (m)-[:HAS_PERSONA]->(p:Persona {active: true})
OPTIONAL MATCH (p)-[:PLAYS]->(r:Role)
OPTIONAL MATCH (p)-[:IN_CONTEXT]->(c:Context)
RETURN m, collect(DISTINCT p) as personas,
       collect(DISTINCT r) as roles,
       collect(DISTINCT c) as contexts

// Get circle hierarchy with roles
MATCH (c:Circle)
OPTIONAL MATCH (c)-[:CONTAINS_ROLE]->(r:Role)
OPTIONAL MATCH (c)<-[:PARENT_CIRCLE]-(child:Circle)
RETURN c.name as circle,
       collect(DISTINCT r.name) as roles,
       collect(DISTINCT child.name) as subCircles
ORDER BY c.name

// Find all members of a specific circle
MATCH (c:Circle {name: $circleName})
MATCH (p:Persona)-[:MEMBER_OF]->(c)
MATCH (m:Member)-[:HAS_PERSONA]->(p)
RETURN m.id, m.name, p.displayName as persona, p.active

// Find who holds which roles in each circle
MATCH (c:Circle)-[:CONTAINS_ROLE]->(r:Role)
OPTIONAL MATCH (p:Persona)-[:PLAYS]->(r)
OPTIONAL MATCH (m:Member)-[:HAS_PERSONA]->(p)
RETURN c.name as circle,
       r.name as role,
       r.category as category,
       collect(m.name) as assignees

// Find all fixies and their delegations
MATCH (f:SoftwareAgent)
OPTIONAL MATCH (p:Party)-[d:DELEGATES]->(f)
RETURN f.id, f.name, f.agentType as tier,
       p.name as delegator,
       d.scope as delegationScope,
       d.expiresAt as expires

// Get all fixies owned by a member
MATCH (m:Member {id: $memberId})-[:OWNS]->(f:SoftwareAgent)
RETURN f.id, f.name, f.agentType, f.model, f.createdAt
ORDER BY f.createdAt DESC

// Find network-level fixies (not member-owned)
MATCH (f:SoftwareAgent)
WHERE f.ownerType = 'network'
RETURN f.id, f.name, f.agentType, f.purpose

// Get member financial overview
MATCH (m:Member {id: $memberId})
OPTIONAL MATCH (m)-[:HAS_WALLET]->(w:Wallet)
OPTIONAL MATCH (m)-[:HAS_VOUCHER]->(v:Voucher)
RETURN m.name,
       collect(DISTINCT {chain: w.chain, address: w.address}) as wallets,
       collect(DISTINCT {code: v.code, amount: v.amount, redeemed: v.redeemed}) as vouchers

// Find members with Bridge.xyz integration
MATCH (m:Member)-[:HAS_BRIDGE_CUSTOMER]->(bc:BridgeCustomer)
RETURN m.id, m.name,
       bc.bridgeCustomerId,
       bc.kycStatus,
       bc.virtualAccounts

// Get overall network stats
MATCH (n)
WITH labels(n) as nodeLabels, count(*) as count
UNWIND nodeLabels as label
RETURN label, sum(count) as total
ORDER BY total DESC

// Count relationships by type
MATCH ()-[r]->()
RETURN type(r) as relationship, count(*) as count
ORDER BY count DESC

// Find isolated members (not in any circle)
MATCH (m:Member)
WHERE NOT (m)-[:HAS_PERSONA]->(:Persona)-[:MEMBER_OF]->(:Circle)
RETURN m.id, m.name, m.email

// Find recently created personas
MATCH (p:Persona)
WHERE p.createdAt > datetime() - duration('P7D')
MATCH (m:Member)-[:HAS_PERSONA]->(p)
RETURN m.name, p.displayName, p.createdAt
ORDER BY p.createdAt DESC

// Find role assignments with validity periods
MATCH (p:Persona)-[plays:PLAYS]->(r:Role)
WHERE plays.validFrom IS NOT NULL
RETURN p.displayName, r.name,
       plays.validFrom, plays.validTo, plays.active
ORDER BY plays.validFrom DESC

// Use composite index for persona resolution
MATCH (prc:PartyRoleContext)
WHERE prc.partyId = $partyId
  AND prc.roleId = $roleId
  AND prc.contextId = $contextId
RETURN prc

// Batch update persona statuses
UNWIND $personaIds as personaId
MATCH (p:Persona {id: personaId})
SET p.active = false, p.updatedAt = datetime()
RETURN count(p) as updated

// Complete member profile with all relationships
MATCH (m:Member {privyUserId: $userId})
OPTIONAL MATCH (m)-[:HAS_PERSONA]->(persona:Persona)
OPTIONAL MATCH (persona)-[:PLAYS]->(role:Role)
OPTIONAL MATCH (persona)-[:MEMBER_OF]->(circle:Circle)
OPTIONAL MATCH (m)-[:HAS_WALLET]->(wallet:Wallet)
OPTIONAL MATCH (m)-[:OWNS]->(fixie:SoftwareAgent)
RETURN m as member,
       collect(DISTINCT persona) as personas,
       collect(DISTINCT role) as roles,
       collect(DISTINCT circle) as circles,
       collect(DISTINCT wallet) as wallets,
       collect(DISTINCT fixie) as fixies

// Get budget and expense summary for a circle
MATCH (c:Circle {id: $circleId})
OPTIONAL MATCH (c)-[:HAS_BUDGET]->(b:Budget)
OPTIONAL MATCH (c)-[:HAS_EXPENSE]->(e:Expense)
RETURN c.name,
       b.totalAmount as budget,
       sum(e.amount) as totalExpenses,
       b.totalAmount - sum(e.amount) as remaining