Freigeben über

Erstellen eines virtuellen Assistenten

  • Artikel

Virtual Assistant ist eine Open-Source-Vorlage von Microsoft, mit der Sie eine stabile Unterhaltungslösung erstellen und gleichzeitig die volle Kontrolle über die Benutzererfahrung, das Branding und die erforderlichen Daten behalten. Die Virtual Assistant-Hauptvorlage ist der grundlegende Baustein, der die Microsoft-Technologien vereint, die zum Erstellen eines virtuellen Assistenten erforderlich sind, einschließlich Bot Framework SDK, Language Understanding (LUIS) und QnA Maker. Es vereint auch die wesentlichen Funktionen wie die Registrierung von Qualifikationen, verknüpfte Konten und grundlegende Konversationsabsichten, um Benutzern eine Reihe nahtloser Interaktionen und Erfahrungen zu bieten. Darüber hinaus enthalten die Vorlagenfunktionen umfassende Beispiele für wiederverwendbare konversationsbasierte Skills. In eine virtuelle Assistentenlösung sind individuelle Skills integriert, um mehrere Szenarien zu ermöglichen. Mithilfe des Bot Framework SDK werden die Skills in Quellcodeform dargestellt, sodass Sie sie nach Bedarf anpassen und erweitern können. Weitere Informationen zu den Skills des Bot Framework finden Sie unter Was ist ein Bot-Framework-Skill?. Dieses Dokument führt Sie durch Implementierungsüberlegungen zu virtuellen Assistenten für Organisationen, das Erstellen eines virtuellen Microsoft Teams-fokussierten Assistenten, verwandte Beispiele, Codebeispiele und Einschränkungen virtueller Assistenten. Die folgende Abbildung zeigt die Übersicht über einen virtuellen Assistenten:

Diagramm, das die Übersicht über den virtuellen Assistenten zeigt.

Textnachrichtenaktivitäten werden vom zentralen virtuellen Assistenten mithilfe eines Versandmodells an die zugehörigen Skills weitergeleitet.

Überlegungen zur Implementierung

Die Entscheidung zum Hinzufügen eines virtuellen Assistenten hängt von vielen Determinanten ab, und diese unterscheiden sich für jede Organisation. Die Faktoren, die für die Implementierung eines virtuellen Assistenten für Ihre Organisation sprechen, sind die folgenden:

  • Ein zentrales Team verwaltet alle Mitarbeiterfunktionen. Es kann einen virtuellen Assistenten erstellen und Updates für die zentrale Funktion verwalten, einschließlich des Hinzufügens neuer Skills.
  • Es gibt mehrere Anwendungen für mehrere Geschäftsfunktionen, und es werden in Zukunft voraussichtlich mehr werden.
  • Bestehende Anwendungen können angepasst werden, gehören der Organisation und werden in Skills für eine virtuellen Assistenten umgewandelt.
  • Das für die zentrale Mitarbeiterfunktion verantwortliche Team kann Anpassungen an vorhandenen Apps beeinflussen. Es bietet auch die erforderliche Hilfe für die Integration vorhandener Anwendungen als Skills in den virtuellen Assistenten.

In der folgenden Abbildung sind die Geschäftsfunktionen des virtuellen Assistenten dargestellt:

Diagramm, das zeigt, dass das zentrale Team den Assistenten verwaltet und Geschäftsfunktionsteams Fähigkeiten beisteuern.

Erstellen eines virtuellen Assistenten für Microsoft Teams

Microsoft hat eine Microsoft-Vorlage zum Erstellen von virtuellen Assistenten und Fähigkeiten veröffentlicht. Mit der Vorlage können Sie einen virtuellen Assistenten erstellen, der von einer textbasierten Oberfläche mit Unterstützung für eingeschränkte Rich-Karten mit Aktionen unterstützt wird. Wir haben die Vorlage erweitert, um Die Funktionen der Microsoft Teams-Plattform einzuschließen und großartige Teams-App-Funktionen zu unterstützen. Einige der Funktionen umfassen unterstützung für umfangreiche adaptive Karten, Dialoge (in TeamsJS v1.x als Aufgabenmodule bezeichnet), Teams oder Gruppenchats und Nachrichtenerweiterungen. Weitere Informationen zum Erweitern von virtuellen Assistenten auf Microsoft Teams finden Sie im Lernprogramm: Erweitern Ihres virtuellen Assistenten auf Microsoft Teams. Die folgende Abbildung zeigt das Übersichtsdiagramm einer virtuellen Assistentenlösung:

Diagramm, das die Lösung für den virtuellen Assistenten zeigt.

Hinzufügen adaptiver Karten zu Ihrem virtuellen Assistenten

Um Anforderungen ordnungsgemäß zu versenden, muss Ihr virtueller Assistent das richtige LUIS-Modell und die zugehörigen Skills identifizieren. Der Verteilungsmechanismus kann jedoch nicht für Kartenaktionsaktivitäten verwendet werden, da das LUIS-Modell, das einem Skill zugeordnet ist, für Kartenaktionstexte trainiert wird. Die Aktionstexte der Karte sind fixe, vordefinierte Schlüsselwörter und werden nicht von einem Benutzer kommentiert.

Dieser Nachteil wird durch das Einbetten von Skillinformationen in die Nutzlast der Kartenaktion behoben. Jeder Skill sollte in das value Feld der Kartenaktionen eingebettet skillId werden. Sie müssen sicherstellen, dass jede Kartenaktionsaktivität die entsprechenden Skillinformationen enthält, und dass der virtuelle Assistent diese Informationen für die Versendung nutzen kann.

Sie müssen skillId im Konstruktor bereitstellen, um sicherzustellen, dass die Skillinformationen immer in Kartenaktionen vorhanden sind. Ein Beispielcode für Kartenaktionsdaten ist im folgenden Abschnitt dargestellt:

    public class CardActionData
    {
        public CardActionData(string skillId)
        {
            this.SkillId = skillId;
        }

        [JsonProperty("skillId")]
        public string SkillId { get; set; }
    }

    ...
    var button = new CardAction
    {
        Type = ActionTypes.MessageBack,
        Title = "Card action button",
        Text = "card action button text",
        Value = new CardActionData(<SkillId>),
    };

Als Nächstes wird die SkillCardActionData-Klasse in die Virtual Assistant-Vorlage eingefügt, um skillId aus der Nutzlast der Kartenaktion zu extrahieren. Ein Codeausschnitt zum Extrahieren skillId aus Kartenaktionsnutzlasten wird im folgenden Abschnitt gezeigt:

    // Skill Card action data should contain skillId parameter
    // This class is used to deserialize it and get skillId 
    public class SkillCardActionData
    {
        /// <summary>
        /// Gets the ID of the skil that should handle this card
        /// </summary>
        [JsonProperty("skillId")]
        public string SkillId { get; set; }
    }

Die Implementierung erfolgt über eine Erweiterungsmethode in der Activity-Klasse. Ein Codeausschnitt zum Extrahieren skillId aus Kartenaktionsdaten wird im folgenden Abschnitt gezeigt:

    public static class ActivityExtensions
    {
        // Fetches skillId from CardAction data if present
        public static string GetSkillId(this Activity activity)
        {
            string skillId = string.Empty;

            try
            {
                if (activity.Type.Equals(ActivityTypes.Message) && activity.Value != null)
                {
                    var data = JsonConvert.DeserializeObject<SkillCardActionData>(activity.Value.ToString());
                    skillId = data.SkillId;
                }
                else if (activity.Type.Equals(ActivityTypes.Invoke) && activity.Value != null)
                {
                    var data = JsonConvert.DeserializeObject<SkillCardActionData>(JObject.Parse(activity.Value.ToString()).SelectToken("data").ToString());
                    skillId = data.SkillId;
                }
            }
            catch
            {
                // If not able to retrive skillId, empty skillId should be returned
            }

            return skillId;
        }
    }

Umgang mit Unterbrechungen

Der virtuelle Assistent kann Unterbrechungen in Fällen behandeln, in denen ein Benutzer versucht, einen Skill aufzurufen, während ein anderer Skill aktiv ist. TeamsSkillDialog und TeamsSwitchSkillDialog werden basierend auf SkillDialog und SwitchSkillDialog von Bot Framework eingeführt. Sie ermöglichen es Benutzern, über Kartenaktionen zwischen Skills zu wechseln. Um diese Anforderung zu verarbeiten, fordert der virtuelle Assistent den Benutzer mit einer Bestätigungsmeldung auf, zu einem anderen Skill zu wechseln:

Screenshot der Bestätigungsaufforderung beim Wechsel zu einem neuen Skill.

Verarbeiten von Dialoganforderungen

Um einem virtuellen Assistenten Dialogfunktionen hinzuzufügen, sind zwei zusätzliche Methoden im Aktivitätshandler des virtuellen Assistenten enthalten: OnTeamsTaskModuleFetchAsync und OnTeamsTaskModuleSubmitAsync. Diese Methoden lauschen auf dialogbezogene Aktivitäten des virtuellen Assistenten, identifizieren den der Anforderung zugeordneten Skill und leiten die Anforderung an den identifizierten Skill weiter.

Die Anforderungsweiterleitung erfolgt über die SkillHttpClient-Methode PostActivityAsync. Die Antwort wird als InvokeResponsezurückgegeben, die analysiert und in konvertiert TaskModuleResponse wird.

    public static TaskModuleResponse GetTaskModuleRespose(this InvokeResponse invokeResponse)
    {
        if (invokeResponse.Body != null)
        {
            return new TaskModuleResponse()
            {
                Task = GetTask(invokeResponse.Body),
            };
        }

        return null;
    }

    private static TaskModuleResponseBase GetTask(object invokeResponseBody)
        {
            JObject resposeBody = (JObject)JToken.FromObject(invokeResponseBody);
            var task = resposeBody.GetValue("task");
            var taskType = task.SelectToken("type").ToString();

            return taskType switch
            {
                "continue" => new TaskModuleContinueResponse()
                {
                    Type = taskType,
                    Value = task.SelectToken("value").ToObject<TaskModuleTaskInfo>(),
                },
                "message" => new TaskModuleMessageResponse()
                {
                    Type = taskType,
                    Value = task.SelectToken("value").ToString(),
                },
                _ => null,
            };
        }

Ein ähnlicher Ansatz wird für die Verteilung von Kartenaktionen und Dialogantworten verfolgt. Die Aktionsdaten zum Abrufen und Übermitteln von Dialogen werden aktualisiert, um einzuschließen skillId. Die Aktivitätserweiterungsmethode GetSkillIdskillId extrahiert aus der Nutzlast, die Details zum Skill bereitstellt, der aufgerufen werden muss.

Im folgenden Abschnitt ist der Codeausschnitt für die OnTeamsTaskModuleFetchAsync- und OnTeamsTaskModuleSubmitAsync-Methoden dargestellt:

    // Invoked when a "task/fetch" event is received to invoke dialog.
    protected override async Task<TaskModuleResponse> OnTeamsTaskModuleFetchAsync(ITurnContext<IInvokeActivity> turnContext, TaskModuleRequest taskModuleRequest, CancellationToken cancellationToken)
    {
        try
        {
            string skillId = (turnContext.Activity as Activity).GetSkillId();
            var skill = _skillsConfig.Skills.Where(s => s.Value.AppId == skillId).First().Value;

            // Forward request to correct skill
            var invokeResponse = await _skillHttpClient.PostActivityAsync(this._appId, skill, _skillsConfig.SkillHostEndpoint, turnContext.Activity as Activity, cancellationToken);

            return invokeResponse.GetTaskModuleResponse();
        }
        catch (Exception exception)
        {
            await turnContext.SendActivityAsync(_templateEngine.GenerateActivityForLocale("ErrorMessage"));
            _telemetryClient.TrackException(exception);

            return null;
        }
    }

    // Invoked when a 'task/submit' invoke activity is received for dialog submit actions.
    protected override async Task<TaskModuleResponse> OnTeamsTaskModuleSubmitAsync(ITurnContext<IInvokeActivity> turnContext, TaskModuleRequest taskModuleRequest, CancellationToken cancellationToken)
    {
        try
        {
            string skillId = (turnContext.Activity as Activity).GetSkillId();
            var skill = _skillsConfig.Skills.Where(s => s.Value.AppId == skillId).First().Value;

            // Forward request to correct skill
            var invokeResponse = await _skillHttpClient.PostActivityAsync(this._appId, skill, _skillsConfig.SkillHostEndpoint, turnContext.Activity as Activity, cancellationToken).ConfigureAwait(false);

            return invokeResponse.GetTaskModuleRespose();
        }
        catch (Exception exception)
        {
            await turnContext.SendActivityAsync(_templateEngine.GenerateActivityForLocale("ErrorMessage"));
            _telemetryClient.TrackException(exception);

            return null;
        }
    }

