docs: update

docs/guide/_meta.json

@@ -7,6 +7,6 @@
     {
         "type": "dir",
         "name": "tutorial",
-        "label": "教程"
+        "label": "基础"
     }
 ]

docs/guide/tutorial/api-binding.mdx

@@ -2,7 +2,15 @@
 
 **Author** : **`Leon 李扬`**
 
-欢迎回到 `dora` 教程！到目前为止，我们已经学习了数据流 （ 第 1 章 ）作为应用程序蓝图， 节点 （ 第 2 章 ）和操作符 （ 第 3 章 ）作为构建块， 事件流 （ 第 4 章 ）作为其通信通道，以及数据消息/箭头数据 （ 第 5 章 ）作为高效数据传输的格式。
+欢迎回到 `dora` 教程！到目前为止，我们已经学习了
+
+[第一章：数据流](./dataflow) 作为应用程序蓝图
+
+[第二章：节点](./node) 和 [第三章：操作符](./operator) 作为构建块
+
+[第四章：事件流](./event-stream) 作为其通信通道
+
+[第五章：数据消息/Arrow Data](./data-message) 作为高效数据传输的格式。
 
 现在，我们来谈谈如何实际编写这些节点和操作符的代码 ，让它们完成各自的工作。你用 `Python` 或 `Rust` 编写的自定义逻辑如何连接到 `dora 运行时`来接收输入并发送输出？这时， **`API 绑定`** 就派上用场了。
 
@@ -13,10 +21,10 @@
 您的 `Python` 代码需要特定的工具来：
 
 1. 告诉 `dora` 运行时它已准备好启动。
-2. 监听来自事件流的传入 `INPUT` 事件（ 第 4 章 ）。
-3. 从事件中提取实际图像数据消息 （ 第 5 章 ）。
-4. 将计算出的边界框数据作为新的数据消息 （ 第 5 章 ）发送回运行时，并指定它应该转到哪个输出。
-5. 如果 `dora` 运行时发送了 `STOP` 信号，则知道何时停止（ 第 4 章 ）。
+2. 监听来自事件流的传入 `INPUT` 事件。
+3. 从事件中提取实际图像数据消息。
+4. 将计算出的边界框数据作为新的数据消息发送回运行时，并指定它应该转到哪个输出。
+5. 如果 `dora` 运行时发送了 `STOP` 信号，则知道何时停止。
 
 这些工具以库或模块的形式提供给不同的编程语言，它们被称为 `API 绑定` 。它们是连接自定义应用程序逻辑和 `dora 运行时`环境的软件层。
 
@@ -97,7 +105,7 @@ def process_data(data):
 
 ### 示例 2：使用 `API` 的简单 `Python` 运算符
 
