Types de nœuds dans Prompt Flow

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.

Ce qui suit montre la structure générale d'un FlowNodeobjet d'entrée dans 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 leAPI, 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 obtenir un exemple, consultez Création d'un flux avec un nœud de condition.

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 :

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 :

Dans leAPI, vous définissez les éléments suivants dans le definition champ lorsque vous envoyez une UpdateFlowdemande CreateFlowou :

Un nœud itérateur prend un tableau et renvoie itérativement ses éléments en sortie au nœud en aval. Les entrées du nœud itérateur sont traitées une par une et non en parallèle les unes avec les autres. 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
    }
}

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 de plus amples informations, veuillez consulter Créez et stockez des instructions réutilisables avec Prompt Management dans Amazon Bedrock.

Pour obtenir un exemple, consultez Commencez avec des exemples de flux de messages.

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 :

Un nœud d'agent vous permet d'envoyer une invite à un agent, qui orchestre les ressources associées entre FMs elles afin d'identifier et d'exécuter des actions pour un utilisateur final. Pour de plus amples informations, veuillez consulter Automatisez les tâches de votre application à l'aide d'agents conversationnels.

Dans la configuration, spécifiez le nom de ressource Amazon (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.

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 de plus amples informations, veuillez consulter Récupérez des données et générez des réponses basées sur l'IA avec des bases de connaissances.

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 URI 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": "s3Uri",
            "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.

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

{
    "name": "string",
    "type": "Retrieval",
    "inputs": [
        {
            "name": "objectKey",
            "type": "String",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "s3Content",
            "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. Lorsque vous incluez un nœud Lambda dans un flux d'invite, Amazon Bedrock envoie un événement d'entrée à la fonction Lambda que vous spécifiez.

Dans la configuration, spécifiez le nom de ressource Amazon (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 dans la 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"
        }
    }
}

Événement d'entrée Lambda pour un flux rapide

L'événement d'entrée envoyé à une fonction Lambda dans un nœud Lambda est au format suivant :

{
   "messageVersion": "1.0",
   "flow": {
        "flowArn": "string",
        "flowAliasArn": "string"
   },
   "node": {
        "name": "string",
        "nodeInputs": [
            {
               "name": "string",
               "type": "String | Number | Boolean | Object | Array",
               "expression": "string",
               "value": ...
            },
            ...
        ]
   }
}

Les champs de chaque entrée correspondent aux champs que vous spécifiez lors de la définition du nœud Lambda, tandis que la valeur du value champ est renseignée avec l'intégralité de l'entrée dans le nœud après avoir été résolue par l'expression. Par exemple, si la totalité de l'entrée du nœud est [1, 2, 3] et que l'expression l'est$.data[1], la valeur envoyée dans l'événement d'entrée à la fonction Lambda serait. 2

Pour plus d'informations sur les événements dans Lambda, consultez les concepts Lambda dans le AWS Lambda Guide du développeur.

Réponse Lambda pour un flux rapide

Lorsque vous écrivez une fonction Lambda, vous définissez la réponse renvoyée par celle-ci. Cette réponse est renvoyée à votre flux d'invite en tant que sortie du nœud Lambda.

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 le nom de ressource Amazon (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.

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