Build-Auftragsausführung (Dialogflow)

Die Auftragsausführung definiert die dialogorientierte Schnittstelle für Ihre Aktion, um Nutzereingaben zu erhalten, sowie die Logik zur Verarbeitung der Eingabe und schließlich zur Ausführung der Aktion.

Gespräch definieren

Nachdem Sie Aktionen definiert haben, können Sie die entsprechende Unterhaltung für diese Aktionen erstellen. Dazu erstellen Sie Dialogflow-Intents, die die Grammatik definieren oder was Nutzer sagen müssen, um den Intent auszulösen, sowie die entsprechende Auftragsausführung, um den Intent beim Auslösen zu verarbeiten.

Sie können so viele Intents erstellen, wie Sie möchten, um das gesamte grammar für Ihre Unterhaltung zu definieren.

Intents erstellen

Klicken Sie im linken Navigationsbereich von Dialogflow neben dem Menüpunkt Intents auf das +-Zeichen. Der Intent-Editor wird angezeigt, in dem Sie die folgenden Informationen eingeben können:

  • Intent name ist der Name des Intents, der in der IDE angezeigt wird.
  • Mit Kontexten können Sie das Auslösen des Intents auf bestimmte Fälle beschränken. Weitere Informationen finden Sie in der Dialogflow-Dokumentation unter Kontexte.
  • Ereignisse lösen Intents aus, ohne dass Nutzer etwas sagen müssen. Ein Beispiel ist das GOOGLE_ASSISTANT_WELCOME-Ereignis, mit dem Google Assistant deine Aktion aufrufen kann. Dieses Ereignis wird für die Standardaktion deiner Aktion verwendet. Weitere Informationen zu integrierten Hilfs-Intents finden Sie in der Dokumentation.
  • Trainingsformulierungen definieren, was Nutzer sagen müssen (die Grammatik), um den Intent auszulösen. Geben Sie hier ein paar Formulierungen (5–10) für den Inhalt ein, den Nutzer sagen können, um die Absicht auszulösen. Dialogflow verarbeitet automatisch natürliche Variationen der von Ihnen angegebenen Beispielformulierungen.
  • Aktion und Parameter legen fest, welche Daten an die Auftragsausführung übergeben werden, wenn die Auftragsausführung für diesen Intent aktiviert ist. Dazu gehören Daten, die aus der Nutzereingabe geparst werden, und den Namen, mit dem Sie in der Auftragsausführung ermitteln können, welcher Intent ausgelöst wurde. Sie verwenden diesen Namen später, um Ihren Intent der entsprechenden Auftragsausführungslogik zuzuordnen. Weitere Informationen zum Definieren von Aktionen finden Sie in der Dialogflow-Dokumentation unter Aktionen und Parameter.

  • Responses ist der Dialogflow Response Builder, mit dem Sie die Antwort auf diesen Intent direkt in Dialogflow definieren können, ohne die Auftragsausführung aufzurufen. Dieses Feature ist nützlich für statische Antworten, die keine Auftragsausführung erfordern. Hiermit können Sie einfache Begrüßungs- oder Verabschiedungsnachrichten verfassen. Sie verwenden jedoch wahrscheinlich die Auftragsausführung, um Ihren Nutzern für die meisten Intents zu antworten.

  • Die Auftragsausführung gibt an, ob die Auftragsausführung aufgerufen werden soll, wenn dieser Intent ausgelöst wird. Sie aktivieren diese höchstwahrscheinlich für die meisten Intents in Ihrem Dialogflow-Agent. Damit dieses Element im Intent angezeigt wird, muss im Menü Fulfillment (Auftragsausführung) für den Agent die Auftragsausführung aktiviert sein.

Antworten in Dialogflow erstellen

Bei einigen Intents muss die Auftragsausführung möglicherweise keine Antwort zurückgeben. In diesen Fällen können Sie mit dem Antwort-Builder in Dialogflow Antworten erstellen.

Geben Sie im Bereich Responses (Antworten) die Textantwort ein, die Sie an die Nutzer zurückgeben möchten. Standardtextantworten sind einfache Textantworten für die Sprachausgabe, die in mehreren Dialogflow-Integrationen funktionieren können. Antworten für Google Assistant werden auf der Seite Antworten beschrieben.

Antworten für die Auftragsausführung erstellen

Der Auftragsausführungscode wird in der Webhook-Auftragsausführungslogik für eine Aktion gehostet. Im Silly Name Maker-Beispiel finden Sie diese Logik beispielsweise in index.js für Cloud Functions for Firebase.