-操作员使用稍微不同的 `API` 结构，专门设计用于 `dora-runtime` 进程（ 第 3 章：操作员 ）。
+操作符使用稍微不同的 `API` 结构，专门设计用于 `dora-runtime` 进程。
 
 ```py
 # operators/my_operator.py
@@ -146,7 +154,7 @@ def process_operator_data(data):
 - `class Operator`: 在 `Python` 中定义运算符的标准方法。
 - `on_event(self, dora_event, send_output)`： `dora-runtime` 期望此特定的方法签名。运行时调用此方法，并传递事件详情（ `dora_event` ）以及特定于此运算符实例的 `send_output` 函数。
 - `dora_event["type"] 、 dora_event["id"] 、 dora_event["value"]`：访问事件详细信息，类似于 `Node API`，但通常直接作为参数提供或嵌套在事件对象中。
-- `send_output("operator_output", processed_data, dora_event["metadata"])`：调用提供的函数来从此特定运算符发送输出数据。然后，运行时会根据数据流 YAML 将此输出路由到同一节点内的其他运算符，或者路由到节点外的其他运算符。
+- `send_output("operator_output", processed_data, dora_event["metadata"])`：调用提供的函数来从此特定运算符发送输出数据。然后，运行时会根据数据流 `YAML` 将此输出路由到同一节点内的其他运算符，或者路由到节点外的其他运算符。
 - `return DoraStatus.CONTINUE / DoraStatus.STOP`：操作符在处理事件后明确向运行时返回状态，指示它们是否应该继续或停止。
 
 您可以在 `Rust` 绑定（ `dora-node-api` 、 `dora-operator-api` ）和 `C/C++` 绑定（通过 `CXX` 和原始 `C FFI` 公开，参见 `apis/rust/node/src/lib.rs` 、 `apis/c++/node/src/lib.rs` 、 `apis/c/node/src/lib.rs` ）中看到类似的 `API` 结构和概念。它们提供了针对特定语言范式定制的相同基本功能（初始化、接收、发送、处理信号）。
@@ -161,7 +169,7 @@ def process_operator_data(data):
 
 1. **事件通道：** 这是 `dora 运行时`向你的 `Node/Operator` 发送事件的地方（即事件流 ）。`API` 绑定的事件循环（ f`or event in node` ）正在监听此通道。
 2. **控制通道：** 这是你的节点/操作员向 `dora 运行时`发送命令的地方（例如“发送此输出”、“我已完成此共享内存块的操作”）。`API` 绑定的 `send_output` 函数使用此通道。
-3. **共享内存：** 如第 5 章所述，对于大数据，数据本身通过共享内存传输，并通过控制通道上的消息进行协调。
+3. **共享内存：** 如第五章所述，对于大数据，数据本身通过共享内存传输，并通过控制通道上的消息进行协调。
 
 这是一个简化的序列图：
 
@@ -175,4 +183,4 @@ def process_operator_data(data):
 
 `API 绑定`是必不可少的软件库，它使您能够使用熟悉的编程语言（例如 P`ython`、`Rust`、`C` 和 `C++`）为自定义 `dora` 节点和操作符编写核心逻辑。它们提供了标准化的函数工具包（ `init` 、 `send_output` 、事件循环/回调），这些函数抽象了进程间通信、共享内存和事件处理的复杂性，使您可以专注于特定的应用程序任务，同时无缝集成到 `dora` 数据流中。
 
-现在您已经了解了如何使用 `API 绑定`为各个组件编写代码，让我们缩小范围并查看用于管理和运行整个数据流的主要工具： `Dora CLI` 。
+现在您已经了解了如何使用 `API 绑定`为各个组件编写代码，让我们缩小范围并查看用于管理和运行整个数据流的主要工具： **`Dora CLI 命令行`** 。

docs/guide/tutorial/data-message.mdx

@@ -2,9 +2,9 @@
 
 **Author** : **`Leon 李扬`**
 
-欢迎回到 `dora` 教程！在第四章：事件流中，我们学习了节点和操作符通过事件流接收信息，包括携带数据的 INPUT 事件。但是，这些数据在事件内部是什么样的 ？ `dora` 又是如何高效地传输这些数据的，尤其是对于图像或传感器读数等大数据项？
+欢迎回到 `dora` 教程！在[第四章：事件流](./event-stream)中，我们学习了节点和操作符通过事件流接收信息，包括携带数据的 INPUT 事件。但是，这些数据在事件内部是什么样的？ `dora` 又是如何高效地传输这些数据的，尤其是对于图像或传感器读数等大数据项？
 
-本章深入探讨 `dora` 数据处理的核心： `数据消息`及其对 `Apache Arrow 格式`的使用。
+本章深入探讨 `dora` 数据处理的核心： `数据消息`及其对 `Apache Arrow` 格式的使用。
 
 ## 对速度的需求：处理大数据
 
@@ -85,7 +85,7 @@ for event in node:
 1. `节点 A` 以 `Apache Arrow` 格式准备数据。
 2. `节点 A` 告诉 `dora 运行时`（通过控制通道）它想要在特定的输出上发送该数据。
 3. `dora 运行时`分配了一块共享内存。这块内存`节点 A` 和`节点 B` 进程都可以访问。
-4.`节点 A` 将 Arrow 格式的数据写入此共享内存块。
+4. `节点 A` 将 Arrow 格式的数据写入此共享内存块。
 5. 然后， `dora 运行时`向`节点 B` 发送一个 INPUT 事件。此事件不包含数据本身，而是包含数据所在的共享内存块的引用或标识符 ，以及 `Arrow` 结构信息（类型、大小、布局）， `dora` 其称为 `ArrowTypeInfo` ，是消息 `Metadata` 的一部分。
 6. `节点 B` 收到 `INPUT` 事件，从 `Metadata` 中读取共享内存标识符和 `ArrowTypeInfo` 。
 7. `节点 B` 使用其 `dora API` 访问数据。该 `API` 知道如何将共享内存块映射（使其可访问）到`节点 B` 的进程中，并使用 Arrow 格式信息直接从那里读取数据。
@@ -122,4 +122,4 @@ for event in node:
 
 在本章中，我们了解到 `dora` 中的数据是通过 `INPUT` 数据消息在节点和算子之间传递的。为了实现高性能，尤其是在处理大数据量时， `dora` 主要使用 `Apache Arrow` 格式，并利用共享内存在进程间实现零拷贝数据传输。这意味着接收节点可以直接从发送节点写入的同一内存位置读取数据。`Drop Token` 机制确保此共享内存得到安全管理，并且仅在所有接收节点都处理完数据后才会释放。理解这些概念是理解 `dora` 在实时数据管道中性能特征的关键。
 
-现在您已经了解了数据如何流动和表示，让我们看看您将用来在 `Node` 或 `Operator` 代码中与 `dora 运行时`进行交互的工具： `API 绑定` 。
+现在您已经了解了数据如何流动和表示，让我们看看您将用来在 `Node` 或 `Operator` 代码中与 `dora 运行时`进行交互的工具： **`API Bingding 绑定`** 。

docs/guide/tutorial/dataflow.mdx

@@ -129,4 +129,4 @@ dora run dataflow.yml
 
 在本节中，我们了解到数据流是 `dora` 应用程序的蓝图，它定义了节点以及数据在节点之间的流动方式。它由 `YAML` 文件描述，类似于管道图，显示了一个节点的输出与另一个节点的输入之间的连接。当您使用 `dora CLI` 运行数据流时， `dora` 会读取此蓝图并设置必要的通信通道。
 
-现在您已经了解了整体数据流蓝图，下一章让我们深入了解构成该蓝图的各个构建块： **节点** 。
+现在您已经了解了整体数据流蓝图，下一章让我们深入了解构成该蓝图的各个构建块： **`Node 节点`** 。

docs/guide/tutorial/dora-cli.mdx

@@ -2,9 +2,9 @@
 
 **Author** : **`Leon 李扬`**
 
-欢迎回到 `dora` 教程！在上一章， [第六章：API 绑定](./api-binding.mdx)中，我们了解了如何使用特定语言的库为自定义节点和操作符编写实际代码，以便与 `dora` 运行时进行通信。
+欢迎回到 `dora` 教程！在上一章， [第六章：API 绑定](./api-binding) 中，我们了解了如何使用特定语言的库为自定义节点和操作符编写实际代码，以便与 `dora` 运行时进行通信。
 
-但是，如何才能将完成的 `Dataflow 蓝图`（`YAML` 文件）和 `Node/Operator` 代码真正地运行在 `dora` 上呢？如何让 `dora` 启动、停止所有操作，或者查看哪些程序正在运行？
+但是，如何才能将完成的 `Dataflow` 和 `Node/Operator` 代码真正地运行在 `dora` 上呢？如何让 `dora` 启动、停止所有操作，或者查看哪些程序正在运行？
 
 这就是 `Dora CLI` 的作用所在！
 
@@ -16,7 +16,7 @@
 
 您可以使用 `CLI` 执行以下基本任务：
 
-- 根据 YAML 蓝图启动数据流。
+- 根据 `YAML` 蓝图启动数据流。
 - 停止正在运行的数据流。
 - 为您的节点准备必要的代码和依赖项。
 - 列出当前正在运行的数据流。
@@ -75,7 +75,7 @@ dora run yolo.yml
 
 您的数据流应用程序现已运行！终端中的输出将显示来自不同 Node 进程的日志。
 
-要停止数据流，通常在执行 `dora run` 终端中按下 `Ctrl + C` 会向运行时发送信号，运行时会向所有节点发送 `STOP` 事件（ 参见[第四章：事件流](./event-stream.mdx) ），使它们能够正常关闭。
+要停止数据流，通常在执行 `dora run` 终端中按下 `Ctrl + C` 会向运行时发送信号，运行时会向所有节点发送 `STOP` 事件，使它们能够正常关闭。
 
 ## 准备依赖项： `dora build` 命令
 
@@ -147,7 +147,7 @@ dora destroy
 
 ## CLI 的工作原理
 
-需要注意的是， `dora CLI` 工具（ `dora` 可执行文件） 并非 `dora 运行时`本身。 `dora 运行时`由一个或多个后台进程组成，通常包括 `Dora Daemon` 和 `Dora Coordinator` （我们将在下一章中详细解释这些进程）。
+需要注意的是， `dora CLI` 工具（ `dora` 可执行文件） 并非 `dora 运行时`本身。 `dora 运行时`由一个或多个后台进程组成，通常包括 `Dora Daemon` 和 `Dora Coordinator`。
 
 当你输入像 `dora run yolo.yml` 这样的命令时：
 
@@ -169,4 +169,4 @@ dora destroy
 
 `Dora CLI` 是您与 `dora` 系统交互的主要工具。您可以使用简单的命令，例如 `dora run` 根据 `Dataflow YAML` 蓝图启动数据流，使用 `dora build` 准备依赖项，以及使用 `dora stop` 和 `dora list` 管理正在运行的应用程序。`CLI` 充当命令接口，与 `dora 运行时`进程（例如 `Dora Coordinator` ）通信，告诉它们执行操作，而不是直接运行数据流。
 
-现在您已经了解了如何使用 `CLI` 命令 `dora` ，让我们深入了解接收这些命令并管理运行节点的关键组件之一： `Dora Daemon` 。
+现在您已经了解了如何使用 `CLI` 命令 `dora` ，让我们深入了解接收这些命令并管理运行节点的关键组件之一： **`Dora Daemon 守候进程`** 。

docs/guide/tutorial/dora-coordinator.mdx

@@ -2,14 +2,15 @@
 
 **Author** : **`Leon 李扬`**
 
-欢迎来到 `dora` 教程的最后一章！在本教程中，我们学习了`数据流蓝图`、`模块化节点`和`操作符` ，以及它们如何通过事件流进行通信并高效地传输数`据消息/Arrow Data` 。我们还了解了如何使用 `API` 绑定编写逻辑，以及如何使用 `Dora CLI` 作为命令行界面。最近，在[第八章：Dora 守护进程](./dora-daemon.mdx)中，我们学习了 `Dora` 守护进程，它是在单台机器上本地管理 `dora` 组件的后台服务。
+欢迎来到 `dora` 教程的最后一章！在本教程中，我们学习了`数据流`、`节点`和`操作符` ，以及它们如何通过事件流进行通信并高效地传输数`据消息/Arrow Data`。
+我们还了解了如何使用 `API` 绑定编写逻辑，以及如何使用 `Dora CLI` 作为命令行界面。最近，在 [第八章：Dora 守护进程](./dora-daemon) 中，我们学习了 `Dora` 守护进程，它是在单台机器上本地管理 `dora` 组件的后台服务。
 
 但是，当你的应用程序变得更大，需要使用分布在多台计算机上的传感器、处理器或硬件时，会发生什么情况呢？例如，你可能会遇到：
 
 - 一个机器人上的一个摄像头。
 - 在强大的台式计算机上运行的重型 AI 模型。
 - 另一块硬件上的电机控制器。
--笔记本电脑上的可视化显示。
+- 笔记本电脑上的可视化显示。
 
 您的 `Dataflow` 需要跨越所有这些机器。您将在每台机器上运行一个 `Dora Daemon` 来管理本地节点 。但是，如何让系统在正确的机器上启动正确的节点 ，协调它们之间通过网络的通信，并管理这个分布式应用程序的整个生命周期呢？
 
@@ -35,7 +36,7 @@
 
 然而，当你定义一个跨多台机器的数据流时，协调器就变得至关重要，并且需要明确指定。你可以使用数据流 `YAML` 文件中的 `_unstable_deploy: machine` 字段来告诉 `dora` 每个节点应该在哪里运行。
 
-以下是分布式数据流的简化示例 YAML：
+以下是分布式数据流的简化示例 `YAML`：
 
 ```yaml
 nodes:
@@ -91,7 +92,7 @@ dora run distributed_dataflow.yml --coordinator-addr 192.168.1.100
 6. 协调器向 `robot-machine-A` 上的守护进程发送指令以启动 `camera-robot` 节点。
 7. 协调器向 `desktop-machine-B` 上的守护进程发送指令以启动 `object-detector-pc` 节点。
 8. 协调器向 `laptop-machine-C` 上的守护进程发送指令以启动 `plot-laptop` 节点。
-9. 协调器还确保正确设置底层分布式通信层（如 Zenoh），以便数据在承载连接节点的守护进程之间流动（ `camera-robot` 输出 -> `object-detector-pc` 输入、 `camera-robot` 输出 -> `plot-laptop` 输入、 `object-detector-pc` 输出 -> `plot-laptop` 输入）。
+9. 协调器还确保正确设置底层分布式通信层（如 `Zenoh`），以便数据在承载连接节点的守护进程之间流动（ `camera-robot` 输出 -> `object-detector-pc` 输入、 `camera-robot` 输出 -> `plot-laptop` 输入、 `object-detector-pc` 输出 -> `plot-laptop` 输入）。
 10. 协调器继续运行，监视守护进程和数据流的状态，并将状态或日志消息（如果需要）传回 `CLI`。
 
 要停止此分布式数据流，您可以再次使用 `CLI`，告诉它与哪个协调器对话：
