Anexando uma função Lambda a um alias de bot Formato dos eventos de entrada Formato de resposta Função do roteador Lambda

Usando umaAWS Lambda função

Esta seção descreve como anexar uma função Lambda a um alias de bot e a estrutura dos dados do evento que o Amazon Lex V2 fornece a uma função do Lambda. Use essas informações para analisar a entrada em seu código Lambda. Também explica o formato da resposta que o Amazon Lex V2 espera que sua função Lambda retorne.

O Amazon Lex V2 usa uma função Lambda por alias de bot por idioma, em vez de uma função Lambda para cada intenção. Para usar uma função individual para cada intenção, a seção Roteador de funções Lambda fornece uma função que você pode usar.

Você pode usar funções do Lambda nos seguintes pontos em uma conversa com um usuário:

Antes do início da conversa. Por exemplo, depois de informar ao usuário a intenção reconhecida.
Depois de instigar um valor de slot do usuário. Por exemplo, depois que o usuário diz ao bot o tamanho da pizza que deseja pedir.
Entre cada nova tentativa para obter um slot. Por exemplo, se o cliente não usar um tamanho de pizza reconhecido.
Ao confirmar uma intenção. Por exemplo, ao confirmar um pedido de pizza.
Para cumprir uma intenção. Por exemplo, para fazer um pedido de pizza.
Depois que a intenção for cumprida. Por exemplo, mudar para a intenção de pedir uma bebida.

Tópicos

Anexando uma função Lambda a um alias de bot
Formato dos eventos de entrada
Formato de resposta
Função do roteador Lambda

Anexando uma função Lambda a um alias de bot

Com o Amazon Lex V2, você indica que uma intenção deve usar uma função Lambda para cada intenção. Mas você atribui a função Lambda que suas intenções usam para cada linguagem suportada por um alias de bot. Dessa forma, você pode criar uma função Lambda personalizada para cada idioma que seu alias de bot suporta.

Você indica que uma intenção deve usar uma função Lambda usando o console CreateIntentou a UpdateIntentoperação or. No editor de intenção, você ativa as funções do Lambda nas opções avançadas na seção Gancho de código de diálogo para cada resposta no editor.

Há duas maneiras de controlar como o Amazon Lex V2 chama o gancho de código para obter uma resposta. Você pode marcar o gancho de código ativo ou inativo e marcar como ativado ou desativado.

Quando um gancho de código está ativo, o Amazon Lex V2 chamará o gancho de código. Quando o gancho de código está inativo, o Amazon Lex V2 não executa o gancho de código.

Você só pode ativar ou desativar um gancho de código quando ele estiver marcado como ativo. Quando está marcado como ativado, o gancho de código é executado normalmente. Quando está desativado, o gancho de código não é chamado e o Amazon Lex V2 age como se o gancho de código tivesse retornado com sucesso.

A seção de ganchos de código do editor de intenção do Amazon Lex V2.

Você define a função Lambda a ser usada em cada alias de bot. A mesma função Lambda é usada para todos os efeitos em um idioma suportado pelo bot.

Para escolher uma função Lambda para usar com um alias de bot

Abra o console Amazon Lex em https://console.aws.amazon.com/lexv2/.
Na lista de bots, escolha o nome do bot que você deseja usar.
Em Criar versões e aliases para implantação, escolha Exibir aliases.
Na lista de alias, escolha o nome do alias que deseja usar.
Na lista de idiomas suportados, escolha o idioma para o qual a função Lambda é usada.
Escolha o nome da função Lambda a ser usada e escolha a versão ou o alias da função.
Escolha Save (Salvar) para salvar as alterações.

Formato dos eventos de entrada

Veja a seguir o formato geral de um evento Amazon Lex V2 que é passado para uma função Lambda. Use essas informações ao escrever sua função Lambda.

nota

O formato de entrada pode mudar sem uma alteração correspondente nomessageVersion. Seu código não deve gerar um erro se novos campos estiverem presentes.



