Von Dialogflow ES zu Conversational Agents (Dialogflow CX) migrieren

Conversational Agents (Dialogflow CX) bieten effektivere Steuerelemente und Tools für Unterhaltungen als Dialogflow ES-Agents. Wenn Ihr Dialogflow ES-Agent komplexe Unterhaltungen abwickelt, sollten Sie eine Migration zu Conversational Agents (Dialogflow CX) in Betracht ziehen.

In diesem Leitfaden wird beschrieben, wie Sie einen Kundenservicemitarbeiter von Dialogflow ES zu Conversational Agents (Dialogflow CX) migrieren. Diese beiden Kundenservicemitarbeitertypen unterscheiden sich grundlegend voneinander, sodass es keine einfache Möglichkeit gibt, diese Migration durchzuführen.

Wenn Sie diesen Leitfaden für eine Migration verwenden, geben Sie bitte positives oder negatives Feedback, indem Sie oben auf die Schaltfläche Feedback geben klicken. Wir nutzen dieses Feedback, um diesen Leitfaden im Laufe der Zeit zu verbessern.

Im Großen und Ganzen wird ein hybrider Prozess empfohlen, der automatisierte und manuelle Schritte umfasst. Sie verwenden ein Tool, das einige Ihrer Dialogflow ES-Kundenservicemitarbeiterdaten liest, diese Daten in Ihren Conversational Agents (Dialogflow CX)-Kundenservicemitarbeiter schreibt und eine To-do-Liste erfasst. Erstellen Sie dann Ihren vollständigen Conversational AI-Agent (Dialogflow CX) anhand der Best Practices, der TODO-Liste und der Daten, die mit dem Tool migriert wurden.

Konversations-Agenten (Dialogflow CX)

Bevor Sie mit der Migration beginnen, sollten Sie sich mit den Abläufen von Conversational Agents (Dialogflow CX) vertraut machen. So gehts:

• Grundlagen von Flows

Sie sollten sich auch zusätzliche Konzeptdokumente ansehen, die Funktionen enthalten, die Sie in Ihrem neuen Bot wahrscheinlich benötigen. Konzentrieren Sie sich auf Folgendes:

• Console – Übersicht
• Agents
• Abläufe
• Seiten
• Zustands-Handler
• Intents
• Parameter
• Ausführungen
• Webhooks

Unterschiede zwischen Dialogflow ES und Conversational Agents (Dialogflow CX)

In diesem Abschnitt sind die wichtigsten Unterschiede zwischen Dialogflow ES und Conversational Agents (Dialogflow CX) aufgeführt. Wenn Sie später manuelle Migrationsschritte ausführen, sollten Sie sich an diesen Abschnitt halten.

Struktur und Unterhaltungsverlauf steuern

Dialogflow ES bietet Folgendes für die Struktur- und Unterhaltungspfadsteuerung:

• Intents sind die Bausteine des Agents. An jedem Punkt der Unterhaltung wird ein Intent abgeglichen. In gewisser Weise ist jeder Intent ein Knoten für die Unterhaltung.
• Der Kontext wird verwendet, um den Ablauf der Unterhaltung zu steuern. Mithilfe des Kontexts wird festgelegt, welche Intents zu einem bestimmten Zeitpunkt abgeglichen werden können. Der Kontext läuft nach einer bestimmten Anzahl von Unterhaltungsrunden ab. Daher kann diese Art der Steuerung bei langen Unterhaltungen ungenau sein.

Conversational Agents (Dialogflow CX) bieten eine Hierarchie von Strukturressourcen und genauere Steuerelemente für den Konversationspfad:

• Seiten sind Graphknoten für die Unterhaltung. Unterhaltungen mit Conversational Agents (Dialogflow CX) ähneln Zustandsmaschinen. Zu jedem Zeitpunkt der Unterhaltung ist eine Seite aktiv. Je nach Eingaben oder Ereignissen des Endnutzers kann die Unterhaltung zu einer anderen Seite wechseln. Es ist üblich, dass eine Seite für mehrere Gesprächsrunden aktiv bleibt.
• Abläufe sind Gruppen ähnlicher Seiten. Jeder Ablauf sollte ein allgemeines Gesprächsthema abdecken.
• Zustands-Handler werden verwendet, um Übergänge und Antworten zu steuern. Es gibt drei Arten von Status-Handlern:
  • Intent-Route: Enthält einen Intent, der abgeglichen werden muss, optionale Antworten und einen optionalen Seitenübergang.
  • Bedingungsroute: Enthält eine Bedingung, die erfüllt sein muss, optionale Antworten und einen optionalen Seitenübergang.
  • Ereignis-Handler: Enthält einen Ereignisnamen, der aufgerufen werden muss, optionale Antworten und optionale Seitenübergänge.
• Mit dem Umfang wird gesteuert, ob ein Zustands-Handler aufgerufen werden kann. Die meisten Handler sind mit einer Seite oder einem gesamten Ablauf verknüpft. Wenn die zugehörige Seite oder der zugehörige Ablauf aktiv ist, liegt der Handler im Gültigkeitsbereich und kann aufgerufen werden. Eine gültige Intent-Route für Conversational Agents (Dialogflow CX) ähnelt einem Dialogflow ES-Intent mit einem aktiven Eingabekontext.

Beachten Sie beim Entwerfen der Aufrufabfolgen und Seiten Ihres Agents die Empfehlungen im Abschnitt zum Aufrufablauf im Leitfaden zum Design von Kundenservicemitarbeitern.

Formular ausfüllen

In Dialogflow ES werden erforderliche Parameter vom Endnutzer mithilfe der Slot-Füllung erfasst:

• Diese Parameter sind als erforderlich gekennzeichnete Intent-Parameter.
• Die Zuordnung des Intents wird fortgesetzt, bis alle erforderlichen Parameter erfasst wurden.
• Sie können einen Prompt definieren, in dem der Endnutzer aufgefordert wird, einen Wert anzugeben.

Conversational Agents (Dialogflow CX) verwenden das Ausfüllen von Formularen, um die erforderlichen Parameter vom Endnutzer zu erfassen:

• Diese Parameter sind mit einer Seite verknüpft und werden erfasst, während die Seite aktiv ist.
• Mithilfe von Bedingungsrouten für Seiten können Sie feststellen, ob das Ausfüllen des Formulars abgeschlossen ist. Diese Bedingungsrouten führen in der Regel zu einer anderen Seite.
• Sie können einen Prompt sowie Handler für wiederholte Prompts definieren, um mehrere Versuche zum Erfassen eines Werts reibungslos zu verarbeiten.

Übergänge

Dialogflow ES wechselt automatisch von einem Intent zum nächsten, wenn die Eingabe des Endnutzers einem Intent zugeordnet wird. Diese Zuordnung kann nur für Intents ohne Eingabekontext oder für Intents mit einem aktiven Eingabekontext erfolgen.

Conversational Agents (Dialogflow CX) wechseln von einer Seite zur nächsten, wenn ein in der Reichweite befindlicher Status-Handler seine Anforderungen erfüllt und ein Übergangsziel angibt. Mithilfe dieser Übergänge können Sie Endnutzer zuverlässig durch Unterhaltungen führen. Es gibt mehrere Möglichkeiten, diese Übergänge zu steuern:

• Die Intent-Zuordnung kann eine Intent-Route auslösen.
• Wenn eine Bedingung erfüllt ist, kann eine Bedingungsroute ausgelöst werden.
• Das Aufrufen eines Ereignisses kann einen Event-Handler auslösen.
• Handler für die erneute Eingabeaufforderung können einen Übergang auslösen, wenn der Endnutzer nach mehreren Versuchen keinen Wert angibt.
• Sie können symbolische Umstellungsziele für Umstellungsziele verwenden.

Antworten des Kundenservicemitarbeiters

Dialogflow ES-Agentantworten werden an den Endnutzer gesendet, wenn ein Intent zugeordnet wird:

• Der Kundenservicemitarbeiter kann aus einer Liste möglicher Antworten eine Nachricht für die Antwort auswählen.
• Antworten können plattformspezifisch sein und Rich-Media-Antwortformate verwenden.
• Antworten können über Webhooks ausgelöst werden.

Antworten von Conversational Agents (Dialogflow CX) werden an den Endnutzer gesendet, wenn fulfillment aufgerufen wird. Im Gegensatz zur Dialogflow ES-Auftragsausführung, die immer einen Webhook erfordert, kann die Auftragsausführung für Conversational Agents (Dialogflow CX) einen Webhook aufrufen oder nicht, je nachdem, ob für die Auftragsausführungsressource ein Webhook konfiguriert ist. Sowohl statische als auch dynamische Antworten, die auf Webhook-Antworten basieren, werden über die Auftragsausführung gesteuert. Es gibt mehrere Möglichkeiten, Antworten von Kundenservicemitarbeitern zu erstellen:

• Die Auftragsausführung kann für jeden Status-Handler bereitgestellt werden.
• Mehrere Antworten können während einer Unterhaltungsrunde über die Antwortwarteschlange verkettet werden. Diese Funktion kann in einigen Fällen das Design Ihres Kundenservicemitarbeiters vereinfachen.
• Conversational Agents (Dialogflow CX) unterstützen keine integrierten plattformspezifischen Antworten. Es bietet jedoch mehrere Antworttypen, einschließlich einer benutzerdefinierten Nutzlast, die für plattformspezifische Antworten verwendet werden kann.

Parameter

Dialogflow ES-Parameter haben folgende Eigenschaften:

• Nur in Intents definiert.
• Wird durch Eingaben von Endnutzern, Ereignissen, Webhooks und API-Aufrufen festgelegt.
• Wird in Antworten, Parameteraufforderungen, Webhook-Code und Parameterwerten referenziert:
  • Das grundlegende Referenzformat ist $parameter-name.
  • Für Verweise wird die Suffixsyntax .original, .partial und .recent unterstützt.
  • In Referenzen kann der aktive Kontext angegeben werden: #context-name.parameter-name.
  • In Verweislisten können Ereignisparameter angegeben werden: #event-name.parameter-name.

Parameter für Conversational Agents (Dialogflow CX) haben folgende Merkmale:

• In Intents und Seitenformularen definiert.
• Intent- und Formularparameter werden an Sitzungsparameter weitergegeben, wo sie während der Sitzung referenziert werden können.
• Wird durch die Endnutzereingabe, Webhooks, Parametervoreinstellungen für die Auftragsausführung und API-Aufrufe festgelegt.
• Wird in Antworten, Parameteraufforderungen, Handlers für wiederholte Aufforderungen, Parametervoreinstellungen und Webhook-Code referenziert:
  • Das Referenzformat ist $session.params.parameter-id für Sitzungsparameter und $intent.params.parameter-id für Intent-Parameter.
  • Intent-Parameterverweise unterstützen die Suffixsyntax .original und .resolved. Diese Syntax wird von Sitzungsparametern nicht unterstützt.

Systementitäten

Dialogflow ES unterstützt viele Systementitäten.

Conversational Agents (Dialogflow CX) unterstützen viele derselben Systementitäten. Es gibt jedoch einige Unterschiede. Prüfen Sie bei der Migration, ob die Systementitäten, die Sie in Dialogflow ES verwenden, auch von Conversational Agents (Dialogflow CX) für dieselbe Sprache unterstützt werden. Andernfalls sollten Sie benutzerdefinierte Entitäten für diese erstellen.

Veranstaltungen

Dialogflow ES-Ereignisse haben folgende Merkmale:

• Kann über API-Aufrufe oder Webhooks aufgerufen werden, um einer Absicht zu entsprechen.
• Parameter festlegen.
• Von Integrationsplattformen werden nur wenige Ereignisse aufgerufen.

Ereignisse für Conversational Agents (Dialogflow CX) haben folgende Merkmale:

• Kann über API-Aufrufe oder Webhooks aufgerufen werden, um einen Ereignis-Handler aufzurufen.
• Parameter können nicht festgelegt werden.
• Viele integrierte Ereignisse können verwendet werden, um den fehlenden oder nicht erkannten Nutzereintrag, Parameter, die durch einen Webhook ungültig gemacht wurden, und Webhook-Fehler zu verarbeiten.
• Aufrufe können mit denselben Umfangsregeln wie andere Status-Handler gesteuert werden.

