

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Personnalisation du comportement de votre agent Amazon Bedrock grâce à une orchestration personnalisée
<a name="agents-custom-orchestration"></a>

Amazon Bedrock vous offre la possibilité de personnaliser la stratégie d’orchestration de votre agent. L’orchestration personnalisée vous permet de contrôler totalement la manière dont vous souhaitez que vos agents gèrent les tâches en plusieurs étapes, prennent des décisions et exécutent les flux de travail. 

L’orchestration personnalisée vous permet de créer des agents Amazon Bedrock capables de mettre en œuvre une logique d’orchestration spécifique à votre cas d’utilisation. Cela inclut des flux de travail d’orchestration complexes, des étapes de vérification ou des processus en plusieurs étapes dans lesquels les agents doivent effectuer plusieurs actions avant de parvenir à une réponse finale. 

Pour utiliser l’orchestration personnalisée pour votre agent, créez une fonction AWS Lambda qui décrit votre logique d’orchestration. La fonction contrôle la façon dont l’agent répond aux entrées en fournissant des instructions au processus d’exécution du Bedrock indiquant quand et comment invoquer le modèle, quand invoquer les outils d’action, puis en déterminant la réponse finale. 

L’option d’orchestration personnalisée est disponible dans toutes les Régions AWS où Amazon Bedrock Agents est disponible. 

Vous pouvez configurer une orchestration personnalisée dans la AWS Management Console ou via l’API. Avant de continuer, assurez-vous que la fonction AWS Lambda est prête pour le test.

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

Dans la console, vous pouvez configurer une orchestration personnalisée après avoir créé l’agent. Vous les configurerez lors de la modification de l’agent.

**Pour afficher ou modifier l’orchestration personnalisée pour l’agent**

1. Connectez-vous à la AWS Management Console avec une identité IAM autorisée à utiliser la console Amazon Bedrock. Ensuite, ouvrez la console Amazon Bedrock à l’adresse [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).

1. Dans le panneau de navigation de gauche, choisissez **Agents**. Choisissez ensuite un agent dans la section **Agents**.

1. Sur la page des détails de l’agent, dans la section **Version préliminaire**, sélectionnez **Version préliminaire**.

1. Sur la page **Version préliminaire**, dans la section **Stratégie d’orchestration**, choisissez **Modifier**.

1. Sur la page **Stratégie d’orchestration**, dans la section **Détails de la stratégie d’orchestration**, sélectionnez **Orchestration personnalisée**.

1. Pour la **fonction Lambda d’orchestration personnalisée**, choisissez la fonction Lambda dans le menu déroulant et pour **Version de fonction**, choisissez la version.

1. Pour permettre à l’agent d’utiliser le modèle lors de la génération de réponses, activez l’option **Activer le modèle**. Si cette configuration est désactivée, l’agent n’utilisera pas le modèle.

1. Une bannière verte s’affiche dans la partie supérieure de la page pour indiquer que les modifications ont été enregistrées avec succès.

1. Pour enregistrer les paramètres, choisissez l’une des options suivantes :

   1. Pour rester dans la même fenêtre afin de pouvoir mettre à jour de manière dynamique la fonction AWS Lambda tout en testant votre agent mis à jour, choisissez **Enregistrer**.

   1. Pour enregistrer vos paramètres et revenir à la page **Version préliminaire**, choisissez **Enregistrer et quitter**.

1. Pour tester l’orchestration personnalisée de votre agent, choisissez **Préparer** dans la fenêtre **Test**.

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

Pour configurer une orchestration personnalisée à l’aide des opérations d’API, envoyez une demande [UpdateAgent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateAgent.html) (voir le lien pour les formats de demande et de réponse et les détails des champs) avec un [point de terminaison de développement des agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Spécifiez l’objet `orchestrationType` en tant que `CUSTOM_ORCHESTRATION`.

**Exemple de données utiles d’orchestration dans React**

Voici un exemple React qui montre la chaîne d’une orchestration pensée. Dans cet exemple, après chaque étape, l’agent Amazon Bedrock demande au modèle de prévoir la prochaine action. Notez que le premier état de toute conversation est toujours `START`. Les événements sont les réponses que la fonction envoie en réponse aux agents 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);
                    }
```

**Exemple de données utiles d’orchestration dans Lambda**

L’exemple suivant illustre la chaîne de l’orchestration pensée. Dans cet exemple, après chaque étape, l’agent Amazon Bedrock demande au modèle de prévoir la prochaine action. Notez que le premier état de toute conversation est toujours `START`. Les événements sont les réponses que la fonction envoie en réponse aux agents Amazon Bedrock.

La structure de données utiles pour l’orchestration 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 structure de données utiles d’une orchestration 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}}
        }
    }
}
```

Exemple d’un START\_STATE envoyé par Amazon Bedrock Agents à l’orchestrateur Lambda

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

En réponse, si l’orchestration Lambda décide d’envoyer une réponse INVOKE\_MODEL EVENT, cela peut ressembler à ce qui suit :

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

Exemple d’un INVOKE\_TOOL\_EVENT utilisant une API Converse 

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

------