Why Neo4j? Graph-Native Memory Architecture

SELECT t.*
FROM transactions t
JOIN customers c ON t.customer_id = c.id
JOIN colleagues col ON c.id = col.customer_id
JOIN investments inv ON col.colleague_id = inv.investor_id
JOIN companies comp ON t.merchant_id = comp.id AND inv.company_id = comp.id
WHERE c.name = 'John Smith';

MATCH (john:Person {name: 'John Smith'})-[:COLLEAGUE_OF]->(colleague)
      -[:INVESTED_IN]->(company)<-[:TRANSACTION_WITH]-(john)
RETURN john, company, colleague

(Customer)-[:PURCHASED]->(Product)
(Product)-[:IN_CATEGORY]->(Category)
(Customer)-[:VIEWED]->(Product)
(Product)-[:FREQUENTLY_BOUGHT_WITH]->(Product)
(Customer)-[:HAS_PREFERENCE]->(Brand)

// Find accounts connected through suspicious transaction patterns
MATCH path = (account:Account)-[:TRANSFERRED_TO*2..5]-(other:Account)
WHERE account.flagged = true
  AND all(r IN relationships(path) WHERE r.amount > 10000)
RETURN path

// Find semantically similar products that the customer's network also purchased
MATCH (customer:Customer {id: $customerId})-[:KNOWS]->(friend)
      -[:PURCHASED]->(product:Product)
WITH collect(DISTINCT product) as friendProducts
CALL db.index.vector.queryNodes('product_embeddings', 10, $queryEmbedding)
YIELD node as similarProduct, score
WHERE similarProduct IN friendProducts
RETURN similarProduct, score
ORDER BY score DESC

// Find customer behavior patterns before large purchases
MATCH (customer:Customer)-[v:VIEWED]->(product:Product)
      -[:IN_CATEGORY]->(cat:Category {name: 'Luxury'})
WHERE v.timestamp > datetime() - duration('P30D')
WITH customer, count(v) as viewCount
MATCH (customer)-[p:PURCHASED]->(item)
WHERE p.amount > 1000
  AND p.timestamp > datetime() - duration('P7D')
RETURN customer, viewCount, sum(p.amount) as totalSpent

// Existing: Customers and Products
// New requirement: Track loyalty program membership

// Simply create new nodes and relationships
CREATE (customer)-[:MEMBER_OF {since: date(), tier: 'Gold'}]->(program:LoyaltyProgram {name: 'Rewards+'})

// Client and account structure
(Client:Person)-[:HAS_ACCOUNT]->(Account)
(Account)-[:HOLDS]->(Position)-[:IN]->(Security)
(Client)-[:ADVISED_BY]->(Advisor:Person)

// Transaction history
(Account)-[:EXECUTED]->(Transaction)-[:INVOLVED]->(Security)
(Transaction)-[:ON_DATE]->(Date)

// Relationships and preferences
(Client)-[:RELATED_TO {type: 'spouse'}]->(Client)
(Client)-[:HAS_PREFERENCE]->(Preference)
(Client)-[:MENTIONED_IN]->(Message)-[:IN_SESSION]->(Conversation)

// Compliance and risk
(Transaction)-[:FLAGGED_BY]->(ComplianceRule)
(Client)-[:HAS_RISK_PROFILE]->(RiskProfile)

// Get complete household financial picture
MATCH (client:Client {id: $clientId})-[:RELATED_TO*0..2]-(family:Client)
      -[:HAS_ACCOUNT]->(account)-[:HOLDS]->(position)
RETURN family.name, account.type, sum(position.value) as totalValue
ORDER BY totalValue DESC

// Find securities matching client preferences mentioned in conversations
MATCH (client:Client {id: $clientId})-[:HAS_PREFERENCE]->(pref)
WHERE pref.category = 'investment_style'
WITH client, collect(pref.value) as preferences

MATCH (security:Security)
WHERE any(p IN preferences WHERE security.style CONTAINS p)
  AND NOT exists((client)-[:HAS_ACCOUNT]->()-[:HOLDS]->()-[:IN]->(security))

CALL db.index.vector.queryNodes('security_embeddings', 20, $queryEmbedding)
YIELD node, score
WHERE node = security
RETURN security, score

// Customer journey
(Customer)-[:VIEWED {timestamp, duration}]->(Product)
(Customer)-[:ADDED_TO_CART {timestamp}]->(Product)
(Customer)-[:PURCHASED {timestamp, price}]->(Product)
(Customer)-[:RETURNED {reason}]->(Product)

// Product catalog
(Product)-[:IN_CATEGORY]->(Category)-[:CHILD_OF]->(Category)
(Product)-[:HAS_ATTRIBUTE]->(Attribute)
(Product)-[:SOLD_BY]->(Seller)
(Product)-[:FREQUENTLY_BOUGHT_WITH]->(Product)

// Customer knowledge
(Customer)-[:HAS_PREFERENCE]->(Preference)
(Customer)-[:MENTIONED_IN]->(Message)
(Customer)-[:IN_SEGMENT]->(CustomerSegment)

// Inventory and fulfillment
(Product)-[:AVAILABLE_AT]->(Warehouse)-[:LOCATED_IN]->(Region)
(Order)-[:SHIPS_TO]->(Address)-[:IN]->(Region)

// Find products based on behavior patterns and stated preferences
MATCH (customer:Customer {id: $customerId})

// Get viewing patterns
OPTIONAL MATCH (customer)-[v:VIEWED]->(viewed:Product)
WHERE v.timestamp > datetime() - duration('P30D')
WITH customer, collect(viewed) as recentlyViewed

// Get stated preferences from conversations
OPTIONAL MATCH (customer)-[:HAS_PREFERENCE]->(pref)
WHERE pref.category IN ['brand', 'style', 'price_range']
WITH customer, recentlyViewed, collect(pref) as preferences

// Find similar products not yet viewed
UNWIND recentlyViewed as viewed
MATCH (viewed)-[:FREQUENTLY_BOUGHT_WITH]->(recommended:Product)
WHERE NOT recommended IN recentlyViewed
RETURN DISTINCT recommended, count(*) as relevanceScore
ORDER BY relevanceScore DESC
LIMIT 10

// Recommend products available for fast shipping to customer location
MATCH (customer:Customer {id: $customerId})-[:SHIPS_TO]->(addr:Address)
      -[:IN]->(region:Region)
MATCH (product:Product)-[:AVAILABLE_AT]->(warehouse)-[:LOCATED_IN]->(region)
WHERE product.category = $category
  AND warehouse.stock > 0

// Boost products matching preferences
OPTIONAL MATCH (customer)-[:HAS_PREFERENCE]->(pref)
WHERE product.brand = pref.value OR product.style = pref.value
WITH product, warehouse, count(pref) as prefMatch
RETURN product, warehouse.estimated_delivery, prefMatch
ORDER BY prefMatch DESC, warehouse.estimated_delivery ASC