流的节点类型

每个流程仅包含一个流程输入节点，并且必须以该节点开头。工作流输入节点从 InvokeFlow 请求中获取 content，验证数据类型，然后将其发送到下面的节点。

以下显示了 API 中输入FlowNode对象的一般结构：

{
    "name": "string",
    "type": "Input",
    "outputs": [
        {
            "name": "document",
            "type": "String | Number | Boolean | Object | Array",
        }
    ],
    "configuration": {
        "input": CONTEXT-DEPENDENT
    }
}

工作流输出节点根据定义的表达式从前一个节点提取输入数据，然后将其返回。在控制台中，输出是在测试窗口中选择运行后返回的响应。在 API 中，输出将在 InvokeFlow 响应中 flowOutputEvent 的 content 字段中返回。一个流程可以有多个流量输出节点。

如果一个工作流中有多个分支，则该工作流可以有多个工作流输出节点。

下面显示了输出FlowNode对象的一般结构：

{
    "name": "string",
    "type": "Output",
    "inputs": [
        {
            "name": "document",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        }
    ],
    "configuration": {
        "output": CONTEXT-DEPENDENT
    }
}

条件节点会根据定义的条件将前一个节点的数据发送到其他节点。一个条件节点可以接受多个输入。

有关示例，请参阅创建具有条件节点的工作流。

条件表达式

要定义一个条件，您可以按输入的名称来引用输入，然后使用以下任意关系运算符将其与值进行比较：

在条件表达式中，您可以将输入与其他输入或常量进行比较。例如，如果您有一个名为 profit 的数字输入和另一个名为 expenses 的数字输入，那么 profit > expenses 或 profit <= 1000 都是有效的表达式。

对于更复杂的条件，您可以使用以下逻辑运算符来组合表达式。我们建议您使用括号来解决表达式分组中的歧义：

在 API 中，您在发送CreateFlow或UpdateFlow请求时在definition字段中定义以下内容：

迭代器节点接收一个数组，并以迭代方式将其项目作为输出返回到下游节点。迭代器节点的输入是逐个处理的，而不是并行处理。流输出节点以不同的响应方式返回每个输入的最终结果。您还可以使用迭代器节点下游的收集器节点来收集迭代后的响应，并将其作为数组返回，此外还可以设置数组的大小。

下面显示了迭代器FlowNode对象的一般结构：

{
    "name": "string",
    "type": "Iterator",
    "inputs": [
        {
            "name": "array",
            "type": "Array",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "arrayItem",
            "type": "String | Number | Boolean | Object | Array",
        },
        {
            "name": "arraySize",
            "type": "Number"
        }
    ],
    "configuration": {
        "iterator": CONTEXT-DEPENDENT
    }
}

收集器节点除了接收迭代后的输入外，还可以设置数组的大小，然后将其作为数组返回。通过某些节点发送迭代后的项目后，您可以在迭代器节点的下游使用收集器节点将这些项目收集起来。

下面显示了收集器FlowNode对象的一般结构：

