Von Dialogflow ES zu Konversations-Agents (Dialogflow CX) migrieren

Agents für Conversational Agents (Dialogflow CX) bieten Ihnen bessere Steuerung und Tools für Unterhaltungen als Dialogflow ES-Agents. Wenn Ihr Dialogflow ES-Agent komplexe Unterhaltungen abwickelt, sollten Sie zu Conversational Agents (Dialogflow CX) migrieren.

In diesem Leitfaden wird beschrieben, wie Sie einen Agent migrieren von Dialogflow Dialogflow ES bis zu Conversational Agents (Dialogflow CX). Diese beiden Agent-Typen haben viele grundlegende Unterschiede. Daher gibt es keine einfache Möglichkeit, diese Migration durchzuführen.

Wenn Sie diese Anleitung für eine Migration verwenden, Bitte geben Sie positives oder negatives Feedback, indem Sie auf Feedback geben. Wir nutzen dieses Feedback, um diese Anleitung mit 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 Konversations-Kundenservicemitarbeiter (Dialogflow CX) schreibt und eine To-do-Liste erfasst. Anschließend erstellen Sie Ihren vollständigen Conversational Agents (Dialogflow CX)-Agent gemäß den Best Practices neu. die ToDo-Liste, und die Daten, die vom Tool migriert wurden.

Konversations-Agents (Dialogflow CX)

Bevor Sie mit der Migration beginnen, sollten Sie sich mit der Funktionsweise von Conversational Agents (Dialogflow CX) vertraut gemacht haben. So gehts:

  1. Grundlagen
  2. Einführungsvideos
  3. Kurzanleitung

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:

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, finden Sie in diesem Abschnitt weitere Informationen.

Struktur und Unterhaltungsverlauf steuern

Dialogflow ES bietet Folgendes für die Steuerung von Struktur- und Unterhaltungspfaden:

  • Intents werden als Bausteine des Agents verwendet. An jedem Punkt der Unterhaltung wird ein Intent abgeglichen. In gewisser Weise ist jeder Intent ein Knoten für die Unterhaltung.
  • Kontext wird zur Steuerung der Unterhaltung verwendet. 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 von Kontrolle bei langen Unterhaltungen ungenau sein.

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

  • Seiten sind Graph-Knoten für die Unterhaltung. Unterhaltungen mit Conversational Agents (Dialogflow CX) ähneln Statusmaschinen. Zu jedem Zeitpunkt im Gespräch eine Seite aktiv ist. Basierend auf den Eingaben oder Ereignissen des Endnutzers wird die Konversation möglicherweise zu einer anderen Seite übergehen. Es ist üblich, dass eine Seite für mehrere Gesprächsrunden aktiv bleibt.
  • Abläufe sind Gruppen verwandter 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 verknüpfte Seite oder der verknüpfte Ablauf aktiv ist, ist der Handler betroffen und kann aufgerufen werden. Eine darin enthaltene Intent-Route für Conversational Agents (Dialogflow CX) ähnelt der einen 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

Dialogflow ES nutzt Slot-Füllung um erforderliche Parameter vom Endnutzer zu erfassen:

  • Diese Parameter sind als erforderlich gekennzeichnete Intent-Parameter.
  • Der Intent wird so lange abgeglichen, bis alle erforderlichen Parameter erfasst sind.
  • Sie können einen Prompt definieren, in dem der Endnutzer aufgefordert wird, einen Wert anzugeben.

Konversations-Agents (Dialogflow CX) verwenden Ausfüllen von Formularen um erforderliche 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 wechseln in der Regel zu einer anderen Seite.
  • Sie können einen Prompt sowie Handler für erneute Eingabeaufforderungen um mehrere Versuche zur Erfassung eines Werts 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 die Anforderungen erfüllt und ein Übergangsziel angibt. Mit diesen Übergängen 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 wiederholte Eingabeaufforderung können einen Übergang verursachen, wenn der Endnutzer fehlschlägt um nach mehreren Versuchen einen Wert bereitzustellen.
  • Sie können symbolische Umstellungsziele für Umstellungsziele verwenden.

