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á.
# Reservar uma viagem
Este exemplo mostra como criar um bot configurado para oferecer suporte a várias intenções. O exemplo também ilustra como é possível usar atributos de sessão para o compartilhamento de informações entre intenções. Depois de criar o bot, você usa um cliente de teste no console do Amazon Lex para testar o bot (BookTrip). O cliente usa a operação da API runtime do [PostText](API_runtime_PostText.md) para enviar solicitações ao Amazon Lex para cada entrada do usuário.
O BookTrip bot neste exemplo está configurado com duas intenções (BookHotel e BookCar). Por exemplo, suponha que um usuário reserve um hotel primeiro. Durante a interação, o usuário fornece informações como datas de check-in, local e número de diárias. Depois de a intenção ser cumprida, o cliente pode manter essas informações usando atributos de sessão. Para mais informações sobre atributos de sessão, consulte [PostText](API_runtime_PostText.md).
Agora, suponha que o usuário prossiga para reservar um carro. Usando informações fornecidas pelo usuário na BookHotel intenção anterior (ou seja, cidade de destino e datas de check-in e check-out), o cohook (função Lambda) que você configurou para inicializar e validar a intenção inicializa os dados BookCar do slot da intenção (ou seja, destino, cidade de coleta, data de coleta e data de devolução). BookCar Isso mostra como o compartilhamento de informações entre intenções permite que você crie bots que podem participar de conversas dinâmicas com o usuário.
Neste exemplo, usamos os seguintes atributos de sessão. Somente o cliente e a função do Lambda podem definir e atualizar os atributos de sessão. Amazon Lex apenas os passa entre o cliente e a função do Lambda. O Amazon Lex não mantem nem modifica atributos de sessão.
+ `currentReservation`: contém dados de slot para uma reserva em andamento e outras informações relevantes. A seguir, veja um exemplo de solicitação do cliente para o Amazon Lex. Ele mostra o atributo de sessão `currentReservation` no corpo da solicitação.
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Chicago",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Moscow\",
\"RoomType\":null,
\"CheckInDate\":null,
\"Nights\":null}"
}
}
```
+ `lastConfirmedReservation`: contém informações semelhantes para uma intenção anterior, se houver. Por exemplo, se o usuário reservou um hotel e está em processo de reserva de um carro, esse atributo de sessão armazena os dados do slot para a BookHotel intenção anterior.
+ `confirmationContext`: a função do Lambda define isso como `AutoPopulate` quando preenche automaticamente alguns dos dados de slot com base nos dados de slot da reserva anterior (se houver). Isso permite o compartilhamento de informações entre intenções. Por exemplo, se o usuário tiver reservado um hotel anteriormente e agora desejar reservar um carro, o Amazon Lex poderá solicitar que o usuário confirme (ou negue) se o carro está sendo reservado para a mesma cidade e as mesmas datas que a reserva de hotel
Neste exercício, você usa esquemas para criar um bot do Amazon Lex e uma função do Lambda. Para obter mais informações sobre esquemas, consulte [Amazon Lex e AWS Lambda Blueprints](lex-lambda-blueprints.md).
**Próxima etapa**
[Etapa 1: revisão dos esquemas usados neste exercício](ex-book-trip-blueprints.md)
# Etapa 1: revisão dos esquemas usados neste exercício
**Topics**
+ [Visão geral do Bot Blueprint () BookTrip](#ex-book-trip-bp-summary-bot)
+ [Visão geral da função Lambda Blueprint () lex-book-trip-python](#ex-book-trip-summary-lambda)
## Visão geral do Bot Blueprint () BookTrip
O esquema (**BookTrip**) que você usa para criar um bot fornece as seguintes pré-configurações:
+ **Tipos de slot**: dois tipos de slot personalizados:
+ `RoomTypes` com valores de enumeração: `king`, `queen` e `deluxe`, para uso na intenção `BookHotel`.
+ `CarTypes` com valores de enumeração: `economy`, `standard`, `midsize`, `full size`, `luxury` e `minivan`, para uso na intenção `BookCar`.
+ **Intenção 1 (BookHotel)** — É pré-configurado da seguinte forma:
+ **Slots pré-configurados**
+ `RoomType`, do tipo de slot personalizado `RoomTypes`
+ `Location`, do tipo de slot integrado `AMAZON.US_CITY`
+ `CheckInDate`, do tipo de slot integrado `AMAZON.DATE`
+ `Nights`, do tipo de slot integrado `AMAZON.NUMBER`
+ **Declarações pré-configuradas**
+ "Reservar um hotel"
+ "Eu gostaria de fazer reservas de hotéis"
+ "Reservar uma estadia de \$1Nights\$1 em \$1Location\$1"
Se o usuário disser qualquer um desses, o Amazon Lex determinará que `BookHotel` é a intenção e, em seguida, solicitará ao usuário dados de slot.
+ **Prompts pré-configurados**
+ Prompt do slot `Location`: "Em que cidade você se hospedará?"
+ Prompt do slot `CheckInDate`: "Em que dia você deseja fazer check-in?"
+ Prompt do slot `Nights`: "Por quantas diárias você se hospedará?"
+ Prompt do slot `RoomType`: "Que tipo de quarto você deseja: queen, king ou deluxe?"
+ Declaração de confirmação — “Ok, eu tenho você pronto para uma estadia de \$1noites\$1 em \$1Location\$1 a partir de \$1CheckInDate\$1. Posso fazer a reserva?"
+ Negação: "OK, cancelei sua reserva em andamento."
+ **Intenção 2 (BookCar)** — É pré-configurado da seguinte forma:
+ **Slots pré-configurados**
+ `PickUpCity`, do tipo integrado `AMAZON.US_CITY`
+ `PickUpDate`, do tipo integrado `AMAZON.DATE`
+ `ReturnDate`, do tipo integrado `AMAZON.DATE`
+ `DriverAge`, do tipo integrado `AMAZON.NUMBER`
+ `CarType`, do tipo personalizado `CarTypes`
+ **Declarações pré-configuradas**
+ "Reservar um carro"
+ "Reservar um carro"
+ "Fazer uma reserva de carro"
Se o usuário proferir qualquer uma dessas palavras, o Amazon Lex determina qual BookCar é a intenção e, em seguida, solicita que o usuário forneça os dados do slot.
+ **Prompts pré-configurados**
+ Prompt do slot `PickUpCity`: "Em que cidade você precisa alugar um carro?"
+ Prompt do slot `PickUpDate`: "Em que dia você deseja iniciar seu aluguel?"
+ Prompt do slot `ReturnDate`: "Em que dia você deseja devolver o carro?"
+ Prompt do slot `DriverAge` – "Quantos anos tem o motorista deste aluguel de carro?"
+ Prompt do slot `CarType`: "Que tipo de carro você deseja alugar?" Nossas opções mais populares são econômico, médio e luxo"
+ Declaração de confirmação — “Ok, eu tenho você pronto para alugar \$1CarType\$1 em \$1PickUpCity\$1 de \$1PickUpDate\$1 a \$1ReturnDate\$1. Devo fazer a reserva?"
+ Negação: "OK, cancelei sua reserva em andamento."
## Visão geral da função Lambda Blueprint () lex-book-trip-python
Além do blueprint do bot, AWS Lambda fornece um blueprint (**lex-book-trip-python**) que você pode usar como um gancho de código com o blueprint do bot. Para obter uma lista de esquemas de bot e esquemas da função do Lambda correspondentes, consulte [Amazon Lex e AWS Lambda Blueprints](lex-lambda-blueprints.md).
Ao criar um bot usando o BookTrip blueprint, você atualiza a configuração das intenções (BookCar e BookHotel) adicionando essa função Lambda como um gancho de código para a entrada de dados initialization/validation do usuário e o cumprimento das intenções.
O código de função do Lambda fornecido demonstra uma conversa dinâmica usando informações conhecidas anteriormente (mantidas nos atributos de sessão) sobre um usuário para inicializar os valores de slot para uma intenção. Para obter mais informações, consulte [Gerenciar contexto da conversa](context-mgmt.md).
**Próxima etapa**
[Etapa 2: criar um bot do Amazon Lex](ex-book-trip-create-bot.md)
# Etapa 2: criar um bot do Amazon Lex
Nesta seção, você cria um bot do Amazon Lex (BookTrip).
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 página **Bots**, selecione **Create**.
1. Na página **Create your Lex bot**,
+ Escolha o esquema **BookTrip**.
+ Deixe o nome padrão do bot (BookTrip).
1. Escolha **Criar**. O console envia uma série de solicitações ao Amazon Lex para criar o bot. Observe o seguinte:
1. O console mostra o BookTrip bot. Na guia **Editor**, revise os detalhes das intenções pré-configuradas (BookCar e BookHotel).
1. Teste o bot na janela de teste. Use o seguinte para ter uma conversa de teste com o bot:
![\[Conversa com um atendente, na qual o atendente solicita a cidade, o dia, o número de noites e o tipo de quarto para a viagem do cliente. O atendente confirma a reserva.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-trip-no-lambda-10.png)
A partir da entrada inicial do usuário (“Reservar um hotel”), o Amazon Lex deduz a intenção ()BookHotel. Em seguida, o bot usa os prompts pré-configurados nessa intenção para escolher os dados de slot do usuário. Depois de o usuário fornecer todos os dados de slot, o Amazon Lex retorna uma resposta ao cliente com uma mensagem que inclui todas as entradas do usuário como uma mensagem. O cliente exibe a mensagem na resposta, conforme exibido.
```
CheckInDate:2016-12-18 Location:Chicago Nights:5 RoomType:queen
```
Agora, continue a conversa e tente reservar um carro.
![\[Conversa com um atendente, na qual o atendente solicita a cidade, o dia de início, o dia de retorno, a idade do motorista e o tipo de carro do aluguel do carro do cliente. O atendente confirma a reserva.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-trip-no-lambda-20.png)
Observe que,
+ Não há validação de dados do usuário dessa vez. Por exemplo, você pode fornecer qualquer cidade para reservar um hotel.
+ Você está fornecendo algumas das mesmas informações novamente (destino, cidade de retirada, data de retirada e data de devolução) para reservar um carro. Em uma conversa dinâmica, seu bot deve inicializar algumas dessas informações com base na entrada anterior que o usuário forneceu para reservar o hotel.
Na próxima seção, você criará uma função do Lambda para executar a validação dos dados do usuário e a inicialização usando o compartilhamento de informações entre intenções por meio de atributos de sessão. Em seguida, você atualiza a configuração da intenção adicionando a função Lambda como gancho de código para initialization/validation executar a entrada do usuário e cumprir a intenção.
**Próxima etapa**
[Etapa 3: criar uma função do Lambda](ex-book-trip-create-lambda-function.md)
# Etapa 3: criar uma função do Lambda
Nesta seção, você cria uma função Lambda usando um blueprint (**lex-book-trip-python**) fornecido no console. AWS Lambda Você também testa a função do Lambda ao invocá-la usando dados de eventos de exemplo fornecidos pelo console.
Essa função do Lambda é escrita em Python.
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. Selecione **Use o esquema**. Digite **lex** para localizar o esquema e escolha o esquema `lex-book-trip-python`.
1. Escolha **Configurar** a função do Lambda da seguinte forma.
+ Digite o nome de uma função do Lambda (`BookTripCodeHook`).
+ Para a função, escolha **Create a new role from template(s)** e, em seguida, digite um nome de função.
+ 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. Invoque a função do Lambda duas vezes usando dados de exemplo para reservar um carro e um hotel.
1. Escolha **Configure test event** no menu suspenso **Select a test event**.
1. Escolha **Amazon Lex Book Hotel** na lista **Sample event template**.
Esse exemplo de evento corresponde ao request/response modelo Amazon Lex. Para obter mais informações, consulte [Uso de funções do Lambda](using-lambda.md).
1. Escolha **Save and test**.
1. Verifique se a função do Lambda foi executada com êxito. A resposta, neste caso, corresponde ao modelo de resposta do Amazon Lex.
1. Repita a etapa. Desta vez, você escolhe **Amazon Lex Book Car** na lista **Sample event template (Modelo de evento de exemplo)**. A função do Lambda processa a reserva do carro.
**Próxima etapa**
[Etapa 4: adicionar a função do Lambda como hook de código](ex-book-trip-create-integrate.md)
# Etapa 4: adicionar a função do Lambda como hook de código
Nesta seção, você atualiza as configurações do BookCar e das BookHotel intenções adicionando a função Lambda como um gancho de código e atividades de initialization/validation atendimento. Verifique se você escolheu a versão \$1LATEST das intenções, pois só é possível atualizar a versão \$1LATEST de seus recursos do Amazon Lex.
1. No console do Amazon Lex, escolha o **BookTrip**bot.
1. Na guia **Editor**, escolha a **BookHotel**intenção. Atualize a configuração de intenção da seguinte forma:
1. Verifique se a versão da intenção (ao lado do nome da intenção) é \$1LATEST.
1. Adicione a função do Lambda como hook de código de inicialização e validação da seguinte forma:
+ Em **Opções**, escolha **Initialization and validation code hook**.
+ Escolha sua função do Lambda na lista.
1. Adicione a função do Lambda como hook de código de cumprimento da seguinte forma:
+ Em **Fulfillment**, escolha **AWS Lambda function**.
+ Escolha sua função do Lambda na lista.
+ Escolha **Goodbye message** e digite uma mensagem.
1. Escolha **Salvar**.
1. Na guia **Editor**, escolha a BookCar intenção. Siga a etapa anterior para adicionar sua função do Lambda como hook de código de validação e cumprimento.
1. Escolha **Criar**. O console envia uma série de solicitações ao Amazon Lex para salvar as configurações.
1. Teste o bot. Agora que você tem uma função do Lambda executando a inicialização, a validação dos dados do usuário e o atendimento, verá a diferença na interação do usuário.
![\[Conversa com um atendente, na qual o atendente solicita a cidade, o dia, o número de noites e o tipo de quarto para uma reserva de viagem e, em seguida, confirma a reserva.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-trip-with-lambda-30.png)
Para obter mais informações sobre o fluxo de dados do cliente (console) para o Amazon Lex e do Amazon Lex para a função do Lambda, consulte [Fluxo de dados: intenção Book Hotel](book-trip-detail-flow.md#data-flow-book-hotel).
1. Continue a conversa e reserve um carro conforme mostrado a seguir:
![\[Conversa com um atendente, na qual o atendente solicita a idade do motorista e o tipo de carro e, em seguida, confirma a reserva do carro.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-trip-with-lambda-40.png)
Quando você escolhe reservar um carro, o cliente (console) envia uma solicitação para o Amazon Lex que inclui os atributos da sessão (da conversa anterior BookHotel). O Amazon Lex passa essas informações para a função Lambda, que então inicializa (ou seja, pré-preenche) alguns dos dados do BookCar slot (ou seja,, PickUpDate e). ReturnDate PickUpCity
**nota**
Isso ilustra como atributos de sessão podem ser usados para manter o contexto nas intenções. O cliente do console fornece o link **Clear** na janela de teste que um usuário pode usar para limpar atributos de sessão anterior.
Para obter mais informações sobre o fluxo de dados do cliente (console) para o Amazon Lex e do Amazon Lex para a função do Lambda, consulte [Fluxo de dados: intenção Book Car](book-trip-detail-flow.md#data-flow-book-car).
# Detalhes do fluxo de informações
Neste exercício, você se envolveu em uma conversa com o BookTrip bot do Amazon Lex usando o cliente de janela de teste fornecido no console do Amazon Lex. Esta seção explica o seguinte:
+ O fluxo de dados entre o cliente e o Amazon Lex..
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 mais informações sobre a API de runtime `PostText`, consulte [PostText](API_runtime_PostText.md).
**nota**
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).
+ O fluxo de dados entre Amazon Lex e a função do Lambda. Para obter mais informações, consulte [Evento de entrada de função do Lambda e formato de resposta](lambda-input-response-format.md).
**Topics**
+ [Fluxo de dados: intenção Book Hotel](#data-flow-book-hotel)
+ [Fluxo de dados: intenção Book Car](#data-flow-book-car)
## Fluxo de dados: intenção Book Hotel
Esta seção explica o que acontece após cada entrada do usuário.
1. Usuário: "reservar um hotel"
1. O cliente (console) envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o Amazon Lex:
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"book a hotel",
"sessionAttributes":{}
}
```
Tanto o URI de solicitação como o corpo fornecem informações para Amazon Lex:
+ URI de solicitação — Fornece o nome do bot (BookTrip), o alias do bot (\$1LATEST) e o nome do 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. Inicialmente, esse é um objeto vazio e a função do Lambda primeiro define os atributos de sessão.
1. A partir de `inputText`, o Amazon Lex detecta a intenção (BookHotel). Essa intenção é configurado com uma função do Lambda como um hook de código para inicialização/validação de dados do usuário. Portanto, o Amazon Lex invoca essa função do Lambda passando as seguintes informações como o parâmetro do evento (consulte [Formato de eventos de entrada](lambda-input-response-format.md#using-lambda-input-event-format)):
```
{
"messageVersion":"1.0",
"invocationSource":"DialogCodeHook",
"userId":"wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes":{
},
"bot":{
"name":"BookTrip",
"alias":null,
"version":"$LATEST"
},
"outputDialogMode":"Text",
"currentIntent":{
"name":"BookHotel",
"slots":{
"RoomType":null,
"CheckInDate":null,
"Nights":null,
"Location":null
},
"confirmationStatus":"None"
}
}
```
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, o objetivo é executar os dados de inicialização e validação do usuário (nesse momento, o Amazon Lex sabe que o usuário não forneceu todos os dados de slot para atender à intenção).
+ `currentIntent` - Todos os valores de slot são definidos como nulos.
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. Para obter mais informações sobre o formato de resposta, consulte [Formato de resposta](lambda-input-response-format.md#using-lambda-response-format).
```
{
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",\"Location\":null,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"dialogAction":{
"type":"Delegate",
"slots":{
"RoomType":null,
"CheckInDate":null,
"Nights":null,
"Location":null
}
}
}
```
**nota**
`currentReservation`: a função do Lambda inclui este atributo de sessão. Seu valor é uma cópia das informações do slot atual e do tipo de reserva.
Somente o cliente e a função do Lambda podem definir e atualizar esses atributos de sessão. Amazon Lex simplesmente passa esses valores.
`dialogAction.type`: ao definir esse valor como `Delegate`, a função do Lambda delega a responsabilidade da próxima ação para Amazon Lex.
Se a função do Lambda tiver detectado algo na validação dos dados do usuário, ela instruirá o Amazon Lex sobre o que fazer a seguir.
1. De acordo com o `dialogAction.type`, o Amazon Lex decide a próxima ação: obter dados do usuário para o slot `Location`. Ele seleciona um dos prompts de mensagens ("Em que cidade você se hospedará?") para esse slot, de acordo com a configuração da intenção, e envia a seguinte resposta de volta ao usuário:
![\[Resposta JSON contendo estado da caixa de diálogo, nome da intenção, mensagem, cartão de resposta, atributos da sessão, slot de evocação e slots.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-hotel-10.png)
Os atributos de sessão são passados para o cliente.
O cliente lê a resposta e, em seguida, exibe a mensagem: "Em qual cidade você se hospedará?"
1. Usuário: "Moscou"
1. O cliente envia a seguinte solicitação `PostText` para Amazon Lex (quebras de linha adicionadas para a capacidade de leitura):
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Moscow",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":null,
\"RoomType\":null,
\"CheckInDate\":null,
\"Nights\":null}"
}
}
```
Além do `inputText`, o cliente inclui os mesmos atributos de sessão `currentReservation` que recebeu.
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 `Location`). Ele atualiza o valor de slot para a intenção atual e invoca a função do Lambda usando o evento a seguir:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":null,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookHotel",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": "Moscow"
},
"confirmationStatus": "None"
}
}
```
**nota**
`invocationSource` continua sendo `DialogCodeHook`. Nesta etapa, estamos apenas validando os dados do usuário.
Amazon Lex está apenas passando o atributo de sessão para a função do Lambda.
Para `currentIntent.slots`, Amazon Lex atualizou o slot `Location` para `Moscow`.
1. A função do Lambda executa a validação dos dados do usuário e determina que `Moscow` é um local inválido.
**nota**
A função do Lambda neste exercício tem uma lista simples de cidades válidas e `Moscow` não está na lista. Em uma aplicação de produção, você pode usar um banco de dados de back-end para obter essas informações.
Ele redefine o valor de slot novamente como nulo e direciona o Amazon Lex a solicitar outro valor ao usuário enviando a seguinte resposta:
```
{
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Moscow\",\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"dialogAction": {
"type": "ElicitSlot",
"intentName": "BookHotel",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": null
},
"slotToElicit": "Location",
"message": {
"contentType": "PlainText",
"content": "We currently do not support Moscow as a valid destination. Can you try a different city?"
}
}
}
```
**nota**
`currentIntent.slots.Location` é redefinido como nulo.
`dialogAction.type` é definido como `ElicitSlot`, que direciona Amazon Lex a solicitar o usuário novamente, fornecendo o seguinte:
`dialogAction.slotToElicit`: slot para onde obter dados do usuário.
`dialogAction.message`: um `message` para transmitir ao usuário.
1. Amazon Lex avisa o `dialogAction.type` e passa as informações para o cliente na resposta a seguir:
![\[Resposta JSON contendo estado da caixa de diálogo, nome da intenção, mensagem, cartão de resposta, atributos da sessão, slot de evocação e slots.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-hotel-20.png)
O cliente simplesmente exibe a mensagem: "No momento, não oferecemos suporte a Moscou como um destino válido. Poderia tentar outra cidade?"
1. Usuário: "Chicago"
1. O cliente envia a seguinte solicitação `PostText` para o Amazon Lex:
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Chicago",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Moscow\",
\"RoomType\":null,
\"CheckInDate\":null,
\"Nights\":null}"
}
}
```
1. Amazon Lex sabe o contexto de onde estava escolhendo dados para o slot `Location`. Nesse contexto, ele sabe que o valor `inputText` é para o slot `Location`. Em seguida, ele invoca a função do Lambda enviando o seguinte evento:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":Moscow,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookHotel",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": "Chicago"
},
"confirmationStatus": "None"
}
}
```
Amazon Lex atualizou o `currentIntent.slots` ao definir o slot `Location` como `Chicago`.
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 `Chicago` como um valor de slot válido, atualiza o atributo de sessão adequadamente e, em seguida, retorna a seguinte resposta ao Amazon Lex.
```
{
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"dialogAction": {
"type": "Delegate",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": "Chicago"
}
}
}
```
**nota**
`currentReservation`: a função do Lambda atualiza esse atributo de sessão definindo o `Location` como `Chicago`.
`dialogAction.type`: é definido como `Delegate`. Os dados do usuário são válidos e a função do Lambda direciona Amazon Lex a escolher a próxima ação.
1. De acordo com o `dialogAction.type`, Amazon Lex escolhe a próxima ação. Amazon Lex sabe que precisa de mais dados de slot e escolhe o próximo slot não preenchido (`CheckInDate`) com a maior prioridade de acordo com a configuração de intenção. Ele seleciona um dos prompts de mensagens ("Em que dia você deseja fazer check-in?") para esse slot, de acordo com a configuração da intenção, e envia a seguinte resposta de volta ao cliente:
![\[Resposta JSON contendo estado da caixa de diálogo, nome da intenção, mensagem, cartão de resposta, atributos da sessão, slot de evocação e slots. O espaço de localização agora está preenchido como Chicago.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-hotel-30.png)
O cliente exibe a mensagem: "Em que dia você deseja fazer check-in?"
1. A interação do usuário continua. O usuário fornece os dados, a função do Lambda valida os dados e, em seguida, delega a próxima ação para o Amazon Lex. Por fim, o usuário fornece todos os dados do slot, a função do Lambda valida todas as entradas do usuário e, em seguida, o Amazon Lex reconhece que tem todos os dados do slot.
**nota**
Neste exercício, depois que o usuário fornece todos os dados do slot, a função do Lambda calcula o preço da reserva de hotel e o retorna como outro atributo de sessão (`currentReservationPrice`).
Nesse momento, a intenção está pronta para ser cumprida, mas a BookHotel intenção é configurada com um aviso de confirmação que exige a confirmação do usuário antes que o Amazon Lex possa cumprir a intenção. Portanto, o Amazon Lex envia a seguinte mensagem ao cliente solicitando a confirmação antes de reservar o hotel:
![\[Resposta JSON contendo estado da caixa de diálogo, nome da intenção, mensagem, cartão de resposta, atributos da sessão, slot de evocação e slots. Todos os slots agora estão preenchidos.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-hotel-40.png)
O cliente exibe a mensagem: "OK, reservarei para você 5 diárias em Chicago a partir de 18/12/2016. Posso fazer a reserva?"
1. Usuário: "sim"
1. O cliente envia a seguinte solicitação `PostText` para o Amazon Lex:
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Yes",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Chicago\",
\"RoomType\":\"queen\",
\"CheckInDate\":\"2016-12-18\",
\"Nights\":\"5\"}",
"currentReservationPrice":"1195"
}
}
```
1. O Amazon Lex interpreta o `inputText` no contexto de confirmação da intenção atual. Amazon Lex entende que o usuário deseja prosseguir com a reserva. Dessa vez, o Amazon Lex invoca a função do Lambda para atender à intenção enviando o seguinte evento. Ao definir o `invocationSource` como `FulfillmentCodeHook` no evento, ele envia para a função do Lambda. O Amazon Lex também define o `confirmationStatus` como `Confirmed`.
```
{
"messageVersion": "1.0",
"invocationSource": "FulfillmentCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}",
"currentReservationPrice": "956"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookHotel",
"slots": {
"RoomType": "queen",
"CheckInDate": "2016-12-18",
"Nights": "5",
"Location": "Chicago"
},
"confirmationStatus": "Confirmed"
}
}
```
**nota**
`invocationSource`: 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 Lambda cumpre a BookHotel intenção, o Amazon Lex conclui a reserva e, em seguida, retorna a seguinte resposta:
```
{
"sessionAttributes": {
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"dialogAction": {
"type": "Close",
"fulfillmentState": "Fulfilled",
"message": {
"contentType": "PlainText",
"content": "Thanks, I have placed your reservation. Please let me know if you would like to book a car rental, or another hotel."
}
}
}
```
**nota**
`lastConfirmedReservation`: é um novo atributo de sessão que a função do Lambda adicionou (em vez do `currentReservation`, `currentReservationPrice`).
`dialogAction.type`: a função do Lambda define esse valor como `Close`, indicando a Amazon Lex que não aguarde 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:
![\[Resposta JSON contendo estado da caixa de diálogo, nome da intenção, mensagem, cartão de resposta, atributos da sessão, slot de evocação e slots. Todos os slots estão preenchidos, e um último campo de reserva confirmado nos atributos da sessão agora está preenchido.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-hotel-60.png)
**nota**
`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.
## Fluxo de dados: intenção Book Car
O BookTrip bot neste exercício apoia duas intenções (BookHotel e BookCar). Depois de reservar um hotel, o usuário pode continuar a conversa para reservar um carro. Desde que a sessão não tenha expirado, em cada solicitação subsequente o cliente continua a enviar os atributos de sessão (neste exemplo, o `lastConfirmedReservation`). A função Lambda pode usar essas informações para inicializar os dados do slot para a intenção. BookCar Isso mostra como é possível usar atributos de sessão no compartilhamento de informações entre intenções.
Especificamente, quando o usuário escolhe a BookCar intenção, a função Lambda usa informações relevantes no atributo de sessão para preencher previamente os slots (PickUpDate, ReturnDate, e) para a intenção. PickUpCity BookCar
**nota**
O console do Amazon Lex fornece o link **Limpar** que você pode usar para limpar os atributos da sessão anterior.
Siga as etapas neste procedimento para continuar a conversa.
1. Usuário: "também reservar um carro"
1. O cliente envia a seguinte solicitação `PostText` para o Amazon Lex.
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"also book a car",
"sessionAttributes":{
"lastConfirmedReservation":""{\"ReservationType\":\"Hotel\",
\"Location\":\"Chicago\",
\"RoomType\":\"queen\",
\"CheckInDate\":\"2016-12-18\",
\"Nights\":\"5\"}"
}
}
```
O cliente inclui o atributo de sessão `lastConfirmedReservation`.
1. O Amazon Lex detecta a intenção (BookCar) do. `inputText` Essa intenção também está configurada para invocar a função do Lambda para executar a inicialização e a validação dos dados do usuário. Amazon Lex invoca a função do Lambda com os seguintes eventos:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookCar",
"slots": {
"PickUpDate": null,
"ReturnDate": null,
"DriverAge": null,
"CarType": null,
"PickUpCity": null
},
"confirmationStatus": "None"
}
}
```
**nota**
`messageVersion`: atualmente, Amazon Lex oferece suporte apenas à versão 1.0.
`invocationSource`: indica que a finalidade de invocação é executar a inicialização e a validação dos dados do usuário.
`currentIntent`: inclui o nome da intenção e os slots. No momento, todos os valores de slot são nulos.
1. A função do Lambda observa todos os valores de slot nulos com nada para validar. No entanto, ela usa atributos de sessão para inicializar alguns dos valores de slot (`PickUpDate`, `ReturnDate` e `PickUpCity`) e, em seguida, retorna a seguinte resposta:
```
{
"sessionAttributes": {
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}",
"currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":null,\"PickUpDate\":null,\"ReturnDate\":null,\"CarType\":null}",
"confirmationContext": "AutoPopulate"
},
"dialogAction": {
"type": "ConfirmIntent",
"intentName": "BookCar",
"slots": {
"PickUpCity": "Chicago",
"PickUpDate": "2016-12-18",
"ReturnDate": "2016-12-22",
"CarType": null,
"DriverAge": null
},
"message": {
"contentType": "PlainText",
"content": "Is this car rental for your 5 night stay in Chicago on 2016-12-18?"
}
}
}
```
**nota**
Além do `lastConfirmedReservation`, a função do Lambda inclui mais atributos de sessão (`currentReservation` e `confirmationContext`).
`dialogAction.type`é definido como`ConfirmIntent`, o que informa ao Amazon Lex que uma resposta sim, não é esperada do usuário (o ConfirmationContext definido como, a função Lambda sabe yes/no que AutoPopulate a resposta do usuário é para obter a confirmação do usuário da inicialização realizada pela função Lambda (dados de slot preenchidos automaticamente).
A função do Lambda também inclui uma mensagem informativa na resposta no `dialogAction.message` para Amazon Lex retornar ao cliente.
O termo `ConfirmIntent` (valor do `dialogAction.type`) não é relacionado a nenhuma intenção de bot. No exemplo, a função Lambda usa esse termo para direcionar o Amazon Lex a receber uma yes/no resposta do usuário.
1. De acordo com o `dialogAction.type`, Amazon Lex retorna a seguinte resposta ao cliente:
![\[Resposta JSON contendo estado da caixa de diálogo, nome da intenção, mensagem, cartão de resposta, atributos da sessão, slot de evocação e slots.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-car-10.png)
O cliente exibe a mensagem: "Este aluguel de carro é para sua estadia de 5 diárias em Chicago em 18/12/2016?"
1. Usuário: "sim"
1. O cliente envia a seguinte solicitação `PostText` para o Amazon Lex.
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"yes",
"sessionAttributes":{
"confirmationContext":"AutoPopulate",
"currentReservation":"{\"ReservationType\":\"Car\",
\"PickUpCity\":null,
\"PickUpDate\":null,
\"ReturnDate\":null,
\"CarType\":null}",
"lastConfirmedReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Chicago\",
\"RoomType\":\"queen\",
\"CheckInDate\":\"2016-12-18\",
\"Nights\":\"5\"}"
}
}
```
1. O Amazon Lex lê o `inputText` e sabe o contexto (solicitou que o usuário confirme o preenchimento automático). O Amazon Lex invoca a função do Lambda enviando o seguinte evento:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"confirmationContext": "AutoPopulate",
"currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":null,\"PickUpDate\":null,\"ReturnDate\":null,\"CarType\":null}",
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookCar",
"slots": {
"PickUpDate": "2016-12-18",
"ReturnDate": "2016-12-22",
"DriverAge": null,
"CarType": null,
"PickUpCity": "Chicago"
},
"confirmationStatus": "Confirmed"
}
}
```
Como o usuário respondeu Sim, Amazon Lex define o `confirmationStatus` como `Confirmed`.
1. A partir do `confirmationStatus`, a função do Lambda sabe que os valores preenchidos automaticamente estão corretos. A função do Lambda faz o seguinte:
+ Atualiza o atributo de sessão `currentReservation` para o valor de slot que tinha preenchido automaticamente.
+ Define o `dialogAction.type` como `ElicitSlot`
+ Define o valor `slotToElicit` como `DriverAge`.
A resposta seguinte é enviada:
```
{
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":\"Chicago\",\"PickUpDate\":\"2016-12-18\",\"ReturnDate\":\"2016-12-22\",\"CarType\":null}",
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"dialogAction": {
"type": "ElicitSlot",
"intentName": "BookCar",
"slots": {
"PickUpDate": "2016-12-18",
"ReturnDate": "2016-12-22",
"DriverAge": null,
"CarType": null,
"PickUpCity": "Chicago"
},
"slotToElicit": "DriverAge",
"message": {
"contentType": "PlainText",
"content": "How old is the driver of this car rental?"
}
}
}
```
1. Amazon Lex retorna a seguinte resposta:
![\[Resposta em JSON mostrando a intenção de reservar um carro e uma mensagem indicando o slot de Idade do motorista.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-car-20.png)
O cliente exibe a mensagem "Quantos anos tem o motorista deste aluguel de carro?" e a conversa continua.