Implementierungstipps (Dialogflow)

Die folgenden Tipps helfen Ihnen dabei, Tipps für die Gestaltung von Unterhaltungen zu implementieren. in Ihre Aktion ein.

Abweichungen zu erwarten

Verarbeiten Sie dies in der Spalte Eingabe in Dialogflow. Sie sollten auch mehrere Intents, die derselben Aktion zugeordnet werden können, wobei jeder Intent mit unterschiedliche Gruppen von „Die nutzende Person sagt“ Wortgruppen.

Hilfreiche Antwortaufforderungen bieten und anmutig scheitern

Manchmal kann deine Aktion nicht fortgesetzt werden, weil keine Eingabe empfangen wurde (als „No-Input“ bezeichnet) oder die Eingabe eines Nutzers nicht verstanden hat (als „No-Match“ bezeichnet). In diesem Fall versucht Assistant zuerst herauszufinden, ob der Nutzer um eine andere Aktion auszulösen. Wenn Assistant nicht mit der Eingabe des Nutzers übereinstimmt zu einer anderen Aktion führt, fährt der Nutzer im Kontext deiner Aktion fort. Dieses Szenario kann jederzeit eintreten. Daher empfiehlt es sich, ohne Eingabe und ohne Übereinstimmung in jeder Unterhaltungsrunde mit einem Fallback. Fallbacks können Nutzern helfen, wieder auf Kurs zu kommen.

Initialisieren Sie dazu eine fallbackCount-Variable in Ihrem conv.data-Objekt. und setzen es auf 0. Bereiten Sie ein Array von zwei Fallback-Prompts vor (eskalieren Sie die Deutlichkeit). und einen letzten Fallback-Prompt, der die Unterhaltung beendet.

Erstellen Sie dann einen Fallback-Intent (idealerweise für jeden umsetzbaren Intent im Kundenservicemitarbeiter). Rufen Sie im Intent-Handler die Fallback-Anzahl aus conv.data ab. inkrementieren Sie es. Ist der Wert kleiner als 3, rufen Sie den Prompt aus dem Array ab. von 3. Liegt die Anzahl bei 4 oder mehr, schließen Sie das Gespräch mit dem . Setzen Sie die Fallback-Anzahl für alle Intents, die keine Fallbacks sind, auf 0 zurück. Erstellen Sie idealerweise Vorlagen für die Fallbacks für bestimmte Intents.

const GENERAL_FALLBACK = [
   'Sorry, what was that?',
   'I didn\'t quite get that. I can help you find good local restaurants, what do you want to know about?',
];

const LIST_FALLBACK = [
   'Sorry, what was that?',
   'I didn\'t catch that. Could you tell me which one you prefer?',
];

const FINAL_FALLBACK = 'I\'m sorry I\'m having trouble here. Let\'s talk again later.';

const handleFallback = (conv, promptFetch, callback) => {
 conv.data.fallbackCount = parseInt(conv.data.fallbackCount, 10);
 conv.data.fallbackCount++;
 if (conv.data.fallbackCount > 2) {
   conv.close(promptFetch.getFinalFallbackPrompt());
 } else {
   callback();
 }
}
// Intent handlers below
const generalFallback = (conv) => {
  handleFallback = (conv, promptFetch, () => {
    conv.ask(GENERAL_FALLBACK[conv.data.fallbackCount],
      getGeneralNoInputPrompts());
 });
}

const listFallback = (conv) => {
  handleFallback = (conv, promptFetch, () => {
   conv.ask(LIST_FALLBACK[conv.data.fallbackCount],
       getGeneralNoInputPrompts());
 });
}

const nonFallback = (conv) => {
  conv.data.fallbackCount = 0;
  conv.ask('A non-fallback message here');
}

private static final List<String> GENERAL_FALLBACK =
    Arrays.asList(
        "Sorry, what was that?",
        "I didn\'t quite get that. I can tell you all about IO, like date or location, or about the sessions. What do you want to know about?");
private static final List<String> LIST_FALLBACK =
    Arrays.asList(
        "Sorry, what was that?",
        "I didn\'t catch that. Could you tell me which one you liked?");
private static final List<String> FINAL_FALLBACK =
    Arrays.asList("I\'m sorry I\'m having trouble here. Maybe we should try this again later.");