@@ -135,4 +136,4 @@ dora stop my_dataflow_id --coordinator-addr 192.168.1.100
 
 `Dora Coordinator` 是 `dora` 系统的中央编排器和指挥中心，对于管理分布在多台机器上的数据流至关重要。它接收来自 `Dora CLI` 的指令，跟踪可用的 `Dora Daemons` ，并根据数据流 YAML 蓝图协调在正确的机器上启动、停止和管理节点 。通过监督分布式系统，它使您能够无缝构建和管理复杂的多机器应用程序。
 
-至此，我们对 `dora` 核心概念的入门教程就结束了。我们介绍了`蓝图（数据流）`、`构建块（节点、操作符）`、`通信机制（事件流、数据消息/Arrow Data、API 绑定）`以及`运行时基础架构（命令行界面、守护进程、协调器）`。现在，您对 `dora` 工作原理及其主要组件的作用有了基本的了解，这将帮助您更深入地构建自己的实时数据流应用程序。
+至此，我们对 `dora` 核心概念的入门教程就结束了。我们介绍了`数据流`、`构建块（节点、操作符）`、`通信机制（事件流、数据消息/Arrow Data、API 绑定）`以及`运行时基础架构（命令行界面、守护进程、协调器）`。现在，您对 `dora` 工作原理及其主要组件的作用有了基本的了解，这将帮助您更深入地构建自己的实时数据流应用程序。

