Pemberitahuan akhir dukungan: Pada 15 September 2025, AWS akan menghentikan dukungan untuk Amazon Lex V1. Setelah 15 September 2025, Anda tidak lagi dapat mengakses konsol Amazon Lex V1 atau sumber daya Amazon Lex V1. Jika Anda menggunakan Amazon Lex V2, lihat [panduan Amazon Lex V2](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html) sebagai gantinya.
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Pesan Perjalanan
Contoh ini menggambarkan pembuatan bot yang dikonfigurasi untuk mendukung beberapa maksud. Contoh ini juga menggambarkan bagaimana Anda dapat menggunakan atribut sesi untuk berbagi informasi lintas maksud. Setelah membuat bot, Anda menggunakan klien pengujian di konsol Amazon Lex untuk menguji bot (BookTrip). Klien menggunakan operasi API [PostText](API_runtime_PostText.md) runtime untuk mengirim permintaan ke Amazon Lex untuk setiap input pengguna.
BookTrip Bot dalam contoh ini dikonfigurasi dengan dua maksud (BookHotel dan BookCar). Misalnya, seorang pengguna pertama kali memesan hotel. Selama interaksi, pengguna memberikan informasi seperti tanggal check-in, lokasi, dan jumlah malam. Setelah maksud terpenuhi, klien dapat menyimpan informasi ini menggunakan atribut sesi. Untuk informasi selengkapnya tentang atribut sesi, lihat[PostText](API_runtime_PostText.md).
Sekarang anggaplah pengguna terus memesan mobil. Menggunakan informasi yang diberikan pengguna di BookHotel intent sebelumnya (yaitu kota tujuan, serta tanggal check-in dan check-out), hook kode (fungsi Lambda) yang Anda konfigurasikan untuk menginisialisasi dan memvalidasi maksud, menginisialisasi data slot untuk BookCar BookCar maksud (yaitu, tujuan, kota penjemputan, tanggal pengambilan, dan tanggal pengembalian). Ini menggambarkan bagaimana berbagi informasi lintas maksud memungkinkan Anda membangun bot yang dapat terlibat dalam percakapan dinamis dengan pengguna.
Dalam contoh ini, kita menggunakan atribut sesi berikut. Hanya klien dan fungsi Lambda yang dapat mengatur dan memperbarui atribut sesi. Amazon Lex hanya meneruskan ini antara klien dan fungsi Lambda. Amazon Lex tidak mempertahankan atau memodifikasi atribut sesi apa pun.
+ `currentReservation`— Berisi data slot untuk reservasi yang sedang berlangsung dan informasi relevan lainnya. Misalnya, berikut ini adalah contoh permintaan dari klien ke Amazon Lex. Ini menunjukkan atribut `currentReservation` sesi di badan permintaan.
```
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`— Berisi informasi serupa untuk maksud sebelumnya, jika ada. Misalnya, jika pengguna memesan hotel dan kemudian sedang dalam proses pemesanan mobil, atribut sesi ini menyimpan data slot untuk BookHotel maksud sebelumnya.
+ `confirmationContext`— Fungsi Lambda mengatur ini `AutoPopulate` saat mengisi beberapa data slot berdasarkan data slot dari reservasi sebelumnya (jika ada). Ini memungkinkan berbagi informasi lintas maksud. Misalnya, jika pengguna sebelumnya memesan hotel dan sekarang ingin memesan mobil, Amazon Lex dapat meminta pengguna untuk mengonfirmasi (atau menolak) bahwa mobil sedang dipesan untuk kota dan tanggal yang sama dengan reservasi hotel mereka
Dalam latihan ini Anda menggunakan cetak biru untuk membuat bot Amazon Lex dan fungsi Lambda. Untuk informasi selengkapnya tentang cetak biru, lihat [Amazon Lex dan AWS Lambda Cetak Biru](lex-lambda-blueprints.md).
**Langkah Selanjutnya**
[Langkah 1: Tinjau Cetak Biru yang Digunakan dalam Latihan ini](ex-book-trip-blueprints.md)
# Langkah 1: Tinjau Cetak Biru yang Digunakan dalam Latihan ini
**Topics**
+ [Ikhtisar Bot Blueprint () BookTrip](#ex-book-trip-bp-summary-bot)
+ [Ikhtisar Cetak Biru Fungsi Lambda () lex-book-trip-python](#ex-book-trip-summary-lambda)
## Ikhtisar Bot Blueprint () BookTrip
Blueprint (**BookTrip**) yang Anda gunakan untuk membuat bot menyediakan pra-konfigurasi berikut:
+ **Jenis slot** - Dua jenis slot khusus:
+ `RoomTypes`dengan nilai enumerasi:`king`,, dan `queen``deluxe`, untuk digunakan dalam maksud. `BookHotel`
+ `CarTypes`dengan nilai enumerasi:`economy`,,`standard`,`midsize`,`full size`, dan `luxury``minivan`, untuk digunakan dalam maksud. `BookCar`
+ **Maksud 1 (BookHotel)** - Ini telah dikonfigurasikan sebagai berikut:
+ **Slot yang telah dikonfigurasi sebelumnya**
+ `RoomType`, dari jenis slot `RoomTypes` khusus
+ `Location`, dari tipe slot `AMAZON.US_CITY` bawaan
+ `CheckInDate`, dari tipe slot `AMAZON.DATE` bawaan
+ `Nights`, dari tipe slot `AMAZON.NUMBER` bawaan
+ **Ucapan yang telah dikonfigurasi**
+ “Pesan hotel”
+ “Saya ingin membuat reservasi hotel”
+ “Pesan \$1Nights\$1 menginap di \$1Lokasi\$1”
Jika pengguna mengucapkan salah satu dari ini, Amazon Lex menentukan bahwa itu `BookHotel` adalah maksud dan kemudian meminta pengguna untuk data slot.
+ **Permintaan yang telah dikonfigurasi**
+ Prompt untuk `Location` slot — “Kota apa yang akan Anda tinggali?”
+ Prompt untuk `CheckInDate` slot — “Hari apa Anda ingin check-in?”
+ Prompt untuk `Nights` slot — “Berapa malam Anda akan tinggal?”
+ Prompt untuk `RoomType` slot — “Jenis kamar apa yang Anda inginkan, ratu, raja, atau deluxe?”
+ Pernyataan konfirmasi — “Oke, saya meminta Anda untuk menginap malam \$1Nights\$1 di \$1Location\$1 mulai \$1CheckInDate\$1. Haruskah saya memesan reservasi?”
+ Penolakan — “Oke, saya telah membatalkan reservasi Anda dalam proses.”
+ **Maksud 2 (BookCar)** - Ini telah dikonfigurasikan sebagai berikut:
+ **Slot yang telah dikonfigurasi sebelumnya**
+ `PickUpCity`, dari tipe `AMAZON.US_CITY` bawaan
+ `PickUpDate`, dari tipe `AMAZON.DATE` bawaan
+ `ReturnDate`, dari tipe `AMAZON.DATE` bawaan
+ `DriverAge`, dari tipe `AMAZON.NUMBER` bawaan
+ `CarType`, dari tipe `CarTypes` kustom
+ **Ucapan yang telah dikonfigurasi**
+ “Pesan mobil”
+ “Pesan mobil”
+ “Buat reservasi mobil”
Jika pengguna mengucapkan salah satu dari ini, Amazon Lex menentukan BookCar maksud dan kemudian meminta pengguna untuk data slot.
+ **Permintaan yang telah dikonfigurasi**
+ Prompt untuk `PickUpCity` slot — “Di kota apa Anda perlu menyewa mobil?”
+ Prompt untuk `PickUpDate` slot — “Hari apa Anda ingin memulai sewa Anda?”
+ Prompt untuk `ReturnDate` slot — “Hari apa Anda ingin mengembalikan mobil ini?”
+ Prompt untuk `DriverAge` slot — “Berapa umur pengemudi untuk sewa ini?”
+ Prompt untuk `CarType` slot — “Jenis mobil apa yang ingin Anda sewa? Pilihan kami yang paling populer adalah ekonomi, menengah, dan mewah”
+ Pernyataan konfirmasi — “Oke, saya minta Anda turun untuk sewa \$1CarType\$1 di \$1PickUpCity\$1 dari \$1PickUpDate\$1 ke \$1ReturnDate\$1. Haruskah saya memesan reservasi?”
+ Penolakan — “Oke, saya telah membatalkan reservasi Anda dalam proses.”
## Ikhtisar Cetak Biru Fungsi Lambda () lex-book-trip-python
Selain cetak biru bot, AWS Lambda menyediakan blueprint (**lex-book-trip-python**) yang dapat Anda gunakan sebagai pengait kode dengan cetak biru bot. Untuk daftar cetak biru bot dan cetak biru fungsi Lambda yang sesuai, lihat. [Amazon Lex dan AWS Lambda Cetak Biru](lex-lambda-blueprints.md)
Saat Anda membuat bot menggunakan BookTrip cetak biru, Anda memperbarui konfigurasi maksud (BookCar dan BookHotel) dengan menambahkan fungsi Lambda ini sebagai pengait kode untuk input data pengguna dan initialization/validation pemenuhan maksud.
Kode fungsi Lambda yang disediakan ini menampilkan percakapan dinamis menggunakan informasi yang diketahui sebelumnya (bertahan dalam atribut sesi) tentang pengguna untuk menginisialisasi nilai slot untuk maksud. Untuk informasi selengkapnya, lihat [Mengelola Konteks Percakapan](context-mgmt.md).
**Langkah Selanjutnya**
[Langkah 2: Buat Amazon Lex Bot](ex-book-trip-create-bot.md)
# Langkah 2: Buat Amazon Lex Bot
Di bagian ini, Anda membuat bot Amazon Lex (BookTrip).
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Pada halaman **Bots**, pilih **Buat**.
1. Pada halaman **Create your Lex bot**,
+ Pilih **BookTrip**cetak biru.
+ Tinggalkan nama bot default (BookTrip).
1. Pilih **Buat**. Konsol mengirimkan serangkaian permintaan ke Amazon Lex untuk membuat bot. Perhatikan hal-hal berikut:
1. Konsol menunjukkan BookTrip bot. Pada tab **Editor**, tinjau detail maksud yang telah dikonfigurasi sebelumnya (BookCar dan BookHotel).
1. Uji bot di jendela uji. Gunakan yang berikut ini untuk terlibat dalam percakapan uji coba dengan bot Anda:
![\[Percakapan dengan agen, di mana agen memunculkan kota, hari, jumlah malam, dan jenis kamar untuk perjalanan pelanggan. Agen kemudian mengkonfirmasi reservasi.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/book-trip-no-lambda-10.png)
Dari input pengguna awal (“Pesan hotel”), Amazon Lex menyimpulkan intent ()BookHotel. Bot kemudian menggunakan prompt yang telah dikonfigurasi sebelumnya dalam maksud ini untuk memperoleh data slot dari pengguna. Setelah pengguna memberikan semua data slot, Amazon Lex mengembalikan respons kembali ke klien dengan pesan yang mencakup semua input pengguna sebagai pesan. Klien menampilkan pesan dalam respons seperti yang ditunjukkan.
```
CheckInDate:2016-12-18 Location:Chicago Nights:5 RoomType:queen
```
Sekarang Anda melanjutkan percakapan dan mencoba memesan mobil dalam percakapan berikut.
![\[Percakapan dengan agen, di mana agen memunculkan kota, hari mulai, hari kembali, usia pengemudi, dan jenis mobil, untuk sewa mobil pelanggan. Agen kemudian mengkonfirmasi reservasi.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/book-trip-no-lambda-20.png)
Perhatikan bahwa,
+ Tidak ada validasi data pengguna saat ini. Misalnya, Anda dapat menyediakan kota mana pun untuk memesan hotel.
+ Anda memberikan beberapa informasi yang sama lagi (tujuan, kota penjemputan, tanggal penjemputan, dan tanggal kembali) untuk memesan mobil. Dalam percakapan dinamis, bot Anda harus menginisialisasi beberapa informasi ini berdasarkan masukan sebelumnya yang diberikan pengguna untuk pemesanan hotel.
Di bagian berikutnya, Anda membuat fungsi Lambda untuk melakukan beberapa validasi data pengguna, dan inisialisasi menggunakan berbagi informasi lintas maksud melalui atribut sesi. Kemudian Anda memperbarui konfigurasi intent dengan menambahkan fungsi Lambda sebagai hook kode untuk initialization/validation melakukan input pengguna dan memenuhi intent.
**Langkah Selanjutnya**
[Langkah 3: Buat fungsi Lambda](ex-book-trip-create-lambda-function.md)
# Langkah 3: Buat fungsi Lambda
Di bagian ini Anda membuat fungsi Lambda menggunakan blueprint (**lex-book-trip-python**) yang disediakan di konsol. AWS Lambda Anda juga menguji fungsi Lambda dengan memanggilnya menggunakan contoh data peristiwa yang disediakan oleh konsol.
Fungsi Lambda ini ditulis dengan Python.
1. Masuk ke Konsol Manajemen AWS dan buka AWS Lambda konsol di [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Pilih **Buat fungsi**.
1. Pilih **Gunakan cetak biru**. Ketik **lex** untuk menemukan cetak biru, pilih cetak biru. `lex-book-trip-python`
1. Pilih **Konfigurasi** fungsi Lambda sebagai berikut.
+ Ketik nama fungsi Lambda ()`BookTripCodeHook`.
+ Untuk peran tersebut, pilih **Buat peran baru dari templat**, lalu ketik nama peran.
+ Tinggalkan nilai default lainnya.
1. Pilih **Buat fungsi**.
1. Jika Anda menggunakan lokal selain bahasa Inggris (AS) (en-US), perbarui nama maksud seperti yang dijelaskan dalam. [Memperbarui Cetak Biru untuk Lokal Tertentu](lex-lambda-blueprints.md#blueprint-update-locale)
1. Uji fungsi Lambda. Anda memanggil fungsi Lambda dua kali, menggunakan data sampel untuk pemesanan mobil dan pemesanan hotel.
1. Pilih **Konfigurasikan peristiwa pengujian** dari **menu drop-down Pilih acara pengujian**.
1. Pilih **Amazon Lex Book Hotel** dari daftar **template acara Sample**.
Contoh acara ini cocok dengan request/response model Amazon Lex. Untuk informasi selengkapnya, lihat [Menggunakan Fungsi Lambda](using-lambda.md).
1. Pilih **Simpan dan uji**.
1. Verifikasi bahwa fungsi Lambda berhasil berjalan. Respons dalam hal ini cocok dengan model respons Amazon Lex.
1. Ulangi langkahnya. Kali ini Anda memilih **Amazon Lex Book Car** dari daftar **template acara Sample**. Fungsi Lambda memproses reservasi mobil.
**Langkah Selanjutnya**
[Langkah 4: Tambahkan Fungsi Lambda sebagai Kode Hook](ex-book-trip-create-integrate.md)
# Langkah 4: Tambahkan Fungsi Lambda sebagai Kode Hook
Di bagian ini, Anda memperbarui konfigurasi BookHotel maksud BookCar dan maksud dengan menambahkan fungsi Lambda sebagai pengait kode untuk initialization/validation dan aktivitas pemenuhan. Pastikan Anda memilih versi \$1 LATEST dari intent karena Anda hanya dapat memperbarui versi \$1LATEST dari sumber daya Amazon Lex Anda.
1. Di konsol Amazon Lex, pilih **BookTrip**bot.
1. Pada tab **Editor**, pilih **BookHotel**intent. Perbarui konfigurasi maksud sebagai berikut:
1. Pastikan versi intent (di sebelah nama maksud) adalah \$1LATEST.
1. Tambahkan fungsi Lambda sebagai pengait kode inisialisasi dan validasi sebagai berikut:
+ Di **Opsi**, pilih **Inisialisasi dan pengait kode validasi**.
+ Pilih fungsi Lambda Anda dari daftar.
1. Tambahkan fungsi Lambda sebagai hook kode pemenuhan sebagai berikut:
+ Dalam **Pemenuhan**, pilih fungsi **AWS Lambda**.
+ Pilih fungsi Lambda Anda dari daftar.
+ Pilih **Pesan selamat tinggal** dan ketik pesan.
1. Pilih **Simpan**.
1. Pada tab **Editor**, pilih BookCar intent. Ikuti langkah sebelumnya untuk menambahkan fungsi Lambda Anda sebagai pengait kode validasi dan pemenuhan.
1. Pilih **Build**. Konsol mengirimkan serangkaian permintaan ke Amazon Lex untuk menyimpan konfigurasi.
1. Uji botnya. Sekarang Anda memiliki fungsi Lambda melakukan inisialisasi, validasi data pengguna dan pemenuhan, Anda dapat melihat perbedaan dalam interaksi pengguna dalam percakapan berikut:
![\[Percakapan dengan agen, di mana agen memunculkan kota, hari, jumlah malam, dan jenis kamar untuk reservasi perjalanan dan kemudian mengkonfirmasi reservasi.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/book-trip-with-lambda-30.png)
Untuk informasi selengkapnya tentang aliran data dari klien (konsol) ke Amazon Lex, dan dari Amazon Lex ke fungsi Lambda, lihat. [Aliran Data: Pesan Hotel Intent](book-trip-detail-flow.md#data-flow-book-hotel)
1. Lanjutkan percakapan dan pesan mobil seperti yang ditunjukkan pada gambar berikut:
![\[Percakapan dengan agen, di mana agen memunculkan usia pengemudi dan jenis mobil dan kemudian mengkonfirmasi reservasi mobil.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/book-trip-with-lambda-40.png)
Ketika Anda memilih untuk memesan mobil, klien (konsol) mengirimkan permintaan ke Amazon Lex yang menyertakan atribut sesi (dari percakapan sebelumnya, BookHotel). Amazon Lex meneruskan informasi ini ke fungsi Lambda, yang kemudian menginisialisasi (yaitu, mengisi sebelumnya) beberapa data BookCar slot (yaitu,,, PickUpDate dan). ReturnDate PickUpCity
**catatan**
Ini menggambarkan bagaimana atribut sesi dapat digunakan untuk mempertahankan konteks di seluruh maksud. Klien konsol menyediakan tautan **Hapus** di jendela pengujian yang dapat digunakan pengguna untuk menghapus atribut sesi sebelumnya.
Untuk informasi selengkapnya tentang aliran data dari klien (konsol) ke Amazon Lex, dan dari Amazon Lex ke fungsi Lambda, lihat. [Aliran Data: Pesan Niat Mobil](book-trip-detail-flow.md#data-flow-book-car)
# Rincian Alur Informasi
Dalam latihan ini, Anda terlibat dalam percakapan dengan BookTrip bot Amazon Lex menggunakan klien jendela uji yang disediakan di konsol Amazon Lex. Bagian ini menjelaskan hal berikut:
+ Aliran data antara klien dan Amazon Lex.
Bagian ini mengasumsikan bahwa klien mengirimkan permintaan ke Amazon Lex menggunakan API `PostText` runtime dan menampilkan detail permintaan dan respons yang sesuai. Untuk informasi selengkapnya tentang API `PostText` runtime, lihat[PostText](API_runtime_PostText.md).
**catatan**
Untuk contoh aliran informasi antara klien dan Amazon Lex di mana klien menggunakan `PostContent` API, lihat[Langkah 2a (Opsional): Tinjau Detail Alur Informasi Lisan (Konsol)](gs-bp-details-postcontent-flow.md).
+ Aliran data antara Amazon Lex dan fungsi Lambda. Untuk informasi selengkapnya, lihat [Peristiwa Input Fungsi Lambda dan Format Respons](lambda-input-response-format.md).
**Topics**
+ [Aliran Data: Pesan Hotel Intent](#data-flow-book-hotel)
+ [Aliran Data: Pesan Niat Mobil](#data-flow-book-car)
## Aliran Data: Pesan Hotel Intent
Bagian ini menjelaskan apa yang terjadi setelah setiap input pengguna.
1. Pengguna: “pesan hotel”
1. Klien (konsol) mengirimkan [PostText](API_runtime_PostText.md) permintaan berikut ke Amazon Lex:
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"book a hotel",
"sessionAttributes":{}
}
```
URI permintaan dan badan memberikan informasi ke Amazon Lex:
+ Request URI — Menyediakan nama bot (BookTrip), bot alias (\$1 LATEST) dan nama pengguna. Trailing `text` menunjukkan bahwa itu adalah permintaan `PostText` API (dan bukan`PostContent`).
+ Request body - Termasuk input pengguna (`inputText`) dan kosong`sessionAttributes`. Awalnya, ini adalah objek kosong dan fungsi Lambda pertama menetapkan atribut sesi.
1. Dari`inputText`, Amazon Lex mendeteksi intent ()BookHotel. Maksud ini dikonfigurasi dengan fungsi Lambda sebagai hook kode untuk inisialisasi/validasi data pengguna. Oleh karena itu, Amazon Lex memanggil fungsi Lambda tersebut dengan meneruskan informasi berikut sebagai parameter peristiwa ([Format Peristiwa Masukan](lambda-input-response-format.md#using-lambda-input-event-format)lihat):
```
{
"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"
}
}
```
Selain informasi yang dikirim oleh klien, Amazon Lex juga menyertakan data tambahan berikut:
+ `messageVersion`- Saat ini Amazon Lex hanya mendukung versi 1.0.
+ `invocationSource`— Menunjukkan tujuan pemanggilan fungsi Lambda. Dalam hal ini, ini adalah untuk melakukan inisialisasi dan validasi data pengguna (saat ini Amazon Lex tahu bahwa pengguna belum menyediakan semua data slot untuk memenuhi maksud).
+ `currentIntent`— Semua nilai slot diatur ke nol.
1. Pada saat ini, semua nilai slot adalah nol. Tidak ada fungsi Lambda untuk memvalidasi. Fungsi Lambda mengembalikan respons berikut ke Amazon Lex. Untuk informasi tentang format respons, lihat[Format Respons](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
}
}
}
```
**catatan**
`currentReservation`— Fungsi Lambda mencakup atribut sesi ini. Nilainya adalah salinan informasi slot saat ini dan jenis reservasi.
Hanya fungsi Lambda dan klien yang dapat memperbarui atribut sesi ini. Amazon Lex hanya meneruskan nilai-nilai ini.
`dialogAction.type`— Dengan menetapkan nilai ini`Delegate`, fungsi Lambda mendelegasikan tanggung jawab untuk tindakan selanjutnya ke Amazon Lex.
Jika fungsi Lambda mendeteksi apa pun dalam validasi data pengguna, fungsi ini menginstruksikan Amazon Lex apa yang harus dilakukan selanjutnya.
1. Sesuai dengan itu`dialogAction.type`, Amazon Lex memutuskan tindakan selanjutnya — mendapatkan data dari pengguna untuk slot. `Location` Ini memilih salah satu pesan prompt (“Kota apa yang akan Anda tinggali?”) untuk slot ini, sesuai dengan konfigurasi maksud, dan kemudian mengirimkan respons berikut kepada pengguna:
![\[Respons JSON yang berisi status dialog, nama maksud, pesan, kartu respons, atribut sesi, slot yang akan diperoleh, dan slot.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/book-hotel-10.png)
Atribut sesi diteruskan ke klien.
Klien membaca tanggapan dan kemudian menampilkan pesan: “Kota apa yang akan Anda tinggali?”
1. Pengguna: “Moskow”
1. Klien mengirimkan `PostText` permintaan berikut ke Amazon Lex (jeda baris ditambahkan untuk keterbacaan):
```
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}"
}
}
```
Selain itu`inputText`, klien menyertakan atribut `currentReservation` sesi yang sama yang diterimanya.
1. Amazon Lex pertama-tama menafsirkan `inputText` dalam konteks maksud saat ini (layanan mengingat bahwa ia telah meminta pengguna tertentu untuk informasi tentang `Location` slot). Ini memperbarui nilai slot untuk maksud saat ini dan memanggil fungsi Lambda menggunakan peristiwa berikut:
```
{
"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"
}
}
```
**catatan**
`invocationSource`terus menjadi`DialogCodeHook`. Pada langkah ini, kami hanya memvalidasi data pengguna.
Amazon Lex baru saja meneruskan atribut session ke fungsi Lambda.
Untuk`currentIntent.slots`, Amazon Lex telah memperbarui `Location` slot ke`Moscow`.
1. Fungsi Lambda melakukan validasi data pengguna dan menentukan lokasi yang `Moscow` tidak valid.
**catatan**
Fungsi Lambda dalam latihan ini memiliki daftar sederhana kota yang valid dan tidak `Moscow` ada dalam daftar. Dalam aplikasi produksi, Anda mungkin menggunakan database back-end untuk mendapatkan informasi ini.
Ini mengatur ulang nilai slot kembali ke nol dan mengarahkan Amazon Lex untuk meminta pengguna lagi untuk nilai lain dengan mengirimkan respons berikut:
```
{
"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?"
}
}
}
```
**catatan**
`currentIntent.slots.Location`disetel ulang ke null.
`dialogAction.type`diatur ke`ElicitSlot`, yang mengarahkan Amazon Lex untuk meminta pengguna lagi dengan memberikan yang berikut:
`dialogAction.slotToElicit`— slot untuk mendapatkan data dari pengguna.
`dialogAction.message`— a `message` untuk disampaikan kepada pengguna.
1. Amazon Lex memperhatikan `dialogAction.type` dan meneruskan informasi ke klien dalam tanggapan berikut:
![\[Respons JSON yang berisi status dialog, nama maksud, pesan, kartu respons, atribut sesi, slot yang akan diperoleh, dan slot.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/book-hotel-20.png)
Klien hanya menampilkan pesan: “Saat ini kami tidak mendukung Moskow sebagai tujuan yang valid. Bisakah kamu mencoba kota yang berbeda?”
1. Pengguna: “Chicago”
1. Klien mengirimkan `PostText` permintaan berikut ke 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 tahu konteksnya, bahwa itu memunculkan data untuk slot. `Location` Dalam konteks ini, ia tahu `inputText` nilainya untuk `Location` slot. Kemudian memanggil fungsi Lambda dengan mengirimkan acara berikut:
```
{
"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 memperbarui `currentIntent.slots` dengan mengatur `Location` slot ke`Chicago`.
1. Menurut `invocationSource` nilai`DialogCodeHook`, fungsi Lambda melakukan validasi data pengguna. Ini mengenali `Chicago` sebagai nilai slot yang valid, memperbarui atribut sesi yang sesuai, dan kemudian mengembalikan respons berikut ke Amazon Lex.
```
{
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"dialogAction": {
"type": "Delegate",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": "Chicago"
}
}
}
```
**catatan**
`currentReservation`— Fungsi Lambda memperbarui atribut sesi ini dengan menyetel ke. `Location` `Chicago`
`dialogAction.type`— Diatur ke`Delegate`. Data pengguna valid, dan fungsi Lambda mengarahkan Amazon Lex untuk memilih tindakan berikutnya.
1. Menurut`dialogAction.type`, Amazon Lex memilih tindakan berikutnya. Amazon Lex tahu bahwa ia membutuhkan lebih banyak data slot dan memilih slot yang tidak terisi berikutnya (`CheckInDate`) dengan prioritas tertinggi sesuai dengan konfigurasi maksud. Ini memilih salah satu pesan prompt (“Hari apa yang ingin Anda periksa?”) untuk slot ini sesuai dengan konfigurasi maksud dan kemudian mengirimkan respons berikut kembali ke klien:
![\[Respons JSON yang berisi status dialog, nama maksud, pesan, kartu respons, atribut sesi, slot yang akan diperoleh, dan slot. Slot lokasi sekarang diisi sebagai Chicago.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/book-hotel-30.png)
Klien menampilkan pesan: “Hari apa Anda ingin check-in?”
1. Interaksi pengguna berlanjut—pengguna menyediakan data, fungsi Lambda memvalidasi data, dan kemudian mendelegasikan tindakan berikutnya ke Amazon Lex. Akhirnya pengguna menyediakan semua data slot, fungsi Lambda memvalidasi semua input pengguna, dan kemudian Amazon Lex mengenali bahwa ia memiliki semua data slot.
**catatan**
Dalam latihan ini, setelah pengguna menyediakan semua data slot, fungsi Lambda menghitung harga reservasi hotel dan mengembalikannya sebagai atribut sesi lain (). `currentReservationPrice`
Pada titik ini, intent siap dipenuhi, tetapi BookHotel intent dikonfigurasi dengan prompt konfirmasi yang memerlukan konfirmasi pengguna sebelum Amazon Lex dapat memenuhi intent. Oleh karena itu, Amazon Lex mengirimkan pesan berikut kepada klien yang meminta konfirmasi sebelum memesan hotel:
![\[Respons JSON yang berisi status dialog, nama maksud, pesan, kartu respons, atribut sesi, slot yang akan diperoleh, dan slot. Semua slot sekarang terisi.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/book-hotel-40.png)
Klien menampilkan pesan: “Oke, saya minta Anda turun selama 5 malam di Chicago mulai 2016-12-18. Haruskah saya memesan reservasi?”
1. Pengguna: “ya”
1. Klien mengirimkan `PostText` permintaan berikut ke 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 menafsirkan `inputText` dalam konteks mengonfirmasi maksud saat ini. Amazon Lex memahami bahwa pengguna ingin melanjutkan reservasi. Kali ini Amazon Lex memanggil fungsi Lambda untuk memenuhi maksud dengan mengirimkan acara berikut. Dengan mengatur `invocationSource` ke `FulfillmentCodeHook` dalam acara tersebut, ia mengirim ke fungsi Lambda. Amazon Lex juga menetapkan `confirmationStatus` untuk`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"
}
}
```
**catatan**
`invocationSource`— Kali ini, Amazon Lex menetapkan nilai ini`FulfillmentCodeHook`, mengarahkan fungsi Lambda untuk memenuhi maksud.
`confirmationStatus`— Diatur ke`Confirmed`.
1. Kali ini, fungsi Lambda memenuhi BookHotel intent, Amazon Lex menyelesaikan reservasi, dan kemudian mengembalikan respons berikut:
```
{
"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."
}
}
}
```
**catatan**
`lastConfirmedReservation`— Adalah atribut sesi baru yang ditambahkan fungsi Lambda (bukan`currentReservation`,`currentReservationPrice`).
`dialogAction.type`— Fungsi Lambda menetapkan nilai ini`Close`, menunjukkan bahwa Amazon Lex tidak mengharapkan respons pengguna.
`dialogAction.fulfillmentState`— Diatur ke `Fulfilled` dan termasuk yang sesuai `message` untuk disampaikan kepada pengguna.
1. Amazon Lex mengulas `fulfillmentState` dan mengirimkan tanggapan berikut kepada klien:
![\[Respons JSON yang berisi status dialog, nama maksud, pesan, kartu respons, atribut sesi, slot yang akan diperoleh, dan slot. Semua slot diisi dan kolom reservasi terakhir yang dikonfirmasi di bawah atribut sesi sekarang diisi.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/book-hotel-60.png)
**catatan**
`dialogState`— Amazon Lex menetapkan nilai ini ke`Fulfilled`.
`message`— Adalah pesan yang sama dengan fungsi Lambda yang disediakan.
Klien menampilkan pesan.
## Aliran Data: Pesan Niat Mobil
BookTrip Bot dalam latihan ini mendukung dua maksud (BookHotel dan BookCar). Setelah memesan hotel, pengguna dapat melanjutkan percakapan untuk memesan mobil. Selama sesi belum habis waktu, dalam setiap permintaan berikutnya klien terus mengirim atribut sesi (dalam contoh ini,`lastConfirmedReservation`). Fungsi Lambda dapat menggunakan informasi ini untuk menginisialisasi data slot untuk maksud tersebut. BookCar Ini menunjukkan bagaimana Anda dapat menggunakan atribut sesi dalam berbagi data lintas maksud.
Khususnya, saat pengguna memilih BookCar intent, fungsi Lambda menggunakan informasi yang relevan dalam atribut session untuk mengisi slot (PickUpDate, ReturnDate, dan) untuk intent. PickUpCity BookCar
**catatan**
Konsol Amazon Lex menyediakan tautan **Hapus** yang dapat Anda gunakan untuk menghapus atribut sesi sebelumnya.
Ikuti langkah-langkah dalam prosedur ini untuk melanjutkan percakapan.
1. Pengguna: “juga pesan mobil”
1. Klien mengirimkan `PostText` permintaan berikut ke 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\"}"
}
}
```
Klien menyertakan atribut `lastConfirmedReservation` sesi.
1. Amazon Lex mendeteksi intent (BookCar) dari file. `inputText` Maksud ini juga dikonfigurasi untuk memanggil fungsi Lambda untuk melakukan inisialisasi dan validasi data pengguna. Amazon Lex memanggil fungsi Lambda dengan acara berikut:
```
{
"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"
}
}
```
**catatan**
`messageVersion`- Saat ini Amazon Lex hanya mendukung versi 1.0.
`invocationSource`— Menunjukkan tujuan pemanggilan adalah untuk melakukan inisialisasi dan validasi data pengguna.
`currentIntent`— Ini termasuk nama niat dan slot. Pada saat ini, semua nilai slot adalah nol.
1. Fungsi Lambda memperhatikan semua nilai slot null tanpa memvalidasi apa pun. Namun, ia menggunakan atribut sesi untuk menginisialisasi beberapa nilai slot (`PickUpDate`,`ReturnDate`, dan`PickUpCity`), dan kemudian mengembalikan respons berikut:
```
{
"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?"
}
}
}
```
**catatan**
Selain itu`lastConfirmedReservation`, fungsi Lambda mencakup lebih banyak atribut sesi (`currentReservation`dan`confirmationContext`).
`dialogAction.type`disetel ke`ConfirmIntent`, yang memberi tahu Amazon Lex bahwa jawaban ya, tidak diharapkan dari pengguna (ConfirmationContext disetel AutoPopulate ke, fungsi Lambda mengetahui yes/no bahwa balasan pengguna adalah untuk mendapatkan konfirmasi pengguna tentang inisialisasi fungsi Lambda yang dilakukan (data slot yang diisi otomatis).
Fungsi Lambda juga menyertakan dalam respons pesan informatif untuk Amazon `dialogAction.message` Lex untuk kembali ke klien.
Istilah `ConfirmIntent` (nilai`dialogAction.type`) tidak terkait dengan maksud bot apa pun. Dalam contoh, fungsi Lambda menggunakan istilah ini untuk mengarahkan Amazon Lex untuk mendapatkan yes/no balasan dari pengguna.
1. Menurut`dialogAction.type`, Amazon Lex mengembalikan respons berikut ke klien:
![\[Respons JSON yang berisi status dialog, nama maksud, pesan, kartu respons, atribut sesi, slot yang akan diperoleh, dan slot.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/book-car-10.png)
Klien menampilkan pesan: “Apakah sewa mobil ini untuk masa inap 5 malam Anda di Chicago pada 2016-12-18?”
1. Pengguna: “ya”
1. Klien mengirimkan `PostText` permintaan berikut ke 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 membaca `inputText` dan mengetahui konteksnya (meminta pengguna untuk mengonfirmasi populasi mobil). Amazon Lex memanggil fungsi Lambda dengan mengirimkan acara berikut:
```
{
"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"
}
}
```
Karena pengguna menjawab Ya, Amazon Lex menetapkan `confirmationStatus` ke`Confirmed`.
1. Dari`confirmationStatus`, fungsi Lambda tahu bahwa nilai prepopulated sudah benar. Fungsi Lambda melakukan hal berikut:
+ Memperbarui atribut `currentReservation` sesi ke nilai slot yang telah diisi sebelumnya.
+ Mengatur `dialogAction.type` ke `ElicitSlot`
+ Menetapkan `slotToElicit` nilai ke`DriverAge`.
Tanggapan berikut dikirim:
```
{
"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 mengembalikan tanggapan berikut:
![\[Respons JSON menunjukkan niat untuk memesan mobil dan pesan memunculkan slot untuk slot Driver Age.\]](http://docs.aws.amazon.com/id_id/lex/latest/dg/images/book-car-20.png)
Klien menampilkan pesan “Berapa umur pengemudi rental mobil ini?” dan percakapan berlanjut.