Jenis node dalam aliran cepat - Amazon Bedrock
Node untuk mengontrol logika aliran cepatNode untuk menangani data dalam aliran promptTabel ringkasan untuk tipe simpul

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

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:

  • 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

  1. Tambahkan input sebanyak yang Anda butuhkan untuk mengevaluasi kondisi yang ingin Anda tambahkan.

  2. Masukkan nama untuk setiap input, tentukan jenis yang diharapkan, dan tulis ekspresi untuk mengekstrak bagian yang relevan dari seluruh input.

  3. Connect setiap input ke output yang relevan dari node upstream.

  4. Tambahkan kondisi sebanyak yang Anda butuhkan.

  5. 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:

  1. 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"
                },
                ...
            ]
        }
    }
}

  2. 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"
        }
    }
}

  3. 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 contentBidang 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
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
Ukuran array output arraySize Jumlah
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
Kunci objek yang digunakan untuk objek S3. objectKey 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