This is an automated email from the ASF dual-hosted git repository.
jin pushed a commit to branch auth-reminder
in repository https://gitbox.apache.org/repos/asf/incubator-hugegraph-doc.git
commit 7e93f7162aae1717f4041a98787843d5ccf8b9db
Author: imbajin <j...@apache.org>
AuthorDate: Thu Feb 20 14:13:23 2025 +0800
doc: add EN for vermeer(OLAP) & server auth
---
content/cn/docs/quickstart/hugegraph-server.md | 13 +-
content/cn/docs/quickstart/hugegraph-spark.md | 2 +-
content/cn/docs/quickstart/hugegraph-vermeer.md | 43 +--
content/en/docs/quickstart/hugegraph-server.md | 15 +-
content/en/docs/quickstart/hugegraph-vermeer.md | 454 ++++++++++++++++++++++++
5 files changed, 495 insertions(+), 32 deletions(-)
diff --git a/content/cn/docs/quickstart/hugegraph-server.md
b/content/cn/docs/quickstart/hugegraph-server.md
index de1541b1..1ef83d28 100644
--- a/content/cn/docs/quickstart/hugegraph-server.md
+++ b/content/cn/docs/quickstart/hugegraph-server.md
@@ -6,7 +6,7 @@ weight: 1
### 1 HugeGraph-Server 概述
-HugeGraph-Server 是 HugeGraph 项目的核心部分，包含 Core、Backend、API 等子模块。
+HugeGraph-Server 是 HugeGraph 项目的核心部分，包含 graph-core、backend、API 等子模块。
Core 模块是 Tinkerpop 接口的实现，Backend
模块用于管理数据存储，目前支持的后端包括：Memory、Cassandra、ScyllaDB 以及 RocksDB，API 模块提供 HTTP
Server，将 Client 的 HTTP 请求转化为对 Core 的调用。
@@ -22,8 +22,6 @@ Core 模块是 Tinkerpop 接口的实现，Backend 模块用于管理数据存
**在往下阅读之前先执行 `java -version` 命令确认 jdk 版本**
> 注：使用 Java 8 启动 HugeGraph-Server 会失去一些**安全性**的保障，也会降低性能相关指标
->
-> 我们推荐生产或对外网暴露访问的环境使用 Java 11 并考虑开启 [Auth
权限认证](/cn/docs/config/config-authentication/)。
### 3 部署
@@ -34,6 +32,8 @@ Core 模块是 Tinkerpop 接口的实现，Backend 模块用于管理数据存
- 方式 3：源码编译
- 方式 4：使用 tools 工具部署 (Outdated)
+**注意** 生产或对外网暴露访问的环境必须使用 Java 11 并开启 [Auth
权限认证](/cn/docs/config/config-authentication/), 否则会有安全隐患。
+
#### 3.1 使用 Docker 容器 (便于**测试**)
<!-- 3.1 is linked by another place. if change 3.1's title, please check -->
@@ -127,6 +127,10 @@ mvn package -DskipTests
执行成功后，在 hugegraph 目录下生成 `*hugegraph-*.tar.gz` 文件，就是编译生成的 tar 包。
+<details>
+<summary>过时的 tools 工具安装</summary>
+
+```bash
#### 3.4 使用 tools 工具部署 (Outdated)
HugeGraph-Tools 提供了一键部署的命令行工具，用户可以使用该工具快速地一键下载、解压、配置并启动 HugeGraph-Server 和
HugeGraph-Hubble，最新的 HugeGraph-Toolchain 中已经包含所有的这些工具，直接下载它解压就有工具包集合了
@@ -148,6 +152,7 @@ bin/hugegraph deploy -v {hugegraph-version} -p
{install-path} [-u {download-path
```
`{hugegraph-version}` 表示要部署的 HugeGraphServer 及 HugeGraphStudio 的版本，用户可查看
`conf/version-mapping.yaml` 文件获取版本信息，`{install-path}` 指定 HugeGraphServer 及
HugeGraphStudio 的安装目录，`{download-path-prefix}` 可选，指定 HugeGraphServer 及
HugeGraphStudio tar 包的下载地址，不提供时使用默认下载地址，比如要启动 0.6 版本的 HugeGraph-Server 及
HugeGraphStudio 将上述命令写为 `bin/hugegraph deploy -v 0.6 -p services` 即可。
+</details>
### 4 配置
@@ -169,7 +174,7 @@ HugeGraphServer 启动时会连接后端存储并尝试检查后端存储版本
由于各种后端所需的配置（hugegraph.properties）及启动步骤略有不同，下面逐一对各后端的配置及启动做介绍。
-如果想要使用 HugeGraph 鉴权模式，在后面正式启动 Server 之前应按照 [Server
鉴权配置](https://hugegraph.apache.org/cn/docs/config/config-authentication/) 进行配置。
+**注:** 如果想要开启 HugeGraph 权限系统，在启动 Server 之前应按照 [Server
鉴权配置](https://hugegraph.apache.org/cn/docs/config/config-authentication/)
进行配置。(尤其是生产环境/外网环境须开启)
##### 5.1.1 RocksDB
diff --git a/content/cn/docs/quickstart/hugegraph-spark.md
b/content/cn/docs/quickstart/hugegraph-spark.md
index e7afc8bb..7caaeffe 100644
--- a/content/cn/docs/quickstart/hugegraph-spark.md
+++ b/content/cn/docs/quickstart/hugegraph-spark.md
@@ -2,7 +2,7 @@
title: "HugeGraph-Spark Quick Start"
linkTitle: "(Deprecated) Analysis with HugeGraph-Spark"
draft: true
-weight: 7
+weight: 100
---
> Note: HugeGraph-Spark 已经停止维护, 不再更新, 请转向使用 hugegraph-computer, 感谢理解
diff --git a/content/cn/docs/quickstart/hugegraph-vermeer.md
b/content/cn/docs/quickstart/hugegraph-vermeer.md
index 3748dfb6..57e5bdb4 100644
--- a/content/cn/docs/quickstart/hugegraph-vermeer.md
+++ b/content/cn/docs/quickstart/hugegraph-vermeer.md
@@ -1,14 +1,14 @@
---
title: "HugeGraph-Vermeer Quick Start"
-linkTitle: "使用 Vermeer 计算框架"
-weight: 8
+linkTitle: "(OLAP) Vermeer 内存图计算框架"
+weight: 7
---
## 一、Vermeer 概述
### 1.1 运行架构
-Vermeer 是一个 Go 编写的高性能内存优先的图计算框架，支持 15+ OLAP 图算法的极速计算，包含 master 和 worker
两种角色。master 目前只有一个，worker 可以有多个。
+Vermeer 是一个 `Go`编写的高性能内存优先的图计算框架 (一次启动，任意执行)，支持 15+ OLAP 图算法的极速计算
(大部分秒~分钟级别完成执行)，包含 master 和 worker 两种角色。master 目前只有一个 (可增加 HA)，worker 可以有多个。
master 是负责通信、转发、汇总的节点，计算量和占用资源量较少。worker 是计算节点，用于存储图数据和运行计算任务，占用大量内存和 cpu。grpc
和 rest 模块分别负责内部通信和外部调用。
@@ -36,7 +36,6 @@ master 是负责通信、转发、汇总的节点，计算量和占用资源量
request 示例：
```javascript
-
POST http://localhost:8688/tasks/create
{
"task_type": "load",
@@ -60,7 +59,7 @@ POST http://localhost:8688/tasks/create
request 示例：
-```
+```javascript
POST http://localhost:8688/tasks/create
{
"task_type": "compute",
@@ -91,7 +90,7 @@ PageRank 算法适用于网页排序、社交网络重点人物发掘等场景
request 示例：
-```
+```javascript
POST http://localhost:8688/tasks/create
{
"task_type": "compute",
@@ -113,7 +112,7 @@ POST http://localhost:8688/tasks/create
request 示例：
-```
+```javascript
POST http://localhost:8688/tasks/create
{
"task_type": "compute",
@@ -135,7 +134,7 @@ POST http://localhost:8688/tasks/create
request 示例：
-```
+```javascript
POST http://localhost:8688/tasks/create
{
"task_type": "compute",
@@ -157,7 +156,7 @@ POST http://localhost:8688/tasks/create
request 示例：
-```
+```javascript
POST http://localhost:8688/tasks/create
{
"task_type": "compute",
@@ -179,7 +178,7 @@ POST http://localhost:8688/tasks/create
request 示例：
-```
+```javascript
POST http://localhost:8688/tasks/create
{
"task_type": "compute",
@@ -201,7 +200,7 @@ POST http://localhost:8688/tasks/create
request 示例：
-```
+```javascript
POST http://localhost:8688/tasks/create
{
"task_type": "compute",
@@ -227,7 +226,7 @@ POST http://localhost:8688/tasks/create
request 示例：
-```
+```javascript
POST http://localhost:8688/tasks/create
{
"task_type": "compute",
@@ -248,7 +247,7 @@ K-Core 算法，标记所有度数为 K 的顶点，适用于图的剪枝，查
request 示例：
-```
+```javascript
POST http://localhost:8688/tasks/create
{
"task_type": "compute",
@@ -270,7 +269,7 @@ POST http://localhost:8688/tasks/create
request 示例：
-```
+```javascript
POST http://localhost:8688/tasks/create
{
"task_type": "compute",
@@ -292,7 +291,7 @@ POST http://localhost:8688/tasks/create
request 示例：
-```
+```javascript
POST http://localhost:8688/tasks/create
{
"task_type": "compute",
@@ -317,7 +316,7 @@ Vermeer 上实现的分布式 Louvain 算法受节点顺序、并行计算等因
request 示例：
-```
+```javascript
POST http://localhost:8688/tasks/create
{
"task_type": "compute",
@@ -342,7 +341,7 @@ Jaccard index , 又称为 Jaccard 相似系数（Jaccard similarity
coefficient
request 示例：
-```
+```javascript
POST http://localhost:8688/tasks/create
{
"task_type": "compute",
@@ -367,7 +366,7 @@ POST http://localhost:8688/tasks/create
request 示例：
-```
+```javascript
POST http://localhost:8688/tasks/create
{
"task_type": "compute",
@@ -392,7 +391,7 @@ POST http://localhost:8688/tasks/create
request 示例：
-```
+```javascript
POST http://localhost:8688/tasks/create
{
"task_type": "compute",
@@ -415,7 +414,7 @@ POST http://localhost:8688/tasks/create
request 示例：
-```
+```javascript
POST http://localhost:8688/tasks/create
{
"task_type": "compute",
@@ -435,7 +434,7 @@ POST http://localhost:8688/tasks/create
在有向图的数学理论中，如果一个图的每一个顶点都可从该图其他任意一点到达，则称该图是强连通的。在任意有向图中能够实现强连通的部分我们称其为强连通分量。它表明各个点之间的连通性，区分不同的连通社区。
-```
+```javascript
POST http://localhost:8688/tasks/create
{
"task_type": "compute",
@@ -451,3 +450,5 @@ POST http://localhost:8688/tasks/create
}
```
+> 🚧, 后续随时更新完善，欢迎随时提出建议和意见。
+
diff --git a/content/en/docs/quickstart/hugegraph-server.md
b/content/en/docs/quickstart/hugegraph-server.md
index af585c60..19c3fda1 100644
--- a/content/en/docs/quickstart/hugegraph-server.md
+++ b/content/en/docs/quickstart/hugegraph-server.md
@@ -6,7 +6,7 @@ weight: 1
### 1 HugeGraph-Server Overview
-`HugeGraph-Server` is the core part of the HugeGraph Project, contains
submodules such as Core, Backend, API.
+`HugeGraph-Server` is the core part of the HugeGraph Project, contains
submodules such as graph-core, backend, API.
The Core Module is an implementation of the Tinkerpop interface; The Backend
module is used to save the graph data to the data store, currently supported
backends include: Memory, Cassandra, ScyllaDB, RocksDB; The API Module provides
HTTP Server, which converts Client's HTTP request into a call to Core Module.
@@ -24,9 +24,7 @@ and configure by yourself.
**Be sure to execute the `java -version` command to check the jdk version
before reading**
-> Note: Using Java8 will lose some security guarantees, we recommend using
Java11 in production or
->
-> environments exposed to the public network and enable [Auth
authentication](/docs/config/config-authentication/).
+> Note: Using Java8 will lose some security guarantees, we recommend using
Java11 in production
### 3 Deploy
@@ -37,6 +35,8 @@ There are four ways to deploy HugeGraph-Server components:
- Method 3: Source code compilation
- Method 4: One-click deployment
+**Note:** If it's exposed to the public network, **must enable** [Auth
authentication](/docs/config/config-authentication/) to ensure safety (so as
the legacy version).
+
#### 3.1 Use Docker container (Convenient for Test/Dev)
<!-- 3.1 is linked by another place. if change 3.1's title, please check -->
@@ -145,7 +145,9 @@ The execution log is as follows:
After successful execution, `*hugegraph-*.tar.gz` files will be generated in
the hugegraph directory, which is the tarball generated by compilation.
-#### 3.4 One-click deployment
+<details>
+<summary> Outdated tools</summary>
+#### 3.4 One-click deployment (Outdated)
`HugeGraph-Tools` provides a command-line tool for one-click deployment, users
can use this tool to quickly download, decompress, configure and start
`HugeGraphServer` and `HugeGraph-Hubble` with one click.
@@ -170,6 +172,7 @@ bin/hugegraph deploy -v {hugegraph-version} -p
{install-path} [-u {download-path
```
`{hugegraph-version}` indicates the version of HugeGraphServer and
HugeGraphStudio to be deployed, users can view the `conf/version-mapping.yaml`
file for version information, `{install-path}` specify the installation
directory of HugeGraphServer and HugeGraphStudio, `{download-path-prefix}`
optional, specify the download address of HugeGraphServer and HugeGraphStudio
tarball, use default download URL if not provided, for example, to start
HugeGraph-Server and HugeGraphStudio version 0.6 [...]
+</details>
### 4 Config
@@ -190,7 +193,7 @@ If you need to access HugeGraphServer externally, please
modify the `restserver.
Since the configuration (hugegraph.properties) and startup steps required by
various backends are slightly different, the following will introduce the
configuration and startup of each backend one by one.
-If you want to use HugeGraph authentication mode, you should follow the
[Server Authentication
Configuration](https://hugegraph.apache.org/docs/config/config-authentication/)
before you start Server later.
+Follow the [Server Authentication
Configuration](https://hugegraph.apache.org/docs/config/config-authentication/)
before you start Server later.
##### 5.1.1 Memory
diff --git a/content/en/docs/quickstart/hugegraph-vermeer.md
b/content/en/docs/quickstart/hugegraph-vermeer.md
new file mode 100644
index 00000000..3c7843c4
--- /dev/null
+++ b/content/en/docs/quickstart/hugegraph-vermeer.md
@@ -0,0 +1,454 @@
+---
+title: "HugeGraph-Vermeer Quick Start"
+linkTitle: "(OLAP) Vermeer Memory-First Computing Framework"
+weight: 7
+---
+
+## 1. Overview of Vermeer
+
+### 1.1 Architecture
+
+Vermeer is a high-performance, memory-first graph computing framework written
in `Go` (start once, execute any task), supporting ultra-fast computation of
15+ OLAP graph algorithms (most tasks complete in seconds to minutes), with
master and worker roles. Currently, there is only one master (HA can be added),
and there can be multiple workers.
+
+The master is responsible for communication, forwarding, and aggregation, with
minimal computation and resource usage. Workers are computation nodes used to
store graph data and run computation tasks, consuming a large amount of memory
and CPU. The grpc and rest modules handle internal communication and external
calls, respectively.
+
+The framework's runtime configuration can be passed via command-line
parameters or specified in configuration files located in the `config/`
directory. The `--env` parameter can specify which configuration file to use,
e.g., `--env=master` specifies using `master.ini`. Note that the master needs
to specify the listening port, and the worker needs to specify the listening
port and the master's `ip:port`.
+
+### 1.2 Running Method
+
+Enter the directory and input `./vermeer --env=master` or `./vermeer
--env=worker01`.
+
+## 2. Task Creation REST API
+
+### 2.1 Introduction
+
+This REST API provides all task creation functions, including reading graph
data and various computation functions, offering both asynchronous and
synchronous return interfaces. The returned content includes information about
the created tasks. The overall process of using Vermeer is to first create a
task to read the graph data, and after the graph is read, create a computation
task to execute the computation. The graph will not be automatically deleted;
multiple computation tasks can b [...]
+
+Available URLs are as follows:
+
+- Asynchronous return interface: POST http://master_ip:port/tasks/create
returns only whether the task creation is successful, and the task status needs
to be actively queried to determine completion.
+- Synchronous return interface: POST http://master_ip:port/tasks/create/sync
returns after the task is completed.
+
+### 2.2 Loading Graph Data
+
+Refer to the Vermeer parameter list document for specific parameters.
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "load",
+ "graph": "testdb",
+ "params": {
+ "load.parallel": "50",
+ "load.type": "local",
+ "load.vertex_files": "{\"localhost\":\"data/twitter-2010.v_[0,99]\"}",
+ "load.edge_files": "{\"localhost\":\"data/twitter-2010.e_[0,99]\"}",
+ "load.use_out_degree": "1",
+ "load.use_outedge": "1"
+ }
+}
+```
+
+### 2.3 Output Computation Results
+
+All Vermeer computation tasks support multiple result output methods, which
can be customized: local, hdfs, afs, or hugegraph. Add the corresponding
parameters under the params parameter when sending the request to take effect.
When output.need_statistics is set to 1, it supports outputting statistical
information of the computation results, which will be written in the interface
task information. The statistical mode operators currently support "count" and
"modularity," but only for com [...]
+
+Refer to the Vermeer parameter list document for specific parameters.
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "compute",
+ "graph": "testdb",
+ "params": {
+ "compute.algorithm": "pagerank",
+ "compute.parallel":"10",
+ "compute.max_step":"10",
+ "output.type":"local",
+ "output.parallel":"1",
+ "output.file_path":"result/pagerank"
+ }
+ }
+```
+
+## 3. Supported Algorithms
+
+### 3.1 PageRank
+
+The PageRank algorithm, also known as the web ranking algorithm, is a
technique used by search engines to calculate the relevance and importance of
web pages (nodes) based on their mutual hyperlinks.
+
+- If a web page is linked to by many other web pages, it indicates that the
web page is relatively important, and its PageRank value will be relatively
high.
+- If a web page with a high PageRank value links to other web pages, the
PageRank value of the linked web pages will also increase accordingly.
+
+The PageRank algorithm is suitable for scenarios such as web page ranking and
identifying key figures in social networks.
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "compute",
+ "graph": "testdb",
+ "params": {
+ "compute.algorithm": "pagerank",
+ "compute.parallel":"10",
+ "output.type":"local",
+ "output.parallel":"1",
+ "output.file_path":"result/pagerank",
+ "compute.max_step":"10"
+ }
+}
+```
+
+### 3.2 WCC (Weakly Connected Components)
+
+The weakly connected components algorithm calculates all connected subgraphs
in an undirected graph and outputs the weakly connected subgraph ID to which
each vertex belongs, indicating the connectivity between points and
distinguishing different connected communities.
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "compute",
+ "graph": "testdb",
+ "params": {
+ "compute.algorithm": "wcc",
+ "compute.parallel":"10",
+ "output.type":"local",
+ "output.parallel":"1",
+ "output.file_path":"result/wcc",
+ "compute.max_step":"10"
+ }
+}
+```
+
+### 3.3 LPA (Label Propagation Algorithm)
+
+The label propagation algorithm is a graph clustering algorithm commonly used
in social networks to discover potential communities.
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "compute",
+ "graph": "testdb",
+ "params": {
+ "compute.algorithm": "lpa",
+ "compute.parallel":"10",
+ "output.type":"local",
+ "output.parallel":"1",
+ "output.file_path":"result/lpa",
+ "compute.max_step":"10"
+ }
+}
+```
+
+### 3.4 Degree Centrality
+
+The degree centrality algorithm calculates the degree centrality value of each
node in the graph, supporting both undirected and directed graphs. Degree
centrality is an important indicator of node importance; the more edges a node
has with other nodes, the higher its degree centrality value, and the more
important the node is in the graph. In an undirected graph, degree centrality
is calculated based on edge information to count the number of times a node
appears, resulting in the degre [...]
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "compute",
+ "graph": "testdb",
+ "params": {
+ "compute.algorithm": "degree",
+ "compute.parallel":"10",
+ "output.type":"local",
+ "output.parallel":"1",
+ "output.file_path":"result/degree",
+ "degree.direction":"both"
+ }
+}
+```
+
+### 3.5 Closeness Centrality
+
+Closeness centrality is used to calculate the inverse of the shortest distance
from a node to all other reachable nodes, accumulating and normalizing the
value. Closeness centrality can be used to measure the time it takes for
information to be transmitted from the node to other nodes. The larger the
closeness centrality of a node, the closer its position in the graph is to the
center, suitable for scenarios such as identifying key nodes in social networks.
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "compute",
+ "graph": "testdb",
+ "params": {
+ "compute.algorithm": "closeness_centrality",
+ "compute.parallel":"10",
+ "output.type":"local",
+ "output.parallel":"1",
+ "output.file_path":"result/closeness_centrality",
+ "closeness_centrality.sample_rate":"0.01"
+ }
+}
+```
+
+### 3.6 Betweenness Centrality
+
+The betweenness centrality algorithm determines the value of a node as a
"bridge" node; the larger the value, the more likely it is to be a necessary
path between two points in the graph. Typical examples include mutual followers
in social networks. It is suitable for measuring the degree of aggregation
around a node in a community.
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "compute",
+ "graph": "testdb",
+ "params": {
+ "compute.algorithm": "betweenness_centrality",
+ "compute.parallel":"10",
+ "output.type":"local",
+ "output.parallel":"1",
+ "output.file_path":"result/betweenness_centrality",
+ "betweenness_centrality.sample_rate":"0.01"
+ }
+}
+```
+
+### 3.7 Triangle Count
+
+The triangle count algorithm calculates the number of triangles passing
through each vertex, suitable for calculating the relationships between users
and whether the associations form triangles. The more triangles, the higher the
degree of association between nodes in the graph, and the tighter the
organizational relationship. In social networks, triangles indicate cohesive
communities, and identifying triangles helps understand clustering and
interconnections among individuals or groups [...]
+
+The output result is the Triangle Count corresponding to each vertex, i.e.,
the number of triangles the vertex is part of.
+
+Note: This algorithm is for undirected graphs and ignores edge directions.
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "compute",
+ "graph": "testdb",
+ "params": {
+ "compute.algorithm": "triangle_count",
+ "compute.parallel":"10",
+ "output.type":"local",
+ "output.parallel":"1",
+ "output.file_path":"result/triangle_count"
+ }
+}
+```
+
+### 3.8 K-Core
+
+The K-Core algorithm marks all vertices with a degree of K, suitable for graph
pruning and finding the core part of the graph.
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "compute",
+ "graph": "testdb",
+ "params": {
+ "compute.algorithm": "kcore",
+ "compute.parallel":"10",
+ "output.type":"local",
+ "output.parallel":"1",
+ "output.file_path":"result/kcore",
+ "kcore.degree_k":"5"
+ }
+}
+```
+
+### 3.9 SSSP (Single Source Shortest Path)
+
+The single source the shortest path algorithm calculates the shortest distance
from one point to all other points.
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "compute",
+ "graph": "testdb",
+ "params": {
+ "compute.algorithm": "sssp",
+ "compute.parallel":"10",
+ "output.type":"local",
+ "output.parallel":"1",
+ "output.file_path":"result/degree",
+ "sssp.source":"tom"
+ }
+}
+```
+
+### 3.10 KOUT
+
+Starting from a point, get the k-layer nodes of this point.
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "compute",
+ "graph": "testdb",
+ "params": {
+ "compute.algorithm": "kout",
+ "compute.parallel":"10",
+ "output.type":"local",
+ "output.parallel":"1",
+ "output.file_path":"result/kout",
+ "kout.source":"tom",
+ "compute.max_step":"6"
+ }
+}
+```
+
+### 3.11 Louvain
+
+The Louvain algorithm is a community detection algorithm based on modularity.
The basic idea is that nodes in the network try to traverse all neighbor
community labels and choose the community label that maximizes the modularity
increment. After maximizing modularity, each community is regarded as a new
node, and the process is repeated until the modularity no longer increases.
+
+The distributed Louvain algorithm implemented on Vermeer is affected by
factors such as node order and parallel computation. Due to the random
traversal order of the Louvain algorithm, community compression also has a
certain randomness, leading to different results in multiple executions.
However, the overall trend will not change significantly.
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "compute",
+ "graph": "testdb",
+ "params": {
+ "compute.algorithm": "louvain",
+ "compute.parallel":"10",
+ "compute.max_step":"1000",
+ "louvain.threshold":"0.0000001",
+ "louvain.resolution":"1.0",
+ "louvain.step":"10",
+ "output.type":"local",
+ "output.parallel":"1",
+ "output.file_path":"result/louvain"
+ }
+ }
+```
+
+### 3.12 Jaccard Similarity Coefficient
+
+The Jaccard index, also known as the Jaccard similarity coefficient, is used
to compare the similarity and diversity between finite sample sets. The larger
the Jaccard coefficient value, the higher the similarity of the samples. It is
used to calculate the Jaccard similarity coefficient between a given source
point and all other points in the graph.
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "compute",
+ "graph": "testdb",
+ "params": {
+ "compute.algorithm": "jaccard",
+ "compute.parallel":"10",
+ "compute.max_step":"2",
+ "jaccard.source":"123",
+ "output.type":"local",
+ "output.parallel":"1",
+ "output.file_path":"result/jaccard"
+ }
+}
+```
+
+### 3.13 Personalized PageRank
+
+The goal of personalized PageRank is to calculate the relevance of all nodes
relative to user u. Starting from the node corresponding to user u, at each
node, there is a probability of 1-d to stop walking and start again from u, or
a probability of d to continue walking, randomly selecting a node from the
nodes pointed to by the current node to walk down. It is used to calculate the
personalized PageRank score starting from a given starting point, suitable for
scenarios such as social re [...]
+
+Since the calculation requires using out-degree, load.use_out_degree needs to
be set to 1 when reading the graph.
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "compute",
+ "graph": "testdb",
+ "params": {
+ "compute.algorithm": "ppr",
+ "compute.parallel":"100",
+ "compute.max_step":"10",
+ "ppr.source":"123",
+ "ppr.damping":"0.85",
+ "ppr.diff_threshold":"0.00001",
+ "output.type":"local",
+ "output.parallel":"1",
+ "output.file_path":"result/ppr"
+ }
+}
+```
+
+### 3.14 Global Kout
+
+Calculate the k-degree neighbors of all nodes in the graph (excluding
themselves and 1~k-1 degree neighbors). Due to the severe memory expansion of
the global kout algorithm, k is currently limited to 1 and 2. Additionally, the
global kout algorithm supports filtering functions (parameters such as
"compute.filter":"risk_level==1"), and the filtering condition is judged when
calculating the k-degree. The final result set includes those that meet the
filtering condition. The algorithm's fi [...]
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "compute",
+ "graph": "testdb",
+ "params": {
+ "compute.algorithm": "kout_all",
+ "compute.parallel":"10",
+ "output.type":"local",
+ "output.parallel":"10",
+ "output.file_path":"result/kout",
+ "compute.max_step":"2",
+ "compute.filter":"risk_level==1"
+ }
+}
+```
+
+### 3.15 Clustering Coefficient
+
+The clustering coefficient represents the coefficient of the clustering degree
of nodes in a graph. In real networks, especially in specific networks, nodes
tend to establish a tightly organized relationship due to relatively
high-density connection points. The clustering coefficient algorithm (Cluster
Coefficient) is used to calculate the clustering degree of nodes in the graph.
This algorithm is for local clustering coefficients. The local clustering
coefficient can measure the cluster [...]
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "compute",
+ "graph": "testdb",
+ "params": {
+ "compute.algorithm": "clustering_coefficient",
+ "compute.parallel":"100",
+ "compute.max_step":"10",
+ "output.type":"local",
+ "output.parallel":"1",
+ "output.file_path":"result/cc"
+ }
+}
+```
+
+### 3.16 SCC (Strongly Connected Components)
+
+In the mathematical theory of directed graphs, if every vertex of a graph can
be reached from any other point in the graph, the graph is said to be strongly
connected. The parts of any directed graph that can achieve strong connectivity
are called strongly connected components. It indicates the connectivity between
points and distinguishes different connected communities.
+
+Request example:
+
+```javascript
+POST http://localhost:8688/tasks/create
+{
+ "task_type": "compute",
+ "graph": "testdb",
+ "params": {
+ "compute.algorithm": "scc",
+ "compute.parallel":"10",
+ "output.type":"local",
+ "output.parallel":"1",
+ "output.file_path":"result/scc",
+ "compute.max_step":"200"
+ }
+}
+```
+
+> 🚧, further updates and improvements will be made at any time. Suggestions
and feedback are welcome.
+```
