Knotentypen für Ihren Flow - Amazon Bedrock
Knoten zur Steuerung der Flow-LogikKnoten für die Verarbeitung von Daten im FlowÜbersichtstabellen für Knotentypen

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.

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 Feld type und die entsprechende FlowNodeConfiguration im Feld configuration.

  • Eingaben – Geben Sie für jede Eingabe die folgenden Informationen an:

  • 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.

    • 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 die entsprechende FlowNodeConfiguration 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.

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.

Nachstehend ist die allgemeine Struktur eines FlowNode-Objekts für Eingaben in der API dargestellt:

{
    "name": "string",
    "type": "Input",
    "outputs": [
        {
            "name": "document",
            "type": "String | Number | Boolean | Object | Array",
        }
    ],
    "configuration": {
        "input": CONTEXT-DEPENDENT
    }
}

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.

Nachstehend ist die allgemeine Struktur eines FlowNode-Objekts für Ausgaben dargestellt:

{
    "name": "string",
    "type": "Output",
    "inputs": [
        {
            "name": "document",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        }
    ],
    "configuration": {
        "output": CONTEXT-DEPENDENT
    }
}

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.

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.

  2. 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.

  3. Verbinden Sie jede Eingabe mit der entsprechenden Ausgabe eines Upstream-Knotens.

  4. Fügen Sie so viele Bedingungen wie nötig hinzu.

  5. Gehen Sie für jede Bedingung wie folgt vor:

    1. Geben Sie einen Namen für die Bedingung ein.

    2. 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.

    3. 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
!= Nicht gleich Zeichenfolge, Zahl, boolescher Wert A != 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
and Beide Ausdrücke sind wahr (true). (A < B) and (C == 1) Wenn beide Ausdrücke wahr (true) sind:

  • A ist kleiner als B

  • C ist gleich 1
or Mindestens ein Ausdruck ist wahr (true). (A != 2) or (B > C) Wenn einer der Ausdrücke wahr (true) ist:

  • A ist nicht gleich B

  • B ist größer als C
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 im Feld definition, wenn Sie eine CreateFlow- oder UpdateFlow-Anfrage senden:

  1. Ein FlowNode-Objekt für die Bedingung 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"
                },
                ...
            ]
        }
    }
}

  2. Für jede Eingabe in den Bedingungsknoten ein FlowConnection-Objekt im connections-Array. Fügen Sie ein FlowDataConnectionConfiguration-Objekt in das Feld configuration des Objekts FlowConnection 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"
        }
    }
}

  3. Für jede Bedingung (einschließlich der Standardbedingung) im Bedingungsknoten ein FlowConnection-Objekt im connections-Array. Fügen Sie ein FlowConditionalConnectionConfiguration-Objekt in das Feld configuration des Objekts FlowConnection ein. Das allgemeine Format des FlowConnection-Objekts sieht folgendermaßen aus:

    {
    "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.

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.

Nachstehend ist die allgemeine Struktur eines FlowNode-Objekts für Iteratoren dargestellt:

{
    "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
    }
}

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.

Nachstehend ist die allgemeine Struktur eines FlowNode-Objekts für Kollektoren 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
    }
}

Ein DoWhile-Schleifenknoten führt eine Sequenz von Knoten wiederholt aus, solange eine angegebene Bedingung wahr (true) 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-Schleifenknoten nimmt Eingabedaten entgegen und leitet sie durch den Schleifenkörper weiter. 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.

Nachstehend ist die allgemeine Struktur eines FlowNode-Objekts für DoWhile-Schleifen dargestellt:

{
    "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:

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.

Ein Beispiel finden Sie unter Ausprobieren von Beispiel-Flows.

Die Eingaben für den Prompt-Knoten sind Werte zum Ausfüllen der Variablen. Die Ausgabe ist die generierte Antwort aus dem Modell.

Nachstehend ist die allgemeine Struktur eines FlowNode-Objekts für Prompts dargestellt:

{
    "name": "string",
    "type": "prompt",
    "inputs": [
        {
            "name": "content",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        ...
    ],
    "outputs": [
        {
            "name": "modelCompletion",
            "type": "String"
        }
    ],
    "configuration": {
        "prompt": {
            "sourceConfiguration": PromptFlowNodeSourceConfiguration object (see below),
            "guardrailConfiguration": {
                "guardrailIdentifier": "string",
                "guardrailVersion": "string"
            }
        }
    }
}

Das PromptFlowNodeSourceConfiguration-Objekt hängt davon ab, ob Sie einen Prompt aus dem Prompt-Management verwenden oder einen Inline-Prompt 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 (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.

Ein Agenten-Knoten ermöglicht es Ihnen, einen Prompt an einen Agenten zu senden, der zwischen FMs und den zugehörigen Ressourcen orchestriert, 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.

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

Nachstehend ist die allgemeine Struktur eines FlowNode-Objekts für Agenten dargestellt:

{
    "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"
        }
    }
}

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.

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

Nachstehend ist die allgemeine Struktur eines FlowNode-Objekts für Wissensdatenbanken dargestellt:

{
    "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"
            }
        }
    }
}

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. Der Knoten gibt den URI des S3-Speicherorts als Ausgabe zurück.

Nachstehend ist die allgemeine Struktur eines FlowNode-Objekts für S3-Speicher dargestellt:

