Nœuds pour contrôler la logique de flux rapide Nœuds pour gérer les données dans le flux rapide Tableaux récapitulatifs des types de nœuds

Types de nœuds dans Prompt Flow

Amazon Bedrock propose les types de nœuds suivants pour créer votre flux rapide. Lorsque vous configurez un nœud, vous devez fournir les champs suivants :

Nom — Entrez le nom du nœud.
Type : dans la console, vous devez glisser-déposer le type de nœud à utiliser. Dans l'API, utilisez le type champ et FlowNodeConfigurationle configuration champ correspondant.
Entrées — Indiquez un nom et un type de données pour chaque entrée. Certains nœuds ont des noms ou des types prédéfinis que vous devez utiliser. Pour savoir lesquels ont des noms prédéfinis, voirTypes de nœuds logiques. Dans le champ d'expression, définissez la partie de l'ensemble de l'entrée à utiliser comme entrée individuelle. Pour plus d’informations, consultez Utilisez des expressions pour définir les entrées en extrayant la partie pertinente d'une entrée entière.
Sorties — Indiquez un nom et un type de données pour chaque sortie. Certains nœuds ont des noms ou des types prédéfinis que vous devez utiliser. Pour savoir lesquels ont des noms prédéfinis, voirTypes de nœuds logiques.
Configuration : dans la console, vous définissez des champs spécifiques au nœud en haut du nœud. Dans l'API, utilisez le champ approprié FlowNodeConfigurationet renseignez ses champs.

Chaque type de nœud est décrit ci-dessous et sa structure dans l'API est fournie. Développez une section pour en savoir plus sur ce type de nœud.

Nœuds pour contrôler la logique de flux rapide

Utilisez les types de nœuds suivants pour contrôler la logique de votre flux d'appels.

Chaque flux d'invite ne contient qu'un seul nœud d'entrée de flux et doit commencer par celui-ci. Le nœud d'entrée du flux prend le contenu content de la InvokeFlow demande, valide le type de données et l'envoie au nœud suivant.

Voici la structure générale d'un FlowNodeobjet d'entrée dans l'API :


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

Un nœud de sortie de flux extrait les données d'entrée du nœud précédent, en fonction de l'expression définie, et les renvoie. Dans la console, le résultat est la réponse renvoyée après avoir sélectionné Exécuter dans la fenêtre de test. Dans l'API, la sortie est renvoyée dans le content champ de la InvokeFlow réponse. flowOutputEvent Un flux rapide peut avoir plusieurs nœuds de sortie de flux.

Un flux peut avoir plusieurs nœuds de sortie de flux s'il comporte plusieurs branches.

Voici la structure générale d'un FlowNodeobjet de sortie :


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

Un nœud de condition envoie des données du nœud précédent à différents nœuds, en fonction des conditions définies. Un nœud de condition peut accepter plusieurs entrées.

Pour définir un nœud de condition

Ajoutez autant d'entrées que nécessaire pour évaluer les conditions que vous prévoyez d'ajouter.
Entrez un nom pour chaque entrée, spécifiez le type attendu et écrivez une expression pour extraire la partie pertinente de l'ensemble de l'entrée.
Connectez chaque entrée à la sortie appropriée depuis un nœud en amont.
Ajoutez autant de conditions que nécessaire.
Pour chaque condition :
1. Entrez le nom de la condition.
2. Utilisez des opérateurs relationnels et logiques pour définir une condition qui compare les entrées à d'autres entrées ou à une constante.
  
  Note
  Les conditions sont évaluées dans l'ordre. Si plusieurs conditions sont satisfaites, la première est prioritaire.
3. Connectez chaque condition au nœud en aval auquel vous souhaitez envoyer les données si cette condition est remplie.

Expressions de condition

Pour définir une condition, vous faites référence à une entrée par son nom et vous la comparez à une valeur en utilisant l'un des opérateurs relationnels suivants :

Opérateur	Signification	Types de données pris en charge	Exemple d’utilisation	Exemple de signification
==	Égal à (le type de données doit également être égal)	Chaîne, nombre, booléen	A = B	Si A est égal à B
!=	Non égal à	Chaîne, nombre, booléen	UN ! = B	Si A n'est pas égal à B
>	Supérieure à	Nombre	A > B	Si A est supérieur à B
>=	Supérieur ou égal à	Nombre	A >= B	Si A est supérieur ou égal à B
<	Inférieur à	Nombre	A < B	Si A est inférieur à B
<=	Inférieur ou égal à	Nombre	A <= B	Si A est inférieur ou égal à B