Wenn ein Intent mit Auftragsausführung ausgelöst wird, erhalten Sie von Dialogflow eine Anfrage mit Informationen zum Intent. Anschließend antworten Sie auf die Anfrage, indem Sie den Intent verarbeiten und eine Antwort zurückgeben. Diese Anfrage und Antwort werden vom Dialogflow-Webhook definiert.

Wir empfehlen dringend, die Node.js-Clientbibliothek zu verwenden, um Anfragen zu verarbeiten und Antworten zurückzugeben. Im Folgenden wird das allgemeine Verfahren zur Verwendung der Clientbibliothek beschrieben:

  1. Initialisieren Sie das Dialogflow-Objekt. Dieses Objekt überwacht automatisch Anfragen und parst sie, damit sie in der Auftragsausführung verarbeitet werden können.
  2. Funktionen zum Verarbeiten von Anfragen erstellen Diese Funktionen verarbeiten die Nutzereingabe und andere Komponenten des Intents und erstellen die Antwort, die an Dialogflow zurückgegeben wird.

Dialogflow-Objekt initialisieren

Mit dem folgenden Code wird Dialogflow instanziiert und Node.js-Boilerplate-Einrichtung für Google Cloud Functions vorgenommen:

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
    // ...
  }

Funktionen zur Verarbeitung von Anfragen erstellen

Wenn Nutzer eine Wortgruppe sprechen, die einen Intent auslöst, erhalten Sie von Dialogflow eine Anfrage, die Sie mit einer Funktion in der Auftragsausführung verarbeiten. In dieser Funktion führen Sie im Allgemeinen folgende Aufgaben aus:

  1. Ausführung der für die Verarbeitung der Nutzereingabe erforderlichen Logik
  2. Erstellen Sie Ihre Antworten so, dass sie auf ausgelöste Intents reagieren. Berücksichtigen Sie die Oberfläche, die Ihre Nutzenden verwenden, um geeignete Antworten zu formulieren. Weitere Informationen zum Zuordnen von Antworten für verschiedene Oberflächen finden Sie unter Oberflächenfunktionen.
  3. Rufen Sie mit Ihrer Antwort die Funktion ask() auf.

Der folgende Code zeigt, wie Sie zwei TTS-Antworten erstellen, die einen Aufruf-Intent (input.welcome) und einen Dialog-Intent (input.number) verarbeiten, der den Nutzer zu Ihrer Aktion begrüßt und eine Zahl zurückgibt, die ein Nutzer für einen Dialogflow-Intent mit dem Namen gesprochen hat:

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();
}

Der benutzerdefinierte Intent Input Number, der dem obigen Code beiliegt, verwendet die Entität @sys.number, um eine Zahl aus Nutzeräußerungen zu extrahieren. Der Intent sendet dann den Parameter num, der die Nummer des Nutzers enthält, an die Funktion in der Auftragsausführung.

Anstatt für jeden Intent einen eigenen Handler zu verwenden, können Sie alternativ eine Fallback-Funktion hinzufügen. Prüfen Sie innerhalb der Fallback-Funktion, welcher Intent die Fallback-Funktion ausgelöst hat, und führen Sie dann die entsprechende Aktion aus.

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();
}

Keine Übereinstimmung

Wenn Dialogflow keiner der Eingabegrammatiken zuordnen kann, die in den Trainingsformulierungen des Intents definiert sind, wird ein Fallback-Intent ausgelöst. Fallback-Intents fordern den Nutzer in der Regel wieder auf, die erforderliche Eingabe für Ihre Aktion zu geben. Sie können Formulierungen für die Aufforderung angeben, indem Sie sie im Bereich Response (Antwort) eines Fallback-Intents angeben. Alternativ können Sie einen Webhook verwenden, um Antworten bereitzustellen.

Wenn die Antwort eines Nutzers nicht mit den Trainingsformulierungen deiner Aktion übereinstimmt, versucht Google Assistant, die Eingabe zu verarbeiten. Dieses Verhalten erleichtert es Nutzern, Aktionen mitten in einer Konversation zu ändern. Beispiel: Ein Nutzer fragt: „Welche Filme laufen diese Woche?“ und ändert dann mitten in der Unterhaltung den Kontext: „Wie wird das Wetter morgen?“ Da in diesem Beispiel „Wie wird das Wetter morgen?“ keine gültige Antwort auf die Unterhaltung ist, die von der ersten Aufforderung ausgelöst wird, versucht Assistant automatisch, die Übereinstimmung zu verarbeiten und den Nutzer in eine entsprechende Unterhaltung zu leiten.

