Neo4j GDS Agent

The Delta-Stepping Shortest Path algorithm computes all shortest paths between a source node and all reachable nodes in the graph. The algorithm supports weighted graphs with positive relationship weights. To compute the shortest path between a source and a single target node, Dijkstra Source-Target can be used. In contrast to Dijkstra Single-Source, the Delta-Stepping algorithm is a distance correcting algorithm. This property allows it to traverse the graph in parallel. The algorithm is guaranteed to always find the shortest path between a source node and a target node. However, if multiple …

The Depth First Search algorithm is a graph traversal that starts at a given node and explores as far as possible along each branch before backtracking, see https://en.wikipedia.org/wiki/Depth-first_search. A related algorithm is the Breadth First Search algorithm, Breadth First Search. This algorithm can be preferred over Breadth First Search for example if one wants to find a target node at a large distance and exploring a random path has decent probability of success. There are multiple termination conditions supported for the traversal, based on either reaching one of several target nodes,…

The Dijkstra Shortest Path algorithm computes the shortest path between nodes. The algorithm supports weighted graphs with positive relationship weights. The Dijkstra Single-Source algorithm computes the shortest paths between a source node and all nodes reachable from that node. To compute the shortest path between a source and a target node, Dijkstra Source-Target can be used.

Drop a projected graph from memory. This frees up memory and removes the graph projection. The graph must be dropped before a new graph with the same name can be created. This does not affect the underlying data in the Neo4j database - only the in-memory projection.

Remove a trained machine learning model from the GDS model catalog to free memory. This does not affect the underlying data in the Neo4j database or any projected graphs.

Calculate eigenvector centrality for all nodes in the graph. Eigenvector Centrality is an algorithm that measures the transitive influence of nodes. Relationships originating from high-scoring nodes contribute more to the score of a node than connections from low-scoring nodes. A high eigenvector score means that a node is connected to many nodes who themselves have high scores. The algorithm computes the eigenvector associated with the largest absolute eigenvalue. To compute that eigenvalue, the algorithm applies the power iteration approach. Within each iteration, the…

Fast Random Projection (FastRP) is a node embedding algorithm that computes a vector representation for every node in the graph. It uses sparse random projections and iterative averaging over node neighborhoods, making it very fast and scalable. Embeddings capture graph topology, and can optionally incorporate node properties via propertyRatio and featureProperties. The resulting embeddings can be used for downstream tasks such as k_nearest_neighbors similarity, clustering, or as features for ML pipeline training. For downstream use within the same projected graph, prefer mode 'mutate' to stor…

Find the shortest path between two nodes using Dijkstra's algorithm

Inspect one projected graph in the GDS graph catalog. Returns graph object metadata including counts, labels, relationship types, projected properties, degree distribution, density, memory usage, configuration, and timestamps. Use this before running mutate/stream algorithms to understand the graph schema and available in-memory properties.

Get all node labels in the database

Get all node properties keys in the database

Get all relationship properties keys in the database

Get relationship types in the database.

Generates node embeddings using a previously trained GraphSAGE model from the model catalog (see graph_sage_train). The graph must contain the feature properties the model was trained on. Use mode 'mutate' to store embeddings as a node property for downstream tools such as k_nearest_neighbors or ML pipeline training; stream mode returns one embedding vector per node.

Trains a GraphSAGE model and stores it in the GDS model catalog under modelName. GraphSAGE is an inductive graph neural network that learns a function to generate node embeddings by sampling and aggregating features from a node's local neighborhood. Unlike FastRP or Node2Vec, a trained GraphSAGE model can be reused to compute embeddings for unseen nodes or other graphs with the same schema (use graph_sage_predict). The graph should be projected with undirected relationships for best results. All featureProperties must exist in the projected graph as numeric properties (use get_graph_info to ch…

Calculate harmonic centrality for all nodes in the graph. Harmonic centrality is a variant of closeness centrality that is more robust to disconnected graphs.

HashGNN is a node embedding algorithm which resembles Graph Neural Networks but does not include a model or require training. It uses hashing functions (min-hash) instead of trained neural network weights, making it orders of magnitude faster than GNNs. Node input features must be binary; provide binary featureProperties, or use binarizeFeatures to binarize numeric properties, or generateFeatures to generate random binary features from topology alone. It supports heterogeneous graphs (set heterogeneous to true) where embeddings distinguish different relationship types. Output embeddings are bi…

