Types de nœuds dans le flux - Amazon Bedrock
Nœuds pour contrôler la logique de fluxNœuds pour la gestion des données dans le fluxTableaux récapitulatifs pour les types de nœuds

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Types de nœuds dans le flux

Amazon Bedrock Flows fournit les types de nœuds suivants pour créer votre flux. 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 — Fournissez les informations suivantes pour chaque entrée :

  • Sorties — Fournissez les informations suivantes pour chaque sortie :

    • Nom — Nom de la 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.

    • Type — Type de données pour la sortie. Lorsque ce nœud est atteint lors de l'exécution, Amazon Bedrock vérifie que la sortie du nœud correspond au type de données.

  • 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

Utilisez les types de nœuds suivants pour contrôler la logique de 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 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 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.

Pour définir un nœud de condition

  1. Ajoutez autant d'entrées que nécessaire pour évaluer les conditions que vous prévoyez d'ajouter.

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

  3. Connectez chaque entrée à la sortie appropriée à partir d'un nœud en amont.

  4. Ajoutez autant de conditions que nécessaire.

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

  1. 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": {
        "condition": {
            "conditions": [
                {
                    "name": "string",
                    "expression": "string"
                },
                ...
            ]
        }
    }
}

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

  3. 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": "Conditional",
    "configuration": {
        "conditional": {
            "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. 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
    }
}

Nœuds pour la gestion des données dans le flux

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

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.

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

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,
                "topP": float
            }
        },
        "additionalModelRequestFields": {
            "key": "value",
            ...
        }
    }
}

Pour appliquer un garde-corps d'Amazon Bedrock Guardrails à votre demande ou à la réponse générée par celui-ci, incluez le guardrailConfiguration champ et spécifiez l'ID ou l'ARN du garde-corps dans le guardrailIdentifier champ et la version du garde-corps dans le champ. guardrailVersion

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

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 informations spécifiques à l'utilisateur. Une fois que l'utilisateur a fourni les informations demandées, le nœud Agent poursuit son traitement avec la nouvelle entrée. Cela continue jusqu'à ce que le nœud agent dispose de toutes les informations requises pour terminer son exécution.

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 à partir des bases de connaissances Amazon Bedrock. 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 les bases de connaissances Amazon Bedrock.

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

  • modelId— Incluez 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.

  • guardrailConfiguration— Incluez l'ID ou l'ARN du garde-corps, défini dans Amazon Bedrock Guardrails sur le guardrailIdentifier terrain et la version du garde-corps sur le terrain. guardrailVersion

    Note

    Les barrières de sécurité ne peuvent être appliquées que lors d'une utilisation RetrieveAndGenerate dans un nœud de base de connaissances.

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

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

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

Note

Le nœud Lex repose sur le service Amazon Lex, qui peut stocker et utiliser le contenu des clients pour le développement et l'amélioration continue d'autres AWS services. En tant que AWS client, vous pouvez refuser que votre contenu soit stocké ou utilisé pour améliorer le service. Pour savoir comment mettre en œuvre une politique de désinscription pour Amazon Lex, consultez les politiques de désinscription des services d'intelligence artificielle.

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 pour les types de nœuds

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

  • 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
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
La taille du tableau de sortie arraySize Nombre
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. s3Uri Chaîne
La clé d'objet à utiliser pour l'objet S3. objectKey Chaîne
Récupération S3 La clé d'objet pour l'objet S3 objectKey Chaîne Les données à récupérer à partir d'un compartiment S3. s3Content 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 avec l'énoncé. requestAttributes Objet
Tous les attributs de session à envoyer avec l'énoncé. sessionAttributes Objet