Algorithms overview

Degree centrality

Degree Centrality counts how many outgoing relationships a node has. Nodes with more connections score higher.

Question it answers: "Who has the most direct connections?"

Data model example: In an actor collaboration network, degree centrality reveals which actors have worked with the most co-stars.

You already projected the following graph in the previous module.

MATCH (a1:Actor)-[:ACTED_IN]->(:Movie)<-[:ACTED_IN]-(a2:Actor)
WHERE a1.name < a2.name
WITH gds.graph.project('actor-network', a1, a2, {}, {}) AS g
RETURN g.graphName, g.nodeCount, g.relationshipCount

This projection creates a network where actors connect directly to each other if they appeared in movies together.

Now run degree centrality on this graph:

CALL gds.degree.stream('actor-network')
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name AS actor,
  score AS collaborations
ORDER BY score DESC
LIMIT 10

The actors with the highest scores have collaborated with the most other actors. The question it answers then is not 'How important is X?'; it is 'Who is the most central collaborator?'

Had you interpreted the results as an answer of raw importance, you might have come to some pretty strange conclusions. Reframed in terms of what it is actually answering, however, puts the output in the correct context.

Bruce Willis is certainly not the 'most important' actor in general terms. It is more believable that he would be the 'most important collaborator'.

However, this is only part of the story. Degree centrality counts only the number of connections and does not consider the relative importance of them.

To do that, we need another algorithm you’ve seen before: PageRank.

PageRank

PageRank measures importance by considering both the number of connections and the relative importance of those connections.

A low-degree node connected to many more important nodes may score higher than a high-degree node connected to many nodes of lesser importance.

Think of it this way: There are some actors whose faces you just 'know'. They show up all the time alongside more famous faces. If anyone asked you for their names, you wouldn’t know the answer.

These actors will receive an increased PageRank score because of their consistent connections to those more famous faces.

Question it answers: "Which nodes are central and highly connected to other central nodes?"

Data model example: In the same actor network, PageRank reveals which actors are connected to other influential actors, not just many actors.

Run it now, on the same graph, and compare the results.

CALL gds.pageRank.stream('actor-network')
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name AS actor, score AS influence
ORDER BY score DESC
LIMIT 10

PageRank often reveals different "important" actors than degree centrality because it weights relationship quality.

Betweenness centrality

Betweenness Centrality measures how often a node appears on the shortest paths between other nodes. High scores indicate nodes that connect different parts of the network.

It is often described as measuring the "influence" of a node.

Question it answers: "Who connects different groups?"

Data model example: In our actor network, betweenness reveals actors who bridge different film collaborative communities.

CALL gds.betweenness.stream('actor-network')
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name AS actor, score AS bridging
ORDER BY score DESC
LIMIT 10

Actors with high betweenness often work across multiple genres or connect different acting communities.

Let’s say you’re a producer, and you want a star who will bridge multiple fan communities.

You could use these results.

Louvain

Louvain detects communities by grouping nodes that are more connected to each other than to the rest of the network.

Question it answers: "What natural groups exist in this network?"

Data model example: In an actor network, Louvain might reveal groups of actors who frequently work together, perhaps indicating film franchises or director preferences.

This differs from our centrality algorithm in that we are not defining "importance" from collaborations, but we are literally finding the communities who collaborate.

Run the query below to uncover the communities of actors present in the collaboration graph.

CALL gds.louvain.stream('actor-network')
YIELD nodeId, communityId
RETURN communityId,
  collect(gds.util.asNode(nodeId).name) AS actors,
  count(*) AS size
ORDER BY size DESC
LIMIT 5

Each communityId represents a group of actors who are more connected to each other than to actors in other communities.

You may notice here that Louvain has created rather large communities. This is a known limitation of Louvain. It tends to cluster early, and end up with a few large components.

In the next lesson, you will learn to use Leiden — which was created to fix Louvain’s limitations.

Node similarity

Node Similarity finds nodes that connect to similar neighbors. Two nodes are similar if they share many of the same connections.

Question it answers: "Which nodes have similar connection patterns?"

Data model example: In a user-movie network, node similarity reveals users with similar viewing habits or movies with similar audiences.

First, create a bipartite projection preserving labels:

MATCH (u:User)-[r:RATED]->(m:Movie)
WITH gds.graph.project(
  'user-movie',
  u, m,
  {
    sourceNodeLabels: labels(u),
    targetNodeLabels: labels(m),
    relationshipType: type(r)
  },
  {}
) AS g
RETURN g.graphName, g.nodeCount, g.relationshipCount

Now run node similarity:

CALL gds.nodeSimilarity.write('user-movie', {
  writeRelationshipType: 'SIMILAR',
  writeProperty: 'score'
})
YIELD nodesCompared, relationshipsWritten

This creates SIMILAR relationships between users who rated similar movies.

Verify the results:

MATCH (u1:User)-[s:SIMILAR]->(u2:User)
RETURN u1.name, u2.name, s.score
ORDER BY s.score DESC
LIMIT 10

Users with high similarity scores have very similar movie rating patterns.

There is, however, a caveat to this. The algorithm you just ran does not account for the score that the user gave a movie — only that they both rated the same movie.

It is, for example, possible that "Katie Collins" gave all movies five stars, while "Aaron Nelson" gave all their movies one star.

In lesson 3, you will learn how to configure an algorithm to include properties in its calculations and then re-run this algorithm.

Dijkstra’s Shortest Path

Dijkstra finds the shortest path between two nodes. It’s useful for understanding how different parts of a network connect.

Question it answers: "What’s the shortest path from A to B?"

Data model example: In the actor network you already created, Dijkstra reveals the "degrees of separation" between actors—how they connect through collaborations.

Run the following query to find the shortest path between two actors:

MATCH (source:Actor {name: 'Meg Ryan'})
MATCH (target:Actor {name: 'Kevin Bacon'})
CALL gds.shortestPath.dijkstra.stream('actor-network', {
  sourceNode: source,
  targetNode: target
})
YIELD path
RETURN [node IN nodes(path) | node.name] AS connectionPath,
  length(path) AS degrees

This returns the shortest collaboration chain connecting Meg Ryan to Kevin Bacon, and how many degrees of separation exist between them.

Try a few different combinations.

Other shortest path algorithms include:

FastRP

FastRP (Fast Random Projection) creates node embeddings that capture both local and global network structure.

Question it answers: "How can I represent this network as numbers?"

Data model example: Create embeddings of actors based on their collaboration patterns. These embeddings can then be used for clustering, classification, or similarity searches.

CALL gds.fastRP.mutate('actor-network', {
  embeddingDimension: 64,
  mutateProperty: 'embedding',
  iterationWeights: [0.0, 0.5, 1.0, 1.0],
  nodeSelfInfluence: 0.1
})
YIELD nodePropertiesWritten

Each actor is now represented as a 64-dimensional vector that captures their position in the collaboration network.

You can now find the most similar actor to another — in terms of their collaborations — with a simple similarity function like cosine.

MATCH (a:Actor {name:'Kevin Bacon'})
WITH a
MATCH (b:Actor)
WHERE b.embedding IS NOT NULL
WITH gds.similarity.cosine(a.embedding, b.embedding) AS similarity, a, b
RETURN a.name, b.name, similarity
ORDER BY similarity DESC
LIMIT 10

In the results, you will see which actors FastRP has decided are most structurally similar. They may not even be direct neighbors in the graph — in fact, they don’t even need to be connected.