Perform HDBSCAN clustering on the graph. HDBSCAN, which stands for Hierarchical Density-Based Spatial Clustering of Applications with Noise, is a clustering algorithm used to identify clusters of similar data points within a dataset. It builds upon the DBSCAN algorithm but adds a hierarchical structure, making it more robust to varying densities within the data. Unlike DBSCAN, HDBSCAN does not require tuning a specific density parameter; instead, it runs DBSCAN over a range of parameters, creating a hierarchy of clusters. This hierarchical approach allows HDBSCAN to find clusters of varying de…

Calculate HITS (Hyperlink-Induced Topic Search) scores for nodes in the graph. The Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes based on two scores, a hub score and an authority score. The authority score estimates the importance of the node within the network. The hub score estimates the value of its relationships to other nodes.

The K-1 Coloring algorithm assigns a color to every node in the graph, trying to optimize for two objectives: 1. To make sure that every neighbor of a given node has a different color than the node itself. 2. To use as few colors as possible. Note that the graph coloring problem is proven to be NP-complete, which makes it intractable on anything but trivial graph sizes. For that reason the implemented algorithm is a greedy algorithm. Thus it is neither guaranteed that the result is an optimal solution, using as few colors as theoretically possible, nor does it always produce a correct result w…

The K-core decomposition constitutes a process of separates the nodes in a graph into groups based on the degree sequence and topology of the graph. The term i-core refers to a maximal subgraph of the original graph such that each node in this subgraph has degree at least i. The maximality ensures that it is not possible to find another subgraph with more nodes where this degree property holds. The nodes in the subgraph denoted by i-core also belong to the subgraph denoted by j-core for any j<i. The converse however is not true. Each node u is associated with a core value which denotes the la…

K-Means clustering is an unsupervised learning algorithm that is used to solve clustering problems. It follows a simple procedure of classifying a given data set into a number of clusters, defined by the parameter k. The Neo4j GDS Library conducts clustering based on node properties, with a float array node property being passed as input via the nodeProperty parameter. Nodes in the graph are then positioned as points in a d-dimensional space (where d is the length of the array property). The algorithm then begins by selecting k initial cluster centroids, which are d-dimensional arrays (see sec…

The K-Nearest Neighbors algorithm computes a distance value for all node pairs in the graph and creates new relationships between each node and its k nearest neighbors. The distance is calculated based on node properties. The input of this algorithm is a homogeneous graph; any node label or relationships type information in the graph is ignored. The graph does not need to be connected, in fact, existing relationships between nodes will be ignored - apart from random walk sampling if that that initial sampling option is used. New relationships are created between each node and its k nearest nei…

The Label Propagation algorithm (LPA) is a fast algorithm for finding communities in a graph. It detects these communities using network structure alone as its guide, and doesn't require a pre-defined objective function or prior information about the communities. LPA works by propagating labels throughout the network and forming communities based on this process of label propagation.

The Leiden algorithm is an algorithm for detecting communities in large networks. The algorithm separates nodes into disjoint communities so as to maximize a modularity score for each community. Modularity quantifies the quality of an assignment of nodes to communities, that is how densely connected nodes in a community are, compared to how connected they would be in a random network. The Leiden algorithm is a hierarchical clustering algorithm, that recursively merges communities into single nodes by greedily optimizing the modularity and the process repeats in the condensed graph. It modifies…

List all projected graphs currently in memory with their metadata. Returns information about each graph including node count, relationship count, memory usage, and schema. In Aura session mode, graphs from all active sessions are listed, each tagged with its sessionName. Use this to see what graphs are available for running algorithms on.

List all machine learning models in the GDS model catalog (GraphSAGE, node classification, link prediction, node regression) with their type, training configuration, and metrics. Models are created by graph_sage_train, train_node_classification_model, train_link_prediction_model, and train_node_regression_model.

List all GDS sessions

The Local Clustering Coefficient algorithm computes the local clustering coefficient for each node in the graph. The local clustering coefficient Cn of a node n describes the likelihood that the neighbours of n are also connected. To compute Cn we use the number of triangles a node is a part of Tn, and the degree of the node dn. The formula to compute the local clustering coefficient is as follows: Cn = 2 * Tn / (dn * (dn - 1))As we can see the triangle count is required to compute the local clustering coefficient. To do this the Triangle Count algorithm is utilised. Additionally, the algorith…

Finding the longest path that leads to a node in a graph is possible to do in linear time for the special case of DAGs, that is graphs which do not contain cycles. The GDS implementation for this problem is based on topological sort and operates in linear time. When the graph is not a DAG, any node that belongs to component containing at least one cycle will be excluded from the results. That is, the implementation will only give results for those components of the graph that form DAGs. You can use topological sort to make sure the graph is a DAG. The algorithm supports weighted and unweighted…

The Louvain method is an algorithm to detect communities in large networks. It maximizes a modularity score for each community, where the modularity quantifies the quality of an assignment of nodes to communities. This means evaluating how much more densely connected the nodes within a community are, compared to how connected they would be in a random network. The Louvain algorithm is a hierarchical clustering algorithm, that recursively merges communities into a single node and executes the modularity clustering on the condensed graphs.

Given source nodes, target nodes and relationships with capacity constraints, the max-flow algorithm assigns a flow to each relationship to achieve maximal transport from source to target. The flow is a scalar property for each relationship and must satisfy 1) Flow into a node equals flow out of a node (preservation). 2) Flow is restricted by the capacity of a relationship

