Webhook-Dienst erstellen

Der vorgefertigte Agent, den Sie im letzten Schritt erstellt haben, erfordert einen Webhook. Cloud Run-Funktionen werden in diesem Tutorial verwendet, um den Webhook zu hosten, da sie einfach zu verwenden sind. Es gibt jedoch viele andere Möglichkeiten, einen Webhook-Dienst zu hosten. Im Beispiel wird auch die Programmiersprache Go verwendet, Sie können aber jede Sprache verwenden, die von Cloud Run-Funktionen unterstützt wird.

Funktion erstellen

Cloud Run-Funktionen können mit der Google Cloud Console erstellt werden (Dokumentation ansehen, Konsole öffnen). So erstellen Sie eine Funktion für dieses Tutorial:

  1. Ihr Dialogflow-Agent und die Funktion müssen sich im selben Projekt befinden. So kann Dialogflow am einfachsten sicher auf Ihre Funktion zugreifen. Wählen Sie vor dem Erstellen der Funktion, wählen Sie Ihr Projekt in der Google Cloud Konsole aus.

    Zur Projektauswahl

  2. Öffnen Sie die Übersichtsseite zu Cloud Run-Funktionen.

    Übersicht zu Cloud Run-Funktionen aufrufen

  3. Klicken Sie auf Funktion erstellen und legen Sie die Werte für die folgenden Felder fest:

    • Umgebung: 1. Generation
    • Funktionsname: tutorial-telecommunications-webhook
    • Region: Wenn Sie eine Region für Ihren Agenten angegeben haben, verwenden Sie dieselbe Region.
    • HTTP-Triggertyp: HTTP
    • URL: Klicken Sie hier auf die Schaltfläche „Kopieren“ und speichern Sie den Wert. Sie benötigen diese URL, wenn Sie den Webhook konfigurieren.
    • Authentifizierung: Authentifizierung erforderlich
    • HTTPS erforderlich: aktiviert

  4. Klicken Sie auf Speichern.

  5. Klicken Sie auf Weiter (Sie benötigen keine speziellen Laufzeit-, Build-, Verbindungs- oder Sicherheitseinstellungen).

  6. Legen Sie die Werte für die folgenden Felder fest:

    • Laufzeit: Wählen Sie die neueste Go-Laufzeit aus.
    • Quellcode: Inline-Editor
    • Einstiegspunkt: HandleWebhookRequest

  7. Ersetzen Sie den Code durch Folgendes: 

    package cxtwh

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"strings"

	"cloud.google.com/go/spanner"
  "google.golang.org/grpc/codes"
)

// client is a Spanner client, created only once to avoid creation
// for every request.
// See: https://cloud.google.com/functions/docs/concepts/go-runtime#one-time_initialization
var client *spanner.Client

func init() {
	// If using a database, these environment variables will be set.
	pid := os.Getenv("PROJECT_ID")
	iid := os.Getenv("SPANNER_INSTANCE_ID")
	did := os.Getenv("SPANNER_DATABASE_ID")
	if pid != "" && iid != "" && did != "" {
		db := fmt.Sprintf("projects/%s/instances/%s/databases/%s",
			pid, iid, did)
		log.Printf("Creating Spanner client for %s", db)
		var err error
		// Use the background context when creating the client,
		// but use the request context for calls to the client.
		// See: https://cloud.google.com/functions/docs/concepts/go-runtime#contextcontext
		client, err = spanner.NewClient(context.Background(), db)
		if err != nil {
			log.Fatalf("spanner.NewClient: %v", err)
		}
	}
}

type fulfillmentInfo struct {
	Tag string `json:"tag"`
}

type sessionInfo struct {
	Session    string         `json:"session"`
	Parameters map[string]any `json:"parameters"`
}

type text struct {
	Text []string `json:"text"`
}

type responseMessage struct {
	Text text `json:"text"`
}

type fulfillmentResponse struct {
	Messages []responseMessage `json:"messages"`
}