docs/guide/tutorial/dora-daemon.mdx

@@ -2,9 +2,14 @@
 
 **Author** : **`Leon 李扬`**
 
-欢迎回到 `dora` 教程！我们探索了 `Dataflow 蓝图`、 `节点`和`操作符`等构建块，它们如何通过事件流接收信息，以及如何高效地传输`数据消息/Arrow Data` 。我们还了解了 `API 绑定`如何帮助您编写组件代码，以及 `Dora CLI` 如何成为您管理一切的主要工具。
+欢迎回到 `dora` 教程！我们探索了 `Dataflow`、 `节点` 和 `操作符` 等构建块，它们如何通过事件流接收信息，以及如何高效地传输 `数据消息/Arrow Data`。
 
-当您使用 `Dora CLI` 运行类似 `dora run` 命令时，实际上是在告诉 `dora` 执行您的数据流。但是，`CLI` 程序本身并不是运行节点和管理所有复杂通信的程序。这项工作落到了构成 `dora` 运行时的后台进程身上。这些后台进程中最重要的一个，尤其是在单机上运行的 `Dora 守护进程 (Dora Daemon)` 就是它。
+我们还了解了 `API 绑定`如何帮助您编写组件代码，以及 `Dora CLI` 如何成为您管理一切的主要工具。
+
+当您使用 `Dora CLI` 运行类似 `dora run` 命令时，实际上是在告诉 `dora` 执行您的数据流。但是，`CLI` 程序本身并不是运行节点和管理所有复杂通信的程序。
+这项工作落到了构成 `dora` 运行时的后台进程身上。
+
+这些后台进程中最重要的一个，尤其是在单机上运行的 **`Dora 守护进程 (Dora Daemon)`** 就是它。
 
 ## 本地交通经理
 
