Freigeben über

Einen Azure Bot konfigurierien, um Unterhaltungen zu eskalieren und zu beenden

  • Artikel

Dieser Artikel zeigt, wie Sie einen Azure Bot in Omnichannel for Customer Service programmieren können, um eine Unterhaltung an einen menschlichen Agenten zu verschieben. Außerdem wird beschrieben, wie der Bot so programmiert wird, dass er die Unterhaltung beendet.

Wichtig

  • Bots können Unterhaltungen nur dann empfangen, wenn sie Teil eines Push-basierten Arbeitsstreams sind.
  • Bot-Agenten werden im Konsultationsmodus nicht unterstützt.

Anforderungen

  • Sie müssen einen vorkonfigurierten Azure-Bot haben, der mit Omnichannel for Customer Service integriert werden kann. Weitere Informationen: Integrieren Sie einen Azure Bot
  • Qualifikationsbasierte Weiterleitung sollte aktiviert werden.

Eskalieren Sie eine Unterhaltung an einen menschlichen Agenten.

Im Omnichannel für Kundenservice kann ein Bot die aktuelle Unterhaltung an einen menschlichen Agenten eskalieren. Das Routing der Unterhaltung hängt von der Routingregel ab, die für den Arbeitsstream konfiguriert ist.

Wenn die Unterhaltung vom Bot an einen menschlichen Agenten übertragen wird, werden die Kunden- und Falldetails automatisch erkannt, wenn der Agent die Eskalationsanfrage annimmt. Der Bot leitet Unterhaltungen mithilfe der Kontextvariablen Omnichannel for Customer Service weiter, die dem Chat zugeordnet werden. Der Bot kann eine Liste mit Kontextvariablen und den zugeordneten Werten an den Omnichannel for Customer Service versenden, zusammen mit der Eskalationsanforderung. Der Bot kann auch Kontextelemente festlegen, die von Fertigkeitssuch-Modellen verwendet werden können, um neue Fähigkeiten zu identifizieren und sie an die Liste der vorhandenen Fähigkeiten für die Unterhaltung anzuhängen. Omnichannel for Customer Service wird dann die Kontextvariablen für die angegebenen Werten aktualisieren und dann das Routingmodul erneut ausführen. Dadurch wird sichergestellt, dass die eskalierte Unterhaltung an die richtige Warteschlange weitergeleitet wird. Informationen zu Kontextelementen und Variablennamen finden Sie unter Verknüpfen Sie Kunden und Fälle mit Unterhaltungen, wenn der Bot die Unterhaltung eskaliert oder beendet.

Nachdem der Agent die Eskalationsanforderung angenommen hat, ist die Unterhaltungsaufzeichnung mit dem Bot auf dem Unterhaltungswidget des Agenten sichtbar. Der Agent kann dann die Unterhaltung mit dem Kunden fortsetzen.

Notiz

Die Unterhaltungs-Zusammenfassung ist für den Kunden nicht sichtbar.

Eine Unterhaltung beenden

Der Azure Bot kann entscheiden, die Unterhaltung zu beenden, falls er erkennt, dass die Anfragen des Kunden beantwortet wurden oder wenn der Kunde nicht mehr reagiert. Der Bot kann dies tun, indem er eine EndConversation Anfrage an den Omnichannel for Customer Service sendet.

Beispielcode

Dieser Abschnitt enthält Codebeispiele, die Sie zum Konfigurieren eines Azure-Bots zum Eskalieren und Beenden von Unterhaltungen verwenden können.

  1. Implementieren Sie eine Befehlsklasse, um Aufgaben im Zusammenhang mit dem Eskalieren und Beenden von Unterhaltungen zu modellieren.

Nachfolgend ist ein Codebeispiel aufgeführt.

using System.Collections.Generic;
using System.Runtime.Serialization;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;

