DATTAX — Catálogo de Algoritmos de Grafo (Neo4j GDS)

Descobrir quem é central numa rede, que comunidades existem ou qual o caminho mais curto entre duas entidades costumava exigir escrever procedures Cypher e conhecer a biblioteca Graph Data Science por dentro. No DATTAX, cada algoritmo é um operador de pipeline: você projeta o grafo, encadeia o algoritmo com |> e recebe o resultado como tabela — pronto para filtrar, juntar e materializar como qualquer outro dado.

Escopo: o DATTAX cobre o catálogo open source do Neo4j GDS por padrão. Algoritmos Enterprise (Leiden, SLLPA e as variantes gds.leiden.* / gds.sllpa.*) exigem licença Neo4j Enterprise e habilitação pelo administrador da plataforma — desabilitados por padrão.

Todos os algoritmos listados executam em modo stream, ou seja, somente leitura. As opções WRITE_PROPERTY e MUTATE_PROPERTY são proibidas — o DATTAX nunca escreve no grafo durante pipelines, então sua base original fica intacta.

Os resultados ficam em cache por 1 hora: repetir o mesmo algoritmo sobre a mesma projeção responde em segundos. A invalidação acontece automaticamente quando a projeção é removida.

Sintaxe genérica

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>, ...] ;

Quando ON <graphName> é omitido, o algoritmo usa a última projeção registrada na execução.

Também há uma forma genérica para qualquer algoritmo do catálogo:

dattax

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

Aliases de opções (DATTAX → GDS)

DATTAX alias	Chave de configuração GDS
`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`	PROIBIDA (read-only)
`MUTATE_PROPERTY`	PROIBIDA (read-only)

Centralidade

PAGERANK

dattax

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

Retorna nodeId, node, score.

ARTICLE_RANK

Variante do PageRank que penaliza hubs (origem acadêmica).

dattax

|> ARTICLE_RANK ON myGraph ITER=20

EIGENVECTOR

dattax

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

BETWEENNESS

Centralidade por intermediação (custo alto em grafos grandes).

dattax

|> BETWEENNESS ON myGraph CONCURRENCY=4

CLOSENESS

dattax

|> CLOSENESS ON myGraph

HARMONIC

Closeness harmônica — robusta em grafos desconectados.

dattax

|> HARMONIC ON myGraph

DEGREE

dattax

|> DEGREE DIRECTION=IN

CELF (Influence Maximization)

dattax

|> CELF ON myGraph K=10

Comunidade

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

Coeficiente de clustering local por nó.

dattax

|> LOCAL_CLUSTERING ON myGraph

KCORE

Decomposição k-core.

dattax

|> KCORE ON myGraph

KMEANS

Clustering sobre a propriedade vetor (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* com heurística lat/lon)

dattax

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

YENS (top-k caminhos mais curtos)

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

Similaridade

NODE_SIMILARITY

dattax

|> NODE_SIMILARITY ON myGraph SIMILARITY_CUTOFF=0.5

FILTEREDNODESIMILARITY

Variante filtrada do NODE_SIMILARITY, disponível pelo mesmo catálogo com o nome FILTERED_NODE_SIMILARITY.

KNN (grafo)

dattax

|> KNN ON myGraph K=10

FILTERED_KNN

dattax

|> FILTERED_KNN ON myGraph K=5

Nota: KNN FIELD "..." K N (sem ON) é a forma usada para KNN em Elasticsearch/OpenSearch — não é algoritmo de grafo, é uma transformação de vetor documental.

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 (inferência, requer modelo pré-treinado)

dattax

|> GRAPHSAGE MODEL "myTrainedModel" ON myGraph

Link Prediction (features topológicas)

Todas essas features recebem duas referências de nós (por id). O nome do método é um identificador simples — ADAMIC_ADAR, COMMON_NEIGHBORS, PREFERENTIAL_ATTACHMENT, RESOURCE_ALLOCATION, SAME_COMMUNITY, TOTAL_NEIGHBORS — e é resolvido internamente para a entrada LINK_PREDICTION_<METHOD> do catálogo.

dattax

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

Retorna score.

Exemplo prático — quem são as partes mais influentes?

Abra o editor em DATTA BIDATTAX.
Cole o script abaixo, ajustando o nome da conexão para a sua base de grafo cadastrada em 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 ;

Execute. O resultado chega como tabela com as 20 partes de maior centralidade — pronto para virar um dashboard ou ser materializado.

Algoritmos Enterprise

Leiden (gds.leiden.*) e SLLPA — Speaker-Listener Label Propagation (gds.sllpa.*) — fazem parte do catálogo Enterprise do Neo4j GDS. Sem licença Neo4j Enterprise e sem a habilitação correspondente, a chamada retorna uma mensagem clara em português indicando que o algoritmo requer a licença.

Se a sua instância tem a licença, peça ao administrador da plataforma para ativar o suporte Enterprise na configuração do DATTAX:

yaml

datta:
  dattax:
    gds:
      enterprise:
        enabled: true

Para uso fora do DATTAX, utilize o driver Neo4j diretamente.