Node untuk mengontrol logika aliran cepat Node untuk menangani data dalam aliran prompt Tabel ringkasan untuk tipe simpul

Jenis node dalam aliran cepat

Amazon Bedrock menyediakan jenis node berikut untuk membangun alur prompt Anda. Ketika Anda mengkonfigurasi node, Anda perlu menyediakan bidang-bidang berikut:

Nama — Masukkan nama untuk node.
Ketik — Di konsol, Anda menyeret dan melepas jenis node yang akan digunakan. DiAPI, gunakan type bidang dan yang sesuai FlowNodeConfigurationdi configuration lapangan.
Input — Berikan informasi berikut untuk setiap masukan:
- Nama — Nama untuk input. Beberapa node memiliki nama atau tipe yang telah ditentukan sebelumnya yang harus Anda gunakan. Untuk mempelajari mana yang memiliki nama yang telah ditentukan sebelumnya, lihatJenis simpul logika.
- Ekspresi — Tentukan bagian dari seluruh input untuk digunakan sebagai input individu. Untuk informasi selengkapnya, lihat Gunakan ekspresi untuk mendefinisikan input dengan mengekstrak bagian yang relevan dari seluruh input.
- Tipe — Tipe data untuk input. Ketika node ini tercapai saat runtime, Amazon Bedrock menerapkan ekspresi ke seluruh input dan memvalidasi bahwa hasilnya cocok dengan tipe data.
Output - Berikan informasi berikut untuk setiap output:
- Nama — Nama untuk output. Beberapa node memiliki nama atau tipe yang telah ditentukan sebelumnya yang harus Anda gunakan. Untuk mempelajari mana yang memiliki nama yang telah ditentukan sebelumnya, lihatJenis simpul logika.
- Tipe — Tipe data untuk output. Ketika node ini tercapai saat runtime, Amazon Bedrock memvalidasi bahwa output node cocok dengan tipe data.
Konfigurasi — Di konsol, Anda menentukan bidang khusus node di bagian atas node. DiAPI, gunakan yang sesuai FlowNodeConfigurationdan isi bidangnya.

Setiap jenis node dijelaskan di bawah ini dan strukturnya di API disediakan. Perluas bagian untuk mempelajari lebih lanjut tentang jenis node tersebut.

Node untuk mengontrol logika aliran cepat

Gunakan jenis node berikut untuk mengontrol logika aliran prompt Anda.

Setiap aliran prompt hanya berisi satu node input aliran dan harus dimulai dengan itu. Node input aliran mengambil content dari InvokeFlow permintaan, memvalidasi tipe data, dan mengirimkannya ke node berikut.

Berikut ini menunjukkan struktur umum dari FlowNodeobjek masukan dalamAPI:


{
    "name": "string",
    "type": "Input",
    "outputs": [
        {
            "name": "document",
            "type": "String | Number | Boolean | Object | Array",
        }
    ],
    "configuration": {
        "input": CONTEXT-DEPENDENT
    }
}

Sebuah node output aliran mengekstrak data input dari node sebelumnya, berdasarkan ekspresi yang ditentukan, dan mengembalikannya. Di konsol, output adalah respons yang dikembalikan setelah memilih Jalankan di jendela pengujian. DalamAPI, output dikembalikan di content bidang flowOutputEvent dalam InvokeFlow respon. Aliran prompt dapat memiliki beberapa node keluaran aliran.

Sebuah aliran dapat memiliki beberapa node keluaran aliran jika ada beberapa cabang dalam aliran.

Berikut ini menunjukkan struktur umum dari FlowNodeobjek output:


{
    "name": "string",
    "type": "Output",
    "inputs": [
        {
            "name": "document",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        }
    ],
    "configuration": {
        "output": CONTEXT-DEPENDENT
    }
}

Sebuah node kondisi mengirimkan data dari node sebelumnya ke node yang berbeda, tergantung pada kondisi yang didefinisikan. Sebuah node kondisi dapat mengambil beberapa input.

Sebagai contoh, lihat Buat aliran dengan node kondisi.

Untuk menentukan node kondisi