Integrierte Intents

Dialogflow ES unterstützt die folgenden integrierten Intents:

• Willkommensabsicht
• Fallback-Intents
• Vordefinierte Follow-up-Intents

Im Folgenden wird die Unterstützung für vordefinierte Intents in Conversational Agents (Dialogflow CX) beschrieben:

• Willkommensabsichten werden unterstützt.
• Fallback-Intents werden nicht bereitgestellt. Verwenden Sie stattdessen die Ereignisse vom Typ „Kein Übereinstimmen“ in Ereignis-Handlern.
• Verwenden Sie für Negativbeispiele den standardmäßig auszuschließenden Intent.
• Vordefinierte Follow-up-Intents sind nicht verfügbar. Sie müssen diese Intents entsprechend den Anforderungen Ihres Agents erstellen. Beispielsweise müssen Sie wahrscheinlich eine Absicht erstellen, um negative Antworten auf eine Frage eines Kundenservicemitarbeiters zu verarbeiten („Nein“, „Nein, danke“, „Nein, ich habe keine“ usw.). Intents für Conversational Agents (Dialogflow CX) können für Ihren gesamten Agenten wiederverwendet werden. Sie müssen sie also nur einmal definieren. Wenn Sie für diese häufigen Intents unterschiedliche Intent-Routen in verschiedenen Bereichen verwenden, haben Sie viel mehr Kontrolle über die Unterhaltung.

Webhooks

Dialogflow ES-Webhooks haben folgende Eigenschaften:

• Sie können einen Webhook-Dienst für den Kundenservicemitarbeiter konfigurieren.
• Jede Absicht kann als Verwendung des Webhooks gekennzeichnet werden.
• Es gibt keine integrierte Unterstützung für die Verarbeitung von Webhook-Fehlern.
• Intent-Aktionen oder Intent-Namen werden von Webhooks verwendet, um zu ermitteln, wo im Bot sie aufgerufen wurden.
• Die Console bietet den Inline-Editor.

Webhooks für Conversational Agents (Dialogflow CX) haben die folgenden Eigenschaften:

• Sie können mehrere Webhook-Dienste für den Kundenservicemitarbeiter konfigurieren.
• Für jede Auftragsausführung kann optional ein Webhook-Aufruf angegeben werden.
• Es gibt eine integrierte Unterstützung für die Webhook-Fehlerbehandlung.
• Ein Fulfillment-Webhook für Conversational Agents (Dialogflow CX) enthält ein Tag. Dieses Tag ähnelt einer Dialogflow ES-Aktion, wird aber nur zum Aufrufen von Webhooks verwendet. Der Webhook-Dienst kann anhand dieser Tags ermitteln, wo im Agenten er aufgerufen wurde.
• Die Console hat keinen integrierten Webhook-Code-Editor. Häufig werden Cloud Functions verwendet, aber es gibt viele Optionen.

Wenn Sie zu Conversational Agents (Dialogflow CX) migrieren, müssen Sie Ihren Webhook-Code ändern, da sich die Anfrage- und Antworteigenschaften unterscheiden.

Integrationen

Dialogflow ES-Integrationen und Integrationen für Konversations-Agenten (Dialogflow CX) unterstützen unterschiedliche Plattformen. Bei Plattformen, die von beiden Kundenservicemitarbeitertypen unterstützt werden, kann es zu Unterschieden bei der Konfiguration kommen.

Wenn die von Ihnen verwendete Dialogflow ES-Integration von Konversations-Agents (Dialogflow CX) nicht unterstützt wird, müssen Sie möglicherweise die Plattform wechseln oder die Integration selbst implementieren.

Weitere Funktionen nur für Conversational Agents (Dialogflow CX)

Es gibt viele weitere Funktionen, die nur von Conversational Agents (Dialogflow CX) unterstützt werden. Sie sollten diese Funktionen während der Migration verwenden. Beispiel:

• Erweiterte NLU
• Erweiterte Spracheinstellungen (Empfindlichkeit für das Ende der Spracheingabe, kein Sprachzeitlimit usw.)
• Änderungsverlauf
• Bedingte Logik
• DTMF-Eingabe für Telefonieintegrationen
• Umgebungsspezifische Webhooks
• Tests
• Route-Gruppen
• Suchdaten für Kundenservicemitarbeiter
• Sicherheitseinstellungen (Entfernen von Daten und Datenaufbewahrung)
• Systemfunktionen für erweiterte Antworten und Bedingungen
• Testfälle
• Validierung von Kundenservicemitarbeiterdaten

Best Practices

Bevor Sie migrieren, sollten Sie sich mit den Best Practices für das Design von Konversations-Agents (Dialogflow CX) vertraut machen. Viele dieser Best Practices für Conversational Agents (Dialogflow CX) ähneln den Best Practices für Dialogflow ES, einige sind jedoch nur für Conversational Agents (Dialogflow CX) geeignet.

Informationen zum Migrationstool

Das Migrationstool kopiert den Großteil der Dialogflow ES-Daten in Ihren Konversations-Agent (Dialogflow CX) und schreibt eine TODO-Datei mit einer Liste der Elemente, die manuell migriert werden müssen. Das Tool kopiert nur benutzerdefinierte Entitätstypen und Trainingsphrasen für Absichten. Sie sollten dieses Tool an Ihre spezifischen Anforderungen anpassen.

Code des Migrationstools

Hier ist der Code für das Tool. Sie sollten sich den Code für dieses Tool ansehen, damit Sie wissen, was es tut. Sie können diesen Code ändern, um bestimmte Situationen in Ihrem Kundenservicemitarbeiter zu behandeln. In den folgenden Schritten führen Sie dieses Tool aus.

// Package main implements the ES to CX migration tool.
package main

import (
	"context"
	"encoding/csv"
	"flag"
	"fmt"
	"os"
	"strings"
	"time"

	v2 "cloud.google.com/go/dialogflow/apiv2"
	proto2 "cloud.google.com/go/dialogflow/apiv2/dialogflowpb"
	v3 "cloud.google.com/go/dialogflow/cx/apiv3"
	proto3 "cloud.google.com/go/dialogflow/cx/apiv3/cxpb"
	"google.golang.org/api/iterator"
	"google.golang.org/api/option"
)

