流的节点类型 - Amazon Bedrock
用于控制流逻辑的节点用于处理流中数据的节点节点类型汇总表

本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

流的节点类型

Amazon Bedrock 提供了以下节点类型用于构建流。配置节点时，您需要提供以下字段：

  • 名称 – 输入节点的名称。

  • 类型 – 在控制台中，您可以拖放要使用的节点类型。在 API 中，在 configuration 字段中使用 type 字段和相应的 FlowNodeConfiguration。

  • 输入 – 为每个输入提供以下信息：

    • Name – 输入的名称。有些节点有预定义名称或类型，您必须使用这些名称和类型。要了解哪些节点有预定义名称，请参阅逻辑节点类型。

    • 表达式 – 定义整个输入中用作单个输入的部分。有关更多信息，请参阅在 Amazon Bedrock 流中提取整个输入的相关部分，使用表达式定义输入。

    • 类型 – 输入的数据类型。在运行时到达此节点时，Amazon Bedrock 会将表达式应用到整个输入，并验证结果是否与数据类型相匹配。

  • 输出 – 为每个输出提供以下信息：

    • 名称 – 输出的名称。有些节点有预定义名称或类型，您必须使用这些名称和类型。要了解哪些节点有预定义名称，请参阅逻辑节点类型。

    • 类型 – 输出的数据类型。在运行时到达此节点时，Amazon Bedrock 会验证节点输出是否与数据类型相匹配。

  • 配置 – 在控制台中，您可以在节点顶部定义特定于节点的字段。在 API 中，使用相应的 FlowNodeConfiguration 并填写其字段。

下文介绍了每种节点类型，并提供了它们在 API 中的结构。展开一个部分可了解有关该节点类型的更多信息。

用于控制流逻辑的节点

使用以下节点类型来控制流的逻辑。

每个流仅包含一个流输入节点，并且必须以该节点开头。工作流输入节点从 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
    }
}

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

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

定义条件节点

  1. 根据需要添加任意数量的输入，以评估您计划添加的条件。

  2. 为每个输入输入名称，指定预期的类型，然后编写一个表达式以从整个输入中提取相关部分。

  3. 将每个输入连接到上游节点的相关输出。

  4. 根据需要添加多个条件。

  5. 对于每个条件：

    1. 为连接输入名称。

    2. 使用关系运算符和逻辑运算符定义条件，以将输入与其他输入或常量进行比较。

      注意

      条件是按顺序进行评估的。如果满足多个条件，则排在前面的条件优先。

    3. 将每个条件连接到您想要发送数据的下游节点（如果满足该条件）。

条件表达式

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

运算符 意义 支持的数据类型 示例用法 示例含义
== 等于（数据类型也必须等于） 字符串、数字、布尔值 A == B 如果 A 等于 B
!= 不等于 字符串、数字、布尔值 A != B 如果 A 不等于 B
> Greater than 数字 A > B 如果 A 大于 B
>= 大于或等于 数字 A >= B 如果 A 大于或等于 B
< Less than 数字 A < B 如果 A 小于 B
<= 小于或等于 数字 A <= B 如果 A 小于或等于 B

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

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

运算符 意义 示例用法 示例含义
以及 两个表达式都有效 (A < B) and (C == 1) 如果两个表达式都有效：

  • A 小于 B

  • C 等于 1
或 至少有一个表达式有效 (A != 2) or (B > C) 如果任一表达式有效：

  • A 不等于 B

  • B 大于 C