Agent-Antworten

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 des Conversational Agents (Dialogflow CX) werden an den Endnutzer gesendet, wenn Auftragsausführung aufgerufen wird. Im Gegensatz zur Dialogflow ES-Auftragsausführung, bei der immer ein Webhook verwendet wird, Die Ausführung von Conversational Agents (Dialogflow CX) kann das Aufrufen eines Webhooks, 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 Diese Funktion kann in einigen Fällen das Design Ihres Agents vereinfachen.
  • Konversations-KI-Agents (Dialogflow CX) unterstützen keine integrierten plattformspezifischen Antworten. Sie 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 Endnutzereingaben, Ereignisse, Webhooks und API-Aufrufe festgelegt.
  • Wird in Antworten, Parameteraufforderungen, Webhook-Code und Parameterwerten referenziert:
    • Das grundlegende Referenzformat ist $parameter-name.
    • Referenzen unterstützen die Suffixsyntax .original, .partial und .recent.
    • Verweise können den aktiven Kontext angeben: #context-name.parameter-name.
    • Referenzen können Ereignisparameter angeben: #event-name.parameter-name.

Parameter für Konversations-Agenten (Dialogflow CX) haben folgende Eigenschaften:

  • Wird 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.
  • auf die in Antworten, Parameteraufforderungen, Handlern für erneute Eingabeaufforderung verwiesen wird, Parametervoreinstellungen und Webhook-Code:
    • 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.

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

Veranstaltungen

Dialogflow ES-Ereignisse folgende Merkmale haben:

  • 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 Konversations-Agents (Dialogflow CX) haben folgende Merkmale:

  • Kann über API-Aufrufe oder Webhooks aufgerufen werden, um einen Event-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 vom gleichen Bereichsregeln wie andere State-Handler.

Integrierte Intents

Dialogflow ES unterstützt die folgenden integrierten Intents:

Im Folgenden wird die Unterstützung von integrierten Intents durch Konversations-Agenten (Dialogflow CX) beschrieben:

  • Willkommens-Intents unterstützt werden.
  • Fallback-Intents werden nicht bereitgestellt. Verwenden Sie stattdessen die Ereignisse vom Typ „Kein Übereinstimmen“ in Ereignis-Handlern.
  • Negative Beispiele: verwenden Sie die standardmäßige auszuschließende Absicht.
  • Vordefinierte Follow-up-Intents sind nicht angegeben. Sie müssen diese Intents gemäß den Anforderungen Ihres Agents erstellen. Beispiel: müssen Sie wahrscheinlich einen Intent erstellen, mit negativen Antworten auf Fragen von Kundenservicemitarbeitern umgehen („nein“, „nein danke“, „nein, nicht.“ usw.). Intents für Konversations-Agents (Dialogflow CX) können für Ihren gesamten Agenten wiederverwendet werden. Sie müssen sie also nur einmal definieren. Wenn Sie verschiedene Intent-Routen für diese allgemeinen Intents verwenden, in unterschiedlichen Bereichen haben Sie eine viel bessere Kontrolle über das Gespräch.

Webhooks

Dialogflow ES-Webhooks haben folgende Eigenschaften:

  • Sie können einen Webhook-Dienst für den Kundenservicemitarbeiter konfigurieren.
  • Für jeden Intent kann angegeben werden, dass er den Webhook verwendet.
  • 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 Konversations-Agents (Dialogflow CX) haben die folgenden Eigenschaften:

  • Sie können mehrere Webhook-Dienste für den Agent 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 Konversations-Agenten (Dialogflow CX) enthält ein Tag. Dieses Tag ähnelt einer Dialogflow ES-Aktion, wird aber nur beim Aufrufen von Webhooks verwendet. Der Webhook-Dienst kann anhand dieser Tags ermitteln, wo im Agenten er aufgerufen wurde.
  • Die Console bietet keinen integrierten Webhook-Code-Editor. Es ist üblich, Cloud Functions aber es gibt viele Möglichkeiten.

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 Conversational Agents (Dialogflow CX) unterstützen unterschiedliche Plattformen. Bei Plattformen, die von beiden Agent-Typen unterstützt werden, kann es Abweichungen bei der Konfiguration geben.

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 Konversations-Agenten (Dialogflow CX)