// Commandline flags
var v2Project *string = flag.String("es-project-id", "", "ES project")
var v3Project *string = flag.String("cx-project-id", "", "CX project")
var v2Region *string = flag.String("es-region-id", "", "ES region")
var v3Region *string = flag.String("cx-region-id", "", "CX region")
var v3Agent *string = flag.String("cx-agent-id", "", "CX region")
var outFile *string = flag.String("out-file", "", "Output file for CSV TODO items")
var dryRun *bool = flag.Bool("dry-run", false, "Set true to skip CX agent writes")

// Map from entity type display name to fully qualified name.
var entityTypeShortToLong = map[string]string{}

// Map from ES system entity to CX system entity
var convertSystemEntity = map[string]string{
	"sys.address":         "sys.address",
	"sys.any":             "sys.any",
	"sys.cardinal":        "sys.cardinal",
	"sys.color":           "sys.color",
	"sys.currency-name":   "sys.currency-name",
	"sys.date":            "sys.date",
	"sys.date-period":     "sys.date-period",
	"sys.date-time":       "sys.date-time",
	"sys.duration":        "sys.duration",
	"sys.email":           "sys.email",
	"sys.flight-number":   "sys.flight-number",
	"sys.geo-city-gb":     "sys.geo-city",
	"sys.geo-city-us":     "sys.geo-city",
	"sys.geo-city":        "sys.geo-city",
	"sys.geo-country":     "sys.geo-country",
	"sys.geo-state":       "sys.geo-state",
	"sys.geo-state-us":    "sys.geo-state",
	"sys.geo-state-gb":    "sys.geo-state",
	"sys.given-name":      "sys.given-name",
	"sys.language":        "sys.language",
	"sys.last-name":       "sys.last-name",
	"sys.street-address":  "sys.location",
	"sys.location":        "sys.location",
	"sys.number":          "sys.number",
	"sys.number-integer":  "sys.number-integer",
	"sys.number-sequence": "sys.number-sequence",
	"sys.ordinal":         "sys.ordinal",
	"sys.percentage":      "sys.percentage",
	"sys.person":          "sys.person",
	"sys.phone-number":    "sys.phone-number",
	"sys.temperature":     "sys.temperature",
	"sys.time":            "sys.time",
	"sys.time-period":     "sys.time-period",
	"sys.unit-currency":   "sys.unit-currency",
	"sys.url":             "sys.url",
	"sys.zip-code":        "sys.zip-code",
}

// Issues found for the CSV output
var issues = [][]string{
	{"Field", "Issue"},
}

// logIssue logs an issue for the CSV output
func logIssue(field string, issue string) {
	issues = append(issues, []string{field, issue})
}

// convertEntityType converts an ES entity type to CX
func convertEntityType(et2 *proto2.EntityType) *proto3.EntityType {
	var kind3 proto3.EntityType_Kind
	switch kind2 := et2.Kind; kind2 {
	case proto2.EntityType_KIND_MAP:
		kind3 = proto3.EntityType_KIND_MAP
	case proto2.EntityType_KIND_LIST:
		kind3 = proto3.EntityType_KIND_LIST
	case proto2.EntityType_KIND_REGEXP:
		kind3 = proto3.EntityType_KIND_REGEXP
	default:
		kind3 = proto3.EntityType_KIND_UNSPECIFIED
	}
	var expansion3 proto3.EntityType_AutoExpansionMode
	switch expansion2 := et2.AutoExpansionMode; expansion2 {
	case proto2.EntityType_AUTO_EXPANSION_MODE_DEFAULT:
		expansion3 = proto3.EntityType_AUTO_EXPANSION_MODE_DEFAULT
	default:
		expansion3 = proto3.EntityType_AUTO_EXPANSION_MODE_UNSPECIFIED
	}
	et3 := &proto3.EntityType{
		DisplayName:           et2.DisplayName,
		Kind:                  kind3,
		AutoExpansionMode:     expansion3,
		EnableFuzzyExtraction: et2.EnableFuzzyExtraction,
	}
	for _, e2 := range et2.Entities {
		et3.Entities = append(et3.Entities, &proto3.EntityType_Entity{
			Value:    e2.Value,
			Synonyms: e2.Synonyms,
		})
	}
	return et3
}

// convertParameterEntityType converts a entity type found in parameters
func convertParameterEntityType(intent string, parameter string, t2 string) string {
	if len(t2) == 0 {
		return ""
	}
	t2 = t2[1:] // remove @
	if strings.HasPrefix(t2, "sys.") {
		if val, ok := convertSystemEntity[t2]; ok {
			t2 = val
		} else {
			t2 = "sys.any"
			logIssue("Intent<"+intent+">.Parameter<"+parameter+">",
				"This intent parameter uses a system entity not supported by CX English agents. See the migration guide for advice. System entity: "+t2)
		}
		return fmt.Sprintf("projects/-/locations/-/agents/-/entityTypes/%s", t2)
	}
	return entityTypeShortToLong[t2]
}