{
    "name": "string",
    "type": "Collector",
    "inputs": [
        {
            "name": "arrayItem",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        {
            "name": "arraySize",
            "type": "Number"
        }
    ],
    "outputs": [
        {
            "name": "collectedArray",
            "type": "Array"
        },
    ],
    "configuration": {
        "collector": CONTEXT-DEPENDENT
    }
}

当指定的条件保持为真时， DoWhile 循环节点会重复执行一系列节点。在评估条件之前，该循环至少执行一次，因此非常适合需要执行操作然后根据结果检查是否应该重复操作的场景。

DoWhile 循环节点获取输入数据并将其传递到循环主体。每次迭代后，都会评估条件以确定是继续循环还是退出。只要条件的计算结果为 true，或者未超过，循环就会继续。maxIterations

下面显示了 DoWhile 循环FlowNode对象的一般结构：

{
    "name": "string",
    "type": "DoWhile",
    "inputs": [
        {
            "name": "loopInput",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "loopOutput",
            "type": "String | Number | Boolean | Object | Array"
        },
        {
            "name": "iterationCount",
            "type": "Number"
        }
    ],
    "configuration": {
        "doWhile": {
            "condition": "string",
            "maxIterations": "number"
        }
    }
}

在配置中：

提示节点定义了要在工作流中使用的提示。您可以使用提示管理器中的提示，也可以在节点中定义一个内联提示。有关更多信息，请参阅 在 Amazon Bedrock 中使用提示管理器构建和存储可重复使用的提示。

有关示例，请参阅尝试示例流程。

提示节点的输入是用于填充变量的值。输出则是模型生成的响应。

下面显示了提示FlowNode对象的一般结构：

{
    "name": "string",
    "type": "prompt",
    "inputs": [
        {
            "name": "content",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        ...
    ],
    "outputs": [
        {
            "name": "modelCompletion",
            "type": "String"
        }
    ],
    "configuration": {
        "prompt": {
            "sourceConfiguration": PromptFlowNodeSourceConfiguration object (see below),
            "guardrailConfiguration": {
                "guardrailIdentifier": "string",
                "guardrailVersion": "string"
            }
        }
    }
}

该PromptFlowNodeSourceConfiguration对象取决于你是使用 Prompt 管理中的提示还是内联定义它：

要将来自 Amazon Bedrock Guardrails 的护栏应用于您的提示或由此产生的响应，请在guardrailConfiguration字段中添加该字段并指定护栏的 ID 或 ARN，并在guardrailIdentifier字段中指定护栏的版本。guardrailVersion

代理节点允许您向代理发送提示，代理在 FMs 和关联的资源之间进行协调，以识别最终用户并为其执行操作。有关更多信息，请参阅 使用 AI 代理自动执行应用程序中的任务。

在配置中，指定要使用的代理别名的 Amazon 资源名称（ARN）。节点的输入是代理的提示以及任何相关的提示或会话属性。节点将代理的响应作为输出返回。

代理节点可以支持多回合调用，从而在流程执行期间启用用户与代理之间的交互式对话。当代理节点需要其他信息或澄清时，它可以暂停流程执行并请求用户提供特定输入。用户提供所请求的信息后，代理节点将继续处理新的输入。这种情况一直持续到代理节点获得完成其执行所需的所有信息为止

下面显示了代理FlowNode对象的一般结构：

{
    "name": "string",
    "type": "Agent",
    "inputs": [
       {
            "name": "agentInputText"
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        {
            "name": "promptAttributes"
            "type": "Object",
            "expression": "string"
        },
        {
            "name": "sessionAttributes"
            "type": "Object",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "agentResponse",
            "type": "String"
        }
    ],
    "configuration": {
        "agent": {
            "agentAliasArn": "string"
        }
    }
}

知识库节点允许您从 Amazon Bedrock 知识库向知识库发送查询。有关更多信息，请参阅 使用 Amazon Bedrock 知识库检索数据并生成 AI 响应。

在配置中，提供knowledgeBaseId最低限度。根据您的用例，您可以选择添加以下字段：

节点的输入是对知识库的查询。输出要么是模型响应（字符串形式），要么是检索到的结果的数组。

下图显示了知识库FlowNode对象的一般结构：

{
    "name": "string",
    "type": "KnowledgeBase",
    "inputs": [
       {
            "name": "retrievalQuery",
            "type": "String",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "retrievalResults" | "outputText",
            "type": "Array | String"
        }
    ],
    "configuration": {
        "knowledgeBase": {
            "knowledgeBaseId": "string",
            "modelId": "string",
            "guardrailConfiguration": {
                "guardrailIdentifier": "string",
                "guardrailVersion": "string"
            }
        }
    }
}

S3 存储节点允许您将数据流中的数据存储到 Amazon S3 存储桶。在配置中，您可以指定用于数据存储的 S3 存储桶。节点的输入是要存储的内容和对象键。节点的输出是其返回的 S3 位置的 URI。

以下显示了 S3 存储FlowNode对象的一般结构：

{
    "name": "string",
    "type": "Storage",
    "inputs": [
        {
            "name": "content",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        {
            "name": "objectKey",
            "type": "String",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "s3Uri",
            "type": "String"
        }
    ],
    "configuration": {
        "retrieval": {
            "serviceConfiguration": {
                "s3": {
                    "bucketName": "string"
                }
            }
        }
    }
}

S3 检索节点让您可以从 Amazon S3 位置检索数据，并将其引入工作流。在配置中，您可以指定要从中检索数据的 S3 存储桶。节点的输入是对象键。节点的输出是其返回的 S3 位置的内容。

下面显示了 S3 检索FlowNode对象的一般结构：

{
    "name": "string",
    "type": "Retrieval",
    "inputs": [
        {
            "name": "objectKey",
            "type": "String",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "s3Content",
            "type": "String"
        }
    ],
    "configuration": {
        "retrieval": {
            "serviceConfiguration": {
                "s3": {
                    "bucketName": "string"
                }
            }
        }
    }
}

通过 Lambda 函数节点，您可以调用一个 Lambda 函数，在其中定义代码来执行业务逻辑。当您在流程中包含 Lambda 节点时，Amazon Bedrock 会向您指定的 Lambda 函数发送一个输入事件。

对于配置，请指定 Lambda 函数的 Amazon 资源名称（ARN）。定义要在 Lambda 输入事件中发送的输入。您可以根据这些输入编写代码并定义函数返回的内容。函数响应将在输出中返回。

下面显示了 Lambda 函数FlowNode对象的一般结构：

{
    "name": "string",
    "type": "LambdaFunction",
    "inputs": [
       {
            "name": "codeHookInput",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        ...
    ],
    "outputs": [
        {
            "name": "functionResponse",
            "type": "String | Number | Boolean | Object | Array"
        }
    ],
    "configuration": {
        "lambdaFunction": {
            "lambdaArn": "string"
        }
    }
}

流程的 Lambda 输入事件

发送到 Lambda 节点中 Lambda 函数的输入事件采用以下格式：

{
   "messageVersion": "1.0",
   "flow": {
        "flowArn": "string",
        "flowAliasArn": "string"
   },
   "node": {
        "name": "string",
        "inputs": [
            {
               "name": "string",
               "type": "String | Number | Boolean | Object | Array",
               "expression": "string",
               "value": ...
            },
            ...
        ]
   }
}

每个输入的字段都与您在定义 Lambda 节点时指定的字段相匹配，而 value 字段的值则由通过表达式解析后的节点的整个输入填充。例如，如果节点的整个输入为 [1, 2, 3]，表达式为 $.data[1]，那么在输入事件中发送到 Lambda 函数的值将是 2。

有关更多信息，请参阅《AWS Lambda 开发人员指南》https://docs.aws.amazon.com/lambda/latest/dg/中的配置 Lambda 概念。

流的 Lambda 响应

编写 Lambda 函数时，您需要定义该函数返回的响应。此响应将作为 Lambda 节点的输出返回到您的流程。

内联代码节点可让您直接在流中编写和执行代码，无需使用外部 Lambda 函数即可实现数据转换、自定义逻辑和集成。当您在流程中包含内联代码节点时，Amazon Bedrock 会在隔离的 AWS 托管环境中执行您的代码，该环境不与任何人共享，也无法访问互联网。

在节点配置中，指定要执行的代码以及编程语言（目前Python_3是唯一的选项）。将您的代码可以访问的输入定义为变量。代码中最后执行的行的结果将作为节点输出返回。

以下示例显示了内联代码FlowNode对象的一般结构：

{
    "name": "string",
    "type": "InlineCode",
    "inputs": [{
            "name": "string",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        ...
    ],
    "outputs": [{
        "name": "response",
        "type": "String | Number | Boolean | Object | Array"
    }],
    "configuration": {
        "inlineCode": {
            "code": "string",
            "language": "Python_3"
        }
    }
}

使用内联代码节点时的注意事项

在流程中使用内联代码节点时，请考虑以下几点：

内联代码节点输入

您为内联代码节点定义的输入可在代码中作为 Python 变量使用。例如，如果您定义了一个名为的输入userData，则可以直接在代码中将其访问为userData。

每个输入的值将根据您定义的表达式进行填充。例如，如果节点的输入为{"name": "John", "age": 30}，表达式为$.name，则输入变量的值将为"John"。

内联代码节点输出

代码中最后执行行的结果将作为内联代码节点的输出返回。此输出可供流程中的后续节点使用。

例如，以下代码返回字典作为节点输出：

# Process input data
result = {"processed": True, "data": userData}

# The last line's result is returned as the node output
result

通过 Lex 节点，您可以调用 Amazon Lex 机器人来使用自然语言处理功能处理语句，并根据机器人定义识别意图。有关更多信息，请参阅 Amazon Lex 开发人员指南。

在配置中，指定要使用的机器人别名的 Amazon 资源名称（ARN）和要使用的区域设置。节点的输入是语句以及任何随附的请求属性或会话属性。节点的输出是已识别的意图。

以下显示了 Lex FlowNode对象的一般结构：

{
    "name": "string",
    "type": "Lex",
    "inputs": [
       {
            "name": "inputText",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        {
            "name": "requestAttributes",
            "type": "Object",
            "expression": "string"
        },
        {
            "name": "sessionAttributes",
            "type": "Object",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "predictedIntent",
            "type": "String"
        }
    ],
    "configuration": {
        "lex": {
            "botAliasArn": "string",
            "localeId": "string"
        }
    }
}