# Query modules

The Cypher query language can be extended with custom procedures written in
**Python**, **C**, **C++** and **Rust**. These procedures are grouped into so
called query modules. Memgraph offers an open-source collection of implemented
query modules in the form of **MAGE** - **Memgraph Advanced Graph
Extensions**.

##### MAGE Documentation

Check out the **MAGE documentation** for a detailed overview of all the
available modules and installation instructions.

## Available query modules

Algorithms | Lang | Description |
---|---|---|

betweenness_centrality | C++ | The betweenness centrality of a node is defined as the sum of the of all-pairs shortest paths that run through the node, divided by the number of all-pairs shortest paths in the graph. The algorithm has O(nm) time complexity. |

betweenness_centrality_online | C++ | A dynamic algorithm that updates exact betweenness centrality scores of nodes in evolving graphs. Suitable for graph streaming applications. |

biconnected_components | C++ | Algorithm for calculating maximal biconnected subgraph. A biconnected subgraph is a subgraph with a property that if any vertex were to be removed, the graph will remain connected. |

bipartite_matching | C++ | Algorithm for calculating maximum bipartite matching, where matching is a set of nodes chosen in such a way that no two edges share an endpoint. |

bridges | C++ | A bridge is an edge, which when deleted, increases the number of connected components. The goal of this algorithm is to detect edges that are bridges in a graph. |

community_detection | C++ | The Louvain method for community detection is a greedy method for finding communities with maximum modularity in a graph. Runs in O(nlogn) time. |

community_detection_online | C++ | A dynamic community detection algorithm suitable for large-scale graphs based upon label propagation. Runs in O(m) time and has O(mn) space complexity. |

cycles | C++ | Algorithm for detecting cycles on graphs. |

cugraph | CUDA | Collection of NVIDIA GPU-powered algorithms integrated in Memgraph. Includes centrality measures, link analysis and graph clusterings. |

distance_calculator | Python | Module for finding the geographical distance between two points defined with 'lng' and 'lat' coordinates. |

export_util | Python | A module for exporting the graph database in different formats (JSON). |

graph_analyzer | Python | This Graph Analyzer query module offers insights about the stored graph or a subgraph. |

graph_coloring | Python | Algorithm for assigning labels to the graph elements subject to certain constraints. In this form, it is a way of coloring the graph vertices such that no two adjacent vertices are of the same color. |

json_util | Python | A module for loading JSON from a local file or remote address. |

import_util | Python | A module for importing data from different formats (JSON). |

katz_centrality | C++ | Katz centrality is a centrality measurement that outputs a node's influence based on the number of shortest paths and their weighted length. |

katz_centrality_online | C++ | Online implementation of the Katz centrality. Outputs the approximate result for Katz centrality while maintaining the order of rankings. |

max_flow | Python | An algorithm for finding a flow through a graph such that it is the maximum possible flow. |

node2vec | Python | An algorithm for calculating node embeddings on static graph. |

node2vec_online | Python | An algorithm for calculating node embeddings as new edges arrive. |

node_similarity | Python | A module that contains similarity measures for calculating the similarity between two nodes. |

nxalg | Python | A module that provides NetworkX integration with Memgraph and implements many NetworkX algorithms. |

pagerank | C++ | Algorithm that yields the influence measurement based on the recursive information about the connected nodes influence. |

pagerank_online | C++ | A dynamic algorithm made for calculating PageRank in a graph streaming scenario. |

rust_example | Rust | Example of a basic module with input parameters forwarding, made in Rust. |

set_cover | Python | An algorithm for finding the minimum cost subcollection of sets that covers all elements of a universe. |

temporal_graph_networks | Python | A graph neural network (GNN) algorithm that can learn to predict new edges and node labels from the graph structure and available node and edge features. |

tsp | Python | An algorithm for finding the shortest possible route that visits each vertex exactly once. |

union_find | Python | A module with an algorithm that enables the user to check whether the given nodes belong to the same connected component. |

uuid_generator | C++ | A module that generates a new universally unique identifier (UUID). |

vrp | Python | Algorithm for finding the shortest route possible between the central depot and places to be visited. The algorithm can be solved with multiple vehicles that represent a visiting fleet. |

weakly_connected_components | C++ | A module that finds weakly connected components in a graph. |