DATTAX — Graph Algorithm Catalog (Neo4j GDS)

Finding out who is central in a network, which communities exist or the shortest path between two entities used to require writing Cypher procedures and knowing the Graph Data Science library inside out. In DATTAX, each algorithm is a pipeline operator: you project the graph, chain the algorithm with |> and get the result as a table — ready to filter, join and materialize like any other data.

Scope: DATTAX covers the Neo4j GDS open source catalog by default. Enterprise algorithms (Leiden, SLLPA and the gds.leiden.* / gds.sllpa.* variants) require a Neo4j Enterprise license and enablement by the platform administrator — disabled by default.

All listed algorithms run in stream mode, that is, read-only. The WRITE_PROPERTY and MUTATE_PROPERTY options are forbidden — DATTAX never writes to the graph during pipelines, so your original database stays intact.

Results are cached for 1 hour: re-running the same algorithm over the same projection responds in seconds. Invalidation happens automatically when the projection is removed.

Generic syntax

dattax

EVALUATE FROM GRAPH "neo4j-main"
   |> PROJECT GRAPH myGraph NODES "MATCH (n) RETURN id(n) AS id" RELS "MATCH (a)-[r]->(b) RETURN id(a) AS source, id(b) AS target"
   |> <ALGO_NAME> [ON <graphName>] [<OPT>=<val>, ...] ;

When ON <graphName> is omitted, the algorithm uses the last projection registered in the run.

There is also a generic form for any algorithm in the catalog:

dattax

|> GDS <ALGO_NAME> [ON <graphName>] [<OPT>=<val>, ...]

Option aliases (DATTAX → GDS)

DATTAX alias	GDS config key
`ITER` / `MAX_ITERATIONS`	`maxIterations`
`TOLERANCE`	`tolerance`
`DAMPING`	`dampingFactor`
`K`	`k`
`SIMILARITY_CUTOFF`	`similarityCutoff`
`MAX_DEPTH`	`maxDepth`
`RELATIONSHIP_WEIGHT`	`relationshipWeightProperty`
`CONCURRENCY`	`concurrency`
`RANDOM_SEED`	`randomSeed`
`EMBEDDING_DIMENSION`	`embeddingDimension`
`ITERATIONS`	`iterations`
`WALK_LENGTH`	`walkLength`
`WALKS_PER_NODE`	`walksPerNode`
`RETURN_FACTOR`	`returnFactor`
`IN_OUT_FACTOR`	`inOutFactor`
`MODEL_NAME`	`modelName` (GraphSAGE)
`LATITUDE_PROPERTY`	`latitudeProperty` (A*)
`LONGITUDE_PROPERTY`	`longitudeProperty` (A*)
`WRITE_PROPERTY`	FORBIDDEN (read-only)
`MUTATE_PROPERTY`	FORBIDDEN (read-only)

Centrality

PAGERANK

dattax

|> PAGERANK ON myGraph ITER=20, DAMPING=0.85, TOLERANCE=0.0001

Returns nodeId, node, score.

ARTICLE_RANK

PageRank variant that penalizes hubs (academic origin).

dattax

|> ARTICLE_RANK ON myGraph ITER=20

EIGENVECTOR

dattax

|> EIGENVECTOR ON myGraph ITER=100, TOLERANCE=0.0001

BETWEENNESS

Betweenness centrality (expensive on large graphs).

dattax

|> BETWEENNESS ON myGraph CONCURRENCY=4

CLOSENESS

dattax

|> CLOSENESS ON myGraph

HARMONIC

Harmonic closeness — robust on disconnected graphs.

dattax

|> HARMONIC ON myGraph

DEGREE

dattax

|> DEGREE DIRECTION=IN

CELF (Influence Maximization)

dattax

|> CELF ON myGraph K=10

Community

LOUVAIN (via COMMUNITY)

dattax

|> COMMUNITY ALGO=LOUVAIN ON myGraph

LABEL_PROPAGATION (via COMMUNITY)

dattax

|> COMMUNITY ALGO=LABEL_PROPAGATION ON myGraph

WCC (via COMMUNITY)

dattax

|> COMMUNITY ALGO=WCC ON myGraph

SCC (Strongly Connected Components)

dattax

|> SCC ON myGraph

TRIANGLE_COUNT

dattax

|> TRIANGLE_COUNT ON myGraph

LOCAL_CLUSTERING

