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.
# Ejercicio 1: creación de un bot de Amazon Lex mediante un esquema (consola)
En este ejercicio, hará lo siguiente:
+ Crear su primer bot de Amazon Lex y probarlo en la consola de Amazon Lex.
Para este ejercicio, utilizará el **OrderFlowers**plano. Para obtener más información sobre los proyectos, consulte [Amazon Lex y AWS Lambda planos](lex-lambda-blueprints.md).
+ Cree una AWS Lambda función y pruébela en la consola Lambda. Cuando procesa una solicitud, el bot llama a esta función de Lambda. Para este ejercicio, utilizará un blueprint de Lambda (**lex-order-flowers-python**) incluido en la AWS Lambda consola para crear la función Lambda. El código del esquema indica cómo se puede utilizar la misma función de Lambda para la inicialización y validación, así como para llevar a cabo la intención `OrderFlowers`.
+ Actualizar el bot para agregar la función de Lambda como el enlace de código que permite cumplir con la intención. Pon a prueba la experiencia. end-to-end
En las siguientes secciones se explica qué hacen los proyectos.
## Bot de Amazon Lex: descripción general del esquema
El **OrderFlowers**plano se utiliza para crear un bot de Amazon Lex. Para obtener más información sobre la estructura de un bot, consulte. [Funcionamiento de Amazon Lex](how-it-works.md) El bot está preconfigurado del modo siguiente:
+ **Intención:** OrderFlowers
+ **Tipos de slot**: un tipo de slot personalizado denominado `FlowerTypes` con los valores de enumeración: `roses`, `lilies` y `tulips`.
+ **Slots**: la intención requiere la siguiente información (es decir, slots) para que el bot pueda llevar a cabo la intención.
+ `PickupTime` (AMAZON.TIME built-in type)
+ `FlowerType`(tipo FlowerTypes personalizado)
+ `PickupDate` (tipo integrado AMAZON.DATE)
+ **Enunciados**: los siguientes enunciados de muestra identifican la intención del usuario:
+ «Me gustaría recoger unas flores».
+ «Me gustaría pedir unas flores».
+ **Preguntas**: una vez que el bot identifica la intención, utiliza las siguientes preguntas para rellenar los slots:
+ Pregunta para el slot `FlowerType`: «¿Qué tipo de flores deseas pedir?»
+ Pregunta para el `PickupDate` espacio: «¿Qué día quieres que recojan el \$1FlowerType\$1?»
+ Pregunta sobre el `PickupTime` espacio: «¿A qué hora quieres que recojan el \$1FlowerType\$1?»
+ Declaración de confirmación: «De acuerdo, tu \$1FlowerType\$1 estará listo para ser recogido antes del \$1PickupTime\$1 el \$1PickupDate\$1. ¿Te parece bien?»
## AWS Lambda Función: resumen del plano
La función de Lambda de este ejercicio realiza tanto las tareas de inicialización y validación como las de cumplimiento. Por lo tanto, después de crear la función de Lambda, deberá actualizar la configuración de la intención y especificar la misma función de Lambda como enlace de código para administrar las tareas de inicialización o validación y de cumplimiento.
+ Como enlace de código de inicialización y validación, la función de Lambda realiza la validación básica. Por ejemplo, si el usuario indica una hora de recogida que está fuera del horario de apertura habitual, la función de Lambda indica a Amazon Lex que solicite una hora nueva al usuario.
+ Como parte del enlace de código de cumplimiento, la función de Lambda devuelve un mensaje de resumen que indica que se ha realizado el pedido de flores (es decir, que se ha cumplido con la intención).
**Paso siguiente**
[Paso 1: creación de un bot de Amazon Lex (consola)](gs-bp-create-bot.md)
# Paso 1: creación de un bot de Amazon Lex (consola)
Para este ejercicio, crea un bot para pedir flores, llamado OrderFlowersBot.
Creación de un bot de Amazon Lex (consola)
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. Si es su primer bot, elija **Get Started (Empezar)**; de lo contrario, en la página **Bots**, elija **Create (Crear)**.
1. En la página **Create your Lex bot**, proporcione la información siguiente y, a continuación, seleccione **Create**.
+ Elija el proyecto **OrderFlowers**.
+ Deje el nombre del bot predeterminado (OrderFlowers).
+ En **COPPA**, elija **No**.
+ En **Almacenamiento de enunciados del usuario**, elija la respuesta adecuada.
1. Seleccione **Crear**. La consola realiza las solicitudes necesarias para que Amazon Lex guarde la configuración. A continuación, la consola muestra la ventana del editor de bots.
1. Espere a que se le confirme que se creó su bot.
1. Pruebe el bot.
**nota**
Puede probar el bot escribiendo el texto en la ventana de prueba o, con navegadores compatibles, seleccionando el botón de micrófono en la misma ventana y hablando.
Utilice el siguiente texto de ejemplo para participar en la conversación con el bot para pedir flores:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/OrderFlowers-NoLambda.png)
A partir de esta entrada, el bot deduce la intención `OrderFlowers` y solicita los datos de slot. Cuando proporcione todos los datos necesarios del slot, el bot llevará a cabo la intención (`OrderFlowers`) devolviendo toda la información a la aplicación cliente (en este caso, la consola). La consola simplemente muestra la información en la ventana de prueba.
En concreto:
+ En la instrucción "¿Qué día desea recoger las rosas?" aparece el término "rosas" porque la pregunta del slot `pickupDate` está configurada con sustituciones, `{FlowerType}`. Compruébelo en la consola.
+ La instrucción "Bien, sus rosas estarán listas..." es lo que ha configurado para la confirmación.
+ La última instrucción ("`FlowerType:roses...`") incluye solo los datos de slot que se devuelven al cliente, en este caso, en la ventana de prueba. En el siguiente ejercicio, utilizará una función de Lambda para llevar a cabo la intención, en cuyo caso obtendrá un mensaje que indica que se ha efectuado el pedido.
**Paso siguiente**
[Paso 2 (opcional): revisión de los detalles del flujo de información (consola)](gs-bp-details-two-runtime-apis.md)
# Paso 2 (opcional): revisión de los detalles del flujo de información (consola)
En esta sección se explica el flujo de información entre un cliente y Amazon Lex para cada entrada de usuario en nuestra conversación de ejemplo.
En el ejemplo se utiliza la ventana de pruebas de la consola para mostrar la conversación con el bot.
**Visualización de la ventana de pruebas de Amazon Lex**
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. Elija el bot que quiera probar.
1. En la parte derecha de la consola, elija **Probar bot de chat**.
Para ver el flujo de información de contenido hablado o escrito, elija el tema correspondiente.
**Topics**
+ [Paso 2a (opcional): revisión de los detalles del flujo de información escrita (consola)](gs-bp-details-postcontent-flow.md)
+ [Paso 2b (opcional): revisión de los detalles del flujo de información escrita (consola)](gs-bp-details-part1.md)
# Paso 2a (opcional): revisión de los detalles del flujo de información escrita (consola)
En esta sección se explica el flujo de información entre el cliente y Amazon Lex cuando el cliente utiliza la voz para enviar solicitudes. Para obtener más información, consulte [PostContent](API_runtime_PostContent.md).
1. El usuario dice: Me gustaría pedir unas flores.
1. El cliente (la consola) envía la siguiente solicitud [PostContent](API_runtime_PostContent.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "audio/x-l16; sample-rate=16000; channel-count=1"
Accept: "audio/mpeg"
Request body
input stream
```
Tanto la URI de la solicitud como el cuerpo proporcionan información a Amazon Lex:
+ URI de la solicitud: proporciona el nombre del bot (`OrderFlowers`), su alias (`$LATEST`) y el nombre del usuario (una cadena aleatoria que identifica al usuario). `content` indica que se trata de una solicitud de la API `PostContent` (no una solicitud `PostText`).
+ Encabezados de solicitudes
+ `x-amz-lex-session-attributes`: el valor con codificación base64 representa “\$1\$1”. Cuando el cliente realiza la primera solicitud, no existen atributos de la sesión.
+ `Content-Type`: refleja el formato de audio.
+ Cuerpo de la solicitud: la transmisión de audio de la entrada del usuario ("Me gustaría pedir unas flores.").
**nota**
En caso de que el usuario elija enviar texto ("Me gustaría pedir unas flores") a la API `PostContent` en lugar de hablar, el cuerpo de la solicitud será la entrada del usuario. El encabezado `Content-Type` se fija en consecuencia:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "text/plain; charset=utf-8"
Accept: accept
Request body
input stream
```
1. Amazon Lex deduce la intención (`OrderFlowers`) a partir de la transmisión de entrada. A continuación, elige uno de los slots de la intención (en este caso, `FlowerType`) y una de sus preguntas para obtener valores y, luego, envía una respuesta con los siguientes encabezados:
```
x-amz-lex-dialog-state:ElicitSlot
x-amz-lex-input-transcript:I would like to order some flowers.
x-amz-lex-intent-name:OrderFlowers
x-amz-lex-message:What type of flowers would you like to order?
x-amz-lex-session-attributes:e30=
x-amz-lex-slot-to-elicit:FlowerType
x-amz-lex-slots:eyJQaWNrdXBUaW1lIjpudWxsLCJGbG93ZXJUeXBlIjpudWxsLCJQaWNrdXBEYXRlIjpudWxsfQ==
```
Los valores de encabezado proporcionan la siguiente información:
+ `x-amz-lex-input-transcript`: proporciona la transcripción del audio (entrada del usuario) de la solicitud
+ `x-amz-lex-message`: proporciona la transcripción del audio que devuelve Amazon Lex en la respuesta
+ `x-amz-lex-slots`: la versión de la codificación de base64 de los slots y los valores:
```
{"PickupTime":null,"FlowerType":null,"PickupDate":null}
```
+ `x-amz-lex-session-attributes`: la versión de la codificación de base64 de los atributos de la sesión (\$1\$1)
El cliente reproduce el audio en el cuerpo de la respuesta.
1. El usuario dice: rosas
1. El cliente (la consola) envía la siguiente solicitud [PostContent](API_runtime_PostContent.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "audio/x-l16; sample-rate=16000; channel-count=1"
Accept: "audio/mpeg"
Request body
input stream ("roses")
```
El cuerpo de la solicitud es la transmisión de audio de la entrada del usuario (rosas). No hay `sessionAttributes`.
1. Amazon Lex interpreta la transmisión de entrada en el contexto de la intención actual (recuerda que ha solicitado al usuario información sobre la ranura `FlowerType`). En primer lugar, Amazon Lex actualiza el valor de ranura de la intención actual. Después, elige otro slot (`PickupDate`), junto con uno de los mensajes de pregunta (¿Cuándo desea pasar a por las rosas?) y devuelve una respuesta con los siguientes encabezados:
```
x-amz-lex-dialog-state:ElicitSlot
x-amz-lex-input-transcript:roses
x-amz-lex-intent-name:OrderFlowers
x-amz-lex-message:When do you want to pick up the roses?
x-amz-lex-session-attributes:e30=
x-amz-lex-slot-to-elicit:PickupDate
x-amz-lex-slots:eyJQaWNrdXBUaW1lIjpudWxsLCJGbG93ZXJUeXBlIjoicm9zaSdzIiwiUGlja3VwRGF0ZSI6bnVsbH0=
```
Los valores de encabezado proporcionan la siguiente información:
+ `x-amz-lex-slots`: la versión de la codificación de base64 de los slots y los valores:
```
{"PickupTime":null,"FlowerType":"roses","PickupDate":null}
```
+ `x-amz-lex-session-attributes`: la versión de la codificación de base64 de los atributos de la sesión (\$1\$1)
El cliente reproduce el audio en el cuerpo de la respuesta.
1. El usuario dice: mañana
1. El cliente (la consola) envía la siguiente solicitud [PostContent](API_runtime_PostContent.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "audio/x-l16; sample-rate=16000; channel-count=1"
Accept: "audio/mpeg"
Request body
input stream ("tomorrow")
```
El cuerpo de la solicitud es la transmisión de audio de la entrada del usuario ("mañana"). No hay `sessionAttributes`.
1. Amazon Lex interpreta la transmisión de entrada en el contexto de la intención actual (recuerda que ha solicitado al usuario información sobre la ranura `PickupDate`). Amazon Lex actualiza el valor de ranura (`PickupDate`) de la intención actual. A continuación, elige otro slot para obtener el valor (`PickupTime`) y una de las preguntas para obtener valores (¿Cuándo desea recoger las rosas el 18/03/2017?), y devuelve una respuesta con los siguientes encabezados:
```
x-amz-lex-dialog-state:ElicitSlot
x-amz-lex-input-transcript:tomorrow
x-amz-lex-intent-name:OrderFlowers
x-amz-lex-message:When do you want to pick up the roses on 2017-03-18?
x-amz-lex-session-attributes:e30=
x-amz-lex-slot-to-elicit:PickupTime
x-amz-lex-slots:eyJQaWNrdXBUaW1lIjpudWxsLCJGbG93ZXJUeXBlIjoicm9zaSdzIiwiUGlja3VwRGF0ZSI6IjIwMTctMDMtMTgifQ==
x-amzn-RequestId:3a205b70-0b69-11e7-b447-eb69face3e6f
```
Los valores de encabezado proporcionan la siguiente información:
+ `x-amz-lex-slots`: la versión de la codificación de base64 de los slots y los valores:
```
{"PickupTime":null,"FlowerType":"roses","PickupDate":"2017-03-18"}
```
+ `x-amz-lex-session-attributes`: la versión de la codificación de base64 de los atributos de la sesión (\$1\$1)
El cliente reproduce el audio en el cuerpo de la respuesta.
1. El usuario dice: 18:00 h
1. El cliente (la consola) envía la siguiente solicitud [PostContent](API_runtime_PostContent.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "text/plain; charset=utf-8"
Accept: "audio/mpeg"
Request body
input stream ("6 pm")
```
El cuerpo de la solicitud es la transmisión de audio de la entrada del usuario ("18:00 h"). No hay `sessionAttributes`.
1. Amazon Lex interpreta la transmisión de entrada en el contexto de la intención actual (recuerda que ha solicitado al usuario información sobre la ranura `PickupTime`). Primero actualiza el valor de slot de la intención actual.
Ahora Amazon Lex detecta que tiene información para todas las ranuras. Sin embargo, la intención `OrderFlowers` se ha configurado con un mensaje de confirmación. Por lo tanto, Amazon Lex necesita una confirmación explícita del usuario antes de cumplir con la intención. Envía una respuesta con los siguientes encabezados para solicitar la confirmación antes de encargar las flores:
```
x-amz-lex-dialog-state:ConfirmIntent
x-amz-lex-input-transcript:six p. m.
x-amz-lex-intent-name:OrderFlowers
x-amz-lex-message:Okay, your roses will be ready for pickup by 18:00 on 2017-03-18. Does this sound okay?
x-amz-lex-session-attributes:e30=
x-amz-lex-slots:eyJQaWNrdXBUaW1lIjoiMTg6MDAiLCJGbG93ZXJUeXBlIjoicm9zaSdzIiwiUGlja3VwRGF0ZSI6IjIwMTctMDMtMTgifQ==
x-amzn-RequestId:083ca360-0b6a-11e7-b447-eb69face3e6f
```
Los valores de encabezado proporcionan la siguiente información:
+ `x-amz-lex-slots`: la versión de la codificación de base64 de los slots y los valores:
```
{"PickupTime":"18:00","FlowerType":"roses","PickupDate":"2017-03-18"}
```
+ `x-amz-lex-session-attributes`: la versión de la codificación de base64 de los atributos de la sesión (\$1\$1)
El cliente reproduce el audio en el cuerpo de la respuesta.
1. El usuario dice: Sí
1. El cliente (la consola) envía la siguiente solicitud [PostContent](API_runtime_PostContent.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "audio/x-l16; sample-rate=16000; channel-count=1"
Accept: "audio/mpeg"
Request body
input stream ("Yes")
```
El cuerpo de la solicitud es la transmisión de audio de la entrada del usuario ("Sí"). No hay `sessionAttributes`.
1. Amazon Lex interpreta la transmisión de entrada y entiende que el usuario desea continuar con el pedido. La intención `OrderFlowers` se ha configurado con `ReturnIntent` como la actividad de cumplimiento. Esto provoca que Amazon Lex devuelva todos los datos de la intención al cliente. Amazon Lex devuelve una respuesta con lo siguiente:
```
x-amz-lex-dialog-state:ReadyForFulfillment
x-amz-lex-input-transcript:yes
x-amz-lex-intent-name:OrderFlowers
x-amz-lex-session-attributes:e30=
x-amz-lex-slots:eyJQaWNrdXBUaW1lIjoiMTg6MDAiLCJGbG93ZXJUeXBlIjoicm9zaSdzIiwiUGlja3VwRGF0ZSI6IjIwMTctMDMtMTgifQ==
```
El encabezado de la respuesta `x-amz-lex-dialog-state` está configurado en `ReadyForFulfillment`. Ahora el cliente podrá llevar a cabo la intención.
1. Ahora, pruebe de nuevo el bot. Para establecer un nuevo contexto (usuario), elija el enlace **Clear** en la consola. Proporcione datos para la intención `OrderFlowers` e incluya algunos datos no válidos. Por ejemplo:
+ Jazmín como tipo de flor (este tipo de flor no se admite)
+ Ayer como el día en que desea recoger las flores
Observe que el bot acepta estos valores, ya que no tiene ningún código para inicializar y validar los datos de usuario. En la siguiente sección, añadirá una función de Lambda para que lo haga. Tenga en cuenta lo siguiente en relación con la función de Lambda:
+ Valida los datos de slot después de cada entrada de usuario. Gestiona la intención al final. Es decir, el bot procesa el pedido de flores y devuelve un mensaje al usuario en lugar de simplemente devolver los datos de slot al cliente. Para obtener más información, consulte [Uso de funciones de Lambda](using-lambda.md).
+ También establece 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).
Una vez completada la sección Introducción, puede realizar los ejercicios adicionales ([Ejemplos adicionales: creación de bots de Amazon Lex](additional-exercises.md)). [Reserva de viaje](ex-book-trip.md) usa los atributos de sesión para compartir información entre intenciones y entablar una conversación dinámica con el usuario.
**Paso siguiente**
[Paso 3: creación de una función de Lambda (consola)](gs-bp-create-lambda-function.md)
# Paso 2b (opcional): revisión de los detalles del flujo de información escrita (consola)
En esta sección se explica el flujo de información entre el cliente y Amazon Lex en el que el cliente utiliza la API `PostText` para enviar solicitudes. Para obtener más información, consulte [PostText](API_runtime_PostText.md).
1. El usuario escribe: Me gustaría pedir unas flores
1. El cliente (la consola) envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "I would like to order some flowers",
"sessionAttributes": {}
}
```
Tanto la URI de la solicitud como el cuerpo proporcionan información a Amazon Lex:
+ URI de la solicitud: proporciona el nombre del bot (`OrderFlowers`), el alias del bot (`$LATEST`) y el nombre de usuario (una cadena aleatoria que identifica al 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`. Cuando el cliente realiza la primera solicitud, no existen atributos de la sesión. La función Lambda los inicia más adelante.
1. Amazon Lex deduce la intención (`OrderFlowers`) a partir de `inputText`. Esta intención no tiene ningún enlace de código (es decir, funciones de Lambda) para la inicialización y validación de la entrada del usuario o el cumplimiento.
Amazon Lex elige una de las ranuras de la intención (`FlowerType`) para obtener el valor. También selecciona una de las preguntas para obtener valores para el slot (que forman parte de la configuración de la intención) y, a continuación, envía la siguiente respuesta al cliente. La consola muestra el mensaje en la respuesta al usuario.
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-10.png)
El cliente muestra el mensaje en la respuesta.
1. El usuario escribe: rosas
1. El cliente (la consola) envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "roses",
"sessionAttributes": {}
}
```
El `inputText` del cuerpo de la solicitud proporciona la entrada del usuario. No hay `sessionAttributes`.
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 `FlowerType`). Amazon Lex actualiza primero el valor del slot de la intención actual y elige otro slot (`PickupDate`) junto con uno de los mensajes de pregunta (¿Qué día desea recoger las rosas?) ``para el slot.
A continuación, Amazon Lex devuelve la siguiente respuesta:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-20.png)
El cliente muestra el mensaje en la respuesta.
1. El usuario escribe: mañana
1. El cliente (la consola) envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "tomorrow",
"sessionAttributes": {}
}
```
El `inputText` del cuerpo de la solicitud proporciona la entrada del usuario. No hay `sessionAttributes`.
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 `PickupDate`). Amazon Lex actualiza el valor de ranura (`PickupDate`) de la intención actual. Elige otro slot para obtener un valor para (`PickupTime`). Devuelve una de las preguntas para obtener valores (¿A qué hora quiere que se entreguen las rosas el 05/01/2017?) ``al cliente.
A continuación, Amazon Lex devuelve la siguiente respuesta:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-30.png)
El cliente muestra el mensaje en la respuesta.
1. El usuario escribe: 18:00 h
1. El cliente (la consola) envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "6 pm",
"sessionAttributes": {}
}
```
El `inputText` del cuerpo de la solicitud proporciona la entrada del usuario. No hay `sessionAttributes`.
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 `PickupTime`). En primer lugar, Amazon Lex actualiza el valor de ranura de la intención actual. Ahora Amazon Lex detecta que tiene información para todas las ranuras.
La intención `OrderFlowers` se ha configurado con un mensaje de confirmación. Por lo tanto, Amazon Lex necesita una confirmación explícita del usuario antes de cumplir con la intención. Amazon Lex envía el siguiente mensaje al cliente para solicitar su confirmación antes de pedir las flores:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-40.png)
El cliente muestra el mensaje en la respuesta.
1. El usuario escribe: Sí
1. El cliente (la consola) envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "Yes",
"sessionAttributes": {}
}
```
El `inputText` del cuerpo de la solicitud proporciona la entrada del usuario. No hay `sessionAttributes`.
1. Amazon Lex interpreta `inputText` en el contexto de la confirmación de la intención actual. Entiende que el usuario desea continuar con el pedido. La intención `OrderFlowers` se ha configurado con `ReturnIntent` como la actividad de cumplimiento (no existe ninguna función de Lambda para cumplir con la intención). Por ello, Amazon Lex devuelve los siguientes datos de ranura al cliente.
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-50.png)
Amazon Lex establece `dialogState` en `ReadyForFulfillment`. Ahora el cliente podrá llevar a cabo la intención.
1. Ahora vuelva a probar el bot. Para ello, debe elegir el enlace **Clear** en la consola y establecer un nuevo contexto (usuario). Al proporcionar datos para la intención Pedir flores, intente que sean datos no válidos. Por ejemplo:
+ Jazmín como tipo de flor (este tipo de flor no se admite).
+ Ayer como el día en que desea recoger las flores.
Ten en cuenta que el bot acepta estos valores porque no tienes ningún código para los datos initialize/validate del usuario. En la siguiente sección, añadirá una función de Lambda para que lo haga. Tenga en cuenta lo siguiente en relación con la función de Lambda:
+ La función de Lambda valida los datos de ranura después de cada entrada del usuario. Gestiona la intención al final. Es decir, el bot procesa el pedido de flores y devuelve un mensaje al usuario en lugar de simplemente devolver los datos de slot al cliente. Para obtener más información, consulte [Uso de funciones de Lambda](using-lambda.md).
+ La función de Lambda también establece 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).
Una vez completada la sección Introducción, puede realizar los ejercicios adicionales ([Ejemplos adicionales: creación de bots de Amazon Lex](additional-exercises.md)). [Reserva de viaje](ex-book-trip.md) usa los atributos de sesión para compartir información entre intenciones y entablar una conversación dinámica con el usuario.
**Paso siguiente**
[Paso 3: creación de una función de Lambda (consola)](gs-bp-create-lambda-function.md)
# Paso 3: creación de una función de Lambda (consola)
Cree una función Lambda (mediante el **lex-order-flowers-python**esquema) y realice una invocación de prueba con datos de eventos de muestra en la consola. AWS Lambda
Regrese a la consola de Amazon Lex y agregue la función de Lambda como el enlace de código para cumplir la intención `OrderFlowers` en `OrderFlowersBot` que ha creado en la sección anterior.
**Para crear la función Lambda (consola)**
1. Inicie sesión en la consola Consola de administración de AWS y ábrala en AWS Lambda . [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)
1. Seleccione **Creación de función**.
1. En la página **Create function (Crear función)**, seleccione **Use a blueprint (Utilizar un proyecto)**. Escriba **lex-** en el cuadro de texto de filtro y pulse `Enter` para buscar el proyecto. Seleccione el proyecto `lex-order-flowers-python`.
Los esquemas de funciones de Lambda están en formato Node.js y Python. En este ejercicio, utilizaremos el proyecto basado en Python.
1. En la página **Basic information (Información básica)**, haga lo siguiente:
+ Escriba el nombre de la función de Lambda (`OrderFlowersCodeHook`).
+ Para el rol de ejecución, elija **Crear un nuevo rol con permisos básicos de Lambda**.
+ 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.
1. Haga clic en **Select a test event (Seleccionar un evento de prueba)** y en **Configure test events (Configurar eventos de prueba)**.
1. Seleccione **Amazon Lex Order Flowers (Pedido de flores de Amazon Lex)** en la lista **Event template (Plantilla de eventos)**. Este evento de muestra coincide con el request/response modelo Amazon Lex (consulte[Uso de funciones de Lambda](using-lambda.md)). Asigne un nombre al evento de prueba (`LexOrderFlowersTest`).
1. Seleccione **Crear**.
1. Seleccione **Test (Probar)** para probar el enlace de código.
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.
**Paso siguiente**
[Paso 4: adición de la función de Lambda como enlace de código (consola)](gs-bp-create-integrate.md)
# Paso 4: adición de la función de Lambda como enlace de código (consola)
En esta sección, se actualiza la configuración de la OrderFlowers intención de utilizar la función Lambda de la siguiente manera:
+ Primero debe utilizar la función de Lambda como enlace de código para cumplir con la intención `OrderFlowers`. Puede probar el bot y verificar que ha recibido un mensaje de cumplimiento de la función de Lambda. Amazon Lex invoca la función de Lambda únicamente después de proporcionar datos para todas las ranuras necesarias para pedir flores.
+ Configure la misma función de Lambda como enlace de código para llevar a cabo la inicialización y la validación. Puede probar y comprobar que la función de Lambda realiza la validación (a medida que proporciona datos de ranura).
**Adición de una función de Lambda como enlace de código (consola)**
1. En la consola Amazon Lex, selecciona el **OrderFlowers**bot. La consola muestra la **OrderFlowers**intención. Asegúrese de que la versión de la intención está establecida en `$LATEST` porque esta es la única versión que podemos modificar.
1. Agregue la función de Lambda como enlace de código de cumplimiento y pruébela.
1. En el editor, elija **AWS Lambda Función** como **Cumplimiento** y seleccione la función de Lambda que ha creado en el paso anterior (`OrderFlowersCodeHook`). Elija **Aceptar** para dar a Amazon Lex permiso para invocar la función de Lambda.
Está configurando esta función de Lambda como un enlace de código para cumplir con la intención. Amazon Lex invoca esta función únicamente después de disponer de todos los datos de ranura necesarios para llevar a cabo la intención.
1. Especifique un **mensaje de despedida**.
1. Elija **Compilar**.
1. Pruebe el bot utilizando la conversación anterior.
La última frase, “Gracias, su pedido de rosas…”, es una respuesta de la función de Lambda configurada como enlace de código. En la sección anterior, no había ninguna función de Lambda. Ahora utiliza una función de Lambda para cumplir realmente la intención `OrderFlowers`.
1. Añada la función de Lambda como un enlace de código de inicialización y validación y pruébela.
El código del ejemplo de función de Lambda que utiliza se encarga tanto de la validación de la entrada del usuario como del cumplimiento. El evento de entrada que recibe la función de Lambda tiene un campo (`invocationSource`) que el código utiliza para determinar qué parte del código debe ejecutar. 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).
1. Seleccione la versión \$1LATEST de la intención `OrderFlowers`. Esa es la única versión que puede actualizar.
1. En el Editor, seleccione **Initialization and validation** en **Options**.
1. De nuevo, seleccione la misma función de Lambda.
1. Elija **Compilar**.
1. Pruebe el bot.
Ahora está listo para conversar con Amazon Lex como se indica en la siguiente imagen. Para probar la parte de validación, elija la hora 18:00. La función de Lambda devolverá una respuesta (“Nuestro horario es de 10:00 a 17:00 horas”) y le preguntará de nuevo. Después de proporcionar todos los datos de ranura válidos, la función de Lambda realizará el pedido.
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/OrderFlowers-FullLambda.png)
**Paso siguiente**
[Paso 5 (opcional): revisión de los detalles del flujo de información (consola)](gs-bp-details-after-lambda.md)
# Paso 5 (opcional): revisión de los detalles del flujo de información (consola)
En esta sección se explica el flujo de información entre el cliente y Amazon Lex para cada entrada del usuario, incluida la integración de la función de Lambda.
**nota**
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 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).
Para obtener más información sobre la API en tiempo de ejecución `PostText` y detalles adicionales sobre las solicitudes y las respuestas que se muestran en los siguientes pasos, consulte [PostText](API_runtime_PostText.md).
1. Usuario: Me gustaría pedir unas flores.
1. El cliente (la consola) envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "I would like to order some flowers",
"sessionAttributes": {}
}
```
Tanto la URI de la solicitud como el cuerpo proporcionan información a Amazon Lex:
+ URI de la solicitud: proporciona el nombre del bot (`OrderFlowers`), el alias del bot (`$LATEST`) y el nombre de usuario (una cadena aleatoria que identifica al 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`. Cuando el cliente realiza la primera solicitud, no existen atributos de la sesión. La función Lambda los inicia más adelante.
1. Amazon Lex deduce la intención (`OrderFlowers`) 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 mediante la transferencia de la siguiente información como datos de eventos:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "ignw84y6seypre4xly5rimopuri2xwnd",
"sessionAttributes": {},
"bot": {
"name": "OrderFlowers",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"PickupTime": null,
"FlowerType": null,
"PickupDate": null
},
"confirmationStatus": "None"
}
}
```
Para obtener más información, consulte [Formato del evento de entrada](lambda-input-response-format.md#using-lambda-input-event-format).
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, es para inicializar y validar los datos del usuario. En este punto, Amazon Lex sabe que el usuario no ha proporcionado todos los datos de ranura necesarios para cumplir la intención.
+ Información de `currentIntent` con todos los valores de slot establecidos en 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:
```
{
"sessionAttributes": {},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": null,
"PickupDate": null
}
}
}
```
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).
Tenga en cuenta lo siguiente:
+ `dialogAction.type`: al establecer este valor en `Delegate`, la función de Lambda delega la responsabilidad de decidir el siguiente procedimiento a Amazon Lex.
**nota**
Si la función de Lambda detecta algo en la validación de los datos de usuario, indica a Amazon Lex el siguiente paso, tal como se muestra a continuación.
1. De acuerdo con `dialogAction.type`, Amazon Lex decide cómo continuar. Puesto que ninguno de los slots tiene información, decide obtener el valor del slot `FlowerType`. Selecciona una de las preguntas para obtener valores para el slot ("¿Qué tipo de flores le gustaría pedir?") y envía la siguiente respuesta al cliente:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-10.png)
El cliente muestra el mensaje en la respuesta.
1. Usuario: rosas
1. El cliente envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "roses",
"sessionAttributes": {}
}
```
En el cuerpo de la solicitud, `inputText` proporciona la entrada del usuario. No hay `sessionAttributes`.
1. Amazon Lex interpreta primero `inputText` en el contexto de la confirmación de la intención actual. El servicio recuerda que ha solicitado al usuario específico información acerca del slot `FlowerType`. Actualiza el valor de la ranura para la intención actual e invoca la función de Lambda con los siguientes datos de evento:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "ignw84y6seypre4xly5rimopuri2xwnd",
"sessionAttributes": {},
"bot": {
"name": "OrderFlowers",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": null
},
"confirmationStatus": "None"
}
}
```
Tenga en cuenta lo siguiente:
+ `invocationSource`: sigue siendo `DialogCodeHook` (simplemente validamos los datos de usuario).
+ `currentIntent.slots`: Amazon Lex ha actualizado la ranura `FlowerType` con “roses”.
1. Al establecer el valor `invocationSource` como `DialogCodeHook`, la función de Lambda valida los datos del usuario. Reconoce `roses` como un valor de ranura válido (y establece `Price` como atributo de la sesión) y devuelve la siguiente respuesta a Amazon Lex.
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": null
}
}
}
```
Tenga en cuenta lo siguiente:
+ `sessionAttributes`: la función de Lambda ha agregado `Price` (de las rosas) como un atributo de la sesión.
+ `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 (`PickupDate`) con la mayor prioridad según la configuración de la intención. Amazon Lex selecciona uno de los mensajes de pregunta (“¿Qué día desea recoger las rosas?”) para esta ranura, según la configuración de la intención y, a continuación, envía esta respuesta al cliente:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-20.png)
El cliente simplemente muestra el mensaje en la respuesta: "¿Qué día desea recoger las rosas?."
1. Usuario: mañana
1. El cliente envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "tomorrow",
"sessionAttributes": {
"Price": "25"
}
}
```
En el cuerpo de la solicitud, `inputText` proporciona la entrada del usuario y el cliente devuelve los atributos de la sesión al servicio.
1. Amazon Lex recuerda el contexto; es decir, que está obteniendo datos para la ranura `PickupDate`. En este contexto, sabe que el valor de `inputText` es para el slot `PickupDate`. A continuación, Amazon Lex llama la función de Lambda mediante el envío de los siguientes eventos:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "ignw84y6seypre4xly5rimopuri2xwnd",
"sessionAttributes": {
"Price": "25"
},
"bot": {
"name": "OrderFlowersCustomWithRespCard",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": "2017-01-05"
},
"confirmationStatus": "None"
}
}
```
Amazon Lex ha actualizado `currentIntent.slots` al establecer el valor `PickupDate`. Además, tenga en cuenta que el servicio pasa `sessionAttributes` tal cual a la función de Lambda.
1. Al establecer el valor `invocationSource` como `DialogCodeHook`, la función de Lambda valida los datos de usuario. Reconoce que el valor de la ranura `PickupDate` es válido y devuelve la siguiente respuesta a Amazon Lex:
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": "2017-01-05"
}
}
}
```
Tenga en cuenta lo siguiente:
+ `sessionAttributes`: sin cambios.
+ `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 (`PickupTime`) con la mayor prioridad según la configuración de la intención. Amazon Lex selecciona uno de los mensajes de pregunta (“¿A qué hora quiere que se entreguen las rosas el 05/01/2017?”) para esta ranura, según la configuración de la intención y, a continuación, envía esta respuesta al cliente:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-30.png)
El cliente muestra el mensaje en la respuesta: “¿A qué hora quiere que entreguen las rosas el 05/01/2017?”.
1. Usuario: 16:00 h
1. El cliente envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "4 pm",
"sessionAttributes": {
"Price": "25"
}
}
```
En el cuerpo de la solicitud, `inputText` proporciona la entrada del usuario. El cliente pasa los `sessionAttributes` en la solicitud.
1. Amazon Lex entiende el contexto. Entiende que estaba obteniendo datos para el slot `PickupTime`. En este contexto, sabe que el valor `inputText` es para la ranura `PickupTime`. A continuación, Amazon Lex llama la función de Lambda mediante el envío de los siguientes eventos:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "ignw84y6seypre4xly5rimopuri2xwnd",
"sessionAttributes": {
"Price": "25"
},
"bot": {
"name": "OrderFlowersCustomWithRespCard",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"PickupTime": "16:00",
"FlowerType": "roses",
"PickupDate": "2017-01-05"
},
"confirmationStatus": "None"
}
}
```
Amazon Lex ha actualizado `currentIntent.slots` al establecer el valor `PickupTime`.
1. Al establecer el valor `invocationSource` como `DialogCodeHook`, la función de Lambda valida los datos del usuario. Reconoce que el valor de la ranura `PickupDate` es válido y devuelve la siguiente respuesta a Amazon Lex.
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": "16:00",
"FlowerType": "roses",
"PickupDate": "2017-01-05"
}
}
}
```
Tenga en cuenta lo siguiente:
+ `sessionAttributes`: sin cambios en el atributo de la sesión.
+ `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. En este punto, Amazon Lex sabe que dispone de todos los datos de ranura. Esta intención se ha configurado con un mensaje de confirmación. Por lo tanto, Amazon Lex envía la siguiente respuesta al usuario para solicitar su confirmación antes de cumplir con la intención:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-45.png)
El cliente simplemente muestra el mensaje en la respuesta y espera la respuesta del usuario.
1. Usuario: Sí
1. El cliente envía la siguiente solicitud [PostText](API_runtime_PostText.md) a Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "yes",
"sessionAttributes": {
"Price": "25"
}
}
```
1. Amazon Lex interpreta `inputText` en el contexto de la confirmación de la intención actual. Amazon Lex entiende que el usuario desea continuar con el pedido. Esta vez, Amazon Lex invoca la función de Lambda para cumplir la intención mediante el envío del siguiente evento, que establece `invocationSource` en `FulfillmentCodeHook` en el caso de que se envíe a la función. Amazon Lex también establece `confirmationStatus` en `Confirmed`.
```
{
"messageVersion": "1.0",
"invocationSource": "FulfillmentCodeHook",
"userId": "ignw84y6seypre4xly5rimopuri2xwnd",
"sessionAttributes": {
"Price": "25"
},
"bot": {
"name": "OrderFlowersCustomWithRespCard",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"PickupTime": "16:00",
"FlowerType": "roses",
"PickupDate": "2017-01-05"
},
"confirmationStatus": "Confirmed"
}
}
```
Tenga en cuenta lo siguiente:
+ `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 de Lambda cumple con la intención `OrderFlowers` y devuelve la siguiente respuesta:
```
{
"sessionAttributes": {
"Price": "25"
},
"dialogAction": {
"type": "Close",
"fulfillmentState": "Fulfilled",
"message": {
"contentType": "PlainText",
"content": "Thanks, your order for roses has been placed and will be ready for pickup by 16:00 on 2017-01-05"
}
}
}
```
Tenga en cuenta lo siguiente:
+ Establece `dialogAction.type`: la función de Lambda establece este valor en `Close` para que Amazon Lex no espere una 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 de vuelta al cliente:
A continuación, Amazon Lex devuelve lo siguiente al cliente:
![\[\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs-1-details-48.png)
Tenga en cuenta que:
+ `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.
1. Ahora vuelva a probar el bot. Para establecer un nuevo contexto (usuario), elija el enlace **Clear** en la ventana de prueba. Ahora proporcione datos de slot no válidos para la intención `OrderFlowers`. Esta vez, la función de Lambda valida los datos, restablece el valor de los datos de ranura no válidos en nulo y pide a Amazon Lex que solicite al usuario datos válidos. Por ejemplo, pruebe lo siguiente:
+ Jazmín como tipo de flor (este tipo de flor no se admite).
+ Ayer como el día en que desea recoger las flores.
+ Después de realizar el pedido, escriba otro tipo de flores en lugar de responder "sí" para confirmar el pedido. Como respuesta, la función de Lambda actualiza `Price` en el atributo de la sesión y mantiene un recuento actual de los pedidos de flores.
La función de Lambda también lleva a cabo la actividad de cumplimiento.
**Paso siguiente**
[Paso 6: actualización de la configuración de la intención para añadir un enunciado (consola)](gs-bp-utterance.md)
# Paso 6: actualización de la configuración de la intención para añadir un enunciado (consola)
El bot `OrderFlowers` está configurado con tan solo dos enunciados. Esto proporciona información limitada para que Amazon Lex genere un modelo de machine learning que reconozca la intención del usuario y responda a esta. Pruebe a escribir “Deseo encargar flores” en la siguiente ventana de pruebas. Amazon Lex no reconoce el texto y responde “No he entendido, ¿qué desea hacer?”. Puede mejorar el modelo de machine learning añadiendo más enunciados.
![\[Ventana de pruebas con un enunciado no reconocido\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs1-120.png)
Cada enunciado que agrega proporciona a Amazon Lex más información sobre cómo responder a los usuarios. No es necesario añadir un enunciado, exacto, Amazon Lex generaliza a partir de las muestras que proporcione para reconocer las coincidencias exactas y entradas similares.
**Para añadir un enunciado (consola)**
1. Escriba el enunciado “Quiero flores” en la sección **Ejemplos de enunciados** del editor de intenciones para agregarlo, tal como se indica en la siguiente imagen, y, a continuación, haga clic en el icono del signo más situado junto a la nueva publicación.
![\[Editor de intenciones con el nuevo enunciado\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs1-130.png)
1. Compile el bot para incluir el cambio. Elija **Build** y vuelva a elegir **Build**.
1. Pruebe el bot para confirmar que reconoce el nuevo enunciado. En la ventana de pruebas, tal como se indica en la siguiente imagen, escriba “Quiero pedir flores”. Amazon Lex reconoce la frase y responde con “¿Qué tipo de flores desea encargar?”.
![\[El editor de intenciones reconoce el nuevo enunciado\]](http://docs.aws.amazon.com/es_es/lex/latest/dg/images/gs1-140.png)
**Paso siguiente**
[Paso 7 (opcional): eliminar recursos (consola)](gs-bp-cleaning-up.md)
# Paso 7 (opcional): eliminar recursos (consola)
Ahora va a eliminar los recursos que ha creado y a limpiar la cuenta.
Puede eliminar únicamente los recursos que no se usan. En general, debería eliminar los recursos en el orden que se indica a continuación:
+ Eliminar bots para liberar los recursos de las intenciones.
+ Eliminar intenciones para liberar los recursos de los tipos de slot.
+ Por último, eliminar el tipo de slot.
**Para limpiar la cuenta (consola)**
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 lista de bots, selecciona la casilla de verificación situada junto a **OrderFlowers**.
1. Para borrar el bot, elija **Delete** y luego elija **Continue** en el cuadro de diálogo de confirmación.
1. En el panel izquierdo, elija **Intents**.
1. En la lista de intenciones, elija **OrderFlowersIntent**.
1. Para eliminar la intención, elija **Delete** y luego elija **Continue** en el cuadro de diálogo de confirmación.
1. En el panel izquierdo, elija **Slot types**.
1. En la lista de tipos de slot, elija **Flowers**.
1. Para borrar el tipo de slot, elija **Delete** y luego elija **Continue** en el cuadro de diálogo de confirmación.
Ha eliminado todos los recursos de Amazon Lex que ha creado y ha limpiado su cuenta. Si lo desea, puede utilizar la [consola de Lambda](https://console.aws.amazon.com/lambda) para eliminar la función de Lambda que se utiliza en este ejercicio.