namespace EchoBot.OmniChannel
{
    /// <summary>
    /// Command types that bot can send to Omnichannel
    /// </summary>
    [JsonConverter(typeof(StringEnumConverter))]
    public enum CommandType
    {
        [EnumMember(Value = "Escalate")]
        Escalate = 0,
        [EnumMember(Value = "EndConversation")]
        EndConversation = 1,
    }
    /// <summary>
    /// Action
    /// </summary>
    [DataContract]
    public class Command
    {
        /// <summary>
        /// Type of action that bot can send to Omnichannel
        /// </summary>
        [DataMember(Name = "type")]
        public CommandType Type { get; set; }

        /// <summary>
        /// Dictionary of Workstream Context variable and value pairs to be sent to Omnichannel for Customer Service
        /// </summary>
        [DataMember(Name = "context")]
        public Dictionary<string, object> Context { get; set; }
    }
}
  1. Implementieren eines Omnichannel for Customer Service Clientklasse, um den Befehlskontext festzulegen.

Nachfolgend ist ein Codebeispiel aufgeführt.

using Microsoft.Bot.Schema;
using Newtonsoft.Json;
using System.Collections.Generic;

namespace EchoBot.OmniChannel
{
    /// <summary>
    /// Extension class for middleware implementation management
    /// </summary>
    public static class OmnichannelBotClient
    {
        /// <summary>
        /// Delivery mode of bot's reply activity
        /// </summary>
        private const string DeliveryMode = "deliveryMode";
        /// <summary>
        /// Delivery Mode value bridged
        /// </summary>
        private const string Bridged = "bridged";
        /// <summary>
        /// Custom data tag
        /// </summary>
        private const string Tags = "tags";

        /// <summary>
        /// Adds Omnichannel for Customer Service escalation context to the bot's reply activity.
        /// </summary>
        /// <param name="activity">Bot's reply activity</param>
        /// <param name="contextVars">Omnichannel for Customer Service workstream context variable value pairs</param>
        public static void AddEscalationContext(IActivity activity, Dictionary<string, object> contextVars)
        {
            Command command = new Command
            {
                Type = CommandType.Escalate,
                Context = contextVars
            };

            string serializedString = JsonConvert.SerializeObject(command);
            if (activity.ChannelData != null)
            {
                (activity as IActivity).ChannelData[Tags] = serializedString;
            }
            else
            {
                activity.ChannelData = new Dictionary<string, object>() { { Tags, serializedString } };
            }
        }

        /// <summary>
        /// Adds Omnichannel end conversation context to the bot's reply activity.
        /// </summary>
        /// <param name="activity">Bot's reply activity</param>
        public static void AddEndConversationContext(IActivity activity)
        {
            Command command = new Command
            {
                Type = CommandType.EndConversation,
                Context = new Dictionary<string, object>()
            };

            string serializedString = JsonConvert.SerializeObject(command);
            if (activity.ChannelData != null)
            {
                (activity as IActivity).ChannelData[Tags] = serializedString;
            }
            else
            {
                activity.ChannelData = new Dictionary<string, object>() { { Tags, serializedString } };
            }
        }

        /// <summary>
        /// Sets delivery mode for bot as bridged so that Customer can see bot messages
        /// </summary>
        /// <param name="activity">Bot's reply activity</param>
        public static void BridgeBotMessage(IActivity activity)
        {
            if (activity.ChannelData != null)
            {
                (activity as IActivity).ChannelData[DeliveryMode] = Bridged;
            }
            else
            {
                activity.ChannelData = new Dictionary<string, object>() { { DeliveryMode, Bridged } };
            }
        }
    }
}

  1. In der Bot ActivityHandler-Klasse rufen Sie die entsprechende Clientmethode auf.

    Änderen Sie die Escalate und EndConversation Befehlskriterien basierend auf Ihren Anforderungen.

    Fügen Sie die Codeanweisung OmnichannelBotClient.BridgeBotMessage(turnContext.Activity); Ihrem Botcode hinzu, um Nachrichten an Omnichannel for Customer Service zu senden. Diese Methode muss für jede Aktivitätsnachricht aufgerufen werden, die an die Kunden gesendet wird.

Nachfolgend ist ein Codebeispiel aufgeführt.

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using EchoBot.OmniChannel;
using Microsoft.Bot.Schema;

