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. Di API, gunakan type bidang dan yang sesuai FlowNodeConfigurationdi configuration bidang.
Input — Berikan nama dan tipe data untuk setiap 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. Di bidang ekspresi, tentukan bagian dari seluruh input yang akan digunakan sebagai input individu. Untuk informasi selengkapnya, lihat Gunakan ekspresi untuk mendefinisikan input dengan mengekstrak bagian yang relevan dari seluruh input.
Output — Berikan nama dan tipe data untuk setiap 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.
Konfigurasi — Di konsol, Anda menentukan bidang khusus node di bagian atas node. Di API, 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 FlowNodeobjek masukan di API:


{
    "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. Di API, output dikembalikan flowOutputEvent di content bidang InvokeFlow respons. 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.

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 adalah 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)

Di API, Anda menentukan hal berikut di definition bidang saat mengirim CreateFlowatau UpdateFlowmeminta:

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": {
        "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. 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 Manajemen cepat di Amazon Bedrock.

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 menentukan varian di tab API Buat prompt menggunakan manajemen Prompt (perhatikan bahwa tidak ada name bidang dalam objek ini). 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 MM dan sumber daya terkait untuk mengidentifikasi dan melakukan tindakan bagi pengguna akhir. Untuk informasi selengkapnya, lihat Agen untuk Amazon Bedrock.

Dalam konfigurasi, tentukan Nama Sumber Daya Amazon (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 Basis pengetahuan untuk Amazon Bedrock.

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 dari 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": "storageS3Uri",
            "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": "retrievalObjectKey"
            "type": "String",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "retrievalNodeContent",
            "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. Lihat informasi selengkapnya di Panduan Developer AWS Lambda.

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 sebagai 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"
        }
    }
}

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	URI dari lokasi S3.	`storageS3Uri`	String
Penyimpanan S3	Kunci objek yang akan digunakan untuk objek S3.	`objectKey`	String	URI dari lokasi S3.	`storageS3Uri`	String
Pengambilan S3	Kunci objek untuk objek S3	`retrievalObjectKey`	String	Data untuk diambil dari bucket S3.	`retrievalNodeContent`	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 dikembalikan 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 bersamaan dengan 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