@@ -87,5 +92,5 @@ dora run yolo.yml
 
 `Dora Daemon` 是 `dora` 运行时的关键组件。它充当机器上的本地管理器，负责启动和监控分配给它的 `Node` 进程，最重要的是，它基于 `Dataflow YAML` 建立和管理它们之间高效的本地通信通道（例如共享内存） 。它接收来自 `Dora CLI` 或 `Dora Coordinator` 的指令，并确保数据流量在其本地机器上正确流动。
 
-现在我们了解了本地管理器（守护进程），让我们了解一下协调多个守护进程并管理跨不同机器的数据流的组件： `Dora Coordinator` 。
+现在我们了解了本地管理器（守护进程），让我们了解一下协调多个守护进程并管理跨不同机器的数据流的组件： **`Dora Coordinator 协调器`** 。
 

docs/guide/tutorial/event-stream.mdx

@@ -2,7 +2,9 @@
 
 **Author** : **`Leon 李扬`**
 
-欢迎回到 `dora` 教程！在第二章：节点中，我们了解到节点是数据流中独立的工作单元。在第三章：操作符中，我们了解了操作符如何在一种特殊的节点内部构建工作。节点和操作符都需要一种方法来感知需要关注的事件发生——例如新数据到达或停止命令。它们是如何接收这些重要通知的？
+欢迎回到 `dora` 教程！在[第二章：节点](./node)中，我们了解到节点是数据流中独立的工作单元。在[第三章：操作符](./operator)中，我们了解了操作符如何在一种特殊的节点内部构建工作。
+
+`节点`和`操作符`都需要一种方法来感知需要关注的事件发生——例如新数据到达或停止命令。它们是如何接收这些重要通知的？
 
 这就是 **`事件流`** 发挥作用的地方。
 
@@ -16,7 +18,7 @@
 
 ## 事件流中包含哪些类型的消息？
 
-事件流不仅仅用于传入数据。它包含不同类型的消息， `dora` 称之为 “事件” 。这些事件会告诉您的节点或操作员数据流和系统中正在发生的事情。
+事件流不仅仅用于传入数据。它包含不同类型的消息， `dora` 称之为 **“事件”** 。这些事件会告诉您的节点或操作员数据流和系统中正在发生的事情。
 
 以下是您通常会在信息流中发现的主要事件类型：
 
@@ -106,6 +108,6 @@ print("Node stopping gracefully.")
 
 ## 总结
 
-`事件流`是 `dora` 中的一个基本概念。它是节点和操作符接收其运行所需的所有信息的重要通信渠道，包括传入数据 ( `INPUT` )、输入源关闭信号 ( `InputClosed` ) 以及系统命令（ `STOP` 、 `RELOAD` ）。通过监听此事件流，您的节点和操作符代码可以动态地响应数据流的状态。`dora` 运行管理这些事件流，并根据数据流蓝图将事件传递给相应的节点和操作符。
+`事件流` 是 `dora` 中的一个基本概念。它是节点和操作符接收其运行所需的所有信息的重要通信渠道，包括传入数据 ( `INPUT` )、输入源关闭信号 ( `InputClosed` ) 以及系统命令（ `STOP` 、 `RELOAD` ）。通过监听此事件流，您的节点和操作符代码可以动态地响应数据流的状态。`dora` 运行管理这些事件流，并根据数据流蓝图将事件传递给相应的节点和操作符。
 
-现在您已经了解了节点和操作员如何接收通知，让我们仔细看看 `INPUT` 事件中经常包含的 `数据本身` 。
+现在您已经了解了节点和操作员如何接收通知，让我们仔细看看 `INPUT` 事件中经常包含的 **`DataMessage/Arrow Data 数据`** 本身 。

docs/guide/tutorial/node.mdx

