1
 1|# 智能代理
2
 2|
3
 3|> 原文：[智能代理](https://docs.dify.ai/zh/use-dify/nodes/agent)
4
 4|
5
 5|---
6
 6|
7
 7|## Documentation IndexFetch the complete documentation index at:[https://docs.dify.ai/llms.txt](https://docs.dify.ai/llms.txt)
8
 8|
9
 9|
10
10|> ⚠️ ⚠️ 本文档由 AI 自动翻译。如有任何不准确之处，请参考[英文原版](/en/use-dify/nodes/agent)。
11
11|
12
12|智能代理节点让你的大型语言模型自主控制工具，使其能够迭代决定使用哪些工具以及何时使用它们。智能代理不是预先规划每一步，而是动态地推理问题，根据需要调用工具来完成复杂任务。
13
13|
14
14|
15
15|## 智能代理策略智能代理策略定义了你的智能代理如何思考和行动。选择最适合你的模型能力和任务需求的方法。
16
16|
17
17|
18
18|- 函数调用
19
19|- 推理与行动 (ReAct):first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0" data-component-part="tab-content"> 使用大型语言模型的原生函数调用能力，通过工具参数直接传递工具定义。大型语言模型使用其内置机制决定何时以及如何调用工具。
20
20|
21
21|最适合像 GPT-4、Claude 3.5 和其他具有强大函数调用支持的模型。
22
22|
23
23|:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0 hidden" data-component-part="tab-content"> 使用结构化提示词来引导大型语言模型通过明确的推理步骤。遵循 ** 思维 → 行动 → 观察 ** 循环进行透明的决策制定。
24
24|
25
25|适用于可能没有原生函数调用能力的模型，或者当你需要明确推理轨迹时。
26
26|
27
27|
28
28|> 💡 从 ** 应用市场 → 智能代理策略 ** 安装其他策略，或向[社区仓库](https://github.com/langgenius/dify-plugins) 贡献自定义策略。
29
29|
30
30|
31
31|## 配置
32
32|### 模型选择选择支持你所选智能代理策略的大型语言模型。更强大的模型能更好地处理复杂推理，但每次迭代成本更高。如果使用函数调用策略，请确保你的模型支持函数调用。
33
33|
34
34|
35
35|### 工具配置配置你的智能代理可以访问的工具。每个工具需要：
36
36|
37
37|** 授权 **- 在工作空间中配置的外部服务的 API 密钥和凭据
38
38|
39
39|** 描述 **- 清楚说明工具的作用以及何时使用它（这指导智能代理的决策制定）
40
40|
41
41|** 参数 **- 工具接受的必需和可选输入，带有适当的验证
42
42|
43
43|
44
44|### 指令和上下文使用自然语言指令定义智能代理的角色、目标和上下文。使用 Jinja2 语法引用上游工作流节点的变量。
45
45|
46
46|** 查询 ** 指定智能代理应该处理的用户输入或任务。这可以是来自先前工作流节点的动态内容。
47
47|
48
48|
49
49|### 执行控制 ** 最大迭代次数 ** 设置安全限制以防止无限循环。根据任务复杂性进行配置 - 简单任务需要 3-5 次迭代，而复杂研究可能需要 10-15 次。
50
50|
51
51|** 记忆 ** 控制智能代理使用 TokenBufferMemory 记提供更多上下文，但会增加标记成本。这使得对话连续性成为可能，用户可以引用以前的行动。
52
52|
53
53|
54
54|### 工具参数自动生成工具可以将参数配置为 ** 自动生成 ** 或 ** 手动输入 **。自动生成的参数（`auto: false`）由智能代理自动填充，而手动输入参数需要明确的值，这些值成为工具永久配置的一部分。
55
55|
56
56|
57
57|## 输出变量智能代理节点提供全面的输出，包括：
58
58|
59
59|** 最终答案 **- 智能代理对查询的最终响应
60
60|
61
61|** 工具输出 **- 执行期间每次工具调用的结果
62
62|
63
63|** 推理轨迹 **- 逐步决策过程（推理与行动策略特别详细）在 JSON 输出中可用
64
64|
65
65|** 迭代计数 **- 使用的推理循环次数
66
66|
67
67|** 成功状态 **- 智能代理是否成功完成任务
68
68|
69
69|** 智能代理日志 **- 带有元数据的结构化日志事件，用于调试和监控工具调用
70
70|
71
71|
72
72|## 用例 ** 研究与分析 **- 智能代理可以自主搜索多个来源，综合信息，并提供全面的答案。
73
73|
74
74|** 故障排除 **- 诊断任务，智能代理需要收集信息、测试假设，并根据发现调整其方法。
75
75|
76
76|** 多步数据处理 **- 复杂的工作流，其中下一个行动取决于中间结果。
77
77|
78
78|** 动态 API 集成 **- API 调用序列取决于无法预先确定的响应和条件的场景。
79
79|
80
80|
81
81|## 最佳实践 ** 清晰的工具描述 ** 帮助智能代理了解何时以及如何有效使用每个工具。
82
82|
83
83|** 适当的迭代限制 ** 防止失控成本，同时为复杂任务提供足够的灵活性。
84
84|
85
85|** 详细的指令 ** 提供关于智能代理角色、目标以及任何约束或偏好的上下文。
86
86|
87
87|** 记忆管理 ** 根据你的用例要求平衡上下文保留与标记效率。
88
88|

1
 1|# 直接回复
2
 2|
3
 3|> 原文：[直接回复](https://docs.dify.ai/zh/use-dify/nodes/answer)
4
 4|
5
 5|---
6
 6|
7
 7|## Documentation IndexFetch the complete documentation index at:[https://docs.dify.ai/llms.txt](https://docs.dify.ai/llms.txt)
8
 8|
9
 9|
10
10|> ⚠️ ⚠️ 本文档由 AI 自动翻译。如有任何不准确之处，请参考[英文原版](/en/use-dify/nodes/answer)。
11
11|
12
12|直接回复节点定义了在对话流应用中向用户传递的内容。使用它来格式化响应、将文本与变量结合，以及流式传输包括文本、图像和文件在内的多模态内容。
13
13|
14
14|
15
15|> 💡 直接回复节点仅适用于对话流应用。工作流应用使用结束节点。
16
16|
17
17|
18
18|## 内容配置直接回复节点提供了一个灵活的文本编辑器，你可以使用固定文本、来自先前节点的变量或两者的组合来制作响应。
19
19|
20
20|使用`{{variable_name}}`语法引用任何先前工作流节点的变量。编辑器支持丰富的内容格式化和变量插入，以创建动态的、上下文相关的响应。
21
21|
22
22|
23
23|## 多模态响应直接回复节点支持丰富的内容传递，包括在单个响应流中传递文本、图像和文件。
24
24|
25
25|
26
26|** 文本内容 ** 可以包括变量替换、markdown 格式化以及基于工作流处理结果的动态内容。
27
27|
28
28|** 图像内容 ** 显示由工具生成、用户上传或由工作流节点处理的图像。图像与文本一起流式传输，提供丰富的用户体验。
29
29|
30
30|** 文件内容 ** 传递在工作流执行期间生成或处理的文档、电子表格或其他文件。
31
31|
32
32|
33
33|## 多个直接回复节点你可以在对话流中的不同位置放置多个直接回复节点，以在处理的不同阶段传递内容。这实现了：
34
34|
35
35|** 渐进式响应 **- 在后台处理继续的同时提供即时确认
36
36|
37
37|** 条件响应 **- 基于工作流分支逻辑发送不同的内容
38
38|
39
39|** 流式更新 **- 在长时间运行的过程中，一旦部分结果可用就立即传递
40
40|
41
41|每个直接回复节点独立地为对话做出贡献，允许复杂的响应模式和用户体验设计。
42
42|
43
43|
44
44|## 变量集成直接回复节点与所有工作流节点类型的输出无缝集成。常见的变量源包括：
45
45|
46
46|** 大型语言模型响应 **- 显示生成的文本、分析结果或来自语言模型的结构化输出
47
47|
48
48|** 知识检索 **- 显示在知识库中找到的相关信息，并自动进行引用跟踪
49
49|
50
50|** 工具结果 **- 展示来自外部 API、计算或服务集成的数据
51
51|
52
52|** 文件处理 **- 显示提取的文本、分析结果或处理过的文档内容
53
53|
54
54|变量系统维护类型安全，并自动处理不同的内容类型，以便在聊天界面中实现最佳显示。
55
55|

1
 1|# 代码
2
 2|
3
 3|> 原文：[代码](https://docs.dify.ai/zh/use-dify/nodes/code)
4
 4|
5
 5|---
6
 6|
7
 7|## Documentation IndexFetch the complete documentation index at:[https://docs.dify.ai/llms.txt](https://docs.dify.ai/llms.txt)
8
 8|
9
 9|
10
10|> ⚠️ ⚠️ 本文档由 AI 自动翻译。如有任何不准确之处，请参考[英文原版](/en/use-dify/nodes/code)。
11
11|
12
12|代码节点执行自定义 Python 或 JavaScript 来处理工作流中复杂的数据转换、计算和逻辑。当预设节点无法满足你的特定处理需求时可以使用它。
13
13|
14
14|
15
15|## 配置定义 ** 输入变量 ** 以访问工作流中其他节点的数据，然后在代码中引用这些变量。你的函数必须返回一个包含你已声明的 ** 输出变量 ** 的字典。
16
16|
17
17|
18
18|```
19
19|`defmain(input_variable:str) ->dict:
20
20|# Process the input
21
21|result=input_variable.upper()
22
22|return{
23
23|'output_variable': result
24
24|}
25
25|`
26
26|```
27
27|
28
28|## 语言支持根据你的需求和熟悉程度在 **Python** 和 **JavaScript** 之间进行选择。两种语言都在安全沙箱中运行，并可访问用于数据处理的常用库。
29
29|
30
30|
31
31|- Python
32
32|- JavaScript:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0" data-component-part="tab-content">Python 包含标准库，如`json`、`math`、`datetime`和`re`。非常适合数据分析、数学运算和文本处理。
33
33|
34
34|
35
35|```
36
36|`defmain(data:list) ->dict:
37
37|importjson
38
38|importmath
39
39|
40
40|average=sum(data)/len(data)
41
41|return{'result': math.ceil(average)}
42
42|`
43
43|```
44
44|:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0 hidden" data-component-part="tab-content">JavaScript 提供标准内置对象和方法。适合 JSON 操作和字符串操作。
45
45|
46
46|
47
47|```
48
48|`functionmain(data) {
49
49|constprocessed=data.map(item=>item.toUpperCase());
50
50|return{result:processed};
51
51|}
52
52|`
53
53|```
54
54|
55
55|## 错误处理和重试为失败的代码执行配置自动重试行为，并定义代码遇到错误时的回退策略。
56
56|
57
57|
58
58|** 重试设置 ** 允许最多 10 次自动重试，并可配置间隔（最大 5000ms）。启用此功能来处理临时处理问题。
59
59|
60
60|** 错误处理 ** 让你在代码执行失败时定义回退路径，使你的工作流即使在代码遇到问题时也能继续运行。
61
61|
62
62|
63
63|## 输出验证和限制代码输出会自动验证并有严格限制：
64
64|
65
65|
66
66|- ** 字符串 **：最大长度 80,000 个字符，空字节会被移除
67
67|- ** 数字 **：范围从 -999999999 到 999999999，浮点数限制为 10 位小数
68
68|- ** 对象 / 数组 **：最大深度 5 级，以防止复杂的嵌套结构这些限制确保工作流的性能并防止内存问题。
69
69|
70
70|
71
71|## 安全考虑代码在严格的沙箱中执行，阻止文件系统访问、网络请求和系统命令。这在提供编程灵活性的同时保持安全性。
72
72|
73
73|出于安全原因，某些操作会被自动阻止。避免尝试访问系统文件或执行可能危险的操作：
74
74|
75
75|
76
76|如果你的代码无法保存，请检查浏览器的网络选项卡 - 安全过滤器可能正在阻止潜在危险的操作。
77
77|
78
78|
79
79|## 依赖支持代码节点支持 Python 和 JavaScript 的外部依赖：
80
80|
81
81|
82
82|```
83
83|`# Python: Import numpy, pandas, requests, etc.
84
84|importnumpyasnp
85
85|importpandasaspd
86
86|
87
87|defmain(data:list) ->dict:
88
88|df=pd.DataFrame(data)
89
89|return{'mean':float(np.mean(df['values']))}
90
90|`
91
91|```
92
92|
93
93|```
94
94|`// JavaScript: Import lodash, moment, etc.
95
95|const_=require('lodash');
96
96|
97
97|functionmain(data) {
98
98|return{unique:_.uniq(data) };
99
99|}

1
 1|# 文档提取器
2
 2|
3
 3|> 原文：[文档提取器](https://docs.dify.ai/zh/use-dify/nodes/doc-extractor)
4
 4|
5
 5|---
6
 6|
7
 7|## Documentation IndexFetch the complete documentation index at:[https://docs.dify.ai/llms.txt](https://docs.dify.ai/llms.txt)
8
 8|
9
 9|
10
10|> ⚠️ ⚠️ 本文档由 AI 自动翻译。如有任何不准确之处，请参考[英文原版](/en/use-dify/nodes/doc-extractor)。
11
11|
12
12|文档提取器节点将上传的文件转换为大型语言模型可以处理的文本。由于语言模型无法直接读取 PDF 或 DOCX 等文档格式，此节点作为文件上传和 AI 分析之间的重要桥梁。
13
13|
14
14|
15
15|## 支持的文件类型该节点处理大多数基于文本的文档格式：
16
16|
17
17|** 文本文档 **- TXT、Markdown、HTML 文件，包含直接文本内容
18
18|
19
19|** 办公文档 **- Microsoft Word 和兼容应用程序的 DOCX 文件
20
20|
21
21|**PDF 文档 **- 基于文本的 PDF，使用 pypdfium2 进行精确的文本提取
22
22|
23
23|** 办公文件 **- DOC 文件需要 Unstructured API，DOCX 文件支持直接解析，表格提取转换为 Markdown 格式
24
24|
25
25|** 电子表格 **- Excel（.xls/.xlsx）和 CSV 文件转换为 Markdown 表格
26
26|
27
27|** 演示文稿 **- PowerPoint（.ppt/.pptx）文件通过 Unstructured API 处理
28
28|
29
29|** 邮件格式 **- EML 和 MSG 文件用于邮件内容提取
30
30|
31
31|** 专业格式 **- EPUB 电子书、VTT 字幕、JSON/YAML 数据和 Properties 文件
32
32|
33
33|主要包含二进制内容（如图像、音频或视频）的文件需要专门的处理工具或外部服务。
34
34|
35
35|
36
36|## 输入和输出
37
37|### 输入配置配置节点以接受：
38
38|
39
39|来自文件变量的 ** 单个文件 ** 输入（通常来自开始节点）
40
40|
41
41|用于批量文档处理的 ** 多个文件 ** 数组
42
42|
43
43|
44
44|### 输出结构节点输出提取的文本内容：
45
45|
46
46|
47
47|- 单个文件输入产生包含提取文本的`string`
48
48|- 多个文件输入产生包含每个文件内容的`array[string]`输出变量命名为`text`，包含准备用于下游处理的原始文本内容。
49
49|
50
50|
51
51|## 实现示例以下是使用文档提取器的完整文档问答工作流：
52
52|
53
53|
54
54|### 工作流设置 ** 文件上传配置 **- 在开始节点中启用文件输入，接受用户上传的文档。
55
55|
56
56|** 文本提取 **- 连接文档提取器处理上传的文件并提取其文本内容。
57
57|
58
58|**AI 处理 **- 在大型语言模型提示词中使用提取的文本进行分析、摘要或问答。
59
59|
60
60|
61
61|## 常见用例 ** 文档问答应用 **- 构建 ChatPDF 风格的应用，用户上传文档并询问其内容相关问题。
62
62|
63
63|** 内容分析 **- 处理合同、报告或研究论文以提取关键信息和见解。
64
64|
65
65|** 批量文档处理 **- 同时从多个文档提取文本用于分析、索引或迁移。
66
66|
67
67|** 文档转换 **- 将各种文档格式转换为纯文本以进行进一步处理或存储。
68
68|
69
69|
70
70|## 处理注意事项文档提取器使用针对不同文件格式优化的专用解析库。它尽可能保留文本结构和格式，使提取的内容对大型语言模型处理更加有用。
71
71|
72
72|
73
73|### 文件格式处理 ** 编码检测 **- 使用 chardet 库自动检测文件编码，基于文本的文件使用 UTF-8 作为后备
74
74|
75
75|** 表格转换 **- Excel 和 CSV 数据转换为 Markdown 表格，以便大型语言模型更好地理解
76
76|
77
77|** 文档结构 **- DOCX 文件保持段落和表换
78
78|
79
79|** 多行内容 **- VTT 字幕文件合并同一发言者的连续话语
80
80|
81
81|
82
82|### 外部依赖某些文件格式需要通过`UNSTRUCTURED_API_URL`和`UNSTRUCTURED_API_KEY`配置 **Unstructured API** 服务：
83
83|
84
84|
85
85|- DOC 文件（旧版 Word 文档）
86
86|- PowerPoint 演示文稿（如果使用 API 处理）
87
87|- EPUB 电子书（如果使用 API 处理）对于非常大的文档，请考虑大型语言模型的上下文限制，如果需要，可以实施分段策略。提取的文本保持原始文档的逻辑结构，以保留含义和上下文。
88
88|

1
 1|# HTTP 请求
2
 2|
3
 3|> 原文：[HTTP 请求](https://docs.dify.ai/zh/use-dify/nodes/http-request)
4
 4|
5
 5|---
6
 6|
7
 7|## Documentation IndexFetch the complete documentation index at:[https://docs.dify.ai/llms.txt](https://docs.dify.ai/llms.txt)
8
 8|
9
 9|
10
10|> ⚠️ ⚠️ 本文档由 AI 自动翻译。如有任何不准确之处，请参考[英文原版](/en/use-dify/nodes/http-request)。
11
11|
12
12|HTTP 请求节点将你的工作流连接到外部 API 和 Web 服务。使用它来获取数据、发送 webhooks、上传文件，或与任何接受 HTTP 请求的服务集成。
13
13|
14
14|
15
15|## HTTP 方法该节点支持所有标准 HTTP 方法，用于不同类型的操作：
16
16|
17
17|
18
18|- 数据检索
19
19|- 数据提交
20
20|- 资源管理:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0" data-component-part="tab-content">**GET** 从服务器检索数据而不修改任何内容。用于获取用户资料、搜索数据库或获取当前状态。
21
21|
22
22|**HEAD** 获取响应头而不包含完整的响应正文。用于检查资源是否存在或获取元数据。
23
23|
24
24|:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0 hidden" data-component-part="tab-content">**POST** 向服务器发送数据，通常用于创建新资源。用于表单提交、文件上传或发送 JSON 负载。
25
25|
26
26|**PUT** 创建或完全替换资源。当你想要设置资源的整个状态时使用。
27
27|
28
28|**PATCH** 对现有资源进行部分更新。当你只需要修改特定字段时使用。
29
29|
30
30|:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0 hidden" data-component-part="tab-content">**DELETE** 从服务器移除资源。用于删除文件、用户账户或任何应该被移除的资源。
31
31|
32
32|
33
33|## 配置配置 HTTP 请求的各个方面，包括 URL、头部、查询参数、请求正文和身份验证。来自先前工作流节点的变量可以动态插入到请求配置的任何位置。
34
34|
35
35|
36
36|### 变量替换使用双花括号引用工作流变量：`{{variable_name}}`。Dify 支持深度对象访问，因此你可以从先前的 HTTP 响应中提取嵌套值，如`{{api_response.data.items[0].id}}`。
37
37|
38
38|
39
39|### 超时配置 HTTP 请求具有可配置的超时设置以防止挂起：
40
40|
41
41|
42
42|- ** 连接超时 **：建立连接的最大时间（默认值因部署而异）
43
43|- ** 读取超时 **：读取响应数据的最大时间
44
44|- ** 写入超时 **：发送请求数据的最大时间强制执行超时以维持工作流性能并防止资源耗尽。
45
45|
46
46|
47
47|### 身份验证该节点支持多种身份验证类型：
48
48|
49
49|** 无认证 **(`type: "no-auth"`) - 不添加身份验证头部
50
50|
51
51|**API 密钥 **(`type: "api-key"`) 具有三种子类型：
52
52|
53
53|
54
54|- ** 基础 **(`type: "basic"`) - 添加带有 base64 编码的基础认证头部
55
55|- **Bearer**(`type: "bearer"`) - 添加`Authorization: Bearer`头部
56
56|- ** 自定义 **(`type: "custom"`) - 添加具有指定名称和值的自定义头部
57
57|### 请求正文根据你的 API 要求选择适当的正文类型：
58
58|
59
59|
60
60|- **JSON** 用于结构化数据
61
61|- ** 表单数据 ** 用于传统 Web 表单
62
62|- ** 二进制 ** 用于文件上传
63
63|- ** 原始文本 ** 用于自定义内容类型
64
64|## 文件检测 HTTP 请求节点使用复杂的逻辑自动检测文件响应：
65
65|
66
66|
67
67|- **Content-Disposition 分析 **- 检查`attachment`配置或文件名参数
68
68|- **MIME 类型评估 **- 分析内容类型以区分文本和二进制
69
69|- ** 内容采样 **- 对于模糊类型，采样前 1024 字节以检测文本模式基于文本的响应（JSON、XML、HTML 等）被视为常规数据，而二进制内容则成为文件变量。
70
70|
71
71|
72
72|## 文件操作 HTTP 请求节点无缝处理文件上传和下载：
73
73|
74
74|
75
75|** 文件上传 ** 使用二进制请求正文选项。从先前节点选择文件变量，将文件发送到外部服务进行文档存储、媒体处理或备份。
76
76|
77
77|** 文件下载 ** 在响应包含文件内容时自动处理。下载的文件可作为文件变量在处理和重试
78
78|
79
79|为依赖外部服务的生产工作流配置健壮的错误处理：
80
80|
81
81|
82
82|** 重试设置 ** 自动重试失败的请求，最多 10 次，具有可配置的间隔（最大 5000ms）。这处理临时网络问题或服务不可用性。
83
83|
84
84|
85
85|** 错误处理 ** 定义 HTTP 请求失败时的替代工作流路径，确保即使在外部 API 不可用时你的工作流也能继续执行。
86
86|
87
87|
88
88|## 响应处理 HTTP 响应在后续节点中成为结构化变量，可分别访问：
89
89|
90
90|
91
91|- ** 响应正文 **- API 返回的主要内容
92
92|- ** 状态码 **- 用于条件逻辑的 HTTP 状态
93
93|- ** 头部 **- 作为键值对的响应元数据
94
94|- ** 文件 **- API 返回的任何文件内容
95
95|- ** 大小信息 **- 内容大小（以字节为单位），具有可读格式（KB/MB）
96
96|### SSL 验证每个节点的 SSL 证书验证是可配置的（`ssl_verify`参数）。这允许连接到具有自签名证书的内部服务，同时为外部 API 维持安全性。
97
97|
98
98|
99
99|## 常见集成模式 **API 数据获取 **- 检索用户资料、产品信息或外部数据以丰富你的工作流处理。

1
 1|# 人工介入
2
 2|
3
 3|> 原文：[人工介入](https://docs.dify.ai/zh/use-dify/nodes/human-input)
4
 4|
5
 5|---
6
 6|
7
 7|## Documentation IndexFetch the complete documentation index at:[https://docs.dify.ai/llms.txt](https://docs.dify.ai/llms.txt)
8
 8|
9
 9|
10
10|> ⚠️ ⚠️ 本文档由 AI 自动翻译。如有任何不准确之处，请参考[英文原版](/en/use-dify/nodes/human-input)。
11
11|
12
12|人工介入节点在关键点暂停工作流，发送可自定义的请求表单。接收人可使用表单审核信息、提供输入，并从预定义的决策中进行选择，这些决策决定工作流如何继续。
13
13|
14
14|通过在关键环节直接嵌入人工判断，你可在 ** 自动化效率与人工监督之间取得平衡 **。
15
15|
16
16|
17
17|## 配置配置以下内容以定义该节点如何请求和处理人工输入：
18
18|
19
19|
20
20|- ** 发送方式 **：请求表单如何送达接收人。
21
21|
22
22|
23
23|- ** 表单内容 **：接收人将看到什么信息以及他们可以与之交互的内容。
24
24|
25
25|
26
26|- ** 用户动作 **：接收人可以做出哪些决策，以及工作流相应如何进行。
27
27|
28
28|
29
29|- ** 超时策略 **：等待多久以及如果无人响应会发生什么。
30
30|
31
31|
32
32|### 发送方式选择发送请求的渠道。当前可用的方式：
33
33|
34
34|
35
35|- **WebApp**：向 WebApp 终端用户显示请求表单。在由触发器启动的工作流中不可用。
36
36|
37
37|
38
38|> 💡 外部客户端也可通过 Service API 获取并提交 WebApp 表单。详见[获取人工介入表单](/api-reference/%E4%BA%BA%E5%B7%A5%E4%BB%8B%E5%85%A5/%E8%8E%B7%E5%8F%96%E4%BA%BA%E5%B7%A5%E4%BB%8B%E5%85%A5%E8%A1%A8%E5%8D%95)。
39
39|
40
40|
41
41|- ** 邮件 **：将请求链接发送至特定工作区成员、外部邮箱地址或工作区全体成员。任何持有链接的人都可响应，无需 Dify 账户。
42
42|
43
43|
44
44|> ⚠️ 无论采用何种发送方式，请求将在收到第一个响应后关闭。
45
45|
46
46|
47
47|### 表单内容自定义接收人看到并与之交互的表单：
48
48|
49
49|
50
50|- ** 使用 Markdown 格式化结构 **
51
51|
52
52|使用标题、列表、粗体文本、链接和其他 Markdown 元素清晰地呈现信息。
53
53|
54
54|
55
55|- ** 使用变量显示动态数据 **
56
56|
57
57|引用工作流变量以显示动态内容，例如供审核的 AI 生成文本或上游节点的任何上下文信息。
58
58|
59
59|
60
60|> 💡 推理模型在最终答案旁输出其思维过程。引用`text`输出变量时默认显示两者。
61
61|
62
62|要仅显示答案，为相应的 LLM 节点开启 ** 思维链分离渲染 **（Enable Reasoning Tag Separation）。
63
63|
64
64|
65
65|- ** 使用输入字段收集输入 **
66
66|
67
67|输入字段可以是空的，也可以预填变量（例如，需优化的 LLM 输出）或静态文本（例如，示例或默认值），接收人可对其进行编辑。
68
68|
69
69|每个输入字段都成为供下游使用的变量。例如，将编辑后的内容传递给后续处理，或将反馈发送给 LLM 进行内容修订。
70
70|
71
71|接收人响应后，填入所有值的表单内容可作为下游变量`__rendered_content`使用。
72
72|
73
73|
74
74|### 用户动作定义接收人可点击的决策按钮，每个按钮将工作流路由到不同的执行路径。
75
75|
76
76|例如，`发布`分支可能会通向触发内容发布的节点，而`重新生成`分支可能会循环回 LLM 节点以修改内容。
77
77|
78
78|每个按钮包含显示标题和动作 ID。按钮被点击时，其 ID 可作为`__action_id`、标题（按钮文本）可作为`__action_value`在下游使用。
79
79|
80
80|
81
81|> 💡 使用预设按钮样式在视觉上区分动作。
82
82|
83
83|例如，对`批准`等关键动作使用醒目的样式，对次要选项使用较淡的样式。
84
84|
85
85|
86
86|### 超时策略配置请求保持开启的时长。默认 3 天。
87
87|
88
88|如果在超时前没有接收人响应，工作流将沿节点的超时分支继续。将该分支连接到后备路径，例如发送通知或重试循环。
89
89|
90
90|如果未连接超时分支，工作流将结束。
91
91|

1
 1|# If-Else
2
 2|
3
 3|> 原文：[If-Else](https://docs.dify.ai/zh/use-dify/nodes/ifelse)
4
 4|
5
 5|---
6
 6|
7
 7|## Documentation IndexFetch the complete documentation index at:[https://docs.dify.ai/llms.txt](https://docs.dify.ai/llms.txt)
8
 8|
9
 9|
10
10|> ⚠️ ⚠️ 本文档由 AI 自动翻译。如有任何不准确之处，请参考[英文原版](/en/use-dify/nodes/ifelse)。
11
11|
12
12|If-Else 节点通过根据你定义的条件将执行路由到不同路径，为你的工作流添加决策逻辑。它评估变量并确定你的工作流应该遵循哪个分支。
13
13|
14
14|
15
15|## 分支逻辑该节点支持多个分支路径来处理复杂的决策树：
16
16|
17
17|**IF 路径 ** 在主要条件评估为真时执行。
18
18|
19
19|**ELIF 路径 ** 在 IF 条件为假时提供按顺序检查的附加条件。你可以添加多个 ELIF 分支来处理复杂逻辑。
20
20|
21
21|**ELSE 路径 ** 作为没有条件匹配时的后备选项，确保你的工作流始终有路径可循。
22
22|
23
23|
24
24|## 条件类型配置条件以使用各种比较运算符测试变量：
25
25|
26
26|
27
27|- 文本操作
28
28|- 值检查:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0" data-component-part="tab-content">** 包含 **/** 不包含 **- 检查值是否包含特定词语或短语
29
29|
30
30|** 开头为 **/** 结尾为 **- 测试文本开头或结尾的模式匹配
31
31|
32
32|** 是 **/** 不是 **- 精确值匹配
33
33|
34
34|:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0 hidden" data-component-part="tab-content">** 为空 **/** 不为空 **- 检查空白、空值或缺失值
35
35|
36
36|** 大于 **/** 小于 **- 数字和日期的数值比较
37
37|
38
38|** 等于 **/** 不等于 **- 任何数据类型的精确匹配
39
39|
40
40|
41
41|## 复杂条件使用逻辑运算符组合多个条件以实现复杂的决策制定：
42
42|
43
43|
44
44|**AND 逻辑 ** 要求所有条件都为真。当你需要同时满足多个条件时使用此选项。
45
45|
46
46|**OR 逻辑 ** 要求任何条件为真。当你希望为不同场景触发相同动作时使用此选项。
47
47|
48
48|
49
49|## 变量引用在你的条件中引用来自先前工作流节点的任何变量。变量可以来自用户输入、大型语言模型响应、API 调用或任何其他工作流节点输出。
50
50|
51
51|使用变量选择器从可用变量中选择，或使用`{{variable_name}}`语法直接键入变量名称。
52
52|

1
 1|# 迭代
2
 2|
3
 3|> 原文：[迭代](https://docs.dify.ai/zh/use-dify/nodes/iteration)
4
 4|
5
 5|---
6
 6|
7
 7|## Documentation IndexFetch the complete documentation index at:[https://docs.dify.ai/llms.txt](https://docs.dify.ai/llms.txt)
8
 8|
9
 9|
10
10|> ⚠️ ⚠️ 本文档由 AI 自动翻译。如有任何不准确之处，请参考[英文原版](/en/use-dify/nodes/iteration)。
11
11|
12
12|迭代节点通过对每个元素按顺序或并行运行相同的工作流步骤来处理数组。用于批处理任务，这些任务若作为单一操作会遇到限制或效率低下的问题。
13
13|
14
14|
15
15|## 迭代的工作原理该节点接收数组输入并创建一个子工作流，对每个数组元素运行一次。在每次迭代期间，当前项目及其索引可作为内部节点可以引用的变量。
16
16|
17
17|** 核心组件 **：
18
18|
19
19|
20
20|- ** 输入变量 **- 来自上游节点的数组数据
21
21|- ** 内部工作流 **- 对每个元素执行的处理步骤
22
22|- ** 输出变量 **- 从所有迭代收集的结果（也是一个数组）
23
23|## 配置
24
24|### 数组输入连接来自上游节点的数组变量，如参数提取器、代码节点、知识检索或 HTTP 请求响应。
25
25|
26
26|
27
27|### 内置变量每次迭代提供访问：
28
28|
29
29|
30
30|- `items[object]`- 正在处理的当前数组元素
31
31|- `index[number]`- 当前迭代索引（从 0 开始）
32
32|### 处理模式
33
33|- 顺序模式
34
34|- 并行模式:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0" data-component-part="tab-content">** 顺序处理 **- 项目按顺序逐一处理
35
35|
36
36|** 流式结果返回支持 **- 可以使用回答节点逐步输出结果
37
37|
38
38|** 资源管理 **- 较低的内存使用量，可预测的执行顺序
39
39|
40
40|** 最适用于 **- 当顺序重要或使用流式输出时
41
41|
42
42|:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0 hidden" data-component-part="tab-content">** 并发处理 **- 最多同时处理 10 个项目
43
43|
44
44|** 性能提升 **- 独立操作的更快执行
45
45|
46
46|** 批处理 **- 高效处理大型数组
47
47|
48
48|** 最适用于 **- 顺序无关紧要的独立操作
49
49|
50
50|
51
51|## 错误处理配置如何处理单个数组元素的处理失败：
52
52|
53
53|** 终止 **- 出现任何错误时停止处理并返回错误消息
54
54|
55
55|** 错误时继续 **- 跳过失败的项目并继续处理，为失败的元素输出 null
56
56|
57
57|** 移除失败结果 **- 跳过失败的项目并仅返回成功的结果
58
58|
59
59|输入输出对应示例：
60
60|
61
61|
62
62|- 输入：`[1, 2, 3]`
63
63|- 错误时继续的输出：`[result-1, null, result-3]`
64
64|- 移除失败的输出：`[result-1, result-3]`
65
65|## 长文章生成示例通过单独处理章节大纲生成冗长内容：
66
66|
67
67|
68
68|** 工作流步骤 **：
69
69|
70
70|
71
71|- ** 开始节点 **- 用户提供故事标题和大纲
72
72|- ** 大型语言模型节点 **- 生成详细的章节分解
73
73|- ** 参数提取器 **- 将章节列表转换为结构化数组
74
74|- ** 迭代节点 **- 通过内部大型语言模型处理每个章节
75
75|- ** 回答节点 **- 生成章节内容时进行流式传输
76
76|
77
77|
78
78|> 💡 参数提取的有效性取决于模型能力和指令质量。使用更强的模型并在指令中提供示例以提高结果。
79
79|
80
80|
81
81|## 输出处理迭代节点输出数组，通常需要转换以供最终使用：
82
82|
83
83|
84
84|### 将数组转换为文本
85
85|- 使用代码节点
86
86|- 使用模板节点:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0" data-component-part="tab-content">
87
87|```
88
88|`defmain(articleSections:list):
89
89|return{
90
90|"result":"\n".join(articleSections)
91
91|}
92
92|`
93
93|```
94
94|
95
95|
96
96|:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0 hidden" data-component-part="tab-content">
97
97|```
98
98|`{{ articleSections | join("\n") }}
99
99|`

1
 1|# 知识检索
2
 2|
3
 3|> 原文：[知识检索](https://docs.dify.ai/zh/use-dify/nodes/knowledge-retrieval)
4
 4|
5
 5|---
6
 6|
7
 7|## Documentation IndexFetch the complete documentation index at:[https://docs.dify.ai/llms.txt](https://docs.dify.ai/llms.txt)
8
 8|
9
 9|
10
10|> ⚠️ ⚠️ 本文档由 AI 自动翻译。如有任何不准确之处，请参考[英文原版](/en/use-dify/nodes/knowledge-retrieval)。
11
11|
12
12|
13
13|## 简介你可以通过知识检索节点将已有知识库集成到 Chatflow 或 Workflow 应用中。该节点在指定知识库中检索与查询相关的信息，并将检索结果作为上下文内容传递给下游节点（如 LLM）使用。
14
14|
15
15|知识检索节点在 Chatflow 中的典型用例如下：
16
16|
17
17|
18
18|- ** 用户输入 ** 节点收集用户问题。
19
19|
20
20|
21
21|- ** 知识检索 ** 节点在指定知识库中检索与用户问题相关的内容，并输出检索结果。
22
22|
23
23|
24
24|- **LLM** 节点基于用户问题和检索结果生成回复。
25
25|
26
26|
27
27|- ** 直接回答 ** 节点将 LLM 的回复输出给用户。
28
28|
29
29|
30
30|> 💡 使用知识检索节点前，确保至少有一个可用的知识库。了解如何创建知识库，阅读[知识库](/zh/use-dify/knowledge/readme#%E5%88%9B%E5%BB%BA%E7%9F%A5%E8%AF%86%E5%BA%93)。
31
31|
32
32|
33
33|> ⚠️ 在 Dify Cloud 上，知识检索操作受订阅计划的频率限制。详见[知识库请求频率限制](/zh/use-dify/knowledge/knowledge-request-rate-limit)。
34
34|
35
35|
36
36|## 配置知识检索节点要使知识检索节点正常工作，你需要指定：
37
37|
38
38|
39
39|- * 检索什么 *（查询内容）
40
40|
41
41|
42
42|- * 在哪里检索 *（知识库）
43
43|
44
44|
45
45|- * 如何处理检索结果 *（节点级检索设置）
46
46|
47
47|你还可以利用文档元数据实现基于筛选的检索，进一步提升检索精度。
48
48|
49
49|
50
50|### 指定查询内容设置节点需要在指定知识库中检索的查询内容。
51
51|
52
52|
53
53|- ** 查询文本 **：选择一个文本变量。例如，在 Chatflow 中可用`userinput.query`引用用户输入，而在 Workflow 中则可选择文本类型的用户输入变量。
54
54|
55
55|
56
56|- ** 查询图片 **：选择一个图片变量（如用户通过用户输入节点上传的图片），通过图片进行检索。图片大小限制为 2 MB。
57
57|
58
58|
59
59|> 💡 对于自托管部署，可通过环境变量`ATTACHMENT_IMAGE_FILE_SIZE_LIMIT`调整图片大小限制。
60
60|
61
61|
62
62|> 💡 当添加了至少一个多模态知识库时，才会出现 ** 查询图片 ** 选项。
63
63|
64
64|此类知识库会带有 **Vision** 图标，表示其使用的是多模态嵌入模型。
65
65|
66
66|
67
67|### 选择检索的知识库为节点添加一个或多个知识库，用于检索与查询内容相关的信息。
68
68|
69
69|添加了多个知识库时，会同时检索所有知识库，合并结果并根据[节点级检索设置](#%E8%B0%83%E6%95%B4%E8%8A%82%E7%82%B9%E7%BA%A7%E6%A3%80%E7%B4%A2%E8%AE%BE%E7%BD%AE) 进行处理。
70
70|
71
71|
72
72|> 💡 带有 **Vision** 图标的知识库支持跨模态检索——基于语义相关性同时检索文本和图片。
73
73|
74
74|
75
75|> 💡 点击已添加知识库对应的 ** 编辑 ** 图标，可直接在知识检索节点内修改其设置。了解更多设置说明，阅读[调整知识库设置](/zh/use-dify/knowledge/manage-knowledge/introduction)。
76
76|
77
77|
78
78|### 调整节点级检索设置设置节点在获取知识库检索结果后的处理方式。
79
79|
80
80|
81
81|> 💡 检索设置分为知识库级和节点级两层。
82
82|
83
83|可将其理解为先后两道筛选：知识库设置决定初步的检索结果池，而节点设置对结果进行重排序（Rerank）或进一步筛选。
84
84|
85
85|
86
86|- **Rerank 设置 **
87
87|
88
88|
89
89|- ** 权重设置 **：语义相似度与关键词匹配的权重。语义权重高则更注重语义相关性，关键词权重高则更偏向精确匹配。
90
90|
91
91|
92
92|> 💡 仅当所有已添加的知识库使用的索引方式均为高质量时，才会出现 ** 权重设置 ** 的选项。
93
93|
94
94|
95
95|- **Rerank 模型 **：根据与查询内容的相关性，对所有结果的相似度分数进行重新评定和排序。
96
96|
97
97|
98
98|> ⚠️ 若添加了多模态知识库，需同时选择多模态 Rerank 模型（带有 **Vision** 图标）。否则，检索到的图片将在重排序和最终输出中被排除。
99
99|

1
 1|# 列表操作符
2
 2|
3
 3|> 原文：[列表操作符](https://docs.dify.ai/zh/use-dify/nodes/list-operator)
4
 4|
5
 5|---
6
 6|
7
 7|## Documentation IndexFetch the complete documentation index at:[https://docs.dify.ai/llms.txt](https://docs.dify.ai/llms.txt)
8
 8|
9
 9|
10
10|> ⚠️ ⚠️ 本文档由 AI 自动翻译。如有任何不准确之处，请参考[英文原版](/en/use-dify/nodes/list-operator)。
11
11|
12
12|列表操作符节点通过筛选、排序和选择特定元素来处理数组。当你需要处理混合文件上传、大型数据集或任何需要在下游处理之前进行分离或组织的数组数据时，请使用它。
13
13|
14
14|支持的输入数据类型包括`array[string]`、`array[number]`、`array[file]`和`array[boolean]`。
15
15|
16
16|
17
17|## 数组处理问题大多数工作流节点期望单个值，而不是数组。当你在一个变量中有像`[image.png, document.pdf, audio.mp3]`这样的混合内容时，你需要将其分离成下游节点可以有效处理的专注流。
18
18|
19
19|列表操作符充当智能路由器，使用过滤器分离混合数组并为专门处理做好准备。
20
20|
21
21|
22
22|## 操作
23
23|### 筛选根据属性提取特定项目。对于文件数组，可以按以下条件筛选：
24
24|
25
25|
26
26|- 内容属性
27
27|- 文件属性:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0" data-component-part="tab-content">** 类型 **- 按内容类别筛选：图像、文档、音频、视频
28
28|
29
29|**MIME 类型 **- 精确的内容类型识别（image/jpeg、application/pdf 等）
30
30|
31
31|** 扩展名 **- 文件扩展名（.pdf、.jpg、.mp3、.docx 等）
32
32|
33
33|:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0 hidden" data-component-part="tab-content">** 大小 **- 处理限制的文件大小约束
34
34|
35
35|** 名称 **- 文件名模式或特定名称
36
36|
37
37|** 传输方法 **- 区分本地上传和基于 URL 的文件
38
38|
39
39|
40
40|### 排序按任何属性组织筛选结果：
41
41|
42
42|** 升序（ASC）**- 从最小到最大值，A-Z 字母顺序
43
43|
44
44|** 降序（DESC）**- 从最大到最小值，Z-A 逆序
45
45|
46
46|
47
47|### 选择从处理后的数组中选择特定元素：
48
48|
49
49|** 取前 N 个 **- 在筛选和排序后选择前 1-20 个项目
50
50|
51
51|** 第一条记录 **- 仅返回第一个匹配元素作为单个值
52
52|
53
53|** 最后一条记录 **- 仅返回最后一个匹配元素作为单个值
54
54|
55
55|
56
56|## 输出变量 **result**- 完整的筛选和排序数组，用于批量处理
57
57|
58
58|**first_record**- 来自开头的单个元素，非常适合”主要”或”最新”项目选择
59
59|
60
60|**last_record**- 来自末尾的单个元素，用于”最近”或”最终”选择
61
61|
62
62|
63
63|## 混合文件处理示例处理用户同时上传文档和图像的工作流：
64
64|
65
65|
66
66|** 实施步骤 **：
67
67|
68
68|
69
69|- ** 配置混合上传 **- 启用文件上传功能以接受多种文件类型
70
70|- ** 按类型分离 **- 使用带有不同过滤器的独立列表操作符节点：
71
71|- 筛选`type = "image"`→ 路由到具有视觉能力的大型语言模型
72
72|- 筛选`type = "document"`→ 路由到文档提取器
73
73|- ** 适当处理 **- 图像被直接分析，文档进行文本提取
74
74|- ** 合并结果 **- 将处理后的输出合并为统一响应这种模式自动将不同文件类型路由到适当的处理器，创建无缝的多模态用户体验。
75
75|

1
 1|# 大语言模型
2
 2|
3
 3|> 原文：[大语言模型](https://docs.dify.ai/zh/use-dify/nodes/llm)
4
 4|
5
 5|---
6
 6|
7
 7|## Documentation IndexFetch the complete documentation index at:[https://docs.dify.ai/llms.txt](https://docs.dify.ai/llms.txt)
8
 8|
9
 9|
10
10|> ⚠️ ⚠️ 本文档由 AI 自动翻译。如有任何不准确之处，请参考[英文原版](/en/use-dify/nodes/llm)。
11
11|
12
12|大型语言模型节点调用语言模型来处理文本、图像和文档。它向你配置的模型发送提示词并捕获其响应，支持结构化输出、上下文管理和多模态输入。
13
13|
14
14|
15
15|> 💡 在使用大型语言模型节点之前，请先在 ** 系统设置 → 模型供应商 ** 中配置至少一个模型供应商。
16
16|
17
17|
18
18|## 模型选择和参数从你已配置的任何模型供应商中进行选择。不同模型擅长不同任务 - GPT-4 和 Claude 3.5 在复杂推理方面表现良好但成本较高，而 GPT-3.5 Turbo 在能力和经济性之间取得平衡。对于本地部署，使用 Ollama、LocalAI 或 Xinference。
19
19|
20
20|
21
21|模型参数控制响应生成。** 温度 ** 范围从 0（确定性）到 1（创造性）。** 核采样 ** 通过概率限制词汇选择。** 频率惩罚 ** 减少重复。** 存在惩罚 ** 鼓励新话题。你也可以使用预设：** 精确 **、** 平衡 ** 或 ** 创意 **。
22
22|
23
23|
24
24|## 提示词配置你的界面根据模型类型自适应。聊天模型使用消息角色（** 系统 ** 用于行为，** 用户 ** 用于输入，** 助手 ** 用于示例），而完成模型使用简单的文本续写。
25
25|
26
26|在提示词中使用双花括号引用工作流变量：`{{variable_name}}`。变量在到达模型之前会被实际值替换。
27
27|
28
28|
29
29|```
30
30|`System: You are a technical documentation expert.
31
31|User: {{user_input}}
32
32|`
33
33|```
34
34|
35
35|## 上下文变量上下文变量在保持来源归属的同时注入外部知识。这使得大型语言模型可以使用你的特定文档回答问题的检索增强生成应用成为可能。
36
36|
37
37|
38
38|将知识检索节点的输出连接到你的大型语言模型节点的上下文输入，然后引用它：
39
39|
40
40|
41
41|```
42
42|`Answer using only this context:
43
43|{{knowledge_retrieval.result}}
44
44|
45
45|Question: {{user_question}}
46
46|`
47
47|```
48
48|当使用来自知识检索的上下文变量时，Dify 会自动跟踪引用，以便用户看到信息来源。
49
49|
50
50|
51
51|## 结构化输出强制模型返回特定数据格式（如 JSON）以便程序化使用。通过三种方法配置：
52
52|
53
53|
54
54|- 可视化编辑器
55
55|- JSON Schema
56
56|- AI 生成:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0" data-component-part="tab-content"> 用户友好的界面适用于简单结构。添加具有名称和类型的字段，标记必需字段，设置描述。编辑器自动生成 JSON Schema。
57
57|
58
58|:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0 hidden" data-component-part="tab-content"> 直接编写 Schema，适用于具有嵌套对象、数组和验证规则的复杂结构。
59
59|
60
60|
61
61|```
62
62|`{
63
63|"type":"object",
64
64|"properties": {
65
65|"sentiment": {
66
66|"type":"string",
67
67|"enum": ["positive","negative","neutral"]
68
68|}
69
69|},
70
70|"required": ["sentiment"]
71
71|}
72
72|`
73
73|```
74
74|:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0 hidden" data-component-part="tab-content"> 用自然语言描述需求，让 AI 生成 Schema。
75
75|
76
76|
77
77|> 💡 具有原生 JSON 支持的模型可以可靠地处理结构化输出。对于其他模型，Dify 在提示词中包含 Schema，但结果可能有所不同。
78
78|
79
79|
80
80|## 记忆和文件处理启用记忆以在聊天流对话中的多个大型语言模型调用之间维护上下文。启用后，之前的交互将作为格式化的用户-助手输出包含在后续提示词中。你可以通过编辑`USER`模板来自定义用户提示词的内容。记忆是节点特定的，不会在不同对话之间持续存在。
81
81|
82
82|对于 ** 文件处理 **，将文件变量添加到多模态模型的提示词中。GPT-4V 处理图像，Claude 直接处理 PDF，而其他模型可能需要预处理。
83
83|
84
84|
85
85|### 视觉能力配置处理图像时，你可以控制细节级别：
86
86|
87
87|
88
88|- ** 高细节 **- 对复杂图像具有更好的准确性但使用更多令牌
89
89|- ** 低细节 **- 对简单图像进行更快处理，使用较少令牌视觉能力的默认变量选择器是`userinput.files`，它会自动从用户输入节点获取文件。
90
90|
91
91|
92
92|## Jinja2 模板支持大型语言模型提示词支持 Jinja2 模板以进行高级变量处理。当你使用 Jinja2 模式（`edition_type: "jinja2"`）时，你可以：
93
93|
94
94|
95
95|```
96
96|`{%foriteminsearch_results%}
97
97|{{loop.index}}.{{item.title}}:{{item.content}}
98
98|{%endfor%}
99
99|`

1
 1|# 循环
2
 2|
3
 3|> 原文：[循环](https://docs.dify.ai/zh/use-dify/nodes/loop)
4
 4|
5
 5|---
6
 6|
7
 7|## Documentation IndexFetch the complete documentation index at:[https://docs.dify.ai/llms.txt](https://docs.dify.ai/llms.txt)
8
 8|
9
 9|
10
10|> ⚠️ ⚠️ 本文档由 AI 自动翻译。如有任何不准确之处，请参考[英文原版](/en/use-dify/nodes/loop)。
11
11|
12
12|循环节点执行重复性工作流，每个循环都基于前一个循环的结果进行构建。与迭代处理数组元素独立不同，循环创建的是随着每次重复而演进的渐进式工作流。
13
13|
14
14|
15
15|## 循环 vs 迭代了解何时使用每种重复模式：
16
16|
17
17|
18
18|- 循环
19
19|- 迭代:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0" data-component-part="tab-content">** 顺序处理 **- 每个循环依赖于先前的结果
20
20|
21
21|** 渐进式改进 **- 输出在迭代过程中得到改善或演化
22
22|
23
23|** 状态管理 **- 变量在循环中持续存在并累积
24
24|
25
25|** 使用场景 **- 内容优化、问题解决、质量保证
26
26|
27
27|:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0 hidden" data-component-part="tab-content">** 独立处理 **- 每个项目单独处理
28
28|
29
29|** 并行执行 **- 项目可以同时处理
30
30|
31
31|** 批量操作 **- 对多个数据点应用相同操作
32
32|
33
33|** 使用场景 **- 数据转换、批量处理、并行分析
34
34|
35
35|
36
36|## 配置
37
37|### 循环变量定义在循环迭代中持续存在并在循环完成后仍可访问的变量。这些变量维护状态并实现渐进式工作流。
38
38|
39
39|
40
40|### 终止条件配置循环何时停止执行：
41
41|
42
42|** 循环终止条件 **- 确定何时退出的表达式（例如，`quality_score > 0.9`）
43
43|
44
44|** 最大循环次数 **- 防止无限循环的安全限制
45
45|
46
46|** 退出循环节点 **- 达到此节点时立即终止
47
47|
48
48|
49
49|> 💡 当满足终止条件、达到最大次数或执行退出循环节点时，循环终止。如果未指定条件，循环将继续直到达到最大次数。
50
50|
51
51|
52
52|## 基础循环示例生成随机数，直到找到小于 50 的数：
53
53|
54
54|
55
55|** 工作流步骤 **：
56
56|
57
57|
58
58|- ** 代码节点 ** 生成 1-100 之间的随机整数
59
59|- ** 条件分支节点 ** 检查数字是否小于 50
60
60|- ** 模板节点 ** 为小于 50 的数字返回 “done” 以触发循环终止
61
61|- 循环继续直到满足终止条件
62
62|
63
63|
64
64|## 高级循环示例通过迭代改进创建诗歌，每个版本都基于前一个版本构建：
65
65|
66
66|** 循环变量 **：
67
67|
68
68|
69
69|- `num`- 计数器，从 0 开始，每次迭代递增
70
70|- `verse`- 文本变量，保存当前诗歌版本 ** 工作流逻辑 **：
71
71|
72
72|
73
73|- ** 条件分支节点 ** 检查`num > 3`以确定何时退出
74
74|- ** 大型语言模型节点 ** 基于前一版本生成改进的诗歌
75
75|- ** 变量赋值器 ** 更新计数器和诗歌内容
76
76|- ** 退出循环节点 ** 在 4 个改进循环后终止大型语言模型提示词引用当前诗句和迭代上下文：
77
77|
78
78|
79
79|```
80
80|`You are a European literary figure creating poetic verses.
81
81|
82
82|Current verse: {{verse}}
83
83|
84
84|Refine and improve this poem based on your previous work.
85
85|`
86
86|```
87
87|
88
88|## 常见使用场景 ** 内容优化 **- 通过多次大型语言模型审查逐步改进文本、代码或设计，直到达到质量标准。
89
89|
90
90|** 问题解决 **- 将复杂问题分解为迭代步骤，其中每个循环基于先前的进展处理下一个逻辑部分。
91
91|
92
92|** 研究工作流 **- 基于每个搜索循环的发现，迭代搜索、分析和优化研究查询。
93
93|
94
94|** 质量保证 **- 重进直到满足所有标准。
95
95|
96
96|
97
97|## 最佳实践 ** 定义明确的退出条件 **- 确保循环具有特定的、可测量的终止条件，以防止无限执行。
98
98|
99
99|** 设置合理限制 **- 根据预期复杂性和处理需求使用适当的最大迭代次数。

1
 1|# 输出
2
 2|
3
 3|> 原文：[输出](https://docs.dify.ai/zh/use-dify/nodes/output)
4
 4|
5
 5|---
6
 6|
7
 7|## Documentation IndexFetch the complete documentation index at:[https://docs.dify.ai/llms.txt](https://docs.dify.ai/llms.txt)
8
 8|
9
 9|
10
10|> ⚠️ ⚠️ 本文档由 AI 自动翻译。如有任何不准确之处，请参考[英文原版](/en/use-dify/nodes/output)。
11
11|
12
12|使用输出节点将工作流中的特定变量值传递给终端用户或 API 调用者。在需要呈现结果的位置添加该节点。
13
13|
14
14|
15
15|> 💡 输出节点的前身是「结束」节点，曾是每个工作流的必需组件。
16
16|
17
17|现在它是可选的，没有输出节点的工作流仍然可以正常运行，但不会向调用者返回任何数据。
18
18|
19
19|输出节点仅适用于工作流应用。对话流应用请使用[直接回复](/zh/use-dify/nodes/answer) 节点。
20
20|
21
21|
22
22|## 配置输出变量每个输出节点至少需要一个输出变量。添加变量时，指定一个名称并从上游节点的输出中选择数据来源。
23
23|
24
24|
25
25|> 💡 你设置的变量名称将作为 API 响应中的键名。
26
26|
27
27|
28
28|你可以在单个输出节点中添加多个输出变量，并通过拖拽调整顺序。
29
29|
30
30|
31
31|## 支持的变量类型输出变量支持以下类型：
32
32|
33
33|`string`、`number`、`integer`、`boolean`、`object`、`file`、`array[string]`、`array[number]`、`array[object]`、`array[boolean]`、`array[file]`
34
34|
35
35|
36
36|## 多个输出节点一个工作流可以包含多个输出节点。输出节点不会终止工作流执行，其他并行分支（如果有）会在该节点完成后继续运行。
37
37|
38
38|所有已执行的输出节点的变量会合并为一个最终结果。每个输出节点在工作流执行到它时将变量添加到结果中：
39
39|
40
40|
41
41|- 在 ** 同一分支 ** 上，变量按输出节点的排列顺序依次添加。
42
42|
43
43|
44
44|- 在 ** 并行分支 ** 上，先执行完成的输出节点先添加其变量。
45
45|
46
46|
47
47|> 💡 请确保工作流中所有输出节点的变量名称互不重复。
48
48|
49
49|当两个输出节点使用相同的输出变量名称时，后执行的节点会覆盖先前的值。
50
50|
51
51|
52
52|## API 响应结构通过 API 调用工作流时，输出变量会出现在响应的`outputs`对象中。
53
53|
54
54|
55
55|- 阻塞式返回
56
56|- 流式返回:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0" data-component-part="tab-content"> 工作流完成后，所有输出以单次响应返回：
57
57|
58
58|
59
59|```
60
60|`{
61
61|"workflow_run_id":"...",
62
62|"status":"succeeded",
63
63|"outputs": {
64
64|"result_text":"The processed output...",
65
65|"score":95
66
66|}
67
67|}
68
68|`
69
69|```
70
70|:first-child:not(p)]:mt-0 [&>:first-child:not(p)_img]:mt-0 [&>:first-child[data-table-wrapper]]:!pt-0 hidden" data-component-part="tab-content"> 输出在最终的`workflow_finished`事件中到达：
71
71|
72
72|
73
73|```
74
74|`{
75
75|"event":"workflow_finished",
76
76|"data": {
77
77|"outputs": {
78
78|"result_text":"The processed output...",
79
79|"score":95
80
80|}
81
81|}
82
82|}
83
83|`
84
84|```
85
85|每个输出变量名称直接对应`outputs`对象中的一个键。
86
86|
87
87|
88
88|## 发布为工具当你将[工作流发布为工具](/zh/use-dify/workspace/tools#%E5%B7%A5%E4%BD%9C%E6%B5%81%E5%B7%A5%E5%85%B7) 时，输出节点定义了工具的返回结构。每个输出变量名称会成为工具结果中的一个键，供调用该工具的工作流使用。
89
89|

1
 1|# 参数提取器
2
 2|
3
 3|> 原文：[参数提取器](https://docs.dify.ai/zh/use-dify/nodes/parameter-extractor)
4
 4|
5
 5|---
6
 6|
7
 7|## Documentation IndexFetch the complete documentation index at:[https://docs.dify.ai/llms.txt](https://docs.dify.ai/llms.txt)
8
 8|
9
 9|
10
10|> ⚠️ ⚠️ 本文档由 AI 自动翻译。如有任何不准确之处，请参考[英文原版](/en/use-dify/nodes/parameter-extractor)。
11
11|
12
12|参数提取器节点使用大型语言模型智能将非结构化文本转换为结构化数据。它弥合了自然语言输入与工具、API 和其他工作流节点所需的结构化参数之间的差距。
13
13|
14
14|
15
15|## 配置
16
16|### 输入和模型选择选择包含要提取参数的文本的 ** 输入变量 **。这通常来自用户输入、大型语言模型响应或其他工作流节点。
17
17|
18
18|选择具有强大结构化输出能力的 ** 模型 **。参数提取器依赖于大型语言模型理解上下文并生成结构化 JSON 响应的能力。
19
19|
20
20|
21
21|### 参数定义通过指定以下内容来定义要提取的参数：
22
22|
23
23|
24
24|- ** 参数名称 **- 将出现在输出 JSON 中的键
25
25|- ** 数据类型 **- 字符串、数字、布尔值、数组或对象
26
26|- ** 描述 **- 帮助大型语言模型了解要提取的内容
27
27|- ** 必需状态 **- 参数是否必须存在你可以手动定义参数或 ** 从现有工具快速导入 ** 以匹配下游节点的参数要求。
28
28|
29
29|
30
30|### 提取指令编写清晰的指令，描述要提取什么信息以及如何格式化。在指令中提供示例可以提高复杂参数的提取准确性和一致性。
31
31|
32
32|
33
33|## 高级配置
34
34|### 推理模式根据你的模型能力选择两种提取方法之一：
35
35|
36
36|** 函数调用 / 工具调用 ** 使用模型的结构化输出功能进行可靠的参数提取，具有强类型合规性。
37
37|
38
38|** 基于提示词的方法 ** 依赖纯提示词技术，适用于可能不支持函数调用的模型或基于提示词的提取表现更好的情况。
39
39|
40
40|
41
41|### 记忆启用记忆功能以在提取参数时包含对话历史。这有助于大型语言模型在交互式对话中理解上下文，并提高对话工作流的提取准确性。
42
42|
43
43|
44
44|## 输出变量该节点提供提取的参数和内置状态变量：
45
45|
46
46|** 提取的参数 ** 作为与你的参数定义匹配的单个变量出现，可供下游节点使用。
47
47|
48
48|** 内置变量 ** 包括状态信息：
49
49|
50
50|
51
51|- `__is_success`- 提取成功状态（成功为 1，失败为 0）
52
52|- `__reason`- 提取失败时的错误描述
53
53|
54
54|
55
55|## 常见用例 ** 工具参数准备 ** 从自然语言中提取特定参数，用于需要结构化输入的工作流工具。
56
56|
57
57|** 数据格式转换 ** 将文本转换为其他节点所需的格式，例如将列表转换为数为外部服务的 HTTP 请求构建数据，处理从用户意图到 API 兼容参数的转换。
58
58|
59
59|** 表单数据处理 ** 从自由格式的用户输入中提取结构化信息，用于数据库存储或进一步处理。
60
60|
61
61|
62
62|## 最佳实践 ** 清晰的参数描述 ** 有助于大型语言模型准确理解要提取的信息及其格式。
63
63|
64
64|** 在指令中提供示例 ** 以提高提取准确性，特别是对于复杂或特定领域的参数。
65
65|
66
66|** 使用适当的数据类型 ** 以确保提取的参数符合下游节点的要求。
67
67|
68
68|** 处理提取失败 ** 通过检查`__is_success`变量并在提取失败时提供后备逻辑。
69
69|

1
 1|# 问题分类器
2
 2|
3
 3|> 原文：[问题分类器](https://docs.dify.ai/zh/use-dify/nodes/question-classifier)
4
 4|
5
 5|---
6
 6|
7
 7|## Documentation IndexFetch the complete documentation index at:[https://docs.dify.ai/llms.txt](https://docs.dify.ai/llms.txt)
8
 8|
9
 9|
10
10|> ⚠️ ⚠️ 本文档由 AI 自动翻译。如有任何不准确之处，请参考[英文原版](/en/use-dify/nodes/question-classifier)。
11
11|
12
12|问题分类器节点对用户输入进行智能分类，将对话路由到不同的工作流路径。无需构建复杂的条件逻辑，只需定义分类，让大语言模型基于语义理解判断最契合的一项。
13
13|
14
14|
15
15|## 配置
16
16|### 输入和模型设置 ** 输入变量 **- 选择要分类的内容，通常使用用户问题的`sys.query`，也可以是来自上游工作流节点的任意文本变量。
17
17|
18
18|** 模型选择 **- 选择用于分类的大语言模型。简单分类用速度较快的模型即可处理；分类边界细微时，更强的模型表现更好。
19
19|
20
20|
21
21|### 分类定义每个分类包含两段相互独立的文本：
22
22|
23
23|
24
24|- ** 分类描述 **（编辑器正文）是模型选择分支时读取的内容。
25
25|
26
26|写出能准确区分该分类内容的描述。分类边界相近时，使用「与……相关」「不包括……」等边界表述有助于模型做出判断。下游通过`class_name`输出。
27
27|
28
28|
29
29|- ** 分类标题 **（编辑器上方的小标题）是画布上展示的标签。
30
30|
31
31|双击默认的 ** 分类 N** 标题可重命名。下游通过`class_label`输出。
32
32|
33
33|标题和描述可独立编辑，以便你在画布上保留简洁易读的标签，同时为模型提供更完整、更具体的描述。
34
34|
35
35|每个分类对应一条潜在的输出路径，可连接到不同的下游节点，例如专门的知识库、响应模板或处理流程。
36
36|
37
37|
38
38|## 分类示例以下是问题分类器在客户服务场景中的使用方式：
39
39|
40
40|
41
41|** 已定义的分类 **：
42
42|
43
43|
44
44|- ** 售后服务 **- 保修申请、退货、维修以及购后支持
45
45|- ** 产品使用 **- 安装说明、故障排查、功能解释
46
46|- ** 其他问题 **- 不属于以上分类的一般问询 ** 分类结果 **：
47
47|
48
48|
49
49|- 「如何在 iPhone 14 上设置联系人？」 →** 产品使用 **
50
50|- 「我购买的产品保修期是多长？」 →** 售后服务 **
51
51|- 「今天天气如何？」 →** 其他问题 ** 每个分类结果路由到不同的知识库和响应策略，确保用户获得相关、专业的帮助。
52
52|
53
53|
54
54|## 高级配置
55
55|### 指令和指南在 ** 指令 ** 字段中添加详细的分类指南，用于处理边界场景、模棱两可的情况或特定业务规则。这有助于大语言模型理解分类之间的细微差别。
56
56|

1
 1|# 模板转换
2
 2|
3
 3|> 原文：[模板转换](https://docs.dify.ai/zh/use-dify/nodes/template)
4
 4|
5
 5|---
6
 6|
7
 7|## Documentation IndexFetch the complete documentation index at:[https://docs.dify.ai/llms.txt](https://docs.dify.ai/llms.txt)
8
 8|
9
 9|
10
10|> ⚠️ ⚠️ 本文档由 AI 自动翻译。如有任何不准确之处，请参考[英文原版](/en/use-dify/nodes/template)。
11
11|
12
12|模板转换节点使用 Jinja2 模板语法将来自多个来源的数据转换和格式化为结构化文本。可使用它来组合变量、格式化输出，并为下游节点或终端用户准备数据。
13
13|
14
14|
15
15|## Jinja2 模板模板转换节点使用 Jinja2 模板语法，根据工作流数据动态生成内容。该语法提供类似编程的能力，包括循环、条件判断和过滤器，适用于复杂的文本生成。
16
16|
17
17|
18
18|### 变量替换使用双花括号引用工作流变量：`{{ variable_name }}`。可使用点号和括号语法访问嵌套对象属性和数组元素。
19
19|
20
20|
21
21|```
22
22|`{{user.name}}
23
23|{{items[0].title}}
24
24|{{data.metrics.score}}
25
25|`
26
26|```
27
27|
28
28|### 条件逻辑使用 if-else 语句根据数据值显示不同内容：
29
29|
30
30|
31
31|```
32
32|`{%ifuser.subscription=='premium'%}
33
33|Welcome back, Premium Member! You have access to all features.
34
34|{%else%}
35
35|Consider upgrading to Premium for additional capabilities.
36
36|{%endif%}
37
37|`
38
38|```
39
39|
40
40|### 循环和迭代使用 for 循环处理数组和对象以生成重复内容：
41
41|
42
42|
43
43|```
44
44|`{%foriteminsearch_results%}
45
45|### Result{{loop.index}}
46
46|**Score**:{{item.score|round(2) }}
47
47|{{item.content}}
48
48|---
49
49|{%endfor%}
50
50|`
51
51|```
52
52|
53
53|
54
54|## 数据格式化
55
55|### 过滤器 Jinja2 过滤器在模板渲染时转换数据：
56
56|
57
57|
58
58|```
59
59|`{{name|upper}}
60
60|{{price|round(2) }}
61
61|{{content|replace('\n','') }}
62
62|{{tags|join(', ') }}
63
63|{{score|default('No score available') }}
64
64|`
65
65|```
66
66|
67
67|### 错误处理使用默认值和条件检查优雅处理缺失或无效数据：
68
68|
69
69|
70
70|```
71
71|`{{user.email|default('No email provided') }}
72
72|{{metrics.accuracy|round(2)ifmetrics.accuracyelse'Not calculated'}}
73
73|`
74
74|```
75
75|
76
76|## 交互式表单模板转换节点可在 Chatflow 中生成交互式 HTML 表单，用于收集结构化数据。
77
77|
78
78|提交后，表单值会作为终端用户的下一条聊天消息发送。具体格式取决于``的`data-format`属性：
79
79|
80
80|
81
81|- **`data-format="json"`**：值会序列化为 JSON 对象。下游的代码执行节点或参数提取器可调用`JSON.parse`（或用模式匹配）提取各字段。
82
82|- ** 未设置（或为其他值）**：值以纯文本发送，每行一个`name: value`。便于 LLM 阅读。例如：
83
83|
84
84|
85
85|```
86
86|`<formdata-format="json">
87
87|  <labelfor="username">Username:label>
88
88|  <inputtype="text"name="username"placeholder="Please enter"/>
89
89|  <labelfor="password">Password:label>
90
90|  <inputtype="password"name="password"placeholder="Please enter"/>
91
91|  <labelfor="content">Content:label>
92
92|  <textareaname="content">textarea>
93
93|  <labelfor="date">Date:label>
94
94|  <inputtype="date"name="date"/>
95
95|  <labelfor="time">Time:label>
96
96|  <inputtype="time"name="time"/>
97
97|  <labelfor="datetime">Datetime:label>
98
98|  <inputtype="datetime"name="datetime"/>
99
99|  <labelfor="select">Select:label>