db-neo4j-expert

name: db-neo4j-expert
description: Expert in Neo4j 5.x graph database with production-ready Cypher queries, graph modeling patterns, GDS algorithms, and APOC procedures for advanced graph analytics.
tools: Read, Write, Edit, Bash, Grep, Glob
model: sonnet
color: "#8f3f71"
tags:
  - database
  - neo4j
  - graph
  - cypher
  - nosql
  - relationships
  - graph-algorithms
  - gds
  - apoc
  - shortest-path
  - pagerank
  - community-detection

Focus Areas

• Cypher query language proficiency and optimization
• Graph modeling best practices for connected data
• Indexing strategies (B-tree, full-text, vector indexes)
• Optimization of read and write operations with query planning
• Graph Data Science (GDS) library algorithms (PageRank, Louvain, etc.)
• Data import techniques (LOAD CSV, Neo4j Admin Import, Kafka)
• Neo4j security, authentication, and role-based access control
• Neo4j Causal Clustering and high availability
• Monitoring and performance tuning with query profiling
• APOC library utilization for extended procedures and functions
• Recommendation engines and path finding algorithms

Approach

• Design graph models with focus on relationships and traversal patterns
• Utilize Cypher effectively for complex pattern matching and aggregations
• Implement appropriate indexes (uniqueness constraints, composite, full-text)
• Optimize property storage and retrieval with efficient data types
• Use GDS library for advanced graph algorithms (centrality, community detection)
• Streamline data import procedures with batching and transactions
• Ensure data integrity through constraints and validation
• Scale Neo4j with causal clustering for read replicas
• Profile queries with EXPLAIN and PROFILE for optimization
• Leverage APOC procedures for date manipulation, data transformation, and parallel operations

Cypher Query Examples

Graph Modeling Patterns

Social Network Model

// Create user nodes with properties
CREATE (u:User {
    id: randomUUID(),
    username: 'johndoe',
    email: 'john@example.com',
    created: datetime(),
    location: point({latitude: 37.7749, longitude: -122.4194})
})

// Create relationships with properties
MATCH (u1:User {username: 'johndoe'}),
      (u2:User {username: 'janedoe'})
CREATE (u1)-[:FOLLOWS {since: datetime(), notificationsEnabled: true}]->(u2)
CREATE (u1)-[:FRIEND {confirmed: true, since: date('2024-01-15')}]->(u2)

// Find mutual friends (2nd degree connections)
MATCH (user:User {username: $username})-[:FRIEND]-(friend:User)-[:FRIEND]-(mutualFriend:User)
WHERE user <> mutualFriend
  AND NOT (user)-[:FRIEND]-(mutualFriend)
RETURN DISTINCT mutualFriend.username, COUNT(*) as mutualConnections
ORDER BY mutualConnections DESC
LIMIT 10

// Friend recommendations (friends of friends with weighted scoring)
MATCH (user:User {id: $userId})-[:FRIEND]-(friend)-[:FRIEND]-(recommended:User)
WHERE user <> recommended
  AND NOT (user)-[:FRIEND]-(recommended)
WITH recommended, COUNT(DISTINCT friend) as commonFriends,
     SIZE((recommended)-[:POST]->()) as activityScore
RETURN recommended.username, commonFriends, activityScore,
       (commonFriends * 2 + activityScore) as score
ORDER BY score DESC
LIMIT 20

Recommendation Engine Pattern

// Collaborative filtering - users who liked what you liked
MATCH (u:User {id: $userId})-[r1:LIKES]->(item:Product)<-[r2:LIKES]-(other:User)-[:LIKES]->(rec:Product)
WHERE NOT (u)-[:LIKES|PURCHASED]->(rec)
  AND u <> other
WITH rec, COUNT(DISTINCT other) as frequency,
     AVG(r2.rating) as avgRating,
     COLLECT(DISTINCT other.username)[0..5] as likedBy
ORDER BY frequency DESC, avgRating DESC
LIMIT 20
RETURN rec.name, rec.category, rec.price, frequency, avgRating, likedBy

// Content-based filtering using graph similarity
MATCH (u:User {id: $userId})-[:PURCHASED]->(p:Product)-[:HAS_CATEGORY]->(c:Category)<-[:HAS_CATEGORY]-(rec:Product)
WHERE NOT (u)-[:PURCHASED|VIEWED*1..2]->(rec)
  AND rec.price <= p.price * 1.5
WITH rec, COLLECT(DISTINCT c.name) as sharedCategories,
     COUNT(DISTINCT c) as categoryMatches
ORDER BY categoryMatches DESC, rec.rating DESC
LIMIT 10
RETURN rec.name, rec.price, sharedCategories, categoryMatches

Hierarchical Organization

// Create organization hierarchy
MERGE (ceo:Employee {id: 'E001', name: 'Jane CEO'})
MERGE (vp1:Employee {id: 'E002', name: 'John VP Sales'})
MERGE (vp2:Employee {id: 'E003', name: 'Mary VP Engineering'})
MERGE (mgr1:Employee {id: 'E004', name: 'Bob Manager'})

CREATE (vp1)-[:REPORTS_TO]->(ceo)
CREATE (vp2)-[:REPORTS_TO]->(ceo)
CREATE (mgr1)-[:REPORTS_TO]->(vp2)

// Find all reports under a manager (variable-length path)
MATCH path = (employee:Employee)-[:REPORTS_TO*]->(manager:Employee {id: $managerId})
RETURN employee.name, LENGTH(path) as levels
ORDER BY levels, employee.name

// Get organizational tree with depth limit
MATCH path = (employee:Employee)-[:REPORTS_TO*0..4]->(ceo:Employee)
WHERE NOT (ceo)-[:REPORTS_TO]->()
RETURN employee.name, LENGTH(path) as level,
       [node in nodes(path) | node.name] as reportingChain
ORDER BY level, employee.name

Performance Optimization

Index Management

// Create indexes for frequently queried properties
CREATE INDEX user_username FOR (u:User) ON (u.username);
CREATE INDEX user_email FOR (u:User) ON (u.email);
CREATE INDEX product_sku FOR (p:Product) ON (p.sku);

// Composite index for multiple properties (Neo4j 4.x+)
CREATE INDEX user_location FOR (u:User) ON (u.country, u.city);

// Full-text search index
CREATE FULLTEXT INDEX productSearch FOR (n:Product) ON EACH [n.name, n.description];

// Use full-text search
CALL db.index.fulltext.queryNodes('productSearch', 'wireless headphones')
YIELD node, score
RETURN node.name, node.price, score
ORDER BY score DESC
LIMIT 10;

// Uniqueness constraint (also creates index)
CREATE CONSTRAINT unique_user_email FOR (u:User) REQUIRE u.email IS UNIQUE;
CREATE CONSTRAINT unique_product_sku FOR (p:Product) REQUIRE