Wenn Sie Amazon Lex V2 verwenden, lesen Sie stattdessen das Amazon Lex V2-Handbuch.

Wenn Sie Amazon Lex V1 verwenden, empfehlen wir, Ihre Bots auf Amazon Lex V2 zu aktualisieren. Wir fügen V1 keine neuen Funktionen mehr hinzu und empfehlen dringend, V2 für alle neuen Bots zu verwenden.

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.

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 mithilfe derPostText Runtime-API Anfragen an Amazon Lex sendet, und die Anfrage- und Antwortdetails werden entsprechend angezeigt. Ein Beispiel für den Informationsfluss zwischen dem Client und Amazon Lex, bei dem der Kunde diePostContent API verwendet, finden Sie unterSchritt 2a (optional): Prüfen der Details des Informationsflusses gesprochener Inhalte (Konsole) .

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.

Benutzer: Ich möchte einige Blumen bestellen.
1. Der Client (Konsole) sendet die folgende PostText-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 Anfrage-URI als auch der Text liefern Informationen an Amazon Lex:
  - Anforderungs-URI — Stellt den Botnamen (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.
2. Anhand desinputText erkennt Amazon Lex die Absicht (OrderFlowers). Diese Absicht wird 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 übergibt:
```
{
    "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.
  
  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— Gibt den Zweck des Aufrufs einer 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 angegeben hat, um die Absicht zu erfüllen.
  - currentIntent-Daten, wobei alle Slot-Werte auf Null gesetzt sind.
3. 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.
  
  Beachten Sie Folgendes:
  - dialogAction.type— Wenn Sie diesen Wert auf festlegenDelegate, delegiert die Lambda-Funktion die Verantwortung für die Entscheidung über die nächste Vorgehensweise an Amazon Lex.
    
    Anmerkung
    Wenn die Lambda-Funktion bei der Benutzerdatenüberprüfung etwas feststellt, weist sie Amazon Lex an, was als Nächstes zu tun ist, wie in den nächsten Schritten gezeigt.
4. Laut demdialogAction.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:
  
  Der Client zeigt die Mitteilung in der Antwort an.
Benutzer: Rosen
1. Der Kunde sendet die folgendePostText 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.
2. Amazon Lex interpretiert das zunächstinputText 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 denFlowerType Slot auf Rosen aktualisiert.
3. Entsprechend deminvocationSource Wert vonDialogCodeHook führt die Lambda-Funktion eine Benutzerdatenvalidierung durch. Es wirdroses als gültiger Slot-Wert erkannt (undPrice 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 hatPrice (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.
4. Laut demdialogAction.type wählt Amazon Lex die nächste Vorgehensweise. Amazon Lex weiß, dass es mehr Steckplatzdaten benötigt, und wählt daher den nächsten unbesetzten Steckplatz (PickupDate) mit der höchsten Priorität entsprechend der gewünschten Konfiguration aus. Amazon Lex wählt eine der Aufforderungen zur Wertermittlung aus: „An welchem Tag sollen die Rosen abgeholt werden?“ —für diesen Slot gemäß der Intent-Konfiguration und sendet dann die folgende Antwort zurück an den Client:
  
  Der Client zeigt einfach die Mitteilung in der Antwort an: "An welchem Tag möchten Sie die Rosen abholen?"
Benutzer: morgen
1. Der Kunde sendet die folgendePostText 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.
2. Amazon Lex erinnert sich an den Kontext — dass es Daten für denPickupDate Slot abgerufen hat. 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 denPickupDate Wert festgelegt hat. Beachten Sie auch, dass der Dienst dassessionAttributes unverändert an die Lambda-Funktion übergibt.
3. Gemäß deminvocationSource Wert vonDialogCodeHook führt die Lambda-Funktion eine Benutzerdatenvalidierung durch. Es erkennt, dass derPickupDate 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.
4. Laut demdialogAction.type wählt Amazon Lex die nächste Vorgehensweise. Amazon Lex weiß, dass es mehr Steckplatzdaten benötigt, und wählt daher den nächsten unbesetzten Steckplatz (PickupTime) mit der höchsten Priorität entsprechend der gewünschten Konfiguration aus. Amazon Lex wählt eine der Eingabeaufforderungen aus („Liefern Sie die Rosen zu welcher Uhrzeit am 05.01.2017?“) für diesen Slot gemäß der Intent-Konfiguration und sendet die folgende Antwort zurück an den Client:
  
  Der Kunde zeigt die Nachricht in der Antwort an: „Liefern Sie die Rosen zu welcher Uhrzeit am 05.01.2017?“
Benutzer: 16 Uhr
1. Der Kunde sendet die folgendePostText 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.
2. Amazon Lex versteht den Kontext. Es versteht, dass es Daten für den Slot PickupTime erfragt hat. In diesem Zusammenhang weiß es, dass derinputText Wert für denPickupTime 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 denPickupTime Wert festgelegt hat.
3. Entsprechend deminvocationSource Wert vonDialogCodeHook führt die Lambda-Funktion eine Benutzerdatenvalidierung durch. Es erkennt, dass derPickupDate 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.
4. Zu diesem Zeitpunkt weiß Amazon Lex, dass alle Slot-Daten vorliegen. Diese Absicht wurde mit einer Bestätigungsaufforderung konfiguriert. Daher sendet Amazon Lex die folgende Antwort an den Benutzer und bittet ihn um Bestätigung, bevor die Absicht erfüllt wird:
  
  Der Client zeigt einfach die Mitteilung in der Antwort an und wartet auf die Antwort des Benutzers.
Benutzer: Ja
1. Der Kunde sendet die folgendePostText 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"
    }
}
```
2. Amazon Lex interpretiert dasinputText im Kontext der Bestätigung der aktuellen Absicht. Amazon Lex geht davon aus, dass der Benutzer mit der Bestellung fortfahren möchte. Dieses Mal ruft Amazon Lex die Lambda-Funktion auf, um die Absicht zu erfüllen, indem das folgende Ereignis gesendet wird, das das An für dasinvocationSource Ereignis festlegt, das an die Lambda-Funktion gesendet wird.FulfillmentCodeHook Amazon Lex gibt auch dieconfirmationStatus Messlatte vorConfirmed.
```
{
    "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— Dieses Mal hat Amazon Lex diesen Wert auf gesetztFulfillmentCodeHook und die Lambda-Funktion angewiesen, die Absicht zu erfüllen.
  - confirmationStatus: Wird auf Confirmed gesetzt.
3. Dieses Mal erfüllt die Lambda-Funktion dieOrderFlowers 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 festdialogAction.type — Die Lambda-Funktion legt diesen Wert auf festClose und weist Amazon Lex an, keine Benutzerantwort zu erwarten.
  - dialogAction.fulfillmentState: ist auf Fulfilled eingestellt und enthält eine geeignete message zur Übermittlung an den Benutzer.
4. Amazon LexfulfillmentState überprüft Sie die folgende Antwort an den Kunden.
  
  Amazon Lex gibt dann Folgendes an den Kunden zurück:
  
  Beachten Sie:
  - dialogState— Amazon Lex legt diesen Wert auf festfulfilled.
  - message— ist dieselbe Meldung, die die Lambda-Funktion geliefert hat.
  Der Client zeigt die Mitteilung an.
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. Dieses Mal führt die Lambda-Funktion die Datenüberprüfung 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 AttributPrice in the session, sodass die Gesamtzahl der Blumenbestellungen konstant bleibt.
Die Lambda-Funktion führt auch die Fulfillment-Aktivität aus.

Nächster Schritt

Schritt 6: Aktualisieren der Absichtskonfiguration zum Hinzufügen einer Äußerung (Konsole)

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Schritt 4: Fügen Sie die Lambda-Funktion als Code-Hook hinzu (Konsole)

Schritt 6: Aktualisieren der Absichtskonfiguration zum Hinzufügen einer Äußerung (Konsole)