{
    "messageVersion": "1.0",
    "invocationSource": "DialogCodeHook | FulfillmentCodeHook",
    "inputMode": "DTMF | Speech | Text",
    "responseContentType": "CustomPayload | ImageResponseCard | PlainText | SSML",
    "sessionId": "string",
    "inputTranscript": "string",
    "invocationLabel": "string",
    "bot": {
        "id": "string",
        "name": "string",
        "aliasId": "string",
        "localeId": "string",
        "version": "string"
    },
    "interpretations": [
        {
            "intent": {
                "confirmationState": "Confirmed | Denied | None",
                "name": "string",
                "slots": {
                    "string": {
                        "value": {
                            "interpretedValue": "string",
                            "originalValue": "string",
                            "resolvedValues": [
                                "string"
                            ]
                        }
                    },
                    "string": {
                        "shape": "List",
                        "value": {
                            "interpretedValue": "string",
                            "originalValue": "string",
                            "resolvedValues": [
                                "string"
                            ]
                        },
                        "values": [
                            {
                                "shape": "Scalar",
                                "value": {
                                    "originalValue": "string",
                                    "interpretedValue": "string",
                                    "resolvedValues": [
                                        "string"
                                    ]
                                }
                            },
                            {
                                "shape": "Scalar",
                                "value": {
                                    "originalValue": "string",
                                    "interpretedValue": "string",
                                    "resolvedValues": [
                                        "string"
                                    ]
                                }
                            }
                        ]
                    }
                },
                "state": "Failed | Fulfilled | FulfillmentInProgress | InProgress | ReadyForFulfillment | Waiting",
                "kendraResponse": {
                    // Only present when intent is KendraSearchIntent. For details, see 
                    // https://docs.aws.amazon.com/kendra/latest/dg/API_Query.html#API_Query_ResponseSyntax
                }
            },
            "nluConfidence": number,
            "sentimentResponse": {
                "sentiment": "string",
                "sentimentScore": {
                    "mixed": number,
                    "negative": number,
                    "neutral": number,
                    "positive": number
                }
            }
        }
    ],
    "proposedNextState": {
        "dialogAction": {
            "slotToElicit": "string",
            "type": "Close | ConfirmIntent | Delegate | ElicitIntent | ElicitSlot"
        },
        "intent": {
            "name": "string",
            "confirmationState": "Confirmed | Denied | None",
            "slots": {},
            "state": "Failed | Fulfilled | InProgress | ReadyForFulfillment | Waiting"
        },
        "prompt": {
            "attempt": "string" 
        }
    },
    "requestAttributes": {
        "string": "string"
    },
    "sessionState": {
        "activeContexts": [
            {
                "name": "string",
                "contextAttributes": {
                    "string": "string"
                },
                "timeToLive": {
                    "timeToLiveInSeconds": number,
                    "turnsToLive": number
                }
            }
        ],
        "sessionAttributes": {
            "string": "string"
        },
        "runtimeHints": {
            "slotHints": {
                "string": {
                    "string": {
                        "runtimeHintValues": [
                            {
                                "phrase": "string"
                            },
                            {
                                "phrase": "string"
                            }
                        ]
                    }
                }
            }
        },
        "dialogAction": {
            "slotToElicit": "string",
            "type": "Close | ConfirmIntent | Delegate | ElicitIntent | ElicitSlot"
        },
        "intent": {
            "confirmationState": "Confirmed | Denied | None",
            "name": "string",
            "slots": {
                "string": {
                    "value": {
                        "interpretedValue": "string",
                        "originalValue": "string",
                        "resolvedValues": [
                            "string"
                        ]
                    }
                },
                "string": {
                    "shape": "List",
                    "value": {
                        "interpretedValue": "string",
                        "originalValue": "string",
                        "resolvedValues": [
                            "string"
                        ]
                    },
                    "values": [
                        {
                            "shape": "Scalar",
                            "value": {
                                "originalValue": "string",
                                "interpretedValue": "string",
                                "resolvedValues": [
                                    "string"
                                ]
                            }
                        },
                        {
                            "shape": "Scalar",
                            "value": {
                                "originalValue": "string",
                                "interpretedValue": "string",
                                "resolvedValues": [
                                    "string"
                                ]
                            }
                        }
                    ]
                }
            },
            "state": "Failed | Fulfilled | FulfillmentInProgress | InProgress | ReadyForFulfillment | Waiting",
            "kendraResponse": {
                // Only present when intent is KendraSearchIntent. For details, see
                // https://docs.aws.amazon.com/kendra/latest/dg/API_Query.html#API_Query_ResponseSyntax                     }
            },
            "originatingRequestId": "string"
        }
    },
    "transcriptions": [
        {
            "transcription": "string",
            "transcriptionConfidence": number,
            "resolvedContext": {
                "intent": "string"
            },
            "resolvedSlots": {
                "string": {
                    "shape": "List",
                    "value": {
                        "originalValue": "string",
                        "resolvedValues": [
                            "string"
                        ]
                    },
                    "values": [
                        {
                            "shape": "Scalar",
                            "value": {
                                "originalValue": "string",
                                "resolvedValues": [
                                    "string"
                                ]
                            }
                        },
                        {
                            "shape": "Scalar",
                            "value": {
                                "originalValue": "string",
                                "resolvedValues": [
                                    "string"
                                ]
                            }
                        }
                    ]
                }
            }
        }
    ]
}

Observe as seguintes informações adicionais sobre os campos de evento:

MessageVersion — A versão da mensagem que identifica o formato dos dados do evento que vão para a função Lambda e o formato esperado da resposta de uma função Lambda.

