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.
# Erstellen Sie mit Amazon Bedrock Flows einen end-to-end generativen KI-Workflow
Amazon Bedrock Flows bietet Ihnen die Möglichkeit, unterstützte Foundation-Modelle (FMs) zur Erstellung von Workflows zu verwenden, indem Sie Eingabeaufforderungen, grundlegende Modelle und andere AWS Services verknüpfen, um Lösungen zu erstellen. end-to-end
Mit Flows können Sie mithilfe eines Visual Builders schnell komplexe generative KI-Workflows erstellen, problemlos in Amazon Bedrock-Angebote wie FMs Wissensdatenbanken und andere AWS Dienste integrieren, z. B. AWS Lambda indem Sie Daten zwischen ihnen übertragen, und unveränderliche Workflows bereitstellen, um mit wenigen Klicks vom Testen zur Produktion überzugehen.
Weitere Informationen zu Amazon Bedrock Flows finden Sie in den folgenden Ressourcen:
+ Die Preise für Amazon Bedrock Flows hängen von den Ressourcen ab, die Sie nutzen. Wenn Sie beispielsweise einen Flow mit einem Prompt-Knoten aufrufen, der ein Amazon Titan-Modell verwendet, wird Ihnen der Aufruf dieses Modells in Rechnung gestellt. Weitere Informationen finden Sie unter [Amazon Bedrock – Preise](https://aws.amazon.com/bedrock/pricing/).
+ Informationen zu den Kontingenten für Flows finden Sie unter [Endpunkte und Kontingente von Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html) in der Allgemeine AWS-Referenz.
Nachstehend sind einige Beispielaufgaben aufgeführt, für die Sie in Amazon Bedrock einen Flow erstellen können:
+ **E-Mail-Einladung erstellen und senden** – Erstellen Sie einen Flow, der einen Prompt-Knoten, einen Wissensdatenbank-Knoten und einen Lambda-Funktionsknoten verbindet. Geben Sie den folgenden Prompt ein, um einen E-Mail-Text zu generieren: **Send invite to John Smith’s extended team for in-person documentation read for an hour at 2PM EST next Tuesday**. Nach der Verarbeitung des Prompts fragt der Flow eine Wissensdatenbank ab, um nach den E-Mail-Adressen des erweiterten Teams von John Smith zu suchen, und sendet dann die Eingabe an eine Lambda-Funktion, um die Einladung an alle Teammitglieder in der Liste zu senden.
+ **Problembehandlung anhand der Fehlermeldung und der ID der Ressource, die den Fehler verursacht** – Der Flow sucht in einer Dokumentationsdatenbank nach den möglichen Fehlerursachen, ruft Systemprotokolle und andere relevante Informationen über die Ressource ab und aktualisiert die fehlerhaften Konfigurationen und Werte für die Ressource.
+ **Berichte generieren** – Erstellen Sie einen Flow, um Metriken für die wichtigsten Produkte zu generieren. Der Flow sucht in einer Datenbank nach den Verkaufsmetriken, aggregiert die Metriken, generiert einen zusammenfassenden Bericht über die wichtigsten Produktkäufe und veröffentlicht den Bericht im angegebenen Portal.
+ **Daten aus einem bestimmten Datensatz erfassen** – Geben Sie einen Prompt wie den folgenden ein: **Start ingesting new datasets added after 3/31 and report failures**. Der Flow beginnt mit der Vorbereitung der Daten für die Erfassung und berichtet weiterhin über den Status. Nachdem die Datenvorbereitung abgeschlossen ist, startet der Flow den Erfassungsvorgang, wobei die fehlerhaften Daten gefiltert werden. Nach Abschluss der Datenerfassung fasst der Flow die Fehler zusammen und veröffentlicht einen Fehlerbericht.
Mit Flows for Amazon Bedrock können Sie auf einfache Weise Foundation-Modelle (FMs), Prompts und andere AWS Services verknüpfen, um Ihre Flows schnell zu erstellen, zu testen und auszuführen. Sie können Flows mit dem Visual Builder in der Amazon Bedrock-Konsole oder über den APIs verwalten.
Die allgemeinen Schritte zum Erstellen, Testen und Bereitstellen eines Flows sind wie folgt:
**Erstellen des Flows:**
1. Geben Sie einen Flow-Namen, eine Beschreibung und die entsprechenden IAM-Berechtigungen an.
1. Entwerfen Sie den Flow, indem Sie die Knoten festlegen, die Sie verwenden möchten.
1. Erstellen oder definieren Sie alle Ressourcen, die Sie für jeden Knoten benötigen. Wenn Sie beispielsweise planen, eine AWS Lambda Funktion zu verwenden, definieren Sie die Funktionen, die Sie für den Knoten benötigen, um seine Aufgabe zu erledigen.
1. Fügen Sie dem Flow Knoten hinzu, konfigurieren Sie sie und stellen Sie Verbindungen zwischen den Knoten her, indem Sie die Ausgabe eines Knotens mit der Eingabe eines anderen Knotens im Flow verknüpfen.
**Testen des Flows:**
1. Bereiten Sie den Flow so vor, dass die neuesten Änderungen für den *Arbeitsentwurf* des Flows gelten. Dabei handelt es sich um eine Version des Flows, die Sie verwenden können, um Ihren Flow iterativ zu testen und zu aktualisieren.
1. Testen Sie den Flow, indem Sie ihn mit Beispieleingaben aufrufen, um zu sehen, welche Ausgaben er liefert.
1. Wenn Sie mit der Konfiguration eines Flows zufrieden sind, können Sie einen Snapshot davon erstellen, indem Sie eine *Version* veröffentlichen. Die Version erhält die Flow-Definition in dem Zustand, in dem sie zum Erstellungszeitpunkt war. Versionen sind unveränderlich, da sie als Snapshot des Flows zum Erstellungszeitpunkt dienen.
**Bereitstellen des Flows:**
1. Erstellen Sie einen Alias, der auf die Version des Flows verweist, die Sie in Ihrer Anwendung verwenden möchten.
1. Richten Sie die Anwendung so ein, dass `InvokeFlow`-Anfragen an diesen Alias gestellt werden. Wenn Sie zu einer älteren Version zurückkehren oder ein Upgrade auf eine neuere Version durchführen müssen, können Sie die Routing-Konfiguration des Alias ändern.
**Topics**
+ [
# Funktionsweise von Amazon Bedrock Flows
](flows-how-it-works.md)
+ [
# Unterstützte Regionen und Modelle für Flows
](flows-supported.md)
+ [
# Voraussetzungen für Amazon Bedrock Flows
](flows-prereq.md)
+ [
# Einen Flow in Amazon Bedrock erstellen und gestalten
](flows-create.md)
+ [
# Anzeigen von Informationen zu Flows in Amazon Bedrock
](flows-view.md)
+ [
# Ändern eines Flows in Amazon Bedrock
](flows-modify.md)
+ [
# Integrieren von Integritätsschutz in den Flow in Amazon Bedrock
](flows-guardrails.md)
+ [
# Testen eines Flows in Amazon Bedrock
](flows-test.md)
+ [
# Mit Flow-Ausführungen Amazon-Bedrock-Flows asynchron ausführen
](flows-create-async.md)
+ [
# Bereitstellen eines Flows in Ihrer Anwendung mithilfe von Versionen und Aliasen
](flows-deploy.md)
+ [
# Rufen Sie eine AWS Lambda Funktion aus einem Amazon Bedrock-Flow in einem anderen Konto auf AWS
](flow-cross-account-lambda.md)
+ [
# Konversation mit einem Amazon-Bedrock-Flow
](flows-multi-turn-invocation.md)
+ [
# Codebeispiele von Amazon Bedrock Flows ausführen
](flows-code-ex.md)
+ [
# Einen Flow in Amazon Bedrock löschen
](flows-delete.md)
# Funktionsweise von Amazon Bedrock Flows
Mit Amazon Bedrock Flows können Sie Workflows mit generativer KI erstellen, indem Sie Knoten verbinden, von denen jeder einem Schritt im Flow entspricht, der eine Amazon-Bedrock- oder verwandte Ressource aufruft. Um Eingaben in und Ausgaben von Knoten zu definieren, verwenden Sie Ausdrücke, mit denen Sie angeben, wie die Eingabe interpretiert wird. Um ein besseres Verständnis dieser Konzepte zu erhalten, lesen Sie die folgenden Themen:
**Topics**
+ [
# Wichtige Definitionen für Flows in Amazon Bedrock
](key-definitions-flow.md)
+ [
# Verwenden von Ausdrücken zum Definieren von Eingaben durch Extrahieren des relevanten Teils der gesamten Eingabe in Amazon Bedrock Flows
](flows-expressions.md)
+ [
# Knotentypen für Ihren Flow
](flows-nodes.md)
# Wichtige Definitionen für Flows in Amazon Bedrock
Die folgende Liste führt Sie in die grundlegenden Konzepte der Flows von Amazon Bedrock ein.
+ **Flow** – Ein Flow ist ein Konstrukt, das aus einem Namen, einer Beschreibung, Berechtigungen, einer Sammlung von Knoten und Verbindungen zwischen Knoten besteht. Wenn ein Flow aufgerufen wird, wird die Eingabe im Aufruf durch jeden Knoten des Flows gesendet, bis ein Ausgabeknoten erreicht wird. Die Antwort des Aufrufs gibt die endgültige Ausgabe zurück.
+ **Knoten** – Ein Knoten ist ein Schritt innerhalb eines Flows. Für jeden Knoten konfigurieren Sie seinen Namen, seine Beschreibung, Eingabe, Ausgabe und alle zusätzlichen Konfigurationen. Die Konfiguration eines Knotens unterscheidet sich je nach Typ. Weitere Informationen zu den Knotentypen finden Sie unter [Knotentypen für Ihren Flow](flows-nodes.md).
+ **Verbindung** – In den Flows in Amazon Bedrock werden zwei Verbindungstypen verwendet:
+ Eine **Datenverbindung** wird zwischen der Ausgabe eines Knotens (dem *Quellknoten*) und der Eingabe eines anderen Knotens (des *Zielknotens*) hergestellt und sendet Daten von einem Upstream-Knoten an einen Downstream-Knoten. In der Amazon-Bedrock-Konsole sind Datenverbindungen durchgezogene graue Linien.
+ Eine **bedingte Verbindung** wird zwischen einer Bedingung in einem Bedingungsknoten und einem Downstream-Knoten hergestellt und sendet Daten von dem Knoten, der dem Bedingungsknoten vorausgeht, an einen Downstream-Knoten, wenn die Bedingung erfüllt ist. In der Amazon-Bedrock-Konsole sind bedingte Verbindungen violetten Punktlinien.
+ **Ausdrücke** – Ein Ausdruck definiert, wie eine Eingabe aus der gesamten Eingabe extrahiert wird, die in einen Knoten eingeht. Weitere Informationen zum Schreiben von Ausdrücken finden Sie unter [Verwenden von Ausdrücken zum Definieren von Eingaben durch Extrahieren des relevanten Teils der gesamten Eingabe in Amazon Bedrock FlowsDefinieren von Eingaben mit Ausdrücken](flows-expressions.md).
+ **Flow Builder** – Der Flow Builder ist ein Tool auf der Amazon-Bedrock-Konsole, mit dem Sie Flows über eine visuelle Oberfläche erstellen und bearbeiten können. Sie verwenden die visuelle Oberfläche, um Knoten per Drag-and-Drop auf die Oberfläche zu ziehen und Eingaben und Ausgaben für diese Knoten zu konfigurieren, um Ihren Flow zu definieren.
+ In den nachfolgenden Abschnitten werden die folgenden Begriffe verwendet:
+ **Ganze Eingabe** – Die gesamte Eingabe, die vom vorherigen Knoten an den aktuellen Knoten gesendet wird.
+ **Upstream** – Bezieht sich auf Knoten, die zu einem früheren Zeitpunkt im Flow auftreten.
+ **Downstream** – Bezieht sich auf Knoten, die zu einem späteren Zeitpunkt im Fluss auftreten.
+ **Eingabe** – Ein Knoten kann mehrere Eingaben haben. Sie verwenden Ausdrücke, um die relevanten Teile der gesamten Eingabe zu extrahieren und sie für jede einzelne Eingabe zu verwenden. Im Flow Builder der Amazon-Bedrock-Konsole wird eine Eingabe als Kreis am linken Rand eines Knotens angezeigt. Verbinden Sie jede Eingabe mit der entsprechenden Ausgabe eines Upstream-Knotens.
+ **Ausgabe** – Ein Knoten kann mehrere Ausgaben haben. Im Flow Builder der Amazon-Bedrock-Konsole wird eine Ausgabe als Kreis am rechten Rand eines Knotens angezeigt. Verbinden Sie jede Ausgabe mit mindestens einer Eingabe in einem Downstream-Knoten.
+ **Zweig** – Wenn eine Ausgabe von einem Knoten an mehr als einen Knoten gesendet wird oder wenn ein Bedingungsknoten enthalten ist, wird der Pfad eines Flows in mehrere Zweige aufgeteilt. Jeder Zweig kann potenziell eine weitere Ausgabe in der Antwort auf den Flow-Aufruf liefern.
# Verwenden von Ausdrücken zum Definieren von Eingaben durch Extrahieren des relevanten Teils der gesamten Eingabe in Amazon Bedrock Flows
Wenn Sie die Eingaben für einen Knoten konfigurieren, müssen Sie sie in Bezug zur gesamten Eingabe definieren, die in den Knoten eingehen wird. Die gesamte Eingabe kann eine Zeichenfolge, eine Zahl, ein boolescher Wert oder ein Objekt sein. Um eine Eingabe in Bezug zur gesamten Eingabe zu definieren, verwenden Sie eine Teilmenge unterstützter Ausdrücke, die auf [JsonPath](https://github.com/json-path/JsonPath) basieren. Jeder Ausdruck muss mit `$.data` beginnen, was sich auf die gesamte Eingabe bezieht. Beachten Sie bei der Verwendung von Ausdrücken Folgendes:
+ Wenn die gesamte Eingabe eine Zeichenfolge, eine Zahl oder ein boolescher Wert ist, können Sie als Ausdruck nur `$.data` verwenden, um eine einzelne Eingabe zu definieren.
+ Wenn es sich bei der gesamten Eingabe um ein Array oder ein Objekt handelt, können Sie einen Teil davon extrahieren, um eine einzelne Eingabe zu definieren.
Um zu verstehen, wie Ausdrücke verwendet werden, nehmen wir als Beispiel an, dass die gesamte Eingabe das folgende JSON-Objekt ist:
```
{
"animals": {
"mammals": ["cat", "dog"],
"reptiles": ["snake", "turtle", "iguana"]
},
"organisms": {
"mammals": ["rabbit", "horse", "mouse"],
"flowers": ["lily", "daisy"]
},
"numbers": [1, 2, 3, 5, 8]
}
```
Sie können die folgenden Ausdrücke verwenden, um einen Teil der Eingabe zu extrahieren (die Beispiele beziehen sich auf das, was vom vorherigen JSON-Objekt zurückgegeben würde):
****
| Ausdruck | Bedeutung | Beispiel | Beispielergebnis |
| --- | --- | --- | --- |
| \$1.data | Die gesamte Eingabe | \$1.data | Das gesamte Objekt |
| .name | Der Wert für das Feld name in einem JSON-Objekt | \$1.data.numbers | [1, 2, 3, 5, 8] |
| [int] | Das Mitglied an dem durch int angegebenen Index in einem Array | \$1.data.animals.reptiles[2] | iguana |
| [int1, int2, ...] | Die Mitglieder an den durch int angegebenen Indizes in einem Array | \$1.data.numbers[0, 3] | [1, 5] |
| [int1:int2] | Ein Array, das aus den Elementen an den Indizes zwischen int1 (einschließlich) und int2 (exklusiv) in einem Array besteht. Das Weglassen von int1 oder int2 entspricht der Markierung des Anfangs oder Endes des Arrays. | \$1.data.organisms.mammals[1:] | ["horse", "mouse"] |
| \$1 | Ein Platzhalter, der anstelle von name oder int verwendet werden kann. Wenn es mehrere Ergebnisse gibt, werden die Ergebnisse in einem Array zurückgegeben. | \$1.data.\$1.mammals | [["cat", "dog"], ["rabbit", "horse", "mouse"]] |
# Knotentypen für Ihren Flow
Amazon Bedrock Flows bietet die folgenden Knotentypen zum Erstellen Ihres Flows. Wenn Sie einen Knoten konfigurieren, füllen Sie die folgenden Felder aus:
+ Name – Geben Sie einen Namen für den Knoten ein.
+ Typ – In der Konsole legen Sie den zu verwendenden Knotentyp per Drag-and-Drop ab. Verwenden Sie in der API das `type` Feld und das entsprechende [FlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNodeConfiguration.html)`configuration`Feld.
+ Eingaben – Geben Sie für jede Eingabe die folgenden Informationen an:
+ Name – Einen Namen für die Eingabe. Für einige Knoten gibt es vordefinierte Namen oder Typen, die Sie verwenden müssen. Informationen zu den Knoten mit vordefinierten Namen finden Sie unter [Typen von Logikknoten](#flows-nodes-logic-table).
+ Ausdruck – Definieren Sie den Teil der gesamten Eingabe, der als einzelne Eingabe verwendet werden soll. Weitere Informationen finden Sie unter [Verwenden von Ausdrücken zum Definieren von Eingaben durch Extrahieren des relevanten Teils der gesamten Eingabe in Amazon Bedrock FlowsDefinieren von Eingaben mit Ausdrücken](flows-expressions.md).
+ Typ – Der Datentyp der Eingabe. Wenn dieser Knoten während der Laufzeit erreicht wird, wendet Amazon Bedrock den Ausdruck auf die gesamte Eingabe an und überprüft, ob das Ergebnis dem Datentyp entspricht.
+ Ausgaben – Geben Sie für jede Ausgabe die folgenden Informationen an:
+ Name – Einen Namen für die Ausgabe. Für einige Knoten gibt es vordefinierte Namen oder Typen, die Sie verwenden müssen. Informationen zu den Knoten mit vordefinierten Namen finden Sie unter [Typen von Logikknoten](#flows-nodes-logic-table).
+ Typ – Der Datentyp der Ausgabe. Wenn dieser Knoten während der Laufzeit erreicht wird, überprüft Amazon Bedrock, ob die Knotenausgabe dem Datentyp entspricht.
+ Konfiguration – In der Konsole definieren Sie knotenspezifische Felder im oberen Bereich des Knotens. Verwenden Sie in der API das entsprechende [FlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNodeConfiguration.html)und füllen Sie die entsprechenden Felder aus.
Jeder Knotentyp wird nachstehend unter Angabe seiner Struktur in der API beschrieben. Erweitern Sie einen Abschnitt, um mehr über den betreffenden Knotentyp zu erfahren.
## Knoten zur Steuerung der Flow-Logik
Verwenden Sie die folgenden Knotentypen, um die Logik Ihres Flows zu steuern.
### Flow-Eingabeknoten
Jeder Flow enthält nur einen Flow-Eingabeknoten und muss mit diesem beginnen. Der Flow-Eingabeknoten nimmt den `content` aus der `InvokeFlow`-Anfrage entgegen, validiert den Datentyp und sendet ihn an den folgenden Knoten.
Im Folgenden wird die allgemeine Struktur eines [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)Eingabeobjekts in der API dargestellt:
```
{
"name": "string",
"type": "Input",
"outputs": [
{
"name": "document",
"type": "String | Number | Boolean | Object | Array",
}
],
"configuration": {
"input": CONTEXT-DEPENDENT
}
}
```
### Flow-Ausgabeknoten
Ein Flow-Ausgabeknoten extrahiert die Eingabedaten aus dem vorherigen Knoten anhand des definierten Ausdrucks und gibt sie zurück. In der Konsole ist die Ausgabe die Antwort, die zurückgegeben wird, nachdem Sie im Testfenster auf **Ausführen** geklickt haben. In der API wird die Ausgabe im Feld `content` von `flowOutputEvent` in der `InvokeFlow`-Antwort zurückgegeben. Ein Flow kann mehrere Flow-Ausgabeknoten aufweisen.
Ein Flow kann mehrere Flow-Ausgabeknoten besitzen, wenn er mehrere Verzweigungen enthält.
Im Folgenden wird die allgemeine Struktur eines [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)Ausgabeobjekts dargestellt:
```
{
"name": "string",
"type": "Output",
"inputs": [
{
"name": "document",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
}
],
"configuration": {
"output": CONTEXT-DEPENDENT
}
}
```
### Bedingungsknoten
Ein Bedingungsknoten sendet entsprechend den definierten Bedingungen Daten vom vorherigen Knoten an verschiedene Knoten. Ein Bedingungsknoten kann mehrere Eingaben entgegennehmen.
Ein Beispiel finden Sie unter [Erstellen eines Flows mit Bedingungsknoten](flows-ex-condition.md).
**So definieren Sie einen Bedingungsknoten**
1. Fügen Sie so viele Eingaben hinzu, wie Sie benötigen, um die Bedingungen zu evaluieren, die hinzugefügt werden sollen.
1. Geben Sie für jede Eingabe einen Namen ein, geben Sie den zu erwartenden Typ an und schreiben Sie einen Ausdruck, um den entsprechenden Teil aus der gesamten Eingabe zu extrahieren.
1. Verbinden Sie jede Eingabe mit der entsprechenden Ausgabe eines Upstream-Knotens.
1. Fügen Sie so viele Bedingungen wie nötig hinzu.
1. Gehen Sie für jede Bedingung wie folgt vor:
1. Geben Sie einen Namen für die Bedingung ein.
1. Verwenden Sie relationale und logische Operatoren, um eine Bedingung zu definieren, die Eingaben mit anderen Eingaben oder mit einer Konstante vergleicht.
**Anmerkung**
Die Bedingungen werden der Reihe nach evaluiert. Wenn mehrere Bedingungen erfüllt sind, hat die zuerst erfüllte Bedingung Vorrang.
1. Verbinden Sie jede Bedingung mit dem Downstream-Knoten, an den Sie die Daten senden möchten, wenn die betreffende Bedingung erfüllt ist.
#### Bedingungsausdrücke
Um eine Bedingung zu definieren, verweisen Sie auf eine Eingabe anhand ihres Namens und vergleichen Sie sie mithilfe eines der folgenden relationalen Operatoren mit einem Wert:
****
| Operator | Bedeutung | Unterstützte Datentypen | Beispielverwendung | Beispielbedeutung |
| --- | --- | --- | --- | --- |
| == | Gleich (der Datentyp muss ebenfalls gleich sein) | Zeichenfolge, Zahl, boolescher Wert | A == B | Wenn A gleich B ist |
| \$1= | Nicht gleich | Zeichenfolge, Zahl, boolescher Wert | A \$1= B | Wenn A nicht gleich B ist |
| > | Größer als | Zahl | A > B | Wenn A größer als B ist |
| >= | Größer als oder gleich | Zahl | A >= B | Wenn A größer als oder gleich B ist |
| < | Kleiner als | Zahl | A < B | Wenn A kleiner als B ist |
| <= | Kleiner als oder gleich | Zahl | A <= B | Wenn A kleiner als oder gleich B ist |
Sie können Eingaben mit anderen Eingaben oder mit einer Konstante in einem bedingten Ausdruck vergleichen. Wenn Sie beispielsweise die numerische Eingabe `profit` und eine andere Eingabe mit dem Namen `expenses` haben, ist sowohl **profit > expenses** als auch **profit <= 1000** ein gültiger Ausdruck.
Sie können die folgenden logischen Operatoren verwenden, um Ausdrücke für komplexere Bedingungen zu kombinieren. Es wird empfohlen, Klammern zu setzen, um Mehrdeutigkeiten bei der Gruppierung von Ausdrücken aufzulösen:
****
| Operator | Bedeutung | Beispielverwendung | Beispielbedeutung |
| --- | --- | --- | --- |
| und | Beide Ausdrücke sind wahr (true). | (A < B) and (C == 1) | Wenn beide Ausdrücke wahr (true) sind: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/flows-nodes.html) |
| oder | Mindestens ein Ausdruck ist wahr (true). | (A \$1= 2) or (B > C) | Wenn einer der Ausdrücke wahr (true) ist: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/flows-nodes.html) |
| not | Der Ausdruck ist nicht wahr (true). | not (A > B) | Wenn A nicht größer als B ist (entspricht A <= B) |
In der API definieren Sie Folgendes in dem `definition` Feld, wenn Sie eine [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html)Oder-Anfrage [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html)senden:
1. Ein [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)Bedingungsobjekt im `nodes` Array. Das allgemeine Format sieht wie folgt aus (beachten Sie, dass Bedingungsknoten keine `outputs` besitzen):
```
{
"name": "string",
"type": "Condition",
"inputs": [
{
"name": "string",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
}
],
"configuration": {
"condition": {
"conditions": [
{
"name": "string",
"expression": "string"
},
...
]
}
}
}
```
1. Für jede Eingabe in den Bedingungsknoten ein [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)Objekt im `connections` Array. Schließt ein [FlowDataConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowDataConnectionConfiguration.html)Objekt in das `configuration` Feld des `FlowConnection` Objekts ein. Das allgemeine Format des `FlowConnection`-Objekts sieht folgendermaßen aus:
```
{
"name": "string",
"source": "string",
"target": "string",
"type": "Data",
"configuration": {
"data": {
"sourceOutput": "string",
"expression": "string"
}
}
}
```
1. Für jede Bedingung (einschließlich der Standardbedingung) im Bedingungsknoten ein [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)Objekt im `connections` Array. Schließt ein [FlowConditionalConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConditionalConnectionConfiguration.html)Objekt in das `configuration` Feld des `FlowConnection` Objekts ein. Das allgemeine Format des [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)Objekts lautet wie folgt:
```
{
"name": "string",
"source": "string",
"target": "string",
"type": "Conditional",
"configuration": {
"conditional": {
"condition": "string"
}
}
}
```
Verwenden Sie relationale und logische Operatoren, um die `condition` zu definieren, die diesen `source`-Bedingungsknoten mit einem nachgelagerten `target`-Knoten verbindet. Geben Sie für die Standardbedingung die Bedingung als **default** an.
### Iteratorknoten
Ein Iteratorknoten nimmt ein Array entgegen und gibt dessen Elemente iterativ als Ausgabe an den Downstream-Knoten zurück. Die Eingaben für den Iteratorknoten werden nacheinander und nicht parallel verarbeitet. Der Flow-Ausgabeknoten gibt das Endergebnis für jede Eingabe in einer anderen Antwort zurück. Sie können auch einen Kollektorknoten verwenden, der dem Iteratorknoten nachgelagert ist, um die iterierten Antworten zu sammeln und sie zusätzlich zur Größe des Arrays als Array zurückzugeben.
Das Folgende zeigt die allgemeine Struktur eines [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)Iterator-Objekts:
```
{
"name": "string",
"type": "Iterator",
"inputs": [
{
"name": "array",
"type": "Array",
"expression": "string"
}
],
"outputs": [
{
"name": "arrayItem",
"type": "String | Number | Boolean | Object | Array",
},
{
"name": "arraySize",
"type": "Number"
}
],
"configuration": {
"iterator": CONTEXT-DEPENDENT
}
}
```
### Kollektorknoten
Ein Kollektorknoten nimmt zusätzlich zur Größe des Arrays eine iterierte Eingabe entgegen und gibt sie als Array zurück. Sie können einen Kollektorknoten verwenden, der einem Iteratorknoten nachgelagert ist, um die iterierten Elemente zu sammeln, nachdem Sie sie durch einige Knoten gesendet haben.
Im Folgenden wird die allgemeine Struktur eines [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)Collector-Objekts dargestellt:
```
{
"name": "string",
"type": "Collector",
"inputs": [
{
"name": "arrayItem",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
{
"name": "arraySize",
"type": "Number"
}
],
"outputs": [
{
"name": "collectedArray",
"type": "Array"
},
],
"configuration": {
"collector": CONTEXT-DEPENDENT
}
}
```
### DoWhile Loop-Knoten
Ein DoWhile Loop-Knoten führt eine Sequenz von Knoten wiederholt aus, solange eine angegebene Bedingung erfüllt bleibt. Die Schleife wird mindestens einmal ausgeführt, bevor die Bedingung evaluiert wird. Sie eignet sich daher ideal für Szenarien, in denen Sie eine Aktion ausführen und dann anhand des Ergebnisses prüfen müssen, ob sie wiederholt werden soll.
Der DoWhile Loop-Knoten nimmt Eingabedaten entgegen und leitet sie durch den Loop-Body. Nach jeder Iteration wird die Bedingung evaluiert, um zu bestimmen, ob der Schleifenvorgang fortgesetzt oder beendet werden soll. Die Schleife wird fortgesetzt, solange die Bedingung als wahr (true) evaluiert oder `maxIterations` nicht überschritten wird.
Im Folgenden wird die allgemeine Struktur eines DoWhile [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)Loop-Objekts veranschaulicht:
```
{
"name": "string",
"type": "DoWhile",
"inputs": [
{
"name": "loopInput",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
}
],
"outputs": [
{
"name": "loopOutput",
"type": "String | Number | Boolean | Object | Array"
},
{
"name": "iterationCount",
"type": "Number"
}
],
"configuration": {
"doWhile": {
"condition": "string",
"maxIterations": "number"
}
}
}
```
In der Konfiguration:
+ `condition` – Ein boolescher Ausdruck, der bestimmt, ob der Schleifenvorgang fortgesetzt wird. Verwenden Sie dieselben relationalen und logischen Operatoren als Bedingungsknoten. Die Bedingung wird nach jeder Iteration evaluiert.
+ `maxIterations` – Die maximale Anzahl von Iterationen. Der Standardwert ist 10. Sie müssen eine positive Zahl angeben. Dieser Parameter hilft Ihnen, Endlosschleifen zu vermeiden.
**Anmerkung**
Der Parameter `maxIterations` besitzt den Standardwert 10 und akzeptiert nur positive Zahlen. Die Schleife wird beendet, wenn entweder die Bedingung falsch (false) wird oder die maximale Anzahl von Iterationen erreicht ist.
## Knoten für die Verarbeitung von Daten im Flow
Verwenden Sie die folgenden Knotentypen, um Daten in Ihrem Flow zu verarbeiten:
### Prompt-Knoten
Ein Prompt-Knoten definiert einen Prompt, der im Flow verwendet werden soll. Sie können einen Prompt aus dem Prompt-Management verwenden oder einen Inline-Prompt im Knoten definieren. Weitere Informationen finden Sie unter [Erstellen und Speichern wiederverwendbarer Prompts mit dem Prompt-Management in Amazon Bedrock](prompt-management.md).
Ein Beispiel finden Sie unter [Ausprobieren von Beispiel-Flows](flows-ex.md).
Die Eingaben für den Prompt-Knoten sind Werte zum Ausfüllen der Variablen. Die Ausgabe ist die generierte Antwort aus dem Modell.
Im Folgenden wird die allgemeine Struktur eines [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)Prompt-Objekts veranschaulicht:
```
{
"name": "string",
"type": "prompt",
"inputs": [
{
"name": "content",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
...
],
"outputs": [
{
"name": "modelCompletion",
"type": "String"
}
],
"configuration": {
"prompt": {
"sourceConfiguration": [PromptFlowNodeSourceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PromptFlowNodeSourceConfiguration.html) object (see below),
"guardrailConfiguration": {
"guardrailIdentifier": "string",
"guardrailVersion": "string"
}
}
}
}
```
Das [PromptFlowNodeSourceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PromptFlowNodeSourceConfiguration.html)Objekt hängt davon ab, ob Sie einen Prompt aus der Prompt-Verwaltung verwenden oder ob Sie ihn inline definieren:
+ Wenn Sie einen Prompt aus dem Prompt-Management verwenden, sollte das Objekt die folgende allgemeine Struktur aufweisen:
```
{
"resource": {
"promptArn": "string"
}
}
```
+ Wenn Sie einen Inline-Prompt definieren, folgen Sie der Anleitung zur Definition einer Variante auf der API-Registerkarte von [Erstellen eines Prompts mithilfe des Prompt-Managements](prompt-management-create.md) (beachten Sie jedoch, dass dieses Objekt kein Feld `name` enthält). Das von Ihnen verwendete Objekt sollte die folgende allgemeine Struktur aufweisen:
```
{
"inline": {
"modelId": "string",
"templateType": "TEXT",
"templateConfiguration": {
"text": {
"text": "string",
"inputVariables": [
{
"name": "string"
},
...
]
}
},
"inferenceConfiguration": {
"text": {
"maxTokens": int,
"stopSequences": ["string", ...],
"temperature": float,
"topP": float
}
},
"additionalModelRequestFields": {
"key": "value",
...
}
}
}
```
Um einen Integritätsschutz aus Amazon Bedrock auf Ihren Prompt oder die daraus generierte Antwort anzuwenden, fügen Sie das Feld `guardrailConfiguration` hinzu und geben Sie die ID oder den ARN des Integritätsschutzes im Feld `guardrailIdentifier` sowie die Version des Integritätsschutzes im Feld `guardrailVersion` an.
### Agenten-Knoten
Mit einem Agentenknoten können Sie eine Aufforderung an einen Agenten senden, der zwischen den Ressourcen FMs und den zugehörigen Ressourcen koordiniert, um Aktionen für einen Endbenutzer zu identifizieren und auszuführen. Weitere Informationen finden Sie unter [Automatisieren von Aufgaben in einer Anwendung mithilfe von KI-Agenten](agents.md).
Geben Sie in der Konfiguration den Amazon-Ressourcennamen (ARN) des Alias des zu verwendenden Agenten an. Bei den Eingaben in den Knoten handelt es sich um den Prompt für den Agenten und alle zugehörigen [Prompt- oder Sitzungsattribute](agents-session-state.md). Der Knoten gibt die Antwort des Agenten als Ausgabe zurück.
Ein Agenten-Knoten kann Multi-Turn-Aufrufe unterstützen und ermöglicht so interaktive Konversationen zwischen Benutzern und dem Agenten während der Flow-Ausführung. Wenn ein Agenten-Knoten zusätzliche Informationen oder Erläuterungen benötigt, kann er die Flow-Ausführung unterbrechen und bestimmte Eingaben vom Benutzer anfordern. Sobald der Benutzer die angeforderten Informationen bereitgestellt hat, setzt der Agenten-Knoten die Verarbeitung mit der neuen Eingabe fort. Dieser Vorgang wird fortgesetzt, bis der Agenten-Knoten über alle erforderlichen Informationen verfügt, um die Ausführung abzuschließen
Im Folgenden wird die allgemeine Struktur eines [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)Agentenobjekts veranschaulicht:
```
{
"name": "string",
"type": "Agent",
"inputs": [
{
"name": "agentInputText"
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
{
"name": "promptAttributes"
"type": "Object",
"expression": "string"
},
{
"name": "sessionAttributes"
"type": "Object",
"expression": "string"
}
],
"outputs": [
{
"name": "agentResponse",
"type": "String"
}
],
"configuration": {
"agent": {
"agentAliasArn": "string"
}
}
}
```
### Wissensdatenbank-Knoten
Mit einem Wissensdatenbank-Knoten können Sie eine Abfrage von Wissensdatenbanken für Amazon Bedrock an eine Wissensdatenbank senden. Weitere Informationen finden Sie unter [Abrufen von Daten und Generieren von KI-Antworten mit Wissensdatenbanken für Amazon Bedrock](knowledge-base.md).
Geben Sie in der Konfiguration mindestens `knowledgeBaseId` an. Je nach Anwendungsfall können Sie optional die folgenden Felder hinzufügen:
+ `modelId` – Geben Sie eine [Modell-ID](models-supported.md) an, die verwendet werden soll, wenn Sie auf der Grundlage der abgerufenen Ergebnisse eine Antwort generieren möchten. Um die abgerufenen Ergebnisse als Array zurückzugeben, lassen Sie die Modell-ID weg.
+ `guardrailConfiguration` – Geben Sie die ID oder den ARN des Integritätsschutzes, die bzw. der im Integritätsschutz für Amazon Bedrock definiert ist, in das Feld `guardrailIdentifier` und die Version des Integritätsschutzes in das Feld `guardrailVersion` ein.
**Anmerkung**
Integritätsschutz kann nur bei Verwendung von `RetrieveAndGenerate` in einem Wissensdatenbank-Knoten angewendet werden.
Die Eingabe in den Knoten ist die Abfrage an die Wissensdatenbank. Die Ausgabe ist entweder die Modellantwort als Zeichenfolge oder ein Array der abgerufenen Ergebnisse.
Im Folgenden wird die allgemeine Struktur eines [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)Wissensdatenbankobjekts veranschaulicht:
```
{
"name": "string",
"type": "KnowledgeBase",
"inputs": [
{
"name": "retrievalQuery",
"type": "String",
"expression": "string"
}
],
"outputs": [
{
"name": "retrievalResults" | "outputText",
"type": "Array | String"
}
],
"configuration": {
"knowledgeBase": {
"knowledgeBaseId": "string",
"modelId": "string",
"guardrailConfiguration": {
"guardrailIdentifier": "string",
"guardrailVersion": "string"
}
}
}
}
```
### S3-Speicherknoten
Ein S3-Speicherknoten ermöglicht das Speichern von Daten im Flow in einen Amazon-S3-Bucket. In der Konfiguration geben Sie den S3-Bucket an, der für die Datenspeicherung verwendet werden soll. Die Eingaben in den Knoten sind der zu speichernde Inhalt und der [Objektschlüssel](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html). Der Knoten gibt den URI des S3-Speicherorts als Ausgabe zurück.
Im Folgenden wird die allgemeine Struktur eines [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)S3-Speicherobjekts veranschaulicht:
```
{
"name": "string",
"type": "Storage",
"inputs": [
{
"name": "content",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
{
"name": "objectKey",
"type": "String",
"expression": "string"
}
],
"outputs": [
{
"name": "s3Uri",
"type": "String"
}
],
"configuration": {
"retrieval": {
"serviceConfiguration": {
"s3": {
"bucketName": "string"
}
}
}
}
}
```
### S3-Abrufknoten
Mit einem S3-Abrufknoten können Sie Daten von einem Amazon-S3-Speicherort abrufen und in den Flow einführen. In der Konfiguration geben Sie den S3-Bucket an, aus dem Daten abgerufen werden sollen. Die Eingabe in den Knoten ist der [Objektschlüssel](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html). Der Knoten gibt den Inhalt am S3-Speicherort als Ausgabe zurück.
**Anmerkung**
Aktuell müssen die Daten am S3-Speicherort eine UTF-8-codierte Zeichenfolge sein.
Im Folgenden wird die allgemeine Struktur eines [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)S3-Abrufobjekts dargestellt:
```
{
"name": "string",
"type": "Retrieval",
"inputs": [
{
"name": "objectKey",
"type": "String",
"expression": "string"
}
],
"outputs": [
{
"name": "s3Content",
"type": "String"
}
],
"configuration": {
"retrieval": {
"serviceConfiguration": {
"s3": {
"bucketName": "string"
}
}
}
}
}
```
### Lambda-Funktionsknoten
Mit einem Lambda-Funktionsknoten können Sie eine Lambda-Funktion aufrufen, in der Sie Code zur Ausführung der Geschäftslogik definieren können. Wenn Sie einen Lambda-Knoten in einen Flow einbeziehen, sendet Amazon Bedrock ein Eingabeereignis an die von Ihnen angegebene Lambda-Funktion.
Geben Sie in der Konfiguration den Amazon-Ressourcennamen (ARN) der Lambda-Funktion an. Definieren Sie Eingaben, die im Lambda-Eingabeereignis gesendet werden. Sie können auf der Grundlage dieser Eingaben Code schreiben und definieren, was die Funktion zurückgibt. Die Funktionsantwort wird in der Ausgabe zurückgegeben.
Das Folgende zeigt die allgemeine Struktur eines [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)Lambda-Funktionsobjekts:
```
{
"name": "string",
"type": "LambdaFunction",
"inputs": [
{
"name": "codeHookInput",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
...
],
"outputs": [
{
"name": "functionResponse",
"type": "String | Number | Boolean | Object | Array"
}
],
"configuration": {
"lambdaFunction": {
"lambdaArn": "string"
}
}
}
```
#### Lambda-Eingabeereignis für einen Flow
Das Eingabeereignis, das an eine Lambda-Funktion in einem Lambda-Knoten gesendet wird, besitzt das folgende Format:
```
{
"messageVersion": "1.0",
"flow": {
"flowArn": "string",
"flowAliasArn": "string"
},
"node": {
"name": "string",
"inputs": [
{
"name": "string",
"type": "String | Number | Boolean | Object | Array",
"expression": "string",
"value": ...
},
...
]
}
}
```
Die Felder für jede Eingabe entsprechen den Feldern, die Sie bei der Definition des Lambda-Knotens angeben, während der Wert des Felds `value` mit der gesamten Eingabe in den Knoten gefüllt wird, nachdem er durch den Ausdruck aufgelöst wurde. Wenn beispielsweise die gesamte Eingabe in den Knoten `[1, 2, 3]` und der Ausdruck `$.data[1]` ist, wäre der Wert, der im Eingabeereignis an die Lambda-Funktion gesendet wird, `2`.
Weitere Informationen zu Ereignissen in Lambda finden Sie unter [Lambda-Konzepte](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-event) im [Entwicklerhandbuch zu AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/).
#### Lambda-Antwort für einen Flow
Wenn Sie eine Lambda-Funktion schreiben, definieren Sie die von ihr zurückgegebene Antwort. Diese Antwort wird als Ausgabe des Lambda-Knotens an Ihren Flow zurückgegeben.
### Inline-Code-Knoten
Mit einem Inline-Code-Knoten können Sie Code direkt im Flow schreiben und ausführen und so Datentransformationen, benutzerdefinierte Logik und Integrationen ermöglichen, ohne eine externe Lambda-Funktion zu verwenden. Wenn Sie einen Inline-Codeknoten in Ihren Flow aufnehmen, führt Amazon Bedrock Ihren Code in einer isolierten, AWS verwalteten Umgebung aus, die mit niemandem geteilt wird und über keinen Internetzugang verfügt.
**Anmerkung**
Der Inline-Code-Knoten ist als Vorabversion für Amazon Bedrock verfügbar und unterliegt Änderungen.
Geben Sie in der Knotenkonfiguration den auszuführenden Code zusammen mit der Programmiersprache (`Python_3` ist derzeit die einzige Option) an. Definieren Sie Eingaben, auf die Ihr Code zugreifen kann, als Variablen. Das Ergebnis der letzten ausgeführten Zeile im Code wird als Knotenausgabe zurückgegeben.
Das folgende Beispiel zeigt die allgemeine Struktur eines Inline-Code-Objekts: [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)
```
{
"name": "string",
"type": "InlineCode",
"inputs": [{
"name": "string",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
...
],
"outputs": [{
"name": "response",
"type": "String | Number | Boolean | Object | Array"
}],
"configuration": {
"inlineCode": {
"code": "string",
"language": "Python_3"
}
}
}
```
#### Überlegungen zur Verwendung von Inline-Code-Knoten
Bei Verwendung von Inline-Code-Knoten im Flow sollten Sie folgende Punkte berücksichtigen:
**Wichtig**
Wir empfehlen, Ihren Code zu testen, bevor Sie ihn zu einem Inline-Code-Knoten hinzufügen.
+ Inline-Code-Knoten werden bei [asynchroner Flow-Ausführung](flows-create-async.md) nicht unterstützt.
+ Derzeit ist Python 3.12 (`Python_3)` die einzige Programmiersprache, die von Inline-Code-Knoten unterstützt wird.
+ Inline-Code verhält sich wie eine interaktive Python-Sitzung. Nur das Ergebnis der zuletzt ausgeführten Zeile wird erfasst und als Knotenausgabe zurückgegeben.
+ Die Python-Konsolenausgabe (z. B. die Ausgabe von der `print`-Funktion) wird nicht erfasst.
+ Eingaben für Ihren Inline-Code-Knoten sind als Python-Variablen im Code verfügbar. Verwenden Sie den exakten Namen der Knoteneingabe, um auf sie zu verweisen.
+ Konfigurieren Sie die Eingabe- und Ausgabetypen korrekt, um Laufzeitfehler zu vermeiden. Sie können bis zu fünf Knoteneingaben konfigurieren.
+ Es sind bis zu fünf Inline-Code-Knoten pro Flow möglich.
+ Sie können maximal 25 Inline-Code-Knoten pro AWS-Konto gleichzeitig ausführen.
+ Ihr Code darf 5 MB nicht überschreiten.
#### Inline-Code-Knoteneingaben
Die Eingaben, die Sie für einen Inline-Code-Knoten definieren, sind als Python-Variablen im Code verfügbar. Wenn Sie beispielsweise eine Eingabe mit dem Namen `userData` definieren, können Sie direkt in Ihrem Code als `userData` darauf zugreifen.
Der Wert jeder Eingabe wird auf der Grundlage des von Ihnen definierten Ausdrucks eingetragen. Wenn die Eingabe für den Knoten beispielsweise `{"name": "John", "age": 30}` lautet und der Ausdruck `$.name` ist, wäre der Wert der Eingabevariablen `"John"`.
#### Inline-Code-Knotenausgabe
Das Ergebnis der letzten ausgeführten Zeile in Ihrem Code wird als Ausgabe des Inline-Code-Knotens zurückgegeben. Diese Ausgabe ist für nachfolgende Knoten im Flow verfügbar.
Der folgende Code gibt beispielsweise ein Wörterbuch als Knotenausgabe zurück:
```
# Process input data
result = {"processed": True, "data": userData}
# The last line's result is returned as the node output
result
```
### Lex-Knoten
**Anmerkung**
Der Lex-Knoten stützt sich auf den Amazon Lex Lex-Service, der Kundeninhalte für die Entwicklung und kontinuierliche Verbesserung anderer AWS Dienste speichern und verwenden kann. Als AWS Kunde können Sie verhindern, dass Ihre Inhalte gespeichert oder für Serviceverbesserungen verwendet werden. Weitere Informationen zur Implementierung einer Opt-Out-Richtlinie für Amazon Lex finden Sie unter [Opt-out-Richtlinie für KI-Services](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html).
Mit einem Lex-Knoten können Sie einen Amazon Lex-Bot aufrufen, um eine Äußerung mithilfe natürlicher Sprachverarbeitung zu verarbeiten und eine Absicht auf der Grundlage der Bot-Definition zu identifizieren. Weitere Informationen finden Sie im [Entwicklerhandbuch zu Amazon Lex](https://docs.aws.amazon.com/lex/latest/dg/).
Geben Sie in der Konfiguration den Amazon-Ressourcennamen (ARN) des Alias des zu verwendenden Bots sowie das zu verwendende Gebietsschema an. Die Eingaben in den Knoten sind die Äußerung und alle zugehörigen [Anforderungsattribute](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-request-attribs.html) oder [Sitzungsattribute](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-request-attribs.html). Der Knoten gibt die identifizierte Absicht als Ausgabe zurück.
**Anmerkung**
Derzeit unterstützt der Lex-Knoten keine Multi-Turn-Konversationen. Ein Lex-Knoten kann nur jeweils eine Äußerung verarbeiten.
Das Folgende zeigt die allgemeine Struktur eines [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)Lex-Objekts:
```
{
"name": "string",
"type": "Lex",
"inputs": [
{
"name": "inputText",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
{
"name": "requestAttributes",
"type": "Object",
"expression": "string"
},
{
"name": "sessionAttributes",
"type": "Object",
"expression": "string"
}
],
"outputs": [
{
"name": "predictedIntent",
"type": "String"
}
],
"configuration": {
"lex": {
"botAliasArn": "string",
"localeId": "string"
}
}
}
```
## Übersichtstabellen für Knotentypen
In den folgenden Tabellen sind die für alle Knotentypen zulässigen Ein- und Ausgaben aufgeführt. Beachten Sie Folgendes:
+ Wenn ein Name als **Beliebig** markiert ist, können Sie eine beliebige Zeichenfolge als Namen angeben. Ansonsten müssen Sie den in der Tabelle angegebenen Wert verwenden.
+ Wenn ein Typ als **Beliebig** markiert ist, können Sie einen der folgenden Datentypen angeben: Zeichenfolge, Zahl, boolescher Wert, Objekt, Array. Ansonsten müssen Sie den in der Tabelle angegebenen Typ verwenden.
+ Sie können mehrere Eingaben für die Knoten **Bedingung**, **Prompt**, **Lambda-Funktion** und **Inline-Code** definieren.
**Typen von Logikknoten**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/flows-nodes.html)
**Typen von Datenverarbeitungsknoten**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/flows-nodes.html)
# Unterstützte Regionen und Modelle für Flows
Amazon Bedrock Flows wird in den folgenden AWS-Regionen Bereichen unterstützt:
+ ap-northeast-1
+ ap-northeast-2
+ ap-northeast-3
+ ap-south-1
+ ap-south-2
+ ap-southeast-1
+ ap-southeast-2
+ ca-central-1
+ eu-central-1
+ eu-central-2
+ eu-north-1
+ eu-south-1
+ eu-south-2
+ eu-west-1
+ eu-west-2
+ eu-west-3
+ sa-east-1
+ us-east-1
+ us-east-2
+ us-gov-east-1
+ us-gov-west-1
+ us-west-2
Die Modelle, die in Amazon Bedrock Flows unterstützt werden, hängen von den Knoten ab, die Sie im Flow verwenden:
+ Prompt-Knoten – Sie können das Prompt-Management mit jedem Textmodell verwenden, das für die [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html)-API unterstützt wird. Eine Liste der unterstützten Modelle finden Sie unter [Unterstützte Modelle und Modellfeatures](conversation-inference-supported-models-features.md).
+ Agenten-Knoten – Eine Liste der unterstützten Modelle finden Sie unter [Unterstützte Regionen für Agenten für Amazon Bedrock](agents-supported.md).
+ Wissensdatenbank-Knoten – Eine Liste der unterstützten Modelle finden Sie unter [Unterstützte Modelle und Regionen für Amazon-Bedrock-Wissensdatenbanken](knowledge-base-supported.md).
Eine Tabelle, welche Modelle in welchen Regionen unterstützt werden, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md).
# Voraussetzungen für Amazon Bedrock Flows
Lesen Sie vor der Erstellung eines Flows die folgenden Voraussetzungen und bestimmen Sie, welche Sie erfüllen müssen:
1. Definieren oder erstellen Sie Ressourcen für einen oder mehrere Knoten, die Sie Ihrem Flow hinzufügen möchten:
+ Für einen Prompt-Knoten – Erstellen Sie einen Prompt mithilfe des Prompt-Managements. Weitere Informationen finden Sie unter [Erstellen und Speichern wiederverwendbarer Prompts mit dem Prompt-Management in Amazon Bedrock](prompt-management.md). Wenn Sie beabsichtigen, Prompts bei der Erstellung des Knotens im Flow inline zu definieren, müssen Sie im Prompt-Management keinen Prompt erstellen.
+ Für einen Wissensdatenbank-Knotenpunkt – Erstellen Sie eine Wissensdatenbank, die Sie im Flow verwenden möchten. Weitere Informationen finden Sie unter [Abrufen von Daten und Generieren von KI-Antworten mit Wissensdatenbanken für Amazon Bedrock](knowledge-base.md).
+ Für einen Agenten-Knoten – Erstellen Sie einen Agenten, den Sie im Flow verwenden möchten. Weitere Informationen finden Sie unter [Automatisieren von Aufgaben in einer Anwendung mithilfe von KI-Agenten](agents.md).
+ Für einen S3-Speicherknoten – Erstellen Sie einen S3-Bucket, um die Ausgabe eines Knotens im Flow zu speichern.
+ Für einen S3-Abrufknoten – Erstellen Sie ein S3-Objekt in einem Bucket, aus dem Daten für den Flow abgerufen werden sollen. Das S3-Objekt muss eine UTF-8-codierte Zeichenfolge sein.
+ Für einen Lambda-Knoten — Definieren Sie eine AWS Lambda Funktion für die Geschäftslogik, die Sie im Flow implementieren möchten. Weitere Informationen finden Sie im [AWS Lambda-Entwicklerhandbuch](https://docs.aws.amazon.com/lambda/latest/dg/).
+ Für einen Amazon-Lex-Knoten – Erstellen Sie einen Amazon-Lex-Bot, um Absichten zu identifizieren. Weitere Informationen finden Sie im [Entwicklerhandbuch zu Amazon Lex](https://docs.aws.amazon.com/lex/latest/dg/).
1. Um Flows verwenden zu können, müssen Sie zwei verschiedene Rollen besitzen:
1. **Benutzerrolle** — Die IAM-Rolle, mit der Sie sich anmelden AWS-Managementkonsole oder API-Aufrufe tätigen, muss über Berechtigungen verfügen, um Aktionen im Zusammenhang mit Flows auszuführen.
Wenn mit Ihrer Rolle die [AmazonBedrockFullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonBedrockFullAccess)Richtlinie verknüpft ist, müssen Sie keine zusätzlichen Berechtigungen für diese Rolle konfigurieren. Um die Berechtigungen einer Rolle nur auf Aktionen zu beschränken, die für Flows verwendet werden, fügen Sie der IAM-Rolle die folgende identitätsbasierte Richtlinie an:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "FlowPermissions",
"Effect": "Allow",
"Action": [
"bedrock:CreateFlow",
"bedrock:UpdateFlow",
"bedrock:GetFlow",
"bedrock:ListFlows",
"bedrock:DeleteFlow",
"bedrock:ValidateFlowDefinition",
"bedrock:CreateFlowVersion",
"bedrock:GetFlowVersion",
"bedrock:ListFlowVersions",
"bedrock:DeleteFlowVersion",
"bedrock:CreateFlowAlias",
"bedrock:UpdateFlowAlias",
"bedrock:GetFlowAlias",
"bedrock:ListFlowAliases",
"bedrock:DeleteFlowAlias",
"bedrock:InvokeFlow",
"bedrock:TagResource",
"bedrock:UntagResource",
"bedrock:ListTagsForResource"
],
"Resource": "*"
}
]
}
```
------
Sie können die Berechtigungen weiter einschränken, indem Sie [Aktionen](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-actions) weglassen oder [Ressourcen](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-resources) und [Bedingungsschlüssel](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-conditionkeys) angeben. Eine IAM-Identität kann API-Operationen für bestimmte Ressourcen aufrufen. Wenn Sie eine API-Operation angeben, die nicht für die in der Richtlinie angegebene Ressource verwendet werden kann, gibt Amazon Bedrock einen Fehler zurück.
1. **Servicerolle** – Eine Rolle, die es Amazon Bedrock ermöglicht, Aktionen für Sie auszuführen. Sie müssen diese Rolle angeben, wenn Sie einen Flow erstellen oder aktualisieren. Sie können eine [benutzerdefinierte AWS Identity and Access Management-[Servicerolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-role)](flows-permissions.md) erstellen.
**Anmerkung**
Wenn Sie die Amazon-Bedrock-Konsole verwenden möchten, damit beim Erstellen eines Flows automatisch eine Rolle erstellt wird, müssen Sie diese Rolle nicht manuell konfigurieren.
# Einen Flow in Amazon Bedrock erstellen und gestalten
In diesem Abschnitt erfahren Sie, wie Sie Flows mit der Amazon-Bedrock-Konsole erstellen und gestalten. Um Ihnen den Einstieg zu erleichtern, sind Flows, die Sie mit der Konsole erstellen, so konfiguriert, dass sie mit einem einzigen Prompt-Knoten ausgeführt werden. Dieser Abschnitt enthält auch weitere Beispiele und Vorlagen für die Erstellung verschiedener Arten von Flows.
Wenn Sie das AWS SDK verwenden möchten, um einen Flow zu erstellen, finden Sie weitere Informationen unter [Codebeispiele von Amazon Bedrock Flows ausführen](flows-code-ex.md).
**Topics**
+ [
# Erstellen des ersten Flows in Amazon Bedrock
](flows-get-started.md)
+ [
# Entwerfen eines Flows in Amazon Bedrock
](flows-design.md)
+ [
# Ausprobieren von Beispiel-Flows
](flows-ex.md)
+ [
# Verwenden einer Vorlage zum Erstellen eines Amazon-Bedrock-Flows
](flows-templates.md)
# Erstellen des ersten Flows in Amazon Bedrock
Jedes Mal, wenn Sie einen Flow erstellen, erstellt die Amazon-Bedrock-Konsole einen Flow, mit dem Sie beginnen können. Der Flow umfasst einen **Flow-Eingabeknoten**, einen **Prompt-Knoten** und einen **Flow-Ausgabeknoten**. Wenn Sie den Flow ausführen, geben Sie ein Thema für den Flow ein, der den Prompt-Knoten verwendet, um das Thema zusammenzufassen. Bevor Sie die Flows ausführen können, müssen Sie das Modell für den Prompt festlegen.
Um einen Flow zu erstellen, geben Sie einen Namen und eine Beschreibung für den Flow an. Standardmäßig erstellt Amazon Bedrock eine Servicerolle mit den entsprechenden Berechtigungen. Sie können wahlweise auch eine vorhandene Servicerolle angeben.
Amazon Bedrock verschlüsselt Ihre Daten im Ruhezustand. Standardmäßig verschlüsselt Amazon Bedrock diese Daten mit einem AWS-verwalteten Schlüssel. Optional können Sie die Flow-Ausführungsdaten mit einem kundenseitig verwalteten Schlüssel (CMK) verschlüsseln. Weitere Informationen finden Sie unter [Verschlüsselung von Flow-Ressourcen von Amazon Bedrock](encryption-flows.md).
Wenn Sie mit dem Flow für die ersten Schritte fertig sind oder wenn Sie ihn nicht benötigen, können Sie mit der Erstellung Ihres Flows fortfahren. Wir empfehlen, dass Sie [Funktionsweise von Amazon Bedrock Flows](flows-how-it-works.md) lesen, um sich mit den Konzepten und Begriffen in Amazon Bedrock Flows vertraut zu machen und sich über die verfügbaren Knotentypen zu informieren. Weitere Informationen finden Sie unter [Entwerfen eines Flows in Amazon Bedrock](flows-design.md).
**So erstellen Sie Ihren ersten Flow**
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 **Amazon Bedrock Flows** im linken Navigationsbereich aus.
1. Wählen Sie im Abschnitt **Amazon Bedrock Flows** die Option **Flow erstellen** aus.
1. Geben Sie unter **Name** einen Namen und optional eine **Beschreibung** für den Flow ein.
1. Wählen Sie für **Servicerolle-Name** eine der folgenden Optionen:
+ **Neue Servicerolle erstellen und verwenden** – Lassen Sie Amazon Bedrock eine Servicerolle erstellen, die Sie verwenden können.
+ **Eine vorhandene Servicerolle verwenden** – Wählen Sie eine benutzerdefinierte Servicerolle aus, die Sie zuvor konfiguriert haben. Weitere Informationen finden Sie unter [Erstellen einer Servicerolle für Amazon Bedrock Flows in Amazon Bedrock](flows-permissions.md).
1. (Optional) Verschlüsseln Sie Ihren Flow mit einem kundenseitig verwalteten Schlüssel (CMK), indem Sie wie folgt vorgehen:
1. Wählen Sie **Zusätzliche Konfiguration** aus.
1. Wählen Sie unter **KMS-Schlüsselauswahl** die Option **Verschlüsselungseinstellungen anpassen (erweitert)** aus. Wählen Sie dann eine der folgenden Optionen in **AWS KMS-Schlüssel wählen**:
+ Um einen vorhandenen Schlüssel zu verwenden, geben Sie den ARN ein oder suchen Sie nach dem Schlüssel, den Sie verwenden möchten.
+ Um einen neuen Schlüssel zu erstellen, wählen Sie **AWS KMS-Schlüssel erstellen** aus, um die AWS Key Management Service-Konsole zu öffnen und [den Schlüssel zu erstellen](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html). Wenn Sie den Schlüssel erstellen, notieren Sie sich den ARN für den Schlüssel. Zurück in der Amazon-Bedrock-Konsole geben Sie den ARN für den Schlüssel unter **AWS KMS-Schlüssel wählen** ein.
Weitere Informationen finden Sie unter [Verschlüsselung von Flow-Ressourcen von Amazon Bedrock](encryption-flows.md).
1. Klicken Sie auf **Erstellen**. Amazon Bedrock erstellt den Flow für die ersten Schritte und leitet Sie zum **Flow-Builder** weiter.
1. Im Abschnitt **Flow-Builder** werden im mittleren Bereich (Canvas) ein **Flow-Eingabeknoten**, ein **Prompt-Knoten** und eine **Flow-Ausgabe** angezeigt. Die Knoten sind bereits miteinander verbunden.
1. Wählen Sie auf der Canvas den **Prompt-Knoten** aus.
1. Wählen Sie im Bereich „Flow-Builder“ den Abschnitt **Konfigurationen** aus.
1. Vergewissern Sie sich, dass unter **Knotenname** die Option **Im Knoten definieren** aktiviert ist.
1. Wählen Sie in **Ein Modell auswählen** ein Modell zur Verwendung aus.
1. Klicken Sie auf **Speichern**, um den Flow zu speichern.
1. Geben Sie im Bereich **Flow testen** auf der rechten Seite ein Thema ein, das der Flow zusammenfassen soll.
1. Klicken Sie dann auf **Ausführen**, um den Flow auszuführen. Im Flow wird das zusammengefasste Thema angezeigt.
# Entwerfen eines Flows in Amazon Bedrock
In diesem Abschnitt entwerfen Sie einen Amazon-Bedrock-Flow. Bevor Sie einen Flow entwerfen, empfehlen wir, dass Sie [Funktionsweise von Amazon Bedrock Flows](flows-how-it-works.md) lesen, um sich mit den Konzepten und Begriffen in Amazon Bedrock Flows vertraut zu machen und sich über die verfügbaren Knotentypen zu informieren. Beispiele für Flows, die Sie ausprobieren können, finden Sie unter [Ausprobieren von Beispiel-Flows](flows-ex.md).
**So erstellen Sie einen Flow**
1. Falls Sie sich noch nicht im **Flow-Builder** befinden, gehen Sie wie folgt vor:
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 **Amazon Bedrock Flows** im linken Navigationsbereich aus. Wählen Sie dann im Abschnitt **Amazon Bedrock Flows** einen Flow aus.
1. Wählen Sie **Im Flow-Builder bearbeiten** aus.
1. Im Abschnitt **Flow-Builder** werden im mittleren Bereich ein **Flow-Eingabeknoten** und ein **Flow-Ausgabeknoten** angezeigt. Dabei handelt es sich um die Eingabe- und Ausgabeknoten für Ihren Flow.
1. Führen Sie folgende Schritte aus, um Knoten hinzuzufügen und zu konfigurieren:
1. Wählen Sie im Bereich **Flow-Builder** die Option **Knoten** aus.
1. Ziehen Sie einen Knoten, den Sie für den ersten Schritt Ihres Flows verwenden möchten, und legen Sie ihn im mittleren Bereich ab.
1. Die Kreise auf den Knoten sind Verbindungspunkte. Um den Flow-Eingabeknoten mit dem zweiten Knoten zu verbinden, ziehen Sie eine Linie vom Kreis auf dem **Flow-Eingabeknoten** zum Kreis im Abschnitt **Eingabe** des Knotens, den Sie gerade hinzugefügt haben.
1. Wählen Sie den Knoten aus, den Sie gerade hinzugefügt haben.
1. Geben Sie im Abschnitt **Konfigurieren** des Bereichs **Flow-Builder** die Konfigurationen für den ausgewählten Knoten an und definieren Sie Namen, Datentypen und Ausdrücke für die Ein- und Ausgaben des Knotens.
1. Wählen Sie im Bereich **Flow-Builder** die Option **Knoten** aus.
1. Wiederholen Sie die Schritte, um die übrigen Knoten in Ihrem Flow hinzuzufügen und zu konfigurieren.
**Anmerkung**
Wenn Sie eine Servicerolle verwenden, die Amazon Bedrock automatisch für Sie erstellt hat, wird die Rolle mit den entsprechenden Berechtigungen aktualisiert, wenn Sie Knoten hinzufügen. Wenn Sie eine benutzerdefinierte Servicerolle verwenden, müssen Sie der Richtlinie, die der Servicerolle angefügt ist, die entsprechenden Berechtigungen hinzufügen, indem Sie auf [Erstellen einer Servicerolle für Amazon Bedrock Flows in Amazon Bedrock](flows-permissions.md) verweisen.
1. Verbinden Sie die **Ausgabe** des letzten Knotens im Flow mit der **Eingabe** des **Flow-Ausgabeknotens**. Es sind mehrere **Flow-Ausgabeknoten** möglich. Um weitere Flow-Ausgabeknoten hinzuzufügen, ziehen Sie den **Flow-Ausgabeknoten** und legen Sie ihn neben dem Knoten ab, an dem der Flow enden soll. Achten Sie darauf, Verbindungen zwischen den beiden Knoten herzustellen.
1. Fahren Sie mit dem nächsten Verfahren [Testen eines Flows in Amazon Bedrock](flows-test.md) fort oder kehren Sie später zurück. Klicken Sie auf **Speichern**, um mit dem nächsten Schritt fortzufahren. Wenn Sie später zurückkehren möchten, klicken Sie auf **Speichern und beenden**.
**Löschen eines Knotens oder einer Verbindung**
Während der Erstellung des Flows müssen Sie möglicherweise einen Knoten löschen oder Knotenverbindungen entfernen.
**So löschen Sie einen Knoten**
1. Wählen Sie einen Knoten aus, der gelöscht werden soll.
1. Klicken Sie im Bereich **Flow-Builder** auf 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)).
**Anmerkung**
Wenn Sie eine Servicerolle verwenden, die Amazon Bedrock automatisch für Sie erstellt hat, wird die Rolle mit den entsprechenden Berechtigungen aktualisiert, wenn Sie Knoten hinzufügen. Wenn Sie Knoten löschen, werden die entsprechenden Berechtigungen jedoch nicht gelöscht. Wir empfehlen, die Berechtigungen, die Sie nicht mehr benötigen, zu löschen, indem Sie die Schritte unter [Ändern einer Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_modify.html) befolgen.
**So entfernen Sie eine Verbindung**
+ Bewegen Sie auf der Seite **Flow-Builder** den Mauszeiger über die Verbindung, die Sie entfernen möchten, bis Sie das Erweiterungssymbol sehen, und ziehen Sie die Verbindung dann vom Knoten weg.
Für das Erstellen eines Flows gelten folgende Anforderungen:
+ Der Flow darf nur einen Flow-Eingabeknoten aufweisen und muss mindestens einen Flow-Ausgabeknoten besitzen.
+ Sie können keine Eingaben für einen Flow-Eingabeknoten einbeziehen.
+ Sie können keine Ausgaben für einen Flow-Ausgabeknoten einbeziehen.
+ Jede Ausgabe in einem Knoten muss mit einer Eingabe in einem nachgelagerten Knoten verbunden sein (in der API geschieht dies über eine [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html) mit einer [FlowDataConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowDataConnectionConfiguration.html)).
+ Jede Bedingung (einschließlich der Standardbedingung) in einem Knoten muss mit einem nachgelagerten Knoten verbunden sein (in der API geschieht dies über eine [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html) mit einer [FlowConditionalConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConditionalConnectionConfiguration.html)).
Für das Erstellen eines Flows gelten folgende Zeiger:
+ Legen Sie zunächst den Datentyp für die Ausgabe des Flow-Eingabeknotens fest. Dieser Datentyp sollte dem entsprechen, was Sie als Eingabe erwarten, wenn Sie den Flow aufrufen.
+ Wenn Sie die Eingaben für einen Flow mithilfe von Ausdrücken definieren, überprüfen Sie, ob das Ergebnis mit dem Datentyp übereinstimmt, den Sie für die Eingabe ausgewählt haben.
+ Wenn Sie einen Iteratorknoten einbeziehen, fügen Sie einen nachgelagerten Kollektorknoten ein, nachdem Sie die Ausgabe durch die benötigten Knoten gesendet haben. Der Kollektorknoten gibt die Ausgaben in einem Array zurück.
# Ausprobieren von Beispiel-Flows
Dieses Thema enthält einige Beispiel-Flows, die Sie ausprobieren können, um mit Amazon Bedrock Flows zu beginnen. Sie können auch Vorlagen verwenden, um Ihren ersten Flow zu erstellen. Weitere Informationen finden Sie unter [Verwenden einer Vorlage zum Erstellen eines Amazon-Bedrock-Flows](flows-templates.md).
Erweitern Sie ein Beispiel, um zu sehen, wie er in der Amazon-Bedrock-Konsole erstellt wird:
**Topics**
+ [
# Erstellen eines Flows mit einem einzigen Prompt
](flows-ex-prompt.md)
+ [
# Erstellen eines Flows mit Bedingungsknoten
](flows-ex-condition.md)
# Erstellen eines Flows mit einem einzigen Prompt
Die folgende Abbildung zeigt einen Flow, der aus einem einzigen Prompt besteht, der inline im Knoten definiert ist. Der Prompt generiert aus einer JSON-Objekteingabe eine Playlist mit Songs, die das Genre und die Anzahl der Songs, die in die Playlist aufgenommen werden sollen, enthält.
![\[Beispiel für die Verwendung eines Prompt-Knotens mit zwei Variablen\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/flows/flows-prompt.png)
**So erstellen und testen Sie diesen Flow in der Konsole**
1. Erstellen Sie einen Flow, indem Sie den Anleitungen unter [Erstellen des ersten Flows in Amazon Bedrock](flows-get-started.md) folgen.
1. Konfigurieren Sie den Prompt-Knoten wie folgt:
1. Wählen Sie den **Prompt**-Knoten im mittleren Bereich aus.
1. Wählen Sie im Bereich **Flow-Builder** die Registerkarte **Konfigurieren** aus.
1. Geben Sie **MakePlaylist** als **Knotennamen** ein.
1. Wählen Sie **Im Knoten definieren**.
1. Richten Sie die folgenden Konfigurationen für den Prompt ein:
1. Wählen Sie unter **Modell auswählen** ein Modell aus, für das beim Prompt eine Inferenz ausgeführt werden soll.
1. Geben Sie in das Textfeld **Nachricht** **Make me a \$1\$1genre\$1\$1 playlist consisting of the following number of songs: \$1\$1number\$1\$1.** ein. Daraufhin werden zwei Variablen erstellt, die als Eingaben in den Knoten angezeigt werden.
1. (Optional) Ändern Sie die **Inferenzkonfigurationen**.
1. (Optional) Falls das Modell dies unterstützt, können Sie Prompt-**Caching** für die Prompt-Nachricht konfigurieren. Weitere Informationen finden Sie unter [Einen Flow in Amazon Bedrock erstellen und gestalten](flows-create.md).
1. Erweitern Sie den Abschnitt **Eingaben**. Die Namen der Eingaben sind durch die Variablen in der Prompt-Nachricht vorausgefüllt. Konfigurieren Sie die Eingaben wie folgt:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/flows-ex-prompt.html)
Diese Konfiguration bedeutet, dass der Prompt-Knoten ein JSON-Objekt erwartet, das ein Feld namens `genre` enthält, das der Eingabe `genre` zugeordnet wird, sowie das Feld `number`, das der Eingabe `number` zugeordnet wird.
1. Sie können die **Ausgabe** nicht ändern. Es ist die Antwort des Modells, die als Zeichenfolge zurückgegeben wird.
1. Wählen Sie den **Flow-Eingabeknoten** und dann die Registerkarte **Konfigurieren** aus. Wählen Sie **Objekt** als **Typ** aus. Das bedeutet, dass der Flow-Aufruf den Empfang eines JSON-Objekts erwartet.
1. Verbinden Sie Ihre Knoten, um den Flow abzuschließen, indem Sie wie folgt vorgehen:
1. Ziehen Sie eine Verbindung vom Ausgabeknoten des **Flow-Eingabeknotens** zur Eingabe **genre** im Prompt-Knoten **MakePlaylist**.
1. Ziehen Sie eine Verbindung vom Ausgabeknoten des **Flow-Eingabeknotens** zur Eingabe **number** im Prompt-Knoten **MakePlaylist**.
1. Ziehen Sie eine Verbindung vom Ausgabeknoten der Ausgabe **modelCompletion** im Prompt-Knoten **MakePlaylist** zur Eingabe **document** im **Flow-Ausgabeknoten**.
1. Klicken Sie auf **Speichern**, um den Flow zu speichern. Der Flow sollte jetzt für den Test vorbereitet sein.
1. Testen Sie Ihren Flow, indem Sie im Bereich **Flow testen** auf der rechten Seite das folgende JSON-Objekt eingeben. Klicken Sie auf **Ausführen**. Der Flow sollte daraufhin eine Modellantwort zurückgeben.
```
{
"genre": "pop",
"number": 3
}
```
# Erstellen eines Flows mit Bedingungsknoten
Die folgende Abbildung zeigt, dass ein Flow mit einem Bedingungsknoten einen von drei möglichen Werten zurückgibt, die auf der Bedingung basieren, die erfüllt ist:
![\[Beispiel für die Verwendung eines Bedingungsknotens mit zwei Bedingungen\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/flows/flows-condition.png)
**So erstellen und testen Sie diesen Flow in der Konsole:**
1. Erstellen Sie einen Flow, indem Sie den Anleitungen unter [Erstellen des ersten Flows in Amazon Bedrock](flows-get-started.md) folgen.
1. Löschen Sie den **Prompt**-Knoten im mittleren Bereich.
1. Konfigurieren Sie den Bedingungsknoten wie folgt:
1. Wählen Sie im linken Bereich von **Flow-Builder** die Registerkarte **Knoten** aus.
1. Ziehen Sie einen **Bedingungsknoten** in den Flow im mittleren Bereich.
1. Wählen Sie im Bereich **Flow-Builder** die Registerkarte **Konfigurieren** aus.
1. Erweitern Sie den Abschnitt **Eingaben**. Konfigurieren Sie die Eingaben wie folgt:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/flows-ex-condition.html)
Diese Konfiguration bedeutet, dass der Bedingungsknoten ein JSON-Objekt erwartet, das die Felder `retailPrice`, `marketPrice` und `type` enthält.
1. Konfigurieren Sie die Bedingungen wie folgt:
1. Ändern Sie im Abschnitt **Bedingungen** optional den Namen der Bedingung. Fügen Sie dann die folgende Bedingung im Textfeld **Bedingung** hinzu: **(retailPrice > 10) and (type == "produce")**.
1. Fügen Sie eine zweite Bedingung hinzu, indem Sie **Bedingung hinzufügen** wählen. Ändern Sie optional den Namen der zweiten Bedingung. Fügen Sie dann die folgende Bedingung im Textfeld **Bedingung** hinzu: **(retailPrice < marketPrice)**.
1. Wählen Sie den **Flow-Eingabeknoten** und dann die Registerkarte **Konfigurieren** aus. Wählen Sie **Objekt** als **Typ** aus. Das bedeutet, dass der Flow-Aufruf den Empfang eines JSON-Objekts erwartet.
1. Fügen Sie Flow-Ausgabeknoten hinzu, sodass insgesamt drei vorhanden sind. Konfigurieren Sie sie auf der Registerkarte **Konfigurieren** des Bereichs **Flow-Builder** jedes Flow-Ausgabeknotens wie folgt:
1. Legen Sie als Eingabetyp des ersten Flow-Ausgabeknotens **String** und als Ausdruck **\$1.data.action[0]** fest, sodass der erste Wert im Array im Feld `action` des eingehenden Objekts zurückgegeben wird.
1. Legen Sie als Eingabetyp des zweiten Flow-Ausgabeknotens **String** und als Ausdruck **\$1.data.action[1]** fest, sodass der zweite Wert im Array im Feld `action` des eingehenden Objekts zurückgegeben wird.
1. Legen Sie als Eingabetyp des dritten Flow-Ausgabeknotens **String** und als Ausdruck **\$1.data.action[2]** fest, sodass der dritte Wert im Array im Feld `action` des eingehenden Objekts zurückgegeben wird.
1. Verbinden Sie die erste Bedingung mit dem ersten Flow-Ausgabeknoten, die zweite Bedingung mit dem zweiten Flow-Ausgabeknoten und die Standardbedingung mit dem dritten Flow-Ausgabeknoten.
1. Verbinden Sie die Eingaben und Ausgaben in allen Knoten, um den Flow abzuschließen, indem Sie wie folgt vorgehen:
1. Ziehen Sie eine Verbindung vom Ausgabeknoten des **Flow-Eingabeknotens** zur Eingabe **retailPrice** im Bedingungsknoten.
1. Ziehen Sie eine Verbindung vom Ausgabeknoten des **Flow-Eingabeknotens** zur Eingabe **marketPrice** im Bedingungsknoten.
1. Ziehen Sie eine Verbindung vom Ausgabeknoten des **Flow-Eingabeknotens** zur Eingabe **type** im Bedingungsknoten.
1. Ziehen Sie in jedem der drei Ausgabeknoten eine Verbindung von der Ausgabe des **Flow-Eingabeknotens** zur Eingabe **document**.
1. Klicken Sie auf **Speichern**, um den Flow zu speichern. Der Flow sollte jetzt für den Test vorbereitet sein.
1. Testen Sie Ihren Flow, indem Sie im Bereich **Flow testen** auf der rechten Seite die folgenden JSON-Objekte eingeben. Klicken Sie für jede Eingabe auf **Ausführen**:
1. Das folgende Objekt erfüllt die erste Bedingung (der `retailPrice` ist höher als 10 und der `type` ist „produce“) und gibt den ersten Wert in `action` („don't buy“) zurück:
```
{
"retailPrice": 11,
"marketPrice": 12,
"type": "produce",
"action": ["don't buy", "buy", "undecided"]
}
```
**Anmerkung**
Obwohl sowohl die erste als auch die zweite Bedingung erfüllt sind, hat die erste Bedingung Vorrang, da sie an erster Stelle steht.
1. Das folgende Objekt erfüllt die zweite Bedingung (der `retailPrice` ist niedriger als der `marketPrice`) und gibt den zweiten Wert in `action` („buy“) zurück:
```
{
"retailPrice": 11,
"marketPrice": 12,
"type": "meat",
"action": ["don't buy", "buy", "undecided"]
}
```
1. Das folgende Objekt erfüllt weder die erste Bedingung (der `retailPrice` ist höher als 10, aber der `type` ist nicht „produce“) noch die zweite Bedingung (der `retailPrice` ist nicht kleiner als der `marketPrice`), sodass der dritte Wert in `action` („undecided“) zurückgegeben wird:
```
{
"retailPrice": 11,
"marketPrice": 11,
"type": "meat",
"action": ["don't buy", "buy", "undecided"]
}
```
# Verwenden einer Vorlage zum Erstellen eines Amazon-Bedrock-Flows
Um Ihnen den Einstieg in die Definition und Orchestrierung von Amazon Bedrock Flows zu erleichtern, können Sie Vorlagen verwenden, mit denen Sie Flows für eine Vielzahl von Flow-Konfigurationen erstellen können. Sie können beispielsweise eine Vorlage verwenden, um sich einen Flow anzusehen, der eine Wissensdatenbank enthält, oder einen Flow, der Bedingungen verwendet, um die Flow-Logik zu steuern.
Sie greifen über das GitHub-Repository [Amazon Bedrock Flows Samples](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file) auf die Vorlagen zu. Die Amazon-Bedrock-Konsole bietet auch einen Link zum Repository von der Canvas-Seite für einen Flow.
Die Flow-Vorlagen werden als [JSON-Vorlagen](https://github.com/aws-samples/amazon-bedrock-flows-samples/tree/main/templates) für jede unterstützte Flow-Definition und als Python-Skript, mit dem Sie den Flow erstellen und ausführen, bereitgestellt. Sie können auf den Flow auch über die Amazon-Bedrock-Konsole zugreifen.
Das Repository bietet die folgenden Vorlagen:
+ [Wissensdatenbank-Flow](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#1-knowledgebase-flow-1) – Zeigt, wie Sie eine [Wissensdatenbank](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#1-knowledgebase-flow-1) integrieren und abfragen können, einschließlich RAG (Retrieval Augmented Generation) und Wissensdatenbanksuche und -abruf
+ [Agenten-Flow für Multi-Turn-Konversationen](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#2-multi-turn-conversation-agent-flow-1) – Zeigt, wie interaktive, zustandsbehaftete Konversationen mit einem Flow geführt werden. Weitere Informationen finden Sie unter [Konversation mit einem Amazon-Bedrock-Flow](flows-multi-turn-invocation.md).
+ [Bedingungen-Flow](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#3-conditions-flow-1) – Zeigt, wie bedingte Logik und Verzweigungen innerhalb eines Flows ausgeführt werden
+ [Prompt-Knoten mit Integritätsschutz](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#4-prompt-node-with-guardrail-flow-1) – Zeigt, wie ein Prompt-Knoten mit Integritätsschutz geschützt werden kann
+ [Iterator- und Kollektor-Flow](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#5-iterator--collector-flow-1) – Zeigt, wie mehrere Eingaben verarbeitet und Antworten aggregiert werden
+ [Flow mit mehreren Agenten](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#5-iterator--collector-flow-1) – Zeigt verschiedene agentenbasierte Workflows an, darunter die Zusammenarbeit mehrerer Agenten und die Delegierung von Aufgaben
Bevor Sie das Skript ausführen können, müssen Sie die Amazon-Bedrock-Ressourcen, z. B. eine Wissensdatenbank oder einen Agenten, erstellen, die der Flow verwendet. Es liegt in Ihrer Verantwortung, diese Ressourcen zu löschen, wenn Sie sie nicht mehr benötigen.
Um einen Flow aus einer Vorlage zu erstellen und auszuführen, führen Sie das Skript (`flow_manager.py`) aus. Das Skript fordert zusätzliche Informationen an, die es benötigt, z. B. die Flow-Vorlage, die Sie verwenden möchten, und Kennungen für Ressourcen, die die Vorlage benötigt. Sie können einen Test-Prompt hinzufügen, um den Flow auszuprobieren.
Optional können Sie die AWS-Region festlegen, in der der Flow erstellt werden soll. Das Skript erstellt die erforderlichen Ressourcen mit einem Standardsatz von [IAM-Rollenberechtigungen](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#iam-role-permissions). Sie können auch eine von Ihnen erstellte IAM-Rolle verwenden.
Wenn Sie den Flow in der Amazon-Bedrock-Konsole nutzen möchten, verwenden Sie nicht den Parameter `--cleanup`, da dadurch der Flow gelöscht wird, nachdem das Skript den Flow ausgeführt hat. Wenn Sie `--cleanup` nicht verwenden, müssen Sie den Flow löschen, wenn Sie ihn nicht mehr benötigen.
Weitere Informationen finden Sie unter [https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file\$1how-to-use](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#how-to-use).
# Anzeigen von Informationen zu Flows in Amazon Bedrock
Um zu erfahren, wie Sie Informationen zu einem Flow anzeigen, wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und befolgen Sie die angegebenen Schritte:
------
#### [ Console ]
**So zeigen Sie die Details eines Flows 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 **Amazon Bedrock Flows** im linken Navigationsbereich aus. Wählen Sie dann im Abschnitt **Amazon Bedrock Flows** einen Flow aus.
1. Zeigen Sie die Details des Flows im Bereich **Flow-Details** an.
------
#### [ API ]
Um Informationen zu einem Flow zu erhalten, senden Sie eine [GetFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlow.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 den ARN oder die ID des Flows als `flowIdentifier` an.
Um Informationen zu Ihren Flows aufzulisten, senden Sie eine [ListFlows](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlows.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 können die folgenden optionalen Parameter festlegen:
****
| 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. |
------
# Ändern eines Flows in Amazon Bedrock
Wählen Sie die Registerkarte mit Ihrer bevorzugten Methode aus und führen Sie dann die Schritte aus, um zu erfahren, wie Sie einen Flow ändern:
------
#### [ Console ]
**So ändern Sie die Details eines Flows**
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 **Amazon Bedrock Flows** im linken Navigationsbereich aus. Wählen Sie dann im Abschnitt **Amazon Bedrock Flows** einen Flow aus.
1. Wählen Sie im Abschnitt **Flow-Details** die Option **Bearbeiten** aus.
1. Sie können den Namen und die Beschreibung bearbeiten und dem Flow eine andere Servicerolle zuweisen.
1. Wählen Sie **Änderungen speichern** aus.
**So ändern Sie einen Flow**
1. Falls Sie sich noch nicht im **Flow-Builder** befinden, gehen Sie wie folgt vor:
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 **Amazon Bedrock Flows** im linken Navigationsbereich aus. Wählen Sie dann im Abschnitt **Amazon Bedrock Flows** einen Flow aus.
1. Wählen Sie **Im Flow-Builder bearbeiten** aus.
1. Fügen Sie nach Bedarf Knoten und Verbindungen hinzu oder entfernen und ändern Sie sie. Weitere Informationen finden Sie unter [Einen Flow in Amazon Bedrock erstellen und gestalten](flows-create.md) und [Knotentypen für Ihren Flow](flows-nodes.md).
1. Wenn Sie alle Änderungen für Ihren Flow vorgenommen haben, klicken Sie auf **Speichern** oder **Speichern und beenden**.
------
#### [ API ]
Wenn Sie einen Flow bearbeiten möchten, senden Sie eine [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.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). Schließen Sie sowohl Felder ein, die Sie beibehalten möchten, als auch Felder, die geändert werden sollen. Informationen zu den Feldern in der Anforderung finden Sie unter [Einen Flow in Amazon Bedrock erstellen und gestalten](flows-create.md).
------
# Integrieren von Integritätsschutz in den Flow in Amazon Bedrock
Amazon Bedrock Flows ist im Integritätsschutz für Amazon Bedrock integriert, sodass Sie unerwünschten Inhalt in Ihrem Flow identifizieren und blockieren oder filtern können. In der folgenden Tabelle erfahren Sie, wie Sie Integritätsschutz auf unterstützte Knotentypen in einem Flow anwenden können:
****
| Knotentyp | Konsole | API |
| --- | --- | --- |
| Prompt-Knoten | Wenn Sie einen Flow [erstellen](flows-create.md) oder [aktualisieren](flows-modify.md), wählen Sie den Prompt-Knoten aus und geben Sie den Integritätsschutz im Abschnitt Konfigurieren an. | Wenn Sie den Prompt-Knoten im Feld nodes einer [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html)- oder [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html)-Anfrage definieren, fügen Sie ein Feld guardrailConfiguration in die [PromptFlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PromptFlowNodeConfiguration.html) ein. |
| Wissensdatenbank-Knoten | Wenn Sie einen Flow [erstellen](flows-create.md) oder [aktualisieren](flows-modify.md), wählen Sie den Wissensdatenbank-Knoten aus und geben Sie den Integritätsschutz im Abschnitt Konfigurieren an. Sie können einen Integritätsschutz nur einbeziehen, wenn Sie Antworten auf der Grundlage von abgerufenen Ergebnissen generieren. | Wenn Sie den Wissensdatenbank-Knoten im Feld nodes einer [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html)- oder [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html)-Anfrage definieren, fügen Sie ein Feld guardrailConfiguration in die [KnowledgeBaseFlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_KnowledgeBaseFlowNodeConfiguration.html) ein. Sie können einen Integritätsschutz nur einbeziehen, wenn Sie RetrieveAndGenerate verwenden, daher müssen Sie eine modelId angeben. |
Weitere Informationen zum Integritätsschutz finden Sie unter [So erkennen und filtern Sie schädliche Inhalte mithilfe vom Integritätsschutz für Amazon Bedrock](guardrails.md).
Weitere Informationen zu Knotentypen finden Sie unter [Knotentypen für Ihren Flow](flows-nodes.md).
# Testen eines Flows in Amazon Bedrock
Nachdem Sie einen Flow erstellt haben, erhalten Sie einen *Arbeitsentwurf*. Der Arbeitsentwurf ist eine Version des Flows, mit der Sie den Flow iterativ entwickeln und testen können. Jedes Mal, wenn Sie Änderungen an Ihrem Flow vornehmen, wird der Arbeitsentwurf aktualisiert.
Wenn Sie den Flow testen, verifiziert Amazon Bedrock zunächst folgende Punkte und löst eine Ausnahme aus, wenn die Verifizierung fehlschlägt:
+ Konnektivität zwischen allen Flow-Knoten ist gegeben.
+ Mindestens ein Flow-Ausgabeknoten ist konfiguriert.
+ Eingabe- und Ausgabevariablentypen werden nach Bedarf abgeglichen.
+ Bedingungsausdrücke sind gültig und es wird ein Standardergebnis bereitgestellt.
Schlägt die Verifizierung fehl, müssen Sie die Fehler beheben, bevor Sie die Leistung Ihres Flows testen und validieren können. Nachstehend finden Sie die Schritte zum Testen des Flows. Wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und befolgen Sie dann die beschriebenen Schritte:
------
#### [ Console ]
**So testen Sie Ihren Flow**
1. Falls Sie sich noch nicht im **Flow-Builder** befinden, gehen Sie wie folgt vor:
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 **Amazon Bedrock Flows** im linken Navigationsbereich aus. Wählen Sie dann im Abschnitt **Amazon Bedrock Flows** einen Flow aus, den Sie testen möchten.
1. Wählen Sie **Im Flow-Builder bearbeiten** aus.
1. Geben Sie auf der Seite **Flow-Builder** im rechten Bereich eine Eingabe ein, um den Flow aufzurufen. Vergewissern Sie sich, dass der Eingabedatentyp mit dem Ausgabedatentyp, den Sie für den Flow-Eingabeknoten konfiguriert haben, übereinstimmt.
1. Klicken Sie auf **Ausführen**.
1. Knoten oder Verbindungen in der Flow-Konfiguration, die Fehler auslösen, werden rot hervorgehoben, und Knoten oder Verbindungen, die Warnungen auslösen, sind gelb markiert. Lesen Sie die Fehlermeldungen und Warnungen, beheben Sie die identifizierten Probleme, speichern Sie den Flow und führen Sie den Test erneut aus.
**Anmerkung**
Sie müssen den Flow speichern, damit die Änderungen, die Sie vorgenommen haben, beim Testen des Flows übernommen werden.
1. (Optional) Um die Eingaben, Ausgaben und die Ausführungsdauer für jeden Knoten anzuzeigen, wählen Sie in der Antwort die Option **Nachverfolgung anzeigen** aus. Weitere Informationen finden Sie unter [Verfolgen jedes Schritts im Flow durch Anzeigen der zugehörigen Nachverfolgung in Amazon BedrockVerfolgen jedes Schritts im Flow durch Anzeigen der zugehörigen Nachverfolgung](flows-trace.md). Um zum visuellen Builder zurückzukehren, wählen Sie **Nachverfolgung verbergen** oder klicken Sie auf das Symbol zum Ausblenden.
1. Wenn Sie mit der Leistung des Flows zufrieden sind, klicken Sie auf **Speichern und beenden**.
1. Sie können die Erstellung Ihres Flows weiter iterieren. Wenn Sie mit dem Ergebnis zufrieden und bereit sind, den Flow in der Produktionsumgebung bereitzustellen, erstellen Sie eine Version des Flows und einen Alias, der auf die Version verweist. Weitere Informationen finden Sie unter [Bereitstellen eines Flows in Ihrer Anwendung mithilfe von Versionen und Aliasen](flows-deploy.md).
------
#### [ API ]
Um den Flow zu testen, senden Sie eine [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html)-Anfrage mit einem [Laufzeit-Endpunkt von Agenten für Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-rt). Geben Sie den ARN oder die ID des Flows in das Feld `flowIdentifier` und den ARN oder die ID des Alias, der verwendet werden soll, im Feld `flowAliasIdentifier` ein.
Um die Eingaben und Ausgaben für jeden Knoten anzuzeigen, setzen Sie das Feld `enableTrace` auf `TRUE`. Weitere Informationen finden Sie unter [Verfolgen jedes Schritts im Flow durch Anzeigen der zugehörigen Nachverfolgung in Amazon BedrockVerfolgen jedes Schritts im Flow durch Anzeigen der zugehörigen Nachverfolgung](flows-trace.md).
Der Anforderungstext spezifiziert die Eingabe für den Flow und besitzt das folgende Format:
```
{
"inputs": [
{
"content": {
"document": "JSON-formatted string"
},
"nodeName": "string",
"nodeOutputName": "string"
}
],
"enableTrace": TRUE | FALSE
}
```
Geben Sie die Eingabe in das Feld `document` ein und geben Sie einen Namen für die Eingabe im Feld `nodeName` sowie im Feld `nodeOutputName` ein.
Die Antwort wird in einem Stream zurückgegeben. Jedes zurückgegebene Ereignis enthält die Ausgabe von einem Knoten im Feld `document`, den Knoten, der im Feld `nodeName` verarbeitet wurde, und den Knotentyp im Feld `nodeType`. Diese Ereignisse haben das folgende Format:
```
{
"flowOutputEvent": {
"content": {
"document": "JSON-formatted string"
},
"nodeName": "string",
"nodeType": "string"
}
}
```
Wenn der Flow abgeschlossen ist, wird auch ein Feld `flowCompletionEvent` mit dem `completionReason` zurückgegeben. Falls ein Fehler auftritt, wird das entsprechende Fehlerfeld zurückgegeben.
------
# Verfolgen jedes Schritts im Flow durch Anzeigen der zugehörigen Nachverfolgung in Amazon Bedrock
Wenn Sie einen Flow aufrufen, können Sie die *Nachverfolgung* anzeigen, um die Eingaben und Ausgaben von jedem Knoten zu sehen. Mithilfe der Nachverfolgung können Sie den Weg von der Eingabe bis zur Antwort, die letztendlich zurückgegeben wird, verfolgen. Sie können die Nachverfolgung verwenden, um aufgetretene Fehler zu beheben, Schritte zu ermitteln, die zu unerwarteten Ergebnissen oder Leistungsengpässen führen, und Möglichkeiten zur Verbesserung des Flows in Betracht zu ziehen.
Um die Nachverfolgung anzuzeigen, gehen Sie wie folgt vor:
+ Folgen Sie in der Konsole den Schritten auf der Registerkarte **Konsole** unter [Testen eines Flows in Amazon Bedrock](flows-test.md) und wählen Sie in der Antwort vom Flow-Aufruf die Option **Nachverfolgung anzeigen** aus.
+ Setzen Sie in der API das Feld `enableTrace` auf `true` in einer [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html)-Anfrage. Jedes `flowOutputEvent` in der Antwort wird zusammen mit einem `flowTraceEvent` zurückgegeben.
Jedes Nachverfolgungsereignis enthält den Namen des Knotens, der entweder eine Eingabe empfangen oder eine Ausgabe geliefert hat, sowie das Datum und die Uhrzeit der Verarbeitung der Ein- oder Ausgabe. Wählen Sie eine Registerkarte aus, um mehr über einen bestimmten Typ von Nachverfolgungsereignis zu erfahren.
------
#### [ FlowTraceConditionNodeResultEvent ]
Dieser Nachverfolgungstyp identifiziert, welche Bedingungen für einen Bedingungsknoten erfüllt sind, und hilft Ihnen, die Zweige des Flows zu ermitteln, die während des Aufrufs aktiviert wurden. Das folgende JSON-Objekt zeigt, wie ein [FlowTraceEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowTraceEvent.html) für das Ergebnis eines Bedingungsknotens aussieht:
```
{
"trace": {
"conditionNodeOutputTrace": {
"nodeName": "string",
"satisfiedConditions": [
{
"conditionName": "string"
},
...
],
"timestamp": timestamp
}
}
}
```
------
#### [ FlowTraceNodeInputEvent ]
Dieser Nachverfolgungstyp zeigt die Eingabe an, die an einen Knoten gesendet wurde. Wenn sich das Ereignis einem Iteratorknoten nachgelagert, aber einem Kollektorknoten vorgelagert befindet, gibt das Feld `iterationIndex` den Index des Elements in dem Array an, aus dem die Eingabe stammt. Das folgende JSON-Objekt zeigt, wie ein [FlowTraceEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowTraceEvent.html) für die Eingabe in einen Knoten aussieht.
```
{
"trace": {
"nodeInputTrace": {
"fields": [
{
"content": {
"document": JSON object
},
"nodeInputName": "string"
},
...
],
"nodeName": "string",
"timestamp": timestamp,
"iterationIndex": int
}
}
}
```
------
#### [ FlowTraceNodeOutputEvent ]
Dieser Nachverfolgungstyp zeigt die Ausgabe an, die von einem Knoten erzeugt wurde. Wenn sich das Ereignis einem Iteratorknoten nachgelagert, aber einem Kollektorknoten vorgelagert befindet, gibt das Feld `iterationIndex` den Index des Elements in dem Array an, aus dem die Ausgabe stammt. Das folgende JSON-Objekt zeigt, wie ein [FlowTraceEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowTraceEvent.html) für die Ausgabe eines Knotens aussieht.
```
{
"trace": {
"nodeOutputTrace": {
"fields": [
{
"content": {
"document": JSON object
},
"nodeOutputName": "string"
},
...
],
"nodeName": "string",
"timestamp": timestamp,
"iterationIndex": int
}
}
}
```
------
# Mit Flow-Ausführungen Amazon-Bedrock-Flows asynchron ausführen
Mit Flow-Ausführungen können Sie Amazon-Bedrock-Flows asynchron ausführen. Auf diese Weise können Ihre Flows länger ausgeführt werden und Sie haben außerdem die Kontrolle darüber, so dass Ihre Anwendung andere Aufgaben ausführen kann.
Wenn Sie einen Flow mithilfe der Amazon Bedrock-Konsole oder mit dem [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html)Vorgang ausführen, wird der Flow ausgeführt, bis er abgeschlossen ist oder das Timeout nach einer Stunde abläuft (je nachdem, was zuerst eintritt). Wenn Sie eine Flow-Ausführung veranlassen, kann Ihr Flow viel länger laufen: Einzelne Knoten können bis zu fünf Minuten laufen. Ihr gesamter Flow kann bis zu 24 Stunden lang laufen.
**Anmerkung**
Flow-Ausführungen für Amazon Bedrock befinden sich in der Vorversion und unterliegen Änderungen.
## Erforderliche Berechtigungen für Flow-Ausführungen
+ Stellen Sie sicher, dass Ihre Servicerolle für Amazon-Bedrock-Flows über alle erforderlichen Berechtigungen verfügt. Weitere Informationen finden Sie unter [Erstellen einer Servicerolle für Amazon Bedrock Flows in Amazon Bedrock](flows-permissions.md).
+ (Optional) Verschlüsseln Sie Ihre Flow-Ausführungsdaten mit einem vom Kunden verwalteten Schlüssel. AWS KMS Weitere Informationen finden Sie unter [Verschlüsselung von Flow-Ressourcen von Amazon Bedrock](encryption-flows.md).
## Eine Flow-Ausführung erstellen und verwalten
Sie können eine Flow-Ausführung in der Konsole oder mithilfe des [StartFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_StartFlowExecution.html)Vorgangs erstellen.
------
#### [ Console ]
1. Erstellen Sie einen Flow, indem Sie die Anleitungen unter [Einen Flow in Amazon Bedrock erstellen und gestalten](flows-create.md) befolgen.
1. Erstellen Sie einen Alias für den Flow, indem Sie die Anleitungen unter [Einen Alias eines Flows in Amazon Bedrock erstellen](flows-alias-create.md) befolgen.
1. Falls Sie sich noch nicht im **Flow-Builder** befinden, gehen Sie wie folgt vor:
1. Melden Sie sich bei der AWS-Managementkonsole mit einer IAM-Identität an, die berechtigt ist, die Amazon Bedrock-Konsole zu verwenden. Öffnen Sie dann die Amazon Bedrock-Konsole unter [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).
1. Wählen Sie **Amazon Bedrock Flows** im linken Navigationsbereich und anschließend Ihren Flow aus.
1. Wählen Sie die Registerkarte **Ausführungen** und dann **Ausführung erstellen** aus.
1. Geben Sie im Dialogfeld **Ausführung erstellen** Folgendes ein:
1. Geben Sie unter **Name** einen Namen für die Flow-Ausführung ein.
1. Wählen Sie unter **Alias auswählen** den Alias des Flows aus, den Sie verwenden möchten.
1. Geben Sie unter **Prompt-Eingabe** den Prompt ein, mit dem Sie den Flow starten möchten.
1. Wählen Sie **Erstellen** aus, um die Flow-Ausführung zu erstellen und zu starten.
1. Wählen Sie auf der Seite mit den Flow-Details die Registerkarte **Ausführungen** aus und notieren Sie sich den Status der Flow-Ausführung unter **Ausführungsstatus**.
1. (Optional) Wählen Sie eine Ausführung aus, um den Flow zu öffnen und die Zusammenfassung der Ausführung anzuzeigen.
Unter **Ausführungsausgabe** sehen Sie die Ausgabe des Flows.
1. (Optional) Um eine Flow-Ausführung zu stoppen, wählen Sie die Ausführung aus und klicken Sie auf **Stoppen**.
------
#### [ API ]
**Eine Flow-Ausführung starten**
Um eine Flow-Ausführung auszuführen, senden Sie eine [StartFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_StartFlowExecution.html)Anfrage mit einem [Runtime-Endpunkt von Agents for Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-rt). Geben Sie in der Anfrage die Flow-ID und die Flow-Alias-ID des Flows an, den Sie ausführen möchten. Sie können auch Folgendes angeben:
+ **inputs**: Ein Array, das den [Eingabe](flows-nodes.md#flows-nodes-input)-Knoten enthält, von dem aus der Flow ausgeführt werden soll. Sie geben im Feld `content` die Eingabe an, die an den Eingabeknoten des Prompt-Flows gesendet werden soll.
+ **name**: Ein Name für die Flow-Ausführung.
```
{
"inputs": [{
"nodeName": "FlowInputNode",
"nodeOutputName": "document",
"content": {
"document": "Test"
}
}],
"name": "MyExecution"
}
```
Die Antwort ist der Amazon-Ressourcenname (ARN) der Flow-Ausführung. Sie können den `executionArn` verwenden, um den aktuellen Status des Flows abzufragen, z. B. wenn die Flow-Ausführung abgeschlossen ist oder ein Bedingungsknoten seine Bedingungen bewertet.
```
{
"executionArn": "arn:aws:bedrock:us-west-2:111122223333:flow/FLOWID/alias/TSTALIASID/execution/MyExecution"
}
```
**Den Fortschritt einer Flow-Ausführung verfolgen**
Verwenden Sie den [GetFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GetFlowExecution.html)Vorgang, um den aktuellen Status eines Flows abzurufen, den Sie anhand seines Ausführungs-ARN identifizieren. Ein Flow-Status lautet entweder `Running`, `Succeeded`, `Failed`, `TimedOut` oder `Aborted`.
```
{
"endedAt": null,
"errors": null,
"executionArn": "arn:aws:bedrock:us-west-2:111122223333:flow/FLOWID/alias/TSTALIASID/execution/MyExecution",
"flowAliasIdentifier": "TSTALIASID",
"flowIdentifier": "FLOWID",
"flowVersion": "DRAFT",
"startedAt": "2025-03-20T23:32:28.899221162Z",
"status": "Running"
}
```
Fehler (z. B. ein Lambda-Knoten mit Zeitüberschreitung) werden im Array `errors` zurückgegeben, wie im folgenden Beispiel gezeigt:
```
"errors": [{
"nodeName": "LambdaNode1",
"errorType": "ExecutionTimedOut",
"message": "Call to lambda function timed out"
}],
```
**Die Ergebnisse einer Flow-Ausführung abrufen**
Amazon Bedrock schreibt die Ausgaben eines Flows in die [Ausgabe](flows-nodes.md#flows-nodes-output)-Knoten des Flows. Sie können die Ausgaben abrufen, sobald der Flow abgeschlossen ist oder solange der Flow läuft (abhängig von Ihrem Anwendungsfall).
Wenn Sie möchten, dass der Flow zuerst abgeschlossen wird, rufen Sie `GetFlowExecution` auf und stellen Sie sicher, dass der Wert des Felds `status` in der Antwort `Succeeded` lautet.
Rufen Sie auf, um eine Liste der Ausgabeereignisse der Flow-Ausführung abzurufen [ListFlowExecutionEvents](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_ListFlowExecutionEvents.html). Suchen Sie in der Antwort nach `flowOutputEvent`-Objekten in `flowExecutionEvents`. Sie können die Ausgabe eines Flows beispielsweise im Feld `content` abrufen:
```
{
"flowOutputEvent": {
"content": {
"document": "The model response."
},
"nodeName": "FlowOutputNode"
}
}
```
Sie können die Ausgabe von `ListFlowExecutions` auf Eingabe- und Ausgabeknoten beschränken, indem Sie den Abfrageparameter `eventType` auf `Flow` setzen.
**Anzeigen von Ereignissen**
Um Ihnen das Debuggen Ihrer Flow-Ausführung zu erleichtern, können Sie den [ListFlowExecutionEvents](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_ListFlowExecutionEvents.html)Vorgang verwenden, um Ereignisse anzuzeigen, die Knoten während der Ausführung des Flows generieren. Legen Sie den `eventType`-Abfrageparameter auf `Node` fest, um die Eingaben und Ausgaben aller Knoten (einschließlich Zwischenknoten) in der Antwort anzuzeigen, die dem folgenden Beispiel ähnelt:
```
{
"flowExecutionEvents": [{
"nodeOutputEvent": {
"fields": [{
"content": {
"document": "History book"
},
"name": "document"
}],
"nodeName": "FlowInputNode",
"timestamp": "2025-05-05T18:38:56.637867516Z"
}
},
{
"nodeInputEvent": {
"fields": [{
"content": {
"document": "History book"
},
"name": "book"
}],
"nodeName": "Prompt_1",
"timestamp": "2025-05-05T18:38:57.434600163Z"
}
},
{
"nodeOutputEvent": {
"fields": [{
"content": {
"document": "Here's a summary of the history book."
},
"name": "modelCompletion"
}],
"nodeName": "Prompt_1",
"timestamp": "2025-05-05T18:39:06.034157077Z"
}
},
{
"nodeInputEvent": {
"fields": [{
"content": {
"document": "Here's a summary of the history book."
},
"name": "document"
}],
"nodeName": "FlowOutputNode",
"timestamp": "2025-05-05T18:39:06.453128251Z"
}
}
]
}
```
**Einen Snapshot Ihrer Flow-Ausführung erfassen**
Beim Starten einer Flow-Ausführung erstellt Amazon Bedrock automatisch einen Snapshot einer Flow-Definition und von Metadaten. Das ist hilfreich, da ein Flow aktualisiert werden kann, während er asynchron ausgeführt wird. Rufen Sie den [GetExecutionFlowSnapshot](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GetExecutionFlowSnapshot.html)Vorgang auf, um diesen Snapshot abzurufen. Die Antwort enthält die folgenden Felder:
+ **customerEncryptionKeyArn** — Der ARN des AWS KMS Schlüssels, der den Flow verschlüsselt.
+ **definition**: Die [Definition](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowDefinition.html) des Flows.
+ **executionRoleArn**— Der ARN der IAM-Dienstrolle, die von der Flow-Ausführung verwendet wird.
+ **flowAliasIdentifier**— Die Alias-ID des Flows.
+ **flowIdentifier**: Die ID des Flows.
+ **flowVersion**: Die Version des Flows.
```
{
"customerEncryptionKeyArn": null,
"definition": "{flow-definition}",
"executionRoleArn": "arn:aws:iam::111122223333:role/name",
"flowAliasIdentifier": "TSTALIASID",
"flowIdentifier": "FLOWID",
"flowVersion": "DRAFT"
}
```
**Ihre Flow-Ausführungen auflisten**
Sie können eine Liste Ihrer Flow-Ausführungen abrufen, indem Sie die [ListFlowExecutions](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_ListFlowExecutions.html)Operation aufrufen. Die Antwort enthält ein `flowExecutionSummaries` Array mit Informationen zu jeder Ihrer aktuellen Flow-Ausführungen AWS-Region für einen Flow oder Flow-Alias. Jedes Element enthält Informationen wie den Ausführungs-ARN, die Startzeit und den aktuellen Status des Flows.
```
{
"flowExecutionSummaries": [{
"createdAt": "2025-03-11T23:21:02.875598966Z",
"endedAt": null,
"executionArn": "arn:aws:bedrock:us-west-2:111122223333:flow/FLOWID/alias/TSTALIASID/execution/MyExecution",
"flowAliasIdentifier": "TSTALIASID",
"flowIdentifier": "FLOWID",
"flowVersion": "DRAFT",
"status": "Running"
}]
}
```
**Eine laufende Flow-Ausführung stoppen**
Wenn Sie eine laufende Flow-Ausführung beenden müssen, rufen Sie den [StopFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_StopFlowExecution.html)Vorgang auf und übergeben Sie die Flow-ID, die Flow-Alias-ID und die Flow-Ausführungs-ID für die Ausführung, die Sie beenden möchten.
------
## Flow-Ausführungsstatus
Eine Flow-Ausführung kann einen der folgenden Status haben:
+ **Running**: Die Flow-Ausführung ist im Gange.
+ **Succeeded**: Die Flow-Ausführung wurde erfolgreich abgeschlossen.
+ **Failed**: Die Flow-Ausführung ist aufgrund eines Fehlers fehlgeschlagen.
+ **TimedOut**— Die Flow-Ausführung hat die maximale Laufzeit von 24 Stunden überschritten.
+ **Abgebrochen** — Die Flow-Ausführung wurde mithilfe des [StopFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_StopFlowExecution.html)Vorgangs manuell gestoppt.
Flow-Ausführungen, die nicht mehr laufen, werden nach 90 Tagen automatisch gelöscht.
## Best Practices für Flow-Ausführungen
Beachten Sie Folgendes, wenn Sie Flow-Ausführungen verwenden:
+ Rufen Sie den Status Ihrer Flow-Ausführung regelmäßig ab, [GetFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GetFlowExecution.html)bis Ihr Flow einen Terminalstatus erreicht hat (was etwas anderes als`Running`) ist.
+ Wenn Ihre Flow-Ausführung einen Terminalstatus erreicht, verwenden Sie diese [ListFlowExecutionEvents](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_ListFlowExecutionEvents.html)Option, um die Ergebnisse Ihres Flows abzurufen. Sie könnten diese Ergebnisse beispielsweise verwenden, um eine gewisse Logik für Ihren Flow zu schaffen.
+ Erstellen Sie einen Snapshot Ihrer Flow-Ausführung, [GetExecutionFlowSnapshot](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GetExecutionFlowSnapshot.html)um Ihnen beim Debuggen zu helfen, falls bei der Ausführung Probleme auftreten.
# Bereitstellen eines Flows in Ihrer Anwendung mithilfe von Versionen und Aliasen
Wenn Sie zum ersten Mal einen Flow erstellen, werden eine Version des Arbeitsentwurfs (`DRAFT`) und ein Testalias (`TSTALIASID`), der auf die Version des Arbeitsentwurfs verweist, erstellt. Wenn Sie Änderungen an Ihrem Flow vornehmen, gelten die Änderungen für den Arbeitsentwurf, sodass es sich um die neueste Version des Flows handelt. Sie arbeiten solange an Ihrem Arbeitsentwurf, bis Sie mit dem Verhalten des Flows zufrieden sind. Anschließend können Sie den Flow für die Bereitstellung einrichten, indem Sie *Versionen* des Flows erstellen.
Eine *Version* ist ein Snapshot, der die Ressource in dem Zustand erhält, in dem sie zum Erstellungszeitpunkt war. Sie können den Arbeitsentwurf weiterhin ändern und bei Bedarf Versionen Ihres Flows erstellen. Amazon Bedrock erstellt Versionen in numerischer Reihenfolge, die mit 1 beginnt. Versionen sind unveränderlich, da sie als Snapshot des Flows zum Erstellungszeitpunkt dienen. Um einen Flow zu aktualisieren, den Sie in der Produktionsumgebung bereitgestellt haben, müssen Sie eine neue Version aus dem Arbeitsentwurf erstellen und den Alias aufrufen, der auf diese Version verweist.
Um Ihren Flow bereitzustellen, müssen Sie einen *Alias* erstellen, der auf eine Version des Flows verweist. Anschließend richten Sie `InvokeFlow`-Anfragen an diesen Alias. Mithilfe von Aliasen können Sie effizient zwischen verschiedenen Versionen des Flows wechseln, ohne die Version zu verfolgen. Sie können beispielsweise einen Alias so ändern, dass er auf eine frühere Version des Flows verweist, wenn Sie Änderungen schnell rückgängig machen müssen.
In den folgenden Themen wird beschrieben, wie Sie Versionen und Aliase Ihres Flows erstellen.
**Topics**
+ [
# Erstellen einer Flow-Version in Amazon Bedrock
](flows-version-create.md)
+ [
# Anzeigen von Informationen zu Flow-Versionen in Amazon Bedrock
](flows-version-view.md)
+ [
# Löschen einer Flow-Version in Amazon Bedrock
](flows-version-delete.md)
+ [
# Einen Alias eines Flows in Amazon Bedrock erstellen
](flows-alias-create.md)
+ [
# Informationen zu Aliasen von Flows in Amazon Bedrock anzeigen
](flows-alias-view.md)
+ [
# Einen Alias eines Flows in Amazon Bedrock ändern
](flows-alias-modify.md)
+ [
# Einen Alias eines Flows in Amazon Bedrock löschen
](flows-alias-delete.md)
# Erstellen einer Flow-Version in Amazon Bedrock
Wenn Sie mit der Konfiguration Ihres Flows zufrieden sind, erstellen Sie eine unveränderliche Version des Flows, auf die Sie mit einem Alias verweisen können. Wählen Sie die Registerkarte mit Ihrer bevorzugten Methode aus und befolgen Sie dann die Schritte, um zu erfahren, wie Sie eine Version des Flows erstellen:
------
#### [ Console ]
**So erstellen Sie eine Version Ihrer Amazon-Bedrock-Flows**
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 **Amazon Bedrock Flows** im linken Navigationsbereich aus. Wählen Sie dann im Abschnitt **Amazon Bedrock Flows** einen Flow aus.
1. Wählen Sie im Abschnitt **Versionen** die Option **Version veröffentlichen** aus.
1. Nachdem die Version veröffentlicht wurde, erscheint oben ein Erfolgsbanner.
------
#### [ API ]
Um eine Version Ihres Flows zu erstellen, senden Sie eine [CreateFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowVersion.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 den ARN oder die ID des Flows als `flowIdentifier` an.
Die Antwort gibt eine ID und einen ARN für die Version zurück. Versionen werden inkrementell erstellt, beginnend mit 1.
------
# Anzeigen von Informationen zu Flow-Versionen in Amazon Bedrock
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 den Versionen eines Flows anzeigen:
------
#### [ Console ]
**So zeigen Sie Informationen zu einer Flow-Flow-Version an**
1. Öffnen Sie die [AWS-Management-Konsole](https://console.aws.amazon.com/) und melden Sie sich bei Ihrem Konto an. Navigieren Sie zu Amazon Bedrock.
1. Wählen Sie **Flows** im linken Navigationsbereich aus. Wählen Sie dann im Abschnitt **Flows** einen Flow zum Anzeigen aus.
1. Wählen Sie im Abschnitt **Versionen** die Version aus, die Sie sich ansehen möchten.
1. Um sich Details zu den Knoten und Konfigurationen anzusehen, die an die Version des Flows angefügt sind, wählen Sie den Knoten aus und zeigen Sie die Details im Bereich **Flow-Builder** an. Um Änderungen am Flow vorzunehmen, verwenden Sie den Arbeitsentwurf und erstellen Sie eine neue Version.
------
#### [ API ]
Um Informationen zu einer Flow-Version zu erhalten, senden Sie eine [GetFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowVersion.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 den ARN oder die ID des Flows als `flowIdentifier` an. Geben Sie im Feld `flowVersion` die Versionsnummer ein.
Um Informationen für alle Versionen eines Flows aufzulisten, senden Sie eine [ListFlowVersions](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowVersions.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 den ARN oder die ID des Flows als `flowIdentifier` an. Sie können die folgenden optionalen Parameter festlegen:
****
| Feld | Kurzbeschreibung |
| --- | --- |
| maxResults | Hierbei handelt es sich um 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. |
------
# Löschen einer Flow-Version in Amazon Bedrock
Um zu erfahren, wie Sie eine Version eines Flows löschen, wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und befolgen Sie die angegebenen Schritte:
------
#### [ Console ]
**So löschen Sie eine Flow-Version**
1. Öffnen Sie die [AWS-Management-Konsole](https://console.aws.amazon.com/) und melden Sie sich bei Ihrem Konto an. Navigieren Sie zu Amazon Bedrock.
1. Wählen Sie **Flows** im linken Navigationsbereich aus. Wählen Sie dann im Abschnitt **Flows** einen Flow aus.
1. Klicken Sie auf **Löschen**.
1. Es erscheint ein Dialogfenster, das Sie vor den Auswirkungen des Löschvorgangs warnt. Zur Bestätigung, dass Sie die Version löschen möchten, geben Sie **delete** in das Eingabefeld ein und klicken Sie auf **Löschen**.
1. Es wird ein Banner angezeigt, in dem Sie darüber informiert werden, dass die Version gelöscht wird. Wenn der Löschvorgang abgeschlossen ist, wird ein Erfolgsbanner angezeigt.
------
#### [ API ]
Um eine Version eines Flows zu löschen, senden Sie eine [DeleteFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowVersion.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 den ARN oder die ID des Flows im Feld `flowIdentifier` und die zu löschende Version im Feld `flowVersion` an.
------
# Einen Alias eines Flows in Amazon Bedrock erstellen
Um einen Flow aufzurufen, müssen Sie zunächst einen Alias erstellen, der auf eine Version des Flows verweist. Wählen Sie die Registerkarte mit Ihrer bevorzugten Methode aus und führen Sie dann die Schritte aus, um zu erfahren, wie Sie einen Alias erstellen:
------
#### [ Console ]
**So erstellen Sie einen Alias für Ihre Amazon-Bedrock-Flows**
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 **Amazon Bedrock Flows** im linken Navigationsbereich aus. Wählen Sie dann im Abschnitt **Flows** einen Flow aus.
1. Wählen Sie im Abschnitt **Aliase** die Option **Alias erstellen** aus.
1. Geben Sie für den Alias einen eindeutigen Namen und optional eine Beschreibung ein.
1. Wählen Sie eine der folgenden Optionen:
+ Um eine neue Version zu erstellen, wählen Sie **Neue Version erstellen und sie diesem Alias zuordnen** aus.
+ Um eine vorhandene Version zu verwenden, wählen Sie **Vorhandene Version verwenden, um diesen Alias zuzuordnen** aus. Wählen Sie im Dropdown-Menü die Version aus, der Sie den Alias zuordnen möchten.
1. Wählen Sie **Alias erstellen** aus. Oben erscheint ein Erfolgsbanner.
------
#### [ API ]
Um einen Alias zu erstellen, der auf eine Version Ihres Flows verweist, senden Sie eine [CreateFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowAlias.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).
Die folgenden Felder sind erforderlich:
****
| Feld | Grundlegende Beschreibung |
| --- | --- |
| flowIdentifier | Der ARN oder die ID des Flows, für den ein Alias erstellt werden soll. |
| Name | Ein Name für den Alias. |
| routingConfiguration | Geben Sie im Feld flowVersion die Version an, der der Alias zugeordnet werden soll. |
Die folgenden Felder sind optional:
****
| Feld | Anwendungsfall |
| --- | --- |
| description | So geben Sie eine Beschreibung für den Alias an. |
| clientToken | So verhindern Sie eine Vervielfältigung der Anfrage. |
------
Durch die Erstellung eines Alias wird eine Ressource mit einer Kennung und einem Amazon-Ressourcennamen (ARN) erzeugt, die Sie angeben können, wenn Sie einen Flow aus Ihrer Anwendung aufrufen. Informationen zum Aufrufen eines Flows finden Sie unter [Testen eines Flows in Amazon Bedrock](flows-test.md).
# Informationen zu Aliasen von Flows in Amazon Bedrock anzeigen
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 den Aliasen eines Flows anzeigen:
------
#### [ Console ]
**So zeigen Sie die Details eines Alias an**
1. Öffnen Sie die [AWS-Management-Konsole](https://console.aws.amazon.com/) und melden Sie sich bei Ihrem Konto an. Navigieren Sie zu Amazon Bedrock.
1. Wählen Sie **Flows** im linken Navigationsbereich aus. Wählen Sie dann im Abschnitt **Flows** einen Flow aus.
1. Wählen Sie im Abschnitt **Aliase** den anzuzeigenden Alias aus.
1. Sie können den Namen und die Beschreibung des Alias und die dem Alias zugeordneten Tags anzeigen.
------
#### [ API ]
Um Informationen zu einem Alias Ihres Flows zu erhalten, senden Sie eine [GetFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowAlias.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 den ARN oder die ID des Flows als `flowIdentifier` an. Geben Sie im Feld `aliasIdentifier` die ID oder den ARN des Alias an.
Um Informationen für alle Aliase eines Flows aufzulisten, senden Sie eine [ListFlowAliass](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowAliass.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 den ARN oder die ID des Flows als `flowIdentifier` an. Sie können die folgenden optionalen Parameter festlegen:
****
| Feld | Kurzbeschreibung |
| --- | --- |
| maxResults | Hierbei handelt es sich um 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 Anfrage, um den nächsten Ergebnisstapel zu sehen. |
------
# Einen Alias eines Flows in Amazon Bedrock ändern
Wählen Sie die Registerkarte mit Ihrer bevorzugten Methode aus und führen Sie dann die Schritte aus, um zu erfahren, wie Sie den Alias eines Flows ändern:
------
#### [ Console ]
**So ändern Sie einen Alias**
1. Öffnen Sie die [AWS-Management-Konsole](https://console.aws.amazon.com/) und melden Sie sich bei Ihrem Konto an. Navigieren Sie zu Amazon Bedrock.
1. Wählen Sie **Flows** im linken Navigationsbereich aus. Wählen Sie dann im Abschnitt **Flows** einen Flow aus.
1. Wählen Sie im Abschnitt **Aliase** das Optionsfeld neben dem Alias aus, den Sie bearbeiten möchten.
1. Sie können den Namen und die Beschreibung des Aliases bearbeiten. Darüber hinaus können Sie eine der folgenden Aktionen ausführen:
+ Um eine neue Version zu erstellen und ihr diesen Alias zuzuordnen, wählen Sie **Neue Version erstellen und sie diesem Alias zuordnen** aus.
+ Um diesen Alias einer anderen bestehenden Version zuzuordnen, wählen Sie **Bestehende Version verwenden und ihr diesen Alias zuordnen** aus.
1. Wählen Sie **Speichern**.
------
#### [ API ]
Wenn Sie einen Alias aktualisieren möchten, senden Sie eine [UpdateFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlowAlias.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). Schließen Sie in die Anfrage sowohl Felder ein, die Sie beibehalten möchten, als auch Felder, die geändert werden sollen.
------
# Einen Alias eines Flows in Amazon Bedrock löschen
Wählen Sie die Registerkarte mit Ihrer bevorzugten Methode aus und führen Sie dann die Schritte aus, um zu erfahren, wie Sie den Alias eines Flows löschen:
------
#### [ Console ]
**Löschen eines Alias**
1. Öffnen Sie die [AWS-Management-Konsole](https://console.aws.amazon.com/) und melden Sie sich bei Ihrem Konto an. Navigieren Sie zu Amazon Bedrock.
1. Wählen Sie **Flows** im linken Navigationsbereich aus. Wählen Sie dann im Abschnitt **Flows** einen Flow aus.
1. Zum Auswählen des zu löschenden Alias markieren Sie im Abschnitt **Aliase** das Optionsfeld neben dem Alias, den Sie löschen möchten.
1. Wählen Sie **Löschen** aus.
1. Es erscheint ein Dialogfenster, das Sie vor den Auswirkungen des Löschvorgangs warnt. Zum Bestätigen, dass Sie den Alias löschen möchten, geben Sie **delete** in das Eingabefeld ein und wählen Sie **Löschen** aus.
1. Es wird ein Banner angezeigt, in dem Sie darüber informiert werden, dass der Alias gelöscht wird. Wenn der Löschvorgang abgeschlossen ist, wird ein Erfolgsbanner angezeigt.
------
#### [ API ]
Um einen Flow-Alias zu löschen, senden Sie eine [DeleteFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowAlias.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 den ARN oder die ID des Flows in das Feld `flowIdentifier` und den ARN oder die ID des Alias, der gelöscht werden soll, im Feld `aliasIdentifier` ein.
------
# Rufen Sie eine AWS Lambda Funktion aus einem Amazon Bedrock-Flow in einem anderen Konto auf AWS
Ein Amazon Bedrock-Flow kann eine AWS Lambda Funktion aufrufen, die sich in einem anderen AWS Konto als der Flow befindet. Gehen Sie wie folgt vor, um die Lambda-Funktion (*Konto A*) und den Flow (*Konto B*) zu konfigurieren.
**Um einen Flow-Flow so zu konfigurieren, dass er eine Lambda-Funktion in einem anderen AWS Konto aufruft**
1. Fügen Sie in Konto A (Lambda-Funktion) eine ressourcenbasierte Richtlinie zur Lambda-Funktion hinzu und verwenden Sie dabei die Flow-Ausführungsrolle von Konto B als Prinzipal. Weitere Informationen finden Sie unter [Lambda-Funktion den Zugriff auf andere Konten gewähren](https://docs.aws.amazon.com/lambda/latest/dg/permissions-function-cross-account.html) in der Dokumentation zu *AWS Lambda*.
1. Fügen Sie in Konto B (Amazon-Bedrock-Flow) der Flow-Ausführungsrolle für den Lambda-Funktion-ARN, den Sie verwenden, die Berechtigung zum [Aufrufen](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html) hinzu. Weitere Informationen finden Sie unter [Aktualisieren von Berechtigungen für eine Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_update-role-permissions.html) in der Dokumentation zu *AWS Identity and Access Management*.
# Konversation mit einem Amazon-Bedrock-Flow
**Anmerkung**
Multi-Turn-Konversation in Amazon Bedrock Flows ist als Vorversion für Amazon Bedrock verfügbar und unterliegt Änderungen.
Amazon Bedrock Flows Multi-Turn-Konversation ermöglicht dynamische back-and-forth Konversationen zwischen Benutzern und Flows, ähnlich einem natürlichen Dialog. Wenn ein Agenten-Knoten Erläuterungen oder zusätzlichen Kontext benötigt, kann er die Ausführung des Flows intelligent unterbrechen und den Benutzer zur Eingabe bestimmter Informationen auffordern. Dies sorgt für ein interaktiveres und kontextsensitiveres Erlebnis, da der Knoten sein Verhalten an die Benutzerantworten anpassen kann. Wenn beispielsweise eine ursprüngliche Benutzerabfrage mehrdeutig oder unvollständig ist, kann der Knoten nachfragen, um die erforderlichen Details zu erhalten. Sobald der Benutzer die angeforderten Informationen eingegeben hat, setzt der Flow die Ausführung mit der angereicherten Eingabe nahtlos fort, sodass genauere und relevantere Ergebnisse gewährleistet sind. Diese Funktion ist besonders nützlich für komplexe Szenarien, in denen eine einzige Interaktion möglicherweise nicht ausreicht, um die Anforderungen des Benutzers vollständig zu verstehen und zu erfüllen.
**Topics**
+ [
## So verarbeiten Sie eine Multi-Turn-Konversation in einem Flow
](#flows-multi-turn-invocation-how)
+ [
## Erstellen und Ausführen eines Beispiel-Flows
](#flows-multi-turn-invocation-example-flow)
## So verarbeiten Sie eine Multi-Turn-Konversation in einem Flow
Um eine Multi-Turn-Konversation in einem Flow zu verwenden, benötigen Sie einen [Agenten-Knoten](flows-nodes.md#flows-nodes-agent), der mit einem Amazon-Bedrock-Agenten verbunden ist. Wenn Sie den Flow ausführen, findet eine Multi-Turn-Konversation statt, wenn der Agent weitere Informationen vom Benutzer benötigt, bevor er fortfahren kann. In diesem Abschnitt wird ein Flow beschrieben, der einen Agenten mit den folgenden Anweisungen verwendet:
```
You are a playlist creator for a radio station.
When asked to create a playlist, ask for the number of songs,
the genre of music, and a theme for the playlist.
```
Weitere Informationen zum Erstellen eines Agenten finden Sie unter [Automatisieren von Aufgaben in einer Anwendung mithilfe von KI-Agenten](agents.md).
### Schritt 1: Starten des Flows
Sie starten einen Flow, indem Sie den [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html)Vorgang aufrufen. Sie fügen den ursprünglichen Inhalt hinzu, den Sie an den Flow senden möchten. Im folgenden Beispiel enthält das Feld `document` die Anforderung *Create a playlist* zum Erstellen einer Playlist. Jede Konversation besitzt eine eindeutige Kennung (*Ausführungs-ID*), die die Konversation innerhalb des Flows identifiziert. Um die Ausführungs-ID zu erhalten, senden Sie das Feld `executionID` bei Ihrem ersten Aufruf nicht an `InvokeFlow`. Die Antwort von `InvokeFlow` enthält die Ausführungs-ID. Verwenden Sie in Ihrem Code die Kennung, um mehrere Konversationen nachzuverfolgen und eine Konversation in weiteren Aufrufen der Operation `InvokeFlow` zu identifizieren.
Nachstehend finden Sie ein JSON-Beispiel für die Anforderung `InvokeFlow`.
```
{
"flowIdentifier": "XXXXXXXXXX",
"flowAliasIdentifier": "YYYYYYYYYY",
"inputs": [
{
"content": {
"document": "Create a playlist."
},
"nodeName": "FlowInputNode",
"nodeOutputName": "document"
}
]
}
```
### Schritt 2: Abrufen von Agenten-Anfragen
Wenn der Agenten-Knoten im Flow entscheidet, dass er weitere Informationen vom Benutzer benötigt, enthält der Antwortstream (`responseStream`) von `InvokeFlow` ein `FlowMultiTurnInputRequestEvent`-Ereignisobjekt. Das Ereignis enthält die angeforderten Informationen im Feld `content` (`FlowMultiTurnInputContent`). Im folgenden Beispiel bezieht sich die Anforderung im Feld `document` auf Informationen über die Anzahl der Songs, das Musikgenre und das Thema für die Playlist. In Ihrem Code müssen Sie diese Informationen dann vom Benutzer abrufen.
Nachfolgend finden Sie ein Beispiel für ein `FlowMultiTurnInputRequestEvent`-JSON-Objekt.
```
{
"nodeName": "AgentsNode_1",
"nodeType": "AgentNode",
"content": {
"document": "Certainly! I'd be happy to create a playlist for you. To make sure it's tailored to your preferences, could you please provide me with the following information:
1. How many songs would you like in the playlist?
2. What genre of music do you prefer?
3. Is there a specific theme or mood you'd like for the playlist? Once you provide these details, I'll be able to create a customized playlist just for you."
}
}
```
Da der Flow erst fortgesetzt werden kann, wenn weitere Eingaben empfangen wurden, gibt der Flow auch ein `FlowCompletionEvent`-Ereignis aus. Ein Flow gibt immer das `FlowMultiTurnInputRequestEvent` vor dem `FlowCompletionEvent` aus. Wenn der Wert von `completionReason` im `FlowCompletionEvent`-Ereignis `INPUT_REQUIRED` ist, benötigt der Flow weitere Informationen, bevor er fortgesetzt werden kann.
Nachfolgend finden Sie ein Beispiel für ein `FlowCompletionEvent`-JSON-Objekt.
```
{
"completionReason": "INPUT_REQUIRED"
}
```
### Schritt 3: Senden der Benutzerantwort an den Flow
Senden Sie die Benutzerantwort zurück an den Flow, indem Sie die Operation `InvokeFlow` erneut aufrufen. Es ist wichtig, dass Sie die `executionId` für die Konversation angeben.
Im Folgenden sehen Sie ein JSON-Beispiel für die Anforderung `InvokeFlow`. Das Feld `document` enthält die Antwort vom Benutzer.
```
{
"flowIdentifier": "AUS7BMHXBE",
"flowAliasIdentifier": "4KUDB8VBEF",
"executionId": "b6450554-f8cc-4934-bf46-f66ed89b60a0",
"inputs": [
{
"content": {
"document": "1. 5 songs 2. Welsh rock music 3. Castles"
},
"nodeName": "AgentsNode_1",
"nodeInputName": "agentInputText"
}
]
}
```
Wenn der Flow noch mehr Informationen benötigt, erzeugt er weitere `FlowMultiTurnInputRequestEvent`-Ereignisse.
### Schritt 4: Beenden des Flows
Wenn keine weiteren Informationen benötigt werden, gibt der Flow ein `FlowOutputEvent`-Ereignis aus, das die endgültige Antwort enthält.
Nachfolgend finden Sie ein Beispiel für ein `FlowOutputEvent`-JSON-Objekt.
```
{
"nodeName": "FlowOutputNode",
"content": {
"document": "Great news! I've created a 5-song Welsh rock playlist centered around the theme of castles.
Here's the playlist I've put together for you: Playlist Name: Welsh Rock Castle Anthems
Description: A 5-song Welsh rock playlist featuring songs about castles
Songs:
1. Castell y Bere - Super Furry Animals
2. The Castle - Manic Street Preachers
3. Caerdydd (Cardiff Castle) - Stereophonics
4. Castell Coch - Catatonia
5. Chepstow Castle - Feeder
This playlist combines Welsh rock bands with songs that reference castles or specific Welsh castles.
Enjoy your castle-themed Welsh rock music experience!"
}
}
```
Der Flow gibt auch ein `FlowCompletionEvent`-Ereignis aus. Der Wert von `completionReason` ist `SUCCESS`.
Nachfolgend finden Sie ein Beispiel für ein `FlowCompletionEvent`-JSON-Objekt.
```
{
"completionReason": "SUCCESS"
}
```
Das folgende Ablaufdiagramm zeigt die Schritte in einem Multi-Turn-Flow.
![\[Flow-Schritte für eine Multi-Turn-Konversation\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/flows/flows-multi-turn-steps.png)
## Erstellen und Ausführen eines Beispiel-Flows
In diesem Beispiel erstellen Sie einen Flow, der mithilfe eines Agenten Playlisten für einen Radiosender erstellt. Der Agent stellt klärende Fragen, um die Anzahl der Songs, das Musikgenre und das Thema für die Playlist zu ermitteln.
**So erstellen Sie den Flow**
1. Erstellen Sie einen Agenten in der Amazon-Bedrock-Konsole, indem Sie die Anleitungen unter [Manuelles Erstellen und Konfigurieren von Agenten](agents-create.md) befolgen.
+ Geben Sie für Schritt *2.d* **You are a playlist creator for a radio station. When asked to create a playlist, ask for the number of songs, the genre of music, and a theme for the playlist.** ein.
+ Wählen Sie für Schritt *2.e* unter **Benutzereingabe** die Option **Aktiviert** aus. Auf diese Weise kann der Agent bei Bedarf weitere Informationen anfordern.
1. Erstellen Sie den Flow, indem Sie die Anleitungen unter [Einen Flow in Amazon Bedrock erstellen und gestalten](flows-create.md) befolgen. Der Flow muss über einen Eingabeknoten, einen Agenten-Knoten und einen Ausgabeknoten verfügen.
1. Verknüpfen Sie den Agenten-Knoten mit dem Agenten, den Sie in Schritt 1 erstellt haben. Der Flow sollte wie in der Abbildung unten aussehen.
![\[Multi-Turn-Konversation eines Flows\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/flows/flows-multi-turn.png)
1. Führen Sie den Flow in der Amazon-Bedrock-Konsole aus. Zum Testen können Sie die Schritte verfolgen, die der Flow ausführt. Weitere Informationen finden Sie unter [Testen eines Flows in Amazon Bedrock](flows-test.md).
Das folgende Python-Codebeispiel zeigt, wie der Flow verwendet wird.
Um den Code auszuführen, geben Sie Folgendes an:
+ `region_name`— Die AWS Region, in der Sie den Flow ausführen.
+ `FLOW_ID` – Die ID des Flows
+ `FLOW_ALIAS_ID` – Die Alias-ID des Flows
Informationen zum Abrufen von finden Sie unter[Anzeigen von Informationen zu Flows in Amazon Bedrock](flows-view.md). IDs Der Code fordert zum Senden einer ersten Anforderung an den Flow auf und fordert je nach Bedarf weitere Eingaben an. Der Code verwaltet keine anderen Anfragen des Agenten, z. B. Anfragen zum Aufrufen von AWS Lambda Funktionen. Weitere Informationen finden Sie unter [Funktionsweise von Agenten für Amazon Bedrock](agents-how.md). Während der Ausführung generiert der Code `FlowTraceEvent`-Objekte, mit denen Sie den Pfad von der Eingabe bis zur Antwort, die der Flow zurückgibt, verfolgen können. Weitere Informationen finden Sie unter [Verfolgen jedes Schritts im Flow durch Anzeigen der zugehörigen Nachverfolgung in Amazon BedrockVerfolgen jedes Schritts im Flow durch Anzeigen der zugehörigen Nachverfolgung](flows-trace.md).
```
"""
Runs an Amazon Bedrock flow and handles muli-turn interaction for a single conversation.
"""
import logging
import boto3
import botocore
import botocore.exceptions
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def invoke_flow(client, flow_id, flow_alias_id, input_data, execution_id):
"""
Invoke an Amazon Bedrock flow and handle the response stream.
Args:
client: Boto3 client for Amazon Bedrock agent runtime
flow_id: The ID of the flow to invoke
flow_alias_id: The alias ID of the flow
input_data: Input data for the flow
execution_id: Execution ID for continuing a flow. Use the value None on first run.
Returns:
Dict containing flow_complete status, input_required info, and execution_id
"""
response = None
request_params = None
if execution_id is None:
# Don't pass execution ID for first run.
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"inputs": [input_data],
"enableTrace": True
}
else:
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"executionId": execution_id,
"inputs": [input_data],
"enableTrace": True
}
response = client.invoke_flow(**request_params)
if "executionId" not in request_params:
execution_id = response['executionId']
input_required = None
flow_status = ""
# Process the streaming response
for event in response['responseStream']:
# Check if flow is complete.
if 'flowCompletionEvent' in event:
flow_status = event['flowCompletionEvent']['completionReason']
# Check if more input us needed from user.
elif 'flowMultiTurnInputRequestEvent' in event:
input_required = event
# Print the model output.
elif 'flowOutputEvent' in event:
print(event['flowOutputEvent']['content']['document'])
elif 'flowTraceEvent' in event:
logger.info("Flow trace: %s", event['flowTraceEvent'])
return {
"flow_status": flow_status,
"input_required": input_required,
"execution_id": execution_id
}
if __name__ == "__main__":
session = boto3.Session(profile_name='default', region_name='YOUR_FLOW_REGION')
bedrock_agent_client = session.client('bedrock-agent-runtime')
# Replace these with your actual flow ID and alias ID
FLOW_ID = 'YOUR_FLOW_ID'
FLOW_ALIAS_ID = 'YOUR_FLOW_ALIAS_ID'
flow_execution_id = None
finished = False
# Get the intial prompt from the user.
user_input = input("Enter input: ")
flow_input_data = {
"content": {
"document": user_input
},
"nodeName": "FlowInputNode",
"nodeOutputName": "document"
}
logger.info("Starting flow %s", FLOW_ID)
try:
while not finished:
# Invoke the flow until successfully finished.
result = invoke_flow(
bedrock_agent_client, FLOW_ID, FLOW_ALIAS_ID, flow_input_data, flow_execution_id)
status = result['flow_status']
flow_execution_id = result['execution_id']
more_input = result['input_required']
if status == "INPUT_REQUIRED":
# The flow needs more information from the user.
logger.info("The flow %s requires more input", FLOW_ID)
user_input = input(
more_input['flowMultiTurnInputRequestEvent']['content']['document'] + ": ")
flow_input_data = {
"content": {
"document": user_input
},
"nodeName": more_input['flowMultiTurnInputRequestEvent']['nodeName'],
"nodeInputName": "agentInputText"
}
elif status == "SUCCESS":
# The flow completed successfully.
finished = True
logger.info("The flow %s successfully completed.", FLOW_ID)
except botocore.exceptions.ClientError as e:
print(f"Client error: {str(e)}")
logger.error("Client error: %s", {str(e)})
except Exception as e:
print(f"An error occurred: {str(e)}")
logger.error("An error occurred: %s", {str(e)})
logger.error("Error type: %s", {type(e)})
```
# Codebeispiele von Amazon Bedrock Flows ausführen
Bei den folgenden Codebeispielen wird davon ausgegangen, dass Sie die folgenden Voraussetzungen erfüllt haben:
1. Eine Rolle einrichten, um Berechtigungen für Amazon-Bedrock-Aktionen zu erhalten. Falls noch nicht geschehen, finden Sie weitere Informationen unter [Quickstart](getting-started.md).
1. Ihre Anmeldeinformationen für die Verwendung der AWS-API einrichten. Falls noch nicht geschehen, finden Sie weitere Informationen unter [Erste Schritte mit der API](getting-started-api.md).
1. Eine Servicerolle erstellen, um Flow-bezogene Aktionen in Ihrem Namen ausführen zu lassen. Falls noch nicht geschehen, finden Sie weitere Informationen unter [Erstellen einer Servicerolle für Amazon Bedrock Flows in Amazon Bedrock](flows-permissions.md).
Um einen Flow zu erstellen, senden Sie eine [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.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). Beispielcode finden Sie unter [Codebeispiele von Amazon Bedrock Flows ausführen](#flows-code-ex)
Die folgenden Felder sind erforderlich:
****
| Feld | Grundlegende Beschreibung |
| --- | --- |
| Name | Ein Name für den Flow. |
| executionRoleArn | Der ARN der [Servicerolle mit Berechtigungen zum Erstellen und Verwalten von Flows](flows-permissions.md). |
Die folgenden Felder sind optional:
****
| Feld | Anwendungsfall |
| --- | --- |
| definition | Enthält die nodes und connections, aus denen der Flow besteht. |
| description | Dient zur Beschreibung des Flows. |
| tags | Hiermit ordnen Sie dem Flow Tags zu. Weitere Informationen finden Sie unter [Markieren von Amazon-Bedrock-Ressourcen](tagging.md). |
| customerEncryptionKeyArn | Dient zur Verschlüsselung der Ressource mit einem KMS-Schlüssel. Weitere Informationen finden Sie unter [Verschlüsselung von Flow-Ressourcen von Amazon Bedrock](encryption-flows.md). |
| clientToken | Zur Sicherstellung, dass die API-Anfrage nur einmal abgeschlossen wird. Weitere Informationen finden Sie unter [Sicherstellen von Idempotenz](https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-idempotency.html). |
Das Feld `definition` ist zwar optional, aber es ist erforderlich, damit der Flow funktioniert. Sie können sich dafür entscheiden, zuerst einen Flow ohne die Definition zu erstellen und den Flow später zu aktualisieren.
Für jeden Knoten in Ihrer `nodes`-Liste geben Sie den Knotentyp im Feld `type` an und legen seine entsprechende Konfiguration im Feld `config` fest. Einzelheiten zur API-Struktur verschiedener Knotentypen finden Sie unter [Knotentypen für Ihren Flow](flows-nodes.md).
Um einige Codebeispiele für Amazon Bedrock Flows auszuprobieren, wählen Sie die Registerkarte mit Ihrer bevorzugten Methode aus und folgen Sie dann den nachstehenden Schritten:
------
#### [ Python ]
1. Erstellen Sie einen Flow mithilfe einer [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html)-Anfrage mit einem [Build-Time-Endpunkt für Agenten für Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) mit den folgenden Knoten:
+ Ein Eingabeknoten.
+ Ein Prompt-Knoten mit definiertem Inline-Prompt, der eine Musik-Playlist mit zwei Variablen (`genre` und `number`) erstellt.
+ Ein Ausgabeknoten, der die Fertigstellung des Modells zurückgibt.
Führen Sie den folgenden Codeausschnitt aus, um den AWS SDK für Python (Boto3) zu laden, einen Agenten-Client von Amazon Bedrock zu erstellen und einen Flow mit den Knoten zu erstellen (ersetzen Sie das Feld `executionRoleArn` durch den ARN Ihrer Servicerolle, die Sie für den Flow erstellt haben):
```
# Import Python SDK and create client
import boto3
client = boto3.client(service_name='bedrock-agent')
# Replace with the service role that you created. For more information, see https://docs.aws.amazon.com/bedrock/latest/userguide/flows-permissions.html
FLOWS_SERVICE_ROLE = "arn:aws:iam::123456789012:role/MyFlowsRole"
# Define each node
# The input node validates that the content of the InvokeFlow request is a JSON object.
input_node = {
"type": "Input",
"name": "FlowInput",
"outputs": [
{
"name": "document",
"type": "Object"
}
]
}
# This prompt node defines an inline prompt that creates a music playlist using two variables.
# 1. {{genre}} - The genre of music to create a playlist for
# 2. {{number}} - The number of songs to include in the playlist
# It validates that the input is a JSON object that minimally contains the fields "genre" and "number", which it will map to the prompt variables.
# The output must be named "modelCompletion" and be of the type "String".
prompt_node = {
"type": "Prompt",
"name": "MakePlaylist",
"configuration": {
"prompt": {
"sourceConfiguration": {
"inline": {
"modelId": "amazon.nova-lite-v1:0",
"templateType": "TEXT",
"inferenceConfiguration": {
"text": {
"temperature": 0.8
}
},
"templateConfiguration": {
"text": {
"text": "Make me a {{genre}} playlist consisting of the following number of songs: {{number}}."
}
}
}
}
}
},
"inputs": [
{
"name": "genre",
"type": "String",
"expression": "$.data.genre"
},
{
"name": "number",
"type": "Number",
"expression": "$.data.number"
}
],
"outputs": [
{
"name": "modelCompletion",
"type": "String"
}
]
}
# The output node validates that the output from the last node is a string and returns it as is. The name must be "document".
output_node = {
"type": "Output",
"name": "FlowOutput",
"inputs": [
{
"name": "document",
"type": "String",
"expression": "$.data"
}
]
}
# Create connections between the nodes
connections = []
# First, create connections between the output of the flow input node and each input of the prompt node
for input in prompt_node["inputs"]:
connections.append(
{
"name": "_".join([input_node["name"], prompt_node["name"], input["name"]]),
"source": input_node["name"],
"target": prompt_node["name"],
"type": "Data",
"configuration": {
"data": {
"sourceOutput": input_node["outputs"][0]["name"],
"targetInput": input["name"]
}
}
}
)
# Then, create a connection between the output of the prompt node and the input of the flow output node
connections.append(
{
"name": "_".join([prompt_node["name"], output_node["name"]]),
"source": prompt_node["name"],
"target": output_node["name"],
"type": "Data",
"configuration": {
"data": {
"sourceOutput": prompt_node["outputs"][0]["name"],
"targetInput": output_node["inputs"][0]["name"]
}
}
}
)
# Create the flow from the nodes and connections
response = client.create_flow(
name="FlowCreatePlaylist",
description="A flow that creates a playlist given a genre and number of songs to include in the playlist.",
executionRoleArn=FLOWS_SERVICE_ROLE,
definition={
"nodes": [input_node, prompt_node, output_node],
"connections": connections
}
)
flow_id = response.get("id")
```
1. Listen Sie die Flows in Ihrem Konto auf, einschließlich des gerade erstellten, indem Sie den folgenden Codeausschnitt ausführen, um eine [ListFlows](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlows.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) zu stellen:
```
client.list_flows()
```
1. Rufen Sie Informationen über den Flow ab, den Sie gerade erstellt haben, indem Sie den folgenden Codeausschnitt ausführen, um eine [GetFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlow.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) zu stellen:
```
client.get_flow(flowIdentifier=flow_id)
```
1. Bereiten Sie Ihren Flow so vor, dass die neuesten Änderungen aus dem Arbeitsentwurf übernommen werden und er bereit für die Version ist. Führen Sie den folgenden Codeausschnitt aus, um eine [PrepareFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PrepareFlow.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) zu stellen:
```
client.prepare_flow(flowIdentifier=flow_id)
```
1. Versionieren Sie den Arbeitsentwurf Ihres Flows, um einen statischen Snapshot Ihres Flows zu erstellen, und rufen Sie dann mit den folgenden Aktionen Informationen darüber ab:
1. Erstellen Sie eine Version, indem Sie den folgenden Codeausschnitt ausführen, um eine [CreateFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowVersion.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) zu stellen:
```
response = client.create_flow_version(flowIdentifier=flow_id)
flow_version = response.get("version")
```
1. Listen Sie alle Versionen Ihres Flows auf, indem Sie den folgenden Codeausschnitt ausführen, um eine [ListFlowVersions](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowVersions.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) zu stellen:
```
client.list_flow_versions(flowIdentifier=flow_id)
```
1. Rufen Sie Informationen über die Version ab, indem Sie den folgenden Codeausschnitt ausführen, um eine [GetFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowVersion.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) zu stellen:
```
client.get_flow_version(flowIdentifier=flow_id, flowVersion=flow_version)
```
1. Erstellen Sie einen Alias, der auf die Version Ihres Flows verweist, die Sie erstellt haben, und rufen Sie dann mit den folgenden Aktionen Informationen darüber ab:
1. Erstellen Sie einen Alias, der auf die Version verweist, die Sie gerade erstellt haben, indem Sie den folgenden Codeausschnitt ausführen, um eine [CreateFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowAlias.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) zu stellen:
```
response = client.create_flow_alias(
flowIdentifier=flow_id,
name="latest",
description="Alias pointing to the latest version of the flow.",
routingConfiguration=[
{
"flowVersion": flow_version
}
]
)
flow_alias_id = response.get("id")
```
1. Listen Sie alle Aliase Ihres Flows auf, indem Sie den folgenden Codeausschnitt ausführen, um eine [ListFlowAliass](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowAliass.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) zu stellen:
```
client.list_flow_aliases(flowIdentifier=flow_id)
```
1. Rufen Sie Informationen über den Alias ab, den Sie gerade erstellt haben, indem Sie den folgenden Codeausschnitt ausführen, um eine [GetFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowAlias.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) zu stellen:
```
client.get_flow_alias(flowIdentifier=flow_id, aliasIdentifier=flow_alias_id)
```
1. Führen Sie den folgenden Codeausschnitt aus, um einen Laufzeit-Client der Agenten für Amazon Bedrock zu erstellen und einen Flow aufzurufen. Die Anfrage füllt die Variablen im Prompt Ihres Flows aus und gibt die Antwort des Modells zurück, um eine [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html)-Anfrage mit einem Runtime-Endpunkt von [Agenten für Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-rt) zu stellen:
```
client_runtime = boto3.client('bedrock-agent-runtime')
response = client_runtime.invoke_flow(
flowIdentifier=flow_id,
flowAliasIdentifier=flow_alias_id,
inputs=[
{
"content": {
"document": {
"genre": "pop",
"number": 3
}
},
"nodeName": "FlowInput",
"nodeOutputName": "document"
}
]
)
result = {}
for event in response.get("responseStream"):
result.update(event)
if result['flowCompletionEvent']['completionReason'] == 'SUCCESS':
print("Flow invocation was successful! The output of the flow is as follows:\n")
print(result['flowOutputEvent']['content']['document'])
else:
print("The flow invocation completed because of the following reason:", result['flowCompletionEvent']['completionReason'])
```
Die Antwort sollte eine Popmusik-Playlist mit drei Songs zurückgeben.
1. Löschen Sie mit den folgenden Aktionen den Alias, die Version und den Flow, die Sie erstellt haben:
1. Löschen Sie den Alias, indem Sie den folgenden Codeausschnitt ausführen, um eine [DeleteFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowAlias.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) zu stellen:
```
client.delete_flow_alias(flowIdentifier=flow_id, aliasIdentifier=flow_alias_id)
```
1. Löschen Sie die Version, indem Sie den folgenden Codeausschnitt ausführen, um eine [DeleteFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowVersion.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) zu stellen:
```
client.delete_flow_version(flowIdentifier=flow_id, flowVersion=flow_version)
```
1. Löschen Sie den Flow, indem Sie den folgenden Codeausschnitt ausführen, um eine [DeleteFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlow.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) zu stellen:
```
client.delete_flow(flowIdentifier=flow_id)
```
------
# Einen Flow in Amazon Bedrock löschen
Wenn Sie einen Flow nicht mehr benötigen, können Sie ihn löschen. Flows, die Sie löschen, werden bis zu vierzehn Tage auf den AWS-Servern aufbewahrt. Wählen Sie die Registerkarte mit Ihrer bevorzugten Methode aus und führen Sie dann die Schritte aus, um zu erfahren, wie Sie einen Flow löschen:
------
#### [ Console ]
**So löschen Sie einen Flow**
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 **Amazon Bedrock Flows** im linken Navigationsbereich aus. Wählen Sie dann im Abschnitt **Amazon Bedrock Flows** einen Flow aus, den Sie löschen möchten.
1. Wählen Sie **Löschen** aus.
1. Es erscheint ein Dialogfenster, das Sie vor den Auswirkungen des Löschvorgangs warnt. Zum Bestätigen, dass Sie den Flow löschen möchten, geben Sie **delete** in das Eingabefeld ein und wählen Sie **Löschen** aus.
1. Es wird ein Banner angezeigt, in dem Sie darüber informiert werden, dass der Flow gelöscht wird. Wenn der Löschvorgang abgeschlossen ist, wird ein Erfolgsbanner angezeigt.
------
#### [ API ]
Um einen Flow zu löschen, senden Sie eine [DeleteFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlow.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 den ARN oder die ID des Flows als `flowIdentifier` an.
------