Tambahkan input sebanyak yang Anda butuhkan untuk mengevaluasi kondisi yang ingin Anda tambahkan.
Masukkan nama untuk setiap input, tentukan jenis yang diharapkan, dan tulis ekspresi untuk mengekstrak bagian yang relevan dari seluruh input.
Connect setiap input ke output yang relevan dari node upstream.
Tambahkan kondisi sebanyak yang Anda butuhkan.
Untuk setiap kondisi:
1. Masukkan nama untuk kondisi tersebut.
2. Gunakan operator relasional dan logis untuk menentukan kondisi yang membandingkan input dengan input lain atau konstanta.
  
  catatan
  Kondisi dievaluasi secara berurutan. Jika lebih dari satu kondisi terpenuhi, kondisi sebelumnya diutamakan.
3. Connect setiap kondisi ke node hilir yang ingin Anda kirimi data jika kondisi tersebut terpenuhi.

Ekspresi kondisi

Untuk menentukan kondisi, Anda merujuk ke input dengan namanya dan membandingkannya dengan nilai menggunakan salah satu operator relasional berikut:

Operator	Arti	Jenis data yang didukung	Contoh penggunaan	Contoh makna
==	Sama dengan (tipe data juga harus sama)	String, Nomor, Boolean	A == B	Jika A sama dengan B
!=	Tidak sama dengan	String, Nomor, Boolean	SEBUAH! = B	Jika A tidak sama dengan B
>	Lebih besar dari	Jumlah	A > B	Jika A lebih besar dari B
>=	Lebih besar dari atau sama dengan	Jumlah	A >= B	Jika A lebih besar dari atau sama dengan B
<	Kurang dari	Jumlah	A < B	Jika A kurang dari B
<=	Kurang dari atau sama dengan	Jumlah	A <= B	Jika A kurang dari atau sama dengan B

Anda dapat membandingkan input dengan input lain atau konstanta dalam ekspresi bersyarat. Misalnya, jika Anda memiliki input numerik yang dipanggil profit dan yang lain dipanggilexpenses, keduanya profit > expenses atau profit <= 1000 merupakan ekspresi yang valid.

Anda dapat menggunakan operator logis berikut untuk menggabungkan ekspresi untuk kondisi yang lebih kompleks. Kami menyarankan Anda menggunakan tanda kurung untuk menyelesaikan ambiguitas dalam pengelompokan ekspresi:

Operator	Arti	Contoh penggunaan	Contoh makna
and	Kedua ekspresi itu benar	(A < B) dan (C == 1)	Jika kedua ekspresi itu benar: A kurang dari B C sama dengan 1
atau	Setidaknya satu ekspresi benar	(SEBUAH! = 2) atau (B > C)	Jika salah satu ekspresi benar: A tidak sama dengan B B lebih besar dari C
tidak	Ekspresi itu tidak benar	tidak (A > B)	Jika A tidak lebih besar dari B (setara dengan A <= B)

DalamAPI, Anda menentukan hal berikut di definition bidang saat Anda mengirim UpdateFlowpermintaan CreateFlowatau:

Sebuah FlowNodeobjek kondisi dalam nodes array. Format umumnya adalah sebagai berikut (perhatikan bahwa node kondisi tidak memilikioutputs):


{
    "name": "string",
    "type": "Condition",
    "inputs": [
        {
            "name": "string",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        }
    ],
    "configuration": {
        "condition": {
            "conditions": [
                {
                    "name": "string",
                    "expression": "string"
                },
                ...
            ]
        }
    }
}

Untuk setiap input ke node kondisi, FlowConnectionobjek dalam connections array. Sertakan FlowDataConnectionConfigurationobjek di configuration bidang FlowConnection objek. Format umum FlowConnection objek adalah sebagai berikut:


{
    "name": "string",
    "source": "string",
    "target": "string",
    "type": "Data",
    "configuration": {
        "data": {
            "sourceOutput": "string",
            "expression": "string"
        }
    }
}

