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.
# Verwenden von Aktionsgruppen, um Aktionen zu definieren, die Ihr Agent ausführen soll
Eine Aktionsgruppe definiert Aktionen, bei deren Ausführung der Agent dem Benutzer helfen kann. Sie könnten beispielsweise eine Aktionsgruppe mit dem Namen `BookHotel` definieren, mit der Benutzer Aktionen ausführen können, die Sie definieren können, wie z. B.:
+ `CreateBooking` – Hilft Benutzern, ein Hotel zu buchen
+ `GetBooking` – Hilft Benutzern, Informationen zu einem von ihnen gebuchten Hotel zu erhalten
+ `CancelBooking` – Hilft Benutzern, eine Buchung zu stornieren
Sie erstellen eine Aktionsgruppe, indem Sie die folgenden Schritte ausführen:
1. Definieren Sie die Parameter und Informationen, die der Agent für jede Aktion in der Aktionsgruppe, die ausgeführt werden soll, beim Benutzer abfragen muss.
1. Entscheiden Sie, wie der Agent die Parameter und Informationen verarbeitet, die er vom Benutzer erhält, und wohin er die Informationen sendet, die er beim Benutzer abfragt.
Wenn Sie mehr über die Komponenten einer Aktionsgruppe und darüber erfahren möchten, wie Sie die Aktionsgruppe erstellen und einrichten, wählen Sie eines der folgenden Themen aus:
**Topics**
+ [Definieren von Aktionen in der Aktionsgruppe](action-define.md)
+ [Verarbeiten der Ausführung der Aktion](action-handle.md)
+ [Hinzufügen einer Aktionsgruppe zu Ihrem Agenten in Amazon Bedrock](agents-action-add.md)
+ [Anzeigen von Informationen zu einer Aktionsgruppe](agents-action-view.md)
+ [Bearbeiten einer Aktionsgruppe](agents-action-edit.md)
+ [Löschen einer Aktionsgruppe](agents-action-delete.md)
# Definieren von Aktionen in der Aktionsgruppe
Sie können Aktionsgruppen auf eine der folgenden Arten definieren (Sie können unterschiedliche Methoden für verschiedene Aktionsgruppen verwenden):
+ Durch das [Einrichten eines OpenAPI-Schemas](agents-api-schema.md) mit Beschreibungen, Struktur und Parametern, die jede Aktion in der Aktionsgruppe als API-Operation definieren. Mit dieser Option können Sie Aktionen expliziter definieren und sie API-Operationen in Ihrem System zuordnen. Sie fügen das API-Schema auf eine der folgenden Arten zur Aktionsgruppe hinzu:
+ Laden Sie das von Ihnen erstellte Schema in einen Bucket von Amazon Simple Storage Service (Amazon S3) hoch.
+ Schreiben Sie das Schema im Inline-OpenAPI-Schema-Editor in der AWS-Managementkonsole, wenn Sie die Aktionsgruppe hinzufügen. Diese Option ist erst verfügbar, nachdem der Agent, zu dem die Aktionsgruppe gehört, bereits erstellt wurde.
+ Durch das [Einrichten von Funktionsdetails](agents-action-function.md) mit den Parametern, die der Agent beim Benutzer abfragen muss. Mit dieser Option können Sie den Prozess zur Erstellung von Aktionsgruppen vereinfachen und den Agenten so einrichten, dass er eine Reihe von Parametern abfragt, die Sie definieren. Anschließend können Sie die Parameter an Ihre Anwendung übergeben und anpassen, wie Sie sie zur Ausführung der Aktion in Ihren eigenen Systemen verwenden möchten.
Ausgehend vom obigen Beispiel können Sie die `CreateBooking`-Aktion auf eine der folgenden Arten definieren:
+ Durch ein API-Schema – `CreateBooking` könnte dabei eine API-Operation darstellen, deren Anforderungstext Felder wie `HotelName`, `LengthOfStay` und `UserEmail` enthält und deren Antworttext eine `BookingId` zurückgibt.
+ Durch Funktionsdetails – `CreateBooking` könnte dabei eine Funktion darstellen, die mit Parametern wie `HotelName`, `LengthOfStay` und `UserEmail` definiert ist. Nachdem Ihr Agent die Werte dieser Parameter beim Benutzer abgefragt hat, können Sie sie an Ihre Systeme übergeben.
Wenn Ihr Agent mit dem Benutzer interagiert, ermittelt er, welche Aktion innerhalb der Aktionsgruppe aufgerufen werden muss. Anschließend fragt der Agent die Parameter und weitere Informationen ab, die zum Abschließen der API-Anfrage notwendig sind oder die für die Funktion als *erforderlich* gekennzeichnet sind.
Wählen Sie ein Thema aus, um zu erfahren, wie Sie eine Aktionsgruppe mit verschiedenen Methoden definieren.
**Topics**
+ [Definieren der Funktionsdetails für die Aktionsgruppen Ihres Agenten in Amazon Bedrock](agents-action-function.md)
+ [Definieren von OpenAPI-Schemas für die Aktionsgruppen Ihres Agenten in Amazon Bedrock](agents-api-schema.md)
# Definieren der Funktionsdetails für die Aktionsgruppen Ihres Agenten in Amazon Bedrock
Wenn Sie eine Aktionsgruppe in Amazon Bedrock erstellen, können Sie Funktionsdetails definieren, um die Parameter anzugeben, die der Agent vom Benutzer aufrufen muss. Funktionsdetails bestehen aus einer Liste von Parametern, die durch ihren Namen, ihren Datentyp (eine Liste der unterstützten Datentypen finden Sie unter [ParameterDetail](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ParameterDetail.html)) und darüber, ob sie erforderlich sind, definiert werden. Der Agent bestimmt anhand dieser Konfigurationen, welche Informationen er beim Benutzer abfragen muss.
Sie könnten beispielsweise eine Funktion namens **BookHotel** definieren, die Parameter enthält, die der Agent vom Benutzer aufrufen muss, um ein Hotel für den Benutzer zu buchen. Sie könnten die folgenden Parameter für die Funktion definieren:
****
| Parameter | Beschreibung | Typ | Erforderlich |
| --- | --- | --- | --- |
| HotelName | Der Name des Hotels | Zeichenfolge | Ja |
| CheckinDate | Das Datum der Anreise | Zeichenfolge | Ja |
| NumberOfNights | Die Anzahl der Übernachtungen | Ganzzahl | Nein |
| Email | Eine E-Mail-Adresse, um den Benutzer zu kontaktieren | Zeichenfolge | Ja |
| AllowMarketingEmails | Ob Werbe-E-Mails an den Benutzer gesendet werden dürfen | boolesch | Ja |
Durch die Definition dieses Parametersatzes kann der Agent feststellen, ob er mindestens den Namen des Hotels, das der Benutzer buchen möchte, das Anreisedatum, die E-Mail-Adresse des Benutzers und die Frage, ob Werbe-E-Mails an seine E-Mail-Adresse gesendet werden dürfen, abfragen muss.
Wenn der Benutzer **"I want to book Hotel X for tomorrow"** sagt, würde der Agent die Parameter `HotelName` und `CheckinDate` ermitteln. Anschließend würde er sich mit dem Benutzer bezüglich der verbleibenden Parameter in Verbindung setzen und Fragen stellen wie:
+ „Wie lautet Ihre E-Mail-Adresse?“
+ „Möchten Sie dem Hotel erlauben, Ihnen Werbe-E-Mails zu senden?“
Sobald der Agent alle erforderlichen Parameter ermittelt hat, sendet er sie an eine Lambda-Funktion, die Sie für die Ausführung der Aktion definieren, oder gibt sie als Antwort auf den Agentenaufruf zurück.
Informationen zum Definieren einer Funktion bei der Erstellung der Aktionsgruppe finden Sie unter [Hinzufügen einer Aktionsgruppe zu Ihrem Agenten in Amazon Bedrock](agents-action-add.md).
# Definieren von OpenAPI-Schemas für die Aktionsgruppen Ihres Agenten in Amazon Bedrock
Wenn Sie eine Aktionsgruppe in Amazon Bedrock erstellen, müssen Sie die Parameter definieren, die der Agent vom Benutzer aufrufen muss. Sie können auch API-Operationen definieren, die der Agent mithilfe dieser Parameter aufrufen kann. Zum Definieren der API-Operationen erstellen Sie ein OpenAPI-Schema im JSON- oder YAML-Format. Sie können OpenAPI-Schemadateien erstellen und sie in Amazon Simple Storage Service (Amazon S3) hochladen. Alternativ können Sie den OpenAPI-Texteditor in der Konsole verwenden, der Ihr Schema validiert. Nachdem Sie einen Agenten erstellt haben, können Sie den Texteditor verwenden, wenn Sie dem Agenten eine Aktionsgruppe hinzufügen oder eine bestehende Aktionsgruppe bearbeiten. Weitere Informationen finden Sie unter [Ändern eines Agenten](agents-edit.md).
Der Agent bestimmt anhand des Schemas die API-Operation, die er aufrufen muss, und die Parameter, die für die API-Anfrage erforderlich sind. Diese Details werden dann über eine Lambda-Funktion gesendet, die Sie für die Ausführung der Aktion definieren, oder als Antwort auf den Agentenaufruf zurückgegeben.
Weitere Informationen zu API-Schemas finden Sie in den folgenden Ressourcen:
+ Weitere Informationen zu OpenAPI-Schemas finden Sie in der [OpenAPI-Spezifikation](https://swagger.io/specification/) auf der Swagger-Website.
+ Best Practices beim Schreiben von API-Schemas finden Sie unter [Best Practices beim API-Design](https://swagger.io/resources/articles/best-practices-in-api-design/) auf der Swagger-Website.
Nachstehend sehen Sie das allgemeine Format eines OpenAPI-Schemas für eine Aktionsgruppe.
```
{
"openapi": "3.0.0",
"paths": {
"/path": {
"method": {
"description": "string",
"operationId": "string",
"parameters": [ ... ],
"requestBody": { ... },
"responses": { ... },
"x-requireConfirmation": ENABLED | DISABLED
}
}
}
}
```
Die folgende Liste beschreibt Felder im OpenAPI-Schema.
+ `openapi` – (Erforderlich) Die Version der verwendeten OpenAPI. Dieser Wert muss `"3.0.0"` betragen, damit die Aktionsgruppe funktioniert.
+ `paths`: (Erforderlich) Enthält relative Pfade zu einzelnen Endpunkten. Pfadnamen müssen mit einem Schrägstrich (/) beginnen und enden. (`/`).
+ `method`: (Erforderlich) Definiert die zu verwendende Methode.
+ `x-requireConfirmation` – (Optional) Gibt an, ob die Benutzerbestätigung erforderlich ist, bevor die Aktion aufgerufen wird. Aktivieren Sie dieses Feld, um eine Bestätigung vom Benutzer anzufordern, bevor die Aktion aufgerufen wird. Das Anfordern einer Benutzerbestätigung, bevor die Aktion aufgerufen wird, kann Ihre Anwendung davor schützen, aufgrund bösartiger Promptinjektionen Maßnahmen zu ergreifen. Wenn dieses Feld nicht angegeben wird, ist die Benutzerbestätigung standardmäßig `DISABLED`.
Für jede Methode müssen mindestens die folgenden Felder angegeben werden:
+ `description`: Eine Beschreibung der API-Operation. Verwenden Sie dieses Feld, um den Agenten darüber zu informieren, wann diese API‑Operation aufgerufen werden soll und welche Funktion sie hat.
+ `operationId` – Eine eindeutige Zeichenfolge, die eine Operation in einer API identifiziert, z. B. ein Funktionsname. Dies ist ein Pflichtfeld für alle neuen toolUse-fähigen Modelle wie Anthropic Claude 3.5 Sonnet, Meta Llama usw. Stellen Sie sicher, dass der von Ihnen angegebene Bezeichner (ID) bei allen Operationen eindeutig ist und einem einfachen alphanumerischen Muster folgt, das nur Bindestriche oder Unterstriche als Trennzeichen enthält.
+ `responses` – Enthält Eigenschaften, die der Agent in der API-Antwort zurückgibt. Der Agent verwendet die Antworteigenschaften, um Prompts zu erstellen, die Ergebnisse eines API-Aufrufs genau zu verarbeiten und die richtigen Schritte zur Ausführung einer Aufgabe zu ermitteln. Der Agent kann Antwortwerte aus einer Operation als Eingaben für nachfolgende Orchestrierungsschritte verwenden.
Die Felder in den folgenden beiden Objekten bieten Ihrem Agenten weitere Informationen, damit er Ihre Aktionsgruppe effektiv nutzen kann. Legen Sie für jedes Feld den Wert des `required`-Felds auf `true` falls erforderlich und auf `false` falls optional fest.
+ `parameters`: Enthält Informationen über Parameter, die in die Anforderung aufgenommen werden können.
+ `requestBody`: Enthält die Felder im Anforderungstext für die Operation. Schließen Sie dieses Feld nicht für die `GET`- und `DELETE`-Methoden ein.
Wenn Sie mehr über eine Struktur erfahren möchten, wählen Sie eine der folgenden Registerkarten aus.
------
#### [ responses ]
```
"responses": {
"200": {
"content": {
"": {
"schema": {
"properties": {
"": {
"type": "string",
"description": "string"
},
...
}
}
}
},
},
...
}
```
Jeder Schlüssel im `responses`-Objekt ist ein Antwortcode, der den Status der Antwort beschreibt. Der Antwortcode ist einem Objekt zugeordnet, das die folgenden Informationen für die Antwort enthält:
+ `content`: (Für jede Antwort erforderlich) Der Inhalt der Antwort.
+ **: Das Format des Antworttextes. Weitere Informationen finden Sie unter [Medientypen](https://swagger.io/docs/specification/media-types/) auf der Swagger-Website.
+ `schema`: (Für jeden Medientyp erforderlich) Definiert den Datentyp des Antworttextes und seiner Felder.
+ `properties`: (Erforderlich, wenn `items` im Schema enthalten sind) Ihr Agent verwendet Eigenschaften, die Sie im Schema definieren, um zu bestimmen, welche Informationen er an die Endbenutzer zurückgeben muss, um eine Aufgabe auszuführen. Alle Eigenschaften enthalten die folgenden Felder:
+ `type`: (Für jede Eigenschaft erforderlich) Der Datentyp des Antwortfeldes.
+ `description`: (Optional) Beschreibt die Eigenschaft. Der Agent kann anhand dieser Informationen ermitteln, welche Informationen er an die Endbenutzer zurückgeben muss.
------
#### [ parameters ]
```
"parameters": [
{
"name": "string",
"description": "string",
"required": boolean,
"schema": {
...
}
},
...
]
```
Ihr Agent ermittelt anhand der folgenden Felder, welche Informationen er vom Endbenutzer erhalten muss, um die Anforderungen der Aktionsgruppe auszuführen.
+ `name`: (Erforderlich) Der Name des Parameters.
+ `description`: (Erforderlich) Eine Beschreibung des Parameters. Verwenden Sie dieses Feld, um dem Agenten zu vermitteln, wie dieser Parameter vom Benutzer des Agenten abgefragt wird, oder um festzustellen, ob dieser Parameterwert bereits aus früheren Aktionen oder aus der Anforderung des Benutzers an den Agenten vorliegt.
+ `required` – (Optional) Ob der Parameter für die API-Anfrage erforderlich ist. Verwenden Sie dieses Feld, um dem Agenten mitzuteilen, ob dieser Parameter für jeden Aufruf benötigt wird oder ob er optional ist.
+ `schema`: (Optional) Die Definition von Eingabe- und Ausgabedatentypen. Weitere Informationen finden Sie unter [Datenmodelle (Schemas)](https://swagger.io/docs/specification/data-models/) auf der Swagger-Website.
------
#### [ requestBody ]
Es folgt die allgemeine Struktur eines `requestBody`-Felds:
```
"requestBody": {
"required": boolean,
"content": {
"": {
"schema": {
"properties": {
"": {
"type": "string",
"description": "string"
},
...
}
}
}
}
}
```
In der folgenden Liste werden die einzelnen Felder beschrieben:
+ `required` – (Optional) Ob der Anforderungstext für die API-Anfrage erforderlich ist.
+ `content`: (Erforderlich) Der Inhalt des Anforderungstextes.
+ **: (Optional) Das Format des Anforderungstextes. Weitere Informationen finden Sie unter [Medientypen](https://swagger.io/docs/specification/media-types/) auf der Swagger-Website.
+ `schema`: (Optional) Definiert den Datentyp des Anforderungstextes und seiner Felder.
+ `properties` – (Optional) Ihr Agent verwendet Eigenschaften, die Sie im Schema definieren, um die Informationen zu ermitteln, die er vom Endbenutzer abfragen muss, um die API-Anfrage auszuführen. Alle Eigenschaften enthalten die folgenden Felder:
+ `type`: (Optional) Der Datentyp des Anforderungsfeldes.
+ `description`: (Optional) Beschreibt die Eigenschaft. Der Agent kann anhand dieser Informationen ermitteln, welche Informationen er an die Endbenutzer zurückgeben muss.
------
Informationen zum Hinzufügen des OpenAPI-Schemas, das Sie beim Erstellen der Aktionsgruppe erstellt haben, finden Sie unter [Hinzufügen einer Aktionsgruppe zu Ihrem Agenten in Amazon Bedrock](agents-action-add.md).
## Beispiele für API-Schemas
Das folgende Beispiel bietet ein einfaches OpenAPI-Schema im YAML-Format, das das Wetter für einen bestimmten Ort in Celsius abruft.
```
openapi: 3.0.0
info:
title: GetWeather API
version: 1.0.0
description: gets weather
paths:
/getWeather/{location}/:
get:
summary: gets weather in Celsius
description: gets weather in Celsius
operationId: getWeather
parameters:
- name: location
in: path
description: location name
required: true
schema:
type: string
responses:
"200":
description: weather in Celsius
content:
application/json:
schema:
type: string
```
Das folgende Beispiel für ein API-Schema definiert eine Gruppe von API-Operationen, die die Bearbeitung von Versicherungsansprüchen erleichtern. Drei APIs sind wie folgt definiert:
+ `getAllOpenClaims` – Ihr Agent kann im Feld `description` festlegen, dass er diese API-Operation aufrufen soll, wenn eine Liste mit offenen Ansprüchen gefordert wird. Die `properties` in den `responses` geben an, ob die ID, der Versicherungsnehmer und der Status des Anspruchs zurückgegeben werden sollen. Der Agent gibt diese Informationen an den Benutzer des Agenten zurück oder verwendet die gesamte oder einen Teil der Antwort als Eingabe für nachfolgende API-Aufrufe.
+ `identifyMissingDocuments` – Ihr Agent kann im Feld `description` festlegen, dass er diese API-Operation aufrufen soll, wenn fehlende Dokumente für einen Versicherungsanspruch identifiziert werden müssen. Die Felder `name`, `description` und `required` teilen dem Agenten mit, dass er die eindeutige Kennung des offenen Anspruchs des Kunden ermitteln muss. Die `properties` in den `responses` legen fest, dass die IDs der offenen Versicherungsansprüche zurückgegeben werden sollen. Der Agent gibt diese Informationen an den Endbenutzer zurück oder verwendet die gesamte oder einen Teil der Antwort als Eingabe für nachfolgende API-Aufrufe.
+ `sendReminders` – Ihr Agent kann im Feld `description` festlegen, dass er diese API-Operation aufrufen soll, wenn Erinnerungen an den Kunden gesendet werden sollen. Zum Beispiel eine Erinnerung an ausstehende Dokumente im Zusammenhang mit offenen Ansprüchen. Die `properties` im `requestBody` teilen dem Agenten mit, dass er die Anspruchsnummern und die ausstehenden Dokumente suchen muss. Die `properties` in den `responses` geben an, dass eine ID der Erinnerung und ihr Status zurückgegeben werden sollen. Der Agent gibt diese Informationen an den Endbenutzer zurück oder verwendet die gesamte oder einen Teil der Antwort als Eingabe für nachfolgende API-Aufrufe.
```
{
"openapi": "3.0.0",
"info": {
"title": "Insurance Claims Automation API",
"version": "1.0.0",
"description": "APIs for managing insurance claims by pulling a list of open claims, identifying outstanding paperwork for each claim, and sending reminders to policy holders."
},
"paths": {
"/claims": {
"get": {
"summary": "Get a list of all open claims",
"description": "Get the list of all open insurance claims. Return all the open claimIds.",
"operationId": "getAllOpenClaims",
"responses": {
"200": {
"description": "Gets the list of all open insurance claims for policy holders",
"content": {
"application/json": {
"schema": {
"type": "array",
"items": {
"type": "object",
"properties": {
"claimId": {
"type": "string",
"description": "Unique ID of the claim."
},
"policyHolderId": {
"type": "string",
"description": "Unique ID of the policy holder who has filed the claim."
},
"claimStatus": {
"type": "string",
"description": "The status of the claim. Claim can be in Open or Closed state"
}
}
}
}
}
}
}
}
}
},
"/claims/{claimId}/identify-missing-documents": {
"get": {
"summary": "Identify missing documents for a specific claim",
"description": "Get the list of pending documents that need to be uploaded by policy holder before the claim can be processed. The API takes in only one claim id and returns the list of documents that are pending to be uploaded by policy holder for that claim. This API should be called for each claim id",
"operationId": "identifyMissingDocuments",
"parameters": [{
"name": "claimId",
"in": "path",
"description": "Unique ID of the open insurance claim",
"required": true,
"schema": {
"type": "string"
}
}],
"responses": {
"200": {
"description": "List of documents that are pending to be uploaded by policy holder for insurance claim",
"content": {
"application/json": {
"schema": {
"type": "object",
"properties": {
"pendingDocuments": {
"type": "string",
"description": "The list of pending documents for the claim."
}
}
}
}
}
}
}
}
},
"/send-reminders": {
"post": {
"summary": "API to send reminder to the customer about pending documents for open claim",
"description": "Send reminder to the customer about pending documents for open claim. The API takes in only one claim id and its pending documents at a time, sends the reminder and returns the tracking details for the reminder. This API should be called for each claim id you want to send reminders for.",
"operationId": "sendReminders",
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"type": "object",
"properties": {
"claimId": {
"type": "string",
"description": "Unique ID of open claims to send reminders for."
},
"pendingDocuments": {
"type": "string",
"description": "The list of pending documents for the claim."
}
},
"required": [
"claimId",
"pendingDocuments"
]
}
}
}
},
"responses": {
"200": {
"description": "Reminders sent successfully",
"content": {
"application/json": {
"schema": {
"type": "object",
"properties": {
"sendReminderTrackingId": {
"type": "string",
"description": "Unique Id to track the status of the send reminder Call"
},
"sendReminderStatus": {
"type": "string",
"description": "Status of send reminder notifications"
}
}
}
}
}
},
"400": {
"description": "Bad request. One or more required fields are missing or invalid."
}
}
}
}
}
}
```
Weitere Beispiele für OpenAPI-Schemas finden Sie unter [Beispiele für API-Beschreibungen](https://learn.openapis.org/examples/) auf der OpenAPI-Website.
# Verarbeiten der Ausführung der Aktion
Wenn Sie die Aktionsgruppe konfigurieren, wählen Sie auch eine der folgenden Optionen aus, damit der Agent die vom Benutzer erhaltenen Informationen und Parameter übergibt:
+ Benutzereingaben zur Aktionsgruppe Ihres Agenten hinzufügen. Mithilfe von Benutzereingaben kann der Agent den [Benutzer nach weiteren Informationen fragen](agents-user-input.md), wenn er nicht über genügend Informationen verfügt, um eine Aufgabe abzuschließen.
+ An eine [von Ihnen erstellte Lambda-Funktion übergeben](agents-lambda.md), um die Geschäftslogik für die Aktionsgruppe zu definieren
+ Die Verwendung einer Lambda-Funktion überspringen und [die Kontrolle zurückgeben](agents-returncontrol.md), indem die Informationen und Parameter des Benutzers in der `InvokeAgent`-Antwort übergeben werden. Die Informationen und Parameter können an Ihre eigenen Systeme gesendet werden, um Ergebnisse zu erhalten, und diese Ergebnisse können im [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_SessionState.html#bedrock-Type-agent-runtime_SessionState](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_SessionState.html#bedrock-Type-agent-runtime_SessionState) einer anderen [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html)-Anfrage gesendet werden.
+ Die Benutzerbestätigung für eine Aktion aktivieren. Wenn Sie die Benutzerbestätigung aktivieren, können Sie Ihre Anwendung vor böswilligen Promptinjektionen schützen, indem Sie vor dem Aufrufen der Aktionsgruppenfunktion eine [Bestätigung von Ihren Anwendungsbenutzern anfordern](agents-userconfirmation.md).
Wählen Sie ein Thema aus, um zu erfahren, wie das Verarbeiten der Ausführung der Aktionsgruppe konfiguriert wird, nachdem die erforderlichen Informationen beim Benutzer abgefragt wurden.
**Topics**
+ [Konfigurieren von Lambda-Funktionen zum Senden von Informationen, die ein Amazon-Bedrock-Agent beim Benutzer abfragt](agents-lambda.md)
+ [Zurückgeben der Steuerung an den Agent-Entwickler durch Senden der abgerufenen Informationen in einer InvokeAgent-Antwort](agents-returncontrol.md)
+ [Einholen der Benutzerbestätigung vor dem Aufrufen der Aktionsgruppenfunktion](agents-userconfirmation.md)
# Konfigurieren von Lambda-Funktionen zum Senden von Informationen, die ein Amazon-Bedrock-Agent beim Benutzer abfragt
Sie können eine Lambda-Funktion definieren, um die Geschäftslogik für die Aktionsgruppe zu programmieren. Nachdem ein Amazon-Bedrock-Agent die API-Operation ermittelt hat, die er in einer Aktionsgruppe aufrufen muss, sendet er Informationen aus dem API-Schema zusammen mit relevanten Metadaten als Eingabeereignis an die Lambda-Funktion. Um Ihre Funktion zu schreiben, müssen Sie die folgenden Komponenten der Lambda-Funktion verstehen:
+ **Eingabeereignis** – Enthält relevante Metadaten und ausgefüllte Felder aus dem Anforderungstext der API-Operation oder die Funktionsparameter für die Aktion, die laut Agent aufgerufen werden muss.
+ **Antwort** – Enthält relevante Metadaten und ausgefüllte Felder für den Antworttext, der von der API-Operation oder der Funktion zurückgegeben wurde.
Sie schreiben Ihre Lambda-Funktion, um zu definieren, wie eine Aktionsgruppe zu handhaben ist, und um anzupassen, wie die API-Antwort zurückgegeben werden soll. Sie verwenden die Variablen aus dem Eingabeereignis, um Ihre Funktionen zu definieren und eine Antwort an den Agenten zurückzugeben.
**Anmerkung**
Eine Aktionsgruppe kann bis zu 11 API-Operationen enthalten, Sie können jedoch nur eine Lambda-Funktion schreiben. Da die Lambda-Funktion nur ein Eingabeereignis empfangen und eine Antwort für jeweils eine API-Operation zurückgeben kann, sollten Sie die Funktion unter Berücksichtigung der verschiedenen API-Operationen schreiben, die aufgerufen werden können.
Damit Ihr Agent eine Lambda-Funktion verwenden kann, müssen Sie der Funktion eine ressourcenbasierte Richtlinie hinzufügen, um dem Agenten Berechtigungen zu erteilen. Führen Sie die Schritte unter [Ressourcenbasierte Richtlinie, die es Amazon Bedrock erlaubt, die Lambda-Funktion einer Aktionsgruppe aufzurufen](agents-permissions.md#agents-permissions-lambda) aus, um weitere Informationen zu erhalten. Weitere Informationen zu ressourcenbasierten Richtlinien in Lambda finden Sie unter [Using Resource Based Policies for Lambda](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html) im Developer Guide. AWS Lambda
Informationen zum Definieren einer Funktion bei der Erstellung der Aktionsgruppe finden Sie unter [Hinzufügen einer Aktionsgruppe zu Ihrem Agenten in Amazon Bedrock](agents-action-add.md).
**Topics**
+ [Lambda-Eingabeereignis von Amazon Bedrock](#agents-lambda-input)
+ [Lambda-Antwortereignis auf Amazon Bedrock](#agents-lambda-response)
+ [Beispiel für eine Aktionsgruppe mit Lambda-Funktionen](#agents-lambda-example)
## Lambda-Eingabeereignis von Amazon Bedrock
Wenn eine Aktionsgruppe aufgerufen wird, die eine Lambda-Funktion verwendet, sendet Amazon Bedrock ein Lambda-Eingabeereignis im folgenden allgemeinen Format. Sie können Ihre Lambda-Funktion so definieren, dass sie eines der Eingabeereignisfelder verwendet, um die Geschäftslogik innerhalb der Funktion entsprechend anzupassen, damit die Aktion erfolgreich ausgeführt wird. Weitere Informationen zu Lambda-Funktionen finden Sie unter [Event-driven invocation](https://docs.aws.amazon.com/lambda/latest/dg/lambda-services.html#event-driven-invocation) im Developer Guide. AWS Lambda
Das Format des Eingabeergebnisses hängt davon ab, ob Sie die Aktionsgruppe mit einem API-Schema oder mit Funktionsdetails definiert haben:
+ Wenn Sie die Aktionsgruppe mit einem API-Schema definiert haben, lautet das Eingabeereignisformat wie folgt:
```
{
"messageVersion": "1.0",
"agent": {
"name": "string",
"id": "string",
"alias": "string",
"version": "string"
},
"inputText": "string",
"sessionId": "string",
"actionGroup": "string",
"apiPath": "string",
"httpMethod": "string",
"parameters": [
{
"name": "string",
"type": "string",
"value": "string"
},
...
],
"requestBody": {
"content": {
"": {
"properties": [
{
"name": "string",
"type": "string",
"value": "string"
},
...
]
}
}
},
"sessionAttributes": {
"string": "string",
},
"promptSessionAttributes": {
"string": "string"
}
}
```
+ Wenn Sie die Aktionsgruppe mit Funktionsdetails definiert haben, lautet das Eingabeereignisformat wie folgt:
```
{
"messageVersion": "1.0",
"agent": {
"name": "string",
"id": "string",
"alias": "string",
"version": "string"
},
"inputText": "string",
"sessionId": "string",
"actionGroup": "string",
"function": "string",
"parameters": [
{
"name": "string",
"type": "string",
"value": "string"
},
...
],
"sessionAttributes": {
"string": "string",
},
"promptSessionAttributes": {
"string": "string"
}
}
```
Die folgende Liste beschreibt die Eingabeereignisfelder:
+ `messageVersion` – Die Version der Mitteilung, die das Format der Ereignisdaten, die in die Lambda-Funktion eingehen, und das erwartete Format der Antwort von einer Lambda-Funktion identifiziert. Amazon Bedrock unterstützt nur die Version 1.0.
+ `agent`: Enthält Informationen über den Namen, die ID, den Alias und die Version des Agenten, dem die Aktionsgruppe angehört.
+ `inputText`: Die Benutzereingabe für den Gesprächsabschnitt.
+ `sessionId`: Die eindeutige Kennung für die Sitzung des Agenten.
+ `actionGroup`: Der Name der Aktionsgruppe.
+ `parameters` – Enthält eine Liste von Objekten. Jedes Objekt enthält den Namen, den Typ und den Wert eines Parameters in der API-Operation, wie im OpenAPI-Schema oder in der Funktion definiert.
+ Wenn Sie die Aktionsgruppe mit einem API-Schema definiert haben, enthält das Eingabeereignis die folgenden Felder:
+ `apiPath` – Der Pfad zur API-Operation, wie im OpenAPI-Schema definiert.
+ `httpMethod` – Die Methode der API-Operation, wie im OpenAPI-Schema definiert.
+ `requestBody` – Enthält den Text der Anforderung und ihre Eigenschaften, wie im OpenAPI-Schema für die Aktionsgruppe definiert.
+ Wenn Sie die Aktionsgruppe mit Funktionsdetails definiert haben, enthält das Eingabeereignis die folgenden Felder:
+ `function` – Der Name der Funktion, wie in den Funktionsdetails für die Aktionsgruppe definiert.
+ `sessionAttributes` – Enthält [Sitzungsattribute](agents-session-state.md) und ihre Werte. Diese Attribute werden während einer [Sitzung](advanced-prompts.md#advanced-prompts-terminology) gespeichert und stellen den Kontext für den Agenten bereit.
+ `promptSessionAttributes` – Enthält [Prompt-Sitzungsattribute](agents-session-state.md) und ihre Werte. Diese Attribute werden [nacheinander](advanced-prompts.md#advanced-prompts-terminology) gespeichert und stellen den Kontext für den Agenten bereit.
## Lambda-Antwortereignis auf Amazon Bedrock
Amazon Bedrock erwartet eine Antwort Ihrer Lambda-Funktion im folgenden Format. Die Antwort besteht aus Parametern, die von der API-Operation zurückgegeben wurden. Der Agent kann die Antwort der Lambda-Funktion für die weitere Orchestrierung verwenden oder ihr helfen, eine Antwort an den Kunden zurückzugeben.
**Anmerkung**
Die maximale Größe der Nutzdatenantwort entspricht der maximalen Größe einer synchronen Antwort von der Lambda-Funktion. [Weitere Informationen finden Sie im Entwicklerhandbuch unter dem *Ressourcenkontingent für Nutzlasten beim Aufrufen*.](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html#function-configuration-deployment-and-execution) AWS Lambda
Das Format des Eingabeergebnisses hängt davon ab, ob Sie die Aktionsgruppe mit einem API-Schema oder mit Funktionsdetails definiert haben:
+ Wenn Sie die Aktionsgruppe mit einem API-Schema definiert haben, lautet das Eingabeereignisformat wie folgt:
```
{
"messageVersion": "1.0",
"response": {
"actionGroup": "string",
"apiPath": "string",
"httpMethod": "string",
"httpStatusCode": number,
"responseBody": {
"": {
"body": "JSON-formatted string"
}
}
},
"sessionAttributes": {
"string": "string",
...
},
"promptSessionAttributes": {
"string": "string",
...
},
"knowledgeBasesConfiguration": [
{
"knowledgeBaseId": "string",
"retrievalConfiguration": {
"vectorSearchConfiguration": {
"numberOfResults": int,
"overrideSearchType": "HYBRID | SEMANTIC",
"filter": [RetrievalFilter](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_RetrievalFilter.html) object
}
}
},
...
]
}
```
+ Wenn Sie die Aktionsgruppe mit Funktionsdetails definiert haben, lautet das Antwortformat wie folgt:
```
{
"messageVersion": "1.0",
"response": {
"actionGroup": "string",
"function": "string",
"functionResponse": {
"responseState": "FAILURE | REPROMPT",
"responseBody": {
"": {
"body": "JSON-formatted string"
}
}
}
},
"sessionAttributes": {
"string": "string",
},
"promptSessionAttributes": {
"string": "string"
},
"knowledgeBasesConfiguration": [
{
"knowledgeBaseId": "string",
"retrievalConfiguration": {
"vectorSearchConfiguration": {
"numberOfResults": int,
"filter": {
[RetrievalFilter](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_RetrievalFilter.html) object
}
}
}
},
...
]
}
```
In der folgenden Liste werden die Lambda-Antwortfelder beschrieben:
+ `messageVersion` – Die Version der Nachricht, die das Format der Ereignisdaten identifiziert, die in die Lambda-Funktion eingegeben werden, sowie das erwartete Format der Antwort von einer Lambda-Funktion. Amazon Bedrock unterstützt nur die Version 1.0.
+ `response`: Enthält die folgenden Informationen über die API-Antwort.
+ `actionGroup`: Der Name der Aktionsgruppe.
+ Wenn Sie die Aktionsgruppe mit einem API-Schema definiert haben, muss die Antwort das folgende Format haben:
+ `apiPath` – Der Pfad zur API-Operation, wie im OpenAPI-Schema definiert.
+ `httpMethod` – Die Methode der API-Operation, wie im OpenAPI-Schema definiert.
+ `httpStatusCode` – Der von der API-Operation zurückgegebene HTTP-Statuscode.
+ `responseBody` – Enthält den Antworttext, wie im OpenAPI-Schema definiert.
+ Wenn Sie die Aktionsgruppe mit Funktionsdetails definiert haben, können die folgenden Felder in der Antwort enthalten sein:
+ `responseState` (Optional) – Legen Sie einen der folgenden Status fest, um das Verhalten des Agenten nach der Verarbeitung der Aktion zu definieren:
+ FAILURE – Der Agent gibt eine `DependencyFailedException` für die aktuelle Sitzung aus. Gilt, wenn die Funktionsausführung aufgrund eines Abhängigkeitsfehlers fehlschlägt.
+ REPROMPT – Der Agent übergibt eine Antwortzeichenfolge an das Modell, um es erneut aufzufordern. Gilt, wenn die Funktionsausführung aufgrund einer ungültigen Eingabe fehlschlägt.
+ `responseBody` – Enthält ein Objekt, das die Antwort von der Ausführung der Funktion definiert. Der Schlüssel ist der Inhaltstyp (derzeit wird nur `TEXT` unterstützt) und der Wert ist ein Objekt, das den `body` der Antwort enthält.
+ (Optional) `sessionAttributes`: Enthält Sitzungsattribute und ihre Werte. Weitere Informationen finden Sie unter [Sitzungs- und Prompt-Sitzungsattribute](agents-session-state.md#session-state-attributes).
+ (Optional) `promptSessionAttributes`: Enthält Prompt-Attribute und ihre Werte. Weitere Informationen finden Sie unter [Sitzungs- und Prompt-Sitzungsattribute](agents-session-state.md#session-state-attributes).
+ (Optional) `knowledgeBasesConfiguration` – Enthält eine Liste von Abfragekonfigurationen für Wissensdatenbanken, die an den Agenten angefügt sind. Weitere Informationen finden Sie unter [Konfigurationen für den Abruf aus der Wissensdatenbank](agents-session-state.md#session-state-kb).
## Beispiel für eine Aktionsgruppe mit Lambda-Funktionen
Das Folgende ist ein minimales Beispiel dafür, wie die Lambda-Funktion in Python definiert werden kann. Wählen Sie die Registerkarte aus, die der Angabe entspricht, ob Sie die Aktionsgruppe mit einem OpenAPI-Schema oder mit Funktionsdetails definiert haben:
------
#### [ OpenAPI schema ]
```
def lambda_handler(event, context):
agent = event['agent']
actionGroup = event['actionGroup']
api_path = event['apiPath']
# get parameters
get_parameters = event.get('parameters', [])
# post parameters
post_parameters = event['requestBody']['content']['application/json']['properties']
response_body = {
'application/json': {
'body': "sample response"
}
}
action_response = {
'actionGroup': event['actionGroup'],
'apiPath': event['apiPath'],
'httpMethod': event['httpMethod'],
'httpStatusCode': 200,
'responseBody': response_body
}
session_attributes = event['sessionAttributes']
prompt_session_attributes = event['promptSessionAttributes']
api_response = {
'messageVersion': '1.0',
'response': action_response,
'sessionAttributes': session_attributes,
'promptSessionAttributes': prompt_session_attributes
}
return api_response
```
------
#### [ Function details ]
```
def lambda_handler(event, context):
agent = event['agent']
actionGroup = event['actionGroup']
function = event['function']
parameters = event.get('parameters', [])
response_body = {
'TEXT': {
'body': "sample response"
}
}
function_response = {
'actionGroup': event['actionGroup'],
'function': event['function'],
'functionResponse': {
'responseBody': response_body
}
}
session_attributes = event['sessionAttributes']
prompt_session_attributes = event['promptSessionAttributes']
action_response = {
'messageVersion': '1.0',
'response': function_response,
'sessionAttributes': session_attributes,
'promptSessionAttributes': prompt_session_attributes
}
return action_response
```
------
# Zurückgeben der Steuerung an den Agent-Entwickler durch Senden der abgerufenen Informationen in einer InvokeAgent-Antwort
Anstatt die Informationen, die Ihr Agent beim Benutzer abgefragt hat, zur Erfüllung an eine Lambda-Funktion zu senden, können Sie stattdessen die Steuerung an den Agent-Entwickler zurückzugeben, indem Sie die Informationen in der [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html)-Antwort senden. Sie können die Rückgabe der Steuerung an den Agent-Entwickler konfigurieren, wenn Sie eine Aktionsgruppe erstellen oder aktualisieren. Über die API geben Sie `RETURN_CONTROL` als `customControl`-Wert im `actionGroupExecutor`-Objekt in einer [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateAgentActionGroup.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateAgentActionGroup.html)- oder [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateAgentActionGroup.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateAgentActionGroup.html)-Anfrage an. Weitere Informationen finden Sie unter [Hinzufügen einer Aktionsgruppe zu Ihrem Agenten in Amazon Bedrock](agents-action-add.md).
Wenn Sie die Rückgabe der Steuerung für eine Aktionsgruppe konfigurieren und laut Agent eine Aktion in dieser Aktionsgruppe aufgerufen werden soll, werden die vom Benutzer abgerufenen API- oder Funktionsdetails zusammen mit einer eindeutigen `invocationId` im Feld `invocationInputs` der [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html)-Antwort zurückgegeben. Sie können dann Folgendes durchführen:
+ Richten Sie Ihre Anwendung so ein, dass sie die von Ihnen definierte API oder Funktion aufruft, vorausgesetzt, dass die Informationen in den `invocationInputs` zurückgegeben wurden.
+ Senden Sie die Ergebnisse des Aufrufs Ihrer Anwendung in einer anderen [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html)-Anfrage, im Feld `sessionState`, um Kontext für den Agenten bereitzustellen. Sie müssen dieselbe `invocationId` und `actionGroup` verwenden, die in der [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html)-Antwort zurückgegeben wurden. Diese Informationen können als Kontext für die weitere Orchestrierung verwendet, zur Nachbearbeitung gesendet werden, damit der Agent eine Antwort formatieren kann, oder direkt in der Antwort des Agenten an den Benutzer verwendet werden.
**Anmerkung**
Wenn Sie `returnControlInvocationResults` in das Feld `sessionState` aufnehmen, wird das Feld `inputText` ignoriert.
Informationen dazu, wie Sie die Rückgabe der Steuerung an den Agent-Entwickler beim Erstellen der Aktionsgruppe konfigurieren, finden Sie unter [Hinzufügen einer Aktionsgruppe zu Ihrem Agenten in Amazon Bedrock](agents-action-add.md).
## Beispiel für die Rückgabe der Steuerung an den Agent-Entwickler
Sie könnten beispielsweise über die folgenden Aktionsgruppen verfügen:
+ Eine `PlanTrip`-Aktionsgruppe mit einer `suggestActivities`-Aktion, die Ihre Benutzern beim Suchen von Aktivitäten unterstützt, die sie während einer Reise unternehmen können. Die `description` für diese Aktion lautet `This action suggests activities based on retrieved weather information`.
+ Eine `WeatherAPIs`-Aktionsgruppe mit einer `getWeather`-Aktion, die Ihrem Benutzer hilft, die Wetterdaten für einen bestimmten Ort abzurufen. Die erforderlichen Parameter der Aktion lauten `location` und `date`. Die Aktionsgruppe ist so konfiguriert, dass sie die Steuerung an den Agent-Entwickler zurückgibt.
Nachfolgend finden Sie eine hypothetische Sequenz, die auftreten könnte:
1. Der Benutzer fordert Ihren Agenten mit der folgenden Abfrage auf: **What should I do today?** Diese Abfrage wird im Feld `inputText` einer [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html)-Anfrage gesendet.
1. Ihr Agent erkennt, dass die Aktion `suggestActivities` aufgerufen werden sollte, sagt aber anhand der Beschreibung voraus, dass er zuerst die Aktion `getWeather` als Kontext zur Ausführung der Aktion `suggestActivities` aufrufen sollte.
1. Der Agent weiß, dass das aktuelle `date` `2024-09-15` lautet, benötigt jedoch den `location` des Benutzers als erforderlichen Parameter, um die Wetterdaten zu ermitteln. Der Benutzer wird erneut zur Beantwortung der Frage „Wo befinden Sie sich?“ aufgefordert.
1. Der Benutzer antwortet **Seattle**.
1. Der Agent gibt die Parameter für `getWeather` in der folgenden [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html)-Antwort zurück (wählen Sie eine Registerkarte aus, um Beispiele für eine mit dieser Methode definierte Aktionsgruppe anzuzeigen):
------
#### [ Function details ]
```
HTTP/1.1 200
x-amzn-bedrock-agent-content-type: application/json
x-amz-bedrock-agent-session-id: session0
Content-type: application/json
{
"returnControl": {
"invocationInputs": [{
"functionInvocationInput": {
"actionGroup": "WeatherAPIs",
"function": "getWeather",
"parameters": [
{
"name": "location",
"type": "string",
"value": "seattle"
},
{
"name": "date",
"type": "string",
"value": "2024-09-15"
}
]
}
}],
"invocationId": "79e0feaa-c6f7-49bf-814d-b7c498505172"
}
}
```
------
#### [ OpenAPI schema ]
```
HTTP/1.1 200
x-amzn-bedrock-agent-content-type: application/json
x-amz-bedrock-agent-session-id: session0
Content-type: application/json
{
"invocationInputs": [{
"apiInvocationInput": {
"actionGroup": "WeatherAPIs",
"apiPath": "/get-weather",
"httpMethod": "get",
"parameters": [
{
"name": "location",
"type": "string",
"value": "seattle"
},
{
"name": "date",
"type": "string",
"value": "2024-09-15"
}
]
}
}],
"invocationId": "337cb2f6-ec74-4b49-8141-00b8091498ad"
}
```
------
1. Ihre Anwendung ist so konfiguriert, dass sie diese Parameter verwendet, um das Wetter für `seattle` für das Datum `2024-09-15` abzurufen. Das Wetter wird voraussichtlich regnerisch sein.
1. Sie senden diese Ergebnisse im Feld `sessionState` einer anderen [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html)-Anfrage und verwenden dabei dieselbe `invocationId`, `actionGroup` und `function` wie bei der vorherigen Antwort. Wählen Sie eine Registerkarte aus, um Beispiele für eine Aktionsgruppe anzuzeigen, die mit dieser Methode definiert wurde:
------
#### [ Function details ]
```
POST https://bedrock-agent-runtime.us-east-1.amazonaws.com/agents/AGENT12345/agentAliases/TSTALIASID/sessions/abb/text
{
"enableTrace": true,
"sessionState": {
"invocationId": "79e0feaa-c6f7-49bf-814d-b7c498505172",
"returnControlInvocationResults": [{
"functionResult": {
"actionGroup": "WeatherAPIs",
"function": "getWeather",
"responseBody": {
"TEXT": {
"body": "It's rainy in Seattle today."
}
}
}
}]
}
}
```
------
#### [ OpenAPI schema ]
```
POST https: //bedrock-agent-runtime.us-east-1.amazonaws.com/agents/AGENT12345/agentAliases/TSTALIASID/sessions/abb/text
{
"enableTrace": true,
"sessionState": {
"invocationId": "337cb2f6-ec74-4b49-8141-00b8091498ad",
"returnControlInvocationResults": [{
"apiResult": {
"actionGroup": "WeatherAPIs",
"httpMethod": "get",
"apiPath": "/get-weather",
"responseBody": {
"application/json": {
"body": "It's rainy in Seattle today."
}
}
}
}]
}
}
```
------
1. Der Agent sagt voraus, dass die Aktion `suggestActivities` aufgerufen werden soll. Er nutzt den Kontext, dass es an diesem Tag regnet, und schlägt dem Benutzer in der Antwort Indoor- anstelle von Outdoor-Aktivitäten vor.
### Beispiel für die Rückgabe der Steuerung an den Partner-Agent
Wenn Sie die [Zusammenarbeit mehrerer Agenten](agents-multi-agent-collaboration.md) verwenden und ein Agent-Partner die Steuerung durch Senden der Informationen in der [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html)-Antwort zurückgibt, werden die Informationen in der Antwort des Supervisor-Agenten mit den zusätzlichen Kennungen `agentId` und `collaboratorName` zurückgegeben. Wählen Sie eine Registerkarte aus, um Beispiele für eine Aktionsgruppe anzuzeigen, die mit dieser Methode definiert wurde:
------
#### [ Function details ]
```
HTTP/1.1 200
x-amzn-bedrock-agent-content-type: application/json
x-amz-bedrock-agent-session-id: session0
Content-type: application/json
{
"returnControl": {
"invocationInputs": [{
"functionInvocationInput": {
"agentId": "AGENTID",
"collaboratorName": "WeatherAgent"
"actionGroup": "WeatherAPIs",
"function": "getWeather",
"parameters": [
{
"name": "location",
"type": "string",
"value": "seattle"
},
{
"name": "date",
"type": "string",
"value": "2024-09-15"
}
]
}
}],
"invocationId": "79e0feaa-c6f7-49bf-814d-b7c498505172"
}
}
```
------
#### [ OpenAPI Schema ]
```
HTTP/1.1 200
x-amzn-bedrock-agent-content-type: application/json
x-amz-bedrock-agent-session-id: session0
Content-type: application/json
{
"invocationInputs": [{
"apiInvocationInput": {
"actionGroup": "WeatherAPIs",
"agentId": "AGENTID",
"collaboratorName": "WeatherAgent"
"apiPath": "/get-weather",
"httpMethod": "get",
"parameters": [
{
"name": "location",
"type": "string",
"value": "seattle"
},
{
"name": "date",
"type": "string",
"value": "2024-09-15"
}
]
}
}],
"invocationId": "337cb2f6-ec74-4b49-8141-00b8091498ad"
}
```
------
Der Aufrufer des Supervisor-Agenten sendet die Ergebnisse im Feld `sessionState` zurück an den Supervisor-Agenten mit der entsprechenden `agentId`, damit sie an den richtigen Agent-Partner übertragen werden.
------
#### [ Function details ]
```
POST https://bedrock-agent-runtime.us-east-1.amazonaws.com/agents/AGENT12345/agentAliases/TSTALIASID/sessions/abb/text
{
"enableTrace": true,
"sessionState": {
"invocationId": "79e0feaa-c6f7-49bf-814d-b7c498505172",
"returnControlInvocationResults": [{
"functionResult": {
"agentId": "AGENTID",
"actionGroup": "WeatherAPIs",
"function": "getWeather",
"responseBody": {
"TEXT": {
"body": "It's rainy in Seattle today."
}
}
}
}]
}
}
```
------
#### [ OpenAPI Schema ]
```
POST https: //bedrock-agent-runtime.us-east-1.amazonaws.com/agents/AGENT12345/agentAliases/TSTALIASID/sessions/abb/text
{
"enableTrace": true,
"sessionState": {
"invocationId": "337cb2f6-ec74-4b49-8141-00b8091498ad",
"returnControlInvocationResults": [{
"apiResult": {
"agentId": "AGENTID",
"actionGroup": "WeatherAPIs",
"httpMethod": "get",
"apiPath": "/get-weather",
"responseBody": {
"application/json": {
"body": "It's rainy in Seattle today."
}
}
}
}]
}
}
```
------
# Einholen der Benutzerbestätigung vor dem Aufrufen der Aktionsgruppenfunktion
Sie können Ihre Anwendung vor böswilligen Promptinjektionen schützen, indem Sie vor dem Aufrufen der Aktionsgruppenfunktion eine Bestätigung von den Anwendungsbenutzern anfordern. Wenn ein Endbenutzer mit Ihrer Anwendung interagiert, ermittelt Amazon-Bedrock-Agent die API oder Wissensdatenbanken, die aufgerufen werden müssen, um die Aufgabe für den Benutzer zu automatisieren. Die Informationen aus der API oder den Wissensdatenbanken können potenziell schädliche Daten enthalten. Wenn die Antwort zwischen den einzelnen Iterationen Anweisungen enthält, hält sich der Agent daran. Wenn die Antwort Anweisungen für das Modell enthält, unbeabsichtigte Aktionen aufzurufen, fährt der Agent fort und befolgt die Anweisung. Um sicherzustellen, dass bestimmte Aktionen nur nach ausdrücklicher Zustimmung des Benutzers implementiert werden, empfehlen wir, vor dem Aufrufen der Funktion die Bestätigung vom Endbenutzer einzuholen.
Beim Konfigurieren Ihrer Aktionsgruppe können Sie auswählen, ob Sie die Benutzerbestätigung für bestimmte Aktionen aktivieren möchten. Wenn die Benutzerbestätigung für eine Aktion aktiviert ist, antwortet der Agent mit einer Bestätigungsfrage und fordert den Endbenutzer auf, die Aktion entweder zu bestätigen oder verweigern. Sie können die Benutzerbestätigung in der Konsole, mit der CLI oder mit der SDK aktivieren.
Informationen zum Aktivieren der Benutzerbestätigung für eine Aktion finden Sie unter [Hinzufügen einer Aktionsgruppe zu Ihrem Agenten in Amazon Bedrock](agents-action-add.md).
## So funktioniert die Benutzerbestätigung
Die Benutzerbestätigung wird vom Agentenentwickler für eine Aktion in der Aktionsgruppe konfiguriert. Wenn der Agent entscheidet, dass er diese Aktion aufrufen soll, werden die API oder die Funktionsdetails, die vom Benutzer abgerufen wurden, sowie die vom Agentenentwickler konfigurierte Benutzerbestätigung im Feld `invocationInputs` in der [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html)-Antwort zusammen mit `invocationType` und einer eindeutigen `invocationId` zurückgegeben.
Der Agent ruft die API oder die Funktion auf, die in `invocationInputs` bereitgestellt wurde. Wenn die Benutzerbestätigung für die Funktion oder die API aktiviert ist, wird dem Benutzer die Option angezeigt, die in der Antwort erwähnte Aktion zu **BESTÄTIGEN** oder zu **VERWEIGERN**.
Die Ergebnisse des Aufrufs der Funktion oder API durch den Agenten werden in einer weiteren [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html)-Anfrage im Feld `sessionState` gesendet, um dem Agenten einen Kontext bereitzustellen. Der Anforderungsparameter für `InvokeAgent` nutzt `returnControlInvocationResults`. Dabei handelt es sich um eine Liste von Zuordnungen an `apiResult`- oder `functionResult`-Objekte. Die `functionResult`- und `apiResult`-Objekte haben ein zusätzliches Feld: `confirmationState` Dieses Feld enthält die Bestätigungsantwort des Benutzers.
Wenn die Benutzerantwort **BESTÄTIGEN** lautet, wird die Funktion oder die API in der Antwort implementiert.
Wenn die Benutzerantwort **VERWEIGERN** lautet, wird die Funktion oder die API nicht in der Antwort implementiert.
## Beispiele für die Antwort und Anforderung von InvokeAgent
**Antwort**
```
HTTP/1.1 200
x-amzn-bedrock-agent-content-type: contentType
x-amz-bedrock-agent-session-id: sessionId
Content-type: application/json
{
"chunk": {
...
},
...
"returnControl": {
"invocationId": "string",
"invocationInputs": [
{ ... }
]
},
"trace": {
"agentAliasId": "string",
"agentId": "string",
"agentVersion": "string",
"sessionId": "string",
"trace": { ... }
},
}
```
**Anforderung**
```
POST /agents/agentId/agentAliases/agentAliasId/sessions/sessionId/text HTTP/1.1
Content-type: application/json
{
"enableTrace": boolean,
"endSession": boolean,
"inputText": "string",
"sessionState": {
"invocationId": "string",
"promptSessionAttributes": {
"string" : "string"
},
"returnControlInvocationResults": [
{ ... }
],
"sessionAttributes": {
"string" : "string"
}
}
}
```
# Hinzufügen einer Aktionsgruppe zu Ihrem Agenten in Amazon Bedrock
Nachdem Sie das OpenAPI-Schema und die Lambda-Funktion für Ihre Aktionsgruppe eingerichtet haben, können Sie die Aktionsgruppe erstellen. Wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und führen Sie dann die folgenden Schritte aus:
**Anmerkung**
Wenn Sie Anthropic Claude 3.5 Sonnet verwenden, stellen Sie sicher, dass Ihr Toolname, der die Form `httpVerb__actionGroupName__apiName` hat, dem Anthropic-Toolnamenformat `^[a-zA-Z0-9_-]{1,64}$` entspricht. Ihr actionGroupName und Ihr apiName dürfen keine doppelten Unterstriche `'__'` enthalten.
------
#### [ Console ]
Wenn Sie [einen Agenten erstellen](agents-create.md), können Sie dem Arbeitsentwurf Aktionsgruppen hinzufügen.
Nachdem ein Agent erstellt wurde, können Sie ihm Aktionsgruppen hinzufügen, indem Sie die folgenden Schritte ausführen:
**So fügen Sie einem Agenten eine Aktionsgruppe hinzu**
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 **Agenten** aus. Wählen Sie im Abschnitt **Agenten** einen Agenten aus.
1. Wählen Sie **In Agent Builder bearbeiten** aus.
1. Wählen Sie im Abschnitt **Aktionsgruppen** die Option **Hinzufügen** aus.
1. (Optional) Ändern Sie im Abschnitt **Einzelheiten zur Aktionsgruppe** den automatisch generierten **Namen** und geben Sie optional eine **Beschreibung** für Ihre Aktionsgruppe ein.
1. Wählen Sie im Abschnitt **Aktionsgruppentyp** eine der folgenden Methoden zur Definition der Parameter aus, die der Agent bei Benutzern zur Unterstützung der Ausführung von Aktionen abfragen kann:
1. **Mit Funktionsdetails definieren** – Definieren Sie Parameter, die Ihr Agent beim Benutzer zur Ausführung der Aktionen abfragen soll. Weitere Informationen zum Hinzufügen von Funktionen finden Sie unter [Definieren der Funktionsdetails für die Aktionsgruppen Ihres Agenten in Amazon Bedrock](agents-action-function.md).
1. **Mit API-Schemas definieren** – Definieren Sie die API-Operationen, die der Agent aufrufen kann, und die Parameter. Verwenden Sie ein von Ihnen erstelltes OpenAPI-Schema oder den Konsolentexteditor, um das Schema zu erstellen. Weitere Informationen zum Einrichten eines OpenAPI-Schemas finden Sie unter [Definieren von OpenAPI-Schemas für die Aktionsgruppen Ihres Agenten in Amazon Bedrock](agents-api-schema.md).
1. Im Abschnitt **Aktionsgruppenaufruf** legen Sie fest, was der Agent tut, nachdem er die API oder Funktion, die er aufrufen soll, vorhergesagt und die benötigten Parameter erhalten hat. Wählen Sie eine der folgenden Optionen aus:
+ **Schnell eine neue Lambda-Funktion erstellen – E*mpfohlen*** – Lassen Sie Amazon Bedrock eine grundlegende Lambda-Funktion für Ihren Agenten erstellen, die Sie später in AWS Lambda für Ihren Anwendungsfall ändern können. Der Agent übergibt die API oder Funktion, die er vorhersagt, und die auf der Sitzung basierenden Parameter an die Lambda-Funktion.
+ **Eine vorhandene Lambda-Funktion auswählen** – Wählen Sie eine [Lambda-Funktion, die Sie zuvor in AWS Lambda erstellt haben](agents-lambda.md), und die zu verwendende Version der Funktion. Der Agent übergibt die API oder Funktion, die er vorhersagt, und die auf der Sitzung basierenden Parameter an die Lambda-Funktion.
**Anmerkung**
Wenn Sie dem Service-Prinzipal von Amazon Bedrock den Zugriff auf die Lambda-Funktion ermöglichen möchten, [hängen Sie der Lambda-Funktion eine ressourcenbasierte Richtlinie an](agents-permissions.md#agents-permissions-lambda).
+ **Kontrolle zurückgeben** – Anstatt die vorhergesagten Parameter für die API oder Funktion an die Lambda-Funktion zu übergeben, gibt der Agent die Kontrolle an Ihre Anwendung zurück. Er übergibt in der [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html)-Antwort die Aktion, von der er vorhersagt, dass sie aufgerufen werden sollte, zusätzlich zu den Parametern und Informationen für die Aktion, die er in der Sitzung ermittelt hat. Weitere Informationen finden Sie unter [Zurückgeben der Steuerung an den Agent-Entwickler durch Senden der abgerufenen Informationen in einer InvokeAgent-Antwort](agents-returncontrol.md).
1. Abhängig von Ihrer Wahl für den **Aktionsgruppentyp** wird einer der folgenden Abschnitte angezeigt:
+ Wenn Sie **Mit Funktionsdetails definieren** ausgewählt haben, steht Ihnen der Abschnitt **Aktionsgruppenfunktion** zur Verfügung. Gehen Sie wie folgt vor, um die Funktion zu definieren:
1. Geben Sie einen **Namen** und eine optionale (aber empfohlene) **Beschreibung** ein.
1. Um vor dem Aufruf der Funktion eine Bestätigung vom Benutzer anzufordern, wählen Sie **Aktiviert** aus. Das Anfordern einer Bestätigung, bevor die Funktion aufgerufen wird, kann Ihre Anwendung davor schützen, aufgrund bösartiger Promptinjektionen Maßnahmen zu ergreifen.
1. Wählen Sie im Unterabschnitt **Parameter** die Option **Parameter hinzufügen** aus. Definieren Sie die folgenden Felder:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/agents-action-add.html)
1. Wenn Sie einen weiteren Parameter hinzufügen möchten, wählen Sie **Parameter hinzufügen** aus.
1. Wenn Sie ein Feld in einem Parameter bearbeiten möchten, wählen Sie das Feld aus und bearbeiten Sie es nach Bedarf.
1. Wenn Sie einen Parameter löschen möchten, wählen Sie das Löschsymbol (![\[Trapezoid-shaped diagram showing data flow from source to destination through AWS Transfer Family.\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/icons/trash.png)) in der Zeile aus, die den Parameter enthält.
Wenn Sie die Funktion lieber mithilfe eines JSON-Objekts definieren möchten, wählen Sie **JSON-Editor** statt **Tabelle** aus. Das JSON-Objektformat lautet wie folgt (jeder Schlüssel im `parameters`-Objekt ist ein Parametername, den Sie angeben):
```
{
"name": "string",
"description": "string",
"parameters": [
{
"name": "string",
"description": "string",
"required": "True" | "False",
"type": "string" | "number" | "integer" | "boolean" | "array"
}
]
}
```
Wenn Sie Ihrer Aktionsgruppe eine weitere Funktion hinzufügen möchten, indem Sie einen anderen Satz von Parametern definieren, wählen Sie **Aktionsgruppenfunktion hinzufügen** aus.
+ Wenn Sie **Mit API-Schemas definieren** ausgewählt haben, steht Ihnen der Abschnitt **Aktionsgruppenschema** mit den folgenden Optionen zur Verfügung:
+ Wenn Sie ein OpenAPI-Schema verwenden möchten, das Sie zuvor mit API-Beschreibungen, Strukturen und Parametern für die Aktionsgruppe vorbereitet haben, wählen Sie **API-Schema auswählen** aus und geben Sie einen Link zum Amazon-S3-URI des Schemas an.
+ Wenn Sie das OpenAPI-Schema mit dem Inline-Schema-Editor definieren möchten, wählen Sie **Über den Inline-Schema-Editor definieren** aus. Es wird ein Beispielschema angezeigt, das Sie bearbeiten können.
1. Wählen Sie das Format für das Schema aus, indem Sie das Dropdownmenü neben **Format** verwenden.
1. Wählen Sie **Schema importieren**, geben Sie den S3-URI ein und wählen Sie dann **Importieren**, um ein vorhandenes Schema zur Bearbeitung aus S3 zu importieren.
1. Wählen Sie **Zurücksetzen** und bestätigen Sie dann die angezeigte Meldung, indem Sie erneut auf **Zurücksetzen** klicken, um das Schema auf das ursprüngliche Beispielschema zurückzusetzen.
1. Wenn Sie mit der Erstellung der Aktionsgruppe fertig sind, wählen Sie **Hinzufügen** aus. Wenn Sie ein API-Schema definiert haben, wird ein grünes Erfolgsbanner angezeigt, wenn es keine Probleme gibt. Wenn bei der Überprüfung des Schemas Probleme auftreten, wird ein rotes Banner angezeigt. Ihnen stehen folgende Optionen zur Verfügung:
+ Scrollen Sie durch das Schema, um die Zeilen zu sehen, in denen ein Fehler oder eine Warnung zur Formatierung vorliegt. Ein X weist auf einen Formatierungsfehler hin, während ein Ausrufezeichen auf eine Warnung zur Formatierung hinweist.
+ Wählen Sie im roten Banner die Option **Details anzeigen**, um eine Liste mit Fehlern im Zusammenhang mit dem Inhalt des API-Schemas anzuzeigen.
1. Vergewissern Sie sich, dass Sie den Vorgang **Vorbereiten** durchführen, um die am Agenten vorgenommenen Änderungen zu übernehmen, bevor Sie ihn testen.
------
#### [ API ]
Wenn Sie eine Aktionsgruppe erstellen möchten, senden Sie eine [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateAgentActionGroup.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateAgentActionGroup.html)-Anfrage mit einem [Build-Time-Endpunkt von Agenten für Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Sie müssen entweder ein [Funktionsschema](agents-action-function.md) oder ein [OpenAPI-Schema](agents-api-schema.md) angeben.
Die folgende Liste beschreibt die Felder in der Anforderung:
+ Die folgenden Felder sind erforderlich:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/agents-action-add.html)
+ Wenn Sie die Parameter für die Aktionsgruppe definieren möchten, müssen Sie eines der folgenden Felder angeben (Sie können nicht beide angeben).
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/agents-action-add.html)
Im Folgenden ist das allgemeine Format des `functionSchema` und `apiSchema` angegeben:
+ Jedes Element im `functionSchema`-Array ist ein [FunctionSchema](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FunctionSchema.html)-Objekt. Geben Sie für jede Funktion Folgendes an:
+ Geben Sie einen `name` und eine optionale (aber empfohlene) `description` an.
+ Geben Sie optional `ENABLED` für das `requireConfirmation`-Feld an, um eine Bestätigung vom Benutzer anzufordern, bevor die Funktion aufgerufen wird. Das Anfordern einer Bestätigung, bevor die Funktion aufgerufen wird, kann Ihre Anwendung davor schützen, aufgrund bösartiger Promptinjektionen Maßnahmen zu ergreifen.
+ In dem `parameters`-Objekt ist jeder Schlüssel ein Parametername, der Details zu diesem Parameter in einem [ParameterDetail](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ParameterDetail.html)-Objekt zugeordnet ist.
Das allgemeine Format des `functionSchema` sieht folgendermaßen aus:
```
"functionSchema": [
{
"name": "string",
"description": "string",
"requireConfirmation": ENABLED | DISABLED,
"parameters": {
"": {
"type": "string" | number | integer | boolean | array,
"description": "string",
"required": boolean
},
... // up to 5 parameters
}
},
... // up to 11 functions
]
```
+ Das [APISchema](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_APISchema.html) kann in einem der folgenden Formate vorliegen:
1. Für das folgende Format können Sie das OpenAPI-Schema im JSON- oder YAML-Format direkt als Wert einfügen.
```
"apiSchema": {
"payload": "string"
}
```
1. Geben Sie für das folgende Format den Amazon-S3-Bucket-Namen und den Objektschlüssel an, in dem das OpenAPI-Schema gespeichert ist.
```
"apiSchema": {
"s3": {
"s3BucketName": "string",
"s3ObjectKey": "string"
}
}
```
+ Wenn Sie konfigurieren möchten, wie die Aktionsgruppe den Aufruf der Aktionsgruppe verarbeitet, nachdem sie beim Benutzer Parameter abgefragt hat, müssen Sie eines der folgenden Felder innerhalb des `actionGroupExecutor`-Felds angeben.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/agents-action-add.html)
+ Die folgenden Felder sind optional:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/agents-action-add.html)
```
def create_agent_action_group(
self, name, description, agent_id, agent_version, function_arn, api_schema
):
"""
Creates an action group for an agent. An action group defines a set of actions that an
agent should carry out for the customer.
:param name: The name to give the action group.
:param description: The description of the action group.
:param agent_id: The unique identifier of the agent for which to create the action group.
:param agent_version: The version of the agent for which to create the action group.
:param function_arn: The ARN of the Lambda function containing the business logic that is
carried out upon invoking the action.
:param api_schema: Contains the OpenAPI schema for the action group.
:return: Details about the action group that was created.
"""
try:
response = self.client.create_agent_action_group(
actionGroupName=name,
description=description,
agentId=agent_id,
agentVersion=agent_version,
actionGroupExecutor={"lambda": function_arn},
apiSchema={"payload": api_schema},
)
agent_action_group = response["agentActionGroup"]
except ClientError as e:
logger.error(f"Error: Couldn't create agent action group. Here's why: {e}")
raise
else:
return agent_action_group
```
Weitere Informationen finden Sie unter [Hallo Agenten für Amazon Bedrock](bedrock-agent_example_bedrock-agent_Hello_section.md).
------
# Anzeigen von Informationen zu einer Aktionsgruppe
Wählen Sie die Registerkarte mit Ihrer bevorzugten Methode aus und führen Sie dann die Schritte aus, um zu erfahren, wie Sie Informationen zu einer Aktionsgruppe anzeigen:
------
#### [ Console ]
**So zeigen Sie Informationen zu einer Aktionsgruppe an**
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 **Agenten** aus. Wählen Sie im Abschnitt **Agenten** einen Agenten aus.
1. Wählen Sie im Abschnitt **Agenten** einen Agenten aus.
1. Wählen Sie auf der Seite mit den Details zum Agenten im Abschnitt **Arbeitsentwurf** den Arbeitsentwurf aus.
1. Wählen Sie im Abschnitt **Aktionsgruppen** eine Aktionsgruppe aus, für die Sie Informationen anzeigen möchten.
------
#### [ API ]
Senden Sie zum Abrufen von Informationen zu einer Aktionsgruppe eine [GetAgentActionGroup](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetAgentActionGroup.html)-Anfrage mit einem [Build-Time-Endpunkt von Agenten für Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) und geben Sie die `actionGroupId`, `agentId` und `agentVersion` an.
Senden Sie zum Auflisten von Informationen zu den Aktionsgruppen eines Agenten eine [ListAgentActionGroups](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListAgentActionGroups.html)-Anfrage mit einem [Build-Time-Endpunkt von Agenten für Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Geben Sie die `agentId` und die `agentVersion` an, für die Sie Aktionsgruppen anzeigen möchten. Sie können die folgenden optionalen Parameter angeben:
****
| Feld | Kurzbeschreibung |
| --- | --- |
| maxResults | Die maximale Anzahl der Ergebnisse, die in einer Antwort zurückzugeben sind. |
| nextToken | Wenn die Anzahl der Ergebnisse die Anzahl übersteigt, die Sie im Feld maxResults angegeben haben, gibt die Antwort einen nextToken-Wert zurück. Senden Sie den nextToken-Wert in einer weiteren Anforderung, um den nächsten Ergebnisstapel zu sehen. |
```
def list_agent_action_groups(self, agent_id, agent_version):
"""
List the action groups for a version of an Amazon Bedrock Agent.
:param agent_id: The unique identifier of the agent.
:param agent_version: The version of the agent.
:return: The list of action group summaries for the version of the agent.
"""
try:
action_groups = []
paginator = self.client.get_paginator("list_agent_action_groups")
for page in paginator.paginate(
agentId=agent_id,
agentVersion=agent_version,
PaginationConfig={"PageSize": 10},
):
action_groups.extend(page["actionGroupSummaries"])
except ClientError as e:
logger.error(f"Couldn't list action groups. {e}")
raise
else:
return action_groups
```
Weitere Informationen finden Sie unter [Hallo Agenten für Amazon Bedrock](bedrock-agent_example_bedrock-agent_Hello_section.md).
------
# Bearbeiten einer Aktionsgruppe
Wählen Sie die Registerkarte mit Ihrer bevorzugten Methode aus und führen Sie dann die Schritte aus, um zu erfahren, wie Sie eine Aktionsgruppe bearbeiten:
------
#### [ Console ]
**So bearbeiten Sie eine Aktionsgruppe**
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 **Agenten** aus. Wählen Sie im Abschnitt **Agenten** einen Agenten aus.
1. Wählen Sie **In Agent Builder bearbeiten** aus.
1. Wählen Sie im Abschnitt **Aktionsgruppen** eine Aktionsgruppe aus, die bearbeitet werden soll. Wählen Sie dann **Bearbeiten** aus.
1. Bearbeiten Sie die vorhandenen Felder nach Bedarf. Weitere Informationen finden Sie unter [Verwenden von Aktionsgruppen, um Aktionen zu definieren, die Ihr Agent ausführen soll](agents-action-create.md).
1. Wählen Sie für **API-Schema auswählen** die Option **Mit dem Inline-OpenAPI-Schema-Editor definieren** aus, um das Schema für die Aktionsgruppe mit dem Inline-OpenAPI-Schema-Editor zu definieren. Es wird ein Beispielschema angezeigt, das Sie bearbeiten können. Sie können die folgenden Optionen konfigurieren:
+ Wählen Sie **Schema importieren** aus, geben Sie den Amazon-S3-URI ein und wählen Sie dann **Importieren** aus, um ein vorhandenes Schema zur Bearbeitung aus Amazon S3 zu importieren.
+ Wählen Sie **Zurücksetzen** aus und bestätigen Sie dann die angezeigte Meldung, indem Sie **Bestätigen** auswählen, um das Schema auf das ursprüngliche Beispielschema zurückzusetzen.
+ Verwenden Sie das Dropdown-Menü **JSON**, um ein anderes Format für das Schema auszuwählen.
+ Wählen Sie das Zahnradsymbol unter dem Schema aus, um das visuelle Erscheinungsbild des Schemas zu ändern.
1. Wählen Sie **Aktivieren** oder **Deaktivieren** aus, um zu steuern, ob der Agent die Aktionsgruppe verwenden kann. Verwenden Sie diese Funktion, um Probleme mit dem Verhalten Ihres Agenten zu beheben.
1. Wählen Sie **Speichern**. aus, um im selben Fenster zu bleiben und Ihre Änderung zu testen. Wählen Sie **Speichern und beenden** aus, um zur Seite mit den Einzelheiten zur Aktionsgruppe zurückzukehren.
1. Wenn keine Probleme vorliegen, wird ein Erfolgsbanner angezeigt. Wenn bei der Überprüfung des Schemas Probleme auftreten, wird ein Fehlerbanner angezeigt. Wählen Sie im Banner die Option **Details anzeigen** aus, um eine Liste der Fehler anzuzeigen.
1. Damit die Änderungen übernommen werden, die Sie vor dem Testen am Agenten vorgenommen haben, wählen Sie im Fenster **Testen** oder oben auf der Seite **Arbeitsentwurf** die Option **Vorbereiten** aus.
------
#### [ API ]
Wenn Sie eine Aktionsgruppe bearbeiten möchten, senden Sie eine [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateAgentActionGroup.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateAgentActionGroup.html)-Anfrage mit einem [Build-Time-Endpunkt von Agenten für Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Da alle Felder überschrieben werden, schließen Sie sowohl Felder ein, die Sie aktualisieren möchten, als auch Felder, die unverändert bleiben sollen. Sie müssen die `agentVersion` als `DRAFT` angeben. Weitere Informationen zu den erforderlichen und optionalen Feldern finden Sie unter [Verwenden von Aktionsgruppen, um Aktionen zu definieren, die Ihr Agent ausführen soll](agents-action-create.md).
Damit die Änderungen auf den Arbeitsentwurf angewendet werden, senden Sie eine [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PrepareAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PrepareAgent.html)-Anfrage mit einem [Build-Time-Endpunkt von Agenten für Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Fügen Sie der Anfrage die `agentId` hinzu. Die Änderungen gelten für die `DRAFT`-Version, auf die der Alias `TSTALIASID` verweist.
------
# Löschen einer Aktionsgruppe
Wählen Sie die Registerkarte mit Ihrer bevorzugten Methode aus und führen Sie dann die Schritte aus, um zu erfahren, wie Sie eine Aktionsgruppe löschen:
------
#### [ Console ]
**Löschen einer Aktionsgruppe**
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 **Agenten** aus. Wählen Sie im Abschnitt **Agenten** einen Agenten aus.
1. Wählen Sie **In Agent Builder bearbeiten** aus.
1. Wählen Sie im Abschnitt **Aktionsgruppen** die Optionsschaltfläche neben der zu löschenden Aktionsgruppe.
1. Es erscheint ein Dialogfenster, das Sie vor den Auswirkungen des Löschvorgangs warnt. Zum Bestätigen, dass Sie die Aktionsgruppe löschen möchten, geben Sie **delete** in das Eingabefeld ein und wählen Sie dann **Löschen** aus.
1. Wenn der Löschvorgang abgeschlossen ist, wird ein Erfolgsbanner angezeigt.
1. Damit die Änderungen übernommen werden, die Sie vor dem Testen am Agenten vorgenommen haben, wählen Sie im Fenster **Testen** oder oben auf der Seite **Arbeitsentwurf** die Option **Vorbereiten** aus.
------
#### [ API ]
Senden Sie eine [DeleteAgentActionGroup](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteAgentActionGroup.html)-Anfrage, um eine Aktionsgruppe zu löschen, Geben Sie die `actionGroupId`, die `agentId` und die `agentVersion` an, aus der sie gelöscht werden soll. Der Wert des Parameters `skipResourceInUseCheck` ist standardmäßig `false` und der Löschvorgang wird gestoppt, wenn die Ressource verwendet wird. Wenn Sie `skipResourceInUseCheck` auf `true` setzen, wird die Ressource gelöscht, auch wenn sie in Verwendung ist.
Damit die Änderungen auf den Arbeitsentwurf angewendet werden, senden Sie eine [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PrepareAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PrepareAgent.html)-Anfrage mit einem [Build-Time-Endpunkt von Agenten für Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Fügen Sie der Anfrage die `agentId` hinzu. Die Änderungen gelten für die `DRAFT`-Version, auf die der Alias `TSTALIASID` verweist.
------