// webhookRequest is used to unmarshal a WebhookRequest JSON object. Note that
// not all members need to be defined--just those that you need to process.
// As an alternative, you could use the types provided by the Dialogflow protocol buffers:
// https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/dialogflow/cx/v3#WebhookRequest
type webhookRequest struct {
	FulfillmentInfo fulfillmentInfo `json:"fulfillmentInfo"`
	SessionInfo     sessionInfo     `json:"sessionInfo"`
}

// webhookResponse is used to marshal a WebhookResponse JSON object. Note that
// not all members need to be defined--just those that you need to process.
// As an alternative, you could use the types provided by the Dialogflow protocol buffers:
// https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/dialogflow/cx/v3#WebhookResponse
type webhookResponse struct {
	FulfillmentResponse fulfillmentResponse `json:"fulfillmentResponse"`
	SessionInfo         sessionInfo         `json:"sessionInfo"`
}

// detectCustomerAnomaly handles same-named tag.
func detectCustomerAnomaly(ctx context.Context, request webhookRequest) (
	webhookResponse, error) {
	// Create session parameters that are populated in the response.
	// This example hard codes values, but a real system
	// might look up this value in a database.
	p := map[string]any{
		"anomaly_detect":        "false",
		"purchase":              "device protection",
		"purchase_amount":       "12.25",
		"bill_without_purchase": "54.34",
		"total_bill":            "66.59",
		"first_month":           "January 1",
	}
	// Build and return the response.
	response := webhookResponse{
		SessionInfo: sessionInfo{
			Parameters: p,
		},
	}
	return response, nil
}

// validatePhoneLine handles same-named tag.
func validatePhoneLine(ctx context.Context, request webhookRequest) (
	webhookResponse, error) {
	// Create session parameters that are populated in the response.
	// This example hard codes values, but a real system
	// might look up this value in a database.
	p := map[string]any{
		"domestic_coverage":   "true",
		"phone_line_verified": "true",
	}
	// Build and return the response.
	response := webhookResponse{
		SessionInfo: sessionInfo{
			Parameters: p,
		},
	}
	return response, nil
}

// cruisePlanCoverage handles same-named tag.
func cruisePlanCoverage(ctx context.Context, request webhookRequest) (
	webhookResponse, error) {
	// Get the existing parameter values
	port := request.SessionInfo.Parameters["destination"].(string)
	port = strings.ToLower(port)
	// Check if the port is covered
	covered := "false"
	if client != nil {
		// A Spanner client exists, so access the database.
		// See: https://pkg.go.dev/cloud.google.com/go/spanner#ReadOnlyTransaction.ReadRow
		row, err := client.Single().ReadRow(ctx,
			"Destinations",
			spanner.Key{port},
			[]string{"Covered"})
		if err != nil {
			if spanner.ErrCode(err) == codes.NotFound {
				log.Printf("Port %s not found", port)
			} else {
				return webhookResponse{}, err
			}
		} else {
			// A row was returned, so check the value
			var c bool
			err := row.Column(0, &c)
			if err != nil {
				return webhookResponse{}, err
			}
			if c {
				covered = "true"
			}
		}
	} else {
		// No Spanner client exists, so use hardcoded list of ports.
		coveredPorts := map[string]bool{
			"anguilla": true,
			"canada":   true,
			"mexico":   true,
		}
		_, ok := coveredPorts[port]
		if ok {
			covered = "true"
		}
	}
	// Create session parameters that are populated in the response.
	// This example hard codes values, but a real system
	// might look up this value in a database.
	p := map[string]any{
		"port_is_covered": covered,
	}
	// Build and return the response.
	response := webhookResponse{
		SessionInfo: sessionInfo{
			Parameters: p,
		},
	}
	return response, nil
}