Given a source node and a list of target nodes, a directed spanning tree in which there exists a path from the source node to each of the target nodes is called a Directed Steiner Tree. The Minimum Directed Steiner Tree problem asks for the steiner tree that minimizes the sum of all relationship weights in tree. The Minimum Directed Steiner Tree problem is known to be NP-Complete and no efficient exact algorithms have been proposed in the literature. The Neo4j GDS Library offers an efficient implementation of a well-known heuristic for Steiner Tree related problems. The implemented algorithm w…

The Minimum Weight Spanning Tree (MST) starts from a given node, finds all its reachable nodes and returns the set of relationships that connect these nodes together having the minimum possible weight. Prim's algorithm is one of the simplest and best-known minimum spanning tree algorithms. It operates similarly to Dijkstra's shortest path algorithm, but instead of minimizing the total length of a path ending at each relationship, it minimizes the length of each relationship individually. This allows the algorithm to work on graphs with negative weights. The MST algorithm provides meaningful re…

Modularity is a metric that allows you to evaluate the quality of a community detection. Relationships of nodes in a community C connect to nodes either within C or outside C. Graphs with high modularity have dense connections between the nodes within communities but sparse connections between nodes in different communities.

The Modularity Optimization algorithm tries to detect communities in the graph based on their modularity. Modularity is a measure of the structure of a graph, measuring the density of connections within a module or community. Graphs with a high modularity score will have many connections within a community but only few pointing outwards to other communities. The algorithm will explore for every node if its modularity score might increase if it changes its community to one of its neighboring nodes.

The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. Node Similarity computes pair-wise similarities based on the Jaccard metric, also known as the Jaccard Similarity Score, the Overlap coefficient, also known as the Szymkiewicz–Simpson coefficient, and the Cosine Similarity score. The first two are most frequently associated with unweighted sets, whereas Cosine with weighted input.Filters on source nodes, target nodes, or both can additionally be provided to compute results fo…

Node2Vec is a node embedding algorithm that computes a vector representation of a node based on second-order random walks in the graph. The random walks are controlled by returnFactor and inOutFactor to interpolate between breadth-first (structural roles) and depth-first (community) characteristics. A skip-gram neural network is trained on the walks to produce the embeddings. Embeddings can be used for downstream tasks such as k_nearest_neighbors similarity, clustering, or as features for ML pipeline training. For downstream use within the same projected graph, prefer mode 'mutate' to store em…

Calculate PageRank for all nodes in the graph

Predict new relationships in a projected graph using a trained link prediction model from the model catalog (see train_link_prediction_model). The graph must contain the node properties the model's link features were built from, and the relationships must be undirected. Stream mode returns predicted node pairs with probabilities; mutate mode writes the top predicted relationships to the in-memory graph. By default an exhaustive search over all node pairs is used and topN is required; set sampleRate below 1 for a faster approximate search.

Predict class labels for nodes in a projected graph using a trained node classification model from the model catalog (see train_node_classification_model). The graph must contain the feature properties the model was trained on. Stream mode returns predicted classes (and optionally probabilities) per node; mutate mode writes predictions to the in-memory graph.

Predict numeric values for nodes in a projected graph using a trained node regression model from the model catalog (see train_node_regression_model). The graph must contain the feature properties the model was trained on. Stream mode returns the predicted value per node; mutate mode writes predictions to the in-memory graph.

A spanning tree is a graph such that there is exactly one path between any two nodes in the set. A graph can have many possible spanning tree subsets depending on the set of nodes/relationships selected. Given a weighted graph where each node has a prize, the Prize-Collecting Steiner Tree problem asks for the spanning tree that satisfies the following conditions: 1. the sum of prizes for the nodes in the graph is maximized. 2. the sum of weights of relationships and prizes for nodes not in the tree is minimized. The two constraints can combined to form a single maximization problem by simply s…