// convertIntent converts an ES intent to CX
func convertIntent(intent2 *proto2.Intent) *proto3.Intent {
	if intent2.DisplayName == "Default Fallback Intent" ||
		intent2.DisplayName == "Default Welcome Intent" {
		return nil
	}

	intent3 := &proto3.Intent{
		DisplayName: intent2.DisplayName,
	}

	// WebhookState
	if intent2.WebhookState != proto2.Intent_WEBHOOK_STATE_UNSPECIFIED {
		logIssue("Intent<"+intent2.DisplayName+">.WebhookState",
			"This intent has webhook enabled. You must configure this in your CX agent.")
	}

	// IsFallback
	if intent2.IsFallback {
		logIssue("Intent<"+intent2.DisplayName+">.IsFallback",
			"This intent is a fallback intent. CX does not support this. Use no-match events instead.")
	}

	// MlDisabled
	if intent2.MlDisabled {
		logIssue("Intent<"+intent2.DisplayName+">.MlDisabled",
			"This intent has ML disabled. CX does not support this.")
	}

	// LiveAgentHandoff
	if intent2.LiveAgentHandoff {
		logIssue("Intent<"+intent2.DisplayName+">.LiveAgentHandoff",
			"This intent uses live agent handoff. You must configure this in a fulfillment.")
	}

	// EndInteraction
	if intent2.EndInteraction {
		logIssue("Intent<"+intent2.DisplayName+">.EndInteraction",
			"This intent uses end interaction. CX does not support this.")
	}

	// InputContextNames
	if len(intent2.InputContextNames) > 0 {
		logIssue("Intent<"+intent2.DisplayName+">.InputContextNames",
			"This intent uses context. See the migration guide for alternatives.")
	}

	// Events
	if len(intent2.Events) > 0 {
		logIssue("Intent<"+intent2.DisplayName+">.Events",
			"This intent uses events. Use event handlers instead.")
	}

	// TrainingPhrases
	var trainingPhrases3 []*proto3.Intent_TrainingPhrase
	for _, tp2 := range intent2.TrainingPhrases {
		if tp2.Type == proto2.Intent_TrainingPhrase_TEMPLATE {
			logIssue("Intent<"+intent2.DisplayName+">.TrainingPhrases",
				"This intent has a training phrase that uses a template (@...) training phrase type. CX does not support this.")
		}
		var parts3 []*proto3.Intent_TrainingPhrase_Part
		for _, part2 := range tp2.Parts {
			parts3 = append(parts3, &proto3.Intent_TrainingPhrase_Part{
				Text:        part2.Text,
				ParameterId: part2.Alias,
			})
		}
		trainingPhrases3 = append(trainingPhrases3, &proto3.Intent_TrainingPhrase{
			Parts:       parts3,
			RepeatCount: 1,
		})
	}
	intent3.TrainingPhrases = trainingPhrases3

	// Action
	if len(intent2.Action) > 0 {
		logIssue("Intent<"+intent2.DisplayName+">.Action",
			"This intent sets the action field. Use a fulfillment webhook tag instead.")
	}

	// OutputContexts
	if len(intent2.OutputContexts) > 0 {
		logIssue("Intent<"+intent2.DisplayName+">.OutputContexts",
			"This intent uses context. See the migration guide for alternatives.")
	}

	// ResetContexts
	if intent2.ResetContexts {
		logIssue("Intent<"+intent2.DisplayName+">.ResetContexts",
			"This intent uses context. See the migration guide for alternatives.")
	}

	// Parameters
	var parameters3 []*proto3.Intent_Parameter
	for _, p2 := range intent2.Parameters {
		if len(p2.Value) > 0 && p2.Value != "$"+p2.DisplayName {
			logIssue("Intent<"+intent2.DisplayName+">.Parameters<"+p2.DisplayName+">.Value",
				"This field is not set to $parameter-name. This feature is not supported by CX. See: https://cloud.google.com/dialogflow/es/docs/intents-actions-parameters#valfield.")
		}
		if len(p2.DefaultValue) > 0 {
			logIssue("Intent<"+intent2.DisplayName+">.Parameters<"+p2.DisplayName+">.DefaultValue",
				"This intent parameter is using a default value. CX intent parameters do not support default values, but CX page form parameters do. This parameter should probably become a form parameter.")
		}
		if p2.Mandatory {
			logIssue("Intent<"+intent2.DisplayName+">.Parameters<"+p2.DisplayName+">.Mandatory",
				"This intent parameter is marked as mandatory. CX intent parameters do not support mandatory parameters, but CX page form parameters do. This parameter should probably become a form parameter.")
		}
		for _, prompt := range p2.Prompts {
			logIssue("Intent<"+intent2.DisplayName+">.Parameters<"+p2.DisplayName+">.Prompts",
				"This intent parameter has a prompt. Use page form parameter prompts instead. Prompt: "+prompt)
		}
		if len(p2.EntityTypeDisplayName) == 0 {
			p2.EntityTypeDisplayName = "@sys.any"
			logIssue("Intent<"+intent2.DisplayName+">.Parameters<"+p2.DisplayName+">.EntityTypeDisplayName",
				"This intent parameter does not have an entity type. CX requires an entity type for all parameters..")
		}
		parameters3 = append(parameters3, &proto3.Intent_Parameter{
			Id:         p2.DisplayName,
			EntityType: convertParameterEntityType(intent2.DisplayName, p2.DisplayName, p2.EntityTypeDisplayName),
			IsList:     p2.IsList,
		})
		//fmt.Printf("Converted parameter: %+v\n", parameters3[len(parameters3)-1])
	}
	intent3.Parameters = parameters3

	// Messages
	for _, message := range intent2.Messages {
		m, ok := message.Message.(*proto2.Intent_Message_Text_)
		if ok {
			for _, t := range m.Text.Text {
				warnings := ""
				if strings.Contains(t, "#") {
					warnings += " This message may contain a context parameter reference, but CX does not support this."
				}
				if strings.Contains(t, ".original") {
					warnings += " This message may contain a parameter reference suffix of '.original', But CX only supports this for intent parameters (not session parameters)."
				}
				if strings.Contains(t, ".recent") {
					warnings += " This message may contain a parameter reference suffix of '.recent', but CX does not support this."
				}
				if strings.Contains(t, ".partial") {
					warnings += " This message may contain a parameter reference suffix of '.partial', but CX does not support this."
				}
				logIssue("Intent<"+intent2.DisplayName+">.Messages",
					"This intent has a response message. Use fulfillment instead."+warnings+" Message: "+t)
			}
		} else {
			logIssue("Intent<"+intent2.DisplayName+">.Messages",
				"This intent has a non-text response message. See the rich response message information in the migration guide.")
		}
		if message.Platform != proto2.Intent_Message_PLATFORM_UNSPECIFIED {
			logIssue("Intent<"+intent2.DisplayName+">.Platform",
				"This intent has a message with a non-default platform. See the migration guide for advice.")
		}
	}

	return intent3
}