@ForIntent("General Fallback")
public ActionResponse generalFallback(ActionRequest request) {
  ResponseBuilder responseBuilder = getResponseBuilder(request);
  int fallbackCount = (Integer) request.getConversationData().get("fallbackCount");
  fallbackCount++;
  request.getConversationData().put("fallbackCount", fallbackCount);
  if (fallbackCount > 2) {
    responseBuilder.add(getRandomPromptFromList(FINAL_FALLBACK)).endConversation();
  } else {
    responseBuilder.add(getRandomPromptFromList(GENERAL_FALLBACK));
  }
  return responseBuilder.build();
}

private String getRandomPromptFromList(List<String> prompts) {
  Random rand = new Random();
  int i = rand.nextInt(prompts.size());
  return prompts.get(i);
}

@ForIntent("List Fallback")
public ActionResponse listFallback(ActionRequest request) {
  ResponseBuilder responseBuilder = getResponseBuilder(request);
  int fallbackCount = (Integer) request.getConversationData().get("fallbackCount");
  fallbackCount++;
  request.getConversationData().put("fallbackCount", fallbackCount);
  if (fallbackCount > 2) {
    responseBuilder.add(getRandomPromptFromList(FINAL_FALLBACK)).endConversation();
  } else {
    responseBuilder.add(getRandomPromptFromList(LIST_FALLBACK));
  }
  return responseBuilder.build();
}

@ForIntent("Non Fallback")
public ActionResponse nonFallback(ActionRequest request) {
  ResponseBuilder responseBuilder = getResponseBuilder(request);
  request.getConversationData().put("fallbackCount", 0);
  responseBuilder.add("Non Fallback message");
  return responseBuilder.build();
}

Du kannst jederzeit mithelfen

Erstellen Sie einen Intent, der Hilfebefehle wie „Was kann ich tun?“, „Was kannst du mir sagen?“ oder „Hilfe“. Bieten Sie in dieser Absicht einige (rotierend) Antwort, die einen Überblick darüber bietet, was der Agent tun kann, und Nutzer zu einer möglichen Maßnahmen. Nutzen Sie idealerweise auch Follow-up-Hilfe-Intents in Dialogflow, um verschiedene Hilfeszenarien für verschiedene umsetzbare Intents erstellen.

const HELP_PROMPTS = [
   'There\'s a lot you might want to know about the local restaurants, and I can tell you all about it, like where it is and what kind of food they have. What do you want to know?',
   'I\'m here to help, so let me know if you need any help figuring out where or what to eat. What do you want to know?',
];

// Intent handler
const help = (conv) => {
 reply(conv, promptFetch.getHelpPrompt(), // fetches random entry from HELP_PROMPTS
     promptFetch.getGeneralNoInputPrompts());
}

private static final List<String> HELP_PROMPTS =
    Arrays.asList(
        "There's a lot you might want to know about IO, and I can tell you all about it, like where it is and what the sessions are. What do you want to know?",
        "IO can be a little overwhelming, so I\'m here to help. Let me know if you need any help figuring out the event, like when it is, or what the sessions are. What do you want to know?");

@ForIntent("Help")
public ActionResponse help(ActionRequest request) {
  return getResponseBuilder(request).add(getRandomPromptFromList(HELP_PROMPTS)).build();
}

Nutzer dürfen Informationen wiederholen lassen

Verpacken Sie alle app.ask(output)-Methoden mit einer Proxyfunktion, die den Ausgabe in conv.data.lastPrompt. Einen wiederholten Intent erstellen, der auf Folgendes wartet Aufforderungen wiederholen, z. B. „Was?“, „Sag das noch mal“ oder „Kannst du wiederholen?“ Erstellen Sie ein Array von Wiederholungspräfixen, mit denen bestätigen, dass der Nutzer um eine Wiederholung gebeten hat. Wiederholung Intent-Handler, rufen Sie ask() mit einem verketteten String des Wiederholungspräfixes auf. Wert von conv.data.lastPrompt Denken Sie daran, dass Sie alle Öffnende SSML-Tags, wenn sie in der letzten Eingabeaufforderung verwendet wurden.

const REPEAT_PREFIX = [
    'Sorry, I said ',
    'Let me repeat that. ',
];