Wenn Assistant keine passende Aktion findet, die der Eingabe des Nutzers entspricht, wird der Nutzer zum Kontext deiner Aktion zurückgeleitet.

Assistant kann deine Aktion unterbrechen, um auf ein gültiges No-Match-Szenario zu reagieren. Verwende deshalb keine Fallback-Intents zur Ausführung von Nutzerabfragen. Sie sollten Fallback-Intents nur verwenden, um den Nutzer erneut um eine gültige Eingabe zu bitten.

So erstellen Sie einen Fallback-Intent:

  1. Klicken Sie im Navigationsmenü von Dialogflow auf Intents.
  2. Klicken Sie neben Create Intent (Intent erstellen) auf das Dreipunkt-Menü ⋮ und wählen Sie Create Fallback Intent (Fallback-Intent erstellen) aus. Alternativ können Sie auf den Standard-Fallback-Intent klicken, um ihn zu bearbeiten.
  3. Geben Sie Formulierungen für die Aufforderung an, mit denen Nutzer angesprochen werden sollen. Diese Formulierungen sollten dialogorientiert und für den aktuellen Kontext des Nutzers so nützlich wie möglich sein.

    So machen Sie dies ohne Auftragsausführung: Geben Sie im Bereich Response (Antwort) des Intents Formulierungen an. Dialogflow wählt nach dem Zufallsprinzip Wortgruppen aus dieser Liste aus, um Nutzern zu antworten, bis ein spezifischer Intent ausgelöst wird.

    So machen Sie das mit der Auftragsausführung:

    1. Aktivieren Sie im Abschnitt Auftragsausführung des Intents die Option Enable webhook call for this intent (Webhook-Aufruf für diesen Intent aktivieren).
    2. Verarbeiten Sie den Fallback-Intent in Ihrer Auftragsausführungslogik wie jeden anderen Intent, wie im Abschnitt Funktionen zum Verarbeiten von Anfragen erstellen beschrieben.

    Die folgende Funktion verwendet beispielsweise das Objekt conv.data (eine beliebige Datennutzlast, mit der Sie den Status aufrechterhalten können) aus der Node.js-Clientbibliothek, um einen Zähler zu speichern, der verfolgt, wie oft ein Fallback-Intent ausgelöst wird. Wird sie mehr als einmal ausgelöst, wird die Aktion beendet. Auch wenn er im Code nicht angezeigt wird, sollten Sie ihn von anderen Intents auf 0 zurücksetzen, wenn ein Nicht-Fallback-Intent ausgelöst wird. (Weitere Informationen zur Implementierung finden Sie im Number Genie-Beispiel.)

    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();
    }

Kontexte verwenden

Verwenden Sie Kontexte, wenn Dialogflow Fallback-Intents nur in bestimmten Situationen auslösen soll. Dies ist hilfreich, wenn Sie unterschiedliche Fallback-Intents für verschiedene No-Match-Szenarien verwenden möchten.

  • Wenn Sie für einen Fallback-Intent keine Kontexte festlegen, wird er als globaler Fallback-Intent betrachtet, der von Dialogflow ausgelöst wird, wenn kein anderer Intent zugeordnet wird. Sie sollten nur eine dieser Optionen definieren, wenn Sie sich dafür entscheiden.
  • Wenn Sie Eingabekontexte für einen Fallback-Intent festlegen, löst Dialogflow diesen Fallback-Intent aus, wenn die folgenden Bedingungen erfüllt sind:

    • Die aktuellen Kontexte des Nutzers sind eine Obermenge der im Intent definierten Kontexte.
    • Keine anderen Intent-Übereinstimmungen.

    So können Sie mehrere Fallback-Intents mit verschiedenen Eingabekontexten verwenden, um die No-Match-Anfrage für bestimmte Szenarien anzupassen.

  • Wenn Sie für einen Fallback-Intent einen Ausgabekontext festlegen, bleibt der Nutzer im selben Kontext, nachdem der Fallback-Intent ausgelöst und verarbeitet wurde.

Weitere Informationen finden Sie unter Dialogflow-Kontexte.

Erneute Aufforderung ohne Eingabe

Auf der Seite Aufforderungen finden Sie weitere Informationen dazu, was zu tun ist, wenn der Nutzer auf einem Sprachgerät wie einem Google Home, das eine fortlaufende Interaktion erfordert, keine weitere Eingabe abgibt.