NoSQL Graph Databases: Neo4j and ArangoDB

// Create users and relationships
CREATE (alice:User {name: 'Alice', age: 30})
CREATE (bob:User {name: 'Bob', age: 28})
CREATE (carol:User {name: 'Carol', age: 32})
CREATE (david:User {name: 'David', age: 29})

CREATE (alice)-[:FOLLOWS]->(bob)
CREATE (alice)-[:FOLLOWS]->(carol)
CREATE (bob)-[:FOLLOWS]->(david)
CREATE (carol)-[:FOLLOWS]->(david)

// Find who Alice should follow (friend-of-friend recommendations)
MATCH (user:User {name: 'Alice'})-[:FOLLOWS]->(friend)-[:FOLLOWS]->(recommendation)
WHERE NOT (user)-[:FOLLOWS]->(recommendation) AND user <> recommendation
RETURN recommendation.name, COUNT(*) AS mutualFriends
ORDER BY mutualFriends DESC

// Find shortest path between users
MATCH path = shortestPath(
  (alice:User {name: 'Alice'})-[:FOLLOWS*]-(david:User {name: 'David'})
)
RETURN path

// Variable-length pattern matching for influencers
MATCH (user:User)-[:FOLLOWS*2..3]->(influencer:User)
WHERE NOT (user)-[:FOLLOWS]->(influencer)
WITH influencer, COUNT(DISTINCT user) AS reach
WHERE reach > 100
RETURN influencer.name, reach
ORDER BY reach DESC
LIMIT 10

// Create collections (ArangoDB shell or HTTP API)
db._create("users");
db._createEdgeCollection("follows");

// Insert users
db.users.save({_key: "alice", name: "Alice", age: 30});
db.users.save({_key: "bob", name: "Bob", age: 28});
db.users.save({_key: "carol", name: "Carol", age: 32});
db.users.save({_key: "david", name: "David", age: 29});

// Create relationships
db.follows.save({_from: "users/alice", _to: "users/bob"});
db.follows.save({_from: "users/alice", _to: "users/carol"});
db.follows.save({_from: "users/bob", _to: "users/david"});
db.follows.save({_from: "users/carol", _to: "users/david"});

// Friend-of-friend recommendations
FOR user IN users
  FILTER user.name == "Alice"
  FOR friend IN 1..1 OUTBOUND user follows
    FOR recommendation IN 1..1 OUTBOUND friend follows
      FILTER recommendation._id != user._id
      COLLECT rec = recommendation WITH COUNT INTO mutualCount
      SORT mutualCount DESC
      RETURN {name: rec.name, mutualFriends: mutualCount}

// Find products bought by friends who like similar items
FOR user IN users
  FILTER user._key == @userId
  FOR friend IN 2..3 OUTBOUND user follows
    FOR purchase IN purchases
      FILTER purchase.userId == friend._key
      FOR product IN products
        FILTER product._key == purchase.productId
        FILTER product.category IN user.interests
        COLLECT p = product WITH COUNT INTO popularity
        SORT popularity DESC
        LIMIT 10
        RETURN p

// Neo4j: Shortest path (optimized native algorithm)
MATCH path = shortestPath(
  (a:Person {id: 1})-[:KNOWS*]-(b:Person {id: 1000})
)
RETURN length(path)
// Typical: 15-30ms for 6-degree separation in 1M node graph

// ArangoDB: Shortest path
FOR path IN OUTBOUND SHORTEST_PATH
  'persons/1' TO 'persons/1000'
  GRAPH 'socialGraph'
  RETURN path
// Typical: 40-80ms for same dataset

// Knowledge graph: Find related concepts through multiple relationship types
MATCH path = (concept:Concept {name: 'Machine Learning'})-[r:RELATED_TO|PART_OF|ENABLES*1..4]-(related:Concept)
WHERE ALL(rel IN relationships(path) WHERE rel.strength > 0.7)
RETURN DISTINCT related.name, 
       [rel IN relationships(path) | type(rel)] AS relationshipPath,
       reduce(score = 1.0, rel IN relationships(path) | score * rel.strength) AS relevanceScore
ORDER BY relevanceScore DESC
LIMIT 20

// E-commerce: Mix product catalog with social recommendations
FOR user IN users
  FILTER user._key == @currentUser
  
  // Get user's purchase history (document query)
  LET purchases = (
    FOR order IN orders
      FILTER order.userId == user._key
      RETURN order.productId
  )
  
  // Find similar users (graph traversal)
  FOR similar IN 2..3 OUTBOUND user follows
    
    // Get their recent purchases not in user's history
    FOR order IN orders
      FILTER order.userId == similar._key
      FILTER order.productId NOT IN purchases
      FILTER order.timestamp > DATE_SUBTRACT(DATE_NOW(), 30, 'days')
      
      // Enrich with product details (document join)
      FOR product IN products
        FILTER product._key == order.productId
        COLLECT p = product WITH COUNT INTO popularity
        SORT popularity DESC
        LIMIT 10
        RETURN p

# Neo4j with official driver
from neo4j import GraphDatabase

driver = GraphDatabase.driver("bolt://localhost:7687", 
                               auth=("neo4j", "password"))

def get_recommendations(user_name):
    with driver.session() as session:
        result = session.run("""
            MATCH (u:User {name: $name})-[:FOLLOWS]->()-[:FOLLOWS]->(rec)
            WHERE NOT (u)-[:FOLLOWS]->(rec)
            RETURN rec.name, COUNT(*) AS score
            ORDER BY score DESC LIMIT 5
        """, name=user_name)
        return [record.data() for record in result]

# ArangoDB with python-arango
from arango import ArangoClient

client = ArangoClient(hosts='http://localhost:8529')
db = client.db('social', username='root', password='password')

def get_recommendations(user_key):
    aql = """
    FOR user IN users FILTER user._key == @key
      FOR friend IN 1..1 OUTBOUND user follows
        FOR rec IN 1..1 OUTBOUND friend follows
          FILTER rec._key != @key
          COLLECT r = rec WITH COUNT INTO score
          SORT score DESC LIMIT 5
          RETURN {name: r.name, score: score}
    """
    return list(db.aql.execute(aql, bind_vars={'key': user_key}))

# docker-compose.yml
version: '3.8'
services:
  neo4j:
    image: neo4j:5.13
    ports:
      - "7474:7474"  # HTTP
      - "7687:7687"  # Bolt
    environment:
      NEO4J_AUTH: neo4j/password
    volumes:
      - neo4j_data:/data

  arangodb:
    image: arangodb:3.11
    ports:
      - "8529:8529"
    environment:
      ARANGO_ROOT_PASSWORD: password
    volumes:
      - arango_data:/var/lib/arangodb3

volumes:
  neo4j_data:
  arango_data: