---

Dezember 2016

Band 31, Nummer 13

Microsoft Bot Framework: Nutzen von Bot Framework für den zeit- und ortsunabhängigen Zugriff auf Anwendungsdaten

Von Srikantan Sankaran

In der letzten Ausgabe habe ich Microsoft Bot Framework vorgestellt und erläutert, wie Sie dieses nutzen können, um einer Herausforderung zu begegnen, mit der zahlreiche Organisationen heutzutage konfrontiert sind: dem interaktiven Kundenzugriff auf ihre Dienste über Sprache und Text (msdn.com/magazine/mt788623). Im Artikel habe ich ein Geschäftsszenario beschrieben, in dem Informationen aus verschiedenen branchenspezifischen Anwendungen mithilfe von Technologien wie Microsoft Flow und Azure Logic Apps konsolidiert werden mussten, die bei einer Versicherungsanbieterorganisation bereitgestellt werden. Der Inhalt, der aus strukturierten und unstrukturierten Daten besteht, wird mithilfe von Azure Search indiziert und dann für die Nutzung durch Clientanwendungen bereitgestellt.

Abbildung 1 (bereits im vorherigen Artikel enthalten) zeigt die Architektur der Lösung, die das Szenario implementiert.

Abbildung 1: Architektur der Lösung

In diesem Artikel erstelle ich eine Bot-Anwendung, die die über Azure Search erfassten Informationen nutzen kann, und stelle diese Anwendung bereit. Die Bot-Anwendung wird als Azure-Web-App bereitgestellt und über den Microsoft Bot Framework-Connectordienst veröffentlicht. Über den Connectordienst wird auf die Bot-Anwendung aus dem Skype-Kanal zugegriffen. Auf diese Weise erhalten Kunden Zugriff auf den Status ihrer Versicherungspolicenanforderungen und können die ausgestellten Policendokumente herunterladen, Termine für Standortinspektionen planen usw. Kunden identifizieren sich beim Bot mithilfe des Microsoft-Kontos, mit dem sie sich beim Beantragen einer Versicherungspolice registriert haben, und sie können Messaging auf dem Skype-Client oder Sprachbefehle zum Interagieren mit dem Bot verwenden. Die Bot-Anwendung ist in den LUIS-Dienst integriert (einen von mehreren in Azure Cognitive Services verfügbaren Diensten), um Unterhaltungen mit dem Kunden interpretieren zu können, damit Abfragen für Azure Search ausgeführt werden können.

Die zum Erstellen der Lösung erforderlichen Schritte werden im Folgenden erläutert. Die Codeausschnitte stammen aus der Visual Studio 2015-Projektmappe, die mit diesem Artikel heruntergeladen werden kann. Sie sollten folgendermaßen vorgehen, wenn Sie dieses Beispiel nachvollziehen möchten:

• Erstellen und veröffentlichen Sie ein LUIS-Modell, das die verschiedenen Unterhaltungen erfasst, die im Bot unterstützt werden müssen. Verwenden Sie zu diesem Zweck die vom LUIS-Dienst bereitgestellte Benutzeroberfläche.
• Verwenden Sie die Visual Studio 2015-Vorlage zum Erstellen einer neuen Bot-Anwendung. Anschließend können Sie die Codeblöcke aus der mit diesem Artikel bereitgestellten Projektmappe hinzufügen oder den restlichen Artikel anhand der heruntergeladenen Projektmappendatei nachvollziehen. Die Datei „MessageController.cs“ ist der Einstiegspunkt in die Bot-Anwendung, bei der es sich um einen besonderen Typ einer .NET MVC-Anwendung handelt.
• Betten Sie die LUIS-Funktionen mithilfe des LUIS-Dialogfelds in den Bot ein, das im Bot Framework SDK verfügbar ist. Dies wird in der Projektmappe in der Datei „PolicyInfoDialog.cs“ implementiert.
• Implementieren Sie mithilfe des Azure Search SDKs Code, der die Azure Search-APIs aufruft, und führen Sie die vom LUIS-Dienst interpretierten Suchanforderungen aus. Dies wird in der Projektmappe in der Datei „SearchService.cs“ implementiert.
• Implementieren Sie ein Dialogfeld „FormFlow“ zum interaktiven Erfassen des Microsoft-Kontos des Benutzers im Skype-Kanal, wenn eine Benutzeranforderung erstmals erfolgt. Dies wird in der begleitenden Projektmappe in der Datei „SigninForm.cs“ implementiert.
• Verwenden Sie das Azure Search SDK zum Abrufen der Benutzerprofilinformationen aus der Basis des Microsoft-Kontos, das erfasst wird, wenn der Benutzer erstmals auf den Bot zugreift. Dies wird ebenfalls in der Datei „SearchService.cs“ implementiert.
• Verwenden Sie den Bot-Zustandsdienst, um die Benutzerprofilinformationen beizubehalten. Die Adresse und die Kontaktinformationen des Bot-Benutzers, die im Bot-Zustandsdienst gespeichert sind, werden beim Planen einer Standortinspektion verwendet. Dies wird ebenfalls in der Datei „PolicyInfoDialog.cs“ implementiert.
• Testen Sie die Bot-Anwendung, indem Sie sie lokal als Dienst auf Ihrem Entwicklungscomputer ausführen, und verwenden Sie den Bot Framework-Kanalemulator, um die Benutzerinteraktion mit dem Dienst zu bewerten.
• Nachdem Sie die Bot-Anwendung lokal getestet haben, stellen Sie sie in einer Web-App in Azure direkt aus Visual Studio bereit.
• Registrieren Sie die Bot-Anwendung beim Microsoft Bot Framework-Connectordienst, und konfigurieren Sie in ihm die URL der in Azure bereitgestellten Bot-Anwendung.
• Fügen Sie den Namen der Bot-Anwendung, die App-ID und die geheimen Informationen des Bots, die während der Registrierung abgerufen wurden, in der Visual Studio-Projektmappe hinzu, und veröffentlichen Sie die Anwendung dann erneut in Azure.
• Aktivieren Sie die Bot-Anwendung im Bot-Entwicklerportal für den Zugriff aus Kanälen wie Skype und Slack.

Sie können die Visual Studio 2015-Projektmappe für die Bot-Anwendung sowie einen Dateiexport des in dieser Anwendung verwendeten LUIS-Modells aus dem GitHub-Repository unter bit.ly/2cOfANh herunterladen.

Erstellen und Trainieren des LUIS-Modells für andere Anwendungsfallszenarien

Abbildung 2 zeigt eine Aufstellung, wie sich ein Benutzer potenziell (über eine LUIS-Äußerung) mit dem Bot unterhalten kann und wie dies als bestimmter LUIS-Intent oder bestimmte -Aktion interpretiert werden sollte, die über Azure Search ausgeführt wird. Außerdem wird gezeigt, wie Schlüsselwörter(LUIS-Entitäten) aus der LUIS-Äußerung extrahiert werden, damit sie als Abfrageparameter beim Ausführen der Suche verwendet werden können.

Abbildung 2: Zuordnen von Äußerungen und Intents

Äußerungen oder Unterhaltung	Zugeordnete Intents oder Aktionen	Qualifizierer oder Parameter
Etwas, das LUIS nicht interpretieren kann (oder für das kein Training stattgefunden hat).	Keine (Standard)	Nicht anwendbar
Abrufen (oder Anzeigen) aller Policenanforderungen.	GetPolicyRequests	Implizit für angemeldeten Bot-Benutzer
Ich verfüge über eine Policenanforderungsanwendung oder ist meine Policenanforderung genehmigt?	GetPendingPolicyRequests	Implizit für Policenanforderungen, die einen anderen Status als „Genehmigt“ aufweisen
Abrufen der Details der Policenanforderungsnummer „VehPolicy001“.	GetPolicyRequestDetails	Policenanforderungs-ID: „VehPolicy001“
Abrufen des Status meiner Lebensversicherungs-Policenanforderung.	GetPolicyRequestStatusByType	Policenanforderungstyp: Lebensversicherung
Abrufen der in diesem Jahr ausgestellten Policendokumentnummer „Policy0101“.	GetPolicyDocument	Dateiname („Policy0101“ und „lastmoddate“): aktuelles Jahr
Planen einer Standortinspektion für morgen.	ScheduleSiteVisit	Inspektionsdatum: morgen

