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. # 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)