namespace Microsoft.Bot.Builder.EchoBot
{
    public class EchoBot : ActivityHandler
    {
        /// <summary>
        /// This method is called when the bot receives a message.
        /// </summary>
        /// <param name="turnContext">Turn Context object</param>
        /// <param name="cancellationToken">CancellationToken</param>
        /// <returns></returns>
        protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
        {
            if (turnContext.Activity.Type == ActivityTypes.Message)
            {
                // Replace with your own message
                IActivity replyActivity = MessageFactory.Text($"Echo: {turnContext.Activity.Text}");

                // Replace with your own condition for bot escalation
                if (turnContext.Activity.Text.Equals("escalate", StringComparison.InvariantCultureIgnoreCase))
                {
                    Dictionary<string, object> contextVars = new Dictionary<string, object>() { { "Bo-tHandoffTopic", "CreditCard" } };
                    OmnichannelBotClient.AddEscalationContext(replyActivity, contextVars);
                }
                // Replace with your own condition for bot end conversation
                else if (turnContext.Activity.Text.Equals("endconversation", StringComparison.InvariantCultureIgnoreCase))
                {
                    OmnichannelBotClient.AddEndConversationContext(replyActivity);
                }
                // Call method BridgeBotMessage for every response that needs to be delivered to the customer.
                else
                {
                    OmnichannelBotClient.BridgeBotMessage(replyActivity);
                }

                await turnContext.SendActivityAsync(replyActivity, cancellationToken);
            }
        }

        /// <summary>
        /// This method is called when there is a participant added to the chat.
        /// </summary>
        /// <param name="membersAdded">Member being added to the chat</param>
        /// <param name="turnContext">TurnContext</param>
        /// <param name="cancellationToken">CancellationToken</param>
        /// <returns></returns>
        protected override async Task OnMembersAddedAsync(IList<ChannelAccount> membersAdded, ITurn-Context<IConversationUpdateActivity> turnContext, CancellationToken cancellationToken)
        {
            foreach (var member in membersAdded)
            {
                if (member.Id != turnContext.Activity.Recipient.Id)
                {
                    //Set the bridge mode for every message that needs to be delivered to customer
                    OmnichannelBotClient.BridgeBotMessage(turnContext.Activity); 
                    await turnContext.SendActivityAsync(MessageFactory.Text($"Welcome to Echo Bot."), cancellationToken);
                }
            }
        }
    }
}

Das Wörterbuch contextVars enthält die gesamten Omnichannel für Kundenservice Kontext-Variablennamenwertpaare, die Sie im Rahmen der Eskalationsanforderung aktualisieren möchten. Hier ist BotHandoffTopic die Kontextvariablenname und CreditCard ist der variable Wert des Kontexts. Liegt eine Agentwarteschlange mit den Regeln BotHandoffTopic Gleich CreditCar, dann wird dieser eskalierte Chat an die entsprechende Warteschlange weitergeleitet.

Der Name der Kontextvariable ist vom Typ Zeichenfolge. Der Wert der Kontextvariablen muss vom Typ Integer oder Zeichenfolge sein und sollte während der Eskalation als Dictionary <string, object> übergeben werden. Nachfolgend ist ein Codebeispiel aufgeführt.

Dictionary<string, Object> keyValues = new Dictionary<string, object>() {
{ "BotHandoffTopic", "CreditCard" },
{ "IDNumber", 101}
}

Der Bot kann auch eine Eskalationszusammenfassung senden, die nur dem Agent angezeigt wird, wenn er oder sie die weitergeleitete Chatanforderung annimmt. Um die Zusammenfassung zu senden, müssen Sie den Aktivitätstext in der Aktivitätsnachrichten-Eskalation festlegen.

Siehe auch

Integrieren Sie einen Azure Bot
Kontextvariable hinzufügen
Azure Bot Service
Verbinden eines Bots an Kanäle
Bringen Sie Ihren eigenen Messaging-Kanal mit: Direct Line Bot
Bewährte Methoden für Azure und Copilot Studio Bots