

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Personalización del comportamiento de un agente de Amazon Bedrock con la orquestación personalizada
<a name="agents-custom-orchestration"></a>

Amazon Bedrock le ofrece la opción de personalizar la estrategia de orquestación de su agente. La orquestación personalizada le brinda control total sobre cómo desea que los agentes gestionen las tareas de varios pasos, tomen decisiones y ejecuten los flujos de trabajo. 

Elija la orquestación personalizada para crear agentes de Amazon Bedrock que puedan implementar una lógica de orquestación específica para su caso de uso. Esto incluye flujos de trabajo de orquestación complejos, pasos de verificación o procesos de varios pasos en los que los agentes deben realizar varias acciones antes de llegar a una respuesta final. 

Para usar la orquestación personalizada para su agente, cree una AWS Lambda función que describa su lógica de orquestación. La función controla la forma en que el agente responde a la entrada proporcionando instrucciones al proceso de tiempo de ejecución de Bedrock sobre cuándo y cómo invocar el modelo, cuándo invocar las herramientas de acciones y, a continuación, determinar la respuesta final. 

La opción de orquestación personalizada está disponible en todos los Regiones de AWS lugares donde Amazon Bedrock Agents esté disponible. 

Puede configurar la orquestación personalizada en la API Consola de administración de AWS o a través de ella. Antes de continuar, asegúrate de tener la AWS Lambda función lista para la prueba.

------
#### [ Console ]

En la consola, puede configurar la orquestación personalizada una vez creado el agente. Las configura mientras edita el agente.

**Cómo ver o editar la orquestación personalizada de su agente**

1. Inicie sesión Consola de administración de AWS con una identidad de IAM que tenga permisos para usar la consola Amazon Bedrock. A continuación, abra la consola Amazon Bedrock en [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).

1. En el panel de navegación situado a la izquierda, elija **Agentes**. A continuación, elija un agente en la sección **Agentes**.

1. En la página de detalles del agente, en la sección **Borrador de trabajo**, seleccione **Borrador de trabajo**.

1. En la página **Borrador de trabajo**, en la sección **Estrategia de orquestación**, seleccione **Editar**.

1. En la página **Estrategia de orquestación**, en la sección **Detalles de la estrategia de orquestación**, seleccione **Orquestación personalizada**.

1. En **Función de Lambda de orquestación personalizada**, elija la función de Lambda en el menú desplegable y, en **Versión de función**, elija la versión.

1. Active la opción **Activar plantilla** para que el agente pueda usar la plantilla al generar respuestas. Si esta configuración está desactivada, el agente no usa la plantilla.

1. Aparecerá un banner verde en la parte superior de la página que indica que los cambios se guardaron correctamente.

1. Para guardar la configuración, elija una de las siguientes opciones:

   1. Para permanecer en la misma ventana y poder cambiar la AWS Lambda función de forma dinámica mientras se prueba el agente actualizado, seleccione **Guardar**.

   1. Seleccione **Guardar y salir** para guardar la configuración y volver a la página **Borrador de trabajo**.

1. Para probar la orquestación personalizada de su agente, seleccione **Preparar** en la ventana **Prueba**.

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

Para configurar la orquestación personalizada mediante las operaciones de la API, envíe una [UpdateAgent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateAgent.html)solicitud (consulte el enlace para ver los formatos de solicitud y respuesta y los detalles de los campos) a un [punto final en tiempo de compilación de Agents for Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Especifique el objeto como. `orchestrationType` `CUSTOM_ORCHESTRATION`

**Ejemplo de carga útil de orquestación en React**

El siguiente es un ejemplo de React que muestra la orquestación de la cadena de pensamiento. En este ejemplo, después de cada paso, el agente de Amazon Bedrock pide al modelo que prediga la siguiente acción. Tenga en cuenta que el primer estado de cualquier conversación es siempre `START`. Los eventos son las respuestas que la función envía como respuesta a los agentes de 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);
                    }
```

**Ejemplo de carga útil de orquestación en Lambda**

En el siguiente ejemplo se muestra la orquestación de la cadena de pensamiento. En este ejemplo, después de cada paso, el agente de Amazon Bedrock pide al modelo que prediga la siguiente acción. Tenga en cuenta que el primer estado de cualquier conversación es siempre `START`. Los eventos son las respuestas que la función envía como respuesta a los agentes de Amazon Bedrock.

La estructura de carga útil para la orquestación en 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}}
        }
    }
}
```

La estructura de carga útil para la orquestación en 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}}
        }
    }
}
```

Ejemplo de un START\_STATE enviado desde Agentes para Amazon Bedrock al orquestador de Lambda

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

En respuesta, si la orquestación de Lambda decide enviar una respuesta INVOKE\_MODEL EVENT, podría tener un aspecto similar al siguiente:

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

Ejemplo de un INVOKE\_TOOL\_EVENT que utiliza la API de Converse 

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

------