nota
Você configura esse valor ao definir uma intenção. Na implementação atual, apenas a versão de mensagem 1.0 é suportada. Portanto, o console assume o valor padrão de 1.0 e não mostra a versão da mensagem.
invocationSource — Indica a ação que chamou a função Lambda. Quando a fonte éDialogCodeHook, a função Lambda foi chamada após a entrada do usuário. Quando a fonte é,FulfillmentCodeHook a função Lambda foi chamada depois que todos os slots necessários foram preenchidos e a intenção estava pronta para ser cumprida.
InputMode — O tipo de expressão do usuário. Os valores válidos são Speech, DTMF ou Text.
responseContentType— Determina se o bot responde à entrada do usuário com texto ou fala.
sessionId — Identificador de sessão usado para a conversa.
InputTranscript — O texto usado para processar a entrada do usuário. Para entrada de texto ou DTMF, esse é o texto que o usuário digitou. Para entrada de voz, esse é o texto que foi reconhecido a partir da fala.
invocationLabel — Um valor que indica a resposta que invocou a função Lambda. Você pode definir rótulos de invocação para a resposta inicial, os slots e a resposta de confirmação.
bot – Informações sobre o bot que processou a solicitação.
- id — O identificador atribuído ao bot quando você o criou. Você pode ver o ID do bot no console Amazon Lex V2 na página de configurações do bot.
- nome — O nome que você deu ao bot quando o criou.
- AliasId — O identificador atribuído ao alias do bot quando você o criou. Você pode ver o ID do alias do bot no console Amazon Lex V2 na página Aliases. Se você não conseguir ver o ID do alias na lista, escolha o ícone de engrenagem no canto superior direito e ative o ID do alias.
- LocaleID — O identificador da localidade que você usou para seu bot. Para obter uma lista de localidades, consulteAmazon e localidades compatíveis com Amazon Lex V2.
- versão — A versão do bot que processou a solicitação.
interpretações — Uma ou mais intenções que o Amazon Lex V2 considera possíveis correspondências com a expressão do usuário. Para obter mais informações, consulte Interpretação.
proposedNextState— O próximo estado previsto da caixa de diálogo entre o usuário e o bot se a função Lambda definir odialogAction desessionState paraDelegate. Se você substituir o comportamento da caixa de diálogo emsessionState, o próximo estado dependerá das configurações retornadas da sua função Lambda. Você pode usar as informações para modificar o comportamento da sua função do Lambda com base no que o Amazon Lex V2 propõe como a próxima ação. Observe que essa estrutura só está presente quando oinvocationSource campo estáDialogCodeHook e quando a ação de diálogo prevista estáElicitSlot.
- dialogAction — Contém atype açãoslotToElicit e a ação que o Amazon Lex V2 propõe no próximo turno.
- intenção — A intenção que o bot determinou e que o usuário está tentando cumprir. Para obter mais informações, consulte Intenção.
- prompt — A solicitação que o bot usa para instigar o slot.
requestAttributes — Atributos específicos da solicitação que o cliente envia na solicitação. Use atributos de solicitação para passar informações que não precisam ser mantidas durante toda a sessão.
sessionState — O estado atual da conversa entre o usuário e seu bot Amazon Lex V2. Para obter mais informações sobre o estado da sessão, consulte SessionState.
- dialogAction — determina o tipo de ação que o Amazon Lex V2 deve realizar em resposta à função Lambda. Por enquanto, esse campo está sempre em branco.
transcrições — uma ou mais transcrições que o Amazon Lex V2 considera possíveis correspondências com a expressão de áudio do usuário. Para obter mais informações, consulte Usando pontuações de confiança na transcrição de voz.

Formato de resposta

O Amazon Lex V2 espera uma resposta da função do Lambda no formato a seguir:



