Aviso de fin de soporte: el 15 de septiembre de 2025, AWS dejaremos de ofrecer soporte para Amazon Lex V1. Después del 15 de septiembre de 2025, ya no podrá acceder a la consola de Amazon Lex V1 ni a los recursos de Amazon Lex V1. Si utiliza Amazon Lex V2, consulte en su lugar la [guía Amazon Lex V2](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html).
Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Reserva de viaje
Este ejemplo muestra cómo se crea un bot configurado para respaldar múltiples intenciones. El ejemplo también ilustra cómo puede utilizar los atributos de la sesión para el intercambio de información entre intenciones. Tras crear el bot, utiliza un cliente de prueba en la consola de Amazon Lex para probar el bot (BookTrip). El cliente utiliza la operación de la API en tiempo de ejecución [PostText](API_runtime_PostText.md) para enviar una solicitud a Amazon Lex por cada entrada del usuario.
El BookTrip bot de este ejemplo está configurado con dos intenciones (BookHotel y BookCar). Por ejemplo, suponga que un usuario reserva primero un hotel. Durante la interacción, el usuario proporciona información como, por ejemplo, la fecha de llegada, la ubicación y el número de noches. Una vez cumplida la intención, el cliente puede conservar esta información gracias a los atributos de la sesión. Para obtener más información acerca de los atributos de sesión, consulte [PostText](API_runtime_PostText.md).
Ahora suponga que el usuario reserva un automóvil. Con la información que el usuario proporcionó en la BookHotel intención anterior (es decir, la ciudad de destino y las fechas de entrada y salida), el enlace de código (función Lambda) que configuró para inicializar y validar la BookCar intención inicializa los datos de franjas correspondientes a la BookCar intención (es decir, el destino, la ciudad de recogida, la fecha de recogida y la fecha de devolución). Con ello se ilustra cómo el intercambio de información entre intenciones le permite crear bots que pueden participar en una conversación dinámica con el usuario.
En este ejemplo utilizamos los siguientes atributos de la sesión. Solo el cliente y la función de Lambda pueden definir y actualizar los atributos de la sesión. Amazon Lex solo los pasa entre el cliente y la función de Lambda. Amazon Lex no mantiene ni modifica los atributos de la sesión.
+ `currentReservation`: contiene los datos de la ranura para una reserva en curso y demás información relevante. Por ejemplo, a continuación presentamos un ejemplo de solicitud del cliente a Amazon Lex. En él se muestra el atributo de la sesión `currentReservation` en el cuerpo de la solicitud.
```
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`: contiene información similar de una intención anterior, si la hay. Por ejemplo, si el usuario ha reservado un hotel y, a continuación, está en proceso de reservar un coche, este atributo de sesión almacena los datos de franjas horarias para la BookHotel intención anterior.
+ `confirmationContext`: la función de Lambda lo fija en `AutoPopulate` cuando rellena previamente algunos de los datos de ranura basados en datos de ranura de la reserva anterior (si la hay). Esto permite el intercambio de información entre intenciones. Por ejemplo, si el usuario ya ha reservado un hotel y ahora quiere reservar un automóvil, Amazon Lex puede solicitar al usuario que confirme (o deniegue) que está reservado el automóvil para la misma ciudad y las mismas fechas que la reserva de hotel.
En este ejercicio utilizará esquemas para crear un bot de Amazon Lex y una función de Lambda. Para obtener más información acerca de los esquemas, consulte [Amazon Lex y AWS Lambda planos](lex-lambda-blueprints.md).
**Paso siguiente**
[Paso 1: revisión de los proyectos utilizados en este ejercicio](ex-book-trip-blueprints.md)
# Paso 1: revisión de los proyectos utilizados en este ejercicio
**Topics**
+ [Descripción general del esquema del bot () BookTrip](#ex-book-trip-bp-summary-bot)
+ [Descripción general del esquema de funciones Lambda () lex-book-trip-python](#ex-book-trip-summary-lambda)
## Descripción general del esquema del bot () BookTrip
El proyecto (**BookTrip**) que utiliza para crear un bot proporciona la siguiente configuración previa:
+ **Tipos de slot**: dos tipos de slot personalizados:
+ `RoomTypes` con valores de enumeración: `king`, `queen` y `deluxe` para usar con la intención `BookHotel`.
+ `CarTypes` con valores de enumeración: `economy`, `standard`, `midsize`, `full size`, `luxury` y `minivan` para usar con la intención `BookCar`.
+ **Intención 1 (BookHotel)**: está preconfigurado de la siguiente manera:
+ **Slots preconfigurados**
+ `RoomType` del tipo de slot personalizado `RoomTypes`
+ `Location` del tipo de slot integrado `AMAZON.US_CITY`
+ `CheckInDate` del tipo de slot integrado `AMAZON.DATE`
+ `Nights` del tipo de slot integrado `AMAZON.NUMBER`
+ **Enunciados preconfigurados**
+ "Reservar un hotel"
+ "Quiero hacer reservas de hotel"
+ "Reservar una \$1Nights\$1 en \$1Location\$1"
Si el usuario utiliza uno de estos enunciados, Amazon Lex determina que `BookHotel` es la intención y, a continuación, solicita al usuario datos de ranura.
+ **Preguntas preconfiguradas**
+ Pregunta para el slot `Location`: "¿En qué ciudad va a pernoctar?"
+ Pregunta para el slot `CheckInDate`: "¿Qué día desea registrarse?"
+ Pregunta para el slot `Nights`: "¿Cuántas noches va a quedarse?"
+ Pregunta para el slot `RoomType`: "¿Qué tipo de habitación desea: queen, king o deluxe?"
+ Declaración de confirmación: «Vale, te propongo una estancia de \$1noches\$1 noches en \$1Ubicación\$1 a partir de \$1CheckInDate\$1. ¿Tramito la reserva?"
+ Rechazo: “De acuerdo, he cancelado la reserva en curso”.
+ **Intención 2 (BookCar)**: está preconfigurada de la siguiente manera:
+ **Slots preconfigurados**
+ `PickUpCity` del tipo integrado `AMAZON.US_CITY`
+ `PickUpDate` del tipo integrado `AMAZON.DATE`
+ `ReturnDate` del tipo integrado `AMAZON.DATE`
+ `DriverAge` del tipo integrado `AMAZON.NUMBER`
+ `CarType` del tipo personalizado `CarTypes`
+ **Enunciados preconfigurados**
+ "Reservar un automóvil"
+ "Reservar un automóvil"
+ "Realizar una reserva de automóvil"
Si el usuario pronuncia alguna de estas palabras, Amazon Lex BookCar determina la intención y, a continuación, solicita al usuario los datos de las ranuras.
+ **Preguntas preconfiguradas**
+ Pregunta para el slot `PickUpCity`: "¿En qué ciudad desea alquilar un automóvil?"
+ Pregunta para el slot `PickUpDate`: "¿A partir de qué día desea alquilarlo?"
+ Pregunta para el slot `ReturnDate`: "¿Qué día desea devolver el automóvil?"
+ Pregunta para el slot `DriverAge`: "¿Qué edad tiene el conductor que va a alquilar el automóvil?"
+ Pregunta para el slot `CarType`: “¿Qué tipo de automóvil desea alquilar?” Nuestras opciones más populares son: económico, tamaño medio y lujo"
+ Declaración de confirmación: «Vale, te propongo un \$1CarType\$1 alquiler en \$1PickUpCity\$1 de \$1\$1 a \$1PickUpDateReturnDate\$1. ¿Tramito la reserva?"
+ Rechazo: “De acuerdo, he cancelado la reserva en curso”.
## Descripción general del esquema de funciones Lambda () lex-book-trip-python
Además del blueprint del bot, AWS Lambda proporciona un blueprint (**lex-book-trip-python**) que puedes usar como enlace de código con el blueprint del bot. Para obtener una lista de los esquemas de bot y los esquemas de funciones de Lambda correspondientes, consulte [Amazon Lex y AWS Lambda planos](lex-lambda-blueprints.md).
Cuando se crea un bot con el BookTrip blueprint, se actualiza la configuración de las intenciones (BookCar y BookHotel) añadiendo esta función Lambda como enlace de código tanto para la entrada de datos initialization/validation del usuario como para el cumplimiento de las intenciones.
Este código de la función Lambda muestra una conversación dinámica con información conocida de antemano (incluida en los atributos de la sesión) acerca de un usuario para inicializar valores de slot para una intención. Para obtener más información, consulte [Gestión del contexto de la conversación](context-mgmt.md).
**Paso siguiente**
[Paso 2: creación de un bot de Amazon Lex](ex-book-trip-create-bot.md)
# Paso 2: creación de un bot de Amazon Lex
En esta sección, se crea un bot de Amazon Lex (BookTrip).
1. Inicie sesión en la consola Amazon Lex Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. En la página **Bots**, elija **Crear**.
1. En la página **Create your Lex bot**:
+ Elija el proyecto **BookTrip**.
+ Deje el nombre del bot predeterminado (BookTrip).
1. Seleccione **Crear**. La consola envía una serie de solicitudes a Amazon Lex para crear el bot. Tenga en cuenta lo siguiente:
1. La consola muestra el BookTrip bot. En la pestaña **Editor**, revisa los detalles de las intenciones preconfiguradas (BookCar y BookHotel).
1. Pruebe el bot en la ventana de pruebas. Utilice lo siguiente para entablar una conversación de prueba con su bot:
![\[Una conversación con un agente en la que este obtiene la ciudad, la fecha, el número de noches de estancia y el tipo de habitación para tramitar la reserva del viaje del cliente. A continuación, el agente confirma la reserva.\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/book-trip-no-lambda-10.png)
A partir de la entrada inicial del usuario («Reserva un hotel»), Amazon Lex deduce la intención (BookHotel). A continuación, el bot utiliza las preguntas preconfiguradas en esta intención para obtener datos de slot del usuario. Una vez que el usuario haya proporcionado todos los datos de ranura, Amazon Lex devuelve una respuesta al cliente con un mensaje que incluye todas las entradas del usuario en forma de mensaje. El cliente muestra el mensaje en la respuesta, tal como aparece a continuación.
```
CheckInDate:2016-12-18 Location:Chicago Nights:5 RoomType:queen
```
Ahora debe continuar con la conversación e intentar reservar un automóvil.
![\[Una conversación con un agente en la que este obtiene la ciudad, la fecha de inicio, la fecha de devolución, la edad del conductor y el tipo de automóvil para tramitar la solicitud de alquiler de un vehículo del cliente. A continuación, el agente confirma la reserva.\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/book-trip-no-lambda-20.png)
Tenga en cuenta que,
+ En este momento no se validan los datos del usuario. Por ejemplo, puede indicar cualquier ciudad para reservar un hotel.
+ Para reservar el automóvil está proporcionando parte de la misma información (destino, ciudad de recogida, fecha de recogida y fecha de devolución). En una conversación dinámica, su bot debería inicializar parte de esta información en función de las entradas anteriores del usuario para reservar un hotel.
En la siguiente sección debe crear una función Lambda para que valide ciertos datos del usuario e inicialice el intercambio de información entre intenciones mediante los atributos de la sesión. A continuación, actualiza la configuración de intención añadiendo la función Lambda como enlace de código para realizar la entrada initialization/validation del usuario y cumplir la intención.
**Paso siguiente**
[Paso 3: creación de una función de Lambda](ex-book-trip-create-lambda-function.md)
# Paso 3: creación de una función de Lambda
En esta sección, se crea una función Lambda mediante un blueprint (**lex-book-trip-python**) que se proporciona en la consola. AWS Lambda También invocará la función de Lambda para probarla con ejemplos de datos de evento de Amazon Lex de muestra proporcionados por la consola.
Esta función de Lambda está escrita en Python.
1. Inicie sesión en Consola de administración de AWS y abra la AWS Lambda consola en. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)
1. Seleccione **Creación de función**.
1. Elija **Utilizar un esquema**. Escriba **lex** para encontrar el proyecto `lex-book-trip-python` y selecciónelo.
1. Elija **Configurar** para configurar la función de Lambda de la siguiente forma.
+ Escriba el nombre de la función de Lambda (`BookTripCodeHook`).
+ Para el rol, elija **Create a new role from template(s)** y luego escriba el nombre del rol.
+ Deje los demás valores predeterminados.
1. Seleccione **Creación de función**.
1. Si utiliza una configuración regional que no sea Inglés (EE. UU.) (en-US), actualice los nombres de las intenciones tal como se indica en [Actualización de un esquema para una configuración regional específica](lex-lambda-blueprints.md#blueprint-update-locale).
1. Pruebe la función de Lambda. Invoque la función de Lambda dos veces con los datos de ejemplo, una para reservar un automóvil y otra para reservar un hotel.
1. Elija **Configure test event (Configurar evento de prueba)** en el menú desplegable **Select a test event (Seleccionar un evento de prueba)**.
1. Elija **Amazon Lex Book Hotel** en la lista **Sample event template (Plantilla de evento de muestra)**.
Este evento de muestra coincide con el request/response modelo Amazon Lex. Para obtener más información, consulte [Uso de funciones de Lambda](using-lambda.md).
1. Elija **Guardar y probar**.
1. Compruebe que la función de Lambda se ha ejecutado correctamente. En este caso, la respuesta sigue el modelo de respuesta de Amazon Lex.
1. Repita el paso. Esta vez elija **Amazon Lex Book Car** en la lista **Sample event template (Plantilla de evento de muestra)**. La función de Lambda procesa la reserva del automóvil.
**Paso siguiente**
[Paso 4: adición de la función de Lambda como enlace de código](ex-book-trip-create-integrate.md)
# Paso 4: adición de la función de Lambda como enlace de código
En esta sección, actualizarás las configuraciones de las BookHotel intenciones BookCar y añadiendo la función Lambda como enlace de código initialization/validation para las actividades de logística. Asegúrese de elegir la versión \$1LATEST de las intenciones, ya que solo es posible actualizar la versión \$1LATEST de los recursos de Amazon Lex.
1. En la consola Amazon Lex, elige el **BookTrip**bot.
1. En la pestaña **Editor**, elija la **BookHotel**intención. Actualice la configuración de la intención de la siguiente manera:
1. Asegúrese de que la versión de la intención (junto al nombre de la intención) es \$1LATEST.
1. Añada la función de Lambda como enlace de código de inicialización y validación de la siguiente manera:
+ En **Options**, elija **Initialization and validation code hook**.
+ Elija la función de Lambda en la lista.
1. Añada la función de Lambda como enlace de código de cumplimiento de la siguiente manera:
+ En **Fulfillment**, elija **AWS Lambda function**.
+ Elija la función de Lambda en la lista.
+ Elija **Goodbye message** y escriba un mensaje.
1. Seleccione **Save**.
1. En la pestaña **Editor**, elija la BookCar intención. Siga los pasos anteriores para añadir la función Lambda como enlace de código de validación y cumplimiento.
1. Elija **Compilar**. La consola envía una serie de solicitudes a Amazon Lex para guardar las configuraciones.
1. Pruebe el bot. Ahora que ya tiene una función de Lambda que realiza la inicialización, la validación de los datos del usuario y el cumplimiento, podrá ver la diferencia en la interacción con el usuario en la siguiente conversación:
![\[Una conversación con un agente en la que este obtiene la ciudad, la fecha, el número de noches de estancia y el tipo de habitación para tramitar la reserva del viaje del cliente y confirmarla.\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/book-trip-with-lambda-30.png)
Para obtener más información sobre el flujo de datos desde el cliente (consola) a Amazon Lex y desde Amazon Lex a la función de Lambda, consulte [Flujo de datos: intención de reservar un hotel](book-trip-detail-flow.md#data-flow-book-hotel).
1. Siga con la conversación y reserve un automóvil, tal y como se muestra en la siguiente imagen:
![\[Una conversación con un agente en la que este obtiene la edad del conductor y el tipo de automóvil y, a continuación, confirma la reserva del vehículo.\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/book-trip-with-lambda-40.png)
Cuando decide reservar un coche, el cliente (consola) envía una solicitud a Amazon Lex que incluye los atributos de la sesión (de la conversación anterior BookHotel). Amazon Lex pasa esta información a la función Lambda, que, a continuación, inicializa (es decir, rellena previamente) algunos de los datos de la BookCar ranura (es decir,, PickUpDate y). ReturnDate PickUpCity
**nota**
Aquí se muestra cómo se pueden utilizar los atributos de la sesión para conservar el contexto entre diferentes intenciones. La consola cliente proporciona el enlace **Clear** en la ventana de prueba que un usuario puede utilizar para borrar cualquier atributo de la sesión anterior.
Para obtener más información sobre el flujo de datos desde el cliente (consola) a Amazon Lex y desde Amazon Lex a la función de Lambda, consulte [Flujo de datos: intención de reservar un automóvil](book-trip-detail-flow.md#data-flow-book-car).
# Detalles del flujo de información
En este ejercicio, entabló una conversación con el BookTrip bot de Amazon Lex mediante el cliente de ventana de prueba que se proporciona en la consola de Amazon Lex. En esta sección se explica lo siguiente:
+ El flujo de datos entre el cliente y Amazon Lex.
En esta sección se supone que el cliente envía solicitudes a Amazon Lex mediante la API en tiempo de ejecución `PostText` y se muestran los detalles correspondientes de la solicitud y la respuesta. Para obtener más información acerca de la API en tiempo de ejecución `PostText`, consulte [PostText](API_runtime_PostText.md).
**nota**
Para ver un ejemplo de flujo de información entre el cliente y Amazon Lex en el que el usuario usa la API `PostContent`, consulte [Paso 2a (opcional): revisión de los detalles del flujo de información escrita (consola)](gs-bp-details-postcontent-flow.md).
+ El flujo de datos entre Amazon Lex y la función de Lambda. Para obtener más información, consulte [Formato del evento de entrada y de la respuesta de la función de Lambda](lambda-input-response-format.md).
**Topics**
+ [Flujo de datos: intención de reservar un hotel](#data-flow-book-hotel)
+ [Flujo de datos: intención de reservar un automóvil](#data-flow-book-car)
## Flujo de datos: intención de reservar un hotel
En esta sección se explica lo que ocurre después de cada entrada del usuario.
1. Usuario: "reservar un hotel"
1. El cliente (la consola) envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"book a hotel",
"sessionAttributes":{}
}
```
Tanto la URI de la solicitud como el cuerpo proporcionan información a Amazon Lex:
+ URI de solicitud: proporciona el nombre del bot (BookTrip), el alias del bot (\$1LATEST) y el nombre de usuario. El `text` de cola indica que se trata de una solicitud de API `PostText` (no `PostContent`).
+ Cuerpo de la solicitud: incluye la entrada del usuario (`inputText`). No hay `sessionAttributes`. Inicialmente, se trata de un objeto vacío y la función de Lambda establece primero los atributos de sesión.
1. Amazon Lex deduce la intención (BookHotel) a partir de `inputText`. Esta intención está configurada con una función de Lambda como enlace de código para las tareas de inicialización y validación de los datos del usuario. Por ello, Amazon Lex invoca la función de Lambda pasando la siguiente información como parámetro de evento (consulte [Formato del evento de entrada](lambda-input-response-format.md#using-lambda-input-event-format)):
```
{
"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"
}
}
```
Además de la información que envía el cliente, Amazon Lex también incluye los siguientes datos adicionales:
+ `messageVersion`: actualmente Amazon Lex solo es compatible con la versión 1.0.
+ `invocationSource`: indica la finalidad de la invocación de la función de Lambda. En este caso, se trata de inicializar y validar los datos del usuario (en este punto Amazon Lex sabe que el usuario aún no ha proporcionado todos los datos de ranura para llevar a cabo la intención).
+ `currentIntent`: todos los valores de ranura se configuran como nulos.
1. En este momento, todos los valores de slot son nulos. La función de Lambda no tiene que validar nada. y devuelve la siguiente respuesta a Amazon Lex. Para obtener más información sobre el formato de la respuesta, consulte [Formato de respuesta](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
}
}
}
```
**nota**
`currentReservation`: la función de Lambda incluye este atributo de la sesión. Su valor es una copia de la información actual de slot y el tipo de reserva.
Solo el cliente y la función de Lambda pueden actualizar estos atributos de la sesión. Amazon Lex simplemente pasa estos valores.
`dialogAction.type`: al configurar este valor como `Delegate`, la función de Lambda delega la responsabilidad del siguiente procedimiento en Amazon Lex.
Si la función de Lambda detecta algo en la validación de los datos del usuario, le indica a Amazon Lex qué debe hacer a continuación.
1. Según `dialogAction.type`, Amazon Lex decide el siguiente paso: obtener datos del usuario para la ranura `Location`. Selecciona uno de los mensajes de pregunta ("¿En qué ciudad va a pernoctar?") para este slot, según la configuración de la intención, y luego envía esta respuesta al usuario:
![\[La respuesta en formato JSON, que contiene el estado del diálogo, el nombre de la intención, el mensaje, la tarjeta de respuesta, los atributos de la sesión, la ranura a obtener y las ranuras.\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/book-hotel-10.png)
Los atributos de la sesión se transfieren al cliente.
El cliente lee la respuesta y, a continuación, muestra el mensaje: "¿En qué ciudad va a pernoctar?"
1. Usuario: "Moscú"
1. El cliente envía la siguiente solicitud `PostText` a Amazon Lex (se añaden saltos de línea para facilitar la lectura):
```
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}"
}
}
```
Además de `inputText`, el cliente incluye los mismos atributos de la sesión `currentReservation` que ha recibido.
1. En primer lugar, Amazon Lex interpreta `inputText` en el contexto de la intención actual (el servicio recuerda que ha solicitado al usuario información sobre la ranura `Location`). Actualiza el valor de la ranura para la intención actual e invoca la función de Lambda con el siguiente evento:
```
{
"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"
}
}
```
**nota**
`invocationSource` sigue siendo `DialogCodeHook`. En este paso, solo se validan los datos del usuario.
Amazon Lex simplemente transfiere el atributo de la sesión a la función de Lambda.
Para `currentIntent.slots`, Amazon Lex ha actualizado la ranura `Location` con `Moscow`.
1. La función de Lambda valida los datos del usuario y determina que `Moscow` es una ubicación no válida.
**nota**
En este ejercicio, la función de Lambda cuenta con una lista de ciudades muy simple y `Moscow` no aparece en ella. En una aplicación de producción, es posible que pueda utilizar una base de datos back-end para obtener esta información.
Restablece el valor de la ranura a nulo e indica a Amazon Lex que solicite al usuario otro valor enviando la siguiente respuesta:
```
{
"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?"
}
}
}
```
**nota**
`currentIntent.slots.Location` se vuelve a fijar como nulo.
`dialogAction.type` se establece en `ElicitSlot`, por lo que Amazon Lex vuelve a preguntar al usuario proporcionando lo siguiente:
`dialogAction.slotToElicit`: slot para el que se obtienen datos del usuario.
`dialogAction.message`: un `message` que se transmite al usuario.
1. Amazon Lex tiene en cuenta `dialogAction.type` y pasa la información al cliente con la siguiente respuesta:
![\[La respuesta en formato JSON, que contiene el estado del diálogo, el nombre de la intención, el mensaje, la tarjeta de respuesta, los atributos de la sesión, la ranura a obtener y las ranuras.\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/book-hotel-20.png)
El cliente simplemente muestra el mensaje: "En la actualidad, no se admite Moscú como destino válido. ¿Puede probar con otra ciudad?"
1. Usuario: "Chicago"
1. El cliente envía la siguiente solicitud `PostText` a 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 conoce el contexto, es decir, que estaba obteniendo datos para la ranura `Location`. En este contexto, sabe que el valor de `inputText` es para el slot `Location`. A continuación, invoca la función de Lambda mediante el envío del siguiente evento:
```
{
"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 ha actualizado `currentIntent.slots` al configurar la ranura `Location` con `Chicago`.
1. Al establecer el valor `invocationSource` como `DialogCodeHook`, la función de Lambda valida los datos del usuario. Reconoce `Chicago` como un valor de ranura válido, actualiza el atributo de sesión según corresponda y devuelve la siguiente respuesta a 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"
}
}
}
```
**nota**
`currentReservation`: la función de Lambda actualiza este atributo de la sesión al configurar `Location` con `Chicago`.
`dialogAction.type`: se establece en `Delegate`. Los datos del usuario son válidos, por lo que la función de Lambda indica a Amazon Lex que decida el siguiente paso.
1. Amazon Lex elige el siguiente paso en función de `dialogAction.type`. Amazon Lex sabe que necesita más datos de ranura, de modo que elige la siguiente ranura vacía (`CheckInDate`) con la mayor prioridad, según la configuración de la intención. Selecciona uno de los mensajes de pregunta ("¿Qué día desea registrarse?") para este slot, según la configuración de la intención, y entonces envía esta respuesta al cliente:
![\[La respuesta en formato JSON, que contiene el estado del diálogo, el nombre de la intención, el mensaje, la tarjeta de respuesta, los atributos de la sesión, la ranura a obtener y las ranuras. La ranura de ubicación se rellena con el valor “Chicago”.\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/book-hotel-30.png)
El cliente muestra el mensaje: "¿Qué día desea registrarse?"
1. La interacción con el usuario continúa: el usuario proporciona los datos, la función de Lambda los valida y delega el siguiente paso en Amazon Lex. Al final, el usuario proporciona todos los datos de ranura, la función de Lambda valida todas las entradas del usuario y Amazon Lex reconoce que cuenta con todos los datos de ranura.
**nota**
En este ejercicio, después de que el usuario proporcione todos los datos de ranura, la función de Lambda calcula el precio de la reserva de hotel y lo devuelve como otro atributo de sesión (`currentReservationPrice`).
En este punto, la intención está lista para cumplirse, pero la BookHotel intención se configura con un mensaje de confirmación que requiere la confirmación del usuario antes de que Amazon Lex pueda cumplir la intención. Por este motivo, Amazon Lex envía el siguiente mensaje al cliente para solicitar su confirmación antes de reservar el hotel:
![\[La respuesta en formato JSON, que contiene el estado del diálogo, el nombre de la intención, el mensaje, la tarjeta de respuesta, los atributos de la sesión, la ranura a obtener y las ranuras. Ahora todas las ranuras están rellenados.\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/book-hotel-40.png)
El cliente muestra el mensaje: "De acuerdo, tengo anotado que busca alojamiento para 5 noches en Chicago a partir del 18/12/2016. ¿Tramito la reserva?"
1. Usuario: “sí”
1. El cliente envía la siguiente solicitud `PostText` a 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 interpreta `inputText` en el contexto de la confirmación de la intención actual. Amazon Lex entiende que el usuario quiere continuar con la reserva. Esta vez, Amazon Lex invoca la función de Lambda para cumplir la intención mediante el envío del siguiente evento. Al configurar `invocationSource` como `FulfillmentCodeHook` en el evento, lo envía a la función de Lambda. Amazon Lex también establece `confirmationStatus` en `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"
}
}
```
**nota**
`invocationSource`: esta vez, Amazon Lex configura este valor como `FulfillmentCodeHook`, por lo que indica a la función de Lambda que cumpla con la intención.
`confirmationStatus`: se establece en `Confirmed`.
1. Esta vez, la función Lambda cumple la BookHotel intención, Amazon Lex completa la reserva y, a continuación, devuelve la siguiente respuesta:
```
{
"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."
}
}
}
```
**nota**
`lastConfirmedReservation`: es un nuevo atributo de la sesión que ha añadido la función de Lambda (en lugar de `currentReservation`, `currentReservationPrice`).
`dialogAction.type`: la función de Lambda establece este valor en `Close`, lo que indica que Amazon Lex no esperará ninguna respuesta del usuario.
`dialogAction.fulfillmentState`: se establece en `Fulfilled` e incluye un `message` adecuado para transmitir al usuario.
1. Amazon Lex analiza `fulfillmentState` y envía la siguiente respuesta al cliente:
![\[La respuesta en formato JSON, que contiene el estado del diálogo, el nombre de la intención, el mensaje, la tarjeta de respuesta, los atributos de la sesión, la ranura a obtener y las ranuras. Se han rellenado todas las ranuras, así como el campo de la última reservada confirmada en los atributos de la sesión.\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/book-hotel-60.png)
**nota**
`dialogState`: Amazon Lex establece este valor en `Fulfilled`.
`message`: es el mismo mensaje que ha proporcionado la función de Lambda.
El cliente muestra el mensaje.
## Flujo de datos: intención de reservar un automóvil
El BookTrip bot de este ejercicio admite dos intenciones (y)BookHotel . BookCar Después de reservar un hotel, el usuario puede continuar la conversación para reservar un automóvil. Mientras la sesión no haya caducado, en cada solicitud subsiguiente el cliente sigue enviando los atributos de la sesión (en este ejemplo, la `lastConfirmedReservation`). La función Lambda puede usar esta información para inicializar los datos de las ranuras según la intención. BookCar Aquí se muestra cómo puede utilizar los atributos de la sesión en el uso compartido de datos entre intenciones.
En concreto, cuando el usuario elige la BookCar intención, la función Lambda utiliza la información relevante del atributo de sesión para rellenar previamente los espacios (PickUpDate ReturnDate, y PickUpCity) para la intención. BookCar
**nota**
La consola de Amazon Lex proporciona el enlace **Borrar**, que puede utilizar para borrar los atributos de sesión anteriores.
Siga los pasos descritos en este procedimiento para continuar con la conversación.
1. Usuario: "reservar también un automóvil"
1. El cliente envía la siguiente solicitud `PostText` a 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\"}"
}
}
```
El cliente incluye el atributo de la sesión `lastConfirmedReservation`.
1. Amazon Lex detecta la intención (BookCar) de`inputText`. Esta intención también está configurada para invocar la función de Lambda, para que realice las tareas de inicialización y validación de los datos del usuario. Amazon Lex invoca la función de Lambda con los siguientes eventos:
```
{
"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"
}
}
```
**nota**
`messageVersion`: actualmente Amazon Lex solo es compatible con la versión 1.0.
`invocationSource`: indica que el objetivo de la invocación es inicializar y validar los datos del usuario.
`currentIntent`: incluye el nombre de la intención y las ranuras. En este momento, todos los valores de slot son nulos.
1. La función de Lambda observa que todos los valores de ranura son nulos y no hay nada que validar. Sin embargo, utiliza los atributos de la sesión para inicializar algunos de los valores de slot (`PickUpDate`, `ReturnDate` y `PickUpCity`) y, a continuación, devuelve la siguiente respuesta:
```
{
"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?"
}
}
}
```
**nota**
Además de `lastConfirmedReservation`, la función de Lambda incluye más atributos de la sesión (`currentReservation` y `confirmationContext`).
`dialogAction.type`está configurado en`ConfirmIntent`, lo que informa a Amazon Lex de que se espera una respuesta del usuario de sí o no (el ConfirmationContext está establecido en AutoPopulate, la función Lambda sabe que la respuesta del usuario es para obtener la confirmación yes/no del usuario de la inicialización que realizó la función Lambda (datos de ranura rellenados automáticamente).
La función de Lambda también incluye en la respuesta un mensaje informativo en `dialogAction.message` para que Amazon Lex se lo envíe al cliente.
El término `ConfirmIntent` (valor del `dialogAction.type`) no está relacionado con ninguna intención del bot. En el ejemplo, la función Lambda utiliza este término para indicar a Amazon Lex que obtenga una yes/no respuesta del usuario.
1. Amazon Lex devuelve la siguiente respuesta al cliente en función de `dialogAction.type`:
![\[La respuesta en formato JSON, que contiene el estado del diálogo, el nombre de la intención, el mensaje, la tarjeta de respuesta, los atributos de la sesión, la ranura a obtener y las ranuras.\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/book-car-10.png)
El cliente muestra el mensaje: "¿El alquiler de este automóvil es para su estancia de 5 noches en Chicago a partir del 18/12/2016?"
1. Usuario: “sí”
1. El cliente envía la siguiente solicitud `PostText` a 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 lee `inputText` y conoce el contexto (pedirá al usuario que confirme los datos rellenados de forma automática). Amazon Lex invoca la función de Lambda al enviar el siguiente evento:
```
{
"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"
}
}
```
Dado que el usuario ha respondido con un Sí, Amazon Lex establece `confirmationStatus` en `Confirmed`.
1. Por el valor de `confirmationStatus`, la función de Lambda sabe que los valores rellenados previamente son correctos. La función de Lambda hace lo siguiente:
+ Actualiza el atributo de la sesión `currentReservation` con el valor de slot rellenado previamente.
+ Establece el `dialogAction.type` en `ElicitSlot`
+ Establece el valor de `slotToElicit` en `DriverAge`.
Se envía la siguiente respuesta:
```
{
"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 devuelve la siguiente respuesta:
![\[Respuesta en formato JSON que indica la intención de reservar un automóvil y un mensaje en el que se obtiene la ranura para la edad del conductor.\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/book-car-20.png)
El cliente muestra el mensaje “¿Qué edad tiene el conductor del automóvil de alquiler?” y la conversación continúa.