// internationalCoverage handles same-named tag.
func internationalCoverage(ctx context.Context, request webhookRequest) (
	webhookResponse, error) {
	// Get the existing parameter values
	destination := request.SessionInfo.Parameters["destination"].(string)
	destination = strings.ToLower(destination)
	// Hardcoded list of covered international monthly destinations
	coveredMonthly := map[string]bool{
		"anguilla":  true,
		"australia": true,
		"brazil":    true,
		"canada":    true,
		"chile":     true,
		"england":   true,
		"france":    true,
		"india":     true,
		"japan":     true,
		"mexico":    true,
		"singapore": true,
	}
	// Hardcoded list of covered international daily destinations
	coveredDaily := map[string]bool{
		"brazil":    true,
		"canada":    true,
		"chile":     true,
		"england":   true,
		"france":    true,
		"india":     true,
		"japan":     true,
		"mexico":    true,
		"singapore": true,
	}
	// Check coverage
	coverage := "neither"
	_, monthly := coveredMonthly[destination]
	_, daily := coveredDaily[destination]
	if monthly && daily {
		coverage = "both"
	} else if monthly {
		coverage = "monthly_only"
	} else if daily {
		coverage = "daily_only"
	}
	// Create session parameters that are populated in the response.
	// This example hard codes values, but a real system
	// might look up this value in a database.
	p := map[string]any{
		"coverage": coverage,
	}
	// Build and return the response.
	response := webhookResponse{
		SessionInfo: sessionInfo{
			Parameters: p,
		},
	}
	return response, nil
}

// cheapestPlan handles same-named tag.
func cheapestPlan(ctx context.Context, request webhookRequest) (
	webhookResponse, error) {
	// Create session parameters that are populated in the response.
	// This example hard codes values, but a real system
	// might look up this value in a database.
	p := map[string]any{
		"monthly_cost":   70,
		"daily_cost":     100,
		"suggested_plan": "monthly",
	}
	// Build and return the response.
	response := webhookResponse{
		SessionInfo: sessionInfo{
			Parameters: p,
		},
	}
	return response, nil
}

// Define a type for handler functions.
type handlerFn func(ctx context.Context, request webhookRequest) (
	webhookResponse, error)

// Create a map from tag to handler function.
var handlers map[string]handlerFn = map[string]handlerFn{
	"detectCustomerAnomaly": detectCustomerAnomaly,
	"validatePhoneLine":     validatePhoneLine,
	"cruisePlanCoverage":    cruisePlanCoverage,
	"internationalCoverage": internationalCoverage,
	"cheapestPlan":          cheapestPlan,
}

// handleError handles internal errors.
func handleError(w http.ResponseWriter, err error) {
	log.Printf("ERROR: %v", err)
	http.Error(w,
		fmt.Sprintf("ERROR: %v", err),
		http.StatusInternalServerError)
}

// HandleWebhookRequest handles WebhookRequest and sends the WebhookResponse.
func HandleWebhookRequest(w http.ResponseWriter, r *http.Request) {
	var request webhookRequest
	var response webhookResponse
	var err error

	// Read input JSON
	if err = json.NewDecoder(r.Body).Decode(&request); err != nil {
		handleError(w, err)
		return
	}
	log.Printf("Request: %+v", request)

	// Get the tag from the request, and call the corresponding
	// function that handles that tag.
	tag := request.FulfillmentInfo.Tag
	if fn, ok := handlers[tag]; ok {
		response, err = fn(r.Context(), request)
	} else {
		err = fmt.Errorf("Unknown tag: %s", tag)
	}
	if err != nil {
		handleError(w, err)
		return
	}
	log.Printf("Response: %+v", response)

	// Send response
	if err = json.NewEncoder(w).Encode(&response); err != nil {
		handleError(w, err)
		return
	}
}

  8. Klicken Sie auf Bereitstellen.

  9. Warten Sie, bis die Statusanzeige angibt, dass die Funktion erfolgreich bereitgestellt wurde. Sehen Sie sich währenddessen den Code an, den Sie gerade bereitgestellt haben.

Webhook für Ihren Agenten konfigurieren

Nachdem der Webhook als Dienst vorhanden ist, verknüpfen Sie ihn mit Ihrem Agenten. So konfigurieren Sie den Webhook für Ihren Agenten:

  1. Öffnen Sie die Dialogflow CX Console.
  2. Wählen Sie Ihr Google Cloud-Projekt aus.
  3. Wählen Sie den Agent aus.
  4. Wählen Sie den Tab Verwalten.
  5. Klicken Sie auf Webhooks.
  6. Klicken Sie auf den vorhandenen Webhook (der vom vorgefertigten Agenten erstellt wurde).
  7. Aktualisieren Sie die Webhook-URL auf die Webhook-URL, die Sie beim Erstellen der Funktion gespeichert haben.
  8. Legen Sie für Untertyp die Option „Standard“ fest.
  9. Klicken Sie auf Speichern.