const reply = (conv, inputPrompt, noInputPrompts) => {
  conv.data.lastPrompt = inputPrompt;
  conv.data.lastNoInputPrompts = noInputPrompts;
  conv.ask(inputPrompt, noInputPrompts);
}
// Intent handlers
const normalIntent = (conv) => {
  reply(conv, 'Hey this is a question', SOME_NO_INPUT_PROMPTS);
}

const repeat = (conv) => {
  let repeatPrefix = promptFetch.getRepeatPrefix(); // randomly chooses from REPEAT_PREFIX
  // Move SSML start tags over
  if (conv.data.lastPrompt.startsWith(promptFetch.getSSMLPrefix())) {
    conv.data.lastPrompt =
        conv.data.lastPrompt.slice(promptFetch.getSSMLPrefix().length);
    repeatPrefix = promptFetch.getSSMLPrefix() + repeatPrefix;
  }
  conv.ask(repeatPrefix + conv.data.lastPrompt,
      conv.data.lastNoInputPrompts);
}

private final List<String> REPEAT_PREFIX = Arrays.asList("Sorry, I said ", "Let me repeat that.");

private final String SsmlPrefix = "<speak>";

@ForIntent("Normal Intent")
public ActionResponse normalIntent(ActionRequest request) {
  ResponseBuilder responseBuilder = getResponseBuilder(request);
  responseBuilder.getConversationData().put("lastPrompt", "Hey this is a question");
  return responseBuilder.build();
}

@ForIntent("repeat")
public ActionResponse repeat(ActionRequest request) {
  ResponseBuilder responseBuilder = getResponseBuilder(request);
  String repeatPrefix = getRandomPromptFromList(REPEAT_PREFIX);
  // Move SSML start tags over
  String lastPrompt = (String) responseBuilder.getConversationData().get("lastPrompt");
  if (lastPrompt.startsWith(SsmlPrefix)) {
    String newLastPrompt = lastPrompt.substring(SsmlPrefix.length());
    responseBuilder.getConversationData().put("lastPrompt", newLastPrompt);
    repeatPrefix = SsmlPrefix + repeatPrefix;
  }
  responseBuilder.add(repeatPrefix + lastPrompt);
  return responseBuilder.build();
}

Unterhaltungen mit Nutzereinstellungen personalisieren

Deine Aktion kann Nutzer nach ihren Präferenzen fragen und sie für können Sie zukünftige Unterhaltungen mit diesem Nutzer personalisieren.

Durch diese Beispielaktion erhalten Nutzer einen Wetterbericht für eine Postleitzahl. Die folgenden Im Beispielcode wird der Nutzer gefragt, ob die Aktion seine Postleitzahl speichern soll. für spätere Unterhaltungen.

app.intent('weather_report', (conv) => {
  let zip = conv.arguments.get('zipcode');
  conv.data.zip = zip;
  conv.ask(getWeatherReport(zip));
  conv.ask(new Confirmation(`Should I remember ${zip} for next time?`));
});

app.intent('remember_zip', (conv, params, confirmation) => {
  if (confirmation) {
    conv.user.storage.zip = conv.data.zip;
    conv.close('Great! See you next time.');
  } else conv.close('Ok, no problem.');
});

@ForIntent("weather_report")
public ActionResponse weatherReport(ActionRequest request) {
  ResponseBuilder responseBuilder = getResponseBuilder(request);
  String zip = (String) request.getArgument("location").getStructuredValue().get("zipCode");
  responseBuilder.getConversationData().put("zip", zip);
  responseBuilder.add(getWeatherReport(zip));
  responseBuilder.add(
      new Confirmation().setConfirmationText("Should I remember " + zip + " for next time?"));
  return responseBuilder.build();
}

@ForIntent("remember_zip")
public ActionResponse rememberZip(ActionRequest request) {
  ResponseBuilder responseBuilder = getResponseBuilder(request);
  if (request.getUserConfirmation()) {
    responseBuilder.getUserStorage().put("zip", responseBuilder.getConversationData().get("zip"));
    responseBuilder.add("Great! See you next time.").endConversation();
  } else {
    responseBuilder.add("Ok, no problem.").endConversation();
  }
  return responseBuilder.build();
}

