Webhook-Dienst erstellen

Der vordefinierte Agent, den Sie im letzten Schritt erstellt haben, benötigt einen Webhook. In dieser Anleitung werden Cloud Run-Funktionen 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 jedoch jede von Cloud Run-Funktionen unterstützte Sprache verwenden.

Funktion erstellen

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

  1. Es ist wichtig, dass sich Ihr Dialogflow-Agent und die Funktion im selben Projekt befinden. Dies ist die einfachste Möglichkeit, Dialogflow sicheren Zugriff auf Ihre Funktion zu gewähren. Wählen Sie vor dem Erstellen der Funktion Ihr Projekt in der Google Cloud Console aus.

    Zur Projektauswahl

  2. Öffnen Sie die Übersichtsseite zu Cloud Run Functions.

    Zur Übersicht über Cloud Run Functions

  3. Klicken Sie auf Funktion erstellen und legen Sie 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 verlangen
    • 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

Da der Webhook jetzt 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-Konsole.
  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 (vom vordefinierten Agenten erstellt).
  7. Aktualisieren Sie die Webhook-URL auf die Webhook-URL, die Sie beim Erstellen der Funktion gespeichert haben.
  8. Legen Sie den Untertyp auf „Standard“ fest.
  9. Klicken Sie auf Speichern.

KI-Agenten ausprobieren

Ihr KI-Agent ist jetzt bereit zum Testen. Klicken Sie auf den Button Agent testen, um den Simulator zu öffnen. Versuchen Sie, die folgende Unterhaltung mit dem KI-Agenten zu führen:

Gesprächsrunde Ich Agent
1 Hallo! Hallo! Ich bin der virtuelle Kundenservicemitarbeiter für Telekommunikation. Ich kann Ihnen bei Fragen zur Abrechnung und zu Tarifen helfen, Probleme beheben und Reise- und Kreuzfahrtpläne hinzufügen. Wie kann ich Ihnen heute helfen?
2 Ich möchte einen Kreuzfahrtplan hinzufügen Ich sehe mir das mal an. Wie lautet Ihre Telefonnummer, die Sie bei uns angegeben haben?
3 123-123-1234 Wie viele Tage dauert Ihre Kreuzfahrt?
4 7 Option 1 umfasst Anrufe und SMS. Die Kosten betragen [XX] € pro Tag. Weitere Informationen findest du hier: [URL]. Option 2 umfasst Anrufe, SMS und Daten. Die Kosten betragen [XX] € pro Tag. Weitere Informationen findest du hier: [URL]. Welchen Kreuzfahrtplan möchtest du hinzufügen?
5 Option 1 Ok. Ich habe diesen Tarif Ihrem Konto hinzugefügt. Während Ihrer Kreuzfahrt benötigen Sie möglicherweise auch an Land Mobilfunkempfang. An welchem Hafen werden Sie anlegen?
6 Mexiko Und wie viele Tage verbringen Sie dort?
7 3 Wir haben tolle Neuigkeiten! In Mexiko ist die Abdeckung an Land kostenlos. Das war's! Kann ich sonst noch etwas für Sie tun?

Diese Unterhaltung wurde über den Ablauf „Cruise Plan“ verwaltet.

In Gesprächsrunde 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 Seite Collect Port gibt es eine Bedingungsroute für das Ausfüllen des Formulars: $page.params.status = "FINAL". Sobald die beiden Formularparameter angegeben wurden, wird diese Route aufgerufen. Diese Route ruft Ihren Webhook auf und stellt ihm das Tag cruisePlanCoverage zur Verfügung. Wenn Sie sich den Webhook-Code oben ansehen, werden Sie feststellen, dass dieses Tag die benannte Funktion aufruft.

Mit dieser Funktion wird ermittelt, ob das angegebene Ziel im Plan enthalten ist. Die Funktion prüft, ob bestimmte Umgebungsvariablen mit Informationen zum Herstellen einer Verbindung zur Datenbank festgelegt sind. Wenn diese Umgebungsvariablen nicht festgelegt sind, verwendet die Funktion eine hartcodierte Liste von Zielen. In den nächsten Schritten ändern Sie die Umgebung für die Funktion, damit sie Daten aus einer Datenbank abruft, um die Abdeckung des Tarifs für Ziele zu prüfen.

Fehlerbehebung

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

Weitere Informationen

Weitere Informationen zu den oben genannten Schritten finden Sie hier:

Zurück
Vordefinierten Agent erstellen
Weiter
Datenbank abfragen