Project a graph using a custom Cypher query for use with GDS algorithms. The graph will persist in memory until explicitly dropped with drop_graph. Use this to create a graph projection, then reference it by name when running algorithms. In Aura session mode, sessionName is required and must name a session previously created with create_session. All other tools locate a graph's session automatically from graphName, so multiple graphs in one session need no extra parameters. Only nodes in result rows are projected. MATCH (n)-[r]->(m) drops isolates. For a node set that must include degree-0 …

Random Walk is an algorithm that provides random paths in a graph. A random walk simulates a traversal of the graph in which the traversed relationships are chosen at random. In a classic random walk, each relationship has the same, possibly weighted, probability of being picked. This probability is not influenced by the previously visited nodes. The random walk implementation of the Neo4j Graph Data Science library supports the concept of second order random walks. This method tries to model the transition probability based on the currently visited node v, the node t visited before the curren…

The Speaker-Listener Label Propagation Algorithm (SLLPA) is a variation of the Label Propagation algorithm that is able to detect multiple communities per node. The GDS implementation is based on the SLPA: Uncovering Overlapping Communities in Social Networks via A Speaker-listener Interaction Dynamic Process publication by Xie et al. The algorithm is randomized in nature and will not produce deterministic results. To accommodate this, we recommend using a higher number of iterations.

Stream node properties from a projected GDS graph. Use this after running algorithms in mutate mode to inspect mutated node properties, or to inspect properties included during graph projection. This reads from the in-memory GDS graph, not directly from Neo4j, except for optional dbNodeProperties.

Stream relationship properties from a projected GDS graph. Use this after mutate mode algorithms that write relationship properties, or to inspect relationship properties included during projection.

Stream relationship topology from a projected GDS graph. Returns source node id, target node id, and relationship type rows from the in-memory graph. Use this to inspect projected topology by relationship type.

The Strongly Connected Components (SCC) algorithm finds maximal sets of connected nodes in a directed graph. A set is considered a strongly connected component if there is a directed path between each pair of nodes within the set. It is often used early in a graph analysis process to help us get an idea of how our graph is structured.

Train a link prediction model on a projected graph and store it in the GDS model catalog under modelName. Link prediction predicts missing or future relationships of the targetRelationshipType between node pairs, using link features computed by combining node properties (e.g. embeddings) of both nodes. This tool builds a GDS link prediction pipeline (node property steps, link features, relationship split, model candidates), trains it, and cleans up the temporary pipeline. IMPORTANT: the projected graph must contain UNDIRECTED relationships of the targetRelationshipType; project with undirected…

Train a node classification model on a projected graph and store it in the GDS model catalog under modelName. Node classification predicts a categorical node property (the targetProperty) from feature properties using supervised machine learning. This tool builds a GDS node classification pipeline (node property steps, feature selection, train/test split, model candidates), trains it, evaluates it with the given metrics, and cleans up the temporary pipeline. The targetProperty must be an integer property in the projected graph, and all feature properties must exist in the projection (either pr…

Train a node regression model on a projected graph and store it in the GDS model catalog under modelName. Node regression predicts a continuous numeric node property (the targetProperty) from feature properties using supervised machine learning. This tool builds a GDS node regression pipeline (node property steps, feature selection, train/test split, model candidates), trains it, and cleans up the temporary pipeline. The targetProperty and all feature properties must exist in the projected graph (either projected from the database or produced by nodePropertySteps). Use predict_node_regression …

The Triangle Count algorithm counts the number of triangles for each node in the graph. A triangle is a set of three nodes where each node has a relationship to the other two. In graph theory terminology, this is sometimes referred to as a 3-clique. The Triangle Count algorithm in the GDS library only finds triangles in undirected graphs. Triangle counting has gained popularity in social network analysis, where it is used to detect communities and measure the cohesiveness of those communities. It can also be used to determine the stability of a graph, and is often used as part of the computati…

The Weakly Connected Components (WCC) algorithm finds sets of connected nodes in directed and undirected graphs. Two nodes are connected, if there exists a path between them. The set of all nodes that are connected with each other form a component. In contrast to Strongly Connected Components (SCC), the direction of relationships on the path between two nodes is not considered. For example, in a directed graph (a)→(b), a and b will be in the same component, even if there is no directed relationship (b)→(a). WCC is often used early in an analysis to understand the structure of a graph. Using WC…

Yen's Shortest Path algorithm computes a number of shortest paths between two nodes. The algorithm is often referred to as Yen's k-Shortest Path algorithm, where k is the number of shortest paths to compute. The algorithm supports weighted graphs with positive relationship weights. It also respects parallel relationships between the same two nodes when computing multiple shortest paths. For k = 1, the algorithm behaves exactly like Dijkstra's shortest path algorithm and returns the shortest path. For k = 2, the algorithm returns the shortest path and the second shortest path between the same s…