Knotentypen im Prompt-Flow - Amazon Bedrock
Knoten zur Steuerung der Prompt-Flow-LogikKnoten für die Verarbeitung von Daten im Prompt-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 im Prompt-Flow

Amazon Bedrock bietet die folgenden Knotentypen, um Ihren Prompt-Flow zu erstellen. Wenn Sie einen Knoten konfigurieren, müssen Sie die folgenden Felder angeben:

  • Name — Geben Sie einen Namen für den Knoten ein.

  • Typ — In der Konsole ziehen Sie den zu verwendenden Knotentyp per Drag-and-Drop. Verwenden Sie im API type Feld das Feld und das entsprechende FlowNodeConfigurationconfigurationFeld.

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

  • Ausgaben — Geben Sie für jede Ausgabe die folgenden Informationen an:

    • Name — Ein Name für die Ausgabe. Einige Knoten haben vordefinierte Namen oder Typen, die Sie verwenden müssen. Informationen darüber, welche Knoten vordefinierte Namen haben, finden Sie unter. Typen von logischen Knoten

    • Typ — Der Datentyp für die Ausgabe. Wenn dieser Knoten zur Laufzeit erreicht wird, überprüft Amazon Bedrock, ob die Knotenausgabe dem Datentyp entspricht.

  • Konfiguration — In der Konsole definieren Sie knotenspezifische Felder oben auf dem Knoten. Verwenden Sie in der die API entsprechenden Felder FlowNodeConfigurationund füllen Sie die entsprechenden Felder aus.

Jeder Knotentyp wird im Folgenden beschrieben und seine Struktur API wird in der angegeben. Erweitern Sie einen Abschnitt, um mehr über diesen Knotentyp zu erfahren.

Knoten zur Steuerung der Prompt-Flow-Logik

Verwenden Sie die folgenden Knotentypen, um die Logik Ihres Prompt-Ablaufs zu steuern.

Jeder Prompt-Flow enthält nur einen Flow-Eingabeknoten und muss mit diesem beginnen. Der Flow-Eingabeknoten nimmt den content aus der InvokeFlow Anfrage, validiert den Datentyp und sendet ihn an den folgenden Knoten.

Im Folgenden wird die allgemeine Struktur eines FlowNodeEingabeobjekts im 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 auf der Grundlage 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 content Feld der flowOutputEvent in der InvokeFlow Antwort zurückgegeben. Ein Prompt-Flow kann mehrere Flow-Ausgabeknoten haben.

Ein Flow kann mehrere Flow-Ausgabeknoten haben, wenn der Flow mehrere Verzweigungen enthält.

Im Folgenden wird die allgemeine Struktur eines FlowNodeAusgabeobjekts veranschaulicht:

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

Ein Bedingungsknoten sendet je nach den definierten Bedingungen Daten vom vorherigen Knoten an verschiedene Knoten. Ein Bedingungsknoten kann mehrere Eingaben annehmen.

Ein Beispiel finden Sie unter Erstellen Sie einen Flow mit einem Bedingungsknoten.

Um einen Bedingungsknoten zu definieren

  1. Fügen Sie so viele Eingaben hinzu, wie Sie benötigen, um die Bedingungen auszuwerten, die Sie hinzufügen möchten.

  2. Geben Sie für jede Eingabe einen Namen ein, geben Sie den Typ an, der erwartet werden soll, und schreiben Sie einen Ausdruck, um den entsprechenden Teil aus der gesamten Eingabe zu extrahieren.

  3. Connect jeden Eingang mit dem entsprechenden Ausgang eines Upstream-Knotens.

  4. Fügen Sie so viele Bedingungen hinzu, wie Sie benötigen.

  5. Für jede Bedingung:

    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 ausgewertet. Wenn mehr als eine Bedingung erfüllt ist, hat die frühere Bedingung Vorrang.

    3. Connect jede Bedingung mit dem Downstream-Knoten, an den Sie die Daten senden möchten, wenn diese Bedingung erfüllt ist.

Bedingungsausdrücke

Um eine Bedingung zu definieren, verweisen Sie auf eine Eingabe anhand ihres Namens und vergleichen sie mit einem der folgenden relationalen Operatoren mit einem Wert:

Operator Bedeutung Unterstützte Datentypen Beispielverwendung Bedeutung des Beispiels
== Gleich (der Datentyp muss ebenfalls gleich sein) Zeichenfolge, Zahl, Boolean A == B Wenn A gleich B ist
!= nicht gleich Zeichenfolge, Zahl, Boolean EIN! = 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 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 oder gleich B ist

Sie können Eingaben mit anderen Eingaben oder mit einer Konstante in einem bedingten Ausdruck vergleichen. Wenn Sie beispielsweise eine numerische Eingabe aufgerufen profit und eine andere aufgerufen habenexpenses, profit <= 1000 sind beide profit > expenses oder gültige Ausdrücke.

