This section describes the common execution modes for algorithms: `stream`

, `stats`

, `mutate`

and `write`

.

All algorithms are exposed as Neo4j procedures.
They can be called directly from Cypher using Neo4j Browser, `cypher-shell`

, or from your client code using a Neo4j Driver in the language of your choice.

For a detailed guide on the syntax to run algorithms, please see the Syntax overview section.
In short, algorithms are run using one of the execution modes `stream`

, `stats`

, `mutate`

or `write`

, which we cover in this chapter.

The execution of any algorithm can be canceled by terminating the Cypher transaction that is executing the procedure call. For more on how transactions are used, see Transaction Handling.

The `stream`

mode will return the results of the algorithm computation as Cypher result rows.
This is similar to how standard Cypher reading queries operate.

The returned data can be a node ID and a computed value for the node (such as a Page Rank score, or WCC componentId), or two node IDs and a computed value for the node pair (such as a Node Similarity similarity score).

If the graph is very large, the result of a `stream`

mode computation will also be very large.
Using the `ORDER BY`

and `LIMIT`

subclauses in the Cypher query could be useful to support 'top N'-style use cases.

The `stats`

mode returns statistical results for the algorithm computation like counts or percentile distributions.
A statistical summary of the computation is returned as a single Cypher result row.
The direct results of the algorithm are not available when using the `stats`

mode.
This mode forms the basis of the `mutate`

and `write`

execution modes but does not attempt to make any modifications or updates anywhere.

The `mutate`

mode will write the results of the algorithm computation back to the in-memory graph.
Note that the specified `mutateProperty`

value must not exist in the in-memory graph beforehand.
This enables running multiple algorithms on the same in-memory graph without writing results to Neo4j in-between algorithm
executions.

This execution mode is especially useful in three scenarios:

- Algorithms can depend on the results of previous algorithms without the need to write to Neo4j.
- Algorithm results can be written altogether (see write node properties and write relationships).
- Algorithm results can be queried via Cypher without the need to write to Neo4j at all (see
`gds.util.nodeProperty`

).

A statistical summary of the computation is returned similar to the `stats`

mode.
Mutated data can be node properties (such as Page Rank scores), new relationships (such as Node Similarity similarities),
or relationship properties.

The `write`

mode will write the results of the algorithm computation back to the Neo4j database.
This is similar to how standard Cypher writing queries operate.
A statistical summary of the computation is returned similar to the `stats`

mode.
This is the only execution mode that will attempt to make modifications to the Neo4j database.

The written data can be node properties (such as Page Rank scores), new relationships (such as Node Similarity similarities),
or relationship properties.
The `write`

mode can be very useful for use cases where the algorithm results would be inspected multiple times by separate queries since
the computational results are handled entirely by the library.

In order for the results from a `write`

mode computation to be used by another algorithm, a new graph must be created from the Neo4j database with the updated graph.