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.
# Comprendre les conversations avec les robots Amazon Lex V2
Après avoir créé un bot, vous intégrez votre application cliente aux opérations d'exécution Amazon Lex V2 pour tenir des conversations avec votre bot. Lorsqu'un utilisateur entame une conversation avec votre bot, Amazon Lex V2 crée une *session*. Une session encapsule les informations échangées entre votre application et le bot. Pour de plus amples informations, veuillez consulter [Comprendre les sessions de bot Amazon Lex V2](managing-sessions.md).
Une conversation typique implique un va-et-vient entre l'utilisateur et un bot. Par exemple :
```
User : I'd like to make an appointment
Bot : What type of appointment would you like to schedule?
User : dental
Bot : When should I schedule your dental appointment?
User : Tomorrow
Bot : At what time do you want to schedule the dental appointment on 2021-01-01?
User : 9 am
Bot : 09:00 is available, should I go ahead and book your appointment?
User : Yes
Bot : Thank you. Your appointment has been set successfully.
```
Utilisez les opérations de [RecognizeUtterance](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeUtterance.html)l'API [RecognizeText](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeText.html)or pour gérer vous-même les conversations. Utilisez l'opération [StartConversation](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_StartConversation.html)d'API pour laisser Amazon Lex V2 gérer la conversation à votre place.
Pour gérer la conversation, vous devez envoyer les énoncés de l'utilisateur au bot jusqu'à ce que la conversation atteigne une fin logique. La conversation en cours est capturée dans l'état de session. L'état de la session est mis à jour après chaque déclaration de l'utilisateur. L'état de session contient l'état actuel de la conversation et est renvoyé par le bot en réponse à chaque énoncé de l'utilisateur.
Une conversation peut avoir l'un des états suivants :
+ **ElicitIntent**— Indique que le bot n'a pas encore déterminé l'intention de l'utilisateur.
+ **ElicitSlot**— Indique que le bot a détecté l'intention de l'utilisateur et qu'il collecte les informations requises pour atteindre cette intention.
+ **ConfirmIntent**— Indique que le bot attend que l'utilisateur confirme que les informations collectées sont correctes.
+ **Fermé** : indique que l'intention de l'utilisateur est terminée et que la conversation avec le bot a atteint une fin logique.
Un utilisateur peut spécifier une nouvelle intention une fois la première intention terminée. Pour de plus amples informations, veuillez consulter [Contexte de conversation avec vos robots Lex V2](conversation-contexts.md).
Une intention peut avoir l'un des états suivants :
+ **InProgress**— Indique que le bot collecte les informations nécessaires pour réaliser l'intention. Ceci est associé à l'état de la `ElicitSlot` conversation.
+ **En attente** : indique que l'utilisateur a demandé au bot d'attendre lorsque celui-ci a demandé des informations pour un créneau spécifique.
+ **Exécuté — Indique que la logique métier d'une fonction Lambda associée à l'intention s'est exécutée** correctement.
+ **ReadyForFulfillment**— Indique que le bot a rassemblé toutes les informations nécessaires pour atteindre l'objectif et que l'application client peut exécuter la logique métier d'exécution.
+ **Échec** : indique qu'une intention a échoué.
Consultez les rubriques suivantes pour savoir comment utiliser Amazon Lex V2 APIs pour gérer le contexte des conversations et les sessions entre votre bot et les utilisateurs.
**Topics**
+ [Contexte de conversation avec vos robots Lex V2](conversation-contexts.md)
+ [Comprendre les sessions de bot Amazon Lex V2](managing-sessions.md)
# Contexte de conversation avec vos robots Lex V2
Le *contexte de conversation* est une information que l'utilisateur, votre application cliente ou une fonction Lambda fournit à un bot Amazon Lex V2 pour répondre à une intention. Le contexte de conversation inclut les données d'emplacement fournies par l'utilisateur, les attributs de demande définis par l'application cliente et les attributs de session créés par l'application client et les fonctions Lambda.
**Topics**
+ [Définition du contexte d'intention pour votre bot Lex V2](context-mgmt-active-context.md)
+ [Utilisation des valeurs d'emplacement par défaut dans les intentions de votre bot Lex V2](context-mgmt-default.md)
+ [Configuration des attributs de session pour votre bot Lex V2](context-mgmt-session-attribs.md)
+ [Configuration des attributs de demande pour votre bot Lex V2](context-mgmt-request-attribs.md)
+ [Réglage du délai d'expiration de la session](context-mgmt-session-timeout.md)
+ [Partage d'informations entre les intentions avec votre bot Lex V2](context-mgmt-cross-intent.md)
+ [Configuration d'attributs complexes dans votre bot Lex V2](context-mgmt-complex-attributes.md)
# Définition du contexte d'intention pour votre bot Lex V2
Amazon Lex V2 peut déclencher les intentions en fonction du *contexte*. Un *contexte* est une variable d'état qui peut être associée à une intention lorsque vous définissez un bot. Vous configurez les contextes d'une intention lorsque vous créez l'intention à l'aide de la console ou de l'[CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)opération. Vous ne pouvez utiliser le contexte que dans les paramètres régionaux anglais (États-Unis) (en-US).
Il existe deux types de relations pour les contextes, les contextes de sortie et les contextes d'entrée. Un *contexte de sortie* devient actif lorsqu'une intention associée est satisfaite. Un contexte de sortie est renvoyé à votre application dans la réponse de l'[RecognizeUtterance](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeUtterance.html)opération [RecognizeText](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeText.html)or, et il est défini pour la session en cours. Une fois qu'un contexte est activé, il reste actif pendant le nombre de tours ou la limite de temps configurés lors de la définition du contexte.
Un *contexte de saisie* définit les conditions dans lesquelles une intention peut être reconnue. Une intention ne peut être reconnue au cours d'une conversation que lorsque tous ses contextes de saisie sont actifs. Une intention sans contexte de saisie est toujours éligible à la reconnaissance.
Amazon Lex V2 gère automatiquement le cycle de vie des contextes activés en répondant aux intentions avec des contextes de sortie. Vous pouvez également définir des contextes actifs lors d'un appel à l'`RecognizeUtterance`opération `RecognizeText` or.
Vous pouvez également définir le contexte d'une conversation à l'aide de la fonction Lambda pour l'intention. Le contexte de sortie d'Amazon Lex V2 est envoyé à l'événement d'entrée de la fonction Lambda. La fonction Lambda peut envoyer des contextes dans sa réponse. Pour de plus amples informations, veuillez consulter [Intégration d'une AWS Lambda fonction dans votre bot Amazon Lex V2](lambda.md).
Supposons, par exemple, que vous ayez l'intention de réserver une voiture de location configurée pour renvoyer un contexte de sortie appelé « book\$1car\$1fulfilled ». Lorsque l'intention est satisfaite, Amazon Lex V2 définit la variable de contexte de sortie « book\$1car\$1fulfilled ». Puisque « book\$1car\$1fulfilled » est un contexte actif, une intention dont le contexte « book\$1car\$1fulfilled » est défini comme contexte d'entrée est désormais prise en compte pour reconnaissance, à condition qu'un énoncé de l'utilisateur soit reconnu comme une tentative de susciter cette intention. Vous pouvez l'utiliser à des fins qui n'ont de sens qu'après avoir réservé une voiture, par exemple en envoyant un reçu par e-mail ou en modifiant une réservation.
## Contexte de sortie des intentions pour votre bot Lex V2
Amazon Lex V2 active les contextes de sortie d'une intention lorsque l'intention est satisfaite. Vous pouvez utiliser le contexte de sortie pour contrôler les intentions éligibles au suivi de l'intention actuelle.
Chaque contexte possède une liste de paramètres qui sont conservés dans la session. Les paramètres sont les valeurs des créneaux correspondant à l'intention réalisée. Vous pouvez utiliser ces paramètres pour préremplir les valeurs des emplacements à d'autres fins. Pour plus d'informations, consultez[Utilisation des valeurs d'emplacement par défaut dans les intentions de votre bot Lex V2](context-mgmt-default.md).
Vous configurez le contexte de sortie lorsque vous créez une intention avec la console ou avec l'[CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)opération. Vous pouvez configurer une intention avec plusieurs contextes de sortie. Lorsque l'intention est remplie, tous les contextes de sortie sont activés et renvoyés dans la [RecognizeUtterance](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeUtterance.html)réponse [RecognizeText](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeText.html)or.
Lorsque vous définissez un contexte de sortie, vous définissez également sa *durée de vie*, la durée ou le nombre de tours pendant lesquels le contexte est inclus dans les réponses d'Amazon Lex V2. Un *tour correspond à* une demande envoyée par votre application à Amazon Lex V2. Une fois le nombre de tours ou le temps écoulé, le contexte n'est plus actif.
Votre application peut utiliser le contexte de sortie selon ses besoins. Par exemple, votre application peut utiliser le contexte de sortie pour :
+ Modifiez le comportement de l'application en fonction du contexte. Par exemple, une application de voyage peut avoir une action différente pour le contexte « book\$1car\$1fulfilled » et « rental\$1hotel\$1fulfilled ».
+ Renvoie le contexte de sortie à Amazon Lex V2 en tant que contexte d'entrée pour l'énoncé suivant. Si Amazon Lex V2 reconnaît que l'énoncé est une tentative de susciter une intention, il utilise le contexte pour limiter les intentions qui peuvent être renvoyées aux intentions correspondant au contexte spécifié.
## Entrez le contexte des intentions de votre bot Lex V2
Vous définissez un contexte de saisie pour limiter les points de la conversation où l'intention est reconnue. Les intentions sans contexte de saisie peuvent toujours être reconnues.
Vous définissez les contextes de saisie auxquels une intention répond à l'aide de la console ou de l'`CreateIntent`opération. Une intention peut avoir plusieurs contextes d'entrée.
Pour une intention comportant plusieurs contextes d'entrée, tous les contextes doivent être actifs pour déclencher l'intention. Vous pouvez définir un contexte de saisie lorsque vous appelez l'[PutSession](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_PutSession.html)opération [RecognizeText[RecognizeUtterance](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeUtterance.html)](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeText.html), ou.
Vous pouvez configurer les emplacements dans le but de prendre les valeurs par défaut du contexte actif actuel. Les valeurs par défaut sont utilisées lorsqu'Amazon Lex V2 reconnaît une nouvelle intention mais ne reçoit pas de valeur d'emplacement. Vous spécifiez le nom du contexte et le nom du slot dans le formulaire `#context-name.parameter-name` lorsque vous définissez le slot. Pour de plus amples informations, veuillez consulter [Utilisation des valeurs d'emplacement par défaut dans les intentions de votre bot Lex V2](context-mgmt-default.md).
# Utilisation des valeurs d'emplacement par défaut dans les intentions de votre bot Lex V2
Lorsque vous utilisez une valeur par défaut, vous spécifiez une source pour une valeur d'emplacement à remplir pour de nouvelles intentions lorsqu'aucun emplacement n'est fourni par l'entrée de l'utilisateur. Cette source peut être des attributs de dialogue, de demande ou de session antérieurs, ou une valeur fixe que vous avez définie au moment de la création.
Vous pouvez utiliser ce qui suit comme source pour vos valeurs par défaut.
+ Boîte de dialogue précédente (contextes) — \$1context -name.parameter-name
+ Attributs de session — [attribute-name]
+ Attributs de la demande —
+ Valeur fixe : toute valeur qui ne correspond pas à la valeur précédente
Lorsque vous utilisez l'[CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)opération pour ajouter des emplacements à une intention, vous pouvez ajouter une liste de valeurs par défaut. Les valeurs par défaut sont utilisées dans l'ordre dans lequel elles sont répertoriées. Supposons, par exemple, que vous ayez une intention avec un emplacement dont la définition est la suivante :
```
"slots": [
{
"botId": "string",
"defaultValueSpec": {
"defaultValueList": [
{
"defaultValue": "#book-car-fulfilled.startDate"
},
{
"defaultValue": "[reservationStartDate]"
}
]
},
Other slot configuration settings
}
]
```
Lorsque l'intention est reconnue, la valeur de l'emplacement nommé reservation-start-date « » est définie sur l'une des valeurs suivantes.
1. Si le contexte book-car-fulfilled « » est actif, la valeur du paramètre « StartDate » est utilisée comme valeur par défaut.
1. Si le contexte « book-car-fulfilled » n'est pas actif ou si le paramètre « StartDate » n'est pas défini, la valeur de l'attribut de session reservationStartDate « » est utilisée comme valeur par défaut.
1. Si aucune des deux premières valeurs par défaut n'est utilisée, l'emplacement n'a pas de valeur par défaut et Amazon Lex V2 recherchera une valeur comme d'habitude.
Si une valeur par défaut est utilisée pour l'emplacement, celui-ci n'est pas obtenu même s'il est requis.
# Configuration des attributs de session pour votre bot Lex V2
Les *attributs de session* contiennent des informations spécifiques à l'application qui sont transmises entre un bot et une application cliente au cours d'une session. Amazon Lex V2 transmet les attributs de session à toutes les fonctions Lambda configurées pour un bot. Si une fonction Lambda ajoute ou met à jour des attributs de session, Amazon Lex V2 transmet les nouvelles informations à l'application cliente.
Utilisez les attributs de session dans vos fonctions Lambda pour initialiser un bot et personnaliser les invites et les cartes de réponse. Par exemple :
+ Initialisation — Dans un robot de commande de pizzas, l'application client transmet l'emplacement de l'utilisateur comme attribut de session lors du premier appel à l'[RecognizeUtterance](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeUtterance.html)opération [RecognizeText](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeText.html)or. Par exemple, `"Location": "111 Maple Street"`. La fonction Lambda utilise ces informations pour trouver la pizzeria la plus proche pour passer la commande.
+ Personnaliser les invites : configurez les invites et les cartes de réponse pour faire référence aux attributs de session. Par exemple, « Hey [FirstName], quelles garnitures aimerais-tu ? » Si vous transmettez le prénom de l'utilisateur comme attribut de session (`{"FirstName": "Vivian"}`), Amazon Lex remplace l'espace réservé par le nom. Il envoie ensuite une demande personnalisée à l'utilisateur : « Hé Vivian, quelles garnitures aimerais-tu ? »
Les attributs de session sont conservés pendant toute la durée de la session. Amazon Lex V2 les stocke dans un magasin de données crypté jusqu'à la fin de la session. Le client peut créer des attributs de session dans une demande en appelant l'[RecognizeUtterance](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeUtterance.html)opération [RecognizeText](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeText.html)ou avec le `sessionAttributes` champ défini sur une valeur. Une fonction Lambda peut créer un attribut de session dans une réponse. Une fois que le client ou une fonction Lambda a créé un attribut de session, la valeur d'attribut stockée est utilisée chaque fois que l'application cliente n'inclut aucun `sessionAttribute` champ dans une demande adressée à Amazon Lex V2.
Par exemple, supposons que vous ayez deux attributs de session, `{"x": "1", "y": "2"}`. Si le client appelle l'`RecognizeUtterance`opération `RecognizeText` ou sans spécifier le `sessionAttributes` champ, Amazon Lex V2 appelle la fonction Lambda avec les attributs de session enregistrés ()`{"x": 1, "y": 2}`. Si la fonction Lambda ne renvoie pas les attributs de session, Amazon Lex V2 renvoie les attributs de session stockés à l'application cliente.
Si l'application cliente ou une fonction Lambda transmet les attributs de session, Amazon Lex V2 met à jour les attributs de session enregistrés. La transmission d'une valeur existante comme ` {"x": 2}` met à jour la valeur stockée. Si vous transmettez un nouvel ensemble d'attributs de session, par exemple `{"z": 3}`, les valeurs existantes sont supprimées et seule la nouvelle valeur est conservée. Lorsqu'une carte vide, `{}`, est transmise, les valeurs stockées sont effacées.
Pour envoyer des attributs de session à Amazon Lex V2, vous devez créer une string-to-string carte des attributs. L'exemple suivant montre comment mapper des attributs de session :
```
{
"attributeName": "attributeValue",
"attributeName": "attributeValue"
}
```
Pour l'`RecognizeText`opération, vous insérez la carte dans le corps de la demande à l'aide du `sessionAttributes` champ de la `sessionState` structure, comme suit :
```
"sessionState": {
"sessionAttributes": {
"attributeName": "attributeValue",
"attributeName": "attributeValue"
}
}
```
Pour l'`RecognizeUtterance`opération, vous encodez la carte en base64, puis vous l'envoyez dans le cadre de l'`x-amz-lex-session-state`en-tête.
Si vous envoyez des données structurées ou binaires dans un attribut de session, vous devez tout d'abord convertir les données en chaîne simple. Pour de plus amples informations, veuillez consulter [Configuration d'attributs complexes dans votre bot Lex V2](context-mgmt-complex-attributes.md).
# Configuration des attributs de demande pour votre bot Lex V2
Les *attributs de demandes* contiennent des informations spécifiques à la demande et s'appliquent uniquement à la demande en cours. Une application cliente envoie ces informations à Amazon Lex V2. Utilisez les attributs de demande pour transmettre des informations qui n'ont pas besoin de persister pendant la totalité de la session. Vous pouvez utiliser vos propres attributs de demandes ou des attributs prédéfinis. Pour envoyer des attributs de demandes, utilisez l'en-tête `x-amz-lex-request-attributes` dans [RecognizeUtterance](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeUtterance.html) ou le champ `requestAttributes` dans une demande [RecognizeText](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeText.html). Dans la mesure où les attributs de demandes ne sont pas conservés entre toutes les demandes (contrairement aux attributs de session), ils ne sont pas renvoyés dans les réponses `RecognizeUtterance` ou `RecognizeText`.
**Note**
Pour envoyer des informations qui persistent entre les demandes, utilisez des attributs de session.
## Définition des attributs de demande définis par l'utilisateur pour chaque demande de bot Lex V2
Un *attribut de demande défini par l'utilisateur* correspond à des données que vous envoyez au bot dans chaque demande. Vous envoyez les informations dans l'en-tête `amz-lex-request-attributes` d'une demande `RecognizeUtterance` ou dans le champ `requestAttributes` d'une demande `RecognizeText`.
Pour envoyer des attributs de demande à Amazon Lex V2, vous devez créer une string-to-string carte des attributs. L'exemple suivant montre comment mapper des attributs de demandes :
```
{
"attributeName": "attributeValue",
"attributeName": "attributeValue"
}
```
Pour l'opération `PostText`, vous insérez le mappage dans le corps de la requête en utilisant le champ `requestAttributes` comme suit :
```
"requestAttributes": {
"attributeName": "attributeValue",
"attributeName": "attributeValue"
}
```
Pour l'opération `PostContent`, vous codez le mappage en base64, puis l'envoyez en tant qu'en-tête `x-amz-lex-request-attributes`.
Si vous envoyez des données structurées ou binaires dans un attribut de demande, vous devez tout d'abord convertir les données en chaîne simple. Pour de plus amples informations, veuillez consulter [Configuration d'attributs complexes dans votre bot Lex V2](context-mgmt-complex-attributes.md).
Amazon Lex V2 fournit des attributs de demande prédéfinis pour gérer la manière dont il traite les informations envoyées à votre bot. Ces attributs ne sont pas stockés pendant toute la session, vous devez envoyer les attributs prédéfinis dans chaque demande. Tous les attributs prédéfinis sont dans l'espace de noms `x-amz-lex:`.
Outre les attributs prédéfinis suivants, Amazon Lex fournit des attributs prédéfinis pour les plateformes de messagerie. Pour obtenir la liste de ces attributs, consultez Déploiement d'un bot Amazon Lex sur une plateforme de messagerie.
## Définir le type de réponse
Si vous avez deux applications clientes dotées de fonctionnalités différentes, il se peut que vous ayez besoin de limiter le format des messages dans une réponse. Par exemple, vous pouvez limiter les messages envoyés à un client Web au texte brut, mais permettre à un client mobile d'utiliser à la fois du texte brut et du SSML (Speech Synthesis Markup Language). Pour définir le format des messages renvoyés par les `PostText` opérations `PostContent` et, utilisez l'attribut de demande x-amz-lex : accept-content-types ».
Vous pouvez définir l'attribut sur n'importe quelle combinaison des types de messages suivants :
+ `PlainText`— Le message contient du texte UTF-8 brut.
+ `SSML`— Le message contient du texte formaté pour la sortie vocale.
+ `CustomPayload`— Le message contient un format personnalisé que vous avez créé pour votre client. Vous pouvez définir la charge utile pour répondre aux besoins de votre application.
Amazon Lex V2 renvoie uniquement les messages dont le type est spécifié dans le champ Message de la réponse. Vous pouvez définir plusieurs valeurs en les séparant par une virgule. Si vous utilisez des groupes de messages, chaque groupe de messages doit contenir au moins un message du type spécifié. Dans le cas contraire, vous recevrez une erreur `NoUsableMessageException`. Pour plus d'informations, consultez la section Groupes de messages.
## Configuration d'attributs de demande prédéfinis dans votre bot Lex V2
Amazon Lex V2 fournit des attributs de demande prédéfinis pour gérer la manière dont il traite les informations envoyées à votre bot. Ces attributs ne sont pas stockés pendant toute la session, vous devez envoyer les attributs prédéfinis dans chaque demande. Tous les attributs prédéfinis sont dans l'espace de noms `x-amz-lex:`.
## Désactiver les commutateurs d'intention dans votre bot Lex V2
Pour contrôler si les utilisateurs peuvent passer d'une intention à l'autre lors de la confirmation de l'intention ou lors de l'obtention d'un créneau, utilisez l'`x-amz-lex:intent-switch`attribut request. Lorsqu'il est défini sur`DISABLE`, cet attribut empêche les utilisateurs de déclencher une intention différente alors qu'ils sont en train de terminer le flux d'intention actuel.
Par exemple, si un utilisateur est en train de réserver un vol et qu'il est invité à fournir les détails de son vol, les énoncés tels que « consulter la météo » ou « réserver un hôtel », qui peuvent normalement déclencher d'autres intentions, seront ignorés, afin que la conversation reste axée sur le processus de réservation en cours.
# Réglage du délai d'expiration de la session
Amazon Lex conserve les informations contextuelles (données de créneau et attributs de session) jusqu'à la fin d'une session de conversation. Pour contrôler la durée d'une session pour un bot, définissez le délai d'expiration de la session. Par défaut, la durée de la session est de 5 minutes, mais vous pouvez spécifier n'importe quelle durée comprise entre 0 et 1 440 minutes (24 heures).
Supposons que vous créiez un bot `ShoeOrdering` qui prend en charge des intentions comme `OrderShoes` et `GetOrderStatus`. Lorsqu'Amazon Lex détecte que l'intention de l'utilisateur est de commander des chaussures, il demande des informations sur les créneaux. Par exemple, il demande la pointure, la couleur, la marque, etc. Si l'utilisateur fournit certaines données relatives aux machines à sous mais ne termine pas l'achat de chaussures, Amazon Lex mémorise toutes les données des machines à sous et les attributs de session pendant toute la session. Si l'utilisateur revient à la session avant son expiration, il peut fournir les données de créneau restantes et terminer l'achat.
Dans la console Amazon Lex V2, vous définissez le délai d'expiration de session lorsque vous créez un bot. Avec l'interface de ligne de commande (CLI AWS) ou l'API AWS, vous définissez le délai d'expiration lorsque vous créez un bot avec l'[CreateBot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateBot.html)opération en définissant le champ [IdleSession TTLIn](https://docs.aws.amazon.com/lexv2/latest/dg/API_PutBot.html#API_CreateBot.html#lexv2-CreateBot-request-idleSessionTTLInSeconds) Seconds.
# Partage d'informations entre les intentions avec votre bot Lex V2
Amazon Lex V2 prend en charge le partage d'informations entre les intentions. Pour partager entre les intentions, utilisez des contextes de sortie ou des attributs de session.
Pour utiliser des contextes de sortie, vous devez définir un contexte de sortie lorsque vous créez ou mettez à jour une intention. Lorsque l'intention est satisfaite, les réponses d'Amazon Lex V2 contiennent le contexte et les valeurs d'intervalle issues de l'intention en tant que paramètres de contexte. Vous pouvez utiliser ces paramètres comme valeurs par défaut dans les instructions suivantes, dans le code de votre application ou dans les fonctions Lambda.
Pour utiliser les attributs de session, vous devez les définir dans votre code Lambda ou dans votre code d'application. Supposons qu'un utilisateur du bot `ShoeOrdering` commence par commander des chaussures. Le bot engage une conversation avec l'utilisateur, en collectant des données d'option telles que la pointure, la couleur et la marque. Lorsque l'utilisateur passe une commande, la fonction Lambda qui exécute la commande définit l'attribut de `orderNumber` session, qui contient le numéro de commande. Pour obtenir le statut de la commande, l'utilisateur utilise l'intention `GetOrderStatus`. Le bot peut demander à l'utilisateur des données d'option, comme le numéro et la date de commande. Lorsqu'il reçoit les informations requises, il renvoie le statut de la commande.
Si vous pensez que vos utilisateurs peuvent changer d'intention au cours de la même session, vous pouvez concevoir le bot pour qu'il renvoie le statut de la dernière commande. Au lieu de redemander à l'utilisateur des informations sur sa commande, vous utilisez l'attribut de session `orderNumber` pour partager les informations entre les intentions et traiter l'intention `GetOrderStatus`. Le bot effectue cette opération en renvoyant le statut de la dernière commande passée par l'utilisateur.
# Configuration d'attributs complexes dans votre bot Lex V2
Les attributs de session et de demande sont des string-to-string cartes d'attributs et de valeurs. Dans de nombreux cas, vous pouvez utiliser le mappage de chaînes pour transférer les valeurs d'attribut entre votre application cliente et un bot. Cependant, dans certains cas, vous devez transférer des données binaires ou une structure complexe qu'il n'est pas facile de convertir en mappage de chaînes. Par exemple, l'objet JSON suivant représente un tableau des trois villes les plus peuplées aux Etats-Unis :
```
{
"cities": [
{
"city": {
"name": "New York",
"state": "New York",
"pop": "8537673"
}
},
{
"city": {
"name": "Los Angeles",
"state": "California",
"pop": "3976322"
}
},
{
"city": {
"name": "Chicago",
"state": "Illinois",
"pop": "2704958"
}
}
]
}
```
Ce tableau de données ne se traduit pas bien en string-to-string carte. Dans ce cas, vous pouvez convertir un objet en chaîne simple pour pouvoir l'envoyer au bot avec les opérations [RecognizeText](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeText.html) et [RecognizeUtterance](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeUtterance.html).
Par exemple, si vous utilisez JavaScript, vous pouvez utiliser l'`JSON.stringify`opération pour convertir un objet en JSON et l'`JSON.parse`opération pour convertir du texte JSON en JavaScript objet :
```
// To convert an object to a string.
var jsonString = JSON.stringify(object, null, 2);
// To convert a string to an object.
var obj = JSON.parse(JSON string);
```
Pour envoyer des attributs avec cette `RecognizeUtterance` opération, vous devez encoder les attributs en base64 avant de les ajouter à l'en-tête de la demande, comme indiqué dans le code suivant : JavaScript
```
var encodedAttributes = new Buffer(attributeString).toString("base64");
```
Pour envoyer des données binaires aux opérations `RecognizeText` et `RecognizeUtterance`, convertissez d'abord les données en chaîne codée en base64, puis envoyez la chaîne en tant que valeur dans les attributs de session :
```
"sessionAttributes" : {
"binaryData": "base64 encoded data"
}
```
# Comprendre les sessions de bot Amazon Lex V2
Lorsqu'un utilisateur entame une conversation avec votre bot, Amazon Lex V2 crée une *session*. Les informations échangées entre votre application et Amazon Lex V2 constituent l'état de session de la conversation. Lorsque vous faites une demande, la session est identifiée par un identifiant que vous spécifiez. Pour plus d'informations sur l'identifiant de session, consultez le `sessionId` champ de l'[RecognizeUtterance](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeUtterance.html)opération [RecognizeText](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeText.html)or.
Vous pouvez modifier l'état de session envoyé entre votre application et votre bot. Par exemple, vous pouvez créer et modifier des attributs de session qui contiennent des informations personnalisées sur la session, et vous pouvez modifier le flux de la conversation en définissant le contexte de dialogue pour interpréter le prochain énoncé.
Vous pouvez mettre à jour l'état de la session de trois manières.
+ Transmettez les informations de session en ligne dans le cadre d'un appel à l'`RecognizeUtterance`opération `RecognizeText` or.
+ Utilisez une fonction Lambda avec l'`RecognizeUtterance`opération `RecognizeText` ou appelée après chaque tour de conversation. Pour de plus amples informations, veuillez consulter [Intégration d'une AWS Lambda fonction dans votre bot Amazon Lex V2](lambda.md). L'autre consiste à utiliser l'API d'exécution Amazon Lex V2 dans votre application pour modifier l'état de la session.
+ Utilisez des opérations qui vous permettent de gérer les informations de session pour une conversation avec votre bot. Il s'agit des opérations [PutSession](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_PutSession.html), [GetSession](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_GetSession.html) et [DeleteSession](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_DeleteSession.html). Vous utilisez ces opérations pour obtenir des informations sur l'état de session de votre utilisateur dans votre bot et avoir un contrôle précis sur l'état.
Utilisez l'opération `GetSession` lorsque vous souhaitez obtenir l'état actuel de la session. L'opération renvoie l'état actuel de la session, y compris l'état du dialogue avec votre utilisateur, tous les attributs de session définis et les valeurs d'intervalle correspondant à l'intention actuelle, ainsi que toute autre intention identifiée par Amazon Lex V2 comme pouvant correspondre à l'énoncé de l'utilisateur.
L'opération `PutSession` vous permet de manipuler directement l'état de session en cours. Vous pouvez définir la session, notamment le type d'action de dialogue que le bot exécutera ensuite et les messages qu'Amazon Lex V2 envoie à l'utilisateur. Cela vous permet de contrôler le flux de la conversation avec le bot. Définissez le `type` champ d'action de la boîte de dialogue `Delegate` pour qu'Amazon Lex V2 détermine l'action suivante pour le bot.
Vous pouvez utiliser l'opération `PutSession` pour créer une nouvelle session avec un bot et définir l'intention avec laquelle le bot doit démarrer. Vous pouvez également utiliser l'opération `PutSession` pour passer d'une intention à une autre. Lorsque vous créez une session ou modifiez l'intention, vous pouvez également définir un état de session, comme des valeurs d'options et des attributs de session. Lorsque la nouvelle intention est terminée, vous avez la possibilité de redémarrer l'intention précédente.
La réponse générée depuis l'opération `PutSession` contient les mêmes informations que l'opération `RecognizeUtterance`. Vous pouvez utiliser ces informations pour demander à l'utilisateur l'élément d'information suivant, comme vous le feriez avec la réponse de l'opération `RecognizeUtterance`.
Utilisez l'opération `DeleteSession` pour supprimer une session existante et démarrer avec une nouvelle session. Par exemple, lorsque vous testez le bot, vous pouvez utiliser l'opération `DeleteSession` pour supprimer des sessions de test de votre bot.
Les opérations de session fonctionnent avec vos fonctions Lambda d'exécution. Par exemple, si votre fonction Lambda renvoie l'état `Failed` d'exécution, vous pouvez utiliser l'`PutSession`opération pour définir le type d'action de dialogue `close` et pour `fulfillmentState` `ReadyForFulfillment` réessayer l'étape d'exécution.
Voici quelques actions que vous pouvez effectuer avec les opérations de session :
+ Demander au bot de démarrer une conversation au lieu d'attendre l'utilisateur.
+ Changer d'intention au cours d'une conversation.
+ Revenir à une intention précédente.
+ Démarrer ou redémarrer une conversation au milieu de l'interaction.
+ Valider des valeurs d'option et demander au bot d'entrer à nouveau des valeurs en cas de valeurs non valides.
Chacune de ces actions sont décrites plus en détail ci-dessous.
## Démarrer une nouvelle session
Si vous souhaitez que le bot démarre la conversation avec votre utilisateur, vous pouvez utiliser l'opération `PutSession`.
+ Créez une intention de bienvenue sans options et un message de conclusion qui invite l'utilisateur à indiquer une intention. Par exemple, « Que souhaitez-vous commander ? Vous pouvez dire « Commander une boisson » ou « Commander une pizza ». »
+ Appelez l’opération `PutSession`. Définissez nom de l'intention sur le nom de votre intention de bienvenue et définissez l'action de dialogue sur `Delegate`.
+ Amazon Lex répondra en vous demandant d'entamer la conversation avec votre utilisateur dans le cadre de votre message de bienvenue.
## Changer d'intention
Vous pouvez utiliser l'opération `PutSession` pour passer d'une intention à une autre. Vous pouvez également l'utiliser pour revenir à une intention précédente. Vous pouvez utiliser l'opération `PutSession` pour définir des attributs de session ou des valeurs d'option pour la nouvelle intention.
+ Appelez l’opération `PutSession`. Définissez le nom sur le nom de la nouvelle intention et définissez l'action de dialogue sur `Delegate`. Vous pouvez également définir les valeurs d'options ou les attributs de session requis pour la nouvelle intention.
+ Amazon Lex entamera une conversation avec l'utilisateur en utilisant la nouvelle intention.
## Reprise d'une intention antérieure
Pour reprendre une intention antérieure, vous utilisez l'`GetSession`opération pour obtenir l'état de l'intention, effectuer l'interaction nécessaire, puis utilisez l'`PutSession`opération pour remettre l'intention dans son état de dialogue précédent.
+ Appelez l’opération `GetSession`. Enregistrez l'état de l'intention.
+ Effectuez une autre interaction, par exemple en répondant à une intention différente.
+ À l'aide des informations enregistrées pour l'intention précédente, lancez l'`PutSession`opération. Cela renverra à l'utilisateur vers l'intention précédente au même endroit dans la conversation.
Dans certains cas, il peut être nécessaire de reprendre la conversation de votre utilisateur avec votre bot. Par exemple, imaginons que vous avez créé un bot de service client. Votre application détermine que l'utilisateur a besoin de parler à un représentant du service client. Après avoir parlé avec l'utilisateur, le représentant peut rediriger la conversation vers le bot avec les informations qu'il a collectées.
Pour reprendre une session, utilisez des étapes similaires aux étapes suivantes :
+ Votre application détermine que l'utilisateur a besoin de parler à un représentant du service client.
+ Utilisez l'opération `GetSession` pour obtenir l'état de dialogue actuel de l'intention.
+ Le représentant service client parle à l'utilisateur et résout le problème.
+ Utilisez l'opération `PutSession` pour définir l'état de dialogue de l'intention. Cela peut inclure la définition de valeurs d'option et d'attributs de session, ou la modification de l'intention.
+ Le bot reprend la conversation avec l'utilisateur.
## Validation des valeurs des créneaux
Vous pouvez valider les réponses adressées à votre bot à l'aide de votre application cliente. Si la réponse n'est pas valide, vous pouvez utiliser l'opération `PutSession` pour obtenir une nouvelle réponse de votre utilisateur. Par exemple, supposons que votre bot de commande de fleurs ne peut vendre que des tulipes, des roses et des lys. Si l'utilisateur commande des œillets, votre application peut effectuer les opérations suivantes :
+ Examiner la valeur d'option renvoyée à partir de la réponse `PostText` ou `PostContent`.
+ Si la valeur d'option n'est pas valide, appeler l'opération `PutSession`. Votre application doit effacer la valeur d'option, définir le champ `slotToElicit` et définir la valeur de `dialogAction.type` sur `elicitSlot`. Vous pouvez éventuellement définir les `messageFormat` champs `message` et si vous souhaitez modifier le message utilisé par Amazon Lex pour obtenir la valeur de l'emplacement.