// migrateEntities migrates ES entities to your CX agent
func migrateEntities(ctx context.Context) error {
	var err error

	// Create ES client
	var client2 *v2.EntityTypesClient
	options2 := []option.ClientOption{}
	if len(*v2Region) > 0 {
		options2 = append(options2,
			option.WithEndpoint(*v2Region+"-dialogflow.googleapis.com:443"))
	}
	client2, err = v2.NewEntityTypesClient(ctx, options2...)
	if err != nil {
		return err
	}
	defer client2.Close()
	var parent2 string
	if len(*v2Region) == 0 {
		parent2 = fmt.Sprintf("projects/%s/agent", *v2Project)
	} else {
		parent2 = fmt.Sprintf("projects/%s/locations/%s/agent", *v2Project, *v2Region)
	}

	// Create CX client
	var client3 *v3.EntityTypesClient
	options3 := []option.ClientOption{}
	if len(*v3Region) > 0 {
		options3 = append(options3,
			option.WithEndpoint(*v3Region+"-dialogflow.googleapis.com:443"))
	}
	client3, err = v3.NewEntityTypesClient(ctx, options3...)
	if err != nil {
		return err
	}
	defer client3.Close()
	parent3 := fmt.Sprintf("projects/%s/locations/%s/agents/%s", *v3Project, *v3Region, *v3Agent)

	// Read each V2 entity type, convert, and write to V3
	request2 := &proto2.ListEntityTypesRequest{
		Parent: parent2,
	}
	it2 := client2.ListEntityTypes(ctx, request2)
	for {
		var et2 *proto2.EntityType
		et2, err = it2.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Printf("Entity Type: %s\n", et2.DisplayName)

		if *dryRun {
			convertEntityType(et2)
			continue
		}

		request3 := &proto3.CreateEntityTypeRequest{
			Parent:     parent3,
			EntityType: convertEntityType(et2),
		}
		et3, err := client3.CreateEntityType(ctx, request3)
		entityTypeShortToLong[et3.DisplayName] = et3.Name
		if err != nil {
			return err
		}

		// ES and CX each have a quota limit of 60 design-time requests per minute
		time.Sleep(2 * time.Second)
	}
	return nil
}

// migrateIntents migrates intents to your CX agent
func migrateIntents(ctx context.Context) error {
	var err error

	// Create ES client
	var client2 *v2.IntentsClient
	options2 := []option.ClientOption{}
	if len(*v2Region) > 0 {
		options2 = append(options2,
			option.WithEndpoint(*v2Region+"-dialogflow.googleapis.com:443"))
	}
	client2, err = v2.NewIntentsClient(ctx, options2...)
	if err != nil {
		return err
	}
	defer client2.Close()
	var parent2 string
	if len(*v2Region) == 0 {
		parent2 = fmt.Sprintf("projects/%s/agent", *v2Project)
	} else {
		parent2 = fmt.Sprintf("projects/%s/locations/%s/agent", *v2Project, *v2Region)
	}

	// Create CX client
	var client3 *v3.IntentsClient
	options3 := []option.ClientOption{}
	if len(*v3Region) > 0 {
		options3 = append(options3,
			option.WithEndpoint(*v3Region+"-dialogflow.googleapis.com:443"))
	}
	client3, err = v3.NewIntentsClient(ctx, options3...)
	if err != nil {
		return err
	}
	defer client3.Close()
	parent3 := fmt.Sprintf("projects/%s/locations/%s/agents/%s", *v3Project, *v3Region, *v3Agent)

	// Read each V2 entity type, convert, and write to V3
	request2 := &proto2.ListIntentsRequest{
		Parent:     parent2,
		IntentView: proto2.IntentView_INTENT_VIEW_FULL,
	}
	it2 := client2.ListIntents(ctx, request2)
	for {
		var intent2 *proto2.Intent
		intent2, err = it2.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Printf("Intent: %s\n", intent2.DisplayName)
		intent3 := convertIntent(intent2)
		if intent3 == nil {
			continue
		}

		if *dryRun {
			continue
		}

		request3 := &proto3.CreateIntentRequest{
			Parent: parent3,
			Intent: intent3,
		}
		_, err := client3.CreateIntent(ctx, request3)
		if err != nil {
			return err
		}

		// ES and CX each have a quota limit of 60 design-time requests per minute
		time.Sleep(2 * time.Second)
	}
	return nil
}

// checkFlags checks commandline flags
func checkFlags() error {
	flag.Parse()
	if len(*v2Project) == 0 {
		return fmt.Errorf("Need to supply es-project-id flag")
	}
	if len(*v3Project) == 0 {
		return fmt.Errorf("Need to supply cx-project-id flag")
	}
	if len(*v2Region) == 0 {
		fmt.Printf("No region supplied for ES, using default\n")
	}
	if len(*v3Region) == 0 {
		return fmt.Errorf("Need to supply cx-region-id flag")
	}
	if len(*v3Agent) == 0 {
		return fmt.Errorf("Need to supply cx-agent-id flag")
	}
	if len(*outFile) == 0 {
		return fmt.Errorf("Need to supply out-file flag")
	}
	return nil
}

// closeFile is used as a convenience for defer
func closeFile(f *os.File) {
	err := f.Close()
	if err != nil {
		fmt.Fprintf(os.Stderr, "ERROR closing CSV file: %v\n", err)
		os.Exit(1)
	}
}

func main() {
	if err := checkFlags(); err != nil {
		fmt.Fprintf(os.Stderr, "ERROR checking flags: %v\n", err)
		os.Exit(1)
	}
	ctx := context.Background()
	if err := migrateEntities(ctx); err != nil {
		fmt.Fprintf(os.Stderr, "ERROR migrating entities: %v\n", err)
		os.Exit(1)
	}
	if err := migrateIntents(ctx); err != nil {
		fmt.Fprintf(os.Stderr, "ERROR migrating intents: %v\n", err)
		os.Exit(1)
	}
	csvFile, err := os.Create(*outFile)
	if err != nil {
		fmt.Fprintf(os.Stderr, "ERROR opening output file: %v", err)
		os.Exit(1)
	}
	defer closeFile(csvFile)
	csvWriter := csv.NewWriter(csvFile)
	if err := csvWriter.WriteAll(issues); err != nil {
		fmt.Fprintf(os.Stderr, "ERROR writing CSV output file: %v", err)
		os.Exit(1)
	}
	csvWriter.Flush()
}

