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

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

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

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

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

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

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

您可以在 AWS Management Console 或中通过 API 配置自定义编排。在继续操作之前，请确保您的 AWS Lambda 函数已准备好进行测试。

Console

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

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

  1. 使用有权使用 Amazon Bedrock 控制台的 IAM 身份登录。 AWS Management Console 然后，打开 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 中的示例编排有效负载

以下是一个反应示例，显示了思想链的编排。在此示例中，在每个步骤之后，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
        }
    }
}

从亚马逊 Bedrock Agents 发送给编排器 Lambda 的 STAT_STATE 示例

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

作为响应，如果编排 Lambda 决定发送 INVOKE_MODEL 事件响应，则其外观可能类似于以下内容：

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

使用 API 的 INVOKE_TOOL_EVENT 示例 Converse 

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