not 表达式无效 not (A > B) 如果 A 不大于 B（相当于 A <= B）

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

  1. nodes 数组中的条件 FlowNode 对象。一般格式如下（请注意，条件节点没有 outputs）：

    {
    "name": "string",
    "type": "Condition",
    "inputs": [
        {
            "name": "string",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        }
    ],
    "configuration": {
        "condition": {
            "conditions": [
                {
                    "name": "string",
                    "expression": "string"
                },
                ...
            ]
        }
    }
}

  2. 对于条件节点的每个输入，connections 数组中都有一个 FlowConnection 对象。在 FlowConnection 对象的 configuration 字段中包含一个 FlowConnection 对象。FlowConnection 对象的一般格式如下：

    {
    "name": "string",
    "source": "string",
    "target": "string",
    "type": "Data",
    "configuration": {
        "data": {
            "sourceOutput": "string",
            "expression": "string"
        }
    }
}

  3. 对于条件节点中的每个条件（包括默认条件），在 connections 数组中添加一个 FlowConnection 对象。在 FlowConnection 对象的 configuration 字段中包含一个 FlowConditionalConnectionConfiguration 对象。FlowConnection 对象的一般格式如下：

    {
    "name": "string",
    "source": "string",
    "target": "string",
    "type": "Conditional",
    "configuration": {
        "conditional": {
            "condition": "string"
        }
    }
}

    使用关系运算符和逻辑运算符定义连接此条件 source 节点和下游 target 节点的 condition。对于默认条件，请将该条件指定为 default。

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

下面显示了迭代器 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
    }
}

当指定的条件保持为 true 时，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"
        }
    }
}

在配置中：

  • condition – 决定是否继续循环的布尔表达式。使用与条件节点相同的关系和逻辑运算符。每次迭代后都会对条件进行评测。

  • maxIterations – 最大迭代次数。默认值为 10。您必须指定正数。此参数可帮助您避免无限循环。

注意

maxIterations 参数的默认值为 10，并且只接受正数。当条件变为 false 或达到最大迭代次数时，循环就会退出。

用于处理流中数据的节点

使用以下节点类型来处理流中的数据：

提示节点定义了要在工作流中使用的提示。您可以使用提示管理器中的提示，也可以在节点中定义一个内联提示。有关更多信息，请参阅在 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 对象取决于您使用的是提示管理器中的提示还是内联定义提示：

  • 如果您使用的是提示管理器中的提示，对象的一般结构应类似以下内容：

    {
    "resource": {
        "promptArn": "string"
    }
}

  • 如果您使用的是内联定义提示，请遵循使用提示管理器创建提示的 API 选项卡（但请注意，该对象中没有 name 字段）中有关定义变体的指导。您使用的对象的一般结构应类似以下内容：

    {
    "inline": {
        "modelId": "string",
        "templateType": "TEXT",
        "templateConfiguration": {
            "text": {
                "text": "string",
                "inputVariables": [
                    {
                        "name": "string"
                    },
                    ...
                ]
            }
        },
        "inferenceConfiguration": {
            "text": {
                "maxTokens": int,
                "stopSequences": ["string", ...],
                "temperature": float,
                "topP": float
            }
        },
        "additionalModelRequestFields": {
            "key": "value",
            ...
        }
    }
}

要将来自 Amazon Bedrock 护栏的一个护栏应用于您的提示或从提示生成的响应，请添加 guardrailConfiguration 字段，然后在 guardrailIdentifier 字段中指定该护栏的 ID 或 ARN 并在 guardrailVersion 字段中指定该护栏的版本。

代理节点让您可以向代理发送提示，代理可在 FM 和相关资源之间进行协调，以识别和执行终端用户的操作。有关更多信息，请参阅使用人工智能代理在应用程序中自动执行任务。

在配置中，指定要使用的代理别名的 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 知识库检索数据并生成人工智能响应。

在配置中，至少要提供 knowledgeBaseId。您可以根据使用案例选择性地添加以下字段：

  • modelId – 如果要根据检索到的结果生成响应，请添加要使用的模型 ID。要以数组形式返回检索结果，请省略模型 ID。

  • guardrailConfiguration – 在 guardrailIdentifier 字段中添加在 Amazon Bedrock 护栏中定义的护栏的 ID 或 ARN，在 guardrailVersion 字段中添加护栏的版本。

    注意

    只有在知识库节点中使用 RetrieveAndGenerate 时才能应用护栏。

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

下面显示了知识库 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 位置中的数据必须是 UTF-8 编码字符串。

下面显示了 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 托管式环境中执行您的代码，该环境不与任何人共享，也无法访问互联网。

注意

内联代码节点在 Amazon Bedrock 中为预览版，可能会有变化。

在节点配置中，指定要执行的代码以及编程语言（目前，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 3.12 (Python_3)。

  • 内联代码的作用类似于交互式 Python 会话。仅捕获最后执行的行的结果，并将其作为节点输出返回。

  • 不捕获 Python 控制台输出（如来自 print 函数的输出）。

  • 内联代码节点的输入在代码中以 Python 变量形式提供。使用节点输入的确切名称来引用它们。

  • 正确地配置输入和输出类型以避免运行时错误。最多可以配置五个节点输入。

  • 每个流最多可以有五个内联代码节点。

  • 每个 AWS 账户最多可以有 25 个正在运行的内联代码节点。

  • 代码不能超过 5 MB。

内联代码节点输入

内联代码节点的输入在代码中以 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 服务，该服务可能会存储和使用客户内容，用于开发和持续改进其他 AWS 服务。作为 AWS 的客户，您可以选择不存储您的内容，或不将您的内容用于改进服务。要了解如何为 Amazon Lex 实施选择退出策略，请参阅 AI services opt-out policies。

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

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

注意

目前，Lex 节点不支持多轮对话。一个 Lex 节点只能处理一个语句。

下面显示了 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"
        }
    }
}

节点类型汇总表

以下各表总结了每种节点类型允许的输入和输出。请注意以下几点：

  • 如果名称标记为任何，您可以提供任何字符串作为名称，否则必须使用表中指定的值。

  • 如果类型标记为任何，您可以指定以下任何数据类型：字符串、数字、布尔值、对象、数组，否则必须使用表中指定的类型。

  • 您可以为条件、提示、Lambda 函数和内联代码节点定义多个输入。

逻辑节点类型
输入信息 输出信息
节点类型 输入 名称 类型 输出 名称 类型
输入 不适用 不适用 不适用 InvokeFlow 请求中的 content 字段。 document 任何
输出： 要在 InvokeFlow 响应中返回的数据。 document 任何 不适用 不适用 不适用
Condition

基于条件发送的数据。

（允许的多个输入）

 任何 任何

基于条件发送的数据。

（为不同路径指定条件）

 任何 任何
迭代器 一个数组，您要将以下节点迭代应用到该数组的每个成员。 array 数组 数组中的每个项目 arrayItem 任何
输入数组的大小 arraySize 数字
收集器 要合并到数组中的迭代。 arrayItem 任何 一个数组，其中附加了前一个节点的所有输出。 collectedArray 数组
输出数组的大小 arraySize 数字
DoWhile 循环 循环中要处理的数据。 loopInput 任何 所有迭代完成后循环的最终输出。 loopOutput 任何
迭代执行的次数。 iterationCount 数字
数据处理节点类型
输入信息 输出信息
节点类型 输入 名称 类型 输出 名称 类型
提示

用于在提示中填充变量的值（允许多个输入）。

 ${variable-name} 任何 模型返回的响应。 modelCompletion 字符串
S3 存储 要存储在 S3 存储桶中的数据。 content 任何 S3 位置的 URI。 s3Uri 字符串
用于 S3 对象的对象键。 objectKey 字符串
S3 检索 S3 对象的对象键。 objectKey 字符串 要从 S3 存储桶中检索的数据。 s3Content 任何
座席 要发送给代理的提示。 agentInputText 字符串 代理返回的响应。 agentResponse 字符串
要与提示一起发送的任何提示属性。 promptAttributes 对象
要与提示一起发送的任何会话属性。 sessionAttributes 对象
知识库 对知识库的查询。 retrievalQuery 字符串 知识库返回的结果或生成的响应。 retrievalResults 数组
Lambda 函数

要发送到函数的数据（允许多个输入）。

 任何 任何 函数返回的响应。 functionResponse 任何
内联代码节点

供您的代码执行的变量（允许多个输入）。

 任何 任何 代码中执行的最后一行。 response 任何
Lex 要发送给机器人的语句。 inputText 字符串 机器人预测的语句的意图。 predictedIntent 字符串
要与语句一起发送的任何请求属性。 requestAttributes 对象
要与语句一起发送的任何回话属性。 sessionAttributes 对象