Es gibt viele weitere Funktionen, die nur von Konversations-Agents (Dialogflow CX) unterstützt werden. Sie sollten diese Funktionen bei der Migration in Betracht ziehen. Beispiel:

Best Practices

Vor der Migration: vertraut machen, Best Practices für die Gestaltung von Agents für Konversations-Agents (Dialogflow CX). Viele dieser Best Practices für Konversations-KI-Agents (Dialogflow CX) ähneln den Best Practices für Dialogflow ES. Einige sind jedoch nur für Konversations-KI-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 Agent zu bewältigen. 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()
}

Toolmigration von Entitätstypen

Dialogflow ES-Entitätstypen und Entitätstypen für Konversations-Agents (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 Konversations-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.

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

Einschränkungen für das Migrationstool

Folgendes wird vom Migrationstool nicht unterstützt:

  • 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.
  • Systementitätsüberprüfung 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, mit der Annahme, dass Englisch die Standardsprache ist, und dass sie eine US-Region verwendet. Die Unterstützung von Systementitäten variiert je nach Sprache und Region. Für andere Sprachen und Regionen sollten Sie das Tool anpassen, um diese Prüfung durchzuführen.

Wichtige Migrationsschritte

In den folgenden Unterabschnitten werden die erforderlichen Migrationsschritte beschrieben. Sie müssen diese manuellen Schritte nicht in der richtigen Reihenfolge ausführen, Möglicherweise müssen Sie diese Schritte gleichzeitig oder in einer anderen Reihenfolge ausführen. 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 Konversations-Agent (Dialogflow CX) neu erstellen. Es liegt noch viel Arbeit vor der Migration, Der Großteil der manuell eingegebenen Daten ist jedoch in Ihrem Conversational Agents (Dialogflow CX)-Agent vorhanden. und die TODO-Datei.

Conversational Agents (Dialogflow CX)-Agent erstellen

Falls noch nicht geschehen, den Conversational Agents (Dialogflow CX)-Agent erstellen. Achten Sie darauf, dieselbe Standardsprache wie bei Ihrem Dialogflow ES-Agent zu verwenden.

Migrationstool ausführen

Führen Sie die folgenden Schritte aus, um das Tool auszuführen:

  1. Falls noch nicht geschehen, Installieren Sie Go auf Ihrem Computer.
  2. Erstellen Sie ein Verzeichnis für den Tool-Code mit dem Namen migrate.
  3. Kopieren Sie den Toolcode oben. in eine Datei in diesem Verzeichnis namens main.go.
  4. Ändere den Code bei Bedarf für deine Anfrage.

  5. Erstellen: Go-Modul in diesem Verzeichnis. 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:

Fehler Lösung
RPC-Fehler, dass ein Teil einer Trainingsformulierung einen Parameter erwähnt, der nicht für den Intent definiert ist. Dies kann passieren, wenn Sie zuvor mit der Dialogflow ES API Intent-Parameter auf eine Weise erstellt haben, die nicht mit den Trainingsformulierungen übereinstimmt. Um dieses Problem zu beheben, benennen Sie den Dialogflow ES-Parameter über die Console um. Prüfen Sie dann, ob Ihre Trainingsformulierungen den Parameter richtig verwenden, und klicken Sie dann auf „Speichern“. Dieser Fehler kann auch auftreten, wenn Ihre Trainingsformulierungen auf nicht vorhandene Parameter verweisen.

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

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

Das Tool migriert Intent-Trainingsphrasen und -Parameter zu Intents für Conversational Agents (Dialogflow CX). 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 Konversations-KI-Agents (Dialogflow CX), ein entsprechender Intent für Konversations-KI-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 Originalseite, die die Intent-Route enthält wodurch zur nächsten Seite gewechselt wird: Die Intent-Route auf der Originalseite Möglicherweise erhalten Sie Nachrichten zur Auftragsausführung von Conversational Agents (Dialogflow CX), die dem Dialogflow ES-Intent ähneln. Antworten. 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 konversationelle Agents (Dialogflow CX).
  • Auf der nächsten Seite Das ist das Übergangsziel für die Intent-Route auf der Originalseite: Auftragsausführung der Conversational Agents (Dialogflow CX) für die nächste Seite Möglicherweise erhalten Sie Nachrichten zur Auftragsausführung von Conversational Agents (Dialogflow CX), die dem Dialogflow ES-Intent ähneln. Antworten.

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

Es ist üblich, dass ein Konversations-Intent (Dialogflow CX) und eine Konversationsseite (Dialogflow CX) dieselbe Parameterliste haben. Das bedeutet, dass ein einzelner Dialogflow ES-Intent eine entsprechende Konversationsseite (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: an Sitzungsparameter weitergegeben werden, die Seitenformularparameter teilweise oder vollständig ausfüllen können.

Fallback-Intents und vordefinierte Follow-up-Intents sind in Conversational Agents (Dialogflow CX) nicht vorhanden. Weitere Informationen finden Sie unter Vordefinierte Intents.

In der folgenden Tabelle wird beschrieben, wie bestimmte Intent-Daten zugeordnet werden. von Dialogflow ES zu Ressourcen von Conversational Agents (Dialogflow CX):

Dialogflow ES-Intent-Daten Entsprechende Daten zu Konversations-Agenten (Dialogflow CX) Maßnahme erforderlich
Trainingssätze Intent-Trainingsformulierungen Vom Tool migriert. Das Tool prüft, ob Systementitäten unterstützt werden, und erstellt TODO-Elemente für nicht unterstützte Systementitäten.
Antworten des Kundenservicemitarbeiters Antwortnachrichten zur Auftragsausführung Weitere Informationen finden Sie unter Agentantworten.
Kontext für die Unterhaltungssteuerung Keine Weitere Informationen finden Sie unter Struktur und Unterhaltungspfad steuern.
Webhook-Einstellung Konfiguration des Webhooks für die Auftragsausführung Weitere Informationen finden Sie unter Webhooks.
Veranstaltungen Event-Handler auf Ablauf- oder Seitenebene Siehe Ereignisse.
Aktionen Webhook-Tags für die Auftragsausführung Weitere Informationen finden Sie unter Webhooks.
Parameter Intent-Parameter und/oder Seitenformularparameter Migriert zu Intent-Parametern nach Tool. Wenn die Parameter erforderlich sind, erstellt das Tool TODO-Elemente, die möglicherweise auf eine Seite migriert werden. Siehe Parameter.
Parametervorschläge Aufforderungen für Seitenformularparameter Weitere Informationen finden Sie unter Ausfüllen von Formularen.

Workflows erstellen

Erstellen Sie für jedes übergeordnete Unterhaltungsthema einen Ablauf. 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.

Bei einem Mega-Agent sollte jeder Sub-Agent zu einem oder mehreren Flows werden.

Mit einfachen Konversationsabfolgen 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, gehen wir zu detaillierteren Gesprächspfaden über.

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 Eigenschaften von Webhook-Anfragen und -Antworten unterscheiden sich bei Konversations-Agents (Dialogflow CX). Weitere Informationen finden Sie im Abschnitt Webhooks.

Wissensconnectors

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

Agent-Einstellungen

Überprüfen Sie Ihr Einstellungen für Dialogflow ES-Agenten und passen Sie die Einstellungen für Conversational Agents (Dialogflow CX) nach Bedarf anpassen.

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 Tabellenkalkulation. Bearbeiten Sie jeden Artikel in der Tabelle und verwenden Sie eine Spalte, um den Abschluss zu kennzeichnen.

Migration der API-Nutzung

Wenn Ihr System die Dialogflow ES API verwendet für Laufzeit- oder Designzeitaufrufe, müssen Sie diesen Code aktualisieren, um den Conversational Agents (Dialogflow CX) API: Wenn Sie die Intent-Erkennung nur zur Laufzeit verwenden, sollte dieses Update ziemlich einfach sein.

Integrationen

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

In den folgenden Abschnitten werden die empfohlenen Migrationsschritte beschrieben.

Validierung

Verwenden Sie Agent-Validierung um zu 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 der Agent zu arbeiten scheint, Sie sollten Unterhaltungen zwischen Dialogflow ES und Conversational Agents (Dialogflow CX) vergleichen. und prüfen, ob das Verhalten ähnlich oder verbessert wurde.

Beim Testen dieser Unterhaltungen mit dem Simulator sollten Sie Testläufe um zukünftige Regressionen zu vermeiden.

Umgebungen

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