Sie können die folgenden logischen Operatoren verwenden, um Ausdrücke für komplexere Bedingungen zu kombinieren. Es wird empfohlen, Klammern zu verwenden, um Mehrdeutigkeiten bei der Gruppierung von Ausdrücken zu lösen:

Operator Bedeutung Beispielverwendung Bedeutung eines Beispiels
and Beide Ausdrücke sind wahr (A < B) und (C == 1) Wenn beide Ausdrücke wahr sind:

  • A ist kleiner als B

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

  • A ist nicht gleich B

  • B ist größer als C
not Der Ausdruck ist nicht wahr nicht (A > B) Wenn A nicht größer als B ist (entspricht A <= B)

In der definieren Sie in dem definition Feld FolgendesAPI, wenn Sie eine UpdateFlowOder-Anfrage CreateFlowsenden:

  1. Ein FlowNodeBedingungsobjekt im nodes Array. Das allgemeine Format lautet wie folgt (beachten Sie, dass Bedingungsknoten keine habenoutputs):

    {
    "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 FlowConnectionObjekt im connections Array. Schließt ein FlowDataConnectionConfigurationObjekt in das configuration Feld des FlowConnection Objekts ein. Das allgemeine Format des FlowConnection Objekts lautet wie folgt:

    {
    "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 FlowConnectionObjekt im connections Array. Schließt ein FlowConditionalConnectionConfigurationObjekt in das configuration Feld des FlowConnection Objekts ein. Das allgemeine Format des FlowConnectionObjekts lautet wie folgt:

    {
    "name": "string",
    "source": "string",
    "target": "string",
    "type": "Data",
    "configuration": {
        "condition": "default",
        "condition": "string"
        ...
    }
}

    Verwenden Sie relationale und logische Operatoren, um den Knoten zu definierencondition, der diesen source Zustandsknoten mit einem nachgeschalteten target Knoten verbindet. Geben Sie für die Standardbedingung die Bedingung als default an.

Ein Iteratorknoten nimmt ein Array und gibt seine Elemente iterativ als Ausgabe an den Downstream-Knoten zurück. Die Eingaben für den Iteratorknoten werden nacheinander und nicht parallel zueinander 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 Iterator-Knoten nachgeschaltet ist, um die iterierten Antworten zu sammeln und sie zusätzlich zur Größe des Arrays als Array zurückzugeben.

Im Folgenden wird die allgemeine Struktur eines FlowNodeIterator-Objekts veranschaulicht:

{
    "name": "string",
    "type": "Iterator",
    "inputs": [
        {
            "name": "array",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "arrayItem",
            "type": "String | Number | Boolean | Object | Array",
        },
        {
            "name": "arraySize",
            "type": "Number"
        }
    ],
    "configuration": {
        "iterator": CONTEXT-DEPENDENT
    }
}

Ein Collector-Knoten nimmt zusätzlich zur Größe des Arrays eine iterierte Eingabe entgegen und gibt sie als Array zurück. Sie können einen Collector-Knoten verwenden, der einem Iterator-Knoten nachgeschaltet ist, um die iterierten Elemente zu sammeln, nachdem Sie sie durch einige Knoten gesendet haben.

Im Folgenden wird die allgemeine Struktur eines FlowNodeCollector-Objekts veranschaulicht:

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

Knoten für die Verarbeitung von Daten im Prompt-Flow

Verwenden Sie die folgenden Knotentypen, um Daten in Ihrem Prompt-Flow zu verarbeiten:

Ein Prompt-Knoten definiert eine Aufforderung, die im Flow verwendet werden soll. Sie können einen Prompt aus der Prompt-Verwaltung verwenden oder einen Inline-Prompt im Node definieren. Weitere Informationen finden Sie unter Erstellen und speichern Sie wiederverwendbare Eingabeaufforderungen mit der Prompt-Verwaltung in Amazon Bedrock.

Ein Beispiel finden Sie unter Erste Schritte mit Beispiel-Prompt-Flows.

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

Im Folgenden wird die allgemeine Struktur eines FlowNodePrompt-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 object (see below)
        }
    }
}