@@ -124,4 +124,4 @@ print("Node stopping.")
 
 在本章中，我们了解到节点是 `dora` 数据流应用程序中独立的工作单元。它们在数据流 `YAML` 文件中定义，具有唯一的 `ID`、用于接收数据的特定输入以及用于生成数据的输出。每个节点都作为独立的进程运行，其内部逻辑（使用您选择的语言编写的 `dora API`）负责接收输入、执行任务和发送输出。`Dora 运行时`负责启动这些进程并根据 `YAML` 蓝图设置通信管道。
 
-现在我们了解了各个处理单元（节点），让我们看一下在节点内部构建逻辑的常用方法，特别是在处理许多输入和输出时： **操作符** 的概念。
+现在我们了解了各个处理单元（节点），让我们看一下在节点内部构建逻辑的常用方法，特别是在处理许多输入和输出时： **`Operator 操作符`** 的概念。

docs/guide/tutorial/operator.mdx

@@ -2,7 +2,7 @@
 
 **Author** : **`Leon 李扬`**
 
-欢迎回来！在第一章：数据流中，我们学习了 `dora` 应用程序的整体蓝图以及它如何连接各个部分。在第二章：节点中，我们深入探讨了这些节点部分，并了解到每个节点通常作为一个独立的进程运行，执行特定的任务，并通过数据流 `YAML` 中定义的输入和输出进行通信。
+欢迎回来！在[第一章：数据流](./dataflow)中，我们学习了 `dora` 应用程序的整体蓝图以及它如何连接各个部分。在[第二章：节点](./node)中，我们深入探讨了这些节点部分，并了解到每个节点通常作为一个独立的进程运行，执行特定的任务，并通过数据流 `YAML` 中定义的输入和输出进行通信。
 
 现在，让我们探索一种在 `Node` 内部添加更多结构和可重用性的方法： `Operator` 的概念。
 
@@ -25,13 +25,13 @@
 
 让我们快速比较一下：
 
-| 特征          | 自定义节点                        | Dora 运行时节点和操作符 |
-| :--------------- | :--------------------------------- | :------------------------------- |
-| **运行方式**   | 独立节点                | 单进程 |
-| **包含**  | 一段自定义的代码      | 一个或多个操作符            |
-| **逻辑单元**   | 整个节点代码             | 单个操作符             |
-| **通讯**| 使用 `dora Node API` 直接与 `dora` 系统交互 | 节点运行时使用 `dora Node API`; 操作符使用 `dora Operator API` |
-| **可重用性**  | 重用整个 `Node` 进程     | 重复使用单个操作符逻辑模块 |
+| 特征         | 自定义节点                                  | Dora 运行时节点和操作符                                        |
+| :----------- | :------------------------------------------ | :------------------------------------------------------------- |
+| **运行方式** | 独立节点                                    | 单进程                                                         |
+| **包含**     | 一段自定义的代码                            | 一个或多个操作符                                               |
+| **逻辑单元** | 整个节点代码                                | 单个操作符                                                     |
+| **通讯**     | 使用 `dora Node API` 直接与 `dora` 系统交互 | 节点运行时使用 `dora Node API`; 操作符使用 `dora Operator API` |
+| **可重用性** | 重用整个 `Node` 进程                        | 重复使用单个操作符逻辑模块                                     |
 
 因此，虽然自定义节点是其自己独立的程序（ `.py` 、 `.rs` 可执行文件等），但 `Dora 运行时` 节点是一个运行 `dora-runtime` 程序的进程，然后加载和管理数据流 `YAML` 中指定的一个或多个操作员的代码。
 
@@ -187,5 +187,5 @@ class Operator:
 
 在本章中，我们了解到 `Operator` 是运行在 `Dora Runtime` 节点进程中的模块化逻辑。它们在 `Dataflow YAML` 的 `Node` 块中定义，允许您在单个节点内构建复杂的处理流水线。`Operator` 使用 `Operator API` 接收输入并发送输出， `dora-runtime` 负责加载它们、在它们之间建立内部通信，以及在节点的外部输入/输出和 `Operator` 的输入/输出之间路由数据。这提供了一种创建可复用处理步骤的方法。
 
-现在我们了解了节点和操作符，让我们看看数据在系统中移动的基本概念： **事件流** 。
+现在我们了解了节点和操作符，让我们看看数据在系统中移动的基本概念： **`Event Stream 事件流`** 。