Fulfillment do build (Dialogflow)

O fulfillment define a interface de conversa para a ação receber a entrada do usuário e a lógica para processar a entrada e, em algum momento, atender a ação.

Defina sua conversa

Agora que você definiu as ações, poderá criar a conversa correspondente para essas ações. Você faz isso Criar intents do Dialogflow que definam a gramática ou o que os usuários precisam para acionar a intent e o fulfillment correspondente para processar a intent quando ele é acionado.

Você pode criar quantas intents quiser para definir toda a conversa gramática.

Criar intents

Clique no sinal + ao lado do item de menu Intents na no menu de navegação à esquerda. O Intent Editor aparece onde é possível inserir as seguintes informações:

  • Intent name é o nome da intent exibida no ambiente de desenvolvimento integrado.
  • Os contextos permitem definir o escopo do acionamento da intent para casos específicos. leia a documentação do Dialogflow sobre contextos; para mais informações.
  • Os eventos acionam intents sem que os usuários precisem dizer qualquer coisa. Um exemplo de evento é o evento GOOGLE_ASSISTANT_WELCOME, que permite ao Google Google Assistente para invocar sua ação. Esse evento é usado para os eventos Ação padrão. Consulte nossa documentação para saber mais sobre as intents auxiliares integradas.
  • Frases de treinamento definem o que os usuários precisam dizer (a gramática) para acionar o intent. Digite aqui algumas frases (5 a 10) do que os usuários podem dizer para acionar o intent. O Dialogflow processa automaticamente as variações naturais do exemplo. frases que você fornece.

  • Ação e parâmetros definem quais dados transmitir para o fulfillment se o fulfillment está ativado para essa intent. Isso inclui dados analisados entrada do usuário e o nome que pode ser usado no fulfillment para detectar quais intent foi acionada. Você vai usar esse nome mais tarde para mapear sua intent aos lógica de fulfillment correspondente. Consulte Ações e parâmetros. na documentação do Dialogflow para mais informações sobre a definição de ações.

  • Responses é o Criador de respostas do Dialogflow, em que é possível definir as resposta a essa intent diretamente no Dialogflow, sem chamar o atendimento do pedido. Esse recurso é útil para respostas estáticas que não precisam o atendimento do pedido. Você pode usá-lo para fornecer mensagens simples de boas-vindas ou de despedida. No entanto, é provável que você use o fulfillment para responder aos usuários pela maior parte intents.

  • Fulfillment especifica se você quer ou não chamar o fulfillment quando essa intent for acionada. Você provavelmente ativará isso para a maioria intents no agente do Dialogflow. Para ver esse item na intent, é preciso ativar o fulfillment para o agente no menu Fulfillment.

Como criar respostas no Dialogflow

Para algumas intents, pode não ser necessário que o fulfillment retorne uma resposta. Nesses casos, use o criador de respostas no Dialogflow para criar de resposta.

Na área Respostas, forneça a resposta textual que você quer retornar usuários. As respostas de texto padrão são respostas de texto de TTS simples que podem funcionar várias integrações do Dialogflow. As respostas para o Google Assistente estão descritas na página Respostas.

Como criar respostas de fulfillment

O código de fulfillment é hospedado na lógica de fulfillment do webhook de uma ação. Por exemplo, no exemplo do Silly Name Maker, essa lógica é encontrada em index.js da Função do Cloud para Firebase.

Quando uma intent que usa o fulfillment é acionada, você recebe uma solicitação Dialogflow que contém informações sobre a intent. Em seguida, você responde ao processar a intent e retornar uma resposta. Essa solicitação e resposta é definida pelo webhook do Dialogflow.

É altamente recomendável usar a biblioteca de cliente Node.js para processar as solicitações e retornam respostas. Este é o processo geral de uso da biblioteca de cliente:

  1. Inicialize o objeto do Dialogflow. Este objeto lida automaticamente com a escuta de solicitações e a análise delas para que para que você possa processá-las no fulfillment.
  2. Crie funções para processar solicitações. Essas funções processam a entrada do usuário e outros componentes da intent e criar a resposta para retornar ao Dialogflow.

Inicializar o objeto Dialogflow

O código a seguir instancia o Dialogflow e faz alguns códigos boilerplate. Configuração do Node.js para o Google Cloud Functions:

Node.js
'use strict';

const {dialogflow} = require('actions-on-google');
const functions = require('firebase-functions');

const app = dialogflow({debug: true});

