Neo4j: Cypher, APOC and GDS Algorithms Reference Guide

# Docker — single-node Neo4j 5 with APOC + GDS bundled
docker run -d --name neo4j \
    -p 7474:7474 -p 7687:7687 \
    -e NEO4J_AUTH=neo4j/devpassword \
    -e NEO4J_PLUGINS='["apoc","graph-data-science"]' \
    -e NEO4J_dbms_security_procedures_unrestricted='apoc.*,gds.*' \
    neo4j:5

# Neo4j Browser — visual query UI
open http://localhost:7474

# Shell — bundled in the image
docker exec -it neo4j cypher-shell -a bolt://localhost:7687 -u neo4j -p devpassword

# Aura / hosted — connect string includes scheme + auth
cypher-shell -a neo4j+s://xxxxx.databases.neo4j.io -u neo4j -p ****

# Python driver
pip install "neo4j>=5.20"

python - <<'PY'
from neo4j import GraphDatabase
with GraphDatabase.driver("bolt://localhost:7687", auth=("neo4j", "devpassword")) as drv:
    drv.verify_connectivity()
    with drv.session() as s:
        print(s.run("CALL dbms.components() YIELD name, versions").data())
PY

// Variable-length paths + shortest path + property aggregation along the path.

// 1. People reachable in 1–3 hops via FOLLOWS
MATCH path = (me:User {name: 'Ada'})-[:FOLLOWS*1..3]->(other:User)
WHERE other <> me
RETURN other.name AS name, length(path) AS hops
ORDER BY hops, name
LIMIT 25;

// 2. Shortest path (any relationship, ≤ 6 hops) between two users
MATCH (a:User {name: 'Ada'}), (b:User {name: 'Ben'})
MATCH p = shortestPath((a)-[*..6]-(b))
RETURN length(p) AS hops, [n IN nodes(p) | n.name] AS chain;

// 3. Aggregate weights along the path
MATCH p = (a:User {name: 'Ada'})-[r:FOLLOWS*]->(b:User {name: 'Ben'})
WITH p, reduce(s = 0.0, rel IN r | s + rel.weight) AS total
RETURN length(p) AS hops, total ORDER BY total DESC LIMIT 3;

// 4. OPTIONAL MATCH — left-join in graph form
MATCH (u:User {name: 'Ada'})
OPTIONAL MATCH (u)-[:WROTE]->(p:Post)
RETURN u.name, count(p) AS posts;

// Constraints come first — they automatically create the backing index.
CREATE CONSTRAINT user_email_unique IF NOT EXISTS
FOR (u:User) REQUIRE u.email IS UNIQUE;

CREATE CONSTRAINT post_id_unique IF NOT EXISTS
FOR (p:Post) REQUIRE p.id IS UNIQUE;

// Composite NODE KEY (Enterprise) — multi-property unique + NOT NULL.
CREATE CONSTRAINT user_tenant_email IF NOT EXISTS
FOR (u:User) REQUIRE (u.tenant, u.email) IS NODE KEY;

// Range index on a non-unique property — speeds up equality + range queries.
CREATE INDEX user_created IF NOT EXISTS
FOR (u:User) ON (u.created);

// TEXT index — picks the right operator class for CONTAINS / STARTS WITH / ENDS WITH.
CREATE TEXT INDEX user_name IF NOT EXISTS
FOR (u:User) ON (u.name);

// Full-text index across multiple properties on multiple labels.
CREATE FULLTEXT INDEX posts_text IF NOT EXISTS
FOR (n:Post|Comment) ON EACH [n.title, n.body];

// Relationship-property index (5.x).
CREATE INDEX follows_since IF NOT EXISTS
FOR ()-[r:FOLLOWS]-() ON (r.since);

// Block until everything is ONLINE — safe to call from app boot.
CALL db.awaitIndexes();

// Inspect what you've got.
SHOW INDEXES;
SHOW CONSTRAINTS;

from neo4j import GraphDatabase

URI  = "neo4j+s://xxxxx.databases.neo4j.io"
AUTH = ("neo4j", "****")

# One driver per process; sessions are cheap, drivers are not.
driver = GraphDatabase.driver(URI, auth=AUTH)

# Unit-of-work functions get automatic retries on transient errors
# (DEADLOCK_DETECTED, LeaderSwitch, NotALeader, etc.).
def create_follow(tx, follower_id: str, followee_id: str):
    tx.run(
        """
        MATCH (a:User {id: $a}), (b:User {id: $b})
        MERGE (a)-[r:FOLLOWS]->(b)
        ON CREATE SET r.since = datetime()
        """,
        a=follower_id, b=followee_id,
    )

def fanout(tx, user_id: str):
    result = tx.run(
        "MATCH (u:User {id: $id})-[:FOLLOWS]->(f) RETURN f.id AS id, f.name AS name",
        id=user_id,
    )
    return [{"id": r["id"], "name": r["name"]} for r in result]   # consume in-txn

with driver.session(database="neo4j") as s:
    s.execute_write(create_follow, "u1", "u2")
    rows = s.execute_read(fanout, "u1")
    print(rows)

driver.close()

// End-to-end: friend-of-friend recommendations.
// "Show me posts liked by people my friends like — that I haven't liked yet."

// 1. Schema
CREATE CONSTRAINT user_id_unique IF NOT EXISTS
FOR (u:User) REQUIRE u.id IS UNIQUE;
CREATE CONSTRAINT post_id_unique IF NOT EXISTS
FOR (p:Post) REQUIRE p.id IS UNIQUE;

// 2. Seed a tiny graph
UNWIND [
    {id:'u1', name:'Ada'}, {id:'u2', name:'Ben'},
    {id:'u3', name:'Cory'}, {id:'u4', name:'Dru'}
] AS u MERGE (:User {id:u.id}) SET u.name = u.name;

UNWIND [
    {id:'p1', title:'Vector search 101'},
    {id:'p2', title:'TWCS tuning'},
    {id:'p3', title:'Graph algos'}
] AS p MERGE (:Post {id:p.id}) SET p.title = p.title;

MATCH (a:User {id:'u1'}), (b:User {id:'u2'}) MERGE (a)-[:FOLLOWS]->(b);
MATCH (b:User {id:'u2'}), (c:User {id:'u3'}) MERGE (b)-[:FOLLOWS]->(c);
MATCH (u:User), (p:Post)
WHERE (u.id='u2' AND p.id='p2') OR (u.id='u3' AND p.id='p3')
MERGE (u)-[:LIKES]->(p);

// 3. Recommendation query — 2-hop, exclude self-likes
MATCH (me:User {id:'u1'})-[:FOLLOWS*1..2]->(friend:User)-[:LIKES]->(p:Post)
WHERE NOT (me)-[:LIKES]->(p)
RETURN p.id AS id, p.title AS title, count(DISTINCT friend) AS score
ORDER BY score DESC LIMIT 10;