Das PromptFlowNodeSourceConfigurationObjekt hängt davon ab, ob Sie einen Prompt aus der Prompt-Verwaltung verwenden oder ob Sie ihn inline definieren:

  • Wenn Sie eine Aufforderung aus der Prompt-Verwaltung verwenden, sollte das Objekt die folgende allgemeine Struktur haben:

    {
    "resource": {
        "promptArn": "string"
    }
}

  • Wenn Sie eine Inline-Aufforderung definieren, folgen Sie den Anweisungen zur Definition einer Variante API auf der Registerkarte von Erstellen Sie eine Aufforderung mithilfe der Eingabeaufforderungsverwaltung (beachten Sie jedoch, dass dieses Objekt kein name Feld enthält). Das Objekt, das Sie verwenden, sollte die folgende allgemeine Struktur haben:

    {
    "inline": {
        "modelId": "string",
        "templateType": "TEXT",
        "templateConfiguration": {
            "text": {
                "text": "string",
                "inputVariables": [
                    {
                        "name": "string"
                    },
                    ...
                ]
            }
        },
        "inferenceConfiguration": {
            "text": {
                "maxTokens": int,
                "stopSequences": ["string", ...],
                "temperature": float,
                "topK": int,
                "topP": float
            }
        }
    }
}

Ein Agent-Knoten ermöglicht es Ihnen, eine Aufforderung an einen Agenten zu 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 Sie Aufgaben in Ihrer Anwendung mithilfe von Konversationsagenten.

Geben Sie in der Konfiguration den Amazon-Ressourcennamen (ARN) des Alias des Agenten an, der verwendet werden soll. Bei den Eingaben in den Knoten handelt es sich um die Eingabeaufforderung für den Agenten und alle zugehörigen Eingabeaufforderungs- oder Sitzungsattribute. Der Knoten gibt die Antwort des Agenten als Ausgabe zurück.

Anmerkung

Derzeit unterstützt der Agent keine Multi-Turn-Aufrufe. Sie können die Kontrollrückgabe für den Agenten in einem Flow nicht konfigurieren.

Im Folgenden wird die allgemeine Struktur eines FlowNodeAgentenobjekts 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"
        }
    }
}

Mit einem Knotenpunkt in der Wissensdatenbank können Sie eine Anfrage an eine Wissensdatenbank senden. Weitere Informationen finden Sie unter Rufen Sie Daten ab und generieren Sie KI-Antworten mit Wissensdatenbanken.

Geben Sie in der Konfiguration die Wissensdatenbank-ID und eine Modell-ID an, die Sie verwenden können, 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. 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 FlowNodeKnowledge-Base-Objekts veranschaulicht:

{
    "name": "string",
    "type": "KnowledgeBase",
    "inputs": [
       {
            "name": "retrievalQuery",
            "type": "String",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "retrievalResults",
            "type": "Array | String"
        }
    ],
    "configuration": {
        "knowledgeBase": {
            "knowledgeBaseId": "string",
            "modelId": "string"
        }
    }
}

Mit einem S3-Speicherknoten können Sie Daten im Datenfluss an einem Amazon S3 S3-Standort speichern. 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 URI den S3-Standort als Ausgabe zurück.

Im Folgenden wird die allgemeine Struktur eines FlowNodeS3-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"
                }
            }
        }
    }
}

Mit einem S3-Abrufknoten können Sie Daten von einem Amazon S3 S3-Standort abrufen, um in den Datenfluss einzusteigen. 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

Derzeit müssen die Daten am S3-Standort eine mit UTF -8 kodierte Zeichenfolge sein.

Im Folgenden wird die allgemeine Struktur eines FlowNodeS3-Abrufobjekts veranschaulicht:

{
    "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 Prompt-Flow einbeziehen, sendet Amazon Bedrock ein Eingabeereignis an die Lambda-Funktion, die Sie angeben.

Geben Sie in der Konfiguration den Amazon-Ressourcennamen (ARN) der Lambda-Funktion an. Definieren Sie Eingaben, die im Lambda-Eingabeereignis gesendet werden sollen. Sie können Code auf der Grundlage dieser Eingaben schreiben und definieren, was die Funktion zurückgibt. Die Funktionsantwort wird in der Ausgabe zurückgegeben.

Im Folgenden wird die allgemeine Struktur eines FlowNodeJAVA-Funktionsobjekts dargestellt:

{
    "name": "string",
    "type": "LambdaFunction",
    "inputs": [
       {
            "name": "string",
            "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 Prompt-Flow

Das Eingabeereignis, das an eine Lambda-Funktion in einem Lambda-Knoten gesendet wird, hat das folgende Format:

{
   "messageVersion": "1.0",
   "flow": {
        "flowArn": "string",
        "flowAliasArn": "string"
   },
   "node": {
        "name": "string",
        "nodeInputs": [
            {
               "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 value Felds 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 ist [1, 2, 3] und der Ausdruck ist$.data[1], wäre der Wert, der im Eingabeereignis an die Lambda-Funktion gesendet wird2,

Weitere Informationen zu Ereignissen in Lambda finden Sie unter Lambda-Konzepte im AWS Lambda Leitfaden für Entwickler.

Lambda-Antwort für einen schnellen Ablauf

Wenn Sie eine Lambda-Funktion schreiben, definieren Sie die von ihr zurückgegebene Antwort. Diese Antwort wird als Ausgabe des Lambda-Knotens an Ihren Prompt-Flow zurückgegeben.

Anmerkung

Der Lex-Knoten stützt sich auf den Amazon Lex Lex-Service, der Kundeninhalte für die Entwicklung und kontinuierliche Verbesserung anderer speichern und verwenden kann AWS Dienste. Als AWS Als Kunde können Sie der Speicherung oder Nutzung Ihrer Inhalte für Serviceverbesserungen widersprechen. Informationen zur Implementierung einer Opt-Out-Richtlinie für Amazon Lex finden Sie unter Opt-Out-Richtlinien für KI-Dienste.

Mit einem Lex-Knoten können Sie einen Amazon Lex 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 Amazon Lex Developer Guide.

Geben Sie in der Konfiguration den Amazon-Ressourcennamen (ARN) des Alias des zu verwendenden Bots und das zu verwendende Gebietsschema an. Die Eingaben in den Knoten sind die Äußerung und alle zugehörigen Anforderungs- 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 eine Äußerung verarbeiten.

Das Folgende zeigt die allgemeine Struktur eines FlowNodeLex-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 Eingaben und Ausgaben zusammengefasst, die für jeden Knotentyp zulässig sind. Beachten Sie Folgendes:

  • Wenn ein Name als Beliebig markiert ist, können Sie eine beliebige Zeichenfolge als Namen angeben. Andernfalls 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, Boolean, Objekt, Array. Andernfalls müssen Sie den in der Tabelle angegebenen Typ verwenden.

  • Derzeit erlauben nur die Funktionsknoten Condition, Prompt und Lambda mehrere Eingaben, die Sie selbst definieren können.

Typen von logischen Knoten
Geben Sie Informationen ein Informationen ausgeben
Knotentyp Eingabe Name Typ Output Name Typ
Eingabe N/A – N/A Das content Feld in der InvokeFlow Anfrage. document Any
Ausgabe Daten, die in der InvokeFlow Antwort zurückgegeben werden sollen. document Any N/A – N/A
Bedingung

Daten, die aufgrund einer Bedingung gesendet werden sollen.

(mehrere Eingaben zulässig)

 Any Any

Daten, die auf der Grundlage einer Bedingung gesendet werden sollen.

(geben Sie Bedingungen für verschiedene Pfade an)

 Any Any
Iterator Ein Array, für das Sie die folgenden Knoten iterativ auf jedes Mitglied anwenden möchten. array Array Jedes Element aus dem Array arrayItem Any
Die Größe des Eingabe-Arrays arraySize Zahl
Kollektor Eine Iteration, die Sie zu einem Array konsolidieren möchten. arrayItem Any Ein Array, an das alle Ausgaben des vorherigen Knotens angehängt sind. collectedArray Array
Die Größe des Ausgabe-Arrays arraySize Zahl
Typen von Datenverarbeitungsknoten
Geben Sie Informationen ein Informationen ausgeben
Knotentyp Eingabe Name Typ Output Name Typ
Prompt

Ein Wert zum Ausfüllen einer Variablen in der Eingabeaufforderung.

(mehrere Eingaben sind zulässig)

 ${variable-name} Any Die vom Modell zurückgegebene Antwort. modelCompletion String
S3-Speicher Daten, die in einem S3-Bucket gespeichert werden sollen. content Any Der URI des S3-Standorts. s3Uri String
Der Objektschlüssel, der für das S3-Objekt verwendet werden soll. objectKey String
S3-Abruf Der Objektschlüssel für das S3-Objekt objectKey String Die Daten, die aus einem S3-Bucket abgerufen werden sollen. s3Content Any
Kundendienstmitarbeiter Die Aufforderung, die an den Agenten gesendet werden soll. agentInputText String Die Antwort wurde vom Agenten zurückgegeben. agentResponse String
Alle Eingabeaufforderungsattribute, die zusammen mit der Aufforderung gesendet werden sollen. promptAttributes Object
Alle Sitzungsattribute, die zusammen mit der Aufforderung gesendet werden sollen. sessionAttributes Object
Wissensdatenbank Die Anfrage, die an die Wissensdatenbank gesendet werden soll. retrievalQuery String 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)

 Any Die von der Funktion zurückgegebene Antwort. functionResponse Any
Lex Die Äußerung, die an den Bot gesendet werden soll. inputText String Die Absicht, die der Bot für die Äußerung vorhersagt. predictedIntent String
Alle Anforderungsattribute, die zusammen mit der Äußerung gesendet werden sollen. requestAttributes Object
Alle Sitzungsattribute, die zusammen mit der Äußerung gesendet werden sollen. sessionAttributes Object