Update Docs towards New Version Deploy

.wordlist.txt

@@ -360,3 +360,21 @@ propname
 propvalue
 ro
 GenAI
+
+WCC
+SPpath
+SSpath
+
+undirected
+preprocessing
+subgraphs
+directionality
+iteratively
+analytics
+Pathfinding
+Brin
+Sergey
+lookups
+componentId
+Betweenness
+betweenness

algorithms/betweenness_centrality.md

@@ -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.

algorithms/bfs.md

@@ -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

algorithms/index.md

@@ -0,0 +1,47 @@
+---
+title: "Algorithms"
+description: Graph Algorithms Overview
+nav_order: 3
+has_children: true
+---
+
+# FalkorDB Algorithms Overview
+
+FalkorDB offers a suite of graph algorithms optimized for high-performance graph analytics.  
+These algorithms are accessible via the `CALL algo.<name>()` interface and are built for speed and scalability using matrix-based computation.
+
+This overview summarizes the available algorithms and links to their individual documentation.
+
+## Table of Contents
+
+- [Pathfinding Algorithms](#pathfinding-algorithms)
+- [Centrality Measures](#centrality-measures)
+- [Community Detection](#community-detection)
+
+---
+
+## Pathfinding Algorithms
+
+- **[BFS](./bfs.md)**  
+  Performs a breadth-first search starting from a source node and optionally stopping at target nodes or maximum depth.
+
+- **[SPpath](./sppath.md)**  
+  Computes the shortest paths between a source and one or more destination nodes.
+
+- **[SSpath](./sspath.md)**  
+  Enumerates all paths from a single source node to other nodes, based on constraints like edge filters and depth.
+
+For path expressions like `shortestPath()` used directly in Cypher queries, refer to the [Cypher Path Functions section](../cypher/functions.md#path-functions).
+
+## Centrality Measures
+
+- **[PageRank](./pagerank.md)**  
+  Computes the PageRank score of each node in the graph, representing its influence based on the structure of incoming links.
+
+- **[Betweenness Centrality](./betweenness_centrality.md)**  
+  Calculates the number of shortest paths that pass through each node, indicating its importance as a connector in the graph.
+
+## Community Detection
+
+- **[WCC (Weakly Connected Components)](./wcc.md)**  
+  Finds weakly connected components in a graph, where each node is reachable from others ignoring edge directions.

algorithms/pagerank.md

@@ -0,0 +1,99 @@
+---
+title: "PageRank"
+description: "Rank nodes based on the number and quality of edges pointing to them, simulating the likelihood of a random traversal landing on each node."
+parent: "Algorithms"
+---
+
+# PageRank
+
+## Introduction
+
+PageRank is an algorithm that measures the importance of each node within the graph based on the number of incoming relationships and the importance of the corresponding source nodes.
+The algorithm was originally developed by Google's founders Larry Page and Sergey Brin during their time at Stanford University.
+
+## Algorithm Overview
+
+PageRank works by counting the number and quality of relationships to a node to determine a rough estimate of how important that node is.
+The underlying assumption is that more important nodes are likely to receive more connections from other nodes.
+
+The algorithm assigns each node a score, where higher scores indicate greater importance.
+The score for a node is derived recursively from the scores of the nodes that link to it, with a damping factor typically applied to prevent rank sinks.
+For example, in a network of academic papers, a paper cited by many other highly cited papers will receive a high PageRank score, reflecting its influence in the field.
+
+## Syntax
+
+The PageRank procedure has the following call signature:
+
+```cypher
+CALL pagerank.stream(
+    [label],
+    [relationship]
+)
+YIELD node, score
+```
+
+### Parameters
+
+| Name           | Type   | Default | Description                                                                  |
+|----------------|--------|---------|------------------------------------------------------------------------------|
+| `label`        | String | null    | The label of nodes to run the algorithm on. If null, all nodes are used.     |
+| `relationship` | String | null    | The relationship type to traverse. If null, all relationship types are used. |
+
+### Yield
+
+| Name    | Type  | Description                          |
+|---------|-------|--------------------------------------|
+| `node`  | Node  | The node processed by the algorithm. |
+| `score` | Float | The PageRank score for the node.     |
+
+## Examples
+
+### Unweighted PageRank
+
+First, let's create a sample graph representing a citation network between scientific papers:
+
+```cypher
+CREATE 
+  (paper1:Paper {title: 'Graph Algorithms in Database Systems'}),
+  (paper2:Paper {title: 'PageRank Applications'}),
+  (paper3:Paper {title: 'Data Mining Techniques'}),
+  (paper4:Paper {title: 'Network Analysis Methods'}),
+  (paper5:Paper {title: 'Social Network Graph Theory'}),
+
+  (paper2)-[:CITES]->(paper1),
+  (paper3)-[:CITES]->(paper1),
+  (paper3)-[:CITES]->(paper2),
+  (paper4)-[:CITES]->(paper1),
+  (paper4)-[:CITES]->(paper3),
+  (paper5)-[:CITES]->(paper2),
+  (paper5)-[:CITES]->(paper4)
+```
+
+![Graph PR](../images/graph_page_rank.png)
+
+Now we can run the PageRank algorithm on this citation network:
+
+```cypher
+CALL pagerank.stream('Paper', 'CITES')
+YIELD node, score
+RETURN node.title AS paper, score
+ORDER BY score DESC
+```
+
+Expected results:
+
+| paper                                | score |
+|--------------------------------------|-------|
+| Graph Algorithms in Database Systems | 0.43  |
+| Data Mining Techniques               | 0.21  |
+| PageRank Applications                | 0.19  |
+| Network Analysis Methods             | 0.14  |
+| Social Network Graph Theory          | 0.03  |
+
+
+## Usage Notes
+
+**Interpreting scores**:
+   - PageRank scores are relative, not absolute measures
+   - The sum of all scores in a graph equals 1.0
+   - Scores typically follow a power-law distribution