Types de nœuds pour votre flux

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

Voici la structure générale d’un objet FlowNode 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, la sortie est la réponse renvoyée après un clic sur Exécuter dans la fenêtre de test. Dans l’API, la sortie est renvoyée dans le champ content de l’flowOutputEvent de la réponse InvokeFlow. Un flux peut comporter plusieurs nœuds de sortie de flux.

Un flux peut comporter plusieurs nœuds de sortie de flux s’il compte plusieurs branches.

Voici la structure générale d’un objet FlowNode 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 conditionnelles

Pour définir une condition, vous devez faire référence à une entrée par son nom et la comparer à une valeur à l’aide de l’un des opérateurs relationnels suivants :

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

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

Dans l’API, vous définissez les éléments suivants dans le champ definition lorsque vous envoyez une demande CreateFlow ou UpdateFlow :

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 de flux renvoie le résultat final pour chaque entrée dans une réponse différente. Vous pouvez également recueillir les réponses itérées à l’aide d’un nœud collecteur en aval du nœud itérateur et les renvoyer sous forme de tableau, en sus de la taille du tableau.

Voici la structure générale d’un objet FlowNode itérateur :

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

Un nœud collecteur prend une entrée itérée, en sus de la taille du tableau, et les renvoie sous forme de tableau. Vous pouvez recueillir les éléments itérés à l’aide d’un nœud collecteur en aval d’un nœud itérateur après les avoir envoyés au moyen de certains nœuds.

Voici la structure générale d’un objet FlowNode collecteur :

{
    "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 de boucle DoWhile exécute une séquence de nœuds à plusieurs reprises tant qu’une condition spécifiée est remplie. La boucle s’exécute au moins une fois avant d’évaluer la condition, ce qui la rend idéale pour les scénarios dans lesquels vous devez effectuer une action, puis vérifier si elle doit être répétée en fonction du résultat.

Le nœud de boucle DoWhile prend les données d’entrée et les transmet dans le corps de la boucle. Après chaque itération, la condition est évaluée pour déterminer s’il convient de poursuivre la boucle ou d’y mettre fin. La boucle continue tant que la condition est remplie ou que le maxIterations n’est pas dépassé.

Voici la structure générale d’un objet FlowNode de boucle DoWhile :

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

Dans la configuration :

Un nœud d’invite définit une invite à utiliser dans le flux. Vous pouvez utiliser une invite de Prompt Management ou en définir une en ligne dans le nœud. Pour plus d’informations, consultez Création et stockage d’invites réutilisables avec la gestion des invites dans Amazon Bedrock.

Pour obtenir un exemple, consultez Test d’exemples de flux.

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 objet FlowNode 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),
            "guardrailConfiguration": {
                "guardrailIdentifier": "string",
                "guardrailVersion": "string"
            }
        }
    }
}

L’objet PromptFlowNodeSourceConfiguration varie selon que vous utilisez une invite de Prompt Management ou que vous en définissez une en ligne :

Pour appliquer une barrière de protection Amazon Bedrock à votre invite ou à la réponse générée depuis celui-ci, incluez le champ guardrailConfiguration et spécifiez l’identifiant ou l’ARN de la barrière de protection dans le champ guardrailIdentifier et la version de la barrière de protection dans le champ guardrailVersion.

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 Automatisation des tâches de votre application à l’aide d’agents d’IA.

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 pour l’agent et tout attribut d’invite ou de session associé. Le nœud renvoie la réponse de l’agent sous forme de sortie.

Un nœud d’agent peut prendre en charge les invocations à plusieurs tours, permettant ainsi des conversations interactives entre les utilisateurs et l’agent pendant l’exécution du flux. Lorsqu’un nœud d’agent a besoin d’informations ou de précisions supplémentaires, il peut suspendre l’exécution du flux et demander des entrées spécifiques à l’utilisateur. Une fois que l’utilisateur a fourni les informations demandées, le nœud d’agent poursuit son traitement avec la nouvelle entrée. Cela continue jusqu’à ce que le nœud d’agent dispose de toutes les informations requises pour terminer son exécution.

Voici la structure générale d’un objet FlowNode d’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 à partir d’Amazon Bedrock Knowledge Bases. Pour plus d’informations, consultez Récupération de données et génération de réponses basées sur l’IA avec Amazon Bedrock Knowledge Bases.

Dans la configuration, indiquez au minimum l’knowledgeBaseId. Vous pouvez éventuellement inclure les champs suivants en fonction de votre cas d’utilisation :

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 objet FlowNode de base de connaissances :

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

Un nœud de stockage S3 vous permet de stocker des données dans le flux vers un compartiment Amazon S3. Dans la configuration, vous spécifiez le compartiment S3 à utiliser pour le stockage de 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 objet FlowNode 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 sortie.

Voici la structure générale d’un objet FlowNode 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, Amazon Bedrock envoie un événement d’entrée à la fonction Lambda que vous spécifiez.

Dans la configuration, spécifiez l’Amazon Resource Name (ARN) de la fonction Lambda. Définissez les entrées à envoyer dans 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 objet FlowNode de fonction Lambda :

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

Événement d’entrée Lambda pour un flux

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",
        "inputs": [
            {
               "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 champ value 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 est $.data[1], la valeur envoyée dans l’événement d’entrée à la fonction Lambda est 2.

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

Réponse Lambda pour un flux

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 en tant que sortie du nœud Lambda.

Un nœud de code inline vous permet d’écrire et d’exécuter du code directement dans votre flux, ce qui permet des transformations de données, une logique personnalisée et des intégrations sans utiliser de fonction Lambda externe. Lorsque vous incluez un nœud de code inline dans votre flux, Amazon Bedrock exécute votre code dans un environnement AWS géré et isolé qui n’est partagé avec personne et qui n’a pas accès à Internet.

Dans la configuration du nœud, spécifiez le code à exécuter et le langage de programmation. (Python_3 est actuellement la seule option.) Définissez les entrées auxquelles votre code peut accéder en tant que variables. Le résultat de la dernière ligne exécutée de votre code est renvoyé en tant que sortie du nœud.

L’exemple suivant montre la structure générale d’un objet FlowNode de code inline :

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

Éléments à prendre en compte en cas d’utilisation de nœuds de code inline

Lorsque vous utilisez des nœuds de code inline dans votre flux, tenez compte des éléments suivants :

Entrées de nœud de code inline

Les entrées que vous définissez pour un nœud de code inline sont disponibles sous forme de variables Python dans votre code. Par exemple, si vous définissez une entrée nommée userData, vous pouvez y accéder directement dans votre code en tant que userData.

La valeur de chaque entrée est renseignée en fonction de l’expression que vous définissez. Par exemple, si l’entrée du nœud est {"name": "John", "age": 30} et que l’expression est $.name, la valeur de la variable d’entrée est "John".

Sortie de nœud de code inline

Le résultat de la dernière ligne exécutée de votre code est renvoyé en tant que nœud de code inline. Cette sortie est disponible pour les nœuds suivants de votre flux.

Par exemple, le code suivant renvoie un dictionnaire comme sortie du nœud :

# Process input data
result = {"processed": True, "data": userData}

# The last line's result is returned as the node output
result

Un nœud Lex vous permet d’appeler un bot Amazon Lex pour traiter un énoncé à l’aide du traitement du langage naturel et 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 attributs de session qui l’accompagnent. Le nœud renvoie l’intention identifiée en sortie.

Voici la structure générale d’un objet FlowNode 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"
        }
    }
}