

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Anpassen des Verhaltens Ihres Amazon-Bedrock-Agenten mit benutzerdefinierter Orchestrierung
<a name="agents-custom-orchestration"></a>

Amazon Bedrock bietet Ihnen die Möglichkeit, die Orchestrierungsstrategie Ihres Agenten individuell anzupassen. Mit der benutzerdefinierten Orchestrierung haben Sie die volle Kontrolle darüber, wie Ihre Agenten mehrstufige Aufgaben erledigen, Entscheidungen treffen und Workflows ausführen sollen. 

Mit der benutzerdefinierten Orchestrierung können Sie Agenten für Amazon Bedrock erstellen, die eine für Ihren Anwendungsfall spezifische Orchestrierungslogik implementieren können. Dazu gehören komplexe Orchestrierungs-Workflows, Überprüfungsschritte oder mehrstufige Prozesse, bei denen Agenten mehrere Aktionen ausführen müssen, bevor sie zu einer endgültigen Antwort gelangen. 

Um die benutzerdefinierte Orchestrierung für Ihren Agenten zu verwenden, erstellen Sie eine AWS Lambda-Funktion, die Ihre Orchestrierungslogik beschreibt. Die Funktion steuert, wie der Agent auf Eingaben reagiert, indem sie dem Bedrock-Laufzeitprozess Anweisungen gibt, wann und wie das Modell und wann Aktionstools aufgerufen werden müssen, und dann die endgültige Antwort bestimmt. 

Die benutzerdefinierte Orchestrierungsoption ist in allen AWS-Regionen verfügbar, in denen Agenten für Amazon Bedrock verfügbar sind. 

Sie können die benutzerdefinierte Orchestrierung in der AWS-Managementkonsole oder über die API konfigurieren. Vergewissern Sie sich, dass die Funktion AWS Lambda zum Testen bereit ist, bevor Sie fortfahren.

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

In der Konsole können Sie die benutzerdefinierte Orchestrierung konfigurieren, nachdem Sie den Agenten erstellt haben. Diese konfigurieren Sie, während Sie den Agenten bearbeiten.

**So zeigen Sie die benutzerdefinierte Orchestrierung Ihren Agenten an oder bearbeiten Sie sie**

1. Melden Sie sich bei der AWS-Managementkonsole mit einer IAM-Identität an, die zur Verwendung der Amazon-Bedrock-Konsole berechtigt ist. Öffnen Sie dann die Amazon-Bedrock-Konsole unter [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).

1. Wählen Sie im linken Navigationsbereich die Option **Kundendienstmitarbeiter** aus. Wählen Sie dann im Abschnitt **Agenten** einen Agenten aus.

1. Wählen Sie auf der Detailseite des Agenten im Abschnitt **Arbeitsentwurf** die Option **Arbeitsentwurf** aus.

1. Wählen Sie auf der Seite **Arbeitsentwurf** im Abschnitt **Orchestrierungsstrategie** die Option **Bearbeiten** aus.

1. Wählen Sie auf der Seite **Orchestrierungsstrategie** im Abschnitt **Details zur Orchestrierungsstrategie** die Option **Benutzerdefinierte Orchestrierung** aus.

1. Wählen Sie für die **Lambda-Funktion für benutzerdefinierte Orchestrierung** die Lambda-Funktion aus dem Dropdown-Menü und für **Funktionsversion** die Version aus.

1. Aktivieren Sie die Option **Vorlage aktivieren**, damit sie vom Agenten beim Generieren von Antworten verwendet werden kann. Wenn diese Konfiguration deaktiviert ist, verwendet der Agent sie nicht.

1. Oben auf der Seite wird ein grünes Banner angezeigt, das Sie darüber informiert, dass die Änderungen erfolgreich gespeichert wurden.

1. Wählen Sie eine der folgenden Optionen aus, um Ihre Einstellungen zu speichern:

   1. Wenn Sie im selben Fenster bleiben möchten, sodass Sie die Funktion AWS Lambda dynamisch ändern können, während Sie Ihren aktualisierten Agenten testen, wählen Sie **Speichern** aus.

   1. Wenn Sie die Einstellungen zu speichern und zur Seite mit dem **Arbeitsentwurf** zurückzukehren möchten, wählen Sie **Speichern und beenden** aus.

1. Um die benutzerdefinierte Orchestrierung Ihres Agenten zu testen, wählen Sie im Fenster **Test** die Option **Vorbereiten** aus.

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

Um die benutzerdefinierte Orchestrierung mithilfe der API-Operationen zu konfigurieren, senden Sie eine [UpdateAgent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateAgent.html)-Anfrage (siehe Link für Anfrage- und Antwortformate und Felddetails) mit einem [Build-Time-Endpunkt für Agenten für Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Geben Sie das Objekt `orchestrationType` als `CUSTOM_ORCHESTRATION` an.

**Beispiel für Orchestrierungsnutzdaten in React**

Nachfolgend finden Sie ein React-Beispiel, das die Orchestrierung der Gedankenkette zeigt. In diesem Beispiel fordert der Amazon-Bedrock-Agent das Modell nach jedem Schritt auf, die nächste Aktion vorherzusagen. Beachten Sie, dass der erste Status einer Konversation immer `START` lautet. Ereignisse sind die Antworten, die die Funktion als Antwort an Agenten für Amazon Bedrock sendet.

```
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);
                    }
```

**Beispiel für Orchestrierungsnutzdaten in Lambda**

Das folgende Beispiel zeigt die Orchestrierung der Gedankenkette. In diesem Beispiel fordert der Amazon-Bedrock-Agent das Modell nach jedem Schritt auf, die nächste Aktion vorherzusagen. Beachten Sie, dass der erste Status einer Konversation immer `START` lautet. Ereignisse sind die Antworten, die die Funktion als Antwort an Agenten für Amazon Bedrock sendet.

Die Nutzdatenstruktur an Orchestrierungs-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}}
        }
    }
}
```

Die Nutzdatenstruktur von Orchestrierungs-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}}
        }
    }
}
```

Beispiel für einen START\_STATE, der von Agenten für Amazon Bedrock an Orchestrator-Lambda gesendet wurde

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

Wenn Orchestrierungs-Lambda als Antwort eine INVOKE\_MODEL EVENT-Antwort sendet, könnte diese etwa wie folgt aussehen:

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

Beispiel für ein INVOKE\_TOOL\_EVENT über die Converse-API 

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

------