Der LUIS-Dienst stellt unter „luis.ai“ eine Webanwendung bereit, in der visuell ein LUIS-Anwendungsmodell für das vorliegende Problem erstellt werden kann. Abbildung 3 zeigt das für dieses Szenario konfigurierte LUIS-Modell.

Abbildung 3: Das LUIS-Modell für mein Szenario

 Die im vorherigen Schritt identifizierten Intents, Entitäten und Äußerungen können alle in der LUIS-Anwendung erstellt werden. Verwenden Sie das Menü „Intents“ zum Hinzufügen der Intents und das Menü „Entitäten“ zum Erstellen der Entitäten. Beachten Sie, dass zwei spezielle Arten von Entitäten vorhanden sind:

• Hierarchische Entitäten: In diesem Fall wird die „Versicherungspolice“ als eine hierarchische Entität (das übergeordnete Element) mit den verschiedenen Typen (Lebensversicherung, KFZ-Versicherung, Gebäudeversicherung usw.) als untergeordnete Elemente erstellt.
• Vorab erstellte Entitäten: Ich habe eine vorab erstellte, von LUIS bereitgestellte Entität namens „Datetime“ verwendet. Eingabeparameter (z. B. das Jahr, in dem ein Policendokument generiert wurde, oder das Datum einer geplanten Standortinspektion) werden vom LUIS-Modul diesen vorab erstellten Entitätstypen zugeordnet.

Die Entität mit dem Namen „Keyword” wird zum Ausführen einer Volltextsuche im Policendokumentindex in Azure Search verwendet.

Wählen Sie nun die Registerkarte „Neue Äußerungen“ aus, und erstellen Sie Äußerungen für jede der zuvor identifizierten Unterhaltungen. Benennen Sie diese.

Identifizieren und benennen Sie für jede Äußerung den Intent sowie die zugehörigen Entitäten. In Abbildung 3 habe ich beispielsweise die Äußerung „get me the status of my life insurance policy request” (rufe den Status meiner Lebensversicherungs-Policenanforderung ab) dem Intent „GetPolicyRequestStatusByType“ und den Text „Life Insurance” (Lebensversicherung) der hierarchischen Entität „Insurance:life” zugeordnet.

Wiederholen Sie diesen Schritt, um weitere Varianten hinzuzufügen, z. B. für die Policentypen „KFZ“, „Gebäude“ oder „Allgemein“. Ziehen Sie außerdem Varianten in Betracht, bei denen die gleiche Anforderung auf andere Weise vorgenommen wird. Sie müssen jedoch nicht jede Permutation und Kombination erfassen, in der der gleiche Inhalt ggf. übermittelt wird. Wenn ich z. B. eine neue Äußerung mit der Formulierung „show me the status...“ (zeige den Status...an) hinzufüge, kann LUIS diese direkt als eine Variante der vorherigen Äußerung “get me the status….” (rufe den Status...ab) interpretieren. Abbildung 4 zeigt dies. LUIS hat die richtigen Vorschläge hinsichtlich des Intents und der zugehörigen Entitäten gemacht, obwohl die Frage auf eine andere Weise gestellt wurde.

Abbildung 4: Benennen von LUIS-Äußerungen und Verarbeiten von Variationen

Nachdem jede Äußerung erfasst wurde, stellt die LUIS-Anwendung eine Option zum Trainieren des Modells zur Verfügung. Das Ergebnis besteht darin, dass das AI-Modul in LUIS optimierte Modelle generiert, die anschließend von Clientanwendungen verwendet werden können. Dieser Schritt sollte bei jedem Benennen neuer Äußerungen bzw. Vornehmen von Änderungen vorhandener Äußerungen wiederholt werden.

Wenn Sie das LUIS-Modell veröffentlichen, können clientseitige Anwendungen das Modell mithilfe einer REST-API aufrufen. Über das Veröffentlichungsdialogfeld in der Anwendung können Sie das Modell auch testen, um sicherzustellen, dass es wie erwartet arbeitet. Abbildung 5 zeigt, wie das LUIS-Modell schnell getestet werden kann, indem eine Formulierung einer Unterhaltung übergeben und die Ausgabe dann im Browser angezeigt wird. (Aus Gründen der besseren Vergleichbarkeit zeigt Abbildung 5 die Momentaufnahmen aus drei verschiedenen Aufrufen von Äußerungen und die jeweiligen Ergebnisse nebeneinander.)