Darüber hinaus müssen Sie alle Skilldomänen in den Abschnitt der validDomainsApp-Manifestdatei des virtuellen Assistenten einschließen, damit dialoge, die über einen Skill aufgerufen werden, ordnungsgemäß gerendert werden.

Umgang mit App-Bereichen für die Zusammenarbeit

Microsoft Teams-Apps können in mehreren Bereichen genutzt werden, einschließlich 1:1-Chats, Gruppenchats und Kanälen. Die Kernvorlage des virtuellen Assistenten ist für 1:1-Chats konzipiert. Im Rahmen des Onboardings fordert der virtuelle Assistent die Benutzer zur Eingabe des Namens auf und behält den Benutzerstatus bei. Da das Onboarding nicht für Gruppenchat- oder Kanalbereiche geeignet ist, wurde sie entfernt.

Skills sollten Aktivitäten in mehreren Bereichen verarbeiten, z. B. in 1:1-Chats, Gruppenchats und Kanalunterhaltungen. Wenn einer dieser Bereiche nicht unterstützt wird, müssen Skills mit einer entsprechenden Nachricht antworten.

Die folgenden Verarbeitungsfunktionen wurden dem Kern des virtuellen Assistenten hinzugefügt:

  • Der virtuelle Assistent kann ohne Textnachricht aus einem Gruppenchat oder Kanal aufgerufen werden.
  • Artikulationen werden vor dem Senden der Nachricht an das Versandmodul bereinigt. Entfernen Sie z. B. die erforderliche @mention des Bots.
    if (innerDc.Context.Activity.Conversation?.IsGroup == true)
    {
        // Remove bot atmentions for teams/groupchat scope
        innerDc.Context.Activity.RemoveRecipientMention();

        // If bot is invoked without any text, reply with FirstPromptMessage
        if (string.IsNullOrWhiteSpace(innerDc.Context.Activity.Text))
        {
            await innerDc.Context.SendActivityAsync(_templateEngine.GenerateActivityForLocale("FirstPromptMessage"));
            return EndOfTurn;
        }
    }

Umgang mit Nachrichtenerweiterungen

Die Befehle für eine Nachrichtenerweiterung werden in Ihrer App-Manifestdatei deklariert. Die Benutzeroberfläche der Nachrichtenerweiterung wird von diesen Befehlen unterstützt. Damit ein virtueller Assistent einen Nachrichtenerweiterungsbefehl als angefügten Skill ausführen kann, muss das Manifest des virtuellen Assistenten bereits diese Befehle enthalten. Sie müssen die Befehle aus dem Manifest eines einzelnen Skills dem Manifest des virtuellen Assistenten hinzufügen. Die Befehls-ID stellt Informationen zu einem zugeordneten Skill bereit, indem die App-ID des Skills über ein :-Trennzeichen angefügt wird.

Im folgenden Abschnitt ist der Codeausschnitt aus der Manifestdatei eines Skills dargestellt:

 "composeExtensions": [
    {
        "botId": "<Skil_App_Id>",
        "commands": [
            {
                "id": "searchQuery",
                "context": [ "compose", "commandBox" ],
                "description": "Test command to run query",
                 ....}
         ]
     }
 ]

Im folgenden Abschnitt ist der entsprechende Codeausschnitt aus der Manifestdatei des virtuellen Assistenten dargestellt:

 "composeExtensions": [
    {
        "botId": "<VA_App_Id>",
        "commands": [
            {
                "id": "searchQuery:<skill_id>",
                "context": [ "compose", "commandBox" ],
                "description": "Test command to run query",
                 ....}
         ]
     }
 ]

Nachdem die Befehle von einem Benutzer aufgerufen wurden, kann der virtuelle Assistent einen zugeordneten Skill identifizieren, indem er die Befehls-ID analysiert, die Aktivität aktualisieren, indem er das zusätzliche Suffix :<skill_id> aus der Befehls-ID entfernt und an den entsprechenden Skill weiterleitet. Der Code für einen Skill muss das zusätzliche Suffix nicht verarbeiten. Somit werden Konflikte zwischen Befehls-IDs von Skills vermieden. Bei diesem Ansatz werden alle Such- und Aktionsbefehle eines Skills in allen Kontexten, z. B. compose, CommandBox und message, von einem virtuellen Assistenten unterstützt.

    const string MessagingExtensionCommandIdSeparator = ":";

    // Invoked when a 'composeExtension/submitAction' invoke activity is received for a messaging extension action command
    protected override async Task<MessagingExtensionActionResponse> OnTeamsMessagingExtensionSubmitActionAsync(ITurnContext<IInvokeActivity> turnContext, MessagingExtensionAction action, CancellationToken cancellationToken)
    {
        return await ForwardMessagingExtensionActionCommandActivityToSkill(turnContext, action, cancellationToken);
    }

    // Forwards invoke activity to right skill for messaging extension action commands.
    private async Task<MessagingExtensionActionResponse> ForwardMessagingExtensionActionCommandActivityToSkill(ITurnContext<IInvokeActivity> turnContext, MessagingExtensionAction action, CancellationToken cancellationToken)
    {
        var skillId = ExtractSkillIdFromMessagingExtensionActionCommand(turnContext, action);
        var skill = _skillsConfig.Skills.Where(s => s.Value.AppId == skillId).First().Value;
        var invokeResponse = await _skillHttpClient.PostActivityAsync(this._appId, skill, _skillsConfig.SkillHostEndpoint, turnContext.Activity as Activity, cancellationToken).ConfigureAwait(false);

        return invokeResponse.GetMessagingExtensionActionResponse();
    }

    // Extracts skill Id from messaging extension command and updates activity value
    private string ExtractSkillIdFromMessagingExtensionActionCommand(ITurnContext<IInvokeActivity> turnContext, MessagingExtensionAction action)
    {
        var commandArray = action.CommandId.Split(MessagingExtensionCommandIdSeparator);
        var skillId = commandArray.Last();

        // Update activity value by removing skill id before forwarding to the skill.
        var activityValue = JsonConvert.DeserializeObject<MessagingExtensionAction>(turnContext.Activity.Value.ToString());
        activityValue.CommandId = string.Join(MessagingExtensionCommandIdSeparator, commandArray, 0 commandArray.Length - 1);
        turnContext.Activity.Value = activityValue;

        return skillId;
    }

Einige Nachrichtenerweiterungsaktivitäten enthalten die Befehls-ID nicht. Beispielsweise enthält composeExtensions/selectItem nur den Wert der Aktion zum Aufrufen von Tippen. Um den zugeordneten Skill zu identifizieren, skillId wird an jede Elementkarte angefügt, während eine Antwort für OnTeamsMessagingExtensionQueryAsyncerstellt wird. Dies ähnelt dem Ansatz zum Hinzufügen adaptiver Karten zu Ihrem virtuellen Assistenten.

    // Invoked when a 'composeExtension/selectItem' invoke activity is received for compose extension query command.
    protected override async Task<MessagingExtensionResponse> OnTeamsMessagingExtensionSelectItemAsync(ITurnContext<IInvokeActivity> turnContext, JObject query, CancellationToken cancellationToken)
    {
        var data = JsonConvert.DeserializeObject<SkillCardActionData>(query.ToString());
        var skill = _skillsConfig.Skills.Where(s => s.Value.AppId == data.SkillId).First().Value;
        var invokeResponse = await _skillHttpClient.PostActivityAsync(this._appId, skill, _skillsConfig.SkillHostEndpoint, turnContext.Activity as Activity, cancellationToken).ConfigureAwait(false);

        return invokeResponse.GetMessagingExtensionResponse();
    }

Beispiel

Das folgende Beispiel zeigt, wie Die App-Vorlage "Raum buchen" in einen Skill "Virtueller Assistent" konvertiert wird: "Raum buchen" ist ein Team, mit dem Benutzer ab der aktuellen Zeit schnell einen Besprechungsraum für 30, 60 oder 90 Minuten suchen und reservieren können. Die Standarddauer beträgt 30 Minuten. Der "Raum buchen"-Bot ist auf persönliche bzw. 1:1-Unterhaltungen beschränkt. Die folgende Abbildung zeigt einen virtuellen Assistenten mit einem "Raum buchen"-Skill:

Screenshot: Virtueller Assistent mit einem Skill zum Buchen eines Raums

Es folgen die Deltaänderungen, die eingeführt wurden, um sie in einen Skill zu konvertieren, der an einen virtuellen Assistenten angefügt ist. Ähnliche Ansätze werden befolgt, um vorhandene v4-Bots in Skills umzuwandeln.

Skillmanifest

Ein Skillmanifest ist eine JSON-Datei, die den Messaging-Endpunkt, die ID, den Namen und andere relevante Metadaten eines Skills enthält. Dieses Manifest unterscheidet sich von dem Manifest, das für den Upload benutzerdefinierter Apps in Teams verwendet wird. Ein virtueller Assistent erfordert einen Pfad zu dieser Datei als Input zum Anfügen eines Skills. Wir haben dem Ordner wwwroot des Bots das folgende Manifest hinzugefügt.

botskills connect --remoteManifest "<url to skill's manifest>" ..

{
  "$schema": "https://schemas.botframework.com/schemas/skills/skill-manifest-2.1.preview-0.json",
  "$id": "microsoft_teams_apps_bookaroom",
  "name": "microsoft-teams-apps-bookaroom",
  "description": "microsoft-teams-apps-bookaroom description",
  "publisherName": "Your Company",
  "version": "1.1",
  "iconUrl": "<icon url>",
  "copyright": "Copyright (c) Microsoft Corporation. All rights reserved.",
  "license": "",
  "privacyUrl": "<privacy url>",
  "endpoints": [
    {
      "name": "production",
      "protocol": "BotFrameworkV3",
      "description": "Production endpoint for the skill",
      "endpointUrl": "<endpoint url>",
      "msAppId": "skill app id"
    }
  ],
  "dispatchModels": {
    "languages": {
      "en-us": [
        {
          "id": "microsoft-teams-apps-bookaroom-en",
          "name": "microsoft-teams-apps-bookaroom LU (English)",
          "contentType": "application/lu",
          "url": "file://book-a-meeting.lu",
          "description": "English language model for the skill"
        }
      ]
    }
  },
  "activities": {
    "message": {
      "type": "message",
      "description": "Receives the users utterance and attempts to resolve it using the skill's LU models"
    }
  }
}

LUIS-Integration

Das Versandmodell des virtuellen Assistenten basiert auf den LUIS-Modellen der angefügten Skills. Das Versandmodell identifiziert die Absicht für jede Textaktivität und ermittelt die damit verbundenen Skills.

Der virtuelle Assistent erfordert das LUIS-Modell eines Skills im .lu-Format als Input beim Anfügen eines Skills. LUIS-JSON-Code wird mithilfe des Botframework-cli-Tools in das .lu Format konvertiert.

botskills connect --remoteManifest "<url to skill's manifest>" --luisFolder "<path to the folder containing your Skill's .lu files>" --languages "en-us" --cs

npm i -g @microsoft/botframework-cli
bf luis:convert --in <pathToLUIS.json> --out <pathToLuFile>

Der "Raum buchen"-Bot verfügt über zwei Hauptbefehle für Benutzer:

  • Book room
  • Manage Favorites

Wir haben ein LUIS-Modell mit Verständnis der beiden Befehle erstellt. Entsprechende geheime Schlüssel müssen in cognitivemodels.json aufgefüllt werden. Die entsprechende LUIS-JSON-Datei finden Sie hier. Die entsprechende .lu-Datei ist im folgenden Abschnitt dargestellt:

