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. # Reise buchen Dieses Beispiel veranschaulicht das Erstellen eines Bots, der konfiguriert wurde, um mehrere Absichten zu unterstützen. Das Beispiel veranschaulicht auch, wie Sie Sitzungsattribute für die gemeinsame Nutzung von Informationen für mehrere Absichten verwenden können. Nachdem Sie den Bot erstellt haben, verwenden Sie einen Testclient in der Amazon Lex Lex-Konsole, um den Bot zu testen (BookTrip). Der Client verwendet den [PostText](API_runtime_PostText.md) Runtime-API-Vorgang, um für jede Benutzereingabe Anfragen an Amazon Lex zu senden. Der BookTrip Bot in diesem Beispiel ist mit zwei Absichten (BookHotel und BookCar) konfiguriert. Angenommen zum Beispiel, ein Benutzer bucht zuerst ein Hotel. Während der Interaktion gibt der Benutzer Informationen an wie z. B. Anreisedaten, Position und Anzahl der Nächte. Nachdem die Absicht erfüllt ist, kann der Client diese Informationen mithilfe von Sitzungsattributen speichern. Weitere Informationen über Sitzungsattribute finden Sie unter [PostText](API_runtime_PostText.md). Angenommen, dass der Benutzer jetzt damit fortfährt, ein Auto zu buchen. Der Code-Hook (Lambda-Funktion), den Sie für die Initialisierung und Validierung der BookHotel Absicht konfiguriert haben, verwendet Informationen, die der Benutzer in der vorherigen BookCar Absicht angegeben hat (d. h. Zielstadt und An- und Abreisedatum), initialisiert die Slot-Daten für die BookCar Absicht (d. h. Ziel, Abholort, Abholdatum und Rückflugdatum). Dies veranschaulicht, wie die gemeinsame Nutzung von Informationen für mehrere Absichten dazu beiträgt, Bots zu erstellen, die dynamische Unterhaltungen mit dem Benutzer führen können. In diesem Beispiel verwenden wir die folgenden Sitzungsattribute. Nur der Client und die Lambda-Funktion können Sitzungsattribute festlegen und aktualisieren. Amazon Lex leitet diese nur zwischen dem Client und der Lambda-Funktion weiter. Amazon Lex verwaltet oder ändert keine Sitzungsattribute. + `currentReservation`— Enthält Slot-Daten für eine Reservierung, die gerade bearbeitet wird, und andere relevante Informationen. Folgendes ist zum Beispiel eine Beispielanforderung des Clients an Amazon Lex. Das Sitzungsattribut `currentReservation` wird im Anforderungstext gezeigt. ``` POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text "Content-Type":"application/json" "Content-Encoding":"amz-1.0" { "inputText":"Chicago", "sessionAttributes":{ "currentReservation":"{\"ReservationType\":\"Hotel\", \"Location\":\"Moscow\", \"RoomType\":null, \"CheckInDate\":null, \"Nights\":null}" } } ```   + `lastConfirmedReservation`— Enthält ähnliche Informationen für eine frühere Absicht, falls vorhanden. Wenn der Benutzer beispielsweise ein Hotel gebucht hat und gerade dabei ist, ein Auto zu buchen, speichert dieses Sitzungsattribut Slot-Daten für die vorherige BookHotel Absicht.   + `confirmationContext`— Die Lambda-Funktion legt dies fest, `AutoPopulate` wenn sie einige der Slot-Daten auf der Grundlage von Slot-Daten aus der vorherigen Reservierung (falls vorhanden) vorab füllt. Dies ermöglicht die gemeinsame Nutzung von Informationen für mehrere Absichten. Wenn der Benutzer beispielsweise zuvor ein Hotel gebucht hat und jetzt ein Auto buchen möchte, kann Amazon Lex den Benutzer auffordern, zu bestätigen (oder abzulehnen), dass das Auto für dieselbe Stadt und denselben Zeitraum wie seine Hotelreservierung gebucht wird. In dieser Übung verwenden Sie Blueprints, um einen Amazon Lex Lex-Bot und eine Lambda-Funktion zu erstellen. Weitere Informationen über Pläne finden Sie unter [Amazon Lex und AWS Lambda Blueprints](lex-lambda-blueprints.md). **Nächster Schritt** [Schritt 1: Überprüfen der in dieser Übung verwendeten Pläne](ex-book-trip-blueprints.md) # Schritt 1: Überprüfen der in dieser Übung verwendeten Pläne **Topics** + [Überblick über den Bot-Blueprint () BookTrip](#ex-book-trip-bp-summary-bot) + [Überblick über den Lambda-Funktions-Blueprint () lex-book-trip-python](#ex-book-trip-summary-lambda) ## Überblick über den Bot-Blueprint () BookTrip Der Plan (**BookTrip**), den Sie zum Erstellen eines Bot verwenden, bietet folgende Vorkonfiguration: + **Slot-Typen**: Zwei benutzerdefinierte Slot-Typen: + `RoomTypes` mit Aufzählungswerten: `king`, `queen` und `deluxe`, zur Verwendung in der Absicht `BookHotel`. + `CarTypes` mit Aufzählungswerten: `economy`, `standard`, `midsize`, `full size`, `luxury` und `minivan`, zur Verwendung in der Absicht `BookCar`.   + **Absicht 1 (BookHotel)** — Es ist wie folgt vorkonfiguriert: + **Vorkonfigurierte Slots** + `RoomType`, von dem benutzerdefinierten Slot-Typ `RoomTypes` + `Location`, von dem integrierten Slot-Typ `AMAZON.US_CITY` + `CheckInDate`, von dem integrierten Slot-Typ `AMAZON.DATE` + `Nights`, von dem integrierten Slot-Typ `AMAZON.NUMBER` + **Vorkonfigurierte Äußerungen** + „Buche ein Hotel“ + „Ich möchte eine Hotelreservierung vornehmen“ + „Buche einen Aufenthalt für in“ Wenn der Benutzer eine dieser Optionen ausgibt, stellt Amazon Lex fest, dass dies die Absicht `BookHotel` ist, und fordert den Benutzer dann zur Eingabe der Slot-Daten auf. + **Vorkonfigurierte Aufforderungen** + Aufforderung für den Slot `Location`: „In welcher Stadt werden Sie bleiben?“ + Aufforderung für den Slot `CheckInDate`: „An welchem Tag möchten Sie anreisen?“ + Aufforderung für den Slot `Nights`; „Wie viele Nächte werden Sie bleiben?“ + Aufforderung für den Slot `RoomType`: „Welche Art von Zimmer möchten Sie buchen: Queen, King oder Deluxe?“ + Bestätigungserklärung — „Okay, ich habe für Sie ab \$1\$1 einen Aufenthalt von \$1Nächten\$1 Nächten in \$1Location\$1 gebucht. CheckInDate Soll ich die Reservierung vornehmen?“ + Ablehnung: „Okay, ich habe Ihre laufende Reservierung abgebrochen.“   + **Absicht 2 (BookCar)** — Sie ist wie folgt vorkonfiguriert: + **Vorkonfigurierte Slots** + `PickUpCity`, von dem integrierten Typ `AMAZON.US_CITY` + `PickUpDate`, von dem integrierten Typ `AMAZON.DATE` + `ReturnDate`, von dem integrierten Typ `AMAZON.DATE` + `DriverAge`, von dem integrierten Typ `AMAZON.NUMBER` + `CarType`, von dem benutzerdefinierten Typ `CarTypes` + **Vorkonfigurierte Äußerungen** + „Buche ein Auto“ + „Reserviere ein Auto“ + „Nimm eine Autoreservierung vor“ Wenn der Benutzer eine dieser Optionen ausgibt, stellt Amazon Lex fest, dass dies beabsichtigt BookCar ist, und fordert den Benutzer dann zur Eingabe der Slot-Daten auf. + **Vorkonfigurierte Aufforderungen** + Aufforderung für den Slot `PickUpCity`: „In welcher Stadt möchten Sie ein Auto mieten?“ + Aufforderung für den Slot `PickUpDate`: „An welchem Tag möchten Sie die Miete beginnen?“ + Aufforderung für den Slot `ReturnDate`: „An welchem Tag möchten Sie dieses Auto zurückgeben?“ + Aufforderung für den Slot `DriverAge`: „Wie alt ist der Fahrer für diese Miete?“ + Eingabeaufforderung für den `CarType` Slot — „Welche Art von Auto möchten Sie mieten? Unsere beliebtesten Optionen sind Economy, Mittelklasse und Luxusklasse.“ + Bestätigungserklärung — „Okay, ich habe Sie für eine \$1CarType\$1 Anmietung in \$1PickUpCity\$1 von \$1PickUpDate\$1 bis \$1ReturnDate\$1 zur Verfügung. Soll ich die Reservierung vornehmen?“ + Ablehnung: „Okay, ich habe Ihre laufende Reservierung abgebrochen.“ ## Überblick über den Lambda-Funktions-Blueprint () lex-book-trip-python AWS Lambda Bietet zusätzlich zum Bot-Blueprint einen Blueprint (**lex-book-trip-python**), den Sie als Code-Hook mit dem Bot-Blueprint verwenden können. Eine Liste der Bot-Blueprints und der entsprechenden Lambda-Funktions-Blueprints finden Sie unter. [Amazon Lex und AWS Lambda Blueprints](lex-lambda-blueprints.md) Wenn Sie mithilfe des BookTrip Blueprints einen Bot erstellen, aktualisieren Sie die Konfiguration der beiden Absichten (BookCar und BookHotel), indem Sie diese Lambda-Funktion als Code-Hook sowohl für die Benutzerdateneingabe als auch initialization/validation für die Erfüllung der Absichten hinzufügen. Dieser bereitgestellte Lambda-Funktionscode ist ein Beispiel für eine dynamische Unterhaltung, in der zuvor bekannte (in Sitzungsattributen gespeicherte) Informationen über einen Benutzer verwendet werden, um Slot-Werte für eine Absicht zu initialisieren. Weitere Informationen finden Sie unter [Verwaltung von Konversation-Kontext](context-mgmt.md). **Nächster Schritt** [Schritt 2: Erstellen Sie einen Amazon Lex Lex-Bot](ex-book-trip-create-bot.md) # Schritt 2: Erstellen Sie einen Amazon Lex Lex-Bot In diesem Abschnitt erstellen Sie einen Amazon Lex Lex-Bot (BookTrip). 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. Klicken Sie auf der Seite **Bots** auf die Option **Create**. 1. Wählen Sie auf der Seite **Create your Lex bot** + Wählen Sie einen **BookTrip** Plan. + Behalten Sie den Standard-Bot-Namen (BookTrip) bei. 1. Wählen Sie **Erstellen** aus. Die Konsole sendet eine Reihe von Anfragen an Amazon Lex, um den Bot zu erstellen. Beachten Sie Folgendes: 1. Die Konsole zeigt den BookTrip Bot. Überprüfen Sie auf der Registerkarte **Editor** die Details der vorkonfigurierten Absichten (BookCar und BookHotel). 1. Testen Sie den Bot im Testfenster. Verwenden Sie das Folgende, um eine Konversation mit Ihrem Bot zu testen: ![\[Gespräch mit einem Agenten, in dem der Mitarbeiter die Stadt, den Tag, die Anzahl der Nächte und die Art des Zimmers für die Reise des Kunden ermittelt. Der Agent bestätigt dann die Reservierung.\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/book-trip-no-lambda-10.png) Aus der ersten Benutzereingabe („Ein Hotel buchen“) leitet Amazon Lex die Absicht (BookHotel) ab. Der Bot verwendet dann die in dieser Absicht vorkonfigurierten Aufforderungen, um vom Benutzer Slot-Daten zu erfragen. Nachdem der Benutzer alle Slot-Daten eingegeben hat, sendet Amazon Lex eine Antwort mit einer Nachricht an den Client zurück, die alle Benutzereingaben als Nachricht enthält. Der Client zeigt die Mitteilung in der Antwort wie angezeigt an. ``` CheckInDate:2016-12-18 Location:Chicago Nights:5 RoomType:queen ``` Jetzt setzen Sie das Gespräch fort und versuchen in der folgenden Konversation, ein Auto zu buchen. ![\[Gespräch mit einem Agenten, in dem der Makler die Stadt, den Starttag, den Rückreisetag, das Alter des Fahrers und den Fahrzeugtyp für die Autovermietung des Kunden herausgibt. Der Agent bestätigt dann die Reservierung.\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/book-trip-no-lambda-20.png) Beachten Sie, + Dieses Mal erfolgt keine Validierung der Benutzerdaten. Zum Beispiel können Sie jede beliebige Stadt angeben, in der Sie ein Hotel buchen möchten. + Sie geben einige der gleichen Informationen erneut an (Ziel, Stadt der Abholung, Abholungsdatum, Rückgabedatum), um ein Auto zu buchen. In einer dynamischen Unterhaltung sollte Ihr Bot einige dieser Informationen aufgrund vorheriger Angaben des Benutzers für die Hotelbuchung initialisieren. Im nächsten Abschnitt erstellen Sie eine Lambda-Funktion, die einen Teil der Validierung und Initialisierung der Benutzerdaten mithilfe der gemeinsamen Nutzung von Informationen für mehrere Absichten über Sitzungsattribute übernimmt. Anschließend aktualisieren Sie die Absichtskonfiguration, indem Sie die Lambda-Funktion als Code-Hook hinzufügen, um Benutzereingaben durchzuführen initialization/validation und die Absicht zu erfüllen. **Nächster Schritt** [Schritt 3: Erstellen Sie eine Lambda-Funktion](ex-book-trip-create-lambda-function.md) # Schritt 3: Erstellen Sie eine Lambda-Funktion In diesem Abschnitt erstellen Sie eine Lambda-Funktion mithilfe eines in der Konsole bereitgestellten Blueprint (**lex-book-trip-python**). AWS Lambda Sie testen die Lambda-Funktion auch, indem Sie sie mithilfe von Beispielereignisdaten aufrufen, die von der Konsole bereitgestellt werden. Diese Lambda-Funktion ist in Python geschrieben. 1. Melden Sie sich bei 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 **Use a blueprint (Vorlage verwenden)**. Geben Sie **lex** ein, um die Vorlage zu suchen, und wählen Sie die `lex-book-trip-python`-Vorlage aus. 1. Wählen Sie „Lambda-Funktion **konfigurieren**“ wie folgt aus. + Geben Sie einen Lambda-Funktionsnamen (`BookTripCodeHook`) ein. + Wählen Sie für die Rolle **Create a new role from template(s)** aus und geben Sie einen Rollennamen ein. + Ü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. Sie rufen die Lambda-Funktion zweimal auf und verwenden dabei Beispieldaten sowohl für die Buchung eines Autos als auch für die Buchung eines Hotels. 1. Wählen Sie **Configure test event (Testereignis konfigurieren)** aus der Dropdownliste **Select a test event (Ein Testereignis auswählen)** aus. 1. Wählen Sie **Amazon Lex Book Hotel** aus der Liste **Sample event template (Beispielereignisvorlage)** aus. Dieses Beispielereignis entspricht dem Amazon Lex request/response Lex-Modell. Weitere Informationen finden Sie unter [Verwendung von Lambda-Funktionen](using-lambda.md). 1. Klicken Sie auf **Speichern und Testen**. 1. Stellen Sie sicher, dass die Lambda-Funktion erfolgreich ausgeführt wurde. Die Antwort entspricht in diesem Fall dem Amazon Lex Lex-Antwortmodell. 1. Wiederholen Sie den Schritt. Wählen Sie diesmal **Amazon Lex Book Car** aus der Liste **Sample event template (Beispielereignisvorlage)** aus. Die Lambda-Funktion verarbeitet die Fahrzeugreservierung. **Nächster Schritt** [Schritt 4: Fügen Sie die Lambda-Funktion als Code-Hook hinzu](ex-book-trip-create-integrate.md) # Schritt 4: Fügen Sie die Lambda-Funktion als Code-Hook hinzu In diesem Abschnitt aktualisieren Sie die Konfigurationen von Intents BookCar und BookHotel Intents, indem Sie die Lambda-Funktion als Code-Hook für initialization/validation und Fulfillment-Aktivitäten hinzufügen. Stellen Sie sicher, dass Sie die \$1LATEST-Version der Intents wählen, da Sie nur die \$1LATEST-Version Ihrer Amazon Lex-Ressourcen aktualisieren können. 1. Wählen Sie in der Amazon Lex-Konsole den **BookTrip**Bot aus. 1. Wählen Sie auf der Registerkarte **Editor** die **BookHotel**Absicht aus. Aktualisieren Sie die Absichtskonfiguration wie folgt: 1. Stellen Sie sicher, dass die Absichtsversion (neben dem Absichtsnamen) \$1LATEST ist. 1. Fügen Sie die Lambda-Funktion wie folgt als Initialisierungs- und Validierungscode-Hook hinzu: + Wählen Sie im Abschnitt **Options** **Initialization and validation code hook** aus. + Wählen Sie Ihre Lambda-Funktion aus der Liste aus. 1. Fügen Sie die Lambda-Funktion wie folgt als Fulfillment-Code-Hook hinzu: + Wählen Sie im Abschnitt **Fulfillment** **AWS Lambda function** aus. + Wählen Sie Ihre Lambda-Funktion aus der Liste aus. + Wählen Sie **Goodbye message** aus und geben Sie eine Mitteilung ein. 1. Wählen Sie **Speichern**. 1. Wählen Sie auf der Registerkarte **Editor** die BookCar Absicht aus. Befolgen Sie den vorhergehenden Schritt, um Ihre Lambda-Funktion als Code-Haken für Validierung und Erfüllung hinzuzufügen. 1. Wählen Sie **Build** aus. Die Konsole sendet eine Reihe von Anfragen an Amazon Lex, um die Konfigurationen zu speichern. 1. Testen Sie den Bot. Da Sie nun eine Lambda-Funktion haben, die die Initialisierung, Überprüfung und Erfüllung der Benutzerdaten durchführt, können Sie den Unterschied in der Benutzerinteraktion in der folgenden Konversation erkennen: ![\[Konversation mit einem Agenten, in dem der Mitarbeiter die Stadt, den Tag, die Anzahl der Nächte und die Art des Zimmers für eine Reisereservierung ermittelt und dann die Reservierung bestätigt.\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/book-trip-with-lambda-30.png) Weitere Informationen zum Datenfluss vom Client (Konsole) zu Amazon Lex und von Amazon Lex zur Lambda-Funktion finden Sie unter[Datenfluss: Absicht zur Buchung eines Hotels](book-trip-detail-flow.md#data-flow-book-hotel). 1. Setzen Sie das Gespräch fort und buchen Sie ein Auto, wie in der folgenden Abbildung gezeigt: ![\[Gespräch mit einem Agenten, in dem der Agent das Alter des Fahrers und den Fahrzeugtyp ermittelt und dann die Fahrzeugreservierung bestätigt.\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/book-trip-with-lambda-40.png) Wenn Sie sich dafür entscheiden, ein Auto zu buchen, sendet der Client (Konsole) eine Anfrage an Amazon Lex, die die Sitzungsattribute (aus der vorherigen Konversation, BookHotel) enthält. Amazon Lex leitet diese Informationen an die Lambda-Funktion weiter, die dann einige der BookCar Slot-Daten (d. h.,, und) initialisiert (d. h., PickUpDate vorfüllt). ReturnDate PickUpCity **Anmerkung** Dies veranschaulicht, wie Sitzungsattribute dazu dienen können, Kontext über Absichten hinweg aufrechtzuerhalten. Der Konsolenclient zeigt den Link **Clear** im Testfenster an, über das ein Benutzer alle vorherigen Sitzungsattribute löschen kann. Weitere Informationen zum Datenfluss vom Client (Konsole) zu Amazon Lex und von Amazon Lex zur Lambda-Funktion finden Sie unter[Datenfluss: Absicht Auto buchen](book-trip-detail-flow.md#data-flow-book-car). # Informationsfluss im Detail In dieser Übung haben Sie mithilfe des in der Amazon Lex Lex-Konsole bereitgestellten Testfenster-Clients eine Konversation mit dem Amazon Lex BookTrip Lex-Bot geführt. In diesem Abschnitt wird Folgendes erklärt: + Der Datenfluss zwischen dem Client und Amazon Lex.   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. Weitere Informationen zur `PostText` finden Sie unter [PostText](API_runtime_PostText.md). **Anmerkung** 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).   + Der Datenfluss zwischen Amazon Lex und der Lambda-Funktion. Weitere Informationen finden Sie unter [Eingabeereignis und Antwortformat der Lambda-Funktion](lambda-input-response-format.md). **Topics** + [Datenfluss: Absicht zur Buchung eines Hotels](#data-flow-book-hotel) + [Datenfluss: Absicht Auto buchen](#data-flow-book-car) ## Datenfluss: Absicht zur Buchung eines Hotels In diesem Abschnitt wird erklärt, was nach jeder Benutzereingabe geschieht. 1. Benutzer: „Buche ein Hotel“ 1. Der Client (Konsole) sendet die folgende [PostText](API_runtime_PostText.md)-Anforderung an Amazon Lex: ``` POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text "Content-Type":"application/json" "Content-Encoding":"amz-1.0" { "inputText":"book a hotel", "sessionAttributes":{} } ``` Sowohl die Anforderungs-URI als auch der Text stellen Amazon Lex Informationen zur Verfügung: + Anfrage-URI — Stellt den Bot-Namen (BookTrip), den Bot-Alias (\$1LATEST) und den Benutzernamen 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`. Anfänglich ist dies ein leeres Objekt und die Lambda-Funktion legt zuerst die Sitzungsattribute fest. 1. Anhand `inputText` von erkennt Amazon Lex die Absicht (BookHotel). Diese Absicht ist mit einer Lambda-Funktion als Code-Hook für die Initialisierung/Validierung von Benutzerdaten konfiguriert. Daher ruft Amazon Lex diese Lambda-Funktion auf, indem es die folgenden Informationen als Ereignisparameter übergibt (siehe[Eingabe-Ereignis-Format](lambda-input-response-format.md#using-lambda-input-event-format)): ``` { "messageVersion":"1.0", "invocationSource":"DialogCodeHook", "userId":"wch89kjqcpkds8seny7dly5x3otq68j3", "sessionAttributes":{ }, "bot":{ "name":"BookTrip", "alias":null, "version":"$LATEST" }, "outputDialogMode":"Text", "currentIntent":{ "name":"BookHotel", "slots":{ "RoomType":null, "CheckInDate":null, "Nights":null, "Location":null }, "confirmationStatus":"None" } } ``` Zusätzlich zu den vom Kunden gesendeten Informationen 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 muss es die Initialisierung und Validierung der Benutzerdaten durchführen (zu diesem Zeitpunkt weiß Amazon Lex, dass der Benutzer nicht alle Slot-Daten angegeben hat, um die Absicht zu erfüllen). + `currentIntent`: Alle Slot-Werte werden auf Null gesetzt. 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. Weitere Informationen über das Antwortformat finden Sie unter [Reaktion-Format](lambda-input-response-format.md#using-lambda-response-format). ``` { "sessionAttributes":{ "currentReservation":"{\"ReservationType\":\"Hotel\",\"Location\":null,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}" }, "dialogAction":{ "type":"Delegate", "slots":{ "RoomType":null, "CheckInDate":null, "Nights":null, "Location":null } } } ``` **Anmerkung** `currentReservation`— Die Lambda-Funktion beinhaltet dieses Sitzungsattribut. Sein Wert ist eine Kopie der aktuellen Slot-Informationen und des Reservierungstyps. Nur die Lambda-Funktion und der Client können diese Sitzungsattribute aktualisieren. Amazon Lex gibt diese Werte einfach weiter. `dialogAction.type`— Wenn Sie diesen Wert auf setzen`Delegate`, delegiert die Lambda-Funktion die Verantwortung für die nächste Vorgehensweise an Amazon Lex. Wenn die Lambda-Funktion bei der Überprüfung der Benutzerdaten etwas entdeckt hat, weist sie Amazon Lex an, was als Nächstes zu tun ist. 1. Gemäß dem `dialogAction.type` entscheidet Amazon Lex über die nächste Vorgehensweise — das Abrufen von Daten vom Benutzer für den Slot. `Location` Es wählt eine der Aufforderungsmitteilungen ("In welcher Stadt werden Sie bleiben?") gemäß der Konfiguration der Absicht für diesen Slot aus und sendet dann die folgende Antwort an den Benutzer: ![\[JSON-Antwort, die den Dialogstatus, den Namen der Absicht, die Nachricht, die Antwortkarte, die Sitzungsattribute, den abzufragenden Slot und die Slots enthält.\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/book-hotel-10.png) Die Sitzungsattribute werden an den Client übergeben. Der Client liest die Antwort und zeigt dann die Mitteilung an: „In welcher Stadt werden Sie bleiben?“ 1. Benutzer: „Moskau“ 1. Der Client sendet die folgende `PostText` Anfrage an Amazon Lex (Zeilenumbrüche wurden zur besseren Lesbarkeit hinzugefügt): ``` POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text "Content-Type":"application/json" "Content-Encoding":"amz-1.0" { "inputText":"Moscow", "sessionAttributes":{ "currentReservation":"{\"ReservationType\":\"Hotel\", \"Location\":null, \"RoomType\":null, \"CheckInDate\":null, \"Nights\":null}" } } ``` Zusätzlich zu dem `inputText` fügt der Client die gleichen `currentReservation`-Sitzungsattribute hinzu, die er erhalten hat. 1. Amazon Lex interpretiert das zunächst `inputText` im Kontext der aktuellen Absicht (der Service erinnert sich, dass er den bestimmten Benutzer nach Informationen über den `Location` Slot gefragt hat). Es aktualisiert den Slot-Wert für die aktuelle Absicht und ruft die Lambda-Funktion mit dem folgenden Ereignis auf: ``` { "messageVersion": "1.0", "invocationSource": "DialogCodeHook", "userId": "wch89kjqcpkds8seny7dly5x3otq68j3", "sessionAttributes": { "currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":null,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}" }, "bot": { "name": "BookTrip", "alias": null, "version": "$LATEST" }, "outputDialogMode": "Text", "currentIntent": { "name": "BookHotel", "slots": { "RoomType": null, "CheckInDate": null, "Nights": null, "Location": "Moscow" }, "confirmationStatus": "None" } } ``` **Anmerkung** `invocationSource` ist weiterhin `DialogCodeHook`. In diesem Schritt validieren wir nur Benutzerdaten. Amazon Lex übergibt lediglich das Sitzungsattribut an die Lambda-Funktion. Denn `currentIntent.slots` Amazon Lex hat den `Location` Slot auf aktualisiert`Moscow`. 1. Die Lambda-Funktion führt die Überprüfung der Benutzerdaten durch und stellt fest, dass `Moscow` es sich um einen ungültigen Standort handelt. **Anmerkung** Die Lambda-Funktion in dieser Übung hat eine einfache Liste gültiger Städte und `Moscow` ist nicht in der Liste enthalten. In einer Produktionsanwendung würden Sie eventuell eine Backend-Datenbank verwenden, um diese Information zu erhalten. Es setzt den Slot-Wert wieder auf Null zurück und weist Amazon Lex an, den Benutzer erneut zur Eingabe eines anderen Werts aufzufordern, indem die folgende Antwort gesendet wird: ``` { "sessionAttributes": { "currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Moscow\",\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}" }, "dialogAction": { "type": "ElicitSlot", "intentName": "BookHotel", "slots": { "RoomType": null, "CheckInDate": null, "Nights": null, "Location": null }, "slotToElicit": "Location", "message": { "contentType": "PlainText", "content": "We currently do not support Moscow as a valid destination. Can you try a different city?" } } } ``` **Anmerkung** `currentIntent.slots.Location` wird auf Null zurückgesetzt. `dialogAction.type`ist auf gesetzt`ElicitSlot`, was Amazon Lex anweist, den Benutzer erneut aufzufordern, indem es Folgendes angibt: `dialogAction.slotToElicit`: Slot, für den Daten vom Benutzer erfragt werden `dialogAction.message`: Eine an den Benutzer zu übermittelnde `message` 1. Amazon Lex bemerkt das `dialogAction.type` und leitet die Informationen in der folgenden Antwort an den Kunden weiter: ![\[JSON-Antwort, die den Status des Dialogs, den Namen der Absicht, die Nachricht, die Antwortkarte, die Sitzungsattribute, den abzufragenden Slot und die Slots enthält.\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/book-hotel-20.png) Der Client zeigt die Mitteilung einfach an: „Wir unterstützen derzeit Moskau als gültiges Ziel nicht. Können Sie es mit einer anderen Stadt versuchen?“ 1. Benutzer: „Chicago“ 1. Der Client sendet die folgende `PostText` Anfrage an Amazon Lex: ``` POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text "Content-Type":"application/json" "Content-Encoding":"amz-1.0" { "inputText":"Chicago", "sessionAttributes":{ "currentReservation":"{\"ReservationType\":\"Hotel\", \"Location\":\"Moscow\", \"RoomType\":null, \"CheckInDate\":null, \"Nights\":null}" } } ``` 1. Amazon Lex kennt den Kontext, in dem Daten für den `Location` Slot abgerufen wurden. In diesem Kontext weiß es, dass der Wert `inputText` für den Slot `Location` ist. Anschließend ruft es die Lambda-Funktion auf, indem es das folgende Ereignis sendet: ``` { "messageVersion": "1.0", "invocationSource": "DialogCodeHook", "userId": "wch89kjqcpkds8seny7dly5x3otq68j3", "sessionAttributes": { "currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":Moscow,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}" }, "bot": { "name": "BookTrip", "alias": null, "version": "$LATEST" }, "outputDialogMode": "Text", "currentIntent": { "name": "BookHotel", "slots": { "RoomType": null, "CheckInDate": null, "Nights": null, "Location": "Chicago" }, "confirmationStatus": "None" } } ``` Amazon Lex hat das aktualisiert, `currentIntent.slots` indem es den `Location` Slot auf gesetzt hat`Chicago`. 1. Je nach `invocationSource` Wert von `DialogCodeHook` führt die Lambda-Funktion eine Benutzerdatenvalidierung durch. Es erkennt `Chicago` einen gültigen Slot-Wert, aktualisiert das Sitzungsattribut entsprechend und gibt dann die folgende Antwort an Amazon Lex zurück. ``` { "sessionAttributes": { "currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}" }, "dialogAction": { "type": "Delegate", "slots": { "RoomType": null, "CheckInDate": null, "Nights": null, "Location": "Chicago" } } } ``` **Anmerkung** `currentReservation`— Die Lambda-Funktion aktualisiert dieses Sitzungsattribut, indem sie den Wert `Location` auf `Chicago` setzt. `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. Demnach `dialogAction.type` wählt Amazon Lex die nächste Vorgehensweise. Amazon Lex weiß, dass mehr Slot-Daten benötigt werden, und wählt den nächsten unbesetzten Slot (`CheckInDate`) mit der höchsten Priorität entsprechend der Intent-Konfiguration aus. Es wählt eine der Aufforderungsmitteilungen ("An welchem Tag möchten Sie einchecken?") gemäß der Konfiguration der Absicht für diesen Slot aus und sendet dann die folgende Antwort an den Kunden: ![\[JSON-Antwort, die den Dialogstatus, den Namen der Absicht, die Nachricht, die Antwortkarte, die Sitzungsattribute, den abzufragenden Slot und die Slots enthält. Der Standort-Slot ist jetzt als Chicago ausgefüllt.\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/book-hotel-30.png) Der Client zeigt die Nachricht an: „An welchem Tag möchten Sie anreisen?“ 1. Die Benutzerinteraktion wird fortgesetzt — der Benutzer stellt Daten bereit, die Lambda-Funktion validiert Daten und delegiert dann die nächste Vorgehensweise an Amazon Lex. Schließlich stellt der Benutzer alle Slot-Daten bereit, die Lambda-Funktion validiert alle Benutzereingaben, und dann erkennt Amazon Lex, dass es über alle Slot-Daten verfügt. **Anmerkung** In dieser Übung berechnet die Lambda-Funktion, nachdem der Benutzer alle Slot-Daten eingegeben hat, den Preis der Hotelreservierung und gibt ihn als weiteres Sitzungsattribut zurück ()`currentReservationPrice`. Zu diesem Zeitpunkt ist die Absicht bereit, erfüllt zu werden, aber die BookHotel Absicht ist mit einer Bestätigungsaufforderung konfiguriert, die eine Bestätigung durch den Benutzer erfordert, bevor Amazon Lex die Absicht erfüllen kann. Daher sendet Amazon Lex die folgende Nachricht an den Kunden und bittet um Bestätigung, bevor er das Hotel bucht: ![\[JSON-Antwort, die den Status des Dialogs, den Namen der Absicht, die Nachricht, die Antwortkarte, die Sitzungsattribute, den abzufragenden Slot und die Slots enthält. Alle Slots sind jetzt gefüllt.\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/book-hotel-40.png) Der Client zeigt die Nachricht an: „Okay, ich habe einen Aufenthalt für 5 Nächte in Chicago ab 18.12.2016 notiert. Soll ich die Reservierung vornehmen?“ 1. Benutzer: „Ja“ 1. Der Client sendet die folgende `PostText` Anfrage an Amazon Lex: ``` POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text "Content-Type":"application/json" "Content-Encoding":"amz-1.0" { "inputText":"Yes", "sessionAttributes":{ "currentReservation":"{\"ReservationType\":\"Hotel\", \"Location\":\"Chicago\", \"RoomType\":\"queen\", \"CheckInDate\":\"2016-12-18\", \"Nights\":\"5\"}", "currentReservationPrice":"1195" } } ``` 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 Reservierung fortfahren möchte. Diesmal ruft Amazon Lex die Lambda-Funktion auf, um die Absicht zu erfüllen, indem das folgende Ereignis gesendet wird. Wenn Sie das Ereignis `invocationSource` `FulfillmentCodeHook` auf setzen, wird es an die Lambda-Funktion gesendet. Amazon Lex legt auch das `confirmationStatus` auf fest`Confirmed`. ``` { "messageVersion": "1.0", "invocationSource": "FulfillmentCodeHook", "userId": "wch89kjqcpkds8seny7dly5x3otq68j3", "sessionAttributes": { "currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}", "currentReservationPrice": "956" }, "bot": { "name": "BookTrip", "alias": null, "version": "$LATEST" }, "outputDialogMode": "Text", "currentIntent": { "name": "BookHotel", "slots": { "RoomType": "queen", "CheckInDate": "2016-12-18", "Nights": "5", "Location": "Chicago" }, "confirmationStatus": "Confirmed" } } ``` **Anmerkung** `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 BookHotel Absicht, Amazon Lex schließt die Reservierung ab und gibt dann die folgende Antwort zurück: ``` { "sessionAttributes": { "lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}" }, "dialogAction": { "type": "Close", "fulfillmentState": "Fulfilled", "message": { "contentType": "PlainText", "content": "Thanks, I have placed your reservation. Please let me know if you would like to book a car rental, or another hotel." } } } ``` **Anmerkung** `lastConfirmedReservation`— Ist ein neues Sitzungsattribut, das die Lambda-Funktion hinzugefügt hat (anstelle von`currentReservation`,`currentReservationPrice`). `dialogAction.type`— Die Lambda-Funktion setzt diesen Wert auf`Close`, was bedeutet, dass Amazon Lex keine Benutzerantwort erwartet. `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: ![\[JSON-Antwort, die den Status des Dialogs, den Namen der Absicht, die Nachricht, die Antwortkarte, die Sitzungsattribute, den abzufragenden Slot und die Slots enthält. Alle Slots sind gefüllt und ein Feld für die letzte bestätigte Reservierung unter den Sitzungsattributen ist jetzt ausgefüllt.\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/book-hotel-60.png) **Anmerkung** `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. ## Datenfluss: Absicht Auto buchen Der BookTrip Bot in dieser Übung unterstützt zwei Absichten (BookHotel und BookCar). Nach der Buchung eines Hotels kann der Benutzer die Unterhaltung fortsetzen, um ein Auto zu buchen. Solange die Zeit der Sitzung noch nicht abgelaufen ist, sendet der Client bei jeder folgenden Anforderung weiter Sitzungsattribute (in diesem Beispiel die `lastConfirmedReservation`). Die Lambda-Funktion kann diese Informationen verwenden, um Slot-Daten für den BookCar Intent zu initialisieren. Dies zeigt, wie Sie Sitzungsattribute für die gemeinsame Nutzung von Informationen für mehrere Absichten verwenden können. Insbesondere wenn der Benutzer die BookCar Absicht auswählt, verwendet die Lambda-Funktion relevante Informationen im Sitzungsattribut, um die Slots (PickUpDate ReturnDate, und PickUpCity) für die Absicht vorab auszufüllen. BookCar **Anmerkung** Die Amazon Lex Lex-Konsole stellt den Link **Löschen** bereit, mit dem Sie alle Attribute früherer Sitzungen löschen können. Führen Sie die folgenden Schritte aus, um die Unterhaltung fortzusetzen. 1. Benutzer: „Buche ebenfalls ein Auto“ 1. Der Client sendet die folgende `PostText` Anfrage an Amazon Lex. ``` POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text "Content-Type":"application/json" "Content-Encoding":"amz-1.0" { "inputText":"also book a car", "sessionAttributes":{ "lastConfirmedReservation":""{\"ReservationType\":\"Hotel\", \"Location\":\"Chicago\", \"RoomType\":\"queen\", \"CheckInDate\":\"2016-12-18\", \"Nights\":\"5\"}" } } ``` Der Client schließt das Sitzungsattribut `lastConfirmedReservation` ein. 1. Amazon Lex erkennt die Absicht (BookCar) aus dem`inputText`. Diese Absicht ist auch so konfiguriert, dass sie die Lambda-Funktion aufruft, um die Initialisierung und Validierung der Benutzerdaten durchzuführen. Amazon Lex ruft die Lambda-Funktion mit dem folgenden Ereignis auf: ``` { "messageVersion": "1.0", "invocationSource": "DialogCodeHook", "userId": "wch89kjqcpkds8seny7dly5x3otq68j3", "sessionAttributes": { "lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}" }, "bot": { "name": "BookTrip", "alias": null, "version": "$LATEST" }, "outputDialogMode": "Text", "currentIntent": { "name": "BookCar", "slots": { "PickUpDate": null, "ReturnDate": null, "DriverAge": null, "CarType": null, "PickUpCity": null }, "confirmationStatus": "None" } } ``` **Anmerkung** `messageVersion`— Derzeit unterstützt Amazon Lex nur die Version 1.0. `invocationSource`: Zeigt an, dass der Zweck des Aufrufs ist, Initialisierung und Validierung von Benutzerdaten durchzuführen. `currentIntent`— Es enthält den Namen der Absicht und die Slots. Zu diesem Zeitpunkt sind alle Slot-Werte auf Null gesetzt. 1. Die Lambda-Funktion erkennt alle Null-Slot-Werte und es gibt nichts zu validieren. Sie verwendet jedoch Sitzungsattribute, um einige der Slot-Werte zu initialisieren (`PickUpDate`, `ReturnDate` und `PickUpCity`), und gibt dann die folgende Antwort zurück: ``` { "sessionAttributes": { "lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}", "currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":null,\"PickUpDate\":null,\"ReturnDate\":null,\"CarType\":null}", "confirmationContext": "AutoPopulate" }, "dialogAction": { "type": "ConfirmIntent", "intentName": "BookCar", "slots": { "PickUpCity": "Chicago", "PickUpDate": "2016-12-18", "ReturnDate": "2016-12-22", "CarType": null, "DriverAge": null }, "message": { "contentType": "PlainText", "content": "Is this car rental for your 5 night stay in Chicago on 2016-12-18?" } } } ``` **Anmerkung** Darüber hinaus enthält die `lastConfirmedReservation` Lambda-Funktion weitere Sitzungsattribute (`currentReservation`und`confirmationContext`). `dialogAction.type`ist auf gesetzt`ConfirmIntent`, was Amazon Lex darüber informiert, dass vom Benutzer eine Antwort mit Ja, nein erwartet wird (der confirmationContext ist auf gesetzt, die Lambda-Funktion weiß AutoPopulate, dass die yes/no Benutzerantwort darin besteht, vom Benutzer eine Bestätigung der Initialisierung zu erhalten, die die Lambda-Funktion durchgeführt hat (auto aufgefüllte Steckplatzdaten).   Die Lambda-Funktion enthält in der Antwort auch eine informative Nachricht, die `dialogAction.message` Amazon Lex an den Client zurücksenden soll. Der Ausdruck `ConfirmIntent` (Wert des `dialogAction.type`) hat keinen Bezug zu einer Bot-Absicht. In diesem Beispiel verwendet die Lambda-Funktion diesen Begriff, um Amazon Lex anzuweisen, eine yes/no Antwort vom Benutzer zu erhalten. 1. Laut dem `dialogAction.type` gibt Amazon Lex die folgende Antwort an den Kunden zurück: ![\[JSON-Antwort, die den Dialogstatus, den Namen der Absicht, die Nachricht, die Antwortkarte, die Sitzungsattribute, den abzufragenden Slot und die Slots enthält.\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/book-car-10.png) Der Client zeigt die Mitteilung an: „Ist dieser Mietwagen für Ihren 5-Nächte-Aufenthalt in Chicago am 18.12.2016?“ 1. Benutzer: „Ja“ 1. Der Client sendet die folgende `PostText` Anfrage an Amazon Lex. ``` POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text "Content-Type":"application/json" "Content-Encoding":"amz-1.0" { "inputText":"yes", "sessionAttributes":{ "confirmationContext":"AutoPopulate", "currentReservation":"{\"ReservationType\":\"Car\", \"PickUpCity\":null, \"PickUpDate\":null, \"ReturnDate\":null, \"CarType\":null}", "lastConfirmedReservation":"{\"ReservationType\":\"Hotel\", \"Location\":\"Chicago\", \"RoomType\":\"queen\", \"CheckInDate\":\"2016-12-18\", \"Nights\":\"5\"}" } } ``` 1. Amazon Lex liest das `inputText` und kennt den Kontext (hat den Benutzer gebeten, die auto Population zu bestätigen). Amazon Lex ruft die Lambda-Funktion auf, indem es das folgende Ereignis sendet: ``` { "messageVersion": "1.0", "invocationSource": "DialogCodeHook", "userId": "wch89kjqcpkds8seny7dly5x3otq68j3", "sessionAttributes": { "confirmationContext": "AutoPopulate", "currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":null,\"PickUpDate\":null,\"ReturnDate\":null,\"CarType\":null}", "lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}" }, "bot": { "name": "BookTrip", "alias": null, "version": "$LATEST" }, "outputDialogMode": "Text", "currentIntent": { "name": "BookCar", "slots": { "PickUpDate": "2016-12-18", "ReturnDate": "2016-12-22", "DriverAge": null, "CarType": null, "PickUpCity": "Chicago" }, "confirmationStatus": "Confirmed" } } ``` Da der Benutzer mit Ja geantwortet hat, setzt Amazon Lex den `confirmationStatus` Wert auf`Confirmed`. 1. Aus dem `confirmationStatus` weiß die Lambda-Funktion, dass die vorab ausgefüllten Werte korrekt sind. Die Lambda-Funktion bewirkt Folgendes: + Sie aktualisiert das Sitzungsattribut `currentReservation` auf den vorab ausgefüllten Slot-Wert. + Sie setzt den `dialogAction.type` auf `ElicitSlot`. + Sie setzt den Wert `slotToElicit` auf `DriverAge`. Die folgende Antwort wird gesendet: ``` { "sessionAttributes": { "currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":\"Chicago\",\"PickUpDate\":\"2016-12-18\",\"ReturnDate\":\"2016-12-22\",\"CarType\":null}", "lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}" }, "dialogAction": { "type": "ElicitSlot", "intentName": "BookCar", "slots": { "PickUpDate": "2016-12-18", "ReturnDate": "2016-12-22", "DriverAge": null, "CarType": null, "PickUpCity": "Chicago" }, "slotToElicit": "DriverAge", "message": { "contentType": "PlainText", "content": "How old is the driver of this car rental?" } } } ``` 1. Amazon Lex gibt folgende Antwort zurück: ![\[JSON-Antwort, aus der die Absicht hervorgeht, ein Auto zu buchen, und eine Nachricht, in der der Slot für den Driver Age-Slot ausgewählt wurde.\]](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/book-car-20.png) Der Kunde zeigt die Meldung „Wie alt ist der Fahrer dieser Autovermietung?“ und die Unterhaltung wird fortgesetzt.