Vous pouvez comparer les entrées à d'autres entrées ou à une constante dans une expression conditionnelle. Par exemple, si vous avez une entrée numérique appelée profit et une autre appeléeexpenses, les deux profit <= 1000 sont profit > expenses des expressions valides.

Vous pouvez utiliser les opérateurs logiques suivants pour combiner des expressions correspondant à des conditions plus complexes. Nous vous recommandons d'utiliser des parenthèses pour résoudre les ambiguïtés liées au regroupement d'expressions :

Opérateur	Signification	Exemple d’utilisation	Exemple de signification
and	Les deux expressions sont vraies	(A < B) et (C == 1)	Si les deux expressions sont vraies : A est inférieur à B C est égal à 1
or	Au moins une expression est vraie	(UNE ! = 2) ou (B > C)	Si l'une des expressions est vraie : A n'est pas égal à B B est supérieur à C
not	L'expression n'est pas vraie	pas (A > B)	Si A n'est pas supérieur à B (équivalent à A <= B)

Dans l'API, vous définissez les éléments suivants dans le definition champ lorsque vous envoyez une UpdateFlowdemande CreateFlowor :

Un FlowNodeobjet de condition dans le nodes tableau. Le format général est le suivant (notez que les nœuds de condition n'en ont pasoutputs) :


{
    "name": "string",
    "type": "Condition",
    "inputs": [
        {
            "name": "string",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        }
    ],
    "configuration": {
        "conditions": [
            {
                "name": "string",
                "expression": "string"
            },
            ...
        ]
    }
}

Pour chaque entrée dans le nœud de condition, un FlowConnectionobjet dans le connections tableau. Incluez un FlowDataConnectionConfigurationobjet dans le configuration champ de l'FlowConnectionobjet. Le format général de l'FlowConnectionobjet est le suivant :
```
{
    "name": "string",
    "source": "string",
    "target": "string",
    "type": "Data",
    "configuration": {
        "data": {
            "sourceOutput": "string",
            "expression": "string"
        }
    }
}
```
Pour chaque condition (y compris la condition par défaut) du nœud de condition, un FlowConnectionobjet du connections tableau. Incluez un FlowConditionalConnectionConfigurationobjet dans le configuration champ de l'FlowConnectionobjet. Le format général de l'FlowConnectionobjet est le suivant :
```
{
    "name": "string",
    "source": "string",
    "target": "string",
    "type": "Data",
    "configuration": {
        "condition": "default",
        "condition": "string"
        ...
    }
}
```
Utilisez des opérateurs relationnels et logiques pour définir le nœud condition qui connecte ce source nœud conditionnel à un target nœud en aval. Pour la condition par défaut, spécifiez la condition sous la formedefault.

Un nœud itérateur prend un tableau et renvoie itérativement ses éléments en sortie au nœud en aval. Le nœud de sortie du flux renvoie le résultat final pour chaque entrée dans une réponse différente. Vous pouvez également utiliser un nœud collecteur en aval du nœud itérateur pour collecter les réponses itérées et les renvoyer sous forme de tableau, en plus de la taille du tableau.

Voici la structure générale d'un FlowNodeobjet itérateur :


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

Un nœud collecteur prend une entrée itérée, en plus de la taille que sera le tableau, et les renvoie sous forme de tableau. Vous pouvez utiliser un nœud collecteur situé en aval d'un nœud itérateur pour collecter les éléments itérés après les avoir envoyés via certains nœuds.

Voici la structure générale d'un FlowNodeobjet de collection :


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

Nœuds pour gérer les données dans le flux rapide

Utilisez les types de nœuds suivants pour gérer les données dans votre flux d'invite :

Un nœud d'invite définit une invite à utiliser dans le flux. Vous pouvez utiliser une invite depuis Prompt Management ou en définir une en ligne dans le nœud. Pour plus d’informations, consultez Gestion rapide dans Amazon Bedrock.

Les entrées du nœud d'invite sont des valeurs permettant de renseigner les variables. La sortie est la réponse générée par le modèle.

Voici la structure générale d'un FlowNodeobjet d'invite :


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

L'PromptFlowNodeSourceConfigurationobjet varie selon que vous utilisez une invite de la gestion des invites ou que vous la définissez en ligne :

Si vous utilisez une invite de Prompt Management, l'objet doit avoir la structure générale suivante :
```
{
    "resource": {
        "promptArn": "string"
    }
}
```

Si vous définissez une invite en ligne, suivez les instructions pour définir une variante dans l'onglet API de Création d'une invite à l'aide de la gestion rapide (notez toutefois qu'il n'y a aucun name champ dans cet objet). L'objet que vous utilisez doit avoir la structure générale suivante :


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

Un nœud d'agent vous permet d'envoyer une invite à un agent, qui assure l'orchestration entre les FM et les ressources associées afin d'identifier et de réaliser des actions pour un utilisateur final. Pour plus d’informations, consultez Agents for Amazon Bedrock.

Dans la configuration, spécifiez l'Amazon Resource Name (ARN) de l'alias de l'agent à utiliser. Les entrées dans le nœud sont l'invite de l'agent et toute invite ou attribut de session associé. Le nœud renvoie la réponse de l'agent sous forme de sortie.

Note

À l'heure actuelle, l'agent ne prend pas en charge les invocations à plusieurs tours. Vous ne pouvez pas configurer le retour de contrôle pour l'agent dans un flux.

Voici la structure générale d'un FlowNodeobjet agent :


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

Un nœud de base de connaissances vous permet d'envoyer une requête à une base de connaissances. Pour plus d’informations, consultez Bases de connaissances pour Amazon Bedrock.

Dans la configuration, indiquez l'ID de base de connaissances et un ID de modèle à utiliser si vous souhaitez générer une réponse basée sur les résultats récupérés. Pour renvoyer les résultats récupérés sous forme de tableau, omettez l'ID du modèle. L'entrée dans le nœud est la requête envoyée à la base de connaissances. La sortie est soit la réponse du modèle, sous forme de chaîne, soit un tableau des résultats récupérés.

Voici la structure générale d'un FlowNodeobjet de base de connaissances :


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

Un nœud de stockage S3 vous permet de stocker des données dans le flux vers un emplacement Amazon S3. Dans la configuration, vous spécifiez le compartiment S3 à utiliser pour le stockage des données. Les entrées dans le nœud sont le contenu à stocker et la clé de l'objet. Le nœud renvoie l'URI de l'emplacement S3 en sortie.

Voici la structure générale d'un FlowNodeobjet de stockage S3 :


{
    "name": "string",
    "type": "Storage",
    "inputs": [
        {
            "name": "content",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        {
            "name": "objectKey",
            "type": "String",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "storageS3Uri",
            "type": "String"
        }
    ],
    "configuration": {
        "retrieval": {
            "serviceConfiguration": {
                "s3": {
                    "bucketName": "string"
                }
            }
        }
    }
}

Un nœud de récupération S3 vous permet de récupérer des données depuis un emplacement Amazon S3 pour les introduire dans le flux. Dans la configuration, vous spécifiez le compartiment S3 à partir duquel vous souhaitez récupérer les données. L'entrée dans le nœud est la clé de l'objet. Le nœud renvoie le contenu de l'emplacement S3 en tant que sortie.

Note

Actuellement, les données de l'emplacement S3 doivent être une chaîne codée en UTF-8.

Voici la structure générale d'un FlowNodeobjet de récupération S3 :


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

Un nœud de fonction Lambda vous permet d'appeler une fonction Lambda dans laquelle vous pouvez définir du code pour exécuter une logique métier. Pour plus d’informations, consultez le Guide du développeur AWS Lambda.

Dans la configuration, spécifiez l'Amazon Resource Name (ARN) de la fonction Lambda. Définissez les entrées à envoyer lors de l'événement d'entrée Lambda. Vous pouvez écrire du code en fonction de ces entrées et définir ce que la fonction renvoie. La réponse de la fonction est renvoyée en sortie.

Voici la structure générale d'un FlowNodeobjet de fonction λ :


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

Un nœud Lex vous permet d'appeler un robot Amazon Lex pour traiter un énoncé à l'aide du traitement du langage naturel et pour identifier une intention, en fonction de la définition du bot. Pour plus d'informations, consultez le guide du développeur Amazon Lex.

Dans la configuration, spécifiez l'Amazon Resource Name (ARN) de l'alias du bot à utiliser et les paramètres régionaux à utiliser. Les entrées dans le nœud sont l'énoncé et tous les attributs de demande ou de session qui l'accompagnent. Le nœud renvoie l'intention identifiée comme sortie.

Note

Actuellement, le nœud Lex ne prend pas en charge les conversations à plusieurs tours. Un nœud Lex ne peut traiter qu'un seul énoncé.

Voici la structure générale d'un FlowNodeobjet Lex :


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

Tableaux récapitulatifs des types de nœuds

Les tableaux suivants récapitulent les entrées et sorties autorisées pour chaque type de nœud. Notez ce qui suit :

Si un nom est marqué comme N'importe quel, vous pouvez fournir n'importe quelle chaîne comme nom. Dans le cas contraire, vous devez utiliser la valeur spécifiée dans le tableau.
Si un type est marqué comme N'importe quel, vous pouvez spécifier l'un des types de données suivants : chaîne, nombre, booléen, objet, tableau. Dans le cas contraire, vous devez utiliser le type indiqué dans le tableau.
Actuellement, seuls les nœuds de fonctions Condition, Prompt et Lambda autorisent plusieurs entrées que vous pouvez définir vous-même.

Types de nœuds logiques
	Informations d'entrée			Informations de sortie
Type de nœud	Entrée	Nom	Type	Sortie	Nom	Type
Entrée	N/A	N/A	N/A	Le `content` champ de la `InvokeFlow` demande.	`document`	N’importe quel compte
Sortie	Données à renvoyer dans la `InvokeFlow` réponse.	`document`	N’importe quel compte	N/A	N/A	N/A
Condition	Données à envoyer en fonction d'une condition. (entrées multiples autorisées)	N’importe quel compte	N’importe quel compte	Données à envoyer en fonction d'une condition. (spécifiez les conditions pour les différents chemins)	N’importe quel compte	N’importe quel compte
Itérateur	Un tableau pour lequel vous souhaitez appliquer le ou les nœuds suivants de manière itérative à chaque membre.	`array`	Tableau	Chaque élément du tableau	`arrayItem`	N’importe quel compte
Itérateur		`array`	Tableau	La taille du tableau d'entrée	`arraySize`	Nombre
Collectionneur	Une itération que vous souhaitez consolider dans un tableau.	`arrayItem`	N’importe quel compte	Un tableau contenant toutes les sorties du nœud précédent ajoutées.	`collectedArray`	Tableau
Collectionneur	La taille du tableau de sortie	`arraySize`	Nombre		`collectedArray`	Tableau

Types de nœuds de traitement des données
	Informations d'entrée			Informations de sortie
Type de nœud	Entrée	Nom	Type	Sortie	Nom	Type
Prompt	Une valeur pour renseigner une variable dans l'invite. (entrées multiples autorisées)	`${variable-name}`	N’importe quel compte	Réponse renvoyée par le modèle.	`modelCompletion`	Chaîne
Stockage S3	Données à stocker dans un compartiment S3.	`content`	N’importe quel compte	L'URI de l'emplacement S3.	`storageS3Uri`	Chaîne
Stockage S3	La clé d'objet à utiliser pour l'objet S3.	`objectKey`	Chaîne	L'URI de l'emplacement S3.	`storageS3Uri`	Chaîne
Récupération S3	La clé d'objet pour l'objet S3	`retrievalObjectKey`	Chaîne	Les données à récupérer à partir d'un compartiment S3.	`retrievalNodeContent`	N’importe quel compte
Agent	L'invite à envoyer à l'agent.	`agentInputText`	Chaîne	La réponse renvoyée par l'agent.	`agentResponse`	Chaîne
	Tous les attributs d'invite à envoyer en même temps que l'invite.	`promptAttributes`	Objet
	Tous les attributs de session à envoyer en même temps que l'invite.	`sessionAttributes`	Objet
Base de connaissances	Requête à envoyer à la base de connaissances.	`retrievalQuery`	Chaîne	Les résultats renvoyés ou la réponse générée à partir de la base de connaissances.	`retrievalResults`	Tableau
Fonction Lambda	Données à envoyer à la fonction. (entrées multiples autorisées)	N’importe quel compte	Réponse renvoyée par la fonction.	`functionResponse`	N’importe quel compte
Lex	L'énoncé à envoyer au bot.	`inputText`	Chaîne	L'intention que le bot prédit pour l'énoncé.	`predictedIntent`	Chaîne
	Tous les attributs de demande à envoyer à côté de l'énoncé.	`requestAttributes`	Objet
	Tous les attributs de session à envoyer en même temps que l'énoncé.	`sessionAttributes`	Objet

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Définir les entrées avec des expressions

Exemples de flux rapides