{
    "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"
                }
            }
        }
    }
}

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

Nachstehend ist die allgemeine Struktur eines FlowNode-Objekts für S3-Abrufe dargestellt:

{
    "name": "string",
    "type": "Retrieval",
    "inputs": [
        {
            "name": "objectKey",
            "type": "String",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "s3Content",
            "type": "String"
        }
    ],
    "configuration": {
        "retrieval": {
            "serviceConfiguration": {
                "s3": {
                    "bucketName": "string"
                }
            }
        }
    }
}

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.

Nachstehend ist die allgemeine Struktur eines FlowNode-Objekts für Lambda-Funktionen dargestellt:

{
    "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 im Entwicklerhandbuch zu AWS Lambda.

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.

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-Code-Knoten in den Flow aufnehmen, führt Amazon Bedrock den Code in einer isolierten, von AWS verwalteten Umgebung aus, die für niemanden freigegeben wird und die ü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 FlowNode-Objekts für Inline-Code:

{
    "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 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
Anmerkung

Der Lex-Knoten basiert auf dem Service „Amazon Lex“, der Kundeninhalte speichern und verwenden kann, um andere AWS-Services zu entwickeln und kontinuierlich zu verbessern. Als AWS-Kunde können Sie sich entscheiden, 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.

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.

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 oder Sitzungsattribute. 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.

Nachstehend ist die allgemeine Struktur eines FlowNode-Objekts für Lex dargestellt:

{
    "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
Eingabe-Informationen Ausgabe-Informationen
Knotentyp Eingabe Name Typ Ausgabe Name Typ
Eingabe – – – Das Feld content in der InvokeFlow-Anfrage document Beliebig
Ausgabe Daten, die in der InvokeFlow-Antwort zurückgegeben werden sollen document Beliebig – – –
Bedingung

Daten, die basierend auf einer Bedingung gesendet werden

(mehrere Eingaben zulässig)

 Beliebig Beliebig

Daten, die basierend auf einer Bedingung gesendet werden

(Bedingungen für verschiedene Pfade angeben)

 Beliebig Beliebig
Iterator Ein Array, für das Sie den/die folgenden Knoten iterativ auf jedes Element anwenden möchten array Array Jedes Element aus dem Array arrayItem Beliebig
Die Größe des Eingabe-Arrays arraySize Zahl
Kollektor Eine Iteration, die Sie zu einem Array konsolidieren möchten arrayItem Beliebig Ein Array, an das alle Ausgaben des vorherigen Knotens angehängt sind collectedArray Array
Die Größe des Ausgabe-Arrays arraySize Zahl
DoWhile-Schleife Daten, die in der Schleife verarbeitet werden loopInput Beliebig Die endgültige Ausgabe der Schleife nach allen Iterationen loopOutput Beliebig
Anzahl der durchgeführten Iterationen iterationCount Zahl
Typen von Datenverarbeitungsknoten
Eingabe-Informationen Ausgabe-Informationen
Knotentyp Eingabe Name Typ Ausgabe Name Typ
Prompt

Ein Wert zum Ausfüllen einer Variablen im Prompt (mehrere Eingaben zulässig)

 ${variable-name} Beliebig Die vom Modell zurückgegebene Antwort modelCompletion Zeichenfolge
S3-Speicher Daten zum Speichern in einem S3-Bucket content Beliebig Der URI des S3-Speicherorts s3Uri Zeichenfolge
Der Objektschlüssel, der für das S3-Objekt verwendet werden soll objectKey Zeichenfolge
S3-Abruf Der Objektschlüssel für das S3-Objekt objectKey Zeichenfolge Die Daten, die aus einem S3-Bucket abgerufen werden sollen s3Content Beliebig
Agent Der Prompt, der an den Agenten gesendet werden soll agentInputText Zeichenfolge Die Antwort, die vom Agenten zurückgegeben wurde agentResponse Zeichenfolge
Alle Prompt-Attribute, die zusammen mit dem Prompt gesendet werden sollen promptAttributes Objekt
Alle Sitzungsattribute, die zusammen mit dem Prompt gesendet werden sollen sessionAttributes Objekt
Wissensdatenbank Die an die Wissensdatenbank gesendete Abfrage retrievalQuery Zeichenfolge Die zurückgegebenen Ergebnisse oder die generierte Antwort aus der Wissensdatenbank retrievalResults Array
Lambda-Funktion

Daten, die an die Funktion gesendet werden sollen (mehrere Eingaben zulässig)

 Beliebig Beliebig Die von der Funktion zurückgegebene Antwort functionResponse Beliebig
Inline-Code-Knoten

Variablen für die Ausführung Ihres Codes (mehrere Eingaben zulässig)

 Beliebig Beliebig Die letzte Zeile, die in Ihrem Code ausgeführt wurde response Beliebig
Lex Die Äußerung, die an den Bot gesendet werden soll inputText Zeichenfolge Die Absicht, die der Bot für die Äußerung annimmt predictedIntent Zeichenfolge
Alle Anforderungsattribute, die zusammen mit der Äußerung gesendet werden sollen requestAttributes Objekt
Alle Sitzungsattribute, die zusammen mit der Äußerung gesendet werden sollen sessionAttributes Objekt