Tool zur Migration von Entitätstypen

Dialogflow ES-Entitätstypen und Entitätstypen für Konversations-Agenten (Dialogflow CX) sind sehr ähnlich. Daher ist dies der Datentyp, der sich am einfachsten migrieren lässt. Das Tool kopiert Entitätstypen einfach unverändert.

Toolmigration von Intents

Dialogflow ES-Intents und Intents für Conversational Agents (Dialogflow CX) unterscheiden sich stark.

Dialogflow ES-Intents sind die Bausteine des Agents. Sie enthalten Trainingsphrasen, Antworten, Kontext für die Unterhaltungssteuerung, Webhook-Konfigurationen, Ereignisse, Aktionen und Parameter für die Slot-Füllung.

Die meisten dieser Daten wurden in Conversational Agents (Dialogflow CX) in andere Ressourcen verschoben. Intents für Conversational Agents (Dialogflow CX) enthalten nur Trainingsphrasen und Parameter. Dadurch können sie für den gesamten Agenten wiederverwendet werden. Das Tool kopiert nur diese beiden Arten von Intent-Daten in die Intents Ihrer Conversational Agents (Dialogflow CX).

Einschränkungen des Migrationstools

Das Migrationstool unterstützt Folgendes nicht:

• Mega-Agents: Das Tool kann nicht aus mehreren Sub-Agents lesen, aber Sie können das Tool für jeden Sub-Agent mehrmals aufrufen.
• Mehrsprachige Bots: Sie sollten das Tool so ändern, dass Sie mehrsprachige Trainingsformulierungen und Entitätseinträge erstellen können.
• Überprüfung von Systementitäten für andere Sprachen als Englisch: Das Tool erstellt TODO-Elemente, wenn es Systementitäten findet, die nicht von Conversational Agents (Dialogflow CX) unterstützt werden. Dabei wird davon ausgegangen, dass Englisch die Standardsprache ist und dass die Region USA verwendet wird. Die Unterstützung von Systementitäten variiert je nach Sprache und Region. Für andere Sprachen und Regionen müssen Sie das Tool entsprechend anpassen.

Wichtige Migrationsschritte

In den folgenden Abschnitten werden die Migrationsschritte beschrieben. Sie müssen diese manuellen Schritte nicht in der angegebenen Reihenfolge ausführen. Es kann sogar sein, dass Sie diese Schritte gleichzeitig oder in einer anderen Reihenfolge ausführen müssen. Lesen Sie sich die Schritte durch und beginnen Sie mit der Planung Ihrer Änderungen, bevor Sie sie tatsächlich vornehmen.

Nachdem Sie das Migrationstool ausgeführt haben, können Sie Ihren Conversational Agents-Agent (Dialogflow CX) neu erstellen. Sie haben noch einiges an Migrationsarbeit vor sich, aber der Großteil der manuell eingegebenen Daten befindet sich jetzt in Ihrem Conversational Agents (Dialogflow CX)-Agenten und in der TODO-Datei.

Conversational Agents (Dialogflow CX)-Agent erstellen

Erstellen Sie Ihren Konversations-Agenten (Dialogflow CX), falls noch nicht geschehen. Verwenden Sie dieselbe Standardsprache wie für Ihren Dialogflow ES-Agenten.

Migrationstool ausführen

So führen Sie das Tool aus:

1. Installieren Sie Go auf Ihrem Computer, falls Sie es noch nicht getan haben.
2. Erstellen Sie ein Verzeichnis für den Tool-Code mit dem Namen migrate.
3. Kopieren Sie den Code des Tools oben in eine Datei in diesem Verzeichnis mit dem Namen main.go.
4. Passen Sie den Code bei Bedarf an.

5. Erstellen Sie in diesem Verzeichnis ein Go-Modul. Beispiel:

   go mod init migrate
   

6. Installieren Sie die Go-Clientbibliotheken für Dialogflow ES V2 und Conversational Agents (Dialogflow CX) V3:

   go get cloud.google.com/go/dialogflow/apiv2
   go get cloud.google.com/go/dialogflow/cx/apiv3
   

7. Sie müssen die Authentifizierung der Clientbibliothek eingerichtet haben.

8. Führen Sie das Tool aus und speichern Sie die Ausgabe in einer Datei:

   go run main.go -es-project-id=<ES_PROJECT_ID> -cx-project-id=<CX_PROJECT_ID> \
   -cx-region-id=<CX_REGION_ID> -cx-agent-id=<CX_AGENT_ID> -out-file=out.csv
   

Fehlerbehebung beim Migrationstool

Wenn beim Ausführen des Tools Fehler auftreten, prüfen Sie Folgendes:

Nachdem Sie die Fehler behoben haben, müssen Sie den Conversational Agents-Agenten (Dialogflow CX) von Intents und Entitäten befreien, bevor Sie das Migrationstool noch einmal ausführen.

Dialogflow ES-Intent-Daten in Conversational Agents (Dialogflow CX) verschieben

Mit dem Tool werden Intent-Trainingsphrasen und -Parameter zu Intents von Conversational Agents (Dialogflow CX) migriert. Es gibt jedoch viele andere Dialogflow ES-Intent-Felder, die manuell migriert werden müssen.

Für einen Dialogflow ES-Intent kann eine entsprechende Seite für Conversational Agents (Dialogflow CX), ein entsprechender Intent für Conversational Agents (Dialogflow CX) oder beides erforderlich sein.

Wenn eine Dialogflow ES-Intent-Übereinstimmung verwendet wird, um die Unterhaltung von einem bestimmten Unterhaltungsknoten zu einem anderen zu wechseln, sollten Sie in Ihrem Agent zwei Seiten mit Bezug zu diesem Intent haben:

• Die ursprüngliche Seite mit der Intent-Route, über die zur nächsten Seite gewechselt wird: Die Intent-Route auf der ursprünglichen Seite kann Fulfillment-Nachrichten für Conversational Agents (Dialogflow CX) enthalten, die den Intent-Antworten von Dialogflow ES ähneln. Auf dieser Seite können viele Intent-Routen vorhanden sein. Solange die ursprüngliche Seite aktiv ist, können diese Intent-Routen den Dialog auf viele mögliche Pfade umleiten. Viele Dialogflow ES-Intents haben dieselbe ursprüngliche Seite für Conversational Agents (Dialogflow CX).
• Die nächste Seite, also das Übergangsziel für die Intent-Route auf der ursprünglichen Seite: Die Antwort für die Conversational Agents (Dialogflow CX)-Eingabe auf der nächsten Seite kann ähnliche Antwortnachrichten wie die Dialogflow ES-Intent-Antworten enthalten.

Wenn ein Dialogflow ES-Intent erforderliche Parameter enthält, sollten Sie eine entsprechende Seite für Konversations-Agents (Dialogflow CX) mit denselben Parametern in einem Formular erstellen.

Es ist üblich, dass ein Konversations-Intent (Dialogflow CX) und eine Konversations-Seite (Dialogflow CX) dieselbe Parameterliste haben. Das bedeutet, dass ein einzelner Dialogflow ES-Intent eine entsprechende Konversations-Seite (Dialogflow CX) und einen entsprechenden Konversations-Intent (Dialogflow CX) hat. Wenn ein Intent von Conversational Agents (Dialogflow CX) mit Parametern in einer Intent-Route abgeglichen wird, wird die Unterhaltung häufig zu einer Seite mit denselben Parametern weitergeleitet. Die aus dem Intent-Abgleich extrahierten Parameter werden an Sitzungsparameter weitergegeben, die zum teilweisen oder vollständigen Ausfüllen von Formularparametern auf der Seite verfügbar sind.

Fallback-Intents und vordefinierte Folge-Intents gibt es in Conversational Agents (Dialogflow CX) nicht. Weitere Informationen finden Sie unter Vordefinierte Intents.

In der folgenden Tabelle wird beschrieben, wie Sie bestimmte Intent-Daten aus Dialogflow ES auf Ressourcen für Conversational Agents (Dialogflow CX) abbilden:

Workflows erstellen

Erstellen Sie einen Ablauf für jedes allgemeine Gesprächsthema. Die Themen in den einzelnen Abläufen sollten klar voneinander abgegrenzt sein, damit die Unterhaltung nicht häufig zwischen den Abläufen hin- und herspringt.

Wenn Sie einen Mega-Agenten verwendet haben, sollte jeder Sub-Agent in einen oder mehrere Flows umgewandelt werden.

Mit einfachen Konversationspfaden beginnen

Am besten testen Sie Ihren Agenten mit dem Simulator, während Sie Änderungen vornehmen. Konzentrieren Sie sich daher zu Beginn der Unterhaltung auf die grundlegenden Konversationspfade und testen Sie, während Sie Änderungen vornehmen. Sobald diese funktionieren, können Sie zu detaillierteren Konversationsabfolgen übergehen.

Zustands-Handler auf Ablaufebene und auf Seitenebene

Überlegen Sie beim Erstellen von Status-Handlern, ob sie auf Fluss- oder Seitenebene angewendet werden sollen. Ein Handler auf Ablaufebene ist immer dann im Geltungsbereich, wenn der Ablauf (und damit jede Seite innerhalb des Ablaufs) aktiv ist. Ein Handler auf Seitenebene ist nur dann gültig, wenn die entsprechende Seite aktiv ist. Handler auf Ablaufebene ähneln Dialogflow ES-Intents ohne Eingabekontext. Handler auf Seitenebene ähneln Dialogflow ES-Intents mit Eingabekontext.

Webhook-Code

Die Webhook-Anfrage- und ‑Antworteigenschaften unterscheiden sich für Conversational Agents (Dialogflow CX). Weitere Informationen finden Sie im Abschnitt Webhooks.

Wissensconnectors

Conversational Agents (Dialogflow CX) unterstützen noch keine Knowledge Connectors. Sie müssen diese als normale Intents implementieren oder warten, bis Conversational Agents (Dialogflow CX) Knowledge Connectors unterstützt.

Agent-Einstellungen

Prüfen Sie die Einstellungen für Dialogflow ES-Kundenservicemitarbeiter und passen Sie die Einstellungen für Konversations-Agenten (Dialogflow CX) nach Bedarf an.

TODO-Datei verwenden

Das Migrationstool gibt eine CSV-Datei aus. Die Elemente in dieser Liste beziehen sich auf bestimmte Daten, die möglicherweise Aufmerksamkeit erfordern. Importieren Sie diese Datei in eine Tabelle. Bearbeiten Sie jeden Artikel in der Tabelle und verwenden Sie eine Spalte, um den Abschluss zu kennzeichnen.

Migration der API-Nutzung

Wenn in Ihrem System die Dialogflow ES API für Laufzeit- oder Designzeitaufrufe verwendet wird, müssen Sie diesen Code aktualisieren, damit die Conversational Agents (Dialogflow CX) API verwendet wird. Wenn Sie die Intent-Erkennung nur zur Laufzeit verwenden, sollte diese Aktualisierung relativ einfach sein.

Integrationen

Wenn Ihr Kundenservicemitarbeiter Integrationen verwendet, lesen Sie den Abschnitt zu Integrationen und nehmen Sie gegebenenfalls Änderungen vor.

Empfohlene Schritte für die Migration

In den folgenden Abschnitten werden die empfohlenen Migrationsschritte beschrieben.

Validierung

Mit der Agentenüberprüfung können Sie prüfen, ob Ihr Agent den Best Practices entspricht.

Test

Während Sie die oben genannten Schritte zur manuellen Migration ausführen, sollten Sie Ihren Agenten mit dem Simulator testen. Sobald Ihr Agent funktioniert, sollten Sie Unterhaltungen zwischen Ihren Dialogflow ES- und Conversational Agents (Dialogflow CX) vergleichen und prüfen, ob das Verhalten ähnlich oder verbessert ist.

Während Sie diese Unterhaltungen mit dem Simulator testen, sollten Sie Testfälle erstellen, um zukünftige Rückschritte zu vermeiden.

Umgebungen

Prüfen Sie Ihre Dialogflow ES-Umgebungen und aktualisieren Sie nach Bedarf Ihre Conversational Agents-Umgebungen (Dialogflow CX).