Abbildung 5: Testen des LUIS-Modells

Beachten Sie, dass dem von LUIS empfohlenen Intent der maximale Wahrscheinlichkeitswert zugewiesen ist, und er wird als erstes Element in der Liste angezeigt. Die aus dem Ausdruck extrahierten Entitäten werden ebenfalls in der Antwort zurückgegeben. Wenn in der Äußerung mehrere Entitäten identifiziert werden, werden auch diese zurückgegeben. Sie können erkennen, wie das LUIS-Modell Begriffe wie „this year” (dieses Jahr) in der Äußerung interpretiert, diese einer vorab erstellten Entität „Datetime” zuordnet und dann den Wert „2016” zurückgibt, den die Clientanwendung direkt verwenden kann.

Erstellen der Bot-Anwendung

Da das LUIS-Modell nun bereit ist, kann es in einer Bot-Anwendung verwendet werden. Laden Sie die Visual Studio 2015-Vorlage von aka.ms/bf-bc-vstemplate herunter, um die Anwendung zu erstellen. (Besuchen Sie bit.ly/2dYrwyW, um die Grundlagen zum Erstellen einer Bot-Anwendung sowie zum Verwenden eines Bot-Emulators zum Erstellen und lokalen Testen des Bots zu erlernen.)

Das mithilfe dieser Vorlage erstellte Projekt ist eine Variante eines MVC-Projekts. Der Einstiegspunkt in das Projekt ist „MessageController.cs“. Diese Datei verarbeitet eingehende Nachrichten aus Kanälen wie Skype oder Slack und sendet die Antworten zurück.

„LUISDialog“ für das Bot Framework wird zum impliziten Übergeben von Nachrichten vom Bot an das LUIS-Modell verwendet. Für jeden der im LUIS-Modell implementierten Intents wird eine entsprechende Methode implementiert, die direkt aufgerufen werden kann, wenn die Bot-Anwendung ausgeführt wird. Auf diese Weise muss kein benutzerdefinierter Code für den Aufruf der LUIS-REST-APIs zum Interpretieren der Unterhaltung und zum Identifizieren des Intents und der Entitäten bereitgestellt werden.

Die ID der LUIS-Anwendung und die geheimen Werte werden als Decorator für die Attribute auf Klassenebene („LuisModel“) verwendet. Das LuisIntent-Attribut wird für die Methode verwendet, die die Implementierung für das Auftreten dieses Intents in der Benutzeranforderung bereitstellt. Mehr ist nicht erforderlich, um die LUIS-Integration im Bot bereitzustellen. Abbildung 6 zeigt die Implementierung dieser Integration im Code.

Abbildung 6: Implementieren der LUIS-Integration

[LuisModel("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", 
  "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")]
[Serializable]
  public class PolicyInfoDialogs : LuisDialog<object>
  {
    [LuisIntent("")]
    public async Task None(IDialogContext context, LuisResult result)
    {
      // Called when the incoming utterance is not recognized (default bin)
    }
    [LuisIntent("GetPolicyRequests")]
    public async Task GetPolicyRequests(IDialogContext context, LuisResult result)
    {
      //
    }
        ----------------------
      }

An diesem Punkt kann die Implementierung in jeder der Methoden einfach sein. Ich kann einfach eine Nachricht zurückgeben, die identifiziert, welche LuisIntent-Implementierung aufgerufen wurde.

Fügen Sie in „MessageController.cs“ den folgenden Codeausschnitt hinzu, um die eingehende Nachricht vom Bot-Benutzer zu erfassen und an „LuisDialog“ zu übergeben:

if (activity.Type == ActivityTypes.Message)
  {
    await Conversation.SendAsync(activity, () => new PolicyInfoDialog());
  }

Führen Sie die Bot-Anwendung aus, und starten Sie den Bot Framework-Kanalemulator. Er kann von aka.ms/bf-bc-emulator heruntergeladen werden. Geben Sie die Äußerungen ein, für die Sie das LUIS-Modell zuvor trainiert haben, und stellen Sie sicher, dass die Antwortnachricht angibt, dass die richtige Methode, die dem LUIS-Intent zugeordnet ist, aufgerufen wurde.

