Aviso de fim do suporte: em 15 de setembro de 2025, o suporte para o Amazon Lex V1 AWS será interrompido. Após 15 de setembro de 2025, você não poderá mais acessar o console do Amazon Lex V1 nem os respectivos recursos. Se você estiver usando o Amazon Lex V2, consulte o [guia do Amazon Lex V2](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html) em vez disso.
As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Exercício 1: Criar um bot do Amazon Lex usando um esquema (Console).
Neste exercício, você faz o seguinte:
+ Crie seu primeiro bot do Amazon Lex e teste-o no console do Amazon Lex.
Para este exercício, você usa o **OrderFlowers**modelo. Para obter mais informações sobre esquemas, consulte [Amazon Lex e AWS Lambda Blueprints](lex-lambda-blueprints.md).
+ Crie uma AWS Lambda função e teste-a no console Lambda. Ao processar uma solicitação, seu bot chama a função do Lambda. Para este exercício, você usa um blueprint do Lambda (**lex-order-flowers-python**) fornecido no AWS Lambda console para criar sua função do Lambda. O código de esquema ilustra como você pode usar a mesma função do Lambda para realizar a inicialização e validação, e cumprir a intenção `OrderFlowers`.
+ Atualize o bot para adicionar a função do Lambda como o hook de código para cumprir a intenção. Teste a end-to-end experiência.
As seções a seguir explicam o que os esquemas fazem.
## Bot do Amazon Lex: visão geral do esquema
Você usa o **OrderFlowers**blueprint para criar um bot do Amazon Lex. Para obter mais informações sobre a estrutura de um bot, consulte. [Amazon Lex: como funciona](how-it-works.md) O bot é pré-configurado da seguinte forma:
+ **Intenção** — OrderFlowers
+ **Tipos de slot** – Um tipo de slot personalizado chamado `FlowerTypes` com valores de enumeração: `roses`, `lilies` e `tulips`.
+ **Slots** – a intenção requer as seguintes informações (slots) antes de o bot cumprir a intenção.
+ `PickupTime` (tipo integrado AMAZON.TIME)
+ `FlowerType`(tipo FlowerTypes personalizado)
+ `PickupDate` (tipo integrado AMAZON.DATE)
+ **Utterance**: a seguinte amostra de declaração indica a intenção do usuário:
+ "Gostaria de escolher flores."
+ "Gostaria de pedir algumas flores."
+ **Prompts** – Após o bot identificar a intenção, ele usa os seguintes prompts para preencher slots:
+ Prompt do slot `FlowerType` – "Que tipo de flores você deseja pedir?"
+ Solicite a `PickupDate` vaga — “Em que dia você quer que o \$1FlowerType\$1 seja retirado?”
+ Solicitar o `PickupTime` slot — “A que horas você deseja que o \$1FlowerType\$1 seja retirado?”
+ Declaração de confirmação — “Ok, seu \$1FlowerType\$1 estará pronto para retirada até \$1PickupTime\$1 em \$1PickupDate\$1. Tudo bem?"
## AWS Lambda Função: Resumo do plano
A função do Lambda neste exercício executa a inicialização e a validação e as tarefas de atendimento. Portanto, após criar a função do Lambda, você deve atualizar a configuração da intenção especificando a mesma função do Lambda como um hook de código para lidar com a inicialização e a validação e as tarefas de atendimento.
+ Como hook de inicialização e validação, a função do Lambda executa uma validação básica. Por exemplo, se o usuário fornecer uma hora de retirada fora do horário comercial normal, a função do Lambda direcionará o Amazon Lex para solicitar que o usuário insira o horário novamente.
+ Como parte do hook de código de atendimento, a função do Lambda retorna uma mensagem resumida indicando que o pedido de flores foi feito (ou seja, a intenção é atendida).
**Próxima etapa**
[Etapa 1: criar um bot Amazon Lex (console)](gs-bp-create-bot.md)
# Etapa 1: criar um bot Amazon Lex (console)
Para este exercício, crie um bot para pedir flores, chamado OrderFlowersBot.
Para criar um bot Amazon Lex (console)
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Lex em [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Se este for o seu primeiro bot, selecione **Get Started (Conceitos básicos)**; caso contrário, na página **Bots**, escolha **Criar**.
1. Na página **Create your Lex bot**, forneça as informações a seguir e escolha **Create**.
+ Escolha o esquema **OrderFlowers**.
+ Deixe o nome padrão do bot (OrderFlowers).
+ Em **COPPA**, selecione **No**.
+ Para **Armazenamento de declarações do usuário**, escolha a resposta apropriada.
1. Escolha **Criar**. O console faz as solicitações necessárias ao Amazon Lex para salvar a configuração. Em seguida, o console exibe a janela do editor de bot.
1. Aguarde a confirmação de criação do bot.
1. Teste o bot.
**nota**
Você pode testar o bot digitando o texto na janela de teste ou, em navegadores compatíveis, selecionando o botão de microfone na janela de teste e falando.
Use o texto de exemplo a seguir para começar uma conversa com o bot e encomendar flores:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/OrderFlowers-NoLambda.png)
Nesta entrada, o bot infere a intenção `OrderFlowers` e solicita os dados de slot. Quando você fornecer todas os dados de slot necessários, o bot cumprirá a intenção (`OrderFlowers`) retornando todas as informações para o aplicativo cliente (neste caso, o console). O console mostra as informações na janela de teste.
Especificamente:
+ Na instrução "Em que dia você deseja que as rosas sejam entregues?", o termo "rosas" aparece porque a solicitação para o slot `pickupDate` é configurada usando substituições, `{FlowerType}`. Verifique isso no console.
+ A instrução "Está bem, as rosas estarão prontas..." é a solicitação de confirmação que você configurou.
+ A última instrução ("`FlowerType:roses...`") contém apenas os dados do slot que são retornados ao cliente, neste caso, na janela de teste. No próximo exercício, você usará uma função do Lambda para atender à intenção. Nesse caso, você recebe uma mensagem indicando que o pedido foi atendido.
**Próxima etapa**
[Etapa 2 (opcional): revisar os detalhes do fluxo de informações (console)](gs-bp-details-two-runtime-apis.md)
# Etapa 2 (opcional): revisar os detalhes do fluxo de informações (console)
Esta seção explica o fluxo de informações entre um cliente e o Amazon Lex para cada entrada do usuário em nossa conversa de exemplo.
O exemplo usa a janela de teste do console para a conversa com o bot.
**Para abrir a janela de teste do Amazon Lex**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Lex em [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Escolha o bot a ser testado.
1. No lado direito do console, escolha **Testar chatbot**.
Para ver o fluxo de informações do conteúdo falado ou digitado, escolha o tópico apropriado.
**Topics**
+ [Etapa 2a (opcional): revisar os detalhes do fluxo de informações falado (console)](gs-bp-details-postcontent-flow.md)
+ [Etapa 2b (opcional): revisar os detalhes do fluxo de informações digitado (console)](gs-bp-details-part1.md)
# Etapa 2a (opcional): revisar os detalhes do fluxo de informações falado (console)
Esta seção explica o fluxo de informações entre o cliente e o Amazon Lex quando o cliente usa fala para enviar solicitações. Para obter mais informações, consulte [PostContent](API_runtime_PostContent.md).
1. O usuário diz: Eu gostaria de encomendar flores.
1. O cliente (console) envia a seguinte solicitação [PostContent](API_runtime_PostContent.md) para o 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
```
O URI de solicitação e o corpo fornecem informações ao Amazon Lex:
+ URI da solicitação fornece o nome do bot (`OrderFlowers`), o alias do bot (`$LATEST`) e o nome do usuário (uma string aleatória que identifica o usuário). `content` indica que esta é uma solicitação da API `PostContent` (não uma solicitação `PostText`).
+ Cabeçalhos de solicitação
+ `x-amz-lex-session-attributes`: o valor codificado em base64 representa "\$1\$1". Quando o cliente faz a primeira solicitação, não há atributos de sessão.
+ `Content-Type` – reflete o formato de áudio.
+ Corpo da solicitação – o stream de áudio de entrada do usuário ("Eu gostaria de encomendar flores.").
**nota**
Se o usuário escolher enviar texto ("Eu gostaria de encomendar flores") para a API `PostContent` em vez falar, o corpo da solicitação será a entrada do usuário. O cabeçalho `Content-Type` é definido adequadamente:
```
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. No fluxo de entrada, o Amazon Lex detecta a intenção (`OrderFlowers`). Em seguida, ele escolhe um dos slots da intenção (neste caso, o `FlowerType`) e um de seus prompts de seleção de valor e envia uma resposta com os seguintes cabeçalhos:
```
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==
```
Os valores do cabeçalho fornecem as seguintes informações:
+ `x-amz-lex-input-transcript` – fornece a transcrição do áudio (entrada do usuário) da solicitação
+ `x-amz-lex-message`: fornece a transcrição do áudio que Amazon Lex retornou na resposta
+ `x-amz-lex-slots` – a versão codificada em base64 dos slots e valores:
```
{"PickupTime":null,"FlowerType":null,"PickupDate":null}
```
+ `x-amz-lex-session-attributes`: a versão codificada em base64 dos atributos de sessão (\$1\$1)
O cliente reproduz o áudio no corpo da resposta.
1. O usuário diz: rosas
1. O cliente (console) envia a seguinte solicitação [PostContent](API_runtime_PostContent.md) para o 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")
```
O corpo da solicitação é o stream de áudio de entrada do usuário (rosas). O `sessionAttributes` permanece vazio.
1. O Amazon Lex interpreta o fluxo de entrada no contexto da intenção atual (ele lembra que pediu ao usuário informações a respeito do slot `FlowerType`). Primeiro, o Amazon Lex atualiza o valor de slot para a intenção atual. Em seguida, ele escolhe outro slot (`PickupDate`), juntamente com uma das mensagens de solicitação (Quando você deseja pegar as rosas?) e retorna uma resposta com os seguintes cabeçalhos:
```
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=
```
Os valores do cabeçalho fornecem as seguintes informações:
+ `x-amz-lex-slots`: a versão codificada em base64 dos slots e valores:
```
{"PickupTime":null,"FlowerType":"roses","PickupDate":null}
```
+ `x-amz-lex-session-attributes`: a versão codificada em base64 dos atributos de sessão (\$1\$1)
O cliente reproduz o áudio no corpo da resposta.
1. O usuário diz: amanhã
1. O cliente (console) envia a seguinte solicitação [PostContent](API_runtime_PostContent.md) para o 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")
```
O corpo da solicitação é o stream de áudio de entrada do usuário ("amanhã"). O `sessionAttributes` permanece vazio.
1. O Amazon Lex interpreta o fluxo de entrada no contexto da intenção atual (ele lembra que pediu ao usuário informações a respeito do slot `PickupDate`). O Amazon Lex atualiza o valor de slot (`PickupDate`) para a intenção atual. Em seguida, ele escolhe outro slot para escolher o valor para (`PickupTime`) e um dos prompts de seleção de valor (Quando você deseja receber as rosas em 18/03/2017?), e retorna uma resposta com os seguintes cabeçalhos:
```
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
```
Os valores do cabeçalho fornecem as seguintes informações:
+ `x-amz-lex-slots`: a versão codificada em base64 dos slots e valores:
```
{"PickupTime":null,"FlowerType":"roses","PickupDate":"2017-03-18"}
```
+ `x-amz-lex-session-attributes`: a versão codificada em base64 dos atributos de sessão (\$1\$1)
O cliente reproduz o áudio no corpo da resposta.
1. O usuário diz: 18h
1. O cliente (console) envia a seguinte solicitação [PostContent](API_runtime_PostContent.md) para o 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")
```
O corpo da solicitação é o stream de áudio de entrada do usuário ("18h"). O `sessionAttributes` permanece vazio.
1. O Amazon Lex interpreta o fluxo de entrada no contexto da intenção atual (ele lembra que pediu ao usuário informações a respeito do slot `PickupTime`). Primeiro, ele atualiza o valor do slot para a intenção atual.
Agora, o Amazon Lex detecta que tem informações de todos os slots. No entanto, a intenção `OrderFlowers` é configurada com uma mensagem de confirmação. Portanto, o Amazon Lex precisa de uma confirmação explícita do usuário para poder prosseguir para o atendimento da intenção. Ele envia uma resposta com os seguintes cabeçalhos solicitando a confirmação antes de encomendar as 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
```
Os valores do cabeçalho fornecem as seguintes informações:
+ `x-amz-lex-slots`: a versão codificada em base64 dos slots e valores:
```
{"PickupTime":"18:00","FlowerType":"roses","PickupDate":"2017-03-18"}
```
+ `x-amz-lex-session-attributes`: a versão codificada em base64 dos atributos de sessão (\$1\$1)
O cliente reproduz o áudio no corpo da resposta.
1. O usuário diz: Sim
1. O cliente (console) envia a seguinte solicitação [PostContent](API_runtime_PostContent.md) para o 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")
```
O corpo da solicitação é o stream de áudio de entrada do usuário ("Sim"). O `sessionAttributes` permanece vazio.
1. O Amazon Lex interpreta o fluxo de entrada e entende que o usuário deseja prosseguir com o pedido. A intenção `OrderFlowers` é configurada com `ReturnIntent` como a atividade de cumprimento. Isso orienta o Amazon Lex a retornar todos os dados de intenção ao cliente. O Amazon Lex retorna uma resposta com o seguinte:
```
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==
```
O cabeçalho de resposta `x-amz-lex-dialog-state` é definido como `ReadyForFulfillment`. O cliente pode, então, cumprir a intenção.
1. Agora, teste novamente o bot. Para estabelecer um novo contexto (usuário), escolha o link **Clear** no console. Forneça os dados para a intenção `OrderFlowers` e inclua alguns dados inválidos. Por exemplo:
+ Jasmim como o tipo de flor (não é um dos tipos de flor suportados)
+ Ontem como o dia em que você deseja receber as flores
Observe que o bot aceita esses valores, pois você não tem nenhum código para inicializar e validar os dados do usuário. Na próxima seção, adicione uma função do Lambda para fazer isso. Observe o seguinte sobre a função do Lambda:
+ Ela valida dados de slot após cada entrada do usuário. Ela cumpre a intenção no final. Ou seja, o bot processa o pedido de flores e retorna uma mensagem para o usuário, em vez de simplesmente retornar dados do slot para o cliente. Para obter mais informações, consulte [Uso de funções do Lambda](using-lambda.md).
+ Ela também define os atributos da sessão. Para mais informações sobre atributos de sessão, consulte [PostText](API_runtime_PostText.md).
Ao concluir a seção Conceitos básicos, você pode fazer os exercícios adicionais ([Exemplos adicionais: criação de bots do Amazon Lex](additional-exercises.md)). O [Reservar uma viagem](ex-book-trip.md) usa atributos de sessão para compartilhar informações entre intenções para iniciar uma conversa dinâmica com o usuário.
**Próxima etapa**
[Etapa 3: Crie uma função do Lambda (console)](gs-bp-create-lambda-function.md)
# Etapa 2b (opcional): revisar os detalhes do fluxo de informações digitado (console)
Esta seção explica o fluxo de informações entre o cliente e o Amazon Lex, em que o cliente usa a API `PostText` para enviar solicitações. Para obter mais informações, consulte [PostText](API_runtime_PostText.md).
1. O usuário digita: Eu gostaria de encomendar flores.
1. O cliente (console) envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o 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": {}
}
```
O URI de solicitação e o corpo fornecem informações ao Amazon Lex:
+ URI de solicitação: fornece o nome do bot (`OrderFlowers`), o alias do bot (`$LATEST`) e o nome do usuário (uma string aleatória que identifica o usuário). O `text` final indica que esta é uma solicitação de API `PostText` (e não `PostContent`).
+ Corpo da solicitação: inclui a entrada do usuário (`inputText`) e `sessionAttributes` vazio. Quando o cliente faz a primeira solicitação, não há atributos de sessão. A função do Lambda as inicia posteriormente.
1. A partir de `inputText`, o Amazon Lex detecta a intenção (`OrderFlowers`). Essa intenção não tem nenhum hook de código (ou seja, as funções do Lambda) para inicialização e validação do atendimento ou da entrada do usuário.
O Amazon Lex escolhe um dos slots (`FlowerType`) da intenção para obter o valor. Ele também seleciona uma das solicitações de escolha de valor para o slot (tudo parte da configuração de intenção) e, em seguida, envia a resposta a seguir de volta para o cliente. O console exibe a mensagem na resposta para o usuário.
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-10.png)
O cliente exibe a mensagem na resposta.
1. O usuário digita: rosas
1. O cliente (console) envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "roses",
"sessionAttributes": {}
}
```
O `inputText` no corpo da solicitação fornece entradas do usuário. O `sessionAttributes` permanece vazio.
1. Primeiro, o Amazon Lex interpreta o `inputText` no contexto da intenção atual (o serviço lembra que pediu ao usuário específico informações sobre o slot `FlowerType`). O Amazon Lex atualiza o valor de slot para a intenção atual e escolhe outro slot (`PickupDate`) junto com um de seus prompts de mensagens, “Em que dia você deseja que as rosas sejam entregues?”, `` para o slot.
Em seguida, o Amazon Lex retorna a seguinte resposta:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-20.png)
O cliente exibe a mensagem na resposta.
1. O usuário digita: amanhã
1. O cliente (console) envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "tomorrow",
"sessionAttributes": {}
}
```
O `inputText` no corpo da solicitação fornece entradas do usuário. O `sessionAttributes` permanece vazio.
1. Primeiro, o Amazon Lex interpreta o `inputText` no contexto da intenção atual (o serviço lembra que pediu ao usuário específico informações sobre o slot `PickupDate`). O Amazon Lex atualiza o valor de slot (`PickupDate`) para a intenção atual. Ele escolhe outro slot para obter o valor para (`PickupTime`). Ele retorna uma das solicitações de escolha de valor, “Entregar as rosas a que horas em 05/01/2017?” `` para o cliente.
Em seguida, o Amazon Lex retorna a seguinte resposta:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-30.png)
O cliente exibe a mensagem na resposta.
1. O usuário digita: 18h
1. O cliente (console) envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "6 pm",
"sessionAttributes": {}
}
```
O `inputText` no corpo da solicitação fornece entradas do usuário. O `sessionAttributes` permanece vazio.
1. Primeiro, o Amazon Lex interpreta o `inputText` no contexto da intenção atual (o serviço lembra que pediu ao usuário específico informações sobre o slot `PickupTime`). Primeiro, o Amazon Lex atualiza o valor de slot para a intenção atual. Agora, o Amazon Lex detecta que tem informações de todos os slots.
A intenção `OrderFlowers` é configurada com uma mensagem de confirmação. Portanto, o Amazon Lex precisa de uma confirmação explícita do usuário para poder prosseguir para o atendimento da intenção. O Amazon Lex envia a seguinte mensagem para o cliente solicitando confirmação antes de encomendar as flores:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-40.png)
O cliente exibe a mensagem na resposta.
1. O usuário digita: Sim
1. O cliente (console) envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "Yes",
"sessionAttributes": {}
}
```
O `inputText` no corpo da solicitação fornece entradas do usuário. O `sessionAttributes` permanece vazio.
1. O Amazon Lex interpreta o `inputText` no contexto de confirmação da intenção atual. Ele entende que o usuário deseja prosseguir com o pedido. A intenção `OrderFlowers` é configurada com `ReturnIntent` como a atividade de cumprimento (não há função do Lambda para cumprir a intenção). Portanto, o Amazon Lex retorna os dados do slot ao cliente.
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-50.png)
O Amazon Lex definiu `dialogState` como `ReadyForFulfillment`. O cliente pode, então, cumprir a intenção.
1. Agora teste o bot novamente. Para isso, selecione o link **Clear** no console para estabelecer um novo contexto (de usuário). Agora, conforme você fornece dados para a intenção de encomenda de flores, tente fornecer dados inválidos. Por exemplo:
+ Jasmim como o tipo de flor (não é um dos tipos de flor suportados).
+ Ontem como o dia em que você deseja receber as flores.
Observe que o bot aceita esses valores porque você não tem nenhum código para os dados initialize/validate do usuário. Na próxima seção, adicione uma função do Lambda para fazer isso. Observe o seguinte sobre a função do Lambda:
+ A função do Lambda valida os dados do slot depois de cada entrada do usuário. Ela cumpre a intenção no final. Ou seja, o bot processa o pedido de flores e retorna uma mensagem para o usuário, em vez de simplesmente retornar dados de slot para o cliente. Para obter mais informações, consulte [Uso de funções do Lambda](using-lambda.md).
+ A função do Lambda também define os atributos da sessão. Para mais informações sobre atributos de sessão, consulte [PostText](API_runtime_PostText.md).
Ao concluir a seção Conceitos básicos, você pode fazer os exercícios adicionais ([Exemplos adicionais: criação de bots do Amazon Lex](additional-exercises.md)). O [Reservar uma viagem](ex-book-trip.md) usa atributos de sessão para compartilhar informações entre intenções para iniciar uma conversa dinâmica com o usuário.
**Próxima etapa**
[Etapa 3: Crie uma função do Lambda (console)](gs-bp-create-lambda-function.md)
# Etapa 3: Crie uma função do Lambda (console)
Crie uma função Lambda (usando o **lex-order-flowers-python**blueprint) e execute a invocação de teste usando dados de eventos de amostra no console. AWS Lambda
Você retorna ao console do Amazon Lex e adiciona a função do Lambda como o hook de código para atender à intenção `OrderFlowers` no `OrderFlowersBot` que criou na seção anterior.
**Para criar a função do Lambda (console)**
1. Faça login no Console de gerenciamento da AWS e abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Escolha a opção **Criar função**.
1. Na página **Create function (Criar função)**, selecione **Usar um blueprint (Usar um esquema)**. Digite **lex-** na caixa de texto do filtro e pressione `Enter` para localizar o esquema e selecione o esquema `lex-order-flowers-python`.
Os esquemas da função do Lambda são fornecidos em Node.js e em Python. Para este exercício, use o esquema baseado em Python.
1. Na página **Basic information (Informações básicas)**, faça o seguinte:
+ Digite o nome de uma função do Lambda (`OrderFlowersCodeHook`).
+ Em Perfil de execução, escolha **Criar um novo perfil com as permissões básicas do Lambda**.
+ Deixe os outros valores padrão.
1. Escolha a opção **Criar função**.
1. Se você estiver usando uma localidade diferente do inglês (EUA) (en-US), atualize os nomes das intenções conforme descrito em [Atualização de um esquema para uma localidade específica](lex-lambda-blueprints.md#blueprint-update-locale).
1. Testar a função do Lambda.
1. Selecione **Select a test event (Selecionar um evento de teste)**, **Configure test events (Configurar eventos de teste)**.
1. Selecione **Amazon Lex Order Flowers (Flores do pedido do Amazon Lex)** da lista **Event template (Modelo do evento)**. Esse exemplo de evento corresponde ao request/response modelo Amazon Lex (consulte[Uso de funções do Lambda](using-lambda.md)). Dê um nome ao evento de teste (`LexOrderFlowersTest`).
1. Escolha **Criar**.
1. Selecione **Testar** para testar o hook de código.
1. Verifique se a função do Lambda foi executada com êxito. A resposta, neste caso, corresponde ao modelo de resposta do Amazon Lex.
**Próxima etapa**
[Etapa 4: Adicione a função do Lambda como hook de código (console)](gs-bp-create-integrate.md)
# Etapa 4: Adicione a função do Lambda como hook de código (console)
Nesta seção, você atualiza a configuração da OrderFlowers intenção de usar a função Lambda da seguinte forma:
+ Primeiro, use a função do Lambda como um hook de código para executar o cumprimento da intenção `OrderFlowers`. Você pode testar o bot e verificar se recebeu uma mensagem de cumprimento da função do Lambda. O Amazon Lex invoca a função do Lambda somente depois de você fornecer dados para todos os slots necessários para encomendar flores.
+ Configure a mesma função do Lambda como um hook de código para executar a inicialização e a validação. Teste e verifique se a função do Lambda executa a validação (conforme você fornece dados de slot).
**Para adicionar a função do Lambda como um hook de código (console)**
1. No console do Amazon Lex, selecione o **OrderFlowers**bot. O console mostra a **OrderFlowers**intenção. Verifique se a versão da intenção está definida como `$LATEST`, pois essa é a única versão que podemos modificar.
1. Adicione a função do Lambda como o hook de código de atendimento e teste-a.
1. No Editor, escolha **função AWS Lambda ** como **Atendimento** e selecione a função do Lambda que você criou na etapa anterior (`OrderFlowersCodeHook`). Escolha **OK** para ter permissão do Amazon Lex para invocar a função do Lambda.
Você está configurando essa função do Lambda como um hook de código para cumprir a intenção. O Amazon Lex invoca essa função apenas após ter todos os dados de slot necessários do usuário para cumprir a intenção.
1. Especifique uma **Goodbye message**.
1. Escolha **Criar**.
1. Teste o bot usando a conversa anterior.
A última declaração "Obrigado, seu pedido de rosas..." é uma resposta da função do Lambda que você configurou como um hook de código. Na seção anterior, não havia função do Lambda. Agora, você está usando uma função do Lambda para realmente cumprir a intenção `OrderFlowers`.
1. Adicione a função do Lambda como um hook de código de inicialização e validação e teste.
O exemplo de código da função do Lambda que você está usando pode executar a validação e o atendimento da entrada do usuário. O evento de entrada que a função do Lambda recebe tem um campo (`invocationSource`) que o código usa para determinar qual parte do código executar. Para obter mais informações, consulte [Evento de entrada de função do Lambda e formato de resposta](lambda-input-response-format.md).
1. Selecione a versão \$1LATEST da intenção `OrderFlowers`. Essa é a única versão que você pode atualizar.
1. No Editor, escolha **Initialization and validation** em **Options**.
1. Novamente, selecione a mesma função do Lambda.
1. Escolha **Criar**.
1. Teste o bot.
Agora você está pronto para conversar com o Amazon Lex do seguinte modo. Para testar a parte da validação, escolha 6 PM, e a função do Lambda retornará uma resposta ("Our business hours are from 10 AM to 5 PM.”), e enviará prompts à você novamente. Depois de fornecer todos os dados de slot válidos, a função do Lambda atende a ordem.
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/OrderFlowers-FullLambda.png)
**Próxima etapa**
[Etapa 5 (opcional): Revise os detalhes do fluxo de informações (console)](gs-bp-details-after-lambda.md)
# Etapa 5 (opcional): Revise os detalhes do fluxo de informações (console)
Esta seção explica o fluxo de informações entre o cliente e o Amazon Lex para cada entrada do usuário, incluindo a integração da função do Lambda.
**nota**
A seção supõe que o cliente envia solicitações ao Amazon Lex usando a API de runtime `PostText` e mostra os detalhes da solicitação e da resposta adequadamente. Para obter um exemplo do fluxo de informações entre o cliente e o Amazon Lex no qual o cliente usa a API `PostContent`, consulte [Etapa 2a (opcional): revisar os detalhes do fluxo de informações falado (console)](gs-bp-details-postcontent-flow.md).
Para obter mais informações sobre a API de runtime `PostText` e detalhes adicionais sobre as solicitações e respostas mostradas nas etapas a seguir, consulte [PostText](API_runtime_PostText.md).
1. Usuário: "Eu gostaria de encomendar flores."
1. O cliente (console) envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o 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": {}
}
```
O URI de solicitação e o corpo fornecem informações ao Amazon Lex:
+ URI de solicitação: fornece o nome do bot (`OrderFlowers`), o alias do bot (`$LATEST`) e o nome do usuário (uma string aleatória que identifica o usuário). O `text` final indica que esta é uma solicitação de API `PostText` (e não `PostContent`).
+ Corpo da solicitação: inclui a entrada do usuário (`inputText`) e `sessionAttributes` vazio. Quando o cliente faz a primeira solicitação, não há atributos de sessão. A função do Lambda as inicia posteriormente.
1. A partir de `inputText`, o Amazon Lex detecta a intenção (`OrderFlowers`). Essa intenção é configurada com uma função do Lambda como um hook de código para inicialização e validação dos dados do usuário. Portanto, o Amazon Lex invoca aquela função do Lambda especificando as seguintes informações como dados 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": null,
"PickupDate": null
},
"confirmationStatus": "None"
}
}
```
Para obter mais informações, consulte [Formato de eventos de entrada](lambda-input-response-format.md#using-lambda-input-event-format).
Além das informações enviadas pelo cliente, o Amazon Lex também inclui os seguintes dados adicionais:
+ `messageVersion`: atualmente, o Amazon Lex oferece suporte apenas à versão 1.0.
+ `invocationSource`: indica o objetivo da invocação da função do Lambda. Nesse caso, é para executar os dados de inicialização e validação do usuário. Neste ponto, o Amazon Lex sabe que o usuário não forneceu todos os dados do slot para atender à intenção.
+ Informações `currentIntent` com todos os valores de slot definidos como nulo.
1. No momento, todos os valores de slot são nulos. Não há nada para a função do Lambda validar. A função do Lambda retorna a seguinte resposta para Amazon Lex:
```
{
"sessionAttributes": {},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": null,
"PickupDate": null
}
}
}
```
Para obter mais informações sobre o formato de resposta, consulte [Formato de resposta](lambda-input-response-format.md#using-lambda-response-format).
Observe o seguinte:
+ `dialogAction.type`: ao definir esse valor para `Delegate`, a função do Lambda delega a responsabilidade de decidir a próxima ação a Amazon Lex.
**nota**
Se a função do Lambda detectar qualquer coisa na validação dos dados do usuário, ela instruirá o Amazon Lex sobre o que fazer em seguida, conforme mostrado nas próximas etapas.
1. De acordo com o `dialogAction.type`, o Amazon Lex decide a próxima ação. Como nenhum dos slots estão preenchidos, ele decide escolher o valor para o slot `FlowerType`. Ele seleciona uma das solicitações de escolha de valor ("What type of flowers would you like to order? (Que tipo de flores você deseja encomendar?)") para este slot e envia a resposta a seguir de volta ao cliente:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-10.png)
O cliente exibe a mensagem na resposta.
1. Usuário: rosas
1. O cliente envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "roses",
"sessionAttributes": {}
}
```
No corpo da solicitação, o `inputText` fornece entradas do usuário. O `sessionAttributes` permanece vazio.
1. O Amazon Lex primeiro interpreta o `inputText` no contexto da intenção atual. O serviço lembra que havia solicitado ao usuário específico informações sobre o slot `FlowerType`. Ele atualiza o valor de slot na intenção atual e invoca a função do Lambda com os seguintes dados do 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"
}
}
```
Observe o seguinte:
+ `invocationSource` – continua sendo `DialogCodeHook` (estamos simplesmente validando os dados do usuário).
+ `currentIntent.slots`: o Amazon Lex atualizou o slot `FlowerType` para rosas.
1. De acordo com o valor `invocationSource` de `DialogCodeHook`, a função do Lambda executa a validação dos dados do usuário. Ele reconhece `roses` como um valor de slot válido (e define `Price` como um atributo de sessão) e retorna a seguinte resposta ao Amazon Lex.
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": null
}
}
}
```
Observe o seguinte:
+ `sessionAttributes`: a função do Lambda adicionou o `Price` (das rosas) como atributo de sessão.
+ `dialogAction.type`: é definido como `Delegate`. Os dados do usuário eram válidos, então a função do Lambda direciona o Amazon Lex para escolher a próxima ação.
1. De acordo com o `dialogAction.type`, o Amazon Lex escolherá a próxima ação. O Amazon Lex sabe que precisa de mais dados de slot, então escolhe o próximo slot não preenchido (`PickupDate`) com a maior prioridade de acordo com a configuração de intenção. O Amazon Lex seleciona um dos prompts de mensagens ("Em que dia você quer que as rosas sejam retiradas?") para esse slot, de acordo com a configuração da intenção, e envia a seguinte resposta de volta ao cliente:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-20.png)
O cliente simplesmente exibe a mensagem na resposta – "Em que dia você deseja receber as rosas?."
1. Usuário: amanhã
1. O cliente envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "tomorrow",
"sessionAttributes": {
"Price": "25"
}
}
```
No corpo da solicitação, `inputText` fornece entradas do usuário e o cliente passa os atributos de sessão de volta ao serviço.
1. O Amazon Lex lembra do contexto para o qual estava escolhendo dados para o slot `PickupDate`. Nesse contexto, ele sabe que o valor `inputText` é para o slot `PickupDate`. Em seguida, o Amazon Lex invoca a função do Lambda enviando o seguinte evento:
```
{
"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"
}
}
```
O Amazon Lex atualizou o `currentIntent.slots` definindo o valor `PickupDate`. Observe também que o serviço passa o `sessionAttributes` como é para a função do Lambda.
1. De acordo com o valor `invocationSource` de `DialogCodeHook`, a função do Lambda executa a validação dos dados do usuário. Ela reconhece que o valor de slot `PickupDate` é válido e retorna a seguinte resposta a Amazon Lex:
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": "2017-01-05"
}
}
}
```
Observe o seguinte:
+ `sessionAttributes` – sem alteração.
+ `dialogAction.type`: é definido como `Delegate`. Os dados do usuário eram válidos, e a função do Lambda direciona Amazon Lex para escolher a próxima ação.
1. De acordo com o `dialogAction.type`, o Amazon Lex escolherá a próxima ação. O Amazon Lex sabe que precisa de mais dados de slot, então escolhe o próximo slot não preenchido (`PickupTime`) com a maior prioridade de acordo com a configuração de intenção. O Amazon Lex seleciona uma das mensagens de aviso ("Entregar as rosas a que horas em 05/01/2017?") para esse slot de acordo com a configuração de intenção e envia a seguinte resposta de volta ao cliente:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-30.png)
O cliente exibe a mensagem na resposta: "Entregar as rosas em que horário em 05/01/2017?"
1. Usuário: 16h
1. O cliente envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o 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"
}
}
```
No corpo da solicitação, `inputText` fornece entradas do usuário. O cliente passa o `sessionAttributes` na solicitação.
1. O Amazon Lex entende o contexto. Ele entende que estava escolhendo dados para o slot `PickupTime`. Neste contexto, ele sabe que o valor `inputText` é para o slot `PickupTime`. Em seguida, o Amazon Lex invoca a função do Lambda enviando o seguinte evento:
```
{
"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"
}
}
```
O Amazon Lex atualizou o `currentIntent.slots` definindo o valor `PickupTime`.
1. De acordo com o valor `invocationSource` de `DialogCodeHook`, a função do Lambda executa a validação dos dados do usuário. Ela reconhece que o valor de slot `PickupDate` é válido e retorna a seguinte resposta a Amazon Lex.
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": "16:00",
"FlowerType": "roses",
"PickupDate": "2017-01-05"
}
}
}
```
Observe o seguinte:
+ `sessionAttributes` – nenhuma alteração no atributo de sessão.
+ `dialogAction.type`: é definido como `Delegate`. Os dados do usuário eram válidos, então a função do Lambda direciona o Amazon Lex para escolher a próxima ação.
1. Neste ponto, o Amazon Lex sabe que tem todos os dados do slot. Essa intenção é configurada com um prompt de confirmação. Portanto, o Amazon Lex envia a seguinte resposta ao usuário solicitando confirmação antes de atender a intenção:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-45.png)
O cliente simplesmente exibe a mensagem na resposta e aguarda a resposta do usuário.
1. Usuário: Sim
1. O cliente envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o 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. O Amazon Lex interpreta o `inputText` no contexto de confirmação da intenção atual. O Amazon Lex entende que o usuário deseja prosseguir com o pedido. Dessa vez, o Amazon Lex invoca a função do Lambda para cumprir a intenção enviando o seguinte evento, que define o `invocationSource` como `FulfillmentCodeHook` caso ele envie para a função do Lambda. O Amazon Lex também define o `confirmationStatus` como `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"
}
}
```
Observe o seguinte:
+ `invocationSource`: dessa vez, o Amazon Lex define esse valor como `FulfillmentCodeHook`, direcionando a função do Lambda a atender à intenção.
+ `confirmationStatus`: é definido como `Confirmed`.
1. Dessa vez, a função do Lambda cumpre a intenção `OrderFlowers` e retorna a seguinte resposta:
```
{
"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"
}
}
}
```
Observe o seguinte:
+ Define o `dialogAction.type`: a função do Lambda define esse valor como `Close`, direcionando Amazon Lex para não esperar uma resposta do usuário.
+ `dialogAction.fulfillmentState` – é definido como Fulfilled e inclui uma `message` adequada para transmitir para o usuário.
1. Amazon Lex analisa o `fulfillmentState` e envia a resposta seguinte de volta para o cliente.
Em seguida, o Amazon Lex retorna o seguinte ao cliente:
![\[\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs-1-details-48.png)
Observe que:
+ `dialogState`: o Amazon Lex define esse valor como `fulfilled`.
+ `message`: é a mesma mensagem que a função do Lambda forneceu.
O cliente exibe a mensagem.
1. Agora teste o bot novamente. Para estabelecer um novo contexto (de usuário), selecione o link **Clear** na janela de teste. Agora, forneça dados de slot inválidos para a intenção `OrderFlowers`. Desta vez, a função do Lambda executa a validação dos dados, redefine os valores dos dados do slot inválidos como nulos e pede ao Amazon Lex para solicitar dados válidos ao usuário. Por exemplo, tente o seguinte:
+ Jasmim como o tipo de flor (não é um dos tipos de flor suportados).
+ Ontem como o dia em que você deseja receber as flores.
+ Após fazer o pedido, digite outro tipo de flor em vez de responder "sim" para confirmar o pedido. Em resposta, a função do Lambda atualiza o `Price` no atributo da sessão mantendo um total cumulativo de encomendas de flores.
A função do Lambda também executará a atividade de cumprimento.
**Próxima etapa**
[Etapa 6: Atualize a configuração de intenção para adicionar uma declaração (console)](gs-bp-utterance.md)
# Etapa 6: Atualize a configuração de intenção para adicionar uma declaração (console)
O bot `OrderFlowers` é configurado com apenas duas declarações. Isso fornece informações limitadas ao Amazon Lex para criar um modelo de Machine Learning que reconhece e responde à intenção do usuário. Tente digitar "Desejo pedir flores" na janela de teste. O Amazon Lex não reconhece o texto e responde com "Eu não entendi, o que você gostaria de fazer?" Você pode melhorar o modelo de Machine Learning adicionando mais declarações.
![\[A janela de teste mostra a declaração ausente.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs1-120.png)
Cada declaração que você adiciona fornece ao Amazon Lex mais informações sobre como responder aos usuários. Você não precisa adicionar uma declaração exata. O Amazon Lex generaliza a partir dos exemplos que você fornece para reconhecer correspondências exatas e entradas semelhantes.
**Para adicionar uma declaração (console)**
1. Adicione a declaração "Quero flores" à intenção digitando-o na seção **Amostra de declarações** do editor de intenção e, em seguida, clicando no ícone de mais (\$1) próximo a nova declaração.
![\[O editor de intenção com a nova declaração.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs1-130.png)
1. Crie seu bot para incorporar a alteração. Escolha **Build** e, em seguida, escolha **Build** novamente.
1. Teste o bot para confirmar se ele reconheceu a nova declaração. Na janela de teste, como na imagem a seguir, digite "Quero pedir flores". O Amazon Lex reconhece a frase e responde com "Que tipo de flores você gostaria de pedir?"
![\[O editor de intenção reconhece a nova declaração.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/gs1-140.png)
**Próxima etapa**
[Etapa 7 (opcional): Limpe (console)](gs-bp-cleaning-up.md)
# Etapa 7 (opcional): Limpe (console)
Agora, exclua os recursos que você criou e limpe sua conta.
Você só pode excluir os recursos que não estão em uso. Em geral, você deve excluir recursos na seguinte ordem:
+ Exclua bots para liberar recursos de intenção.
+ Exclua intenções para liberar recursos de tipo de slot.
+ Exclua tipos de slot por último.
**Para limpar sua conta (console)**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Lex em [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Na lista de bots, escolha a caixa de seleção ao lado de **OrderFlowers**.
1. Para excluir o bot, escolha **Delete** e, em seguida, escolha **Continue** na caixa de diálogo de confirmação.
1. No painel à esquerda, selecione **Intents**.
1. Na lista de intenções, escolha **OrderFlowersIntent**.
1. Para excluir a intenção, selecione **Delete** e, em seguida, escolha **Continue** na caixa de diálogo de confirmação.
1. No painel esquerdo, escolha **Slot types**.
1. Na lista de tipos de slot, escolha **Flowers**.
1. Para excluir o tipo de slot, selecione **Delete** e, em seguida, escolha **Continue** na caixa de diálogo de confirmação.
Você removeu todos os recursos Amazon Lex que criou e limpou sua conta. Se desejar, você pode usar o [console do Lambda](https://console.aws.amazon.com/lambda) para excluir a função do Lambda usada neste exercício.