Graph Data Science

Traverse ships with a built-in library of 35+ graph algorithms covering centrality, community detection, pathfinding, similarity, link prediction, and node embeddings. Every algorithm is callable from Cypher with a single CALL statement.

How to call an algorithm

CALL traverse.<algorithm>.<mode>(<config>) YIELD ...

Three pieces:

• <algorithm> – the algorithm name (camelCase), e.g. pageRank, dijkstra, louvain.
• <mode> – how the result is delivered (see Modes).
• <config> – a map of options the algorithm understands.

Worked example: PageRank

CALL traverse.pageRank.stream({maxIterations: 20})
YIELD nodeId, score
RETURN nodeId, score
ORDER BY score DESC
LIMIT 10

Returns one row per node with its computed score. The ORDER BY ... LIMIT is a regular Cypher tail; the algorithm just produces the stream.

Modes

Not every algorithm supports every mode. The catalog tables below show which are available per algorithm.

Stream

CALL traverse.pageRank.stream({maxIterations: 20})
YIELD nodeId, score
RETURN nodeId, score LIMIT 10

Stats

CALL traverse.pageRank.stats({maxIterations: 20})
YIELD nodeCount, min, max, mean, computeMillis
RETURN nodeCount, min, max, mean, computeMillis

Write

CALL traverse.pageRank.write({maxIterations: 20, writeProperty: 'pagerank'})
YIELD nodePropertiesWritten
RETURN nodePropertiesWritten

After running the write mode, the score is queryable like any other property:

MATCH (n:User) RETURN n.name, n.pagerank ORDER BY n.pagerank DESC LIMIT 10

Common config

Most algorithms accept this set of generic options in addition to their algorithm-specific config:

Algorithm catalog

Centrality

Score nodes by how "important" they are in the graph.

Community detection

Group nodes into communities based on connectivity.

Paths and traversal

Find shortest paths, multi-hop traversals, and tree structures.

DAG

Algorithms that require a directed acyclic graph.

Similarity

Score how similar two nodes are.

Link prediction

Score node pairs by how likely an edge between them is.

Embeddings

Produce a dense or sparse vector per node, useful as input to ML models or downstream similarity / kNN.

Worked examples

1. Top-10 most central airports

Using the OpenFlights sample (airports + routes):

CALL traverse.pageRank.stream({maxIterations: 30})
YIELD nodeId, score
MATCH (a:Airport) WHERE id(a) = nodeId
RETURN a.iata_code, a.name, score
ORDER BY score DESC LIMIT 10

2. Shortest flight path from JFK to LAX

MATCH (src:Airport {iata_code:'JFK'}), (dst:Airport {iata_code:'LAX'})
CALL traverse.dijkstra.stream({
    sourceNodeId: id(src),
    targetNodeId: id(dst)
})
YIELD nodes, costs
RETURN nodes, costs

3. Detect communities in a social graph and write them back

Using the Pokec sample:

CALL traverse.louvain.write({
    writeProperty: 'community',
    maxIterations: 10
})
YIELD nodeCount, communityCount, largestCommunitySize, computeMillis
RETURN nodeCount, communityCount, largestCommunitySize, computeMillis

Afterwards the result is just a node property:

MATCH (u:User) RETURN u.community, count(*) AS members
ORDER BY members DESC LIMIT 10

4. Generate FastRP embeddings as a node property

CALL traverse.fastRP.write({
    writeProperty: 'embedding',
    embeddingDimension: 128
})
YIELD nodeCount, dimension, nodePropertiesWritten
RETURN nodeCount, dimension, nodePropertiesWritten

Afterwards the vector is just another node property:

MATCH (n) RETURN id(n), n.embedding LIMIT 5

5. Find structurally-similar users via kNN

The structural knn ranks each node's neighbors by Jaccard overlap of their two-hop neighborhoods — useful for "people who follow similar accounts" style recommendations:

CALL traverse.knn.stream({topK: 5, similarityCutoff: 0.1})
YIELD node1, node2, similarity
RETURN node1, node2, similarity
ORDER BY similarity DESC LIMIT 20

6. Embedding-space recommendations via FastRP + knnProperty

Step 1 writes a 128-dim FastRP embedding to each node, step 2 finds the top-5 nearest neighbors in that vector space. This matches the canonical Neo4j GDS feature-similarity pipeline:

// 1. Generate 128-dim embeddings
CALL traverse.fastRP.write({
    writeProperty: 'embedding',
    embeddingDimension: 128
})
YIELD nodeCount, dimension, nodePropertiesWritten
RETURN nodeCount, dimension, nodePropertiesWritten;

// 2. Top-5 similar nodes in embedding space
CALL traverse.knnProperty.stream({
    nodeProperties: ['embedding'],
    topK: 5,
    similarityCutoff: 0.7
})
YIELD node1, node2, similarity
RETURN node1, node2, similarity
ORDER BY similarity DESC LIMIT 20

For tabular features (no embedding step) pass the raw numeric properties instead: nodeProperties: ['age', 'tenure_months', 'avg_session_minutes'].

Stability

Each algorithm carries a stability tag visible in Studio's GDS drawer:

• stable – API and output format are settled; safe to depend on.
• beta – works correctly but the parameter set or output shape may evolve.
• experimental – subject to change without notice.

Studio

The GDS drawer in Studio exposes the same catalog with a form-driven config builder. It writes the same CALL traverse.<algo>.<mode>(...) Cypher you'd write by hand, so anything you do in the drawer is portable to scripts and applications.

See also

• Cypher reference – the language algorithms are invoked from.
• Studio – visual GDS workflow.
• Browser (WASM) – the same algorithms run unchanged in the browser.