Skip to content

Update Docs towards New Version Deploy #155

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 19 commits into from
Jun 5, 2025
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
20 changes: 20 additions & 0 deletions .wordlist.txt
Original file line number Diff line number Diff line change
Expand Up @@ -13,6 +13,8 @@ CMD
CSC
CSV
CSVs
CDLP
communityId
Cailliau
Centos
ColumnType
Expand Down Expand Up @@ -360,3 +362,21 @@ propname
propvalue
ro
GenAI

WCC
SPpath
SSpath

undirected
preprocessing
subgraphs
directionality
iteratively
analytics
Pathfinding
Brin
Sergey
lookups
componentId
Betweenness
betweenness
91 changes: 91 additions & 0 deletions algorithms/betweenness_centrality.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,91 @@
---
title: "Betweenness Centrality"
description: "Measures the importance of nodes based on the number of shortest paths that pass through them."
parent: "Algorithms"
---

# Betweenness Centrality

## Introduction

Betweenness Centrality is a graph algorithm that quantifies the importance of a node based on the number of shortest paths that pass through it. Nodes that frequently occur on shortest paths between other nodes have higher betweenness centrality scores. This makes the algorithm useful for identifying **key connectors** or **brokers** within a network.

## Algorithm Overview

The core idea of Betweenness Centrality is that a node is more important if it lies on many of the shortest paths connecting other nodes. It’s particularly useful in understanding information flow or communication efficiency in a graph.

For example, in a social network, a person who frequently connects otherwise unconnected groups would have high betweenness centrality.

## Syntax

The procedure has the following call signature:
```cypher
CALL algo.betweenness({
nodeLabels: [<node_label>],
relationshipTypes: [<relationship_type>]
})
YIELD node, score
```

### Parameters

| Name | Type | Description | Default |
|-----------------------|---------|-------------------------------------------------|---------|
| `nodeLabels` | Array | *(Optional)* List of Strings representing node labels | [] |
| `relationshipTypes` | Array | *(Optional)* List of Strings representing relationship types | [] |

### Yield

| Name | Type | Description |
|---------|-------|-----------------------------------------------|
| `node` | Node | The node being evaluated |
| `score` | Float | The betweenness centrality score for the node |

## Example:

Lets take this Social Graph as an example:
![Social Graph](../images/between.png)

### Create the Graph

```cypher
CREATE
(a:Person {name: 'Alice'}),
(b:Person {name: 'Bob'}),
(c:Person {name: 'Charlie'}),
(d:Person {name: 'David'}),
(e:Person {name: 'Emma'}),
(a)-[:FRIEND]->(b),
(b)-[:FRIEND]->(c),
(b)-[:FRIEND]->(d),
(c)-[:FRIEND]->(e),
(d)-[:FRIEND]->(e)
```

### Run Betweenness Centrality - Sort Persons by importance based on FRIEND relationship

```cypher
CALL algo.betweenness({
'nodeLabels': ['Person'],
'relationshipTypes': ['FRIEND']
})
YIELD node, score
RETURN node.name AS person, score
ORDER BY score DESC
```

Expected result:

| person | score |
|-----------|--------|
| `Bob` | 6 |
| `Charlie` | 2 |
| `David` | 2 |
| `Alice` | 0 |
| `Emma` | 0 |

## Usage Notes

- Scores are based on **all shortest paths** between node pairs.
- Nodes that serve as bridges between clusters tend to score higher.
- Can be computationally expensive on large, dense graphs.
97 changes: 97 additions & 0 deletions algorithms/bfs.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,97 @@
---
title: "BFS"
description: "Breadth-First Search (BFS) explores a graph level by level, visiting all neighbors of a node before moving to the next depth."
parent: "Algorithms"
---

# BFS

## Overview

The Breadth-First Search (BFS) procedure allows you to perform a breadth-first traversal of a graph starting from a specific node.
BFS explores all the nodes at the present depth before moving on to nodes at the next depth level.
This is particularly useful for finding the shortest path between two nodes or exploring a graph layer by layer.

## Syntax

```
CALL algo.bfs(start_node, max_depth, relationship)
YIELD nodes, edges
```

## Arguments

| Name | Type | Description | Default |
|--------------|----------------|-----------------------------------------------------------------------------|------------|
| start_node | Node | Starting node for the BFS traversal | (Required) |
| max_depth | Integer | Maximum depth to traverse | (Required) |
| relationship | String or null | The relationship type to traverse. If null, all relationship types are used | null |

## Returns

| Name | Type | Description |
|-------|------|----------------------------------------------|
| nodes | List | List of visited nodes in breadth-first order |
| edges | List | List of edges traversed during the BFS |

## Examples

### Social Network Friend Recommendations

This example demonstrates how to use BFS to find potential friend recommendations in a social network.
By exploring friends of friends, BFS uncovers second-degree connections—people you may know through mutual friends—which are often strong candidates for relevant and meaningful recommendations.

#### Create the Graph

```cypher
CREATE
(alice:Person {name: 'Alice', age: 28, city: 'New York'}),
(bob:Person {name: 'Bob', age: 32, city: 'Boston'}),
(charlie:Person {name: 'Charlie', age: 35, city: 'Chicago'}),
(david:Person {name: 'David', age: 29, city: 'Denver'}),
(eve:Person {name: 'Eve', age: 31, city: 'San Francisco'}),
(frank:Person {name: 'Frank', age: 27, city: 'Miami'}),

(alice)-[:FRIEND]->(bob),
(alice)-[:FRIEND]->(charlie),
(bob)-[:FRIEND]->(david),
(charlie)-[:FRIEND]->(eve),
(david)-[:FRIEND]->(frank),
(eve)-[:FRIEND]->(frank)
```

![Graph BFS](../images/graph_bfs.png)

#### Find Friends of Friends (Potential Recommendations)

```
// Find Alice's friends-of-friends (potential recommendations)
MATCH (alice:Person {name: 'Alice'})
CALL algo.bfs(alice, 2, 'FRIEND')
YIELD nodes

// Process results to get only depth 2 connections (friends of friends)
WHERE size(nodes) >= 3
WITH alice, nodes[2] AS potential_friend
WHERE NOT (alice)-[:FRIEND]->(potential_friend)
RETURN potential_friend
```

In this social network example, the BFS algorithm helps find potential friend recommendations by identifying people who are connected to Alice's existing friends but not directly connected to Alice yet.


## Performance Considerations

- **Indexing:** Ensure properties used for finding your starting node are indexed for optimal performance
- **Maximum Depth:** Choose an appropriate max_depth value based on your graph's connectivity; large depths in highly connected graphs can result in exponential growth of traversed nodes
- **Relationship Filtering:** When applicable, specify the relationship type to limit the traversal scope
- **Memory Management:** Be aware that the procedure stores visited nodes in memory to avoid cycles, which may require significant resources in large, densely connected graphs

## Error Handling

Common errors that may occur:

- **Null Starting Node:** If the start_node parameter is null, the procedure will raise an error; ensure your MATCH clause successfully finds the starting node
- **Invalid Relationship Type:** If you specify a relationship type that doesn't exist in your graph, the traversal will only include the starting node
- **Memory Limitations:** For large graphs with high connectivity, an out-of-memory error may occur if too many nodes are visited
- **Result Size:** If the BFS traversal returns too many nodes, query execution may be slow or time out; in such cases, try reducing the max_depth or filtering by relationship types
Loading