> ! Automatically generated by [LUDown CLI](https://github.com/Microsoft/botbuilder-tools/tree/master/Ludown), Tue Mar 31 2020 17:30:32 GMT+0530 (India Standard Time)

> ! Source LUIS JSON file: book-a-meeting.json

> ! Source QnA TSV file: Not Specified

> ! Source QnA Alterations file: Not Specified


> # Intent definitions

## BOOK ROOM
- book a room
- book room
- please book a room
- reserve a room
- i want to book a room
- i want to book a room please
- get me a room please
- get me a room


## MANAGE FAVORITES
- manage favorites
- manage favorite
- please manage my favorite rooms
- manage my favorite rooms please
- manage my favorite rooms
- i want to manage my favorite rooms

## None


> # Entity definitions


> # PREBUILT Entity definitions


> # Phrase list definitions


> # List entities

> # RegEx entities

Bei diesem Ansatz wird jeder Befehl an den virtuellen Assistenten im Zusammenhang mit book room oder manage favorites, der von einem Benutzer ausgegeben wird, als ein dem Book-a-room-Bot zugeordneter Befehl identifiziert und an diesen Skill weitergeleitet. Auf der anderen Seite muss der Bot das LUIS-Modell verwenden, Book-a-room room um diese Befehle zu verstehen, wenn sie nicht vollständig eingegeben sind. Zum Beispiel: I want to manage my favorite rooms.

Unterstützung mehrerer Sprachen

Als Beispiel wird ein LUIS-Modell mit ausschließlicher Unterstützung der englischen Sprache erstellt. Sie können LUIS-Modelle für andere Sprachen erstellen und einen Eintrag zu cognitivemodels.json hinzufügen.

{
  "defaultLocale": "en-us",
  "languageModels": {
    "en-us": {
      "luisAppId": "",
      "luisApiKey": "",
      "luisApiHost": ""
    },
    "<your_language_culture>": {
      "luisAppId": "",
      "luisApiKey": "",
      "luisApiHost": ""
    }
  }
}

Fügen Sie parallel die entsprechende .lu-Datei im luisFolder-Pfad hinzu. Die Ordnerstruktur sollte wie folgt aussehen:

| - luisFolder

        | - en-us

                | - book-a-meeting.lu

        | - your_language_culture

                | - book-a-meeting.lu

Aktualisieren Sie den Befehl bot skills wie folgt, um den Parameter zu ändern languages :

botskills connect --remoteManifest "<url to skill's manifest>" --luisFolder "<path to luisFolder>" --languages "en-us, your_language_culture" --cs

Der virtuelle Assistent verwendet SetLocaleMiddleware, um das aktuelle Gebietsschema zu identifizieren und das entsprechende Versandmodell aufzurufen. Die Bot-Framework-Aktivität verfügt über ein Gebietsschemafeld, das von dieser Middleware verwendet wird. Sie können dies auch für Ihre Skills verwenden. Der Book-a-Room-Bot verwendet diese Middleware nicht und ruft stattdessen das Gebietsschema aus der ClientInfo-Entität der Bot Framework-Aktivität ab.

Anspruchsüberprüfung

Wir haben claimsValidator hinzugefügt, um Aufrufer auf den Skill einzuschränken. Damit ein virtueller Assistent diese Skills aufrufen kann, füllen Sie das AllowedCallers-Array aus appsettings mit der App-ID dieses bestimmten virtuellen Assistenten auf.

"AllowedCallers": [ "<caller_VA1_appId>", "<caller_VA2_appId>" ],

Das Array der zulässigen Aufrufer kann einschränken, welche Skills-Nutzer auf einen Skill zugreifen können. Fügen Sie diesem Array einen einzelnen Eintrag * hinzu, um Aufrufe von allen Skill-Nutzern anzunehmen.

"AllowedCallers": [ "*" ],

Weitere Informationen zum Hinzufügen der Anspruchsüberprüfung zu einem Skill finden Sie unter Hinzufügen der Anspruchsüberprüfung zu Skills.

Einschränkung der Kartenaktualisierung

Das Aktualisieren von Aktivitäten, z. B. die Kartenaktualisierung, wird über den virtuellen Assistenten noch nicht unterstützt (GitHub-Problem). Daher haben wir alle Kartenaktualisierungsanrufe UpdateActivityAsync durch das Posten neuer Kartenanrufe SendActivityAsyncersetzt.

Kartenaktionen und Dialogflows

Um Kartenaktionen oder Dialogaktivitäten an einen zugeordneten Skill weiterzuleiten, muss der Skill darin eingebettet skillId werden. Book-a-room Bot-Kartenaktion, Dialogabruf- und Sendeaktionsnutzlasten werden so geändert, dass sie als Parameter enthalten skillId .

Weitere Informationen finden Sie unter Hinzufügen adaptiver Karten zu Ihrem virtuellen Assistenten.

Verarbeiten von Aktivitäten aus dem Gruppenchat- oder Kanalbereich

Book-a-room bot ist nur für private Chats wie persönliche oder 1:1-Bereiche konzipiert. Da wir den virtuellen Assistenten angepasst haben, um Gruppenchat- und Kanalbereiche zu unterstützen, muss er aus den Kanalbereichen aufgerufen werden, und daher muss der Book-a-room-Bot Aktivitäten für denselben Bereich abrufen. Daher ist der Book-a-room-Bot angepasst, um diese Aktivitäten zu behandeln. Sie finden die Check-in-OnMessageActivityAsync-Methoden des Aktivitätshandlers des Book-a-room-Bots.

    protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
    {
        // Check if activities are from groupchat/ teams scope. This might happen when the bot is consumed by Virtual Assistant.
        if (turnContext.Activity.Conversation.IsGroup == true)
        {
            await ShowNotSupportedInGroupChatCardAsync(turnContext).ConfigureAwait(false);
        }
        else
        {
            ...
        }
    }

Sie können auch vorhandene Skills aus dem Bot Framework Solutions-Repository verwenden oder einen neuen Skill ganz von Grund auf neu erstellen. Informationen zum Erstellen eines neuen Skills finden Sie in den Lernprogrammen zum Erstellen neuer Skills. Die Dokumentation zur Architektur des virtuellen Assistenten und skills finden Sie unter Virtual Assistant and skills architecture (Architektur des virtuellen Assistenten und Skills).

Einschränkungen von virtuellen Assistenten

  • EndOfConversation: Ein Skill muss eine endOfConversation-Aktivität senden, wenn er eine Unterhaltung beendet. Basierend auf der Aktivität beendet ein virtueller Assistent den Kontext mit diesem bestimmten Skill und kehrt zum eigenen Stammkontext zurück. Für den Bot "Raum buchen" gibt es keinen eindeutigen Zustand, in dem die Konversation beendet wird. Daher haben wir nicht vom Book-a-room Bot gesendetendOfConversation, und wenn Benutzer zum Stammkontext zurückkehren möchten, können sie dies per start over Befehl tun.
  • Kartenaktualisierung: Die Kartenaktualisierung wird über den virtuellen Assistenten noch nicht unterstützt.
  • Nachrichtenerweiterungen:
    • Ein virtueller Assistent kann maximal 10 Befehle für Nachrichtenerweiterungen unterstützen.
    • Die Konfiguration von Nachrichtenerweiterungen ist nicht auf einzelne Befehle, sondern auf die gesamte Erweiterung selbst ausgerichtet. Dadurch wird die Konfiguration für jeden einzelnen Skill durch den virtuellen Assistenten beschränkt.
    • Nachrichtenerweiterungen-Befehls-IDs haben eine maximale Länge von 64 Zeichen, und zum Einbetten von Skillinformationen werden 37 Zeichen verwendet. Daher sind aktualisierte Einschränkungen für die Befehls-ID auf 27 Zeichen beschränkt.

Sie können auch vorhandene Skills aus dem Bot Framework Solutions-Repository verwenden oder einen neuen Skill ganz von Grund auf neu erstellen. Lernprogramme für später finden Sie hier. Weitere Informationen finden Sie in der Dokumentation zur Architektur des virtuellen Assistenten und der Qualifikationen.

Codebeispiel

Beispielname Beschreibung .NET
Aktualisierte Visual Studio-Vorlage Angepasste Vorlage zur Unterstützung von Microsoft Teams-Funktionen Anzeigen
"Raum buchen"-Bot-Skillcode Ermöglicht Ihnen, unterwegs schnell einen Besprechungsraum zu finden und zu buchen. Anzeigen

Siehe auch