Integration von Search

Nun füge ich der Visual Studio-Projektmappe das Azure Search SDK für .NET mithilfe des NuGet-Paket-Managers hinzu. Die Datei „SearchService.cs“ in der Projektmappe verwendet dieses SDK und kapselt die gesamte Integration in Azure Search Service. Sie implementiert Methoden, die Abfragen für Azure Search ausführen, das „UserProfile“ des Kunden zurückgeben und „Policy­Requests“ und „PolicyDocuments“ abrufen.

Die Search-Befehle für die verschiedenen Szenarien werden mithilfe der Lucene-Abfragesyntax erstellt, die in der Datei „PolicyInfoDialog.cs“ implementiert ist. Dazu einige Beispiele: 

Abrufen aller Policenanforderungen für den Bot-Benutzer in der Unterhaltung:

command += "CustomerId:(" + msftid + ")";
Retrieve all policy requests for the bot user that haven’t yet been approved:
command += "CustomerId:(" + msftid + ") -PolicyStatus:(Approved)";
Query policy requests for the bot user based on the policy request Id:
public async Task GetPolicyRequestDetails(IDialogContext context, LuisResult result)
  {
    ----------------------
      string  command += "CustomerId:(" + msftid + ") AND PolicyRequestId:(" +
        result.Entities[0].Entity + ")";
    ----------------------
  }

Der oben abgebildete Codeausschnitt zeigt, wie die PolicyRequestId-Entität (die Eingabeparameter zum Ausführen der Suchabfragen) an das LUIS-Modul über „LuisResult“ (Ergebnis) übergeben wird.

Abbildung 7 zeigt, wie die auf Eigenschaften basierende Suche und die Volltextsuche für Dokumente implementiert werden.

Beachten Sie, dass Sie ggf. auf meinen vorherigen Artikel zurückgreifen können, um sich über die Eigenschaftennamen und Werte im Code aus Abbildung 7 zu informieren. Sie können auch das Schema aller Tabellen mithilfe der in späteren Abschnitten bereitgestellten Links herunterladen, die in der diesen Artikel begleitenden Datenbank verwendet werden. 

Abbildung 7: Implementieren der auf Eigenschaften basierenden Suche und der Volltextsuche für Dokumente

foreach (EntityRecommendation curEntity in request.Entities)
  {
    switch (curEntity.Type)
      {
        case "PolicyNumber": // Look for documents with this filename
          {
            command += " filename:(" + request.Entities[0].Entity + ") ";
            break;
          }
        case "keyword": // Search within documents for this keyword expression
          {
            command += " " + request.Entities[0].Entity + " ";
            break;
          }
        case "builtin.datetime.date":
        // Retrieve based on the year a document was generated
          {
            char[] delimiterChars = { '.', ':' };
        List<string> allvalues = curEntity.Resolution.Values.ToList<string>();
             string val = allvalues[0];
             string[] vals = val.Split(delimiterChars);
             command += " lastmoddate:(" + vals[0] + ") ";
             break;
          }
        default:
          {
            break;
          }
        }
    }

Formatieren der Antwort an den Benutzer

Sie können den Text in der vom Bot zurückgegebenen Antwortnachricht formatieren, um Links oder Medieninhalt usw. hinzuzufügen. Auf diese Weise wird die Bot-Anwendung benutzerfreundlicher. Es folgen einige Beispiele:

Wenn Sie den Schriftschnitt nur für die von Azure Search zurückgegebenen dynamischen Daten auf Fett festlegen möchten, schließen Sie diese in doppelte Sternchen (**) ein:

foreach (SearchResult<PolicyRequest> result in eachGroup)
  {
    searchResponse += (counter) + ". **" + result.Document.PolicyRequestId + "**" +
      " on the insured :**" + result.Document.InsuredIdentifier + "**
      for an amount of :**" +
    result.Document.Currency + " " + result.Document.AssessedValue + "**
      has status: **" +
    result.Document.PolicyStatus + "**\n\n";
    counter++;
  }

Zum Hinzufügen eines Links zu einem von Azure Search zurückgegebenen Policendokument fügen Sie das Link-Attribut der URL des Dokuments hinzu:

foreach (SearchResult<PolicyDocument> result in results)
 {
   searchResponse += counter + ". Link: [" + result.Document.filename + "](" +
     result.Document.fileurl + ") \n";
   counter++;
 }

Identifizieren des Bot-Benutzers

Das Bot Framework stellt die Kanal-ID des Benutzers und den Anzeigenamen aus dem Unterhaltungskontext bereit, nicht jedoch den Benutzernamen, der zum Anmelden beim Kanal (z. B. bei Skype) verwendet wurde. Diese Informationen sollten daher explizit abgerufen werden, wenn ein Benutzer die Interaktion mit dem Bot startet. Das weiter oben beschriebene Dialogfeld „FormFlow“ wird verwendet, um den Benutzer zur Eingabe dieser Informationen aufzufordern. Die Benutzerprofilinformationen werden aus Azure Search basierend auf dem Kontonamen abgerufen.

Damit sichergestellt wird, dass der Benutzer, der mit dem Bot interagiert, der Besitzer des Microsoft-Kontonamens ist, der in „FormDialog“ freigegeben wird, können Sie eine interaktive Anmeldung in die Seite „Microsoft-Kontoanmeldung“ integrieren und erst nach der Authentifizierung und Validierung Zugriff auf den Bot erteilen. Dieser Vorgang wird in diesem Artikel jedoch nicht behandelt. Stattdessen fordern Sie den Benutzer einfach zur Eingabe des Kontonamens auf, indem Sie das Dialogfeld „SigninForm“ verwenden und davon ausgehen, dass der Benutzer keine falschen Angaben macht:

public static IForm<SigninForm> BuildForm()
  {
    return new FormBuilder<SigninForm>()
      .Message("I would need some information before we get started.")
      .Field(nameof(MicrosoftAccount))
      .Build();
  }

Speichern des Benutzerprofils im Bot-Zustand

Sobald der Benutzer zu Beginn einer Unterhaltung im Bot identifiziert wurde, wird ein Benutzerprofilobjekt aus Azure Search abgerufen. Diese Informationen werden im Bot-Zustand gespeichert, damit sie verwendet werden können, wenn der Benutzer z. B. die Planung einer Standortinspektion anfordert. Die Adresse und die Kontaktnummer des Benutzers werden während der Bestätigung des Inspektionstermins verifiziert.

Das Bot Framework stellt eine API zum Speichern dieser Informationen im privateConversationData-Kontext pro Benutzer und Unterhaltung bereit. Abbildung 8 zeigt dies.

Abbildung 8: Speichern des Benutzerprofils

private async Task SignUpComplete(IDialogContext context, IAwaitable<SigninForm> result)
  {
----------------------------------------------
----------------------------------------------
  UserProfile profile =
    await LoadBotUserState(profileIdentityForm.MicrosoftAccount);
  if (profile == null)
  {
  message = $"Sorry, I could not locate your profile in our system.
    Please retry with the right Microsoft Account";
  }
  else
  {
    context.PrivateConversationData.SetValue<bool>("ProfileComplete", true);
    context.PrivateConversationData.SetValue<string>(
      "FirstName", profile.FirstName);
    context.PrivateConversationData.SetValue<string>("LastName", profile.LastName);
    context.PrivateConversationData.SetValue<string>("Address", profile.Address);
    context.PrivateConversationData.SetValue<string>("Phone", profile.Phone);
    context.PrivateConversationData.SetValue<string>(
      "CustomerId", profile.CustomerId);
    message = $"Thanks {profile.LastName},{profile.FirstName}
      for identifying yourself! \n\n
      Let me know how I could assist you.";
  }
    await context.PostAsync(message);
  }
    context.Wait(MessageReceived);
  }

Für jede Anforderung überprüft die Bot-Anwendung den Bot-Zustand, um sicherzustellen, dass die Identität des Benutzers verifiziert wird, der die Anforderung ausgibt, und dass die Benutzerprofilinformationen verfügbar sind.

Lokales Verwenden des Bot-Kanalemulators

Für die Bot-Anwendung ist es erforderlich, dass der Azure Search-Namespace, der Zugriffsschlüssel und der Indexname zum Ausführen der Anforderungen vom Benutzer verwendet werden. Diese Parameter werden in der Datei „SearchParameters.cs“ gespeichert, und ihre Werte werden aus der Datei „web.config“ beim Ausführen der Bot-Anwendung festgelegt. Nun können Sie die Visual Studio-Projektmappe ausführen.

Starten Sie den Bot-Kanalemulator, und geben Sie die Unterhaltungen ein, für die Sie das LUIS-Modell trainiert haben. Abbildung 9 zeigt ein typisches Benutzerinteraktionsszenario. Nachdem die Bot-Anwendung erfolgreich in der lokalen Umgebung ausgeführt wird, kann sie in einer Azure-Web-App veröffentlicht werden.

Abbildung 9: Ausführen des Bots aus einem Emulator

Bereitstellen des Bots in Azure

Erstellen Sie im Azure-Portal eine Web-App in Azure. Fügen Sie dann in den Anwendungseinstellungen die appSetting-Schlüssel und -Werte aus der Datei „web.config“ in der Visual Studio-Projektmappe hinzu.

Bevor Sie die Bot-Anwendung in einer Azure-Web-App veröffentlichen, müssen Sie diesen Bot unter dev.botframework.com/bots/new registrieren. Durch diesen Vorgang werden eine Bot-ID, eine Microsoft-App-ID und ein geheimer Schlüssel generiert. Fügen Sie diese Werte der Datei „web.config“ der Bot-Anwendung in Visual Studio 2015 hinzu, und veröffentlichen Sie diese App erneut in Azure.

Verwenden Sie während des Registrierungsvorgangs für den URL-Umleitungsparameter die für SSL aktivierte URL der Bot-Anwendung in Azure mit dem Suffix „/api/messages“.

Kanalübergreifendes Aktivieren des Bots

Sie können den Bot in der Bot-Registrierung unter dev.botframework.com/bots für andere Kanäle aktivieren. Abbildung 10 zeigt die Bot-Anwendung, die für die Kanäle Skype und Slack aktiviert wurde. Für das Aktivieren der Bot-Anwendung für Slack sind einige zusätzliche Schritte erforderlich. Wenn Sie den Bot diesem Kanal hinzufügen möchten, wird ein Assistent gestartet, der Sie bei den erforderlichen Schritten unterstützt.

Abbildung 10: Registrieren des Bots für mehrere Kanäle

Abbildung 11 zeigt die Bot-Anwendung, wenn auf sie aus Skype zugegriffen wird.

Abbildung 11: Zugreifen auf den Bot aus Skype

Zusammenfassung

Das Microsoft Bot Framework und andere unterstützende Technologien wie LUIS und Azure Search stellen ein geeignetes Fundament zum Erstellen intuitiver Bot-Anwendungen bereit, durch die Kunden mit Ihren Branchenanwendungen interagieren können. Die Art und Weise, wie jeder dieser Dienste in die Gesamtarchitektur der Lösung passt, stellt sicher, dass die einzelnen Komponenten unabhängig voneinander reifen und verbessert werden können. Das LUIS-Modell kann z. B. für die Unterstützung weiterer Äußerungen optimiert werden, die Benutzer zum Interagieren mit dem Bot verwenden können, ohne dass Änderungen an der Bot-Kernanwendung oder dem Inhalt in Azure Search erforderlich werden. Nach der Bereitstellung kann eine Bot-Anwendung ohne weitere Codeänderungen für den Zugriff aus verschiedenen Kanälen aktiviert werden. Im Lauf der Zeit können dann weitere Kanäle hinzugefügt werden, um die Reichweite und Verwendung der Bot-Anwendung zu steigern.

---

Srikantan Sankaran ist Technical Evangelist aus dem DX-Team in Indien und lebt in Bangaluru. Er arbeitet mit zahlreichen ISVs in Indien zusammen und unterstützt sie beim Architekturentwurf und Bereitstellen ihrer Lösungen unter Microsoft Azure. Sie erreichen Ihn unter sansri@microsoft.com.

Unser Dank gilt den folgenden technischen Experten von Microsoft für die Durchsicht dieses Artikels: Sandeep Alur und Hemanth Kathuria
Sandeep Alur ist Lead Evangelist für DX India und lebt in Bengaluru.

Hemanth Kathuria ist Senior Consultant im India Services Team.