Avis de fin de support : le 15 septembre 2025, le support pour Amazon Lex V1 AWS sera interrompu. Après le 15 septembre 2025, vous ne pourrez plus accéder à la console Amazon Lex V1 ni aux ressources Amazon Lex V1. Si vous utilisez Amazon Lex V2, consultez plutôt le [guide Amazon Lex V2](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html).
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.
# Réservez un voyage
Cet exemple illustre la création d'un bot configuré pour prendre en charge plusieurs intentions. L'exemple montre également comment utiliser des attributs de session pour le partage d'informations entre les intentions. Après avoir créé le bot, vous utilisez un client de test dans la console Amazon Lex pour tester le bot (BookTrip). Le client utilise l'opération [PostText](API_runtime_PostText.md) d'API d'exécution pour envoyer des demandes à Amazon Lex pour chaque entrée utilisateur.
Dans cet exemple, le BookTrip bot est configuré à deux fins (BookHotel et BookCar). Par exemple, supposons qu'un utilisateur réserve d'abord une chambre d'hôtel. Lors de l'interaction, l'utilisateur fournit des informations telles que les dates d'arrivée et de départ, l'emplacement, et le nombre de nuitées. Une fois l'intention traitée, le client peut conserver ces informations à l'aide d'attributs de session. Pour en savoir plus sur les attributs de session, consultez [PostText](API_runtime_PostText.md).
Maintenant, supposons que l'utilisateur continue pour réserver une voiture. À l'aide des informations fournies par l'utilisateur lors de l' BookHotel intention précédente (c'est-à-dire la ville de destination et les dates d'arrivée et de départ), le crochet de code (fonction Lambda) que vous avez configuré pour initialiser et valider l'intention initialise les données de créneau correspondant à BookCar l'intention (c'est-à-dire la destination, BookCar la ville de prise en charge, la date de prise en charge et la date de retour). Ceci illustre la façon dont le partage d'informations entre les intentions vous permet de créer des bots qui peuvent engager une conversation dynamique avec l'utilisateur.
Dans cet exemple, nous utilisons les attributs de session suivants. Seuls le client et la fonction Lambda peuvent définir et mettre à jour les attributs de session. Amazon Lex les transmet uniquement entre le client et la fonction Lambda. Amazon Lex ne gère ni ne modifie aucun attribut de session.
+ `currentReservation`— Contient les données des créneaux pour une réservation en cours et d'autres informations pertinentes. Par exemple, voici un exemple de demande du client vers Amazon Lex. Il affiche l'attribut de session `currentReservation` dans le corps de la demande.
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Chicago",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Moscow\",
\"RoomType\":null,
\"CheckInDate\":null,
\"Nights\":null}"
}
}
```
+ `lastConfirmedReservation`— Contient des informations similaires pour une intention antérieure, le cas échéant. Par exemple, si l'utilisateur a réservé un hôtel puis est en train de réserver une voiture, cet attribut de session stocke les données de créneau correspondant à l' BookHotel intention précédente.
+ `confirmationContext`— La fonction Lambda définit cette valeur `AutoPopulate` lorsqu'elle préremplit certaines données d'emplacement en fonction des données de créneau de la réservation précédente (le cas échéant). Ceci permet de partager des informations entre les intentions. Par exemple, si l'utilisateur a déjà réservé un hôtel et souhaite maintenant réserver une voiture, Amazon Lex peut l'inviter à confirmer (ou à refuser) que la voiture est réservée pour la même ville et aux mêmes dates que sa réservation d'hôtel.
Dans cet exercice, vous allez utiliser des plans pour créer un bot Amazon Lex et une fonction Lambda. Pour plus d'informations sur les modèles de présentation, consultez [Amazon Lex et AWS Lambda Blueprints](lex-lambda-blueprints.md).
**Étape suivante**
[Etape 1 : Vérification des modèles de présentation utilisés dans cet exercice](ex-book-trip-blueprints.md)
# Etape 1 : Vérification des modèles de présentation utilisés dans cet exercice
**Topics**
+ [Présentation du plan du bot () BookTrip](#ex-book-trip-bp-summary-bot)
+ [Présentation du plan directeur de la fonction Lambda () lex-book-trip-python](#ex-book-trip-summary-lambda)
## Présentation du plan du bot () BookTrip
Le modèle de présentation (**BookTrip**) que vous utilisez pour créer un bot fournit la pré-configuration suivante :
+ **Types d'option** – Deux types d'option personnalisée :
+ `RoomTypes` avec les valeurs d'énumération : `king`, `queen` et `deluxe`, pour une utilisation dans l'intention `BookHotel`.
+ `CarTypes` avec les valeurs d'énumération : `economy`, `standard`, `midsize`, `full size`, `luxury` et `minivan`, pour une utilisation dans l'intention `BookCar`.
+ **Intention 1 (BookHotel)** — Il est préconfiguré comme suit :
+ **Options préconfigurées**
+ `RoomType`, du type d'option personnalisée `RoomTypes`
+ `Location`, du type d'option prédéfinie `AMAZON.US_CITY`
+ `CheckInDate`, du type d'option prédéfinie `AMAZON.DATE`
+ `Nights`, du type d'option prédéfinie `AMAZON.NUMBER`
+ **Enoncés préconfigurés**
+ « Book a hotel »
+ « I want to make hotel reservations »
+ « Book a \$1Nights\$1 stay in \$1Location\$1 »
Si l'utilisateur prononce l'une de ces phrases, Amazon Lex détermine son intention, puis l'invite à saisir les données des créneaux. `BookHotel`
+ **Invites préconfigurées**
+ Invite de l'option `Location` – « What city will you be staying in? »
+ Invite de l'option `CheckInDate` – « What day do you want to check in? »
+ Invite de l'option `Nights` – « How many nights will you be staying? »
+ Invite de l'option `RoomType` – « What type of room would you like, queen, king, or deluxe? »
+ Déclaration de confirmation — « OK, je vous ai réservé un séjour de \$1nuits\$1 nuits à \$1Location\$1 à partir de \$1CheckInDate\$1. Shall I book the reservation? »
+ Refus – « Okay, I have cancelled your reservation in progress. »
+ **Intention 2 (BookCar)** — Il est préconfiguré comme suit :
+ **Options préconfigurées**
+ `PickUpCity`, du type d'option prédéfinie `AMAZON.US_CITY`.
+ `PickUpDate`, du type d'option prédéfinie `AMAZON.DATE`.
+ `ReturnDate`, du type d'option prédéfinie `AMAZON.DATE`.
+ `DriverAge`, du type d'option prédéfinie `AMAZON.NUMBER`.
+ `CarType`, du type d'option personnalisée `CarTypes`
+ **Enoncés préconfigurés**
+ « Book a car »
+ « Reserve a car »
+ « Make a car reservation »
Si l'utilisateur prononce l'une de ces phrases, Amazon Lex détermine BookCar son intention, puis l'invite à saisir les données des créneaux.
+ **Invites préconfigurées**
+ Invite de l'option `PickUpCity` – « In what city do you need to rent a car? »
+ Invite de l'option `PickUpDate` – « What day do you want to start your rental? »
+ Invite de l'option `ReturnDate` – « What day do you want to return this car? »
+ Invite de l'option `DriverAge` – « How old is the driver for this rental? »
+ Demandez le `CarType` créneau — « Quel type de voiture souhaitez-vous louer ? Our most popular options are economy, midsize, and luxury »
+ Déclaration de confirmation — « OK, je vous ai réservé une \$1CarType\$1 location à \$1PickUpCity\$1 entre \$1PickUpDate\$1 et \$1ReturnDate\$1. Should I book the reservation? »
+ Refus – « Okay, I have cancelled your reservation in progress. »
## Présentation du plan directeur de la fonction Lambda () lex-book-trip-python
Outre le plan du bot, AWS Lambda fournit un plan (**lex-book-trip-python**) que vous pouvez utiliser comme crochet de code avec le plan du bot. Pour obtenir la liste des plans de bot et des plans de fonction Lambda correspondants, consultez. [Amazon Lex et AWS Lambda Blueprints](lex-lambda-blueprints.md)
Lorsque vous créez un bot à l'aide du BookTrip plan, vous mettez à jour la configuration des intentions (BookCar et BookHotel) en ajoutant cette fonction Lambda en tant que crochet de code pour la saisie initialization/validation des données utilisateur et la réalisation des intentions.
Ce code de fonction Lambda a fourni une illustration d'une conversation dynamique en utilisant des informations déjà connues (conservées dans des attributs de session) sur un utilisateur afin d'initialiser des valeurs d'option pour une intention. Pour de plus amples informations, veuillez consulter [Gestion du contexte de conversation](context-mgmt.md).
**Étape suivante**
[Étape 2 : créer un robot Amazon Lex](ex-book-trip-create-bot.md)
# Étape 2 : créer un robot Amazon Lex
Dans cette section, vous allez créer un robot Amazon Lex (BookTrip).
1. Connectez-vous à la console Amazon Lex AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Sur la page **Bots**, choisissez **Créer**.
1. Sur la page **Create your Lex bot**,
+ Choisissez un modèle **BookTrip**.
+ Laissez le nom du bot par défaut (BookTrip).
1. Choisissez **Créer**. La console envoie une série de demandes à Amazon Lex pour créer le bot. Notez ce qui suit :
1. La console affiche le BookTrip bot. Dans l'onglet **Éditeur**, passez en revue les détails des intentions (BookCar et BookHotel) préconfigurées.
1. Testez le bot dans la fenêtre de test. Utilisez les éléments suivants pour engager une conversation test avec le bot :
![\[Conversation avec un agent, au cours de laquelle celui-ci indique la ville, le jour, le nombre de nuits et le type de chambre pour le voyage du client. L'agent confirme ensuite la réservation.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-trip-no-lambda-10.png)
À partir de la saisie initiale de l'utilisateur (« Réserver un hôtel »), Amazon Lex en déduit l'intention (BookHotel). Le bot utilise ensuite les invites préconfigurées dans cette intention pour obtenir des données d'option auprès de l'utilisateur. Une fois que l'utilisateur a fourni toutes les données d'emplacement, Amazon Lex renvoie une réponse au client avec un message qui inclut toutes les entrées de l'utilisateur sous forme de message. Le client affiche le message dans la réponse comme illustré.
```
CheckInDate:2016-12-18 Location:Chicago Nights:5 RoomType:queen
```
Vous poursuivez maintenant la conversation et essayez de réserver une voiture dans la conversation suivante.
![\[Conversation avec un agent, au cours de laquelle l'agent demande la ville, le jour de départ, le jour de retour, l'âge du conducteur et le type de voiture, pour la location de voiture du client. L'agent confirme ensuite la réservation.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-trip-no-lambda-20.png)
Remarque :
+ Aucune validation de données utilisateur n'a lieu pour l'instant. Par exemple, vous pouvez fournir n'importe quelle ville pour réserver une chambre d'hôtel.
+ Vous fournissez de nouveau certaines des mêmes informations (destination, ville de récupération, date de récupération et date de retour) pour réserver une voiture. Dans une conversation dynamique, votre bot doit initialiser certaines de ces informations en fonction des entrées utilisateur précédentes fournies pour réserver une chambre d'hôtel.
Dans la section suivante, vous allez créer une fonction Lambda pour effectuer certaines opérations de validation de données utilisateur et d'initialisation à l'aide du partage des informations entre les intentions via des attributs de session. Ensuite, vous mettez à jour la configuration de l'intention en ajoutant la fonction Lambda en tant que crochet de code pour effectuer les saisies par initialization/validation l'utilisateur et répondre à l'intention.
**Étape suivante**
[Étape 3 : Création d'une fonction Lambda](ex-book-trip-create-lambda-function.md)
# Étape 3 : Création d'une fonction Lambda
Dans cette section, vous créez une fonction Lambda à l'aide d'un blueprint (**lex-book-trip-python**) fourni dans la console. AWS Lambda Vous testez également la fonction Lambda en l'invoquant à l'aide d'exemples de données d'événement fournis par la console.
Cette fonction Lambda est écrite en Python.
1. Connectez-vous à la AWS Lambda console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Sélectionnez **Créer une fonction**.
1. Choisissez **Utiliser un plan**. Tapez **lex** pour trouver le plan, choisissez le plan `lex-book-trip-python`.
1. Choisissez **Configurer** la fonction Lambda comme suit.
+ Entrez le nom d'une fonction Lambda ()`BookTripCodeHook`.
+ Pour le rôle, choisissez **Create a new role from template(s)** et tapez un nom de rôle.
+ Laissez les autres valeurs par défaut.
1. Sélectionnez **Create function** (Créer une fonction).
1. Si vous utilisez une langue autre que l'anglais (États-Unis) (en-US), mettez à jour les noms d'intention comme décrit dans[Mettre à jour un plan pour un environnement régional spécifique](lex-lambda-blueprints.md#blueprint-update-locale).
1. Testez la fonction Lambda. Vous appelez la fonction Lambda deux fois, en utilisant des exemples de données pour la réservation d'une voiture et pour la réservation d'un hôtel.
1. Choisissez **Configure test event (Configurer un événement de test)** dans la liste déroulante **Select a test event (Sélectionner un événement de test)**.
1. Choisissez **Amazon Lex-Book Hotel** dans la liste **Sample event template (Exemple de modèle d’événement)**.
Cet exemple d'événement correspond au request/response modèle Amazon Lex. Pour de plus amples informations, veuillez consulter [Utilisation des fonctions Lambda](using-lambda.md).
1. Choisissez **Save and test**.
1. Vérifiez que la fonction Lambda s'est correctement exécutée. Dans ce cas, la réponse correspond au modèle de réponse Amazon Lex.
1. Répétez l'étape. Cette fois, choisissez **Amazon Lex-Book Car** dans la liste **Sample event template (Exemple de modèle d’événement)**. La fonction Lambda traite la réservation du véhicule.
**Étape suivante**
[Étape 4 : Ajouter la fonction Lambda en tant que crochet de code](ex-book-trip-create-integrate.md)
# Étape 4 : Ajouter la fonction Lambda en tant que crochet de code
Dans cette section, vous allez mettre à jour les configurations des objectifs BookCar et des BookHotel intentions en ajoutant la fonction Lambda en tant que code hook initialization/validation pour les activités d'exécution et d'exécution. Assurez-vous de choisir la version \$1LATEST des intentions, car vous ne pouvez mettre à jour que la version \$1LATEST de vos ressources Amazon Lex.
1. Dans la console Amazon Lex, choisissez le **BookTrip**bot.
1. Dans l'onglet **Éditeur**, choisissez l'**BookHotel**intention. Mettez à jour la configuration de l'intention comme suit :
1. Assurez-vous que la version de l'intention (en regard du nom de l'intention) est \$1LATEST.
1. Ajoutez la fonction Lambda en tant que crochet de code d'initialisation et de validation comme suit :
+ Dans **Options**, choisissez **Initialization and validation code hook**.
+ Choisissez votre fonction Lambda dans la liste.
1. Ajoutez la fonction Lambda en tant que crochet de code d'expédition comme suit :
+ Dans **Fulfillment**, choisissez fonction **AWS Lambda function**.
+ Choisissez votre fonction Lambda dans la liste.
+ Choisissez **Goodbye message** et entrez un message.
1. Choisissez **Enregistrer**.
1. Dans l'onglet **Éditeur**, choisissez l' BookCar intention. Suivez l'étape précédente pour ajouter votre fonction Lambda en tant que hook de code de validation et d'exécution.
1. Sélectionnez **Créer**. La console envoie une série de demandes à Amazon Lex pour enregistrer les configurations.
1. Testez le bot. Maintenant que vous disposez d'une fonction Lambda chargée de l'initialisation, de la validation des données utilisateur et de leur exécution, vous pouvez constater la différence dans l'interaction utilisateur dans la conversation suivante :
![\[Conversation avec un agent, au cours de laquelle celui-ci demande la ville, le jour, le nombre de nuits et le type de chambre pour une réservation de voyage, puis confirme la réservation.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-trip-with-lambda-30.png)
Pour plus d'informations sur le flux de données du client (console) vers Amazon Lex, et d'Amazon Lex vers la fonction Lambda, consultez. [Flux de données : intention Book Hotel](book-trip-detail-flow.md#data-flow-book-hotel)
1. Poursuivez la conversation et réservez une voiture comme indiqué dans l'image suivante :
![\[Conversation avec un agent, au cours de laquelle l'agent demande l'âge du conducteur et le type de voiture, puis confirme la réservation du véhicule.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-trip-with-lambda-40.png)
Lorsque vous choisissez de réserver une voiture, le client (console) envoie une demande à Amazon Lex qui inclut les attributs de session (issus de la conversation précédente BookHotel). Amazon Lex transmet ces informations à la fonction Lambda, qui initialise ensuite (c'est-à-dire qu'elle préremplit) certaines des données d' BookCar emplacement (c'est-à-dire, PickUpDate et). ReturnDate PickUpCity
**Note**
Ceci illustre la façon dont les attributs de session peuvent être utilisés pour conserver le contexte entre les intentions. Le client de la console fournit dans la fenêtre de test le lien **Effacer** qui permet d'effacer tous les attributs de session précédents.
Pour plus d'informations sur le flux de données du client (console) vers Amazon Lex, et d'Amazon Lex vers la fonction Lambda, consultez. [Flux de données : intention BookCar](book-trip-detail-flow.md#data-flow-book-car)
# Détails du flux d'informations
Dans cet exercice, vous avez engagé une conversation avec le BookTrip bot Amazon Lex à l'aide du client de fenêtre de test fourni dans la console Amazon Lex. Cette section décrit les éléments suivants :
+ Le flux de données entre le client et Amazon Lex.
La section part du principe que le client envoie des demandes à Amazon Lex à l'aide de l'API `PostText` d'exécution et affiche les détails des demandes et des réponses en conséquence. Pour plus d'informations sur l'API d'exécution `PostText`, consultez [PostText](API_runtime_PostText.md).
**Note**
Pour un exemple du flux d'informations entre le client et Amazon Lex dans lequel le client utilise l'`PostContent`API, consultez[Étape 2a (facultatif) : Vérification des détails du flux d'informations vocales (console)](gs-bp-details-postcontent-flow.md).
+ Le flux de données entre Amazon Lex et la fonction Lambda. Pour de plus amples informations, veuillez consulter [Format d'événement et de réponse d'entrée de la fonction Lambda](lambda-input-response-format.md).
**Topics**
+ [Flux de données : intention Book Hotel](#data-flow-book-hotel)
+ [Flux de données : intention BookCar](#data-flow-book-car)
## Flux de données : intention Book Hotel
Cette section explique ce qui se passe après chaque entrée utilisateur.
1. Utilisateur : « book a hotel »
1. Le client (console) envoie la demande [PostText](API_runtime_PostText.md) suivante à Amazon Lex :
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"book a hotel",
"sessionAttributes":{}
}
```
L'URI et le corps de la demande fournissent des informations à Amazon Lex :
+ URI de demande — Fournit le nom du bot (BookTrip), l'alias du bot (\$1LATEST) et le nom d'utilisateur. Le code `text` de fin indique qu'il s'agit d'une demande d'API `PostText` (et non `PostContent`).
+ Corps de la demande – Inclut l'entrée utilisateur (`inputText`) et un champ `sessionAttributes` vide. Au départ, il s'agit d'un objet vide et la fonction Lambda définit d'abord les attributs de session.
1. À partir du`inputText`, Amazon Lex détecte l'intention (BookHotel). Cette intention est configurée avec une fonction Lambda en tant que crochet de code pour l'initialisation/validation des données utilisateur. Amazon Lex invoque donc cette fonction Lambda en transmettant les informations suivantes comme paramètre d'événement ([Format d'un événement d'entrée](lambda-input-response-format.md#using-lambda-input-event-format)voir) :
```
{
"messageVersion":"1.0",
"invocationSource":"DialogCodeHook",
"userId":"wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes":{
},
"bot":{
"name":"BookTrip",
"alias":null,
"version":"$LATEST"
},
"outputDialogMode":"Text",
"currentIntent":{
"name":"BookHotel",
"slots":{
"RoomType":null,
"CheckInDate":null,
"Nights":null,
"Location":null
},
"confirmationStatus":"None"
}
}
```
Outre les informations envoyées par le client, Amazon Lex inclut également les données supplémentaires suivantes :
+ `messageVersion`— Actuellement, Amazon Lex ne prend en charge que la version 1.0.
+ `invocationSource`— Indique l'objectif de l'appel de la fonction Lambda. Dans ce cas, il s'agit d'effectuer l'initialisation et la validation des données utilisateur (pour le moment, Amazon Lex sait que l'utilisateur n'a pas fourni toutes les données d'emplacement conformément à son intention).
+ `currentIntent` – Toutes les valeurs d'option sont définies sur null.
1. Pour l'instant, toutes les valeurs d'option sont null. La fonction Lambda n'a rien à valider. La fonction Lambda renvoie la réponse suivante à Amazon Lex. Pour plus d'informations sur le format de réponse, consultez [Format de la réponse](lambda-input-response-format.md#using-lambda-response-format).
```
{
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",\"Location\":null,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"dialogAction":{
"type":"Delegate",
"slots":{
"RoomType":null,
"CheckInDate":null,
"Nights":null,
"Location":null
}
}
}
```
**Note**
`currentReservation`— La fonction Lambda inclut cet attribut de session. Sa valeur est une copie des informations d'option actuelles et du type de réservation.
Seuls la fonction Lambda et le client peuvent mettre à jour ces attributs de session. Amazon Lex transmet simplement ces valeurs.
`dialogAction.type`— En définissant cette valeur sur`Delegate`, la fonction Lambda délègue la responsabilité de la prochaine action à Amazon Lex.
Si la fonction Lambda détecte quoi que ce soit lors de la validation des données utilisateur, elle indique à Amazon Lex la marche à suivre.
1. Conformément au`dialogAction.type`, Amazon Lex décide de la marche à suivre : obtenir des données auprès de l'utilisateur pour le slot. `Location` Il sélectionne l'un des messages d'invite (« What city will you be staying in? ») pour cette option, selon la configuration d'intention, puis envoie la réponse suivante à l'utilisateur :
![\[Réponse JSON contenant l'état du dialogue, le nom de l'intention, le message, la carte de réponse, les attributs de session, l'emplacement à obtenir et les emplacements.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-hotel-10.png)
Les attributs de session sont transmis au client.
Le client lit la réponse, puis affiche le message : « What city will you be staying in? »
1. Utilisateur : « Moscow »
1. Le client envoie la `PostText` demande suivante à Amazon Lex (des sauts de ligne ont été ajoutés pour des raisons de lisibilité) :
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Moscow",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":null,
\"RoomType\":null,
\"CheckInDate\":null,
\"Nights\":null}"
}
}
```
En plus de `inputText`, le client inclut les mêmes attributs de session `currentReservation` que ceux qu'il a reçus.
1. Amazon Lex interprète d'abord le `inputText` dans le contexte de l'intention actuelle (le service se souvient qu'il avait demandé à l'utilisateur concerné des informations sur le `Location` slot). Il met à jour la valeur du slot en fonction de l'intention actuelle et appelle la fonction Lambda à l'aide de l'événement suivant :
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":null,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookHotel",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": "Moscow"
},
"confirmationStatus": "None"
}
}
```
**Note**
`invocationSource` continue d'être `DialogCodeHook`. Dans cette étape, nous validons seulement les données utilisateur.
Amazon Lex transmet simplement l'attribut de session à la fonction Lambda.
En effet`currentIntent.slots`, Amazon Lex a mis à jour l'`Location`emplacement en`Moscow`.
1. La fonction Lambda effectue la validation des données utilisateur et détermine qu'il s'`Moscow`agit d'un emplacement non valide.
**Note**
Dans cet exercice, la fonction Lambda contient une simple liste de villes valides et ne `Moscow` figure pas sur cette liste. Dans une application de production, vous pouvez utiliser une base de données principale pour obtenir ces informations.
Il rétablit la valeur de l'emplacement à zéro et demande à Amazon Lex de demander à nouveau à l'utilisateur une autre valeur en envoyant la réponse suivante :
```
{
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Moscow\",\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"dialogAction": {
"type": "ElicitSlot",
"intentName": "BookHotel",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": null
},
"slotToElicit": "Location",
"message": {
"contentType": "PlainText",
"content": "We currently do not support Moscow as a valid destination. Can you try a different city?"
}
}
}
```
**Note**
`currentIntent.slots.Location` est réinitialisé à null.
`dialogAction.type`est défini sur`ElicitSlot`, ce qui demande à Amazon Lex d'inviter à nouveau l'utilisateur en fournissant les informations suivantes :
`dialogAction.slotToElicit` – option pour laquelle obtenir des données auprès de l'utilisateur.
`dialogAction.message` – `message` à transmettre à l'utilisateur.
1. Amazon Lex remarque `dialogAction.type` et transmet les informations au client dans la réponse suivante :
![\[Réponse JSON contenant l'état du dialogue, le nom de l'intention, le message, la carte de réponse, les attributs de session, l'emplacement à obtenir et les emplacements.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-hotel-20.png)
Le client affiche simplement le message : « We currently do not support Moscow as a valid destination. Can you try a different city? »
1. Utilisateur : « Chicago »
1. Le client envoie la `PostText` demande suivante à Amazon Lex :
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Chicago",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Moscow\",
\"RoomType\":null,
\"CheckInDate\":null,
\"Nights\":null}"
}
}
```
1. Amazon Lex connaît le contexte et sait qu'il s'agissait d'obtenir des données pour le `Location` slot. Dans ce contexte, il sait que la valeur `inputText` est pour l'option `Location`. Il invoque ensuite la fonction Lambda en envoyant l'événement suivant :
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":Moscow,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookHotel",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": "Chicago"
},
"confirmationStatus": "None"
}
}
```
Amazon Lex a mis à jour le `currentIntent.slots` en configurant l'`Location`emplacement sur`Chicago`.
1. Selon la `invocationSource` valeur de`DialogCodeHook`, la fonction Lambda effectue la validation des données utilisateur. Il reconnaît `Chicago` comme une valeur d'emplacement valide, met à jour l'attribut de session en conséquence, puis renvoie la réponse suivante à Amazon Lex.
```
{
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"dialogAction": {
"type": "Delegate",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": "Chicago"
}
}
}
```
**Note**
`currentReservation`— La fonction Lambda met à jour cet attribut de session en définissant la `Location` valeur sur. `Chicago`
`dialogAction.type` – Est défini sur `Delegate`. Les données utilisateur étaient valides et la fonction Lambda indique à Amazon Lex de choisir le plan d'action suivant.
1. Selon`dialogAction.type`, Amazon Lex choisit la prochaine ligne de conduite. Amazon Lex sait qu'il a besoin de plus de données d'emplacement et choisit le prochain emplacement vide (`CheckInDate`) ayant la priorité la plus élevée en fonction de la configuration prévue. Il sélectionne l'un des messages d'invite (« What day do you want to check in? ») pour cette option, selon la configuration d'intention, puis renvoie la réponse suivante au client :
![\[Réponse JSON contenant l'état du dialogue, le nom de l'intention, le message, la carte de réponse, les attributs de session, l'emplacement à obtenir et les emplacements. Le créneau de localisation est désormais rempli en tant que Chicago.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-hotel-30.png)
Le client affiche le message : « What day do you want to check in? »
1. L'interaction de l'utilisateur se poursuit : l'utilisateur fournit des données, la fonction Lambda valide les données, puis délègue le plan d'action suivant à Amazon Lex. Finalement, l'utilisateur fournit toutes les données d'emplacement, la fonction Lambda valide toutes les entrées de l'utilisateur, puis Amazon Lex reconnaît qu'il possède toutes les données d'emplacement.
**Note**
Dans cet exercice, une fois que l'utilisateur a fourni toutes les données relatives aux créneaux, la fonction Lambda calcule le prix de la réservation d'hôtel et le renvoie sous la forme d'un autre attribut de session (). `currentReservationPrice`
À ce stade, l'intention est prête à être réalisée, mais elle est configurée avec une invite de confirmation demandant la confirmation de l'utilisateur avant qu'Amazon Lex puisse réaliser l'intention. BookHotel Amazon Lex envoie donc le message suivant au client pour lui demander une confirmation avant de réserver l'hôtel :
![\[Réponse JSON contenant l'état du dialogue, le nom de l'intention, le message, la carte de réponse, les attributs de session, l'emplacement à obtenir et les emplacements. Tous les emplacements sont désormais pourvus.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-hotel-40.png)
Le client affiche le message : « Okay, I have you down for a 5 night in Chicago starting 2016-12-18. Shall I book the reservation? »
1. Utilisateur : « yes »
1. Le client envoie la `PostText` demande suivante à Amazon Lex :
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Yes",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Chicago\",
\"RoomType\":\"queen\",
\"CheckInDate\":\"2016-12-18\",
\"Nights\":\"5\"}",
"currentReservationPrice":"1195"
}
}
```
1. Amazon Lex interprète le `inputText` dans le contexte de la confirmation de l'intention actuelle. Amazon Lex comprend que l'utilisateur souhaite procéder à la réservation. Cette fois, Amazon Lex invoque la fonction Lambda pour répondre à l'intention en envoyant l'événement suivant. En définissant le `invocationSource` to `FulfillmentCodeHook` dans l'événement, il envoie à la fonction Lambda. Amazon Lex définit également la valeur `confirmationStatus` à`Confirmed`.
```
{
"messageVersion": "1.0",
"invocationSource": "FulfillmentCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}",
"currentReservationPrice": "956"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookHotel",
"slots": {
"RoomType": "queen",
"CheckInDate": "2016-12-18",
"Nights": "5",
"Location": "Chicago"
},
"confirmationStatus": "Confirmed"
}
}
```
**Note**
`invocationSource`— Cette fois, Amazon Lex a défini cette valeur sur`FulfillmentCodeHook`, demandant à la fonction Lambda de répondre à l'intention.
`confirmationStatus` – Est défini sur `Confirmed`.
1. Cette fois, la fonction Lambda répond à l' BookHotel intention, Amazon Lex effectue la réservation, puis renvoie la réponse suivante :
```
{
"sessionAttributes": {
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"dialogAction": {
"type": "Close",
"fulfillmentState": "Fulfilled",
"message": {
"contentType": "PlainText",
"content": "Thanks, I have placed your reservation. Please let me know if you would like to book a car rental, or another hotel."
}
}
}
```
**Note**
`lastConfirmedReservation`— Il s'agit d'un nouvel attribut de session ajouté par la fonction Lambda (au lieu de`currentReservation`,`currentReservationPrice`).
`dialogAction.type`— La fonction Lambda définit cette valeur sur`Close`, indiquant qu'Amazon Lex ne s'attend pas à une réponse de l'utilisateur.
`dialogAction.fulfillmentState` – Est défini sur `Fulfilled` et inclut un `message` approprié à transmettre à l'utilisateur.
1. Amazon Lex examine le `fulfillmentState` et envoie la réponse suivante au client :
![\[Réponse JSON contenant l'état du dialogue, le nom de l'intention, le message, la carte de réponse, les attributs de session, l'emplacement à obtenir et les emplacements. Tous les créneaux sont remplis et un champ de dernière réservation confirmée sous les attributs de session est maintenant rempli.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-hotel-60.png)
**Note**
`dialogState`— Amazon Lex définit cette valeur sur`Fulfilled`.
`message`— C'est le même message que celui fourni par la fonction Lambda.
Le client affiche le message.
## Flux de données : intention BookCar
Dans cet exercice, le BookTrip bot prend en charge deux intentions (BookHotel et BookCar). Après avoir réservé une chambre d'hôtel, l'utilisateur peut continuer la conversation pour réserver une voiture. Tant que la session n'a pas expiré, dans chaque demande ultérieure le client continue à envoyer les attributs de session (dans cet exemple, `lastConfirmedReservation`). La fonction Lambda peut utiliser ces informations pour initialiser les données d'emplacement conformément à l'intention. BookCar Ceci montre comment utiliser des attributs de session dans le partage de données entre les intentions.
Plus précisément, lorsque l'utilisateur choisit l' BookCar intention, la fonction Lambda utilise les informations pertinentes contenues dans l'attribut de session pour préremplir les emplacements (PickUpDate ReturnDate, et PickUpCity) correspondant à l'intention. BookCar
**Note**
La console Amazon Lex fournit le lien **Effacer** que vous pouvez utiliser pour effacer tous les attributs de session précédents.
Suivez les étapes de cette procédure pour poursuivre la conversation.
1. Utilisateur : « also book a car »
1. Le client envoie la `PostText` demande suivante à Amazon Lex.
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"also book a car",
"sessionAttributes":{
"lastConfirmedReservation":""{\"ReservationType\":\"Hotel\",
\"Location\":\"Chicago\",
\"RoomType\":\"queen\",
\"CheckInDate\":\"2016-12-18\",
\"Nights\":\"5\"}"
}
}
```
Le client inclut l'attribut de session `lastConfirmedReservation`.
1. Amazon Lex détecte l'intention (BookCar) à partir du`inputText`. Cette intention est également configurée pour appeler la fonction Lambda afin d'effectuer l'initialisation et la validation des données utilisateur. Amazon Lex appelle la fonction Lambda avec l'événement suivant :
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookCar",
"slots": {
"PickUpDate": null,
"ReturnDate": null,
"DriverAge": null,
"CarType": null,
"PickUpCity": null
},
"confirmationStatus": "None"
}
}
```
**Note**
`messageVersion`— Actuellement, Amazon Lex ne prend en charge que la version 1.0.
`invocationSource` – Indique que l'objectif de l'appel est d'effectuer l'initialisation et la validation des données utilisateur.
`currentIntent`— Il inclut le nom de l'intention et les emplacements. Pour l'instant, toutes les valeurs d'option sont null.
1. La fonction Lambda remarque toutes les valeurs d'emplacement nulles sans rien à valider. Cependant, elle utilise les attributs de session pour initialiser certaines des valeurs d'option (`PickUpDate`, `ReturnDate` et `PickUpCity`), puis elle renvoie la réponse suivante :
```
{
"sessionAttributes": {
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}",
"currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":null,\"PickUpDate\":null,\"ReturnDate\":null,\"CarType\":null}",
"confirmationContext": "AutoPopulate"
},
"dialogAction": {
"type": "ConfirmIntent",
"intentName": "BookCar",
"slots": {
"PickUpCity": "Chicago",
"PickUpDate": "2016-12-18",
"ReturnDate": "2016-12-22",
"CarType": null,
"DriverAge": null
},
"message": {
"contentType": "PlainText",
"content": "Is this car rental for your 5 night stay in Chicago on 2016-12-18?"
}
}
}
```
**Note**
En plus de`lastConfirmedReservation`, la fonction Lambda inclut d'autres attributs de session (`currentReservation`et`confirmationContext`).
`dialogAction.type`est défini sur`ConfirmIntent`, ce qui indique à Amazon Lex qu'une réponse oui ou non est attendue de la part de l'utilisateur (le ConfirmmationContext est défini sur AutoPopulate, la fonction Lambda sait que la réponse de l'utilisateur vise à obtenir la confirmation de yes/no l'utilisateur de l'initialisation effectuée par la fonction Lambda (données d'emplacement renseignées automatiquement).
La fonction Lambda inclut également dans la réponse un message d'information à renvoyer au `dialogAction.message` client par Amazon Lex.
Le terme `ConfirmIntent` (valeur de `dialogAction.type`) n'est pas lié à une intention de bot. Dans l'exemple, la fonction Lambda utilise ce terme pour demander à Amazon Lex d'obtenir une yes/no réponse de l'utilisateur.
1. Selon le`dialogAction.type`, Amazon Lex renvoie la réponse suivante au client :
![\[Réponse JSON contenant l'état du dialogue, le nom de l'intention, le message, la carte de réponse, les attributs de session, l'emplacement à obtenir et les emplacements.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-car-10.png)
Le client affiche le message : « Is this car rental for your 5 night stay in Chicago on 2016-12-18? »
1. Utilisateur : « yes »
1. Le client envoie la `PostText` demande suivante à Amazon Lex.
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"yes",
"sessionAttributes":{
"confirmationContext":"AutoPopulate",
"currentReservation":"{\"ReservationType\":\"Car\",
\"PickUpCity\":null,
\"PickUpDate\":null,
\"ReturnDate\":null,
\"CarType\":null}",
"lastConfirmedReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Chicago\",
\"RoomType\":\"queen\",
\"CheckInDate\":\"2016-12-18\",
\"Nights\":\"5\"}"
}
}
```
1. Amazon Lex lit le `inputText` et connaît le contexte (demande à l'utilisateur de confirmer le peuplement automatique). Amazon Lex invoque la fonction Lambda en envoyant l'événement suivant :
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"confirmationContext": "AutoPopulate",
"currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":null,\"PickUpDate\":null,\"ReturnDate\":null,\"CarType\":null}",
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookCar",
"slots": {
"PickUpDate": "2016-12-18",
"ReturnDate": "2016-12-22",
"DriverAge": null,
"CarType": null,
"PickUpCity": "Chicago"
},
"confirmationStatus": "Confirmed"
}
}
```
L'utilisateur ayant répondu « Oui », Amazon Lex définit le « `confirmationStatus` à `Confirmed` ».
1. À partir de`confirmationStatus`, la fonction Lambda sait que les valeurs préremplies sont correctes. La fonction Lambda effectue les opérations suivantes :
+ Elle met à jour l'attribut de session `currentReservation` sur la valeur d'option qu'elle a préremplie.
+ Elle définit `dialogAction.type` sur `ElicitSlot`
+ Elle définit la valeur de `slotToElicit` sur `DriverAge`.
La réponse suivantes est envoyée :
```
{
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":\"Chicago\",\"PickUpDate\":\"2016-12-18\",\"ReturnDate\":\"2016-12-22\",\"CarType\":null}",
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"dialogAction": {
"type": "ElicitSlot",
"intentName": "BookCar",
"slots": {
"PickUpDate": "2016-12-18",
"ReturnDate": "2016-12-22",
"DriverAge": null,
"CarType": null,
"PickUpCity": "Chicago"
},
"slotToElicit": "DriverAge",
"message": {
"contentType": "PlainText",
"content": "How old is the driver of this car rental?"
}
}
}
```
1. Amazon Lex renvoie la réponse suivante :
![\[Réponse JSON indiquant l'intention de réserver une voiture et un message indiquant l'emplacement pour le créneau Driver Age.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-car-20.png)
Le client affiche le message « Quel âge a le chauffeur de cette location de voiture ? » et la conversation continue.