chore: update docs

Change-Id: I1ad09e9f66080cc513dea144e7c1797deac6b791

Author: shentongmartin

assets/js/mermaid.js

@@ -34,18 +34,21 @@
             directive = '%%{init: ' + JSON.stringify(cfg) + '}%%\n';
             body = text.replace(fm[0], '');
         }
+        var isV10 = typeof mermaid !== 'undefined' && mermaid.version && parseInt(mermaid.version.split('.')[0], 10) >= 10;
         body = body.replace(/<br\s*\/?>(?![^`]*`)/gi, '\\n');
-        body = body.split('\n').map(function(line) {
-            var m = line.match(/^\s*([A-Za-z0-9_]+)\s*@\{\s*([^}]*)\s*\}\s*$/);
-            if (m) {
-                var id = m[1];
-                var props = m[2];
-                var lm = props.match(/label\s*:\s*("[^"]*"|'[^']*'|[^,]+)/);
-                var label = lm ? lm[1].replace(/^['"]|['"]$/g, '') : id;
-                return id + '["' + label + '"]';
-            }
-            return line;
-        }).join('\n');
+        if (!isV10) {
+            body = body.split('\n').map(function(line) {
+                var m = line.match(/^\s*([A-Za-z0-9_]+)\s*@\{\s*([^}]*)\s*\}\s*$/);
+                if (m) {
+                    var id = m[1];
+                    var props = m[2];
+                    var lm = props.match(/label\s*:\s*("[^"]*"|'[^']*'|[^,]+)/);
+                    var label = lm ? lm[1].replace(/^['"]|['"]$/g, '') : id;
+                    return id + '["' + label + '"]';
+                }
+                return line;
+            }).join('\n');
+        }
         return directive + body;
     }
 

config.toml

@@ -165,7 +165,7 @@ prism_syntax_highlighting = true
 [params.mermaid]
 enable = true
 theme = "default"
-securitylevel = "strict"
+securitylevel = "loose"
 
 # User interface configuration
 [params.ui]

content/en/docs/eino/core_modules/_index.md

@@ -1,26 +1,22 @@
 ---
 Description: ""
-date: "2025-02-11"
+date: "2025-07-21"
 lastmod: ""
 tags: []
-title: 'Eino: Core Modules'
+title: 'Eino: 核心模块'
 weight: 3
 ---
 
-The core modules in Eino include the following parts:
+Eino 中的核心模块有如下几个部分：
 
-- **Components**: [Eino: Components](/docs/eino/core_modules/components)
+- **Components 组件**：[Eino: Components 组件](/zh/docs/eino/core_modules/components)
 
-Eino abstracts commonly used components in LLM applications, such as `ChatModel`, `Embedding`, `Retriever`, etc. These are the building blocks for constructing an LLM application, forming the foundation of application capabilities and serving as atomic objects for complex logic orchestration.
+Eino 抽象出来的大模型应用中常用的组件，例如 `ChatModel`、`Embedding`、`Retriever` 等，这是实现一个大模型应用搭建的积木，是应用能力的基础，也是复杂逻辑编排时的原子对象。
 
-- **Chain/Graph Orchestration**: [Eino: Chain & Graph Orchestration](/docs/eino/core_modules/chain_and_graph_orchestration)
+- **Chain/Graph 编排**：[Eino: Chain/Graph 编排功能](/zh/docs/eino/core_modules/chain_and_graph_orchestration/chain_graph_introduction)
 
-Using multiple components in combination to implement the chain of business logic, Eino provides orchestration methods through Chains/Graphs, encapsulating the complexity of linking business logic within Eino itself. It offers easy-to-understand business logic orchestration interfaces and provides a unified cross-sectional governance capability.
+多个组件混合使用来实现业务逻辑的串联，Eino 提供 Chain/Graph 的编排方式，把业务逻辑串联的复杂度封装在了 Eino 内部，提供易于理解的业务逻辑编排接口，提供统一的横切面治理能力。
 
-- **Flow Integration Tools (Agents)**: [Eino: Flow integration components](/docs/eino/core_modules/flow_integration_components)
+- **Flow 集成工具 (agents)**: [Eino: Flow 集成组件](/zh/docs/eino/core_modules/flow_integration_components)
 
-Eino packages the most commonly used LLM application modes into simple and easy-to-use tools, ultra-simplifying the development of LLM applications for generic scenarios. Currently, it provides `ReAct Agent` and `Host Multi Agent`.
-
-- **EinoDev Development Assistant Tool**: [EinoDev: Devops tools](/docs/eino/core_modules/devops)
-
-Eino is dedicated to making the development of large-scale model applications with full-code very simple, and EinoDev provides a `visual` and `interactive` development and debugging solution for Eino orchestration, which allows developers to see the results immediately, releasing their energy from the `debugging hell` and focusing on the scene logic.
+Eino 把最常用的大模型应用模式封装成简单、易用的工具，让通用场景的大模型应用开发极致简化，目前提供了 `ReAct Agent` 和 `Host Multi Agent`。

content/en/docs/eino/core_modules/chain_and_graph_orchestration/_index.md

@@ -1,57 +1,57 @@
 ---
 Description: ""
-date: "2025-02-11"
+date: "2025-07-21"
 lastmod: ""
 tags: []
-title: 'Eino: Chain & Graph & Workflow Orchestration'
-weight: 0
+title: 'Eino: Chain & Graph & Workflow 编排功能'
+weight: 2
 ---
 
-In LLM applications, `Components` are the smallest units that provide "atomic capabilities," such as:
+在大模型应用中，`Components` 组件是提供 『原子能力』的最小单元，比如：
 
-- `ChatModel` provides the conversation capability of LLM
-- `Embedding` provides semantic-based text vectorization capabilities
-- `Retriever` provides relevant content retrieval capabilities
-- `ToolsNode` provides the capability to execute external tools
+- `ChatModel` 提供了大模型的对话能力
+- `Embedding` 提供了基于语义的文本向量化能力
+- `Retriever` 提供了关联内容召回的能力
+- `ToolsNode` 提供了执行外部工具的能力
 
-> For detailed information on components, refer to: [Eino: Components](/docs/eino/core_modules/components)
+> 详细的组件介绍可以参考: [Eino: Components 组件](/zh/docs/eino/core_modules/components)
 
-An LLM application, in addition to needing these atomic capabilities, also needs to **combine and sequence** these atomic capabilities based on contextual business logic. This is called **Orchestration**.
+一个大模型应用，除了需要这些原子能力之外，还需要根据场景化的业务逻辑，**对这些原子能力进行组合、串联**，这就是 **『编排』**。
 
-Developing LLM applications has its own typical characteristics: The custom business logic itself is usually not very complex, primarily involving the combination and sequencing of "atomic capabilities."
+大模型应用的开发有其自身典型的特征： 自定义的业务逻辑本身不会很复杂，几乎主要都是对『原子能力』的组合串联。
 
-In traditional code development, business logic is expressed through "code execution logic." When transitioning to LLM application development, the most straightforward approach is "to call components manually and use the results as inputs for subsequent component calls." Such an approach results in `messy code`, `difficulty in reuse`, and `lack of aspect-oriented capabilities`...
+传统代码开发过程中，业务逻辑用 “代码的执行逻辑” 来表达，迁移到大模型应用开发中时，最直接想到的方法就是 “自行调用组件，自行把结果作为下一组件的输入进行调用”。这样的结果，就是 `代码杂乱`、`很难复用`、`没有切面能力`……
 
-When developers pursue code that is '**elegant**' and follows the '**clean code principles**,' they find a significant gap when applying traditional code organization methods to LLM applications.
+当开发者们追求代码『**优雅**』和『**整洁之道**』时，就发现把传统代码组织方式用到大模型应用中时有着巨大的鸿沟。
 
-Eino's initial goal was to make LLM application development extremely simple, ensuring that the application code logic is "simple," "intuitive," "elegant," and "robust."
+Eino 的初衷是让大模型应用开发变得非常简单，就一定要让应用的代码逻辑 “简单” “直观” “优雅” “健壮”。
 
-Eino has the following insights into "Orchestration":
+Eino 对「编排」有着这样的洞察：
 
-- Orchestration should become a clear layer on top of business logic, **without embedding business logic into orchestration**.
-- The core of the LLM application is "sequencing and combining components that provide atomic capabilities," **with components being the "first citizens" of orchestration**.
-- From an abstract perspective, orchestration builds a network where data flows through. Each node within the network has specific format/content requirements for the flowing data. The key to a seamlessly flowing data network is "**whether the data formats between upstream and downstream nodes are aligned**?".
-- The complexity of business scenarios will be reflected in the complexity of orchestration artifacts. Only **horizontal governance capabilities** can keep complex scenarios under control.
-- LLMs will continue to develop rapidly, and so will LLM applications. Only applications with **expansion capabilities** will have vitality.
+- 编排要成为在业务逻辑之上的清晰的一层，**不能让业务逻辑融入到编排中**。
+- 大模型应用的核心是 “对提供原子能力的组件” 进行组合串联，**组件是编排的 “第一公民”**。
+- 抽象视角看编排：编排是在构建一张网络，数据则在这个网络中流动，网络的每个节点都对流动的数据有格式/内容的要求，一个能顺畅流动的数据网络，关键就是 “**上下游节点间的数据格式是否对齐**？”。
+- 业务场景的复杂度会反映在编排产物的复杂性上，只有**横向的治理能力**才能让复杂场景不失控。
+- 大模型是会持续保持高速发展的，大模型应用也是，只有**具备扩展能力的应用才拥有生命力**。
 
-Therefore, Eino provides a solution for "orchestration based on the Graph model (node + edge), with **components** as atomic nodes and **upstream-downstream type alignment** as the foundation."
+于是，Eino 提供了 “基于 Graph 模型 (node + edge) 的，以**组件**为原子节点的，以**上下游类型对齐**为基础的编排” 的解决方案。
 
-Specifically, the following features are implemented:
+具体来说，实现了如下特性：
 
-- Everything is centered around "components," standardizing the encapsulation of business functionalities, making **division of responsibilities clear** and **reuse** natural.
-  - For more details, refer to: [Eino: Components](/docs/eino/core_modules/components)
-- The complexity of business logic is encapsulated within the components, giving the orchestration layer a more global perspective, making **logic layers very clear**.
-- Provides aspect capabilities and a callback mechanism that supports node-based **unified governance capabilities**.
-  - For more details, refer to: [Eino: Callback Manual](/docs/eino/core_modules/chain_and_graph_orchestration/callback_manual)
-- Provides a call option mechanism, **extensibility** is the most fundamental requirement of the system in rapid iterations.
-  - For more details, refer to: [Eino: CallOption capabilities and specification](/docs/eino/core_modules/chain_and_graph_orchestration/call_option_capabilities)
-- Provides an enhanced "type alignment" development method, reducing the mental burden on developers and leveraging Go's **type safety** features.
-  - For more details, refer to: [Eino: The design concept of orchestration](/docs/eino/core_modules/chain_and_graph_orchestration/orchestration_design_principles)
-- Provides an **"automated stream conversion"** capability, removing "stream" from the "source of complexity ranking" in the orchestration system.
-  - For more details, refer to: [Eino Points of Streaming Orchestration](/docs/eino/core_modules/chain_and_graph_orchestration/stream_programming_essentials)
+- 一切以 “组件” 为核心，规范了业务功能的封装方式，让**职责划分变得清晰**，让**复用**变成自然而然
+  - 详细信息参考：[Eino: Components 组件](/zh/docs/eino/core_modules/components)
+- 业务逻辑复杂度封装到组件内部，编排层拥有更全局的视角，让**逻辑层次变得非常清晰**
+- 提供了切面能力，callback 机制支持了基于节点的**统一治理能力**
+  - 详细信息参考：[Eino: Callback 用户手册](/zh/docs/eino/core_modules/chain_and_graph_orchestration/callback_manual)
+- 提供了 call option 的机制，**扩展性**是快速迭代中的系统最基本的诉求
+  - 详细信息参考：[Eino: CallOption 能力与规范](/zh/docs/eino/core_modules/chain_and_graph_orchestration/call_option_capabilities)
+- 提供了 “类型对齐” 的开发方式的强化，降低开发者心智负担，把 golang 的**类型安全**特性发挥出来
+  - 详细信息参考：[Eino: 编排的设计理念](/zh/docs/eino/core_modules/chain_and_graph_orchestration/orchestration_design_principles)
+- 提供了 “**流的自动转换**” 能力，让 “流” 在「编排系统的复杂性来源榜」中除名
+  - 详细信息参考：[Eino 流式编程要点](/zh/docs/eino/core_modules/chain_and_graph_orchestration/stream_programming_essentials)
 
-Graph itself is powerful and semantically complete, capable of rendering almost any "data flow network," such as "branching," "parallel," and "loop."
+Graph 本身是强大且语义完备的，可以用这项底层几乎绘制出所有的 “数据流动网络”，比如 “分支”、“并行”、“循环”。
 
-However, Graph is not without its drawbacks. Based on the "node" and "edge" model, Graph requires developers to use the `graph.AddXXXNode()` and `graph.AddEdge()` interfaces to create a data channel, which is powerful but somewhat complex.
+但 Graph 并不是没有缺点的，基于 “点” “边” 模型的 Graph 在使用时，要求开发者要使用 `graph.AddXXXNode()` 和 `graph.AddEdge()` 两个接口来创建一个数据通道，强大但是略显复杂。
 
-In most real-world business scenarios, simply "connecting in sequence" is often sufficient. Therefore, Eino encapsulates an easier-to-use interface called `Chain`. Chain is a wrapper around Graph, exposing almost all of Graph's capabilities except for "loops."
+而在现实的大多数业务场景中，往往仅需要 “按顺序串联” 即可，因此，Eino 封装了接口更易于使用的 `Chain`。Chain 是对 Graph 的封装，除了 “环” 之外，Chain 暴露了几乎所有 Graph 的能力。