使用自定义编排自定义您的 Amazon Bedrock 代理的行为 - Amazon Bedrock

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

使用自定义编排自定义您的 Amazon Bedrock 代理的行为

Amazon Bedrock 为您提供了自定义代理编排策略的选项。借助自定义编排，您可以完全控制您希望代理如何处理多步骤任务、制定决策和执行工作流。

通过自定义编排，您可以构建 Amazon Bedrock 代理，这些代理能够实施特定于您的使用案例的编排逻辑。这包括复杂的编排工作流、验证步骤或多步骤流程，在这些流程中，代理必须执行多项操作才能得出最终答案。

要为代理使用自定义编排，请创建一个用于概述编排逻辑的 AWS Lambda 函数。该函数通过向 Bedrock 的运行时进程提供说明，来指明何时和如何调用模型、何时调用操作工具，然后确定最终响应，从而控制代理如何响应输入。

自定义编排选项适用于 Amazon Bedrock 代理可用的所有 AWS 区域。

您可以在 AWS 管理控制台中或通过 API 配置自定义编排。在继续之前，确保已准备好要测试的 AWS Lambda 函数。

Console

在控制台中，您可以在创建代理后配置自定义编排。您可以在编辑代理时进行配置。

查看或编辑代理的自定义编排

  1. 采用有权使用 Amazon Bedrock 控制台的 IAM 身份登录 AWS 管理控制台。然后，通过以下网址打开 Amazon Bedrock 控制台：https://console.aws.amazon.com/bedrock。

  2. 在左侧导航窗格中，选择代理。然后，在代理部分选择一个代理。

  3. 在代理详细信息页面上的工作草稿部分，选择工作草稿。

  4. 在工作草稿页面的编排策略部分中，选择编辑。

  5. 在编排策略页面的编排策略详细信息部分中，选择自定义编排。

  6. 对于自定义编排 Lambda 函数，请从下拉菜单中选择 Lambda 函数，对于函数版本，请选择版本。

  7. 要允许代理在生成响应时使用该模板，请打开激活模板。如果关闭此配置，代理将不会使用该模板。

  8. 页面顶部会出现一个绿色横幅，表示更改已成功保存。

  9. 要保存设置，请选择以下选项之一：

    1. 要保留在同一窗口中，以便在测试更新的代理时动态更改 AWS Lambda 函数，请选择保存。

    2. 要保存设置并返回工作草稿页面，请选择保存并退出。

  10. 要测试代理的自定义编排，请在测试窗口中选择准备。

API

要使用 API 操作配置自定义编排，请使用 Amazon Bedrock 代理构建时端点发送 UpdateAgent 请求（有关请求和响应格式以及字段详细信息，请参阅链接）。将 orchestrationType 对象指定为 CUSTOM_ORCHESTRATION。

React 中的编排有效载荷示例

下面是一个 React 示例，其中展示了思想链编排。在本示例中，执行每个步骤之后，Amazon Bedrock 代理都会要求模型预测下一步操作。请注意，任何对话的初始状态始终为 START。事件是函数作为对 Amazon Bedrock 代理的响应而发送的回复。

function react_chain_of_thought_orchestration(event) {
                    const incomingState = event.state;
                    
                    let payloadData = '';
                    let responseEvent = '';
                    let responseTrace = '';
                    let responseAttribution = '';
                    
                    if (incomingState == 'START') {
                        // 1. Invoke model in start
                        responseEvent = 'INVOKE_MODEL';
                        payloadData = JSON.stringify(intermediatePayload(event));
                    }
                    else if (incomingState == 'MODEL_INVOKED') {
                       const stopReason = modelInvocationStopReason(event);
                       if (stopReason == "tool_use") {
                           // 2.a. If invoke model predicts tool call, then we send INVOKE_TOOL event
                           responseEvent = 'INVOKE_TOOL';
                              payloadData = toolUsePayload(event);
                    } 
                    else if (stopReason == "end_turn") {
                         // 2.b. If invoke model predicts an end turn, then we send FINISH event
                         responseEvent = 'FINISH';
                         payloadData = getEndTurnPayload(event);
                      }
                    }
                    else if (incomingState == 'TOOL_INVOKED') {
                        // 3. After a tool invocation, we again ask LLM to predict what should be the next step
                        responseEvent = 'INVOKE_MODEL';
                        payloadData = intermediatePayload(event);
                    } 
                    else {
                       // Invalid incoming state
                       throw new Error('Invalid state provided!');
                    }
                    
                       // 4. Create the final payload to send back to BedrockAgent
                       const payload = createPayload(payloadData, responseEvent, responseTrace, ...);
                       return JSON.stringify(payload);
                    }

