Hinweis zum Ende des Supports: Am 15. September 2025 AWS wird der Support für Amazon Lex V1 eingestellt. Nach dem 15. September 2025 können Sie nicht mehr auf die Amazon-Lex-V1-Konsole oder die Amazon-Lex-V1-Ressourcen zugreifen. Wenn Sie Amazon Lex V2 verwenden, lesen Sie stattdessen das [Amazon Lex V2-Handbuch](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html).
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Übung 1: Erstellen eines Amazon Lex Lex-Bot mithilfe eines Blueprints (Konsole)
In dieser Übung führen Sie folgende Aufgaben aus:
+ Erstellen Sie Ihren ersten Amazon Lex Lex-Bot und testen Sie ihn in der Amazon Lex Lex-Konsole.
Für diese Übung verwenden Sie den **OrderFlowers**Blueprint. Weitere Informationen über Pläne finden Sie unter [Amazon Lex und AWS Lambda Blueprints](lex-lambda-blueprints.md).
+ Erstellen Sie eine AWS Lambda Funktion und testen Sie sie in der Lambda-Konsole. Während der Bearbeitung einer Anfrage ruft Ihr Bot diese Lambda-Funktion auf. Für diese Übung verwenden Sie einen in der AWS Lambda Konsole bereitgestellten Lambda-Blueprint (**lex-order-flowers-python**), um Ihre Lambda-Funktion zu erstellen. Der Blueprint-Code veranschaulicht, wie Sie dieselbe Lambda-Funktion verwenden können, um die Initialisierung und Validierung durchzuführen und die Absicht zu erfüllen. `OrderFlowers`
+ Aktualisieren Sie den Bot, um die Lambda-Funktion als Code-Hook hinzuzufügen, um die Absicht zu erfüllen. Testen Sie die end-to-end Erfahrung.
Die folgenden Abschnitte erläutern, was Pläne tun.
## Amazon Lex Bot: Blueprint-Übersicht
Sie verwenden den **OrderFlowers**Blueprint, um einen Amazon Lex Lex-Bot zu erstellen. Weitere Informationen zur Struktur eines Bots finden Sie unter. [Amazon Lex: So funktioniert's](how-it-works.md) Der Bot ist vorkonfiguriert wie folgt:
+ **Absicht —** OrderFlowers
+ **Slot-Typen** - Ein benutzerdefinierter Slot-Typ namens `FlowerTypes` mit Aufzählungswerten: `roses``lilies`, und `tulips`.
+ **Slots**: Die Absicht erfordert die folgenden Informationen (d. h. Slots), bevor der Bot die Absicht erfüllen kann.
+ `PickupTime`(AMAZON.TIME integrierter Typ)
+ `FlowerType`(FlowerTypes benutzerdefinierter Typ)
+ `PickupDate` (AMAZON.DATE integrierter Typ)
+ **Äußerung**: Die folgenden Beispieläußerungen zeigen die Absicht des Benutzers an:
+ "Ich möchte Blumen abholen."
+ "Ich möchte einige Blumen bestellen."
+ **fordert** - Nachdem der Bot die Absicht identifiziert, verwendet er die folgenden Anweisungen zum Ausfüllen der Slots:
+ Anforderung für den `FlowerType` Slot - "Was für Blumen möchten Sie bestellen?"
+ Aufforderung zur Eingabe des `PickupDate` Automaten — „An welchem Tag soll der \$1FlowerType\$1 abgeholt werden?“
+ Aufforderung zur Eingabe des `PickupTime` Automaten — „Um wie viel Uhr soll der \$1FlowerType\$1 abgeholt werden?“
+ Bestätigungserklärung — „Okay, Ihr \$1FlowerType\$1 wird bis \$1PickupTime\$1 am \$1PickupDate\$1 zur Abholung bereit sein. Ist das OK?"
## AWS Lambda Funktion: Blueprint-Zusammenfassung
Die Lambda-Funktion in dieser Übung führt sowohl Initialisierungs- als auch Validierungs- und Erfüllungsaufgaben aus. Daher aktualisieren Sie nach dem Erstellen der Lambda-Funktion die Absichtskonfiguration, indem Sie dieselbe Lambda-Funktion als Code-Hook angeben, um sowohl die Initialisierungs- als auch die Validierungs- und Erfüllungsaufgaben zu erledigen.
+ Als Code-Hook für Initialisierung und Validierung führt die Lambda-Funktion eine grundlegende Validierung durch. Wenn der Benutzer beispielsweise eine Uhrzeit für die Abholung angibt, die außerhalb der normalen Geschäftszeiten liegt, weist die Lambda-Funktion Amazon Lex an, den Benutzer erneut zur Eingabe der Uhrzeit aufzufordern.
+ Als Teil des Fulfillment-Code-Hooks gibt die Lambda-Funktion eine zusammenfassende Meldung zurück, die angibt, dass die Blumenbestellung aufgegeben wurde (d. h., dass die Absicht erfüllt wurde).
**Nächster Schritt**
[Schritt 1: Erstellen Sie einen Amazon Lex Bot (Konsole)](gs-bp-create-bot.md)
# Schritt 1: Erstellen Sie einen Amazon Lex Bot (Konsole)
Erstellen Sie für diese Übung einen Bot zum Bestellen von Blumen mit dem Namen OrderFlowersBot.
So erstellen Sie einen Amazon Lex Lex-Bot (Konsole)
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon Lex Lex-Konsole unter [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Wenn dies Ihr erster Bot ist, wählen Sie **Get Started (Erste Schritte)**; wählen Sie andernfalls auf der **Bots**-Seite **Create (Erstellen)**.
1. Geben Sie auf der Seite **Create your Lex bot** die folgenden Informationen an und wählen Sie dann **Create**.
+ Wählen Sie den Plan **OrderFlowers** aus.
+ Behalten Sie den Standard-Bot-Namen (OrderFlowers) bei.
+ Wählen Sie für **COPPA** **No** aus.
+ Wählen Sie für die **Speicherung von Benutzeräußerungen** die entsprechende Antwort aus.
1. Wählen Sie **Erstellen** aus. Die Konsole sendet die erforderlichen Anfragen an Amazon Lex, um die Konfiguration zu speichern. Die Konsole zeigt dann das Editorfenster für Bots an.
1. Warten Sie auf die Bestätigung, dass Ihr Bot erstellt wurde.
1. Testen Sie den Bot.
**Anmerkung**
Sie können den Bot durch die Eingabe von Text in das Testfenster oder durch Auswahl der Mikrofonschaltfläche im Testfenster und folgende Spracheingabe testen.
Geben Sie den folgenden Beispieltext ein, um mit dem Bot ein Gespräch über die Bestellung von Blumen zu führen:
![\[\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/OrderFlowers-NoLambda.png)
Aus dieser Eingabe leitet der Bot die Absicht `OrderFlowers` ab und fordert Slot-Daten an. Wenn Sie alle erforderlichen Slot-Daten angegeben haben, erfüllt der Bot die Absicht (`OrderFlowers`), indem er alle Daten an die Client-Anwendung (in diesem Fall die Konsole) zurückgibt. Die Konsole zeigt die Daten im Testfenster an.
Das heißt:
+ Die Aussage "An welchem Tag möchten Sie die Rosen abholen?" enthält den Ausdruck "Rosen", weil die Aufforderung für den Slot `pickupDate` unter Verwendung von Ersetzungen (`{FlowerType}`) konfiguriert wurde. Verifizieren Sie dies in der Konsole.
+ Die "Okay, die Rosen werden bereit sein..."-Aussage ist die von Ihnen konfigurierte Bestätigungsaufforderung.
+ Die letzte Anweisung ("`FlowerType:roses...`") bezeichnet einfach die Slot-Daten, die an den Client zurückgegeben werden, in diesem Fall das Testfenster. In der nächsten Übung verwenden Sie eine Lambda-Funktion, um die Absicht zu erfüllen. In diesem Fall erhalten Sie eine Meldung, dass die Bestellung erfüllt ist.
**Nächster Schritt**
[Schritt 2 (optional): Überprüfen der Details des Informationsflusses (Konsole)](gs-bp-details-two-runtime-apis.md)
# Schritt 2 (optional): Überprüfen der Details des Informationsflusses (Konsole)
In diesem Abschnitt wird der Informationsfluss zwischen einem Kunden und Amazon Lex für jede Benutzereingabe in unserer Beispielkonversation erklärt.
Das Beispiel verwendet das Konsolentestfenster für die Konversation mit dem Bot.
**Um das Amazon Lex Lex-Testfenster zu öffnen**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon Lex Lex-Konsole unter [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Wählen Sie den Bot aus, den Sie testen möchten.
1. Wählen Sie auf der rechten Seite der Konsole die Option **Chatbot testen** aus.
Wählen Sie das einschlägige Thema, um den Informationsfluss für gesprochene oder eingetippte Inhalte darzustellen.
**Topics**
+ [Schritt 2a (optional): Prüfen der Details des Informationsflusses gesprochener Inhalte (Konsole)](gs-bp-details-postcontent-flow.md)
+ [Schritt 2b (optional): Prüfen der Details des Informationsflusses eingetippter Inhalte (Konsole)](gs-bp-details-part1.md)
# Schritt 2a (optional): Prüfen der Details des Informationsflusses gesprochener Inhalte (Konsole)
In diesem Abschnitt wird der Informationsfluss zwischen dem Client und Amazon Lex erklärt, wenn der Client Sprachbefehle zum Senden von Anfragen verwendet. Weitere Informationen finden Sie unter [PostContent](API_runtime_PostContent.md).
1. Der Benutzer sagt: „Ich möchte Blumen bestellen.“
1. Der Client (Konsole) sendet die folgende [PostContent](API_runtime_PostContent.md)-Anforderung an Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "audio/x-l16; sample-rate=16000; channel-count=1"
Accept: "audio/mpeg"
Request body
input stream
```
Sowohl die Anforderungs-URI als auch der Text stellen Amazon Lex Informationen zur Verfügung:
+ Anfrage-URI — Gibt den Bot-Namen (`OrderFlowers`), den Bot-Alias (`$LATEST`) und den Benutzernamen (eine zufällige Zeichenfolge, die den Benutzer identifiziert) an. `content`gibt an, dass es sich um eine `PostContent` API-Anfrage (keine `PostText` Anfrage) handelt.
+ Anfordern von Headern
+ `x-amz-lex-session-attributes`— Der Base64-kodierte Wert steht für „\$1\$1“. Wenn der Client die erste Anforderung stellt, gibt es keine Sitzungsattribute.
+ `Content-Type`: Gibt das Audioformat wieder.
+ Anforderungstext: Der Audiostream der Benutzereingabe („Ich möchte Blumen bestellen.“)
**Anmerkung**
Wenn der Benutzer sich entscheidet, den Text („Ich möchte Blumen bestellen“) an die `PostContent`-API zu senden, anstatt ihn zu sprechen, ist der Anforderungstext die Benutzereingabe. Die `Content-Type`-Kopfzeile wird entsprechend eingestellt:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "text/plain; charset=utf-8"
Accept: accept
Request body
input stream
```
1. Aus dem Eingabestream erkennt Amazon Lex die Absicht (`OrderFlowers`). Es wählt dann einen der Slots der Absicht (in diesem Fall den `FlowerType`) und eine der Aufforderungen zur Abfrage von Werten. Dann sendet es eine Antwort mit den folgenden Kopfzeilen:
```
x-amz-lex-dialog-state:ElicitSlot
x-amz-lex-input-transcript:I would like to order some flowers.
x-amz-lex-intent-name:OrderFlowers
x-amz-lex-message:What type of flowers would you like to order?
x-amz-lex-session-attributes:e30=
x-amz-lex-slot-to-elicit:FlowerType
x-amz-lex-slots:eyJQaWNrdXBUaW1lIjpudWxsLCJGbG93ZXJUeXBlIjpudWxsLCJQaWNrdXBEYXRlIjpudWxsfQ==
```
Die Kopfzeilenwerte liefern die folgenden Informationen:
+ `x-amz-lex-input-transcript`: Liefert das Transkript des Audios (Benutzereingabe) der Anforderung.
+ `x-amz-lex-message`— Stellt das Transkript des Audios bereit, das Amazon Lex in der Antwort zurückgegeben hat
+ `x-amz-lex-slots`: Die base64-kodierte Version der Slots und Werte:
```
{"PickupTime":null,"FlowerType":null,"PickupDate":null}
```
+ `x-amz-lex-session-attributes`: Die base64-kodierte Version der Sitzungsattribute (\$1\$1):
Der Client gibt das Audio im Antworttext wieder.
1. Der Benutzer sagt: Rosen
1. Der Client (Konsole) sendet die folgende [PostContent](API_runtime_PostContent.md)-Anforderung an Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "audio/x-l16; sample-rate=16000; channel-count=1"
Accept: "audio/mpeg"
Request body
input stream ("roses")
```
Der Anforderungstext ist der Audiostream der Benutzereingabe (Rosen). Die `sessionAttributes` bleiben leer.
1. Amazon Lex interpretiert den Eingabestream im Kontext der aktuellen Absicht (es erinnert sich, dass es diesen Benutzer nach Informationen zum `FlowerType` Slot gefragt hat). Amazon Lex aktualisiert zunächst den Slot-Wert für die aktuelle Absicht. Er wählt einen anderen Slot (`PickupDate`) zusammen mit einer der Aufforderungen ("Wann möchten Sie die Rosen abholen?") und gibt eine Antwort mit folgendem Header zurück:
```
x-amz-lex-dialog-state:ElicitSlot
x-amz-lex-input-transcript:roses
x-amz-lex-intent-name:OrderFlowers
x-amz-lex-message:When do you want to pick up the roses?
x-amz-lex-session-attributes:e30=
x-amz-lex-slot-to-elicit:PickupDate
x-amz-lex-slots:eyJQaWNrdXBUaW1lIjpudWxsLCJGbG93ZXJUeXBlIjoicm9zaSdzIiwiUGlja3VwRGF0ZSI6bnVsbH0=
```
Die Kopfzeilenwerte liefern die folgenden Informationen:
+ `x-amz-lex-slots`: Die base64-kodierte Version der Slots und Werte:
```
{"PickupTime":null,"FlowerType":"roses","PickupDate":null}
```
+ `x-amz-lex-session-attributes`: Die base64-kodierte Version der Sitzungsattribute (\$1\$1):
Der Client gibt das Audio im Antworttext wieder.
1. Der Benutzer sagt: morgen
1. Der Client (Konsole) sendet die folgende [PostContent](API_runtime_PostContent.md)-Anforderung an Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "audio/x-l16; sample-rate=16000; channel-count=1"
Accept: "audio/mpeg"
Request body
input stream ("tomorrow")
```
Der Anforderungstext ist der Audiostream der Benutzereingabe („morgen“). Die `sessionAttributes` bleiben leer.
1. Amazon Lex interpretiert den Eingabestream im Kontext der aktuellen Absicht (es erinnert sich, dass es diesen Benutzer nach Informationen zum `PickupDate` Slot gefragt hat). Amazon Lex aktualisiert den slot (`PickupDate`) -Wert für die aktuelle Absicht. Dann wählt es einen anderen Slot, um einen Wert zu erfragen (`PickupTime`) und eine der Aufforderungen zur Eingabe eines Werts (Wann möchten Sie die Rosen am 18.03.2017 abholen?) und gibt eine Antwort mit den folgenden Kopfzeilen zurück:
```
x-amz-lex-dialog-state:ElicitSlot
x-amz-lex-input-transcript:tomorrow
x-amz-lex-intent-name:OrderFlowers
x-amz-lex-message:When do you want to pick up the roses on 2017-03-18?
x-amz-lex-session-attributes:e30=
x-amz-lex-slot-to-elicit:PickupTime
x-amz-lex-slots:eyJQaWNrdXBUaW1lIjpudWxsLCJGbG93ZXJUeXBlIjoicm9zaSdzIiwiUGlja3VwRGF0ZSI6IjIwMTctMDMtMTgifQ==
x-amzn-RequestId:3a205b70-0b69-11e7-b447-eb69face3e6f
```
Die Kopfzeilenwerte liefern die folgenden Informationen:
+ `x-amz-lex-slots`: Die base64-kodierte Version der Slots und Werte:
```
{"PickupTime":null,"FlowerType":"roses","PickupDate":"2017-03-18"}
```
+ `x-amz-lex-session-attributes`: Die base64-kodierte Version der Sitzungsattribute (\$1\$1):
Der Client gibt das Audio im Antworttext wieder.
1. Der Benutzer sagt: 18 Uhr
1. Der Client (Konsole) sendet die folgende [PostContent](API_runtime_PostContent.md)-Anforderung an Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "text/plain; charset=utf-8"
Accept: "audio/mpeg"
Request body
input stream ("6 pm")
```
Der Anforderungstext ist der Audiostream der Benutzereingabe („18 Uhr“). Die `sessionAttributes` bleiben leer.
1. Amazon Lex interpretiert den Eingabestream im Kontext der aktuellen Absicht (es erinnert sich, dass es diesen Benutzer nach Informationen zum `PickupTime` Slot gefragt hat). Es aktualisiert zuerst den Slot-Wert für die aktuelle Absicht.
Jetzt erkennt Amazon Lex, dass es Informationen für alle Slots hat. Die Absicht `OrderFlowers` ist jedoch mit einer Bestätigungsmitteilung konfiguriert. Daher benötigt Amazon Lex eine ausdrückliche Bestätigung des Benutzers, bevor es mit der Erfüllung der Absicht fortfahren kann. Es sendet eine Antwort mit den folgenden Kopfzeilen, die eine Bestätigung anfordert, bevor die Blumen bestellt werden:
```
x-amz-lex-dialog-state:ConfirmIntent
x-amz-lex-input-transcript:six p. m.
x-amz-lex-intent-name:OrderFlowers
x-amz-lex-message:Okay, your roses will be ready for pickup by 18:00 on 2017-03-18. Does this sound okay?
x-amz-lex-session-attributes:e30=
x-amz-lex-slots:eyJQaWNrdXBUaW1lIjoiMTg6MDAiLCJGbG93ZXJUeXBlIjoicm9zaSdzIiwiUGlja3VwRGF0ZSI6IjIwMTctMDMtMTgifQ==
x-amzn-RequestId:083ca360-0b6a-11e7-b447-eb69face3e6f
```
Die Kopfzeilenwerte liefern die folgenden Informationen:
+ `x-amz-lex-slots`: Die base64-kodierte Version der Slots und Werte:
```
{"PickupTime":"18:00","FlowerType":"roses","PickupDate":"2017-03-18"}
```
+ `x-amz-lex-session-attributes`: Die base64-kodierte Version der Sitzungsattribute (\$1\$1):
Der Client gibt das Audio im Antworttext wieder.
1. Der Benutzer sagt: Ja
1. Der Client (Konsole) sendet die folgende [PostContent](API_runtime_PostContent.md)-Anforderung an Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
x-amz-lex-session-attributes: "e30="
Content-Type: "audio/x-l16; sample-rate=16000; channel-count=1"
Accept: "audio/mpeg"
Request body
input stream ("Yes")
```
Der Anforderungstext ist der Audiostream der Benutzereingabe („Ja“). Die `sessionAttributes` bleiben leer.
1. Amazon Lex interpretiert den Eingabestream und versteht, dass der Benutzer mit der Bestellung fortfahren möchte. Die Absicht `OrderFlowers` wird mit `ReturnIntent` als Erfüllungsaktivität konfiguriert. Dadurch wird Amazon Lex angewiesen, alle Absichtsdaten an den Kunden zurückzugeben. Amazon Lex gibt eine Antwort mit folgendem Inhalt zurück:
```
x-amz-lex-dialog-state:ReadyForFulfillment
x-amz-lex-input-transcript:yes
x-amz-lex-intent-name:OrderFlowers
x-amz-lex-session-attributes:e30=
x-amz-lex-slots:eyJQaWNrdXBUaW1lIjoiMTg6MDAiLCJGbG93ZXJUeXBlIjoicm9zaSdzIiwiUGlja3VwRGF0ZSI6IjIwMTctMDMtMTgifQ==
```
Die Antwortkopfzeile `x-amz-lex-dialog-state` ist eingestellt auf `ReadyForFulfillment`. Der Client kann die Absicht dann erfüllen.
1. Testen Sie den Bot jetzt erneut. Um einen neuen Benutzerkontext einzurichten, wählen Sie den Link **Clear** in der Konsole. Geben Sie Daten für die Absicht `OrderFlowers` an und fügen Sie dabei einige ungültige Daten ein. Beispiel:
+ Jasmin als Blumenart (zählt nicht zu den unterstützten Blumenarten)
+ Gestern als den Tag, an dem Sie die Blumen abholen möchten
Beachten Sie, dass der Bot diese Werte akzeptiert, weil Sie keinen Code haben, um die Benutzerdaten zu initialisieren und zu validieren. Im nächsten Abschnitt fügen Sie dazu eine Lambda-Funktion hinzu. Beachten Sie Folgendes zur Lambda-Funktion:
+ Sie validiert Slot-Daten nach jeder Benutzereingabe. Sie erfüllt schließlich die Absicht. Der Bot verarbeitet also die Blumenbestellung und gibt eine Mitteilung an den Benutzer zurück, statt einfach Slot-Daten an den Client zurückzugeben. Weitere Informationen finden Sie unter [Verwendung von Lambda-Funktionen](using-lambda.md).
+ Sie stellt auch die Sitzungsattribute ein. Weitere Informationen über Sitzungsattribute finden Sie unter [PostText](API_runtime_PostText.md).
Nachdem Sie den Abschnitt "Erste Schritte" abgeschlossen haben, können Sie die zusätzlichen Übungen ausführen ([Zusätzliche Beispiele: Amazon Lex Bots erstellen](additional-exercises.md)). [Reise buchen](ex-book-trip.md) verwendet Sitzungsattribute, um Informationen über Absichten hinweg gemeinsam zu nutzen und so eine dynamische Unterhaltung mit dem Benutzer zu führen.
**Nächster Schritt**
[Schritt 3: Lambda-Funktion erstellen (Konsole)](gs-bp-create-lambda-function.md)
# Schritt 2b (optional): Prüfen der Details des Informationsflusses eingetippter Inhalte (Konsole)
In diesem Abschnitt wird der Informationsfluss zwischen dem Client und Amazon Lex erklärt, in dem der Client die `PostText`-API zur Übermittlung von Anforderungen verwendet. Weitere Informationen finden Sie unter [PostText](API_runtime_PostText.md).
1. Der Benutzer gibt ein: Ich möchte Blumen bestellen.
1. Der Client (Konsole) sendet die folgende [PostText](API_runtime_PostText.md)-Anforderung an Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "I would like to order some flowers",
"sessionAttributes": {}
}
```
Sowohl die Anforderungs-URI als auch der Text stellen Amazon Lex Informationen zur Verfügung:
+ Anfrage-URI — Stellt den Bot-Namen (`OrderFlowers`), den Bot-Alias (`$LATEST`) und den Benutzernamen (eine zufällige Zeichenfolge zur Identifizierung des Benutzers) bereit. Der abschließende `text` zeigt an, dass es sich um eine `PostText`-API-Anforderung handelt (und nicht um `PostContent`).
+ Anforderungsinhalt: Enthält die Benutzereingabe (`inputText`) und leere `sessionAttributes`. Wenn der Client die erste Anforderung stellt, gibt es keine Sitzungsattribute. Die Lambda-Funktion initiiert sie später.
1. Anhand `inputText` von erkennt Amazon Lex die Absicht (`OrderFlowers`). Für diese Absicht gibt es keine Code-Hooks (d. h. die Lambda-Funktionen) für die Initialisierung und Validierung von Benutzereingaben oder deren Ausführung.
Amazon Lex wählt einen der Slots (`FlowerType`) der Absicht aus, um den Wert abzurufen. Es wählt auch eine der Aufforderungen zur Angabe von Werten für den Slot aus (alle Teil der Konfiguration der Absicht) und sendet dann die folgende Antwort an den Client zurück. Die Konsole zeigt die Mitteilung in der Antwort an den Benutzer an.
![\[\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/gs-1-details-10.png)
Der Client zeigt die Mitteilung in der Antwort an.
1. Benutzer gibt ein: Rosen
1. Der Client (Konsole) sendet die folgende [PostText](API_runtime_PostText.md)-Anforderung an Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "roses",
"sessionAttributes": {}
}
```
`inputText` im Anforderungstext stellt die Benutzereingabe bereit. Die `sessionAttributes` bleiben leer.
1. Amazon Lex interpretiert das zunächst `inputText` im Kontext der aktuellen Absicht — der Service erinnert sich, dass er den jeweiligen Benutzer nach Informationen über den Slot gefragt hat. `FlowerType` Amazon Lex aktualisiert zunächst den Slot-Wert für die aktuelle Absicht und wählt einen anderen Slot (`PickupDate`) zusammen mit einer der Eingabeaufforderungen aus: An welchem Tag sollen die Rosen abgeholt werden? — `` für den Slot.
Dann gibt Amazon Lex die folgende Antwort zurück:
![\[\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/gs-1-details-20.png)
Der Client zeigt die Mitteilung in der Antwort an.
1. Benutzer gibt ein: morgen
1. Der Client (Konsole) sendet die folgende [PostText](API_runtime_PostText.md)-Anforderung an Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "tomorrow",
"sessionAttributes": {}
}
```
`inputText` im Anforderungstext stellt die Benutzereingabe bereit. Die `sessionAttributes` bleiben leer.
1. Amazon Lex interpretiert das zunächst `inputText` im Kontext der aktuellen Absicht — der Service erinnert sich, dass er den jeweiligen Benutzer nach Informationen über den Slot gefragt hat. `PickupDate` Amazon Lex aktualisiert den slot (`PickupDate`) -Wert für die aktuelle Absicht. Es wählt einen anderen Slot aus, um den Wert zu erfragen (`PickupTime`). Es gibt eine der Eingabeaufforderungen zur Wertermittlung zurück: Um wie viel Uhr sollen die Rosen am 05.01.2017 geliefert werden? — an den Kunden. ``
Amazon Lex gibt dann die folgende Antwort zurück:
![\[\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/gs-1-details-30.png)
Der Client zeigt die Mitteilung in der Antwort an.
1. Benutzer gibt ein: 18 Uhr
1. Der Client (Konsole) sendet die folgende [PostText](API_runtime_PostText.md)-Anforderung an Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "6 pm",
"sessionAttributes": {}
}
```
`inputText` im Anforderungstext stellt die Benutzereingabe bereit. Die `sessionAttributes` bleiben leer.
1. Amazon Lex interpretiert das zunächst `inputText` im Kontext der aktuellen Absicht — der Service erinnert sich, dass er den jeweiligen Benutzer nach Informationen über den Slot gefragt hat. `PickupTime` Amazon Lex aktualisiert zunächst den Slot-Wert für die aktuelle Absicht. Jetzt erkennt Amazon Lex, dass es Informationen für alle Slots hat.
Die Absicht `OrderFlowers` ist mit einer Bestätigungsmitteilung konfiguriert. Daher benötigt Amazon Lex eine ausdrückliche Bestätigung des Benutzers, bevor es mit der Erfüllung der Absicht fortfahren kann. Amazon Lex sendet die folgende Nachricht an den Kunden und bittet um Bestätigung, bevor er die Blumen bestellt:
![\[\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/gs-1-details-40.png)
Der Client zeigt die Mitteilung in der Antwort an.
1. Benutzer gibt ein: Ja
1. Der Client (Konsole) sendet die folgende [PostText](API_runtime_PostText.md)-Anforderung an Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "Yes",
"sessionAttributes": {}
}
```
`inputText` im Anforderungstext stellt die Benutzereingabe bereit. Die `sessionAttributes` bleiben leer.
1. Amazon Lex interpretiert das `inputText` im Zusammenhang mit der Bestätigung der aktuellen Absicht. Es versteht, dass der Benutzer mit der Bestellung fortfahren möchte. Die `OrderFlowers` Absicht ist `ReturnIntent` als Fulfillment-Aktivität konfiguriert (es gibt keine Lambda-Funktion, um die Absicht zu erfüllen). Daher gibt Amazon Lex die folgenden Slot-Daten an den Client zurück.
![\[\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/gs-1-details-50.png)
Amazon Lex hat das `dialogState` auf gesetzt`ReadyForFulfillment`. Der Client kann die Absicht dann erfüllen.
1. Testen Sie nun den Bot erneut. Dafür müssen Sie den Link **Clear** in der Konsole wählen, um einen neuen (Benutzer-)Kontext zu etablieren. Jetzt, da Sie die Daten für die Absicht Blumenbestellung angegeben haben, versuchen Sie, ungültige Daten anzugeben. Beispiel:
+ Jasmin als Blumenart (zählt nicht zu den unterstützten Blumenarten)
+ Gestern als den Tag, an dem Sie die Blumen abholen möchten
Beachten Sie, dass der Bot diese Werte akzeptiert, da Sie keinen Code für initialize/validate Benutzerdaten haben. Im nächsten Abschnitt fügen Sie dazu eine Lambda-Funktion hinzu. Beachten Sie Folgendes zur Lambda-Funktion:
+ Die Lambda-Funktion validiert Slot-Daten nach jeder Benutzereingabe. Sie erfüllt schließlich die Absicht. Der Bot verarbeitet also die Blumenbestellung und gibt eine Mitteilung an den Benutzer zurück, statt einfach Slot-Daten an den Client zurückzugeben. Weitere Informationen finden Sie unter [Verwendung von Lambda-Funktionen](using-lambda.md).
+ Die Lambda-Funktion legt auch die Sitzungsattribute fest. Weitere Informationen über Sitzungsattribute finden Sie unter [PostText](API_runtime_PostText.md).
Nachdem Sie den Abschnitt "Erste Schritte" abgeschlossen haben, können Sie die zusätzlichen Übungen ausführen ([Zusätzliche Beispiele: Amazon Lex Bots erstellen](additional-exercises.md)). [Reise buchen](ex-book-trip.md) verwendet Sitzungsattribute, um Informationen über Absichten hinweg gemeinsam zu nutzen und so eine dynamische Unterhaltung mit dem Benutzer zu führen.
**Nächster Schritt**
[Schritt 3: Lambda-Funktion erstellen (Konsole)](gs-bp-create-lambda-function.md)
# Schritt 3: Lambda-Funktion erstellen (Konsole)
Erstellen Sie eine Lambda-Funktion (mithilfe des **lex-order-flowers-python**Blueprints) und führen Sie einen Testaufruf mit Beispielereignisdaten in der Konsole durch. AWS Lambda
Sie kehren zur Amazon Lex Lex-Konsole zurück und fügen die Lambda-Funktion als Code-Hook hinzu, um die `OrderFlowers` Absicht zu erfüllen`OrderFlowersBot`, die Sie im vorherigen Abschnitt erstellt haben.
**So erstellen Sie eine Lambda-Funktion (Konsole)**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AWS Lambda Konsole unter [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Wählen Sie **Funktion erstellen**.
1. Wählen Sie auf der Seite **Create function (Funktion erstellen)** die Option **Use a blueprint (Blueprint verwenden)** aus. Geben Sie **lex-** in das Textfeld für den Filter ein. Drücken Sie anschließend `Enter`, um die Vorlage zu suchen, und wählen Sie die Vorlage `lex-order-flowers-python` aus.
Lambda-Funktions-Blueprints werden sowohl in Node.js als auch in Python bereitgestellt. Verwenden Sie für diese Übung den auf Python basierenden Plan.
1. Führen Sie auf der Seite **Basic information (Basisinformationen)** folgende Schritte aus:
+ Geben Sie einen Lambda-Funktionsnamen (`OrderFlowersCodeHook`) ein.
+ Wählen Sie für die Ausführungsrolle **Create a new role with basic Lambda permissions** aus.
+ Übernehmen Sie im Übrigen die Standardwerte.
1. Wählen Sie **Funktion erstellen**.
1. Wenn Sie ein anderes Gebietsschema als Englisch (US) (en-US) verwenden, aktualisieren Sie die Namen der Absichten wie unter beschrieben. [Einen Blueprint für ein bestimmtes Gebietsschema aktualisieren](lex-lambda-blueprints.md#blueprint-update-locale)
1. Testen Sie die Lambda-Funktion.
1. Wählen Sie **Select a test event (Testereignis auswählen)**, **Configure test events (Testereignisse konfigurieren)** aus.
1. Wählen Sie **Amazon Lex Order Flowers** aus der Liste der **Event-Vorlagen** aus. Dieses Beispielereignis entspricht dem Amazon Lex request/response Lex-Modell (siehe[Verwendung von Lambda-Funktionen](using-lambda.md)). Geben Sie dem Testereignis einen Namen (`LexOrderFlowersTest`).
1. Wählen Sie **Erstellen** aus.
1. Wählen Sie **Test (Testen)** aus, um den Code-Haken zu testen.
1. Stellen Sie sicher, dass die Lambda-Funktion erfolgreich ausgeführt wurde. Die Antwort entspricht in diesem Fall dem Amazon Lex Lex-Antwortmodell.
**Nächster Schritt**
[Schritt 4: Fügen Sie die Lambda-Funktion als Code-Hook hinzu (Konsole)](gs-bp-create-integrate.md)
# Schritt 4: Fügen Sie die Lambda-Funktion als Code-Hook hinzu (Konsole)
In diesem Abschnitt aktualisieren Sie die Konfiguration der OrderFlowers Absicht, die Lambda-Funktion zu verwenden, wie folgt:
+ Verwenden Sie zunächst die Lambda-Funktion als Code-Hook, um die `OrderFlowers` Absicht zu erfüllen. Sie testen den Bot und stellen sicher, dass Sie eine Fulfillment-Nachricht von der Lambda-Funktion erhalten haben. Amazon Lex ruft die Lambda-Funktion erst auf, nachdem Sie Daten für alle erforderlichen Slots für die Blumenbestellung bereitgestellt haben.
+ Konfigurieren Sie dieselbe Lambda-Funktion als Code-Hook, um die Initialisierung und Validierung durchzuführen. Sie testen und überprüfen, ob die Lambda-Funktion eine Validierung durchführt (wenn Sie Slot-Daten angeben).
**Um eine Lambda-Funktion als Code-Hook hinzuzufügen (Konsole)**
1. Wählen Sie in der Amazon Lex-Konsole den **OrderFlowers**Bot aus. Die Konsole zeigt die **OrderFlowers**Absicht an. Stellen Sie sicher, dass die Absichtsversion auf `$LATEST` eingestellt ist, da dies die einzige Version ist, die wir ändern können.
1. Fügen Sie die Lambda-Funktion als Fulfillment-Code-Hook hinzu und testen Sie sie.
1. Wählen Sie im Editor die **AWS Lambda Funktion** **Fulfillment** und dann die Lambda-Funktion aus, die Sie im vorherigen Schritt erstellt haben (`OrderFlowersCodeHook`). Wählen Sie **OK**, um Amazon Lex die Erlaubnis zu erteilen, die Lambda-Funktion aufzurufen.
Sie konfigurieren diese Lambda-Funktion als Code-Hook, um die Absicht zu erfüllen. Amazon Lex ruft diese Funktion erst auf, nachdem es alle erforderlichen Slot-Daten vom Benutzer erhalten hat, um die Absicht zu erfüllen.
1. Geben Sie eine **Goodbye message** an.
1. Wählen Sie **Build** aus.
1. Testen Sie den Bot mit der vorherigen Konversation.
Die letzte Aussage „Danke, deine Bestellung für Rosen...“ ist eine Antwort der Lambda-Funktion, die du als Code-Hook konfiguriert hast. Im vorherigen Abschnitt gab es keine Lambda-Funktion. Jetzt verwenden Sie eine Lambda-Funktion, um die `OrderFlowers` Absicht tatsächlich zu erfüllen.
1. Fügen Sie die Lambda-Funktion als Code-Hook für Initialisierung und Validierung hinzu und testen Sie.
Der Lambda-Beispielcode, den Sie verwenden, kann sowohl die Validierung als auch die Erfüllung von Benutzereingaben durchführen. Das Eingabeereignis, das die Lambda-Funktion empfängt, hat ein Feld (`invocationSource`), anhand dessen der Code bestimmt, welcher Teil des Codes ausgeführt werden soll. Weitere Informationen finden Sie unter [Eingabeereignis und Antwortformat der Lambda-Funktion](lambda-input-response-format.md).
1. Wählen Sie die "\$1LATEST"-Version der `OrderFlowers`-Absicht aus. Das ist die einzige Version, die Sie aktualisieren können.
1. Wählen Sie im Editor unter **Options** den Wert **Initialization and validation** aus.
1. Wählen Sie erneut dieselbe Lambda-Funktion aus.
1. Wählen Sie **Build** aus.
1. Testen Sie den Bot.
Sie sind jetzt bereit, mit Amazon Lex zu sprechen, wie in der folgenden Abbildung dargestellt. Um den Validierungsteil zu testen, wählen Sie die Uhrzeit 18 Uhr und Ihre Lambda-Funktion gibt eine Antwort zurück („Unsere Geschäftszeiten sind von 10 Uhr bis 17 Uhr.“) und Sie werden erneut aufgefordert. Nachdem Sie alle gültigen Slot-Daten angegeben haben, erfüllt die Lambda-Funktion die Bestellung.
![\[\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/OrderFlowers-FullLambda.png)
**Nächster Schritt**
[Schritt 5 (optional): Prüfen der Details des Informationsflusses (Konsole)](gs-bp-details-after-lambda.md)
# Schritt 5 (optional): Prüfen der Details des Informationsflusses (Konsole)
In diesem Abschnitt wird der Informationsfluss zwischen dem Client und Amazon Lex für jede Benutzereingabe erläutert, einschließlich der Integration der Lambda-Funktion.
**Anmerkung**
In diesem Abschnitt wird davon ausgegangen, dass der Client Anfragen über die `PostText` Runtime-API an Amazon Lex sendet, und zeigt die Anfrage- und Antwortdetails entsprechend an. Ein Beispiel für den Informationsfluss zwischen dem Client und Amazon Lex, bei dem der Client die `PostContent` API verwendet, finden Sie unter[Schritt 2a (optional): Prüfen der Details des Informationsflusses gesprochener Inhalte (Konsole)](gs-bp-details-postcontent-flow.md).
Weitere Informationen über die `PostText`-Laufzeit-API und weitere Details zu den Anforderungen und Antworten, die in den folgenden Schritten gezeigt werden, finden Sie unter [PostText](API_runtime_PostText.md).
1. Benutzer: Ich möchte einige Blumen bestellen.
1. Der Client (Konsole) sendet die folgende [PostText](API_runtime_PostText.md)-Anforderung an Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "I would like to order some flowers",
"sessionAttributes": {}
}
```
Sowohl die Anforderungs-URI als auch der Text stellen Amazon Lex Informationen zur Verfügung:
+ Anfrage-URI — Stellt den Bot-Namen (`OrderFlowers`), den Bot-Alias (`$LATEST`) und den Benutzernamen (eine zufällige Zeichenfolge zur Identifizierung des Benutzers) bereit. Der abschließende `text` zeigt an, dass es sich um eine `PostText`-API-Anforderung handelt (und nicht um `PostContent`).
+ Anforderungsinhalt: Enthält die Benutzereingabe (`inputText`) und leere `sessionAttributes`. Wenn der Client die erste Anforderung stellt, gibt es keine Sitzungsattribute. Die Lambda-Funktion initiiert sie später.
1. Anhand `inputText` von erkennt Amazon Lex die Absicht (`OrderFlowers`). Diese Absicht ist mit einer Lambda-Funktion als Code-Hook für die Initialisierung und Validierung von Benutzerdaten konfiguriert. Daher ruft Amazon Lex diese Lambda-Funktion auf, indem es die folgenden Informationen als Ereignisdaten weitergibt:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "ignw84y6seypre4xly5rimopuri2xwnd",
"sessionAttributes": {},
"bot": {
"name": "OrderFlowers",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"PickupTime": null,
"FlowerType": null,
"PickupDate": null
},
"confirmationStatus": "None"
}
}
```
Weitere Informationen finden Sie unter [Eingabe-Ereignis-Format](lambda-input-response-format.md#using-lambda-input-event-format).
Zusätzlich zu den Informationen, die der Kunde gesendet hat, enthält Amazon Lex auch die folgenden zusätzlichen Daten:
+ `messageVersion`— Derzeit unterstützt Amazon Lex nur die Version 1.0.
+ `invocationSource`— Zeigt den Zweck des Aufrufs der Lambda-Funktion an. In diesem Fall ist es die Durchführung der Initialisierung und Validierung von Benutzerdaten. Derzeit weiß Amazon Lex, dass der Benutzer nicht alle Slot-Daten bereitgestellt hat, um die Absicht zu erfüllen.
+ `currentIntent`-Daten, wobei alle Slot-Werte auf Null gesetzt sind.
1. Zu diesem Zeitpunkt sind alle Slot-Werte auf Null gesetzt. Die Lambda-Funktion muss nichts validieren. Die Lambda-Funktion gibt die folgende Antwort an Amazon Lex zurück:
```
{
"sessionAttributes": {},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": null,
"PickupDate": null
}
}
}
```
Weitere Informationen über das Antwortformat finden Sie unter [Reaktion-Format](lambda-input-response-format.md#using-lambda-response-format).
Beachten Sie Folgendes:
+ `dialogAction.type`— Wenn Sie diesen Wert auf setzen`Delegate`, delegiert die Lambda-Funktion die Verantwortung für die Entscheidung über die nächste Vorgehensweise an Amazon Lex.
**Anmerkung**
Wenn die Lambda-Funktion etwas in der Benutzerdatenvalidierung erkennt, weist sie Amazon Lex an, was als Nächstes zu tun ist, wie in den nächsten Schritten gezeigt.
1. Laut dem `dialogAction.type` entscheidet Amazon Lex über die nächste Vorgehensweise. Da keiner der Slots ausgefüllt ist, entscheidet es, den Wert für den Slot `FlowerType` zu erfragen. Es wählt auch eine der Aufforderungen zur Angabe von Werten für diesen Slot aus ("Welche Art Blumen möchten Sie bestellen?") und sendet dann die folgende Antwort an den Client zurück:
![\[\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/gs-1-details-10.png)
Der Client zeigt die Mitteilung in der Antwort an.
1. Benutzer: Rosen
1. Der Client sendet die folgende [PostText](API_runtime_PostText.md) Anfrage an Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "roses",
"sessionAttributes": {}
}
```
Im Anforderungstext liefert der `inputText` die Benutzereingabe. Die `sessionAttributes` bleiben leer.
1. Amazon Lex interpretiert das zunächst `inputText` im Kontext der aktuellen Absicht. Der Service "erinnert sich" daran, den spezifischen Benutzer nach Informationen über den Slot `FlowerType` gefragt zu haben. Es aktualisiert den Slot-Wert in der aktuellen Absicht und ruft die Lambda-Funktion mit den folgenden Ereignisdaten auf:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "ignw84y6seypre4xly5rimopuri2xwnd",
"sessionAttributes": {},
"bot": {
"name": "OrderFlowers",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": null
},
"confirmationStatus": "None"
}
}
```
Beachten Sie Folgendes:
+ `invocationSource`: Ist immer noch `DialogCodeHook` (wir validieren einfach Benutzerdaten).
+ `currentIntent.slots`— Amazon Lex hat den `FlowerType` Slot auf Rosen aktualisiert.
1. Je nach `invocationSource` Wert von `DialogCodeHook` führt die Lambda-Funktion eine Benutzerdatenvalidierung durch. Es wird `roses` als gültiger Slot-Wert erkannt (und `Price` als Sitzungsattribut festgelegt) und gibt die folgende Antwort an Amazon Lex zurück.
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": null
}
}
}
```
Beachten Sie Folgendes:
+ `sessionAttributes`— Die Lambda-Funktion hat `Price` (von den Rosen) als Sitzungsattribut hinzugefügt.
+ `dialogAction.type`: Wird auf `Delegate` gesetzt. Die Benutzerdaten waren gültig, sodass die Lambda-Funktion Amazon Lex anweist, die nächste Vorgehensweise zu wählen.
1. Laut dem `dialogAction.type` wählt Amazon Lex die nächste Vorgehensweise. Amazon Lex weiß, dass mehr Steckplatzdaten benötigt werden, und wählt daher den nächsten unbesetzten Steckplatz (`PickupDate`) mit der höchsten Priorität entsprechend der Absichtskonfiguration aus. Amazon Lex wählt eine der Eingabeaufforderungen zur Wertermittlung aus: „An welchem Tag sollen die Rosen abgeholt werden?“ — für diesen Slot entsprechend der Intent-Konfiguration und sendet dann die folgende Antwort zurück an den Client:
![\[\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/gs-1-details-20.png)
Der Client zeigt einfach die Mitteilung in der Antwort an: "An welchem Tag möchten Sie die Rosen abholen?"
1. Benutzer: morgen
1. Der Client sendet die folgende [PostText](API_runtime_PostText.md) Anfrage an Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "tomorrow",
"sessionAttributes": {
"Price": "25"
}
}
```
Im Anforderungstext liefert `inputText` die Benutzereingabe und der Client gibt die Sitzungsattribute an den Service zurück.
1. Amazon Lex erinnert sich an den Kontext — dass es Daten für den Slot abgerufen hat. `PickupDate` In diesem Kontext weiß es, dass der Wert `inputText` für den Slot `PickupDate` ist. Amazon Lex ruft dann die Lambda-Funktion auf, indem es das folgende Ereignis sendet:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "ignw84y6seypre4xly5rimopuri2xwnd",
"sessionAttributes": {
"Price": "25"
},
"bot": {
"name": "OrderFlowersCustomWithRespCard",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": "2017-01-05"
},
"confirmationStatus": "None"
}
}
```
Amazon Lex hat das aktualisiert, `currentIntent.slots` indem es den `PickupDate` Wert festgelegt hat. Beachten Sie auch, dass der Dienst das `sessionAttributes` unverändert an die Lambda-Funktion weitergibt.
1. Gemäß dem `invocationSource` Wert von `DialogCodeHook` führt die Lambda-Funktion eine Benutzerdatenvalidierung durch. Es erkennt, dass der `PickupDate` Slot-Wert gültig ist, und gibt die folgende Antwort an Amazon Lex zurück:
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": null,
"FlowerType": "roses",
"PickupDate": "2017-01-05"
}
}
}
```
Beachten Sie Folgendes:
+ `sessionAttributes`: Keine Änderung.
+ `dialogAction.type`: Wird auf `Delegate` gesetzt. Die Benutzerdaten waren gültig, und die Lambda-Funktion weist Amazon Lex an, die nächste Vorgehensweise zu wählen.
1. Laut dem `dialogAction.type` wählt Amazon Lex die nächste Vorgehensweise. Amazon Lex weiß, dass mehr Steckplatzdaten benötigt werden, und wählt daher den nächsten unbesetzten Steckplatz (`PickupTime`) mit der höchsten Priorität entsprechend der Absichtskonfiguration aus. Amazon Lex wählt eine der Aufforderungsnachrichten aus („Um welche Uhrzeit am 05.01.2017 sollen die Rosen geliefert werden?“) für diesen Slot entsprechend der Intent-Konfiguration und sendet die folgende Antwort zurück an den Client:
![\[\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/gs-1-details-30.png)
Der Client zeigt in der Antwort die folgende Meldung an: „Um welche Uhrzeit sollen die Rosen am 05.01.2017 geliefert werden?“
1. Benutzer: 16 Uhr
1. Der Client sendet die folgende [PostText](API_runtime_PostText.md) Anfrage an Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "4 pm",
"sessionAttributes": {
"Price": "25"
}
}
```
Im Anforderungstext liefert der `inputText` die Benutzereingabe. Der Client übergibt die `sessionAttributes` in der Anforderung.
1. Amazon Lex versteht den Kontext. Es versteht, dass es Daten für den Slot `PickupTime` erfragt hat. In diesem Zusammenhang weiß es, dass der `inputText` Wert für den `PickupTime` Slot gilt. Amazon Lex ruft dann die Lambda-Funktion auf, indem es das folgende Ereignis sendet:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "ignw84y6seypre4xly5rimopuri2xwnd",
"sessionAttributes": {
"Price": "25"
},
"bot": {
"name": "OrderFlowersCustomWithRespCard",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"PickupTime": "16:00",
"FlowerType": "roses",
"PickupDate": "2017-01-05"
},
"confirmationStatus": "None"
}
}
```
Amazon Lex hat das aktualisiert, `currentIntent.slots` indem es den `PickupTime` Wert festgelegt hat.
1. Je nach `invocationSource` Wert von `DialogCodeHook` führt die Lambda-Funktion eine Benutzerdatenvalidierung durch. Es erkennt, dass der `PickupDate` Slot-Wert gültig ist, und gibt die folgende Antwort an Amazon Lex zurück.
```
{
"sessionAttributes": {
"Price": 25
},
"dialogAction": {
"type": "Delegate",
"slots": {
"PickupTime": "16:00",
"FlowerType": "roses",
"PickupDate": "2017-01-05"
}
}
}
```
Beachten Sie Folgendes:
+ `sessionAttributes`: Keine Änderung am Sitzungsattribut.
+ `dialogAction.type`: Wird auf `Delegate` gesetzt. Die Benutzerdaten waren gültig, sodass die Lambda-Funktion Amazon Lex anweist, die nächste Vorgehensweise zu wählen.
1. Derzeit weiß Amazon Lex, dass es über alle Slot-Daten verfügt. Diese Absicht wurde mit einer Bestätigungsaufforderung konfiguriert. Daher sendet Amazon Lex die folgende Antwort an den Benutzer mit der Bitte um Bestätigung, bevor die Absicht erfüllt wird:
![\[\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/gs-1-details-45.png)
Der Client zeigt einfach die Mitteilung in der Antwort an und wartet auf die Antwort des Benutzers.
1. Benutzer: Ja
1. Der Client sendet die folgende [PostText](API_runtime_PostText.md) Anfrage an Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "yes",
"sessionAttributes": {
"Price": "25"
}
}
```
1. Amazon Lex interpretiert das `inputText` im Zusammenhang mit der Bestätigung der aktuellen Absicht. Amazon Lex geht davon aus, dass der Benutzer mit der Bestellung fortfahren möchte. Diesmal ruft Amazon Lex die Lambda-Funktion auf, um die Absicht zu erfüllen, indem das folgende Ereignis gesendet wird, das `FulfillmentCodeHook` in dem Ereignis, das `invocationSource` an die Lambda-Funktion gesendet wird, auf setzt. Amazon Lex legt auch das `confirmationStatus` auf fest`Confirmed`.
```
{
"messageVersion": "1.0",
"invocationSource": "FulfillmentCodeHook",
"userId": "ignw84y6seypre4xly5rimopuri2xwnd",
"sessionAttributes": {
"Price": "25"
},
"bot": {
"name": "OrderFlowersCustomWithRespCard",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"PickupTime": "16:00",
"FlowerType": "roses",
"PickupDate": "2017-01-05"
},
"confirmationStatus": "Confirmed"
}
}
```
Beachten Sie Folgendes:
+ `invocationSource`— Diesmal hat Amazon Lex diesen Wert auf gesetzt und die Lambda-Funktion angewiesen`FulfillmentCodeHook`, die Absicht zu erfüllen.
+ `confirmationStatus`: Wird auf `Confirmed` gesetzt.
1. Diesmal erfüllt die Lambda-Funktion die `OrderFlowers` Absicht und gibt die folgende Antwort zurück:
```
{
"sessionAttributes": {
"Price": "25"
},
"dialogAction": {
"type": "Close",
"fulfillmentState": "Fulfilled",
"message": {
"contentType": "PlainText",
"content": "Thanks, your order for roses has been placed and will be ready for pickup by 16:00 on 2017-01-05"
}
}
}
```
Beachten Sie Folgendes:
+ Legt fest `dialogAction.type` — Die Lambda-Funktion setzt diesen Wert auf und weist Amazon Lex an`Close`, keine Benutzerantwort zu erwarten.
+ `dialogAction.fulfillmentState`: ist auf Fulfilled eingestellt und enthält eine geeignete `message` zur Übermittlung an den Benutzer.
1. Amazon Lex überprüft das `fulfillmentState` und sendet die folgende Antwort an den Kunden zurück.
Amazon Lex gibt dann Folgendes an den Client zurück:
![\[\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/gs-1-details-48.png)
Beachten Sie Folgendes:
+ `dialogState`— Amazon Lex legt diesen Wert auf fest`fulfilled`.
+ `message`— ist dieselbe Nachricht, die die Lambda-Funktion bereitgestellt hat.
Der Client zeigt die Mitteilung an.
1. Testen Sie nun den Bot erneut. Um einen neuen (Benutzer-)Kontext zu etablieren, wählen Sie den Link **Clear** im Testfenster aus. Geben Sie jetzt ungültige Slot-Daten für die Absicht `OrderFlowers` an. Diesmal führt die Lambda-Funktion die Datenvalidierung durch, setzt den ungültigen Slot-Datenwert auf Null zurück und fordert Amazon Lex auf, den Benutzer zur Eingabe gültiger Daten aufzufordern. Versuchen Sie zum Beispiel Folgendes:
+ Jasmin als Blumenart (zählt nicht zu den unterstützten Blumenarten)
+ Gestern als den Tag, an dem Sie die Blumen abholen möchten
+ Nachdem Sie Ihre Bestellung aufgegeben haben, geben Sie eine andere Blumensorte ein, statt zur Bestätigung der Bestellung mit "Ja" zu antworten. Als Reaktion darauf aktualisiert die Lambda-Funktion das Attribut `Price` in der Sitzung und behält so die laufende Gesamtzahl der Blumenbestellungen bei.
Die Lambda-Funktion führt auch die Fulfillment-Aktivität durch.
**Nächster Schritt**
[Schritt 6: Aktualisieren der Absichtskonfiguration zum Hinzufügen einer Äußerung (Konsole)](gs-bp-utterance.md)
# Schritt 6: Aktualisieren der Absichtskonfiguration zum Hinzufügen einer Äußerung (Konsole)
Der Bot `OrderFlowers` ist mit nur zwei Äußerungen konfiguriert. Dies stellt Amazon Lex begrenzte Informationen zur Verfügung, um ein Modell für maschinelles Lernen zu erstellen, das die Absicht des Benutzers erkennt und darauf reagiert. Versuchen Sie, „Ich möchte Blumen bestellen“ wie im folgenden Testfenster einzugeben. Amazon Lex erkennt den Text nicht und antwortet mit „Ich habe Sie nicht verstanden, was möchten Sie tun?“ Sie können das Modell für maschinelles Lernen durch Hinzufügen weiterer Äußerungen verbessern.
![\[Im Testfenster wird eine verpasste Äußerung angezeigt.\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/gs1-120.png)
Mit jeder Äußerung, die Sie hinzufügen, erhält Amazon Lex weitere Informationen darüber, wie Sie Ihren Benutzern antworten können. Sie müssen keine exakte Äußerung hinzufügen. Amazon Lex verallgemeinert anhand der von Ihnen bereitgestellten Stichproben, um sowohl exakte Übereinstimmungen als auch ähnliche Eingaben zu erkennen.
**So fügen Sie eine Äußerung hinzu (Konsole)**
1. Fügen Sie der Absicht die Äußerung „Ich möchte Blumen“ hinzu, indem Sie sie wie in der folgenden Abbildung im Abschnitt **Beispieläußerungen** des Absichtseditors eingeben und dann auf das Plussymbol neben der neuen Äußerung klicken.
![\[Absichtseditor mit der neuen Äußerung.\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/gs1-130.png)
1. Erstellen Sie den Bot, um die Änderung zu übernehmen. Wählen Sie **Build** und dann erneut **Build**.
1. Testen Sie den Bot, um zu bestätigen, dass er die neue Äußerung erkennt. Geben Sie im Testfenster, wie in der folgenden Abbildung, „Ich möchte Blumen bestellen“ ein. Amazon Lex erkennt den Satz und antwortet mit „Welche Art von Blumen möchten Sie bestellen?“.
![\[Der Absichtseditor erkennt die neue Äußerung.\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/gs1-140.png)
**Nächster Schritt**
[Schritt 7 (optional): Bereinigen (Konsole)](gs-bp-cleaning-up.md)
# Schritt 7 (optional): Bereinigen (Konsole)
Löschen Sie jetzt die Ressourcen, die Sie erstellt haben, und bereinigen Sie das Konto.
Sie können nur Ressourcen löschen, die nicht genutzt werden. Im Allgemeinen sollten Sie Ressourcen in der folgenden Reihenfolge löschen:
+ Löschen Sie Bots, um Absicht-Ressourcen freizugeben.
+ Löschen Sie Absichten, um Slot-Typ-Ressourcen freizugeben.
+ Löschen Sie Slot-Typen zuletzt.
**So bereinigen Sie Ihr Konto (Konsole)**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon Lex Lex-Konsole unter [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Wählen Sie in der Liste der Bots das Kontrollkästchen neben **OrderFlowers**.
1. Um den Bot zu löschen, wählen Sie **Delete** und dann im Bestätigungsdialogfeld **Continue** aus.
1. Wählen Sie im linken Bereich **Intents** aus.
1. Wählen Sie aus der Liste der Absichten **OrderFlowersIntent** aus.
1. Um die Absicht zu löschen, wählen Sie **Delete** und dann im Bestätigungsdialogfeld **Continue** aus.
1. Wählen Sie im linken Bereich **Slot types** aus.
1. Wählen Sie in der Liste der Slot-Typen **Flowers** aus.
1. Um den Slot-Typ zu löschen, wählen Sie **Delete** und dann im Bestätigungsdialogfeld **Continue** aus.
Sie haben alle Amazon Lex-Ressourcen entfernt, die Sie erstellt und Ihr Konto bereinigt haben. Falls gewünscht, können Sie die [Lambda-Konsole](https://console.aws.amazon.com/lambda) verwenden, um die in dieser Übung verwendete Lambda-Funktion zu löschen.