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

# 使用自定义编排自定义您的 Amazon Bedrock 代理的行为
<a name="agents-custom-orchestration"></a>

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](https://console.aws.amazon.com/bedrock)。

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

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

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

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

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

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

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

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

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

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

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

------
#### [ API ]

要使用 API 操作配置自定义编排，请使用 [Amazon Bedrock 代理构建时端点](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt)发送 [UpdateAgent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateAgent.html) 请求（有关请求和响应格式以及字段详细信息，请参阅链接）。将 `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\$1STATE 示例

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

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

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

使用 Converse API 的 INVOKE\$1TOOL\$1EVENT 示例 

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

------