Local clustering coefficient per node.

dattax

|> LOCAL_CLUSTERING ON myGraph

KCORE

K-core decomposition.

dattax

|> KCORE ON myGraph

KMEANS

Clustering over a vector property (embedding).

dattax

|> KMEANS ON myGraph K=5, ITER=20

MODULARITY (Modularity Optimization)

dattax

|> MODULARITY ON myGraph

Pathfinding

SHORTEST PATH (Dijkstra)

dattax

|> SHORTEST PATH FROM "elem-id-a" TO "elem-id-b" IN myGraph

ASTAR (A* with lat/lon heuristic)

dattax

|> ASTAR FROM "a" TO "b" IN myGraph LATITUDE_PROPERTY=lat, LONGITUDE_PROPERTY=lon

YENS (top-k shortest paths)

dattax

|> YENS FROM "a" TO "b" K 3 IN myGraph

ALLSHORTESTPATHS (Delta-stepping / Dijkstra)

dattax

|> ALL_SHORTEST_PATHS FROM "a" IN myGraph

BFS

dattax

|> BFS FROM "src" IN myGraph MAX_DEPTH=4

DFS

dattax

|> DFS FROM "src" IN myGraph

RANDOM_WALK

dattax

|> RANDOM_WALK ON myGraph WALK_LENGTH=10, WALKS_PER_NODE=5

Similarity

NODE_SIMILARITY

dattax

|> NODE_SIMILARITY ON myGraph SIMILARITY_CUTOFF=0.5

FILTEREDNODESIMILARITY

Filtered variant of NODE_SIMILARITY, available from the same catalog under the name FILTERED_NODE_SIMILARITY.

KNN (graph)

dattax

|> KNN ON myGraph K=10

FILTERED_KNN

dattax

|> FILTERED_KNN ON myGraph K=5

Note: KNN FIELD "..." K N (without ON) is the form used for KNN on Elasticsearch/OpenSearch — it is not a graph algorithm, it is a document vector transform.

Embeddings

FASTRP

dattax

|> FASTRP ON myGraph EMBEDDING_DIMENSION=128, ITERATIONS=4

HASHGNN

dattax

|> HASHGNN ON myGraph ITERATIONS=2, EMBEDDING_DIMENSION=64

NODE2VEC

dattax

|> NODE2VEC ON myGraph WALK_LENGTH=20, WALKS_PER_NODE=10, EMBEDDING_DIMENSION=64

GRAPHSAGE (inference, requires a pre-trained model)

dattax

|> GRAPHSAGE MODEL "myTrainedModel" ON myGraph

Link Prediction (topological features)

All of these features take two node references (by id). The method name is a simple identifier — ADAMIC_ADAR, COMMON_NEIGHBORS, PREFERENTIAL_ATTACHMENT, RESOURCE_ALLOCATION, SAME_COMMUNITY, TOTAL_NEIGHBORS — and it is resolved internally to the LINK_PREDICTION_<METHOD> catalog entry.

dattax

|> LINK_PREDICTION ADAMIC_ADAR BETWEEN "elem-a" AND "elem-b"

Returns score.

Practical example — who are the most influential parties?

Open the editor at DATTA BIDATTAX.
Paste the script below, adjusting the connection name to your graph source registered at SistemaConexões:

dattax

EVALUATE FROM GRAPH "neo4j-main"
  |> PROJECT GRAPH rede NODES "MATCH (p:Parte) RETURN id(p) AS id" RELS "MATCH (a:Parte)-[r:RELACIONADA_A]->(b:Parte) RETURN id(a) AS source, id(b) AS target"
  |> PAGERANK ON rede ITER=20
  |> ORDER BY score DESC
  |> LIMIT 20 ;

Run it. The result arrives as a table with the 20 highest-centrality parties — ready to become a dashboard or be materialized.

Enterprise algorithms

Leiden (gds.leiden.*) and SLLPA — Speaker-Listener Label Propagation (gds.sllpa.*) — are part of the Neo4j GDS Enterprise catalog. Without a Neo4j Enterprise license and the corresponding enablement, the call returns a clear message in Portuguese stating that the algorithm requires the license.

If your instance is licensed, ask the platform administrator to turn on Enterprise support in the DATTAX configuration:

yaml

datta:
  dattax:
    gds:
      enterprise:
        enabled: true

For use outside DATTAX, use the Neo4j driver directly.