{
    "sessionState": {
        "activeContexts": [
            {
                "name": "string",
                "contextAttributes": {
                    "key": "value"
                },
                "timeToLive": {
                    "timeToLiveInSeconds": number,
                    "turnsToLive": number
                }
            }
        ],
        "sessionAttributes": {
            "string": "string"
        },
        "runtimeHints": {
            "slotHints": {
                "string": { 
                    "string": { 
                        "runtimeHintValues": [
                            {
                                "phrase": "string"
                            },
                            {
                                "phrase": "string"
                            }
                        ]
                    }
                }
            } 
        },
        "dialogAction": {
            "slotElicitationStyle": "Default | SpellByLetter | SpellByWord",
            "slotToElicit": "string",
            "type": "Close | ConfirmIntent | Delegate | ElicitIntent | ElicitSlot"
        },
        "intent": {
            "confirmationState": "Confirmed | Denied | None",
            "name": "string",
            "slots": {
                "string": {
                    "value": {
                        "interpretedValue": "string",
                        "originalValue": "string",
                        "resolvedValues": [
                            "string"
                        ]
                    }
                },
                "string": {
                    "shape": "List",
                    "value": {
                        "originalValue": "string",
                        "interpretedValue": "string",
                        "resolvedValues": [
                            "string"
                        ]
                    },
                    "values": [
                        {
                            "shape": "Scalar",
                            "value": {
                                "originalValue": "string",
                                "interpretedValue": "string",
                                "resolvedValues": [
                                    "string"
                                ]
                            }
                        },
                        {
                            "shape": "Scalar",
                            "value": {
                                "originalValue": "string",
                                "interpretedValue": "string",
                                "resolvedValues": [
                                    "string"
                                ]
                            }
                        }
                    ]
                }
            },
            "state": "Failed | Fulfilled | FulfillmentInProgress | InProgress | ReadyForFulfillment | Waiting"
        }
    },
    "messages": [
        {
            "contentType": "CustomPayload | ImageResponseCard | PlainText | SSML",
            "content": "string",
            "imageResponseCard": {
                "title": "string",
                "subtitle": "string",
                "imageUrl": "string",
                "buttons": [
                    {
                        "text": "string",
                        "value": "string"
                    }
                ]
            }
        }
    ],
    "requestAttributes": {
        "string": "string"
    }
}

Observe as seguintes informações adicionais sobre os campos de resposta:

SessionState — Obrigatório. O estado atual da conversa com o usuário. O conteúdo real da estrutura depende do tipo de ação do diálogo. Para obter mais informações, consulte SessionState.
- ActiveContextos — Contém informações sobre os contextos que um usuário está usando em uma sessão. Para obter mais informações, consulte ActiveContext Definindo o contexto de intenção.
- sessionAttributes — Um mapa de pares de chave/valor representando informações de contexto específicas da sessão. Para obter mais informações, consulte Como definir atributos da sessão.
- RuntimeHints — Fornece dicas sobre as frases que um cliente provavelmente usará em um slot. Para obter mais informações, consulte RuntimeHints.
- dialogAction — Obrigatório. Determina o tipo de ação que o Amazon Lex V2 deve realizar em resposta à função Lambda.
  - slotElicitationStyle— Determina se o slot usa spell-by-letter nosso spell-by-word estilo. Para obter mais informações, consulte Usando estilos de ortografia para capturar valores de slots.
  - slotToElicit— Exigido somente quandodialogAction.type éElicitSlot. Define o slot a ser extraído do usuário.
  - tipo — Obrigatório. Define a ação que o bot deve executar.
- intenção — O nome da intenção que o Amazon Lex V2 deve usar. Não é necessário quandodialogAction.type éDelegate ouElicitIntent.
  - estado — Obrigatório. O estado só pode serReadyForFulfillment sedialogAction.type forDelegate.
mensagens — Obrigatório, sedialogAction.type forElicitIntent. Uma ou mais mensagens que o Amazon Lex V2 mostra ao cliente para realizar a próxima etapa da conversa. Se você não fornecer mensagens, o Amazon Lex V2 usa a mensagem apropriada definida quando o bot foi criado. Para obter mais informações, consulte o tipo de dados da mensagem.
- ContentType — O tipo de mensagem a ser usada.
- conteúdo — Se o tipo de mensagem forPlainText,CustomPayload, ouSSML, ocontent campo contiver a mensagem a ser enviada ao usuário.
- imageResponseCard— Se o tipo de mensagem forImageResponseCard, contém a definição do cartão de resposta a ser mostrado ao usuário. Para obter mais informações, consulte o tipo de ImageResponseCarddados.
requestAttributes — Atributos específicos da solicitação que o cliente enviou na solicitação.

Função do roteador Lambda

Quando você cria um bot com as APIs do Amazon Lex V2, há apenas uma função Lambda por alias de bot por idioma, em vez de uma função Lambda para cada intenção. Para usar funções separadas, você pode criar uma função de roteador que ativa uma função separada para cada intenção. A seguir está uma função do roteador que você pode usar ou modificar para seu aplicativo.


import os
import json
import boto3

# reuse client connection as global
client = boto3.client('lambda')

def router(event):
    intent_name = event['sessionState']['intent']['name']
    fn_name = os.environ.get(intent_name)
    print(f"Intent: {intent_name} -> Lambda: {fn_name}")
    if (fn_name):
        # invoke lambda and return result
        invoke_response = client.invoke(FunctionName=fn_name, Payload = json.dumps(event))
        print(invoke_response)
        payload = json.load(invoke_response['Payload'])
        return payload
    raise Exception('No environment variable for intent: ' + intent_name)

def lambda_handler(event, context):
    print(event)
    response = router(event)
    return response

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Usando vários valores em um slot

Usando o Automated Chatbot Designer