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á. # 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: ![Dados JSON contendo uma solicitação para o slot FlowerType.](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: ![Dados JSON enviados para o cliente para perguntar para o slot PickupData .](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: ![Dados JSON para solicitar o PickupTime slot.](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: ![Dados JSON solicitando a confirmação do pedido.](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: ![Dados JSON para a solicitação de confirmação.](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)