Nachdem Sie den Nutzer beim ersten Dialogfeld gefragt haben, können diese Aufforderung beim nächsten Aufruf überspringen und dieselbe Postleitzahl verwenden. Trotzdem sollten Sie eine Escape-Route angeben (z. B. einen Vorschlags-Chip, eine andere Postleitzahl auswählen, sondern auch, indem Sie in den schaffen Sie ein nahtloseres Erlebnis.

app.intent('weather_report', (conv) => {
  let zip = conv.arguments.get('zipcode');
  if (zip) {
    conv.close(getWeatherReport(zip));
  } else if (conv.user.storage.zip) {
    conv.ask(new SimpleResponse(getWeatherReport(conv.user.storage.zip)));
    conv.ask(new Suggestions('Try another zipcode'));
  } else {
    conv.ask('What\'s your zip code?');
  }
});

app.intent('provide_zip_df', (conv) => {
  conv.user.storage.zip = conv.arguments.get('zipcode');
  conv.close(getWeatherReport(conv.user.storage.zip));
});

public ActionResponse weatherReport2(ActionRequest request) {
  ResponseBuilder responseBuilder = getResponseBuilder(request);
  String zip = (String) request.getArgument("location").getStructuredValue().get("zipCode");
  if (zip != null) {
    responseBuilder.add(getWeatherReport(zip)).endConversation();
  } else if ((zip = (String) responseBuilder.getUserStorage().get("zip")) != null) {
    responseBuilder.add(new SimpleResponse().setTextToSpeech(getWeatherReport(zip)));
    responseBuilder.add(new Suggestion().setTitle("Try another zipcode"));
  } else {
    responseBuilder.add("What's your zip code?");
  }
  return responseBuilder.build();
}

Für wiederkehrende Nutzer anpassen

Ein gewisses Gleichgewicht zwischen Unterhaltungen zu erhalten, sorgt für eine viel natürlichere für wiederkehrende Nutzende. Der erste Schritt besteht darin, „Greet“-Nutzer*innen anders. Sie können zum Beispiel die Begrüßung oder hilfreiche Informationen auf der Grundlage vergangener Unterhaltungen anzuzeigen. Verwenden Sie dazu die Methode eingehendes Attribut AppRequest.User lastSeen, um festzustellen, ob der Nutzer hat bereits mit deiner Aktion interagiert. Wenn das Attribut lastSeen enthalten ist können Sie eine andere Begrüßung als normal verwenden.

Der folgende Code verwendet die Node.js-Clientbibliothek, um den Wert von last.seen

// This function is used to handle the welcome intent
// In Dialogflow, the Default Welcome Intent ('input.welcome' action)
// In Actions SDK, the 'actions.intent.MAIN' intent
const welcome = (conv) => {
  if (conv.user.last.seen) {
    conv.ask(`Hey you're back...`);
  } else {
    conv.ask('Welcome to World Cities Trivia!...');
  }
}

// This function is used to handle the welcome intent
// In Dialogflow, the Default Welcome Intent ('input.welcome' action)
// In Actions SDK, the 'actions.intent.MAIN' intent
public ActionResponse welcome(ActionRequest request) {
  ResponseBuilder responseBuilder = getResponseBuilder(request);
  if (request.getUser().getLastSeen() != null) {
    responseBuilder.add("Hey you're back...");
  } else {
    responseBuilder.add("Welcome to Number Genie!...");
  }
  return responseBuilder.build();
}

Sie können diese Begrüßung weiter optimieren, indem Sie die Antwort an den tatsächlichen Wert von lastSeen. Nutzer, deren letzte Interaktion viele Nutzer umfasste, Monate vor der aktuellen Interaktion möglicherweise eine andere Begrüßung als die die Aktion am Vortag verwendet haben.

Lautstärkeregelung während der Unterhaltung

Auf unterstützten Geräten können Nutzer mit Assistant die Gerätelautstärke in ihrem indem du Dinge sagst wie „Lautstärke erhöhen“ oder „Stell die Lautstärke auf 50 %“. Wenn Sie Intents haben, die ähnliche Trainingsformulierungen verarbeiten, haben Ihre Intents Vorrang. Wir empfehlen, Assistant die Verarbeitung zu erlauben wenn deine Aktion keinen bestimmten Grund hat.