app.intent('Default Welcome Intent', (conv) => {
  // Do things
});
exports.yourAction = functions.https.onRequest(app);
Java
public class DfFulfillment extends DialogflowApp {
  private static final Logger LOGGER = LoggerFactory.getLogger(DfFulfillment.class);

  @ForIntent("Default Welcome Intent")
  public ActionResponse welcome(ActionRequest request) {
    // Do things
    // ...
  }

Criar funções para processar solicitações

Quando os usuários falam uma frase que aciona uma intent, você recebe uma solicitação Dialogflow que você processa com uma função no fulfillment. Neste você geralmente fará o seguinte:

  1. Realizar qualquer lógica necessária para processar a entrada do usuário.
  2. Crie respostas para responder às intents acionadas. Considere o que os usuários estão usando para elaborar as respostas apropriadas. Consulte recursos de superfície para mais informações sobre como fornecer respostas para diferentes superfícies.
  3. Chame a função ask() com sua resposta.
.

O código a seguir mostra como criar duas respostas TTS que lidam com uma intent de invocação (input.welcome) e de caixa de diálogo (input.number) que dá as boas-vindas ao usuário na sua ação e repete o número que ele falou. uma intent do Dialogflow com o nome:

Node.js
const app = dialogflow();
app.intent('Default Welcome Intent', (conv) => {
conv.ask('Welcome to number echo! Say a number.');
});
app.intent('Input Number', (conv, {num}) => {
// extract the num parameter as a local string variable
conv.close(`You said ${num}`);
});
Java
@ForIntent("Default Welcome Intent")
public ActionResponse defaultWelcome(ActionRequest request) {
  ResponseBuilder rb = getResponseBuilder(request);
  rb.add("Welcome to number echo! Say a number.");
  return rb.build();
}

@ForIntent("Input Number")
public ActionResponse inputNumber(ActionRequest request) {
  ResponseBuilder rb = getResponseBuilder(request);
  Integer number = (Integer) request.getParameter("num");
  rb.add("You said " + number.toString());
  return rb.endConversation().build();
}

O número de entrada da intenção personalizada, que acompanha o código acima, usa o Entidade @sys.number para extrair um número de enunciados do usuário. Então, a intent envia o parâmetro num, que contém o número do usuário, para o no fulfillment.

Em vez de ter gerenciadores individuais para cada intent, também é possível adicionar uma função de fallback. Na função substituta, verifique qual intent acionou e tomar a medida apropriada de acordo.

Node.js
const WELCOME_INTENT = 'Default Welcome Intent';
const NUMBER_INTENT = 'Input Number';
const NUMBER_PARAMETER = 'num';
// you can add a fallback function instead of a function for individual intents
app.fallback((conv) => {
 // intent contains the name of the intent
 // you defined in the Intents area of Dialogflow
 const intent = conv.intent;
 switch (intent) {
   case WELCOME_INTENT:
     conv.ask('Welcome! Say a number.');
     break;
   case NUMBER_INTENT:
     const num = conv.parameters[NUMBER_PARAMETER];
     conv.close(`You said ${num}`);
     break;
 }
});
Java
// you can add a fallback function instead of a function for individual intents
@ForIntent("Default Fallback Intent")
public ActionResponse fallback(ActionRequest request) {
  final String WELCOME_INTENT = "Default Welcome Intent";
  final String NUMBER_INTENT = "Input Number";
  final String NUMBER_ARGUMENT = "num";
  // intent contains the name of the intent
  // you defined in the Intents area of Dialogflow
  ResponseBuilder rb = getResponseBuilder(request);
  String intent = request.getIntent();
  switch (intent) {
    case WELCOME_INTENT:
      rb.add("Welcome! Say a number.");
      break;
    case NUMBER_INTENT:
      Integer num = (Integer) request.getParameter(NUMBER_ARGUMENT);
      rb.add("You said " + num).endConversation();
      break;
  }
  return rb.build();
}

Nova solicitação sem correspondência

Quando o Dialogflow não consegue corresponder a nenhuma das gramáticas de entrada definidas nas intents Frases de treinamento, ele aciona uma intent substituta. Intents substitutas normalmente solicite novamente que o usuário forneça as informações necessárias para a ação. Você pode fornecer frases de nova solicitação especificando-as na área Response de um de substituta ou usar um webhook para fornecer respostas.

Quando a resposta de um usuário não corresponde às frases de treinamento da sua Ação, o Google O Google Assistente tenta processar a entrada. Esse comportamento facilita que os usuários mudem Ações no meio de uma conversa Por exemplo, um usuário pergunta: “Quais filmes está jogando esta semana?" e muda o contexto no meio da conversa: "O que é a previsão do tempo para amanhã?" Neste exemplo, porque "Qual é a previsão do tempo para amanhã?" não for uma resposta válida para a conversa acionada pelo comando inicial, O Google Assistente tenta processar a partida automaticamente e colocar o usuário em uma a conversa mais apropriada.

Se o Google Assistente não encontrar uma ação que corresponda à entrada do usuário, o usuário é levado de volta ao contexto da sua ação.

Porque o Google Assistente pode interromper sua ação para responder a uma falta de correspondência válida. cenário, não use intents substitutas como forma de atender às consultas do usuário. Você use apenas intents de fallback para solicitar uma nova entrada válida do usuário.

Para criar uma intent substituta:

  1. Clique em Intents no menu de navegação do Dialogflow.
  2. Clique em ⋮ ao lado de Criar intent e selecione Criar intent de fallback (Como alternativa, clique no botão Default Fallback intent para editá-lo.

  3. Especifique frases de recomando para responder aos usuários. Essas frases devem ser conversacional e ser o mais útil possível para o contexto atual do usuário.

    Para fazer isso sem fulfillment: especifique frases na área Resposta da intent. O Dialogflow escolhe aleatoriamente frases desta lista para falar aos usuários até que uma intent mais específica seja acionada.

    Para fazer isso com fulfillment:

    1. Selecione Ativar chamada de webhook para esta intent na seção Fulfillment da intent.
    2. Na lógica de fulfillment, processe a intent substituta como qualquer outra intents, conforme descrito em Criar funções para lidar com solicitações nesta seção.

    Por exemplo, a função a seguir usa o objeto conv.data (um payload de dados arbitrário que pode ser usado para manter o estado) do Biblioteca de cliente Node.js para armazenar uma que rastreia quantas vezes uma intent substituta é acionada. Se for acionada mais de uma vez, a Ação é encerrada. Embora não apareça faça com que outras intents redefinam esse contador para 0 quando uma intent não substituto é acionada. Consulte a Amostra do Number Genie para saber como fazer isso.)

    Node.js
    app.intent('Default Fallback Intent', (conv) => {
 conv.data.fallbackCount++;
 // Provide two prompts before ending game
 if (conv.data.fallbackCount === 1) {
   conv.contexts.set(DONE_YES_NO_CONTEXT, 5);
   conv.ask('Are you done playing Number Genie?');
 } else {
   conv.close(`Since I'm still having trouble, so I'll stop here. ` +
     `Let's play again soon.`);
 }
});
    Java
    @ForIntent("Default Fallback Intent")
public ActionResponse defaultFallback(ActionRequest request) {
  final String DONE_YES_NO_CONTEXT = "done_yes_no_context";
  ResponseBuilder rb = getResponseBuilder(request);

  int fallbackCount =
      request.getConversationData().get("fallbackCount") == null
          ? 0
          : (Integer) request.getConversationData().get("fallbackCount");
  fallbackCount++;
  request.getConversationData().put("fallbackCount", fallbackCount);

  if (fallbackCount == 1) {
    rb.add(new ActionContext(DONE_YES_NO_CONTEXT, 5));
    rb.add("Are you done playing Number Genie?");
  } else {
    rb.add("Since I'm still having trouble, so I'll stop here. Let's play again soon")
        .endConversation();
  }
  return rb.build();
}

Como usar contextos

Use contextos se quiser que o Dialogflow acione intents substitutas somente em determinadas em diferentes situações. Isso é útil se você quer ter diferentes intents substitutas para diferentes cenários sem correspondência.

  • Se você não definir contextos para uma intent de fallback, ela será considerada uma intent de fallback global que o Dialogflow aciona quando nenhuma outra intent está correspondentes. Você deve ter apenas um deles definido se optar por usar um.

  • Se você definir contextos de entrada em uma intent de fallback, o Dialogflow acionará essa intent substituta quando o seguinte for verdadeiro:

    • Os contextos atuais do usuário são um superconjunto dos contextos definidos no intenção.
    • Nenhuma outra intent corresponde.

    Isso permite que você use várias intents substitutas com diferentes contextos de entrada para personalizar novas solicitações sem correspondência para cenários específicos.

  • Se você definir um contexto de saída em uma intent de fallback, manterá o usuário na no mesmo contexto depois que a intent substituta é acionada e processada.

Consulte Contextos do Dialogflow para mais informações.

Reenvio sem entrada

Consulte a página Reprompts para saber mais. lidar com quando o usuário não fornece outras entradas em um dispositivo de voz, como um Google Home que exige interação contínua.