Post on 29-May-2020
transcript
Abschlussprüfung Sommer 2018
Fachinformatiker für Anwendungsentwicklung
Dokumentation zur betrieblichen Projektarbeit
Service-Bot
Entwicklung eines Chatbots zur Unterstützung des Kundenservice
Abgabetermin: 25.04.2018
Prüfungsbewerber:
Jim Eidmann
Lange Straße 52
37181 Hardegsen
Ausbildungsbetrieb: Dr. Kuhl Unternehmensberatung GmbH & Co. KG
Schmiedewiese 1
37181 Hardegsen
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann I
Inhaltsverzeichnis
Abbildungsverzeichnis
Tabellenverzeichnis
Abkürzungsverzeichnis
1. Einleitung ....................................................................................................................................... 1
1.1 Projektbeschreibung ................................................................................................................ 1
1.2 Projektziel ................................................................................................................................ 1
1.3 Projektumfeld .......................................................................................................................... 2
1.4 Projektschnittstellen ................................................................................................................ 2
1.5 Projektabgrenzung ................................................................................................................... 2
2. Projektplanung .............................................................................................................................. 3
2.1 Projektphasen .......................................................................................................................... 3
2.2 Ressourcenplanung .................................................................................................................. 3
2.3 Entwicklungsprozess ............................................................................................................... 3
3. Analysephase .................................................................................................................................. 4
3.1 Ist-Analyse............................................................................................................................... 4
3.2 Wirtschaftlichkeitsanalyse ....................................................................................................... 4
3.3 „Make or Buy“-Entscheidung ................................................................................................. 4
3.4 Projektkosten ........................................................................................................................... 4
3.5 Amortisationsdauer ................................................................................................................. 5
3.6 Nicht-monetäre Vorteile .......................................................................................................... 6
3.7 User-Storys .............................................................................................................................. 7
3.8 Lastenheft ................................................................................................................................ 7
4. Entwurfsphase ............................................................................................................................... 7
4.1 Zielplattform ............................................................................................................................ 7
4.2 Softwarearchitektur ................................................................................................................. 7
4.3 Produktumgebung ................................................................................................................... 8
4.4 Datenmodell ............................................................................................................................ 9
4.5 Pflichtenheft .......................................................................................................................... 10
5. Implementierungsphase .............................................................................................................. 10
5.1 Iterationsplanung ................................................................................................................... 10
5.2 Implementierung der Datenstrukturen ................................................................................... 10
5.3 Einrichtung der Entwicklungsumgebung .............................................................................. 10
5.4 Implementierung der Services ............................................................................................... 11
5.5 Implementierung der Konversationslogik ............................................................................. 13
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann II
6. Abnahme- und Einführungsphase ............................................................................................. 14
6.1 Abnahme durch die Service-Abteilung ................................................................................. 14
6.2 Veröffentlichung und Einführung ......................................................................................... 14
6.3 Dokumentation ...................................................................................................................... 14
7. Fazit .............................................................................................................................................. 15
7.1 Soll/ Ist-Vergleich ................................................................................................................. 15
7.2 Gewonnene Erkenntnisse ...................................................................................................... 15
7.3 Ausblick................................................................................................................................. 15
A Anhang
A.1 Detaillierte Zeitplanung ……………………………………………………………………………………………………………... V
A.2 Verwendete Ressourcen ……………………………………………………………………………………………………………..VI
A.3 Trello – Kanban-Board ………………………………………………………………………………………………………………VII
A.4 Auszug Lastenheft zur Erstellung eines Chat-Bots……………………………………………………………………. VII
A.5 Entity-Relationship-Modell ………………………………………………………………………………………………………. IX
A.6 Tabellenmodell …………………………………………..…………………………………………………………………………….. IX
A.7 Auszug Pflichtenheft zur Erstellung eines Chat-Bots …………………………………………………………..…….. X
A.8 Iterationsplan zur Entwicklung eines Chat-Bots………………….……………………………………………………… XI
A.9 LUIS Klassen …………………………………………….…………………………………..………………………………….……… XI
A.10 LUIS Entity abfragen ………………………….…………………………………..……..…………………..…………………. XII
A.11 JSON Beispiel …………….…………………………………..…….……………………………………………..…..……..…… XIV
A.12 Root Dialog (Ausschnitt) …………………………………..…….………………………………………….………………… XV
A.13 QnA-Maker Dialog (Ausschnitt) …………………..…….………………………………………….………………….… XVI
A.14 Feedback Dialog (Ausschnitt) …..….………………………………..………….…….…………………………….…… XVIII
A.15 E-Mailadressen auf Duplikate prüfen und speichern …………………………….…….………………………… XXII
A.16 Benutzerhandbuch (Ausschnitt) …………….…….…………………………………………………………………….… XXIV
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann III
Abbildungsverzeichnis
Abbildung 1: Produktumgebung ................................................................................................ 9
Abbildung 2: Trello ................................................................................................................. VII
Abbildung 3: Entity-Relationship-Modell ............................................................................... IX
Abbildung 4: Tabellenmodell ................................................................................................... IX
Tabellenverzeichnis
Tabelle 1: Grobe Zeitplanung .................................................................................................... 3
Tabelle 2: Ressourcenplanung ................................................................................................... 5
Tabelle 3: Amortisationsdauer pro Monat ................................................................................. 6
Tabelle 4: LUIS ........................................................................................................................ 12
Tabelle 5: Soll/ Ist-Vergleich ................................................................................................... 15
Tabelle 6: Detaillierte Zeitplanung ........................................................................................... V
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann IV
Abkürzungsverzeichnis
DKUB Dr. Kuhl Unternehmensberatung GmbH & Co. KG
MuK MeyerundKuhl Spezialwäschen GmbH
ERM Entity-Relationship-Modell
FAQ Frequently Asked Questions / Häufig gestellte Fragen
SQL Structured Query Language
QnA Question and Answer
LUIS Language Understanding Intelligent Service
NuGet Open Source Paketverwaltung für Softwareentwicklung in .NET
KVP Kontinuierlicher Verbesserungsprozess
REST Representational State Transfer
API Application Programming Interface
ERM Entity Relationship Modell
JSON JavaScript Object Notation
IIS Internet Information Services
http Hypertext Transfer Protocol
URL Uniform Resource Locator
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann 1
1. Einleitung
Die folgende Projektdokumentation schildert den Ablauf des IHK-Abschlussprojektes, welches
der Autor im Rahmen seiner Ausbildung zum Fachinformatiker Anwendungsentwicklung
durchgeführt hat. Der Ausbildungsbetrieb ist die Dr. Kuhl Unternehmensberatung GmbH & Co.
KG, im Folgenden DKUB genannt, eine unabhängige Management- und IT-Beratung mit Fokus
auf den Mittelstand. Die DKUB ist unter anderem zuständig für die Analyse und Optimierung
interner Prozesse und Abläufe und für die Auswahl und Einführung von maßgeschneiderten und
leistungsfähigen Softwarelösungen. Ein Partnerunternehmen der DKUB ist die MeyerundKuhl
Spezialwäschen GmbH, im Folgenden MuK genannt. Sie ist spezialisiert auf die Pflege und PFC-
freie Imprägnierung von Outdoor- und Funktionstextilien. Dieser Service wird u.a. über einen
Webshop angeboten.
1.1 Projektbeschreibung
In diesem Projekt wurde eine Softwarelösung in Form eines Chat-Bots für die MuK entwickelt, im
Folgenden auch Service-Bot genannt. Dieser dient hauptsächlich der automatischen Beantwortung
von Kundenfragen. Da die meisten Fragen von Kunden oder Kaufinteressenten im Webshop eines
Unternehmens auftreten, wird der Bot über den Webshop zur Verfügung gestellt. Mit dem Chat-
Bot ist es möglich, dass Kunden zu jeder Zeit eine kompetente Antwort auf ihre Anfrage
bekommen. Außerdem gibt es die Möglichkeit, einmalig Feedback zur Internetpräsenz zu geben,
damit diese stetig verbessert werden kann. Die Feedback-Funktion wurde durch eine vordefinierte
Umfrage implementiert. Der Bot ist technisch dazu in der Lage, auf das gegebene Feedback
einzugehen und entsprechende Fragen zu stellen. Der Kunde war bisher darauf angewiesen, dass
ein Mitarbeiter sich persönlich um seine Anfrage kümmert, was je nach Auslastung
unterschiedlich lange dauern und nur innerhalb der Bürozeiten erfolgen konnte.
1.2 Projektziel
Das Ziel des Projektes war es, dem Kunden die Möglichkeit zu geben, noch während des
Bestellprozesses, jederzeit Fragen stellen zu können. Dabei ist es irrelevant, ob der Kunde Fragen
zum Ablauf, zu den Preisen oder zu seinem Auftrag hat.
Mithilfe dieser Lösung soll sowohl das Kundenerlebnis stark verbessert, als auch die Service-
Abteilung entlastet und unterstützt werden.
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann 2
1.3 Projektumfeld
Auftraggeber des Projektes ist die Service-Abteilung der MuK. Zu den Aufgaben der Abteilung
gehört unter anderem die Beantwortung von Kundenanfragen per Telefon und E-Mail. Außerdem
die Weiterleitung und Verarbeitung von Kunden-Feedback, die Anregung zur Verbesserung im
Rahmen des KVP und die Ausarbeitung von FAQs und sonstigen Hilfsdokumenten. Die MuK hat
sehr verschiedene Kundengruppen. Diese gehen von Feuerwehren über Outdoor-Kunden zu
Motorradfahrern. Aber auch speziellere Kunden, wie Gasthäuser, die ihre Sonnenschirme waschen
wollen. Durch die breite Masse an verschiedenen Textilien und Kundengruppen wird der Support
teilweise immens komplex.
Um dem Kunden-Service die Beantwortung wiederkehrender Fragen und das hohe Aufkommen
an Support-Fällen zu erleichtern, soll der Chat-Bot diese teilweise übernehmen.
1.4 Projektschnittstellen
Damit der Chat-Bot sowohl mit dem Kunden als auch mit der Service-Abteilung kommunizieren
kann, muss er von der Cloud-Plattform Microsoft Azure, die von der DKUB festgelegt wurde,
gehostet werden. Dadurch soll der Chat-Bot unter anderem mit dem Webshop der Wäscherei
arbeiten können.
Das Frontend des Bots wurde mittels iFrame in den Webshop eingebunden. Sämtliche Daten
werden mittels Microsoft Azure in einer Microsoft SQL-Datenbank abgelegt. Diese ist unter
anderem für die Speicherung von bereits vorhandenen Teilnehmern der Feedback-Umfrage
verantwortlich. Damit der Aufwand für die Service-Abteilung so gering wie möglich ist, wurde
der QnA-Maker von Microsoft in den Quellcode des Service-Bots eingebunden. Dadurch ist es
möglich, den Bot über die Website, mit Fragen und entsprechenden Antworten zu füllen.
Zur Ergänzung wurde der Service LUIS (Language Understanding Intelligent Service) verwendet,
um zu erreichen, dass der Kunde auch dann verstanden wird, wenn er keine genormten Sätze
verwendet.
1.5 Projektabgrenzung
Es handelt sich um ein komplett eigenständiges Projekt, ohne Bezug zu anderen
Projekten/Teilprojekten. Die Realisierung des Webshops und die Erarbeitung inhaltlicher
Fragestellungen waren nicht Teil des Projektes.
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann 3
2. Projektplanung
2.1 Projektphasen
Für die Umsetzung des Projektes standen dem Autor insgesamt 70 Stunden zur Verfügung. Diese
wurden auf im Unternehmen bereits festgelegte Phasen verteilt. Die grobe Zeitplanung lässt sich
der folgenden Tabelle entnehmen.
Projektphase Geplante Zeit
Anforderungsdefinition 14 Stunden
Konzeption und
Entwicklung
42 Stunden
Systemintegration und
Tests
14 Stunden
Gesamt 70 Stunden
Tabelle 1: Grobe Zeitplanung
Die einzelnen Hauptphasen wurden in Unterpunkte aufgeteilt. Die Übersicht befindet sich im
Anhang A.1: Detaillierte Zeitplanung.
2.2 Ressourcenplanung
Da es sich bei der MuK um ein recht junges Unternehmen handelt, das sich noch im Aufbau
befindet, wurde darauf geachtet, dass die Anschaffungs- und Folgekosten des Projektes möglichst
gering ausfallen. Deshalb wurde das komplette Projekt mittels kostenloser Services und Software
entwickelt und aufgesetzt. In der Übersicht im Anhang A.2: Verwendete Ressourcen befinden sich
alle Personal-, Hardware- und Softwarekosten, die in dem Projekt verwendet wurden.
2.3 Entwicklungsprozess
Um eine flexible Umsetzung der Anforderungen zu ermöglichen, hat sich der Autor für einen
agilen Entwicklungsprozess entschieden. Da es sich um ein vergleichsweise kleines Projekt mit
wenigen Projektteilnehmern handelt, wurde die agile Methode Kanban verwendet.
Die Methode Kanban ermöglicht die flexible Änderung der Anforderungen und einen fließenden
Entwicklungsprozess, ohne dabei viele Einschränkungen zu definieren.
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann 4
Die Umsetzung erfolgte mithilfe eines Kanban-Boards, das in der Projektmanagementsoftware
„Trello“ angelegt und verwaltet wurde. Ein Ausschnitt dieses Boards befindet sich im Anhang
A.3: Trello – Kanban-Board.
3. Analysephase
3.1 Ist-Analyse
Wie bereits im Abschnitt 2. Projektbeschreibung erwähnt, hat die MuK ein hohes Aufkommen
von Support-Fällen registriert. Dabei handelt es sich vor allem um Telefonanrufe von Kunden oder
Kaufinteressenten, die Fragen zum Ablauf, dem Imprägnierungsverfahren oder zu bestimmten
Textilien haben. Bisher war es dem Kunden lediglich per E-Mail oder Telefon möglich, eine
Auskunft über die genannten Themen zu bekommen. Dies ist mit einer entsprechenden zeitlichen
Verzögerung verbunden, da die Service-Abteilung an ihre Arbeitszeiten gebunden und teilweise
bereits voll ausgelastet ist. Dadurch verzögert sich der Ablauf und bietet kein optimales
Kundenerlebnis.
3.2 Wirtschaftlichkeitsanalyse
Aufgrund der hohen Auslastung der Service-Abteilung und der Art und Menge der
Supportanfragen, war das Projekt dringend zu empfehlen. Ob es auch wirtschaftlich sinnvoll ist,
soll im Folgenden geklärt werden.
3.3 „Make or Buy“-Entscheidung
Da es sich bei der MuK um ein sehr spezielles Unternehmen, mit einem noch spezielleren Ablauf
handelt und der Chat-Bot flexibel erweiterbar sein muss, ließ sich keine den Anforderungen
entsprechende Standard-Lösung am Markt finden. Aus diesem Grund sollte das Projekt in
Eigenentwicklung durchgeführt werden.
3.4 Projektkosten
Nachfolgend befinden sich die kalkulierten Kosten, die während der Entwicklung des Projektes
anfielen. Dabei werden sowohl die Personal-, als auch die Hard- und Softwarekosten
berücksichtigt.
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann 5
Da die exakten Personalkosten aus Datenschutzgründen nicht herausgegeben werden dürfen,
wurde die Kalkulation anhand von beispielhaften Kosten durchgeführt. Die Gesamtkosten eines
Mitarbeiters für das Unternehmen betragen demnach 50,00 €, die eines Auszubildenden 20,00 €.
Für die sonstigen Kosten wurde ein pauschaler Satz von 10,00 € pro Stunde verwendet.
Sämtliche anfallende Projektkosten, können der folgenden Tabelle entnommen werden.
Vorgang Mitarbeiter Zeit Personal Sonstige
Kosten
Gesamt
Anforderungs-
definition
1x Auszubildender 14 Std. 280,00 € 140,00 € 420,00 €
Entwicklung 1x Auszubildender 56 Std. 1.120 € 560,00 € 1.680,00 €
Code-Review 1x Mitarbeiter 3 Std. 150,00 € 30,00 € 180,00 €
Abnahme 1x Mitarbeiter 1 Std. 50,00 € 10,00 € 60,00 €
2.340,00 €
Tabelle 2: Ressourcenplanung
3.5 Amortisationsdauer
Im Folgenden soll geprüft werden, ab welchem Zeitpunkt sich das Projekt amortisiert. Dazu
werden die Anschaffungskosten (Entwicklungskosten) durch die laufende Kostenersparnis
dividiert. Einige dieser Services sind nur bis zu einem bestimmten Volumen kostenlos und müssen
bei einer Auslastung von mehr als 10.000 Transaktionen bezahlt werden. Da es unwahrscheinlich
ist, dass diese Auslastung in nächster Zeit erreicht wird, wurden diese zusätzlichen Kosten nicht
in die Amortisationsrechnung aufgenommen. Da es kaum möglich ist, die Anzahl an
Supportanfragen vorauszusehen, hat der Autor die Daten der letzten 3 Monate ausgewertet und
mit dem Durchschnitt davon gearbeitet.
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann 6
Vorgang Zeit
pro Vorgang
Anzahl (alt)
pro Monat
Anzahl (neu)
pro Monat
Einsparung
pro Monat
Fragen zum
Ablauf
10 Minuten 15 8 70 Minuten
Fragen zum
Preis
3 Minuten 20 10 39 Minuten
Fragen zu
bestimmtem
Artikel
7 Minuten 30 20 70 Minuten
Fragen zur
Waschbarkeit
5 Minuten 40 25 75 Minuten
324 Minuten
Tabelle 3: Amortisationsdauer pro Monat
Berechnung der Amortisationsdauer:
324 Min/Monat x 12 Monate/Pro Jahr = 3.888 Min/Jahr = 64,80 h/Jahr
64,80 h/Jahr x (50€ + 30€)1 = 5.184€/Jahr
2.340€ / 5.184€ = 0,45 Jahre ≈ 5 Monate und 2 Wochen
Die Projektkosten amortisieren sich nach der oben ausgeführten Berechnung, in 5 Monaten und 2
Wochen.
3.6 Nicht-monetäre Vorteile
Die nicht-monetären Vorteile teilen sich in die Vorteile für den Kunden und die Vorteile für die Mitarbeiter
der Service-Abteilung.
Der Kunde hat durch das Projekt die Möglichkeit, jederzeit und von überall seine Fragen und Probleme
mitzuteilen und kompetente Hilfe zu erhalten.
Bei den Mitarbeitern entsteht geringerer Aufwand. Dadurch können sie sich besser auf ihre anderen
Aufgaben konzentrieren, was sowohl die Effizienz als auch das Betriebsklima verbessert.
___________________________________
1 Personalkosten + sonstige Kosten
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann 7
3.7 User-Storys
Um die Anforderungen der Kunden und der Mitarbeiter abzudecken, wurden mithilfe der Service-
Abteilung User-Storys erstellt, die der Bot abdecken soll. Eine User-Story, auf Deutsch
Anwendererzählung genannt, ist eine in Umgangssprache formulierte Anforderung an eine Software. Diese
Methode hat sich angeboten, da es sich um einen agilen Entwicklungsprozess handelt.
Die User-Storys wurden ins Lastenheft übernommen.
3.8 Lastenheft
Zusammen mit der MuK wurde als Ergebnis der Analysephase ein Lastenheft erstellt. Dieses
wurde mithilfe der bereits erwähnten User-Storys umgesetzt. Ein Ausschnitt davon befindet sich
im Anhang A.4: Auszug Lastenheft zur Entwicklung eines Chat-Bots.
4. Entwurfsphase
4.1 Zielplattform
Das Projekt wurde mithilfe des Microsoft Bot Frameworks entwickelt, da es die einzige Lösung
ist, die alle benötigten Services (LUIS, QnA-Maker) / Anforderungen unterstützt. Die fertige
Software-Lösung wird in Microsoft Azure gehostet, um eine möglichst hohe Erreichbarkeit zu
ermöglichen. Außerdem wurde der Bot an eine, ebenfalls in Microsoft Azure gehostete, SQL-
Datenbankinstanz angebunden, um dort bestimmte Informationen abzuspeichern.
Bei der Auswahl der Programmiersprache waren die Möglichkeiten eingeschränkt, da das
Microsoft Bot Framework lediglich C# und Node.JS unterstützt. Aufgrund dieser Einschränkung
und den Kenntnissen des Autors, bzw. des Unternehmens wurde als Programmiersprache C#
gewählt. Auf die Erstellung einer Nutzwertanalyse zur Auswahl der Programmiersprache wurde
deshalb verzichtet.
4.2 Softwarearchitektur
Das Microsoft Bot Framework beinhaltet einen Connector, der mittels REST-API auf
verschiedene Kanäle zugreifen kann. Zu den Kanälen gehören unter anderem E-Mail, Skype, SMS,
Telegram und eine Weboberfläche, die per iFrame eingebunden wird. Dadurch ist es dem Bot
möglich, Nachrichten von verschiedenen sozialen Medien zu empfangen und zu interpretieren.
Die Interpretation der empfangenen Nachricht erfolgt über den Message Controller. Wenn es sich
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann 8
bei der Nachricht um eine Benutzer-Nachricht handelt, wird sie an den Root Dialog
weitergegeben, der entscheidet, was damit passiert. Ein Dialog ist dafür zuständig, den
Konversationsfluss zu steuern. Dafür kann der Root Dialog auch weitere Dialoge aufrufen und zur
Laufzeit schließen, wenn sie nicht mehr benötigt werden. Ein Dialog erbt seine Eigenschaften von
der Oberklasse IDialog.
Der Chat-Bot hat die Besonderheit, dass er sowohl Fragen beantworten kann, als auch
Funktionalitäten beinhaltet, die allgemeines Sprachverständnis erfordern. Dazu muss mit zwei
verschiedenen Services von Microsoft gearbeitet werden.
Zum einen mit dem QnA-Maker (Preview), der für die Beantwortung von Fragen zuständig ist.
Zum anderen mit LUIS, um das Sprachverständnis zu ermöglichen.
Damit das Feedback der Kunden und ihre dazugehörige E-Mail-Adresse später ausgewertet
werden können, werden sie in einer Microsoft SQL-Datenbank gespeichert. Außerdem wird
geprüft, ob der Kunde mit dieser E-Mail-Adresse bereits an der Feedback-Umfrage teilgenommen
hat.
4.3 Produktumgebung
Abhängig davon, über welchen Kanal der Kunde den Bot anschreibt, wird die Nachricht entweder
per REST-API (Alle sozialen Netzwerke/Messenger) oder über den im Webshop eingebundenen
iFrame an den Bot Connector übertragen. Dieser gibt die Nachricht an den Chat-Bot weiter.
Der Bot ruft anschließend LUIS auf, um die Interpretation der linguistischen Frage zu definieren.
Je nach Intention der Nachricht greift er nun per REST-API auf LUIS oder den QnA-Maker zu.
Die Mitarbeiter der MuK können per Application Insights von Microsoft Azure die
Zugriffsstatistiken einsehen.
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann 9
In der folgenden Abbildung ist die beschriebene Produktumgebung grafisch veranschaulicht.
Abbildung 1: Produktumgebung
4.4 Datenmodell
Damit das Feedback des Kunden später ausgewertet werden kann, müssen die Daten in einer SQL-
Datenbank gespeichert werden. Dies geschieht erst, nachdem der Kunde seine E-Mail-Adresse
hinterlegt hat und diese noch nicht vorhanden ist. Dadurch wird garantiert, dass keine Spam-Bots
oder Menschen mit unlauteren Absichten das Ergebnis verfälschen können.
Zur Abspeicherung strukturierter Daten wurde zunächst eine Analyse der Feedback-Umfrage und
ihrer möglichen Antworten durchgeführt. Dabei wurde die Art der Daten und ihre entsprechenden
Beziehungen extrahiert. Aus diesen wurde anschließend ein Entity-Relationship-Modell, im
Folgenden ERM genannt, erstellt.
Dieses befindet sich im Anhang A.5: Entity-Relationship-Modell. Folgende Entitätstypen wurden
herausgearbeitet und abgebildet: Kunde, Feedback, Frage, Sonstige.
Da eine relationale Datenbank verwendet werden sollte, wurde das ERM in ein Tabellenmodell
überführt. Das Diagramm befindet sich im Anhang A.6: Tabellenmodell.
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann 10
4.5 Pflichtenheft
Am Ende der Entwurfsphase wurde, als Ergebnis der Konzeption, ein Pflichtenheft erstellt. Dieses
beruht auf dem Lastenheft und definiert die Anforderungen der MuK. Es ist somit die Grundlage
für das durchzuführende Projekt. Einen Auszug vom Pflichtenheft befindet sich im Anhang A.7:
Auszug Pflichtenheft zur Entwicklung eines Chat-Bots.
5. Implementierungsphase
5.1 Iterationsplanung
Da es sich bei dem gewählten Entwicklungsprozess um Kanban handelt, ist es nicht zwingend
erforderlich, Iterationen festzulegen. Dennoch hat der Autor sich dafür entschieden, eine
Iterationsplanung durchzuführen, um die verfügbare Entwicklungszeit präzise ausnutzen zu
können.
Da von den vier User Storys zumindest drei einen ähnlichen zeitlichen Aufwand haben, wurde
jeweils eine User Story in eine Iteration überführt. Die User Storys wurden anschließend in
einzelne Aufgaben aufgeteilt und dem entsprechenden Eigentümer zugewiesen. Zusätzlich
hinzugefügt wurden lediglich die Erstellung der Datenbank, die Implementierung der
grundlegenden Konversationslogik und die Veröffentlichung in Microsoft Azure. Der erstellte
Iterationsplan befindet sich im Anhang A.8: Iterationsplan zur Entwicklung eines Chat-Bots.
5.2 Implementierung der Datenstrukturen
Auf Basis der in 4.4 Datenmodell beschriebenen Datenstruktur wurde die Implementierung der
Datenbank durchgeführt. Dazu wurde eine neue Datenbankinstanz in Microsoft Azure bestellt und
ein neues Schema mit dem Namen „BotData“ angelegt. Anschließend wurden die benötigten
Tabellen mithilfe des Microsoft SQL Server Management Studios angelegt.
5.3 Einrichtung der Entwicklungsumgebung
Als Entwicklungsumgebung wird Visual Studio Professional 2017 von Microsoft verwendet.
Grund dafür ist die hervorragende Unterstützung der Programmiersprache C# und die komfortable
Verwendung des Microsoft Bot Frameworks. Um mit Visual Studio 2017, im Folgenden VS2017
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann 11
genannt, Bots entwickeln zu können, muss zuerst das Projekttemplate heruntergeladen und in das
entsprechende Verzeichnis kopiert werden.
Dieses befindet sich in Windows normalerweise unter:
%USERPROFILE%\Documents\Visual Studio 2017\Templates\ProjectTemplates\Visual C#\
Außerdem müssen die Item-Templates (Controller und Dialog) in das Item-Template Verzeichnis
kopiert werden.
Dieses befindet sich in Windows normalerweise unter:
%USERPROFILE%\Documents\Visual Studio 2017\Templates\ItemTemplates\Visual C#\
Danach kann ein Bot-Projekt erstellt werden. Innerhalb des Projektes muss noch das NuGet-
Package „Microsoft.Bot.Builder“ und das NuGet-Package „QnAMakerDialog“ eingebunden
werden. Dies ist notwendig um auf den QnA-Maker zugreifen zu können. Zum Testen des Chat-
Bots wird eine lokale Version von IIS Express und der Microsoft Bot Emulator installiert.
5.4 Implementierung der Services
Nachdem die Entwicklungsumgebung eingerichtet ist, kann mit der eigentlichen Programmierung
begonnen werden. Im ersten Iterationsschritt hat der Autor die Implementierung des QnA-Makers
umgesetzt. Dazu musste auf der offiziellen Website des Microsoft QnA-Makers ein neuer Service
angelegt werden.
Der Service stellt den Subscription-Key und die Knowledgebase-ID bereit, welche dem Bot zur
Authentifizierung beim QnA-Maker Service dienen. Danach muss auf der Webseite ein FAQ
hinterlegt werden. Das FAQ kann entweder eine PDF-Datei oder eine Internetseite mit einem
entsprechenden FAQ sein. Hier wurde von der Service-Abteilung eine PDF-Datei erstellt, die alle
bereits bekannten Fragen abdeckt. Nachdem der Service fertig eingerichtet ist, werden die
Zugangsdaten im Quellcode des eigentlichen Entwicklungsprojektes hinterlegt, damit mithilfe des
QnA-Maker Dialogs darauf zugegriffen werden kann.
Dazu muss ein neuer Dialog erstellt werden, der vom Root Dialog aufgerufen wird, wenn der
Kunde eine Frage stellt. Um dies zu gewährleisten soll der Bot verstehen, was der Kunde von ihm
will, noch bevor der Dialog des QnA-Makers aufgerufen wird.
Um die Anforderung des linguistischen Sprachverständnisses erfüllen zu können, wird der Service
LUIS in den Bot eingebunden. Dieser sorgt mittels maschinellem Lernen für die benötigte
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann 12
Verarbeitung der Nachricht und wird außerdem für alle weiteren Funktionalitäten, zum Beispiel
der Feedback-Umfrage, benötigt.
Zur Einbindung von LUIS wird, wie beim QnA-Maker, ein neuer Service auf der Website
angelegt. Beim Erstellen wird der Service-Name, die zu verstehende Sprache und eine kurze
Beschreibung hinterlegt. Sobald der Service erfolgreich angelegt wurde, können neue Intents
hinzugefügt werden. Ein Intent, auf Deutsch „Absicht“, ist die Absicht des Anwenders in einem
Wort zusammengefasst. Den Intents werden die entsprechenden Utterances hinzugefügt.
Utterance, auf Deutsch „Äußerung“, bezeichnet einen Satz, den der Anwender dem Bot schreibt.
Abschließend werden die Entities festgelegt. Ein Entity, auf Deutsch „Objekt“, bezeichnet ein
Wort, das die detaillierte, relevante Information des Satzes kennzeichnet. Im Folgenden befindet
sich ein Beispiel für alle drei Erklärungen.
Intent User Utterance Entities
Feedback Ich würde gerne eine
Bewertung abgeben.
Bewertung
Frage Ich würde gern was fragen. fragen
Smalltalk Wie ist das Wetter heute? Wetter
Tabelle 4: LUIS
Nachdem alle benötigten Werte hinzugefügt und definiert sind, wird der Service veröffentlicht,
wobei diese natürlich regelmäßig erweitert werden müssen. Dies geschieht ebenfalls über die
Webseite per Knopfdruck. Dabei wird eine Verknüpfung mit einem entsprechenden Schlüssel
erstellt, über den auf den Service zugegriffen werden kann. Um die Werte interpretieren zu können,
wird bei der Veröffentlichung eine JSON-Datei erstellt, die mithilfe von VS2017 als Klasse
eingefügt wird. Dafür muss lediglich mithilfe der in VS2017 integrierten Funktionalität „Inhalte
einfügen“, bzw. „JSON als Klassen einfügen“ die JSON-Datei eingefügt werden. Die
entsprechenden Klassen LUIS, Rootobject, TopscoringIntent, Intent und Entity befinden sich mit
den entsprechenden Get- und Set-Methoden im Anhang A.9: LUIS Klassen.
Um die Nachricht des Benutzers an den LUIS Service weiterzuleiten, wird eine Funktion
implementiert, welche die Nachricht an die URL anhängt und über eine http-Anfrage aufruft. Der
Quellcode dieser Funktion befindet sich im Anhang A.10: LUIS Entity abfragen. Als Rückgabe
erhält der Chat-Bot, eine JSON-Datei, die von der LUIS Klasse verarbeitet wird. Zur besseren
Veranschaulichung befindet sich eine beispielhafte JSON-Datei im Anhang A.11: JSON Beispiel.
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann 13
Dort sieht man, dass zur Abfrage alle Intents eine Wahrscheinlichkeit zugewiesen bekommen. Am
Ende wird das Intent ausgewählt, das die größte Wahrscheinlichkeit hat, also die Intention des
Anwenders am besten wiederspiegelt.
5.5 Implementierung der Konversationslogik
Nachdem die Services eingebunden sind, wird die eigentliche Konversationslogik implementiert.
Beim Empfang einer Benutzer-Nachricht durch den Message Controller, wird der Root Dialog
aufgerufen. Dieser interpretiert mithilfe von LUIS die Nachricht und ruft den entsprechenden
Dialog auf. Ein Ausschnitt des Root Dialogs befindet sich im Anhang A.12: Root Dialog
(Ausschnitt). Wenn der Anwender eine Frage stellt, wird der QnA-Maker Dialog aufgerufen, der
die Frage, sofern möglich, beantwortet. Falls der Chat-Bot keine passende Antwort geben kann,
wird eine Meldung an den Benutzer geschickt. Da es sich bei dem QnA-Maker bereits um eine
fertige Lösung handelt, wurden einige Methoden überschrieben und angepasst. Ein Ausschnitt
davon befindet sich im Anhang A.13: QnA-Maker Dialog (Ausschnitt).
Wenn der Anwender an der Feedback-Umfrage teilnehmen möchte, wird der Feedback Dialog
aufgerufen und ihm werden eine Reihe von Fragen gestellt. Die Antworten werden bei Abschluss
der Umfrage und, nachdem der Anwender seine E-Mail-Adresse zur Verifizierung übermittelt hat,
in einer SQL-Datenbank gespeichert. Danach erhält der Anwender per E-Mail eine Bestätigung
mit einem Gutschein im Wert von 5,00 €, den er im Anschluss im Online-Shop der MuK einlösen
kann. Ein Ausschnitt davon befindet sich im Anhang A.14: Feedback Dialog (Ausschnitt).
Die Funktion zur Prüfung und Speicherung der E-Mail-Adresse des Benutzers befindet sich
ebenfalls im Anhang A.15: E-Mailadressen auf Duplikate prüfen und speichern.
Der Bot beinhaltet kleinere Funktionen, um auf belanglose Nachrichten, Beleidigungen oder
Supportanfragen eingehen zu können. Bei einer Supportanfrage werden die Kontaktinformationen
des Kunden und seine Anfrage an einen Mitarbeiter der Service-Abteilung weitergeleitet. Bei
belanglosen Nachrichten und Beleidigungen wird eine entsprechende Antwort ausgegeben.
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann 14
6. Abnahme- und Einführungsphase
6.1 Abnahme durch die Service-Abteilung
Nachdem die Anwendung fertig entwickelt war, wurde sie, wie nach jeder Iterationsphase bereits
erfolgt, der Service-Abteilung zur Abnahme vorgelegt. Da sowohl die Funktionalitäten, als auch
der Umgang mit dem Chat-Bot durch die bereits durchlaufenen Iterationen und Tests bekannt war,
lief die Endabnahme problemlos. Vor der finalen Veröffentlichung im Webshop der MuK, wurde
ein Code-Review zur Qualitätssicherung durchgeführt.
6.2 Veröffentlichung und Einführung
Aufgrund der Cloud-Architektur und der Tatsache, dass es sich hierbei nicht um eine Desktop-
bzw. Client-Software handelt, gestaltete sich die Veröffentlichung als unkompliziert. Zuerst wurde
der eigentliche Chat-Bot in Microsoft Azure eingerichtet und öffentlich zugänglich gemacht.
Danach musste im Webshop der MuK der Bot per iFrame hinterlegt werden.
Anschließend wurde in Microsoft Azure die Funktionalität „Application Insights“ aktiviert und
eingerichtet, um Kunden-Anfragen statistisch auswerten zu können.
6.3 Dokumentation
Die Dokumentation des Chat-Bots setzt sich aus dem Benutzerhandbuch und der
Projektdokumentation zusammen, die beide vom Autor manuell erstellt wurden.
Das Benutzerhandbuch besteht aus jeweils einer Anleitung für die Services LUIS und QnA-Maker,
damit die Mitarbeiter der Service-Abteilung, unabhängig vom Entwickler, neue FAQs und
Äußerungen hinzufügen können. Ein Ausschnitt davon befindet sich im Anhang A.16:
Benutzerhandbuch (Ausschnitt). In der Projektdokumentation werden die einzelnen Projektphasen
und entsprechenden Vorgänge des Projekts näher erläutert.
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann 15
7. Fazit
7.1 Soll/ Ist-Vergleich
Rückblickend betrachtet wurden alle im Pflichtenheft definierten Anforderungen umgesetzt. Der
zu Anfang erstellte Projektplan konnte ebenfalls eingehalten werden. In der Tabelle Soll/ Ist-
Vergleich ist der benötigte Zeitaufwand gegenübergestellt. Es ist zu erkennen, dass es eine gewisse
Zeitdifferenz bei der Entwicklung und der Systemintegration gegeben hat. Da die Entwicklung des
Chat-Bots weniger Zeit benötigte, konnten die verbleibenden zwei Stunden für Tests verwendet
werden. Somit wurde das Projekt in den festgelegten 70 Stunden umgesetzt.
Projektphase Soll Ist Differenz
Anforderungsdefinition 14 Std. 14 Std. 0 Std.
Konzeption und
Entwicklung
42 Std. 40 Std. -2 Std.
Systemintegration und
Tests
14 Std. 16 Std. +2 Std.
Gesamt 70 Std. 70 Std. 0 Std.
Tabelle 5: Soll/ Ist-Vergleich
7.2 Gewonnene Erkenntnisse
Im Laufe des Projektes konnte der Autor viele Dinge im Bereich Projektmanagement, Language
Understanding und agiler Softwareentwicklung lernen, aber auch neue Erfahrungen im Bereich
C#, Chat-Bots und Microsoft Azure sammeln. Besonders die hinzugewonnenen Kenntnisse im
Microsoft Bot Framework werden auch weiterhin sehr nützlich sein. Somit war das Projekt nicht
nur für die Service-Abteilung der MuK eine Entlastung, sondern auch für den Autor eine
Bereicherung seiner Fähigkeiten und Kenntnisse.
7.3 Ausblick
Aufgrund der vielen Möglichkeiten, gibt es bereits Ideen und Anforderungen, die in Zukunft noch
umgesetzt werden können. Dazu zählt, zum Beispiel, die Möglichkeit, als Kunde, den Status seiner
Bestellung anfragen zu können oder direkt über den Chat-Bot im Webshop zu bestellen. Durch
den modularen Aufbau der Software, können jederzeit neue Funktionen hinzugefügt und
veröffentlicht werden. Da sich die Anforderungen an den Chat-Bot in unregelmäßigen Abständen
ändern können, werden die Services generell erweitert werden müssen. Dies kann, dank dem
Benutzerhandbuch, von den Mitarbeitern der Service-Abteilung selber erledigt werden.
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann V
A. Anhang
A.1 Detaillierte Zeitplanung
Anforderungsdefinition 14 Std.
1. Ist-Analyse 7 Std.
2. Wirtschaftlichkeitsanalyse 2 Std.
3. Erstellung des Lastenheftes
(mit Auftraggeber)
5 Std.
Konzeption und Entwicklung 42 Std.
1. Zielplattform definieren 0,5 Std.
2. Datenbank entwerfen 1 Std.
3. Konversationslogik (Theorie)
erstellen
3 Std.
4. Pflichtenheft erstellen 5 Std.
5. Iterationsplanung 0,5 Std.
6. Datenbank implementieren 1 Std.
7. Entwicklungsumgebung einrichten 2 Std.
8. Services implementieren 5 Std.
9. Konversationslogik implementieren 10 Std.
10. Entwicklerdokumentation erstellen 2 Std.
11. Benutzerhandbuch erstellen 2 Std.
12. Projektdokumentation erstellen 10 Std.
Systemintegration und Tests 14 Std.
1. Veröffentlichung in Azure 2 Std.
2. Einrichten von Application Insights 2 Std.
3. Abschlusstest durch unabhängige
Testpersonen und ggf. Verbesserung
der Konversationslogik
10 Std.
Tabelle 6: Detaillierte Zeitplanung
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann VI
A.2 Verwendete Ressourcen
Hardware
• Büroarbeitsplatz mit Notebook, Dockingstation und externem Monitor
Software
• Windows 10 Enterprise - Betriebssystem
• Visual Studio Professional 2017 – IDE für .Net-Sprachen
• Microsoft Bot Framework – Framework zur Entwicklung von Bots
• Microsoft SQL Server – Datenbank
• Microsoft Azure – Cloudlösung
• Microsoft SQL Server Management Studio 17.4 – Verwaltung für MSSQL-
Datenbanken
• Microsoft Bot Emulator – Testen von Bots
• LUIS – Language Understanding Intelligent Service
• QnA-Maker – Service von Microsoft zur Beantwortung von Fragen
• Dia Diagram Editor – Open Source Software zur Erstellung von Diagrammen
• MySQL Workbench – Datenbankverwaltung (Wurde zur Erstellung des
Tabellenmodells genutzt)
• Trello – Projektmanagementsoftware
• Shopware 5.4.2 – modulares Online-Shopsystem
• Git - Versionsverwaltung
• Microsoft Word – Textverarbeitungssoftware zur Erstellung der Projektdokumentation
Personal
• Mitarbeiter der Service-Abteilung
• Entwickler – Projektumsetzung
• Anwendungsentwickler – Code-Review
• Unabhängige Tester – Finaler Test der Konversationslogik
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann VII
A.3 Trello – Kanban-Board
Abbildung 2: Trello
A.4 Auszug Lastenheft zur Erstellung eines Chat-Bots
Die Anforderungen werden im Folgenden mithilfe von User Storys dargestellt.
3.1 User Story 1
Nr. / ID US_01 Nichttechnischer Titel Fragen des Kunden
Quelle Webshop-Kunde Verweise Priorität Hoch
Beschreibung
Als Webshop-Kunde möchte ich Fragen stellen können, damit ich den sehr speziellen Ablauf
der Wäscherei besser verstehen kann.
Voraussetzung
- Service-Bot muss in Shopware eingebunden sein
- QnA-Maker muss im Service-Bot eingebunden sein
- Fragen des Kunden müssen zu dem FAQ der Wäscherei passen (Fragen wie: „Wie ist
das Wetter heute“ kann der Bot nicht beantworten)
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann VIII
Auslöser
- Kunde schickt, entweder über die Chatfunktion im Shopsystem oder über Social Media
(Facebook Messenger, Telegram, Skype) eine Frage an den Bot
Grobschätzung des Aufwands
- Einbindung von QnA-Maker
- Anpassung des FAQ
- Aufwand ca. 6 Stunden
3.2 User Story 2
Nr. / ID US_02 Nichttechnischer Titel Feedback des Kunden
Quelle Webshop-Kunde Verweise Priorität Mittel
Beschreibung
Als Webshop-Kunde möchte ich Feedback geben können, damit sich der Service zu meinen
Gunsten verbessern kann.
Voraussetzung
- Service-Bot muss in Shopware eingebunden sein
- LUIS muss mit dem Service-Bot verknüpft sein
- Feedback muss per E-Mail an zuständigen Mitarbeiter geschickt werden können
Auslöser
- Der Kunde wählt im Dialog mit dem Bot die Option für die Bewertung aus
Grobschätzung des Aufwands
- Programmierung (Implementierung von Dialogen)
- Einbindung von LUIS
- Aufwand ca. 10 Stunden
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann IX
A.5 Entity-Relationship-Modell
Abbildung 3: Entity-Relationship-Modell
A.6 Tabellenmodell
Abbildung 4: Tabellenmodell
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann X
A.7 Auszug Pflichtenheft zur Entwicklung eines Chatbots
Zielbestimmungen
Musskriterien
Kundenanfragen
▪ Fragen zur Wäscherei
▪ Fragen zum Wasch- und Imprägnierungsverfahren
▪ Fragen zu bestimmten Produkten
▪ Kontaktaufnahme
▪ Fragen zum Ablauf
▪ Fragen zum Sendungsstatus
• Feedback
▪ Statische Bewertungsfragen
▪ Auswahl durch Benutzer (1. Sehr gut, etc.)
▪ Ergebnis an Mitarbeiter
▪ Manuell erstellter Gutschein an Kunden
• Information an Mitarbeiter senden
▪ Konversation per E-Mail an Mitarbeiter senden
Wunschkriterien
• Auswertung / Statistik
▪ Application Insights
Abgrenzungskriterien
• Keine direkte Schnittstelle zu Shopware
Produkteinsatz
Das Produkt dient zur automatisierten Bearbeitung von Kundenanfragen, der Möglichkeit
für den Kunden Feedback zu hinterlassen und der Bereitstellung bereits vorhandener
Konversationen, damit der Mitarbeiter individuell auf die Anfragen eingehen kann, die der
Bot nicht lösen konnte.
Zielgruppe des Produktes sind vor allem Privatkunden, die im Online-Shop der Wäscherei
bestellen. Aber auch interessierte Parteien, bzw. Geschäftskunden mit individuellen
Verträgen können Anfragen stellen.
Anwendungsbereiche
Der Anwendungsbereich umfasst sämtliche Shop-Kunden (Privat oder Geschäftlich) und
alle, die Interesse an einer umweltfreundlichen Imprägnierung Ihrer Textilie haben.
Außerdem besteht die Möglichkeit mit Hilfe der Feedback-Funktionalität einen Gutschein
für den Online-Shop zu erhalten.
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann XI
Zielgruppen
Die Zielgruppen umfassen alle Privat- und Geschäftskunden der MeyerundKuhl
Spezialwäschen GmbH. Dabei ist es nicht relevant, ob es sich um Erstkunden,
Stammkunden oder Interessenten handelt.
Betriebsbedingungen
Die Betriebsbedingungen müssen für die Anwendung in Microsoft Azure und im Online-
Shop spezifiziert werden. Die maximale Anzahl der Benutzer ist prinzipiell unbeschränkt.
Der Zugang zum Programm steht täglich 24 Stunden lang zur Verfügung, sofern der
Server/Azure dies zulassen.
A.8 Iterationsplan zur Entwicklung eines Chat-Bots
• Erstellung der Datenbank
• Implementierung der Konversationslogik mittels LUIS-Service
• Implementierung der Fragen-/Antwortlogik mittels QnA-Maker
• Implementierung der Feedback-Logik
• Implementierung der Benachrichtigungsfunktion (E-Mail)
• Veröffentlichung in Microsoft Azure
• Application Insights in Azure einrichten
A.9 LUIS Klassen
public class LUIS
{
public string query { get; set; }
public Intent[] intents { get; set; }
public Entity[] entities { get; set; }
}
public class Rootobject
{
public string query { get; set; }
public Topscoringintent topScoringIntent { get; set; }
public Intent[] intents { get; set; }
public Entity[] entities { get; set; }
}
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann XII
public class Topscoringintent
{
public string intent { get; set; }
public float score { get; set; }
}
public class Intent
{
public string intent { get; set; }
public float score { get; set; }
}
public class Entity
{
public string entity { get; set; }
public string type { get; set; }
public int startIndex { get; set; }
public int endIndex { get; set; }
public float score { get; set; }
}
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann XIII
A.10 LUIS Entity abfragen
private static async Task<Luis> GetEntityFromLuis(string Query)
{
// Kodierung der Abfrage (Abfrage = Nachricht des Users)
Query = Uri.EscapeDataString(Query);
// Neue Luis Klasse erstellen
Luis Data = new Luis();
using (HttpClient client = new HttpClient())
{
// Abfrage-URI mit Subscription Key und Abfrage definieren
string RequestURI =
"https://westus.api.cognitive.microsoft.com/luis/v2.0/apps/2e145369-f8e9-4238-86de-
8b6f7871182b?subscription-
key=c92c7d6d010f419bb6c76fc23a4be53f&verbose=true&timezoneOffset=0&q="+ Query;
HttpResponseMessage msg = await client.GetAsync(RequestURI);
// Wenn die Abfrage erfolgreich war
if (msg.IsSuccessStatusCode)
{
// Antwort von Luis-Service
var JsonDataResponse = await msg.Content.ReadAsStringAsync();
// Antwort von JSON zu .NET-Objekt konvertieren
Data = JsonConvert.DeserializeObject<Luis>(JsonDataResponse);
}
}
// Rückgabe der Antwort als .Net-Objekt
return Data;
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann XIV
A.11 JSON Beispiel
{
"query": "wascht ihr auch Schlafsäcke?",
"topScoringIntent": {
"intent": "Question",
"score": 0.9445568
},
"intents": [
{
"intent": "Question",
"score": 0.9445568
},
{
"intent": "price",
"score": 0.0181183256
},
{
"intent": "Offense",
"score": 0.0128170755
},
{
"intent": "Superficial",
"score": 0.009286328
},
{
"intent": "Help",
"score": 0.007988564
},
{
"intent": "Feedback",
"score": 0.00762051623
},
[…]
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann XV
A.12 Root Dialog (Ausschnitt)
public class RootDialog : IDialog<object>
{
public async Task StartAsync(IDialogContext context)
{
// Nachricht empfangen - Art der Nachricht bestimmen
context.Wait(MessageReceivedOperationChoice);
}
public async Task MessageReceivedOperationChoice(IDialogContext context,
IAwaitable<IMessageActivity> argument)
{
// Die Nachricht vom User
var message = await argument;
if (message.Type == ActivityTypes.Message)
{
Luis FeLuis = await GetEntityFromLuis(message.Text);
if (FeLuis.intents.Count()>0)
{
switch(FeLuis.intents[0].intent)
{
case "Welcome":
await context.PostAsync(message.Text);
// Frage, was der User tun will
await context.PostAsync($"Sie können entweder eine Frage stellen oder eine
kurze Feedback-Umfrage ausfüllen, die mit einem 5€ Gutschein belohnt wird.");
await context.PostAsync($"Was wollen Sie tun?");
break;
// Wenn der User Feedback geben will
case "Feedback":
// Feedback-Dialog aufrufen
await context.Forward(new FeedbackDialog(),
ResumeAfterFeedbackDialog, message, CancellationToken.None);
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann XVI
break;
// Wenn der Kunde eine Frage stellt
case "Question":
// Fragen-Dialog aufrufen
Await context.Forward(new QnaDialog(), ResumeAfterQnaDialog, message,
CancellationToken.None);
break;
[…]
A.13 QnA-Maker Dialog (Ausschnitt)
public override async Task DefaultMatchHandler(IDialogContext context, string
originalQueryText, QnAMakerResult result)
{
// Wenn Funktion aus dem Kontext heraus aufgerufen wird (z.B. Bot: Wollen Sie mehr
erfahren? User: Ja.")
if (
originalQueryText.ToLower().Contains("ja") ||
originalQueryText.ToLower().Contains("frage") ||
originalQueryText.ToLower().Contains("fragen"))
{
// Antwort entsprechend als Frage
await context.PostAsync($"Wie lautet Ihre Frage?");
}
else
{
var messageActivity = ProcessResultAndCreateMessageActivity(context, ref result);
string response;
messageActivity.Text = result.Answers.First().Answer;
response = messageActivity.Text;
if (response == "exit")
{
// Nichts tun, Nachricht an User geht über Root-Dialog
}
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann XVII
else
{
context.Done(response);
}
}
}
public override async Task NoMatchHandler(IDialogContext context, string
originalQueryText)
{
// Wenn Funktion aus dem Kontext heraus aufgerufen wird (z.B. Bot: Wollen Sie mehr
erfahren? User: Ja."
if (
originalQueryText.ToLower().Contains("ja") ||
originalQueryText.ToLower().Contains("frage") ||
originalQueryText.ToLower().Contains("fragen"))
{
// Antwort entsprechend als Frage
await context.PostAsync($"Wie lautet Ihre Frage?");
}
else
{
// Antwort des Bots angepasst, sagt normalerweise etwas anderes
await context.PostAsync($"Ich verstehe die Frage nicht. Könnte ich mehr
Informationen haben?");
}
}
[…]
A.14 Feedback Dialog (Ausschnitt)
public async Task MessageReceivedStart(IDialogContext context,
IAwaitable<IMessageActivity> argument)
{
// Die Nachricht vom User
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann XVIII
var message = await argument;
// z.B. User: Kann man euch bewerten?
if (message.Text.Contains("?"))
{
await context.PostAsync("Ja, natürlich.");
}
// Ausgabe
await context.PostAsync("Umfrage beginnt... Bitte beachten Sie, dass Sie die Umfrage
nur einmal durchführen können.");
await context.PostAsync("Wie zufrieden sind Sie mit uns generell?");
// Springt wieder zur Auswahl, was der User tun möchte
context.Wait(MessageReceivedOperationChoice);
}
public async Task MessageReceivedOperationChoice(IDialogContext context,
IAwaitable<IMessageActivity> argument)
{
// Die Nachricht vom User
var message = await argument;
// Klasse Luis aufrufen und entsprechenden Entity auslesen
Luis FeLuis = await GetEntityFromLuis(message.Text);
// Entity gefunden
if (FeLuis.intents.Count() > 0)
{
// Auswahl des entsprechenden Falls
switch (FeLuis.intents[0].intent)
{
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann XIX
// Positives Feedback
case "GoodFeedback":
await context.PostAsync("Das freut mich zu hören! Was hat Ihnen denn
besonders gut gefallen?");
context.Wait(ReceivedMessageGoodFeedback);
break;
// Negatives Feedback
case "BadFeedback":
await context.PostAsync("Das tut mir leid! Was hat Ihnen denn nicht
gefallen?");
context.Wait(ReceivedMessageBadFeedback);
break;
// Kein Feedback (z.B. "Keine Ahnung")
case "NoFeedback":
await context.PostAsync("Das klingt als hätten Sie noch nie bei uns bestellt.
Haben Sie Fragen?");
context.Wait(MessageReceivedNoFeedback);
break;
// Wenn der Bot den User nicht versteht
default:
await context.PostAsync("Wie bitte?");
context.Wait(MessageReceivedOperationChoice);
break;
}
}
else
{
// Wenn der Bot den User nicht versteht
await context.PostAsync("Wie bitte?");
context.Wait(MessageReceivedOperationChoice);
}
}
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann XX
public async Task ReceivedMessageGoodFeedback(IDialogContext context,
IAwaitable<IMessageActivity> argument)
{
// Die Nachricht vom User
var message = await argument;
// Klasse Luis aufrufen und entsprechenden Entity auslesen
Luis FeLuis = await GetEntityFromLuis(message.Text);
// Entity gefunden
if (FeLuis.intents.Count() > 0)
{
// Auswahl des entsprechenden Falls
switch (FeLuis.intents[0].intent)
{
// Guter Ablauf
case "procedure":
await context.PostAsync("Haben Sie bezüglich des Ablaufs noch irgendwelche
Fragen oder Wünsche?");
context.Wait(MessageReceivedFinish);
break;
// Gute Imprägnierung
case "impregnation":
await context.PostAsync("Haben Sie bezüglich der Imprägnierung noch Fragen
oder Wünsche?");
context.Wait(MessageReceivedFinish);
break;
// Guter Preis // Preis-Leistungsverhältnis
case "price":
await context.PostAsync("Haben Sie bezüglich des Preises noch irgendwelche
Fragen oder Wünsche?");
context.Wait(MessageReceivedFinish);
break;
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann XXI
case "NoFeedback":
await context.PostAsync("In Ordnung, haben Sie trotzdem vielen Dank!");
context.Wait(MessageReceivedFinish);
break;
default:
// Nachricht nicht verstanden
await context.PostAsync("Wie bitte?");
break;
}
}
else
{
// Wenn der Bot den User nicht versteht
await context.PostAsync("Wie bitte?");
context.Wait(MessageReceivedOperationChoice);
}
}
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann XXII
A.15 E-Mailadressen auf Duplikate prüfen und speichern
public async Task saveMail(IDialogContext context, IAwaitable<IMessageActivity>
argument)
{
try
{
// Nachricht vom User
var userMessage = await argument as Activity;
// Text der Nachricht
string mail = userMessage.Text;
// Variablen für SQL-Verbindung
string sqlCon = null;
string sql = null;
// Zugangsdaten
sqlCon = "user id=sa;" +
"password=sa;server=NOTEBOOKJK00X\\SQLEXPRESS;" +
"Trusted_Connection=yes;" +
"database=BotData; " +
"connection timeout=30";
// Erstellen der SQL-Verbindung
using (SqlConnection cnn = new SqlConnection(sqlCon))
{
// Anzahl an Einträgen mit dieser E-Mail Adresse zählen
sql = "SELECT COUNT(KundeMail) FROM Kunde WHERE Kunde
Mail=@mail";
// Öffnen der SQL-Verbindung
cnn.Open();
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann XXIII
// Erstellen des SQL-Commands
using (SqlCommand cmd = new SqlCommand(sql, cnn))
{
// Variable mail als Parameter hinzufügen
cmd.Parameters.AddWithValue("@mail", mail);
// Abfrage ausführen
cmd.ExecuteNonQuery();
// Anzahl an Einträgen mit der E-Mail Adresse auslesen
int count = Convert.ToInt32(cmd.ExecuteScalar());
// Wenn 0 / noch nicht vorhanden
if (count == 0)
{
// Einfügen der E-Mail
sql = "INSERT INTO Kunde (KundeMail) Values (@mail);";
using (SqlCommand cmd2 = new SqlCommand(sql, cnn))
{
cmd2.Parameters.AddWithValue("@mail", mail);
cmd2.ExecuteNonQuery();
}
}
else
{
// Falls die E-Mail Adresse bereits existiert
context.Done("Du scheinst schon teilgenommen zu haben. Was möchtest du
tun?");
}
}
}
Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice
Jim Eidmann XXIV
A.16 Ausschnitt Benutzerhandbuch
1. Neue Fragen / Antworten im QnA-Maker hinzufügen
Um neue Fragen / Antworten zum FAQ hinzufügen zu können, muss sich erst auf der offiziellen
Website des QnA-Makers eingeloggt werden.
URL: https://qnamaker.ai
Unter der Kategorie „My services“, in der oberen Menüleiste, kann man sich eine Übersicht
aller bereits erstellten Services anschauen.
Zum Bearbeiten eines Service muss auf das Stift-Symbol auf der rechten Seite geklickt werden.
In dem Bereich „Knowledge Base“ befinden sich die bereits erstellten FAQs. Falls noch keine
FAQs erstellt/hochgeladen wurden, ist diese leer.
Um ein neues FAQ hinzuzufügen, muss man in den Bereich „Settings“ gehen. Dort gibt es die
Möglichkeit, eine Website oder ein PDF zu hinterlegen. Nachdem das erledigt ist, kann der
Service mittels „Save and retrain“-Button trainiert werden. Anschließend wird er im Bereich
„Test“ auf seine Funktionalität geprüft.
Wenn alle Fragen korrekt beantwortet wurden, kann er mittels „Publish“-Button veröffentlicht
werden.
Alternativ besteht die Möglichkeit, in der „Knowledge Base“, einzelne Fragen- und
Antworttexte zu verändern.
[…]