Agenten ausprobieren

Ihr Agent ist jetzt bereit. Klicken Sie auf die Schaltfläche Agent testen , um den Simulator zu öffnen. Versuchen Sie, die folgende Unterhaltung mit dem Agenten zu führen:

Unterhaltungsrunde Ich Agent
1 Hallo! Hallo! Ich bin der virtuelle Kundenservicemitarbeiter des Telekommunikationsunternehmens. Ich kann Ihnen bei Fragen zu Rechnungen und Tarifen helfen, Fehler beheben und Reisepläne und Kreuzfahrten hinzufügen. Wie kann ich Ihnen heute helfen?
2 Ich möchte einen Kreuzfahrttarif hinzufügen. Ich sehe mal nach. Wie lautet Ihre Telefonnummer?
3 123-123-1234 Wie viele Tage dauert Ihre Kreuzfahrt?
4 7 Option 1 umfasst Gesprächsminuten und SMS. Sie kostet $[XX] pro Tag. Weitere Informationen finden Sie hier: [URL]. Option 2 umfasst Gesprächsminuten, SMS und Daten. Sie kostet $[XX] pro Tag. Weitere Informationen finden Sie hier: [URL]. Welchen Kreuzfahrttarif möchten Sie hinzufügen?
5 Option 1 Alles klar. Ich habe diesen Tarif Ihrem Konto hinzugefügt. Während Ihrer Kreuzfahrt benötigen Sie möglicherweise auch eine Abdeckung an Land. In welchem Hafen machen Sie Halt?
6 Mexiko Und wie viele Tage verbringen Sie dort?
7 3 Außerdem haben wir gute Nachrichten: In Mexiko ist die Abdeckung an Land kostenlos. Das war's! Kann ich sonst noch etwas für Sie tun?

Diese Unterhaltung wurde vom Ablauf Cruise Plan verwaltet.

In Unterhaltungsrunde 6 haben Sie „Mexiko“ als Zielhafen angegeben. Der Zielhafen und die Anzahl der Tage dort werden als Formularparameter destination und trip_duration der Seite Collect Port erfasst. Suchen Sie in Ihrem Agenten nach diesen Parameterdefinitionen.

Screenshot der Seite „Port erfassen“ in der Dialogflow-Konsole

Auf der Collect Port Seite, gibt es eine Bedingungsroute für den Abschluss des Formulars: $page.params.status = "FINAL". Sobald die beiden Formularparameter angegeben wurden, wird diese Route aufgerufen. Diese Route ruft Ihren Webhook auf und stellt dem Webhook das Tag cruisePlanCoverage zur Verfügung. Wenn Sie sich den Webhook-Code oben ansehen, sehen Sie, dass dieses Tag den Aufruf der gleichnamigen Funktion auslöst.

Diese Funktion bestimmt, ob das angegebene Ziel vom Tarif abgedeckt wird. Die Funktion prüft, ob bestimmte Umgebungsvariablen mit Informationen für die Verbindung zur Datenbank festgelegt sind. Wenn diese Umgebungsvariablen nicht festgelegt sind, verwendet die Funktion eine fest codierte Liste von Zielen. In den nächsten Schritten ändern Sie die Umgebung für die Funktion so, dass sie Daten aus einer Datenbank abruft, um die Tarifabdeckung für Ziele zu prüfen.

Fehlerbehebung

Der Webhook-Code enthält Logging-Anweisungen. Wenn Sie Probleme haben, rufen Sie die Logs für Ihre Funktion auf.

Weitere Informationen

Weitere Informationen zu den oben genannten Schritten finden Sie unter:

Zurück
Vordefinierten Agent erstellen
Weiter
Datenbank abfragen