Lambda 中的编排有效载荷示例

下面的示例展示了思想链编排。在本示例中，执行每个步骤之后，Amazon Bedrock 代理都会要求模型预测下一步操作。请注意，任何对话的初始状态始终为 START。事件是函数作为对 Amazon Bedrock 代理的响应而发送的回复。

发送到编排 Lambda 的有效载荷结构

{
    "version": "1.0",
    "state": "START | MODEL_INVOKED | TOOL_INVOKED | APPLY_GUARDRAIL_INVOKED | user-defined",
    "input": {
        "text": "user-provided text or tool results in converse format"
    },
    "context": {
        "requestId": "invoke agent request id",
        "sessionId": "invoke agent session id",
        "agentConfiguration": {
            "instruction": "agent instruction>,
            "defaultModelId": "agent default model id",
            "tools": [{
                    "toolSpec": {...} 
                }
                ...
            ],
            "guardrails": {
                "version": "guardrail version",
                "identifier": "guardrail identifier"
            }
        },
        "session": [{
            "agentInput": "input utterance provided in invokeAgent",
            "agentOutput": "output response from invokeAgent",
            "intermediarySteps": [{
                "orchestrationInput": {
                    "state": "START | MODEL_INVOKED | TOOL_INVOKED | APPLY_GUARDRAIL_INVOKED | user defined",
                    "text": "..."
                },
                "orchestrationOutput": {
                    "event": "INVOKE_MODEL | INVOKE_TOOL | APPLY_GUARDRAIL | FINISH | user defined",
                    "text": "Converse API request or text"
                }
            }]
        }],
        "sessionAttributes": {
            key value pairs
        },
        "promptSessionAttributes": {
            key value pairs
        }
    }
}

来自编排 Lambda 的有效载荷结构

{
    "version": "1.0",
    "actionEvent": "INVOKE_MODEL | INVOKE_TOOL | APPLY_GUARDRAIL | FINISH | user defined",
    "output": {
        "text": "Converse API request for INVOKE_MODEL, INVOKE_TOOL, APPLY_GUARDRAIL or text for FINISH",
        "trace": {
            "event": {
                "text": "Trace message to emit as event in InvokeAgent response"
            }
        }
    },
    "context": {
        "sessionAttributes": {
            key value pairs
        },
        "promptSessionAttributes": {
            key value pairs
        }
    }
}

从 Amazon Bedrock 代理发送到编排工具 Lambda 的 START_STATE 示例

{
    "version": "1.0",
    "state": "START",
    "input": {
        "text": "{\"text\":\"invoke agent input text\"}"
    },
    "context": {
        ...
    }
}

如果编排 Lambda 决定发送 INVOKE_MODEL EVENT 响应，其响应可能类似于以下内容：

{
    "version": "1.0",
    "actionEvent": "INVOKE_MODEL",
    "output": {
        "text": "converse API request",
        "trace": {
            "event": {
                "text": "debug trace text"
            }
        }
    },
    "context": {}
}

使用 Converse API 的 INVOKE_TOOL_EVENT 示例 

{
    "version": "1.0",
    "actionEvent": "INVOKE_TOOL",
    "output": {
        "text": "{\"toolUse\":{\"toolUseId\":\"unique id\",\"name\":\"tool name\",\"input\":{}}}"
    }
}