Untuk setiap kondisi (termasuk kondisi default) di node kondisi, FlowConnectionobjek dalam connections array. Sertakan FlowConditionalConnectionConfigurationobjek di configuration bidang FlowConnection objek. Format umum FlowConnectionobjek adalah sebagai berikut:
```
{
    "name": "string",
    "source": "string",
    "target": "string",
    "type": "Data",
    "configuration": {
        "condition": "default",
        "condition": "string"
        ...
    }
}
```
Gunakan operator relasional dan logis untuk menentukan condition yang menghubungkan source node kondisi ini ke target node hilir. Untuk kondisi default, tentukan kondisi sebagaidefault.

Sebuah node iterator mengambil array dan iteratif mengembalikan item-itemnya sebagai output ke node hilir. Masukan ke node iterator diproses satu per satu dan tidak secara paralel satu sama lain. Node keluaran aliran mengembalikan hasil akhir untuk setiap input dalam respons yang berbeda. Anda juga dapat menggunakan node kolektor hilir dari node iterator untuk mengumpulkan respons berulang dan mengembalikannya sebagai array, selain ukuran array.

Berikut ini menunjukkan struktur umum dari sebuah FlowNodeobjek iterator:


{
    "name": "string",
    "type": "Iterator",
    "inputs": [
        {
            "name": "array",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "arrayItem",
            "type": "String | Number | Boolean | Object | Array",
        },
        {
            "name": "arraySize",
            "type": "Number"
        }
    ],
    "configuration": {
        "iterator": CONTEXT-DEPENDENT
    }
}

Sebuah node kolektor mengambil input iterasi, selain ukuran array akan, dan mengembalikannya sebagai array. Anda dapat menggunakan node kolektor hilir dari node iterator untuk mengumpulkan item iterasi setelah mengirimnya melalui beberapa node.

Berikut ini menunjukkan struktur umum FlowNodeobjek kolektor:


{
    "name": "string",
    "type": "Collector",
    "inputs": [
        {
            "name": "arrayItem",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        {
            "name": "arraySize",
            "type": "Number"
        }
    ],
    "outputs": [
        {
            "name": "collectedArray",
            "type": "Array"
        },
    ],
    "configuration": {
        "collector": CONTEXT-DEPENDENT
    }
}

Node untuk menangani data dalam aliran prompt

Gunakan tipe node berikut untuk menangani data dalam alur prompt Anda:

Sebuah node prompt mendefinisikan prompt untuk digunakan dalam aliran. Anda dapat menggunakan prompt dari manajemen Prompt atau menentukan satu inline di node. Untuk informasi selengkapnya, lihat Buat dan simpan petunjuk yang dapat digunakan kembali dengan manajemen Prompt di Amazon Bedrock.

Sebagai contoh, lihat Memulai dengan contoh alur prompt.

Masukan ke node prompt adalah nilai untuk mengisi variabel. Outputnya adalah respons yang dihasilkan dari model.

Berikut ini menunjukkan struktur umum dari FlowNodeobjek prompt:


{
    "name": "string",
    "type": "prompt",
    "inputs": [
        {
            "name": "content",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        ...
    ],
    "outputs": [
        {
            "name": "modelCompletion",
            "type": "String"
        }
    ],
    "configuration": {
        "prompt": {
            "sourceConfiguration": PromptFlowNodeSourceConfiguration object (see below)
        }
    }
}

PromptFlowNodeSourceConfigurationObjek tergantung pada apakah Anda menggunakan prompt dari manajemen Prompt atau jika Anda mendefinisikannya sebaris:

Jika Anda menggunakan prompt dari manajemen Prompt, objek harus dalam struktur umum berikut:
```
{
    "resource": {
        "promptArn": "string"
    }
}
```

Jika Anda menentukan prompt sebaris, ikuti panduan untuk mendefinisikan varian di API tab Buat prompt menggunakan manajemen Prompt (perhatikan bahwa tidak ada name bidang dalam objek ini, bagaimanapun). Objek yang Anda gunakan harus dalam struktur umum berikut:


{
    "inline": {
        "modelId": "string",
        "templateType": "TEXT",
        "templateConfiguration": {
            "text": {
                "text": "string",
                "inputVariables": [
                    {
                        "name": "string"
                    },
                    ...
                ]
            }
        },
        "inferenceConfiguration": {
            "text": {
                "maxTokens": int,
                "stopSequences": ["string", ...],
                "temperature": float,
                "topK": int,
                "topP": float
            }
        }
    }
}

Node agen memungkinkan Anda mengirim prompt ke agen, yang mengatur antara FMs dan sumber daya terkait untuk mengidentifikasi dan melakukan tindakan bagi pengguna akhir. Untuk informasi selengkapnya, lihat Mengotomatiskan tugas dalam aplikasi Anda menggunakan agen percakapan.

Dalam konfigurasi, tentukan Amazon Resource Name (ARN) alias agen yang akan digunakan. Input ke dalam node adalah prompt untuk agen dan atribut prompt atau sesi terkait. Node mengembalikan respon agen sebagai output.

catatan

Saat ini, agen tidak mendukung pemanggilan multi-putaran. Anda tidak dapat mengonfigurasi pengembalian kontrol untuk agen dalam aliran.

Berikut ini menunjukkan struktur umum FlowNodeobjek agen:


{
    "name": "string",
    "type": "Agent",
    "inputs": [
       {
            "name": "agentInputText"
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        {
            "name": "promptAttributes"
            "type": "Object",
            "expression": "string"
        },
        {
            "name": "sessionAttributes"
            "type": "Object",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "agentResponse",
            "type": "String"
        }
    ],
    "configuration": {
        "agent": {
            "agentAliasArn": "string"
        }
    }
}

Node basis pengetahuan memungkinkan Anda mengirim kueri ke basis pengetahuan. Untuk informasi selengkapnya, lihat Mengambil data dan menghasilkan respons AI dengan basis pengetahuan.

Dalam konfigurasi, berikan ID basis pengetahuan dan ID model untuk digunakan jika Anda ingin menghasilkan respons berdasarkan hasil yang diambil. Untuk mengembalikan hasil yang diambil sebagai array, hilangkan ID model. Input ke dalam node adalah kueri ke basis pengetahuan. Outputnya adalah respons model, sebagai string, atau array dari hasil yang diambil.

Berikut ini menunjukkan struktur umum FlowNodeobjek basis pengetahuan:


{
    "name": "string",
    "type": "KnowledgeBase",
    "inputs": [
       {
            "name": "retrievalQuery",
            "type": "String",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "retrievalResults",
            "type": "Array | String"
        }
    ],
    "configuration": {
        "knowledgeBase": {
            "knowledgeBaseId": "string",
            "modelId": "string"
        }
    }
}

Node penyimpanan S3 memungkinkan Anda menyimpan data dalam alur ke lokasi Amazon S3. Dalam konfigurasi, Anda menentukan bucket S3 yang akan digunakan untuk penyimpanan data. Input ke dalam node adalah konten untuk menyimpan dan kunci objek. Node mengembalikan URI lokasi S3 sebagai outputnya.

Berikut ini menunjukkan struktur umum FlowNodeobjek penyimpanan S3:


{
    "name": "string",
    "type": "Storage",
    "inputs": [
        {
            "name": "content",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        {
            "name": "objectKey",
            "type": "String",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "s3Uri",
            "type": "String"
        }
    ],
    "configuration": {
        "retrieval": {
            "serviceConfiguration": {
                "s3": {
                    "bucketName": "string"
                }
            }
        }
    }
}

Node pengambilan S3 memungkinkan Anda mengambil data dari lokasi Amazon S3 untuk diperkenalkan ke alur. Dalam konfigurasi, Anda menentukan bucket S3 untuk mengambil data. Masukan ke dalam node adalah kunci objek. Node mengembalikan konten di lokasi S3 sebagai output.

catatan

Saat ini, data di lokasi S3 harus berupa string yang dikodekan UTF -8.

Berikut ini menunjukkan struktur umum dari objek pengambilan FlowNodeS3:


{
    "name": "string",
    "type": "Retrieval",
    "inputs": [
        {
            "name": "objectKey",
            "type": "String",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "s3Content",
            "type": "String"
        }
    ],
    "configuration": {
        "retrieval": {
            "serviceConfiguration": {
                "s3": {
                    "bucketName": "string"
                }
            }
        }
    }
}

Node fungsi Lambda memungkinkan Anda memanggil fungsi Lambda di mana Anda dapat menentukan kode untuk menjalankan logika bisnis. Saat Anda menyertakan simpul Lambda dalam alur prompt, Amazon Bedrock mengirimkan peristiwa masukan ke fungsi Lambda yang Anda tentukan.

Dalam konfigurasi, tentukan Nama Sumber Daya Amazon (ARN) dari fungsi Lambda. Tentukan input untuk dikirim dalam acara input Lambda. Anda dapat menulis kode berdasarkan masukan ini dan menentukan apa fungsi kembali. Respon fungsi dikembalikan dalam output.

Berikut ini menunjukkan struktur umum FlowNodeobjek fungsi Λ:


{
    "name": "string",
    "type": "LambdaFunction",
    "inputs": [
       {
            "name": "string",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        ...
    ],
    "outputs": [
        {
            "name": "functionResponse",
            "type": "String | Number | Boolean | Object | Array"
        }
    ],
    "configuration": {
        "lambdaFunction": {
            "lambdaArn": "string"
        }
    }
}

Acara input Lambda untuk alur prompt

Peristiwa masukan yang dikirim ke fungsi Lambda di simpul Lambda adalah dari format berikut:


{
   "messageVersion": "1.0",
   "flow": {
        "flowArn": "string",
        "flowAliasArn": "string"
   },
   "node": {
        "name": "string",
        "nodeInputs": [
            {
               "name": "string",
               "type": "String | Number | Boolean | Object | Array",
               "expression": "string",
               "value": ...
            },
            ...
        ]
   }
}

Bidang untuk setiap input cocok dengan bidang yang Anda tentukan saat mendefinisikan simpul Lambda, sedangkan nilai bidang value diisi dengan seluruh input ke dalam node setelah diselesaikan oleh ekspresi. Misalnya, jika seluruh input ke dalam node adalah [1, 2, 3] dan ekspresinya$.data[1], nilai yang dikirim dalam peristiwa input ke fungsi Lambda akan menjadi. 2

Untuk informasi lebih lanjut tentang peristiwa di Lambda, lihat Konsep Lambda di AWS Lambda Panduan Pengembang.

Respons Lambda untuk aliran cepat

Saat Anda menulis fungsi Lambda, Anda menentukan respons yang dikembalikan olehnya. Respons ini dikembalikan ke aliran prompt Anda sebagai output dari node Lambda.

catatan

Node Lex bergantung pada layanan Amazon Lex, yang mungkin menyimpan dan menggunakan konten pelanggan untuk pengembangan dan peningkatan berkelanjutan lainnya AWS layanan. Sebagai AWS pelanggan, Anda dapat memilih untuk tidak menyimpan konten Anda atau digunakan untuk peningkatan layanan. Untuk mempelajari cara menerapkan kebijakan opt-out untuk Amazon Lex, lihat kebijakan opt-out layanan AI.

Node Lex memungkinkan Anda memanggil bot Amazon Lex untuk memproses ucapan menggunakan pemrosesan bahasa alami dan untuk mengidentifikasi maksud, berdasarkan definisi bot. Untuk informasi selengkapnya, lihat Panduan Pengembang Amazon Lex.

Dalam konfigurasi, tentukan Nama Sumber Daya Amazon (ARN) alias bot yang akan digunakan dan lokal yang akan digunakan. Masukan ke dalam node adalah ucapan dan atribut permintaan atau atribut sesi yang menyertainya. Node mengembalikan maksud diidentifikasi sebagai output.

catatan

Saat ini, node Lex tidak mendukung percakapan multi-putaran. Satu Lex node hanya dapat memproses satu ucapan.

Berikut ini menunjukkan struktur umum FlowNodeobjek Lex:


{
    "name": "string",
    "type": "Lex",
    "inputs": [
       {
            "name": "inputText",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        {
            "name": "requestAttributes",
            "type": "Object",
            "expression": "string"
        },
        {
            "name": "sessionAttributes",
            "type": "Object",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "predictedIntent",
            "type": "String"
        }
    ],
    "configuration": {
        "lex": {
            "botAliasArn": "string",
            "localeId": "string"
        }
    }
}

Tabel ringkasan untuk tipe simpul

Tabel berikut merangkum input dan output yang diperbolehkan untuk setiap jenis node. Perhatikan hal berikut:

Jika nama ditandai sebagai Any, Anda dapat memberikan string apa pun sebagai nama. Jika tidak, Anda harus menggunakan nilai yang ditentukan dalam tabel.
Jika tipe ditandai sebagai Any, Anda dapat menentukan salah satu tipe data berikut: String, Number, Boolean, Object, Array. Jika tidak, Anda harus menggunakan jenis yang ditentukan dalam tabel.
Saat ini, hanya node fungsi Condition, Prompt, dan Lambda yang mengizinkan beberapa input yang dapat Anda tentukan sendiri.

Jenis simpul logika
	Info masukan			Info keluaran
Jenis simpul	Input	Nama	Tipe	Output	Nama	Tipe
Masukan	N/A	N/A	N/A	`content`Bidang dalam `InvokeFlow` permintaan.	`document`	Setiap
Keluaran	Data untuk dikembalikan dalam `InvokeFlow` respons.	`document`	Setiap	N/A	N/A	N/A
Kondisi	Data untuk dikirim berdasarkan suatu kondisi. (beberapa input diizinkan)	Setiap	Setiap	Data untuk dikirim berdasarkan suatu kondisi. (tentukan kondisi untuk jalur yang berbeda)	Setiap	Setiap
Iterator	Sebuah array yang Anda ingin menerapkan node berikut (s) iteratif untuk setiap anggota.	`array`	Array	Setiap item dari array	`arrayItem`	Setiap
Iterator		`array`	Array	Ukuran array input	`arraySize`	Jumlah
Kolektor	Iterasi yang ingin Anda konsolidasikan ke dalam array.	`arrayItem`	Setiap	Sebuah array dengan semua output dari node sebelumnya ditambahkan.	`collectedArray`	Array
Kolektor	Ukuran array output	`arraySize`	Jumlah		`collectedArray`	Array

Jenis node pemrosesan data
	Info masukan			Info keluaran
Jenis simpul	Input	Nama	Tipe	Output	Nama	Tipe
Prompt	Nilai untuk mengisi variabel dalam prompt. (beberapa input diizinkan)	`${variable-name}`	Setiap	Respons dikembalikan oleh model.	`modelCompletion`	String
Penyimpanan S3	Data untuk disimpan dalam ember S3.	`content`	Setiap	Lokasi S3. URI	`s3Uri`	String
Penyimpanan S3	Kunci objek yang digunakan untuk objek S3.	`objectKey`	String	Lokasi S3. URI	`s3Uri`	String
Pengambilan S3	Kunci objek untuk objek S3	`objectKey`	String	Data untuk diambil dari bucket S3.	`s3Content`	Setiap
Agen	Prompt untuk mengirim ke agen.	`agentInputText`	String	Tanggapan kembali dari agen.	`agentResponse`	String
	Atribut prompt apa pun untuk dikirim bersama prompt.	`promptAttributes`	Objek
	Atribut sesi apa pun untuk dikirim bersama prompt.	`sessionAttributes`	Objek
Basis pengetahuan	Kueri untuk dikirim ke basis pengetahuan.	`retrievalQuery`	String	Hasil yang dikembalikan atau respons yang dihasilkan dari basis pengetahuan.	`retrievalResults`	Array
Fungsi Lambda	Data untuk dikirim ke fungsi. (beberapa input diizinkan)	Setiap	Respon kembali dari fungsi.	`functionResponse`	Setiap
Lex	Ucapan untuk dikirim ke bot.	`inputText`	String	Maksud yang diprediksi bot untuk ucapan tersebut.	`predictedIntent`	String
	Atribut permintaan apa pun untuk dikirim bersama ucapan.	`requestAttributes`	Objek
	Atribut sesi apa pun untuk dikirim bersama ucapan.	`sessionAttributes`	Objek

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

Tentukan input dengan ekspresi

Contoh arus prompt