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

# Jenis node untuk alur Anda
<a name="flows-nodes"></a>

Amazon Bedrock Flows menyediakan tipe node berikut untuk membangun alur Anda. Ketika Anda mengkonfigurasi node, Anda memberikan 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 [FlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNodeConfiguration.html)di `configuration` bidang.
+ 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, lihat[Jenis simpul logika](#flows-nodes-logic-table).
  + Ekspresi — Tentukan bagian dari seluruh input untuk digunakan sebagai input individu. Untuk informasi selengkapnya, lihat [Gunakan ekspresi untuk menentukan input dengan mengekstrak bagian yang relevan dari seluruh input di Amazon Bedrock FlowsTentukan input dengan ekspresi](flows-expressions.md).
  + 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, lihat[Jenis simpul logika](#flows-nodes-logic-table).
  + 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. Di API, gunakan yang sesuai [FlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNodeConfiguration.html)dan 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
<a name="flows-nodes-logic"></a>

Gunakan tipe node berikut untuk mengontrol logika aliran Anda.

### Node masukan aliran
<a name="flows-nodes-input"></a>

Setiap aliran 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 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objek masukan di API:

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

### Node keluaran aliran
<a name="flows-nodes-output"></a>

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. Sebuah aliran 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 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objek output:

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

### Kondisi simpul
<a name="flows-nodes-condition"></a>

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](flows-ex-condition.md).

**Untuk menentukan node kondisi**

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

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

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

1. Tambahkan kondisi sebanyak yang Anda butuhkan.

1. Untuk setiap kondisi:

   1. Masukkan nama untuk kondisi tersebut.

   1. 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.

   1. Connect setiap kondisi ke node hilir yang ingin Anda kirimi data jika kondisi tersebut terpenuhi.

#### Ekspresi kondisi
<a name="flows-nodes-condition-expr"></a>

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 | Bilangan | A > B | Jika A lebih besar dari B | 
| >= | Lebih besar dari atau sama dengan | Bilangan | A >= B | Jika A lebih besar dari atau sama dengan B | 
| < | Kurang dari | Bilangan | A < B | Jika A kurang dari B | 
| <= | Kurang dari atau sama dengan | Bilangan | 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 dipanggil`expenses`, 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: [See the AWS documentation website for more details](http://docs.aws.amazon.com/id_id/bedrock/latest/userguide/flows-nodes.html) | 
| atau | Setidaknya satu ekspresi adalah benar | (SEBUAH\! = 2) atau (B > C) | Jika salah satu ekspresi benar: [See the AWS documentation website for more details](http://docs.aws.amazon.com/id_id/bedrock/latest/userguide/flows-nodes.html) | 
| 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 [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html)atau [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html)meminta:

1. Sebuah [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objek kondisi dalam `nodes` array. Format umumnya adalah sebagai berikut (perhatikan bahwa node kondisi tidak memiliki`outputs`):

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

1. Untuk setiap input ke node kondisi, [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)objek dalam `connections` array. Sertakan [FlowDataConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowDataConnectionConfiguration.html)objek 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"
           }
       }
   }
   ```

1. Untuk setiap kondisi (termasuk kondisi default) di node kondisi, [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)objek dalam `connections` array. Sertakan [FlowConditionalConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConditionalConnectionConfiguration.html)objek di `configuration` bidang `FlowConnection` objek. Format umum [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)objek adalah sebagai berikut:

   ```
   {
       "name": "string",
       "source": "string",
       "target": "string",
       "type": "Conditional",
       "configuration": {
           "conditional": {
               "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 sebagai**default**.

### Simpul iterator
<a name="flows-nodes-iterator"></a>

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 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 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objek iterator:

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

### Simpul kolektor
<a name="flows-nodes-collector"></a>

Sebuah node kolektor mengambil input iterasi, selain ukuran array yang 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 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objek 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
    }
}
```

### DoWhile simpul lingkaran
<a name="flows-nodes-dowhile"></a>

Sebuah node DoWhile loop mengeksekusi urutan node berulang kali sementara kondisi tertentu tetap benar. Loop mengeksekusi setidaknya sekali sebelum mengevaluasi kondisi, membuatnya ideal untuk skenario di mana Anda perlu melakukan tindakan dan kemudian memeriksa apakah itu harus diulang berdasarkan hasil.

Node DoWhile loop mengambil data input dan meneruskannya melalui badan loop. Setelah setiap iterasi, kondisi dievaluasi untuk menentukan apakah akan melanjutkan perulangan atau keluar. Loop berlanjut selama kondisi mengevaluasi ke true, atau tidak `maxIterations` terlampaui.

Berikut ini menunjukkan struktur umum [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objek DoWhile loop:

```
{
    "name": "string",
    "type": "DoWhile",
    "inputs": [
        {
            "name": "loopInput",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "loopOutput",
            "type": "String | Number | Boolean | Object | Array"
        },
        {
            "name": "iterationCount",
            "type": "Number"
        }
    ],
    "configuration": {
        "doWhile": {
            "condition": "string",
            "maxIterations": "number"
        }
    }
}
```

Dalam konfigurasi:
+ `condition`— Ekspresi boolean yang menentukan apakah akan melanjutkan perulangan. Gunakan operator relasional dan logis yang sama dengan node kondisi. Kondisi ini dievaluasi setelah setiap iterasi.
+ `maxIterations`— Jumlah maksimum iterasi. Default-nya adalah 10. Anda harus menentukan angka positif. Parameter ini membantu Anda menghindari loop tak terbatas.

**catatan**  
`maxIterations`Parameter memiliki nilai default 10 dan hanya menerima angka positif. Loop keluar ketika salah satu kondisi menjadi salah atau jumlah maksimum iterasi tercapai.

## Node untuk menangani data dalam aliran
<a name="flows-nodes-data"></a>

Gunakan tipe node berikut untuk menangani data dalam alur Anda:

### Simpul cepat
<a name="flows-nodes-prompt"></a>

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](prompt-management.md).

Sebagai contoh, lihat [Coba contoh aliran](flows-ex.md).

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

Berikut ini menunjukkan struktur umum dari [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objek 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](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PromptFlowNodeSourceConfiguration.html) object (see below),
            "guardrailConfiguration": {
                "guardrailIdentifier": "string",
                "guardrailVersion": "string"
            }
        }
    }
}
```

[PromptFlowNodeSourceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PromptFlowNodeSourceConfiguration.html)Objek 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](prompt-management-create.md) (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,
                  "topP": float
              }
          },
          "additionalModelRequestFields": {
              "key": "value",
              ...
          }
      }
  }
  ```

Untuk menerapkan pagar pembatas dari Amazon Bedrock Guardrails ke prompt Anda atau respons yang dihasilkan darinya, sertakan `guardrailConfiguration` bidang dan tentukan ID atau ARN pagar pembatas di `guardrailIdentifier` bidang dan versi pagar pembatas di lapangan. `guardrailVersion`

### Node agen
<a name="flows-nodes-agent"></a>

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 [Mengotomatiskan tugas dalam aplikasi Anda menggunakan agen AI](agents.md).

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](agents-session-state.md) terkait. Node mengembalikan respon agen sebagai output.

Node Agen dapat mendukung pemanggilan multi-putaran, memungkinkan percakapan interaktif antara pengguna dan Agen selama eksekusi flow. Ketika node Agen memerlukan informasi atau klarifikasi tambahan, node tersebut dapat menjeda eksekusi aliran dan meminta masukan spesifik dari pengguna. Setelah pengguna memberikan informasi yang diminta, simpul Agen melanjutkan pemrosesannya dengan input baru. Ini berlanjut sampai node agen memiliki semua informasi yang diperlukan untuk menyelesaikan pelaksanaannya

Berikut ini menunjukkan struktur umum [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objek 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 dasar pengetahuan
<a name="flows-nodes-kb"></a>

Node basis pengetahuan memungkinkan Anda mengirim kueri ke basis pengetahuan dari Amazon Bedrock Knowledge Bases. Untuk informasi selengkapnya, lihat [Ambil data dan hasilkan respons AI dengan Pangkalan Pengetahuan Amazon Bedrock](knowledge-base.md).

Dalam konfigurasi, berikan `knowledgeBaseId` minimal. Anda dapat secara opsional menyertakan bidang-bidang berikut tergantung pada kasus penggunaan Anda:
+ `modelId`— Sertakan [ID model](models-supported.md) untuk digunakan jika Anda ingin menghasilkan respons berdasarkan hasil yang diambil. Untuk mengembalikan hasil yang diambil sebagai array, hilangkan ID model.
+ `guardrailConfiguration`— Sertakan ID atau ARN pagar pembatas, yang didefinisikan dalam Pagar Batuan Dasar Amazon di `guardrailIdentifier` lapangan dan versi pagar pembatas di lapangan. `guardrailVersion`
**catatan**  
Guardrails hanya dapat diterapkan saat menggunakan `RetrieveAndGenerate` dalam node basis pengetahuan.

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 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objek basis pengetahuan:

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

### Simpul penyimpanan S3
<a name="flows-nodes-storage"></a>

Node penyimpanan S3 memungkinkan Anda menyimpan data dalam alur ke bucket 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](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html). Node mengembalikan URI dari lokasi S3 sebagai outputnya.

Berikut ini menunjukkan struktur umum [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objek 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
<a name="flows-nodes-retrieval"></a>

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](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html). Node mengembalikan konten di lokasi S3 sebagai output.

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

Berikut ini menunjukkan struktur umum dari objek pengambilan [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)S3:

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

### Simpul fungsi Lambda
<a name="flows-nodes-lambda"></a>

Node fungsi Lambda memungkinkan Anda memanggil fungsi Lambda di mana Anda dapat menentukan kode untuk menjalankan logika bisnis. Saat Anda menyertakan node Lambda dalam alur, 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 objek fungsi [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)Lambda:

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

#### Peristiwa masukan Lambda untuk aliran
<a name="flows-nodes-lambda-input"></a>

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",
        "inputs": [
            {
               "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 selengkapnya tentang peristiwa di Lambda, lihat [Konsep Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-event) di Panduan Pengembang.AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/)

#### Respons Lambda untuk aliran
<a name="flows-nodes-lambda-response"></a>

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

### Node kode sebaris
<a name="flows-nodes-inline-code"></a>

Node kode inline memungkinkan Anda menulis dan mengeksekusi kode secara langsung di alur Anda, memungkinkan transformasi data, logika kustom, dan integrasi tanpa menggunakan fungsi Lambda eksternal. Saat Anda menyertakan node kode inline dalam alur Anda, Amazon Bedrock mengeksekusi kode Anda di lingkungan terisolasi dan AWS terkelola yang tidak dibagikan dengan siapa pun dan tidak memiliki akses internet.

**catatan**  
Node kode sebaris dalam rilis pratinjau untuk Amazon Bedrock dan dapat berubah sewaktu-waktu.

Dalam konfigurasi node, tentukan kode yang akan dijalankan bersama dengan bahasa pemrograman (saat `Python_3` ini satu-satunya pilihan). Tentukan input yang dapat diakses kode Anda sebagai variabel. Hasil dari baris terakhir yang dieksekusi dalam kode Anda dikembalikan sebagai output node.

Contoh berikut menunjukkan struktur umum dari [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objek kode inline:

```
{
    "name": "string",
    "type": "InlineCode",
    "inputs": [{
            "name": "string",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        ...
    ],
    "outputs": [{
        "name": "response",
        "type": "String | Number | Boolean | Object | Array"
    }],
    "configuration": {
        "inlineCode": {
            "code": "string",
            "language": "Python_3"
        }
    }
}
```

#### Pertimbangan saat menggunakan node kode inline
<a name="flows-nodes-inline-code-usage"></a>

Saat menggunakan node kode inline dalam alur Anda, pertimbangkan hal berikut:

**penting**  
Kami menyarankan Anda menguji kode Anda sebelum menambahkannya ke node kode inline.
+ Node kode inline tidak didukung dalam eksekusi aliran [asinkron](flows-create-async.md).
+ Saat ini, satu-satunya bahasa pemrograman yang didukung oleh node kode inline adalah Python 3.12 (. `Python_3)`
+ Kode inline bertindak seperti sesi Python interaktif. Hanya hasil dari baris terakhir yang dieksekusi ditangkap dan dikembalikan sebagai output node.
+ Output konsol Python (output seperti dari `print` fungsi) tidak ditangkap.
+ Input untuk node kode inline Anda tersedia sebagai variabel Python dalam kode Anda. Gunakan nama yang tepat dari input node untuk mereferensikannya.
+ Konfigurasikan jenis input dan output dengan benar untuk menghindari kesalahan runtime. Anda dapat mengkonfigurasi hingga lima input node.
+ Anda dapat memiliki hingga lima node kode inline per aliran.
+ Anda dapat memiliki maksimum 25 node kode inline yang berjalan per Akun AWS.
+ Kode Anda tidak boleh melebihi 5 MB.

#### Input simpul kode sebaris
<a name="flows-nodes-inline-code-input"></a>

Masukan yang Anda tentukan untuk node kode inline tersedia sebagai variabel Python dalam kode Anda. Misalnya, jika Anda menentukan input bernama`userData`, Anda dapat mengaksesnya langsung dalam kode Anda sebagai`userData`.

Nilai setiap input diisi berdasarkan ekspresi yang Anda tentukan. Misalnya, jika input ke node adalah `{"name": "John", "age": 30}` dan ekspresinya`$.name`, nilai variabel input akan menjadi`"John"`.

#### Keluaran simpul kode sebaris
<a name="flows-nodes-inline-code-output"></a>

Hasil dari baris terakhir yang dieksekusi dalam kode Anda dikembalikan sebagai output dari node kode inline. Output ini tersedia untuk node berikutnya dalam aliran Anda.

Misalnya, kode berikut mengembalikan kamus sebagai output node:

```
# Process input data
result = {"processed": True, "data": userData}

# The last line's result is returned as the node output
result
```

### Lex simpul
<a name="flows-nodes-lex"></a>

**catatan**  
Node Lex bergantung pada layanan Amazon Lex, yang mungkin menyimpan dan menggunakan konten pelanggan untuk pengembangan dan peningkatan berkelanjutan AWS layanan lainnya. 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](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html).

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](https://docs.aws.amazon.com/lex/latest/dg/).

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](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-request-attribs.html) atau atribut sesi yang menyertainya.](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-request-attribs.html) 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 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objek 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
<a name="flows-nodes-summary-table"></a>

Tabel berikut merangkum input dan output yang diperbolehkan untuk setiap jenis node. Perhatikan hal-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.
+ Anda dapat menentukan beberapa input untuk **kondisi**, **Prompt**, fungsi **Lambda**, **dan node kode Inline**.


**Jenis simpul logika**  
<a name="flows-nodes-logic-table"></a>
<table>
<thead>
  <tr><th></th><th colspan="3">Info masukan</th><th colspan="3">Info keluaran</th></tr>
  <tr><th>Tipe simpul</th><th>Input</th><th>Nama</th><th>Tipe</th><th>Output</th><th>Nama</th><th>Tipe</th></tr>
</thead>
<tbody>
  <tr><td>Masukan</td><td>N/A</td><td>N/A</td><td>N/A</td><td>contentBidang dalam InvokeFlow permintaan.</td><td>document</td><td>Setiap</td></tr>
  <tr><td>Keluaran</td><td>Data untuk dikembalikan dalam InvokeFlow respons.</td><td>document</td><td>Setiap</td><td>N/A</td><td>N/A</td><td>N/A</td></tr>
  <tr><td>Kondisi</td><td>Data untuk dikirim berdasarkan suatu kondisi.<br />(beberapa input diizinkan)</td><td>Setiap</td><td>Setiap</td><td>Data untuk dikirim berdasarkan suatu kondisi.<br />(tentukan kondisi untuk jalur yang berbeda)</td><td>Setiap</td><td>Setiap</td></tr>
  <tr><td rowspan="2">Iterator</td><td rowspan="2">Sebuah array yang Anda ingin menerapkan node berikut (s) iteratif untuk setiap anggota.</td><td rowspan="2">array</td><td rowspan="2">Array</td><td>Setiap item dari array</td><td>arrayItem</td><td>Setiap</td></tr>
  <tr><td>Ukuran array input</td><td>arraySize</td><td>Bilangan</td></tr>
  <tr><td rowspan="2">Kolektor</td><td>Iterasi yang ingin Anda konsolidasikan ke dalam array.</td><td>arrayItem</td><td>Setiap</td><td rowspan="2">Sebuah array dengan semua output dari node sebelumnya ditambahkan.</td><td rowspan="2">collectedArray</td><td rowspan="2">Array</td></tr>
  <tr><td>Ukuran array output</td><td>arraySize</td><td>Bilangan</td></tr>
  <tr><td rowspan="2">DoWhile lingkaran</td><td>Data untuk diproses dalam loop.</td><td>loopInput</td><td>Setiap</td><td>Output akhir dari loop setelah semua iterasi.</td><td>loopOutput</td><td>Setiap</td></tr>
  <tr><td>Jumlah iterasi yang dilakukan.</td><td>iterationCount</td><td>Bilangan</td><td></td><td></td><td></td></tr>
</tbody>
</table>



**Jenis node pemrosesan data**  
<a name="flows-nodes-data-table"></a>
<table>
<thead>
  <tr><th></th><th colspan="3">Info masukan</th><th colspan="3">Info keluaran</th></tr>
  <tr><th>Tipe simpul</th><th>Input</th><th>Nama</th><th>Tipe</th><th>Output</th><th>Nama</th><th>Tipe</th></tr>
</thead>
<tbody>
  <tr><td>Prompt</td><td>Nilai untuk mengisi variabel dalam prompt (beberapa input diperbolehkan).</td><td>{{${variable-name}}}</td><td>Setiap</td><td>Respons dikembalikan oleh model.</td><td>modelCompletion</td><td>String</td></tr>
  <tr><td rowspan="2">Penyimpanan S3</td><td>Data untuk disimpan dalam ember S3.</td><td>content</td><td>Setiap</td><td rowspan="2">URI dari lokasi S3.</td><td rowspan="2">s3Uri</td><td rowspan="2">String</td></tr>
  <tr><td>[Kunci objek](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html) yang digunakan untuk objek S3.</td><td>objectKey</td><td>String</td></tr>
  <tr><td>Pengambilan S3</td><td>[Kunci objek](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html) untuk objek S3.</td><td>objectKey</td><td>String</td><td>Data untuk diambil dari bucket S3.</td><td>s3Content</td><td>Setiap</td></tr>
  <tr><td rowspan="3">Agen</td><td>Prompt untuk mengirim ke agen.</td><td>agentInputText</td><td>String</td><td rowspan="3">Tanggapan kembali dari agen.</td><td rowspan="3">agentResponse</td><td rowspan="3">String</td></tr>
  <tr><td>[Atribut prompt](agents-session-state.md) apa pun untuk dikirim bersama prompt.</td><td>promptAttributes</td><td>Objek</td></tr>
  <tr><td>[Atribut sesi](agents-session-state.md) apa pun untuk dikirim bersama prompt.</td><td>sessionAttributes</td><td>Objek</td></tr>
  <tr><td>Basis pengetahuan</td><td>Kueri untuk dikirim ke basis pengetahuan.</td><td>retrievalQuery</td><td>String</td><td>Hasil yang dikembalikan atau respons yang dihasilkan dari basis pengetahuan.</td><td>retrievalResults</td><td>Array</td></tr>
  <tr><td>Fungsi Lambda</td><td>Data untuk dikirim ke fungsi (beberapa input diperbolehkan).</td><td>Setiap</td><td>Setiap</td><td>Respon dikembalikan dari fungsi.</td><td>functionResponse</td><td>Setiap</td></tr>
  <tr><td>Node kode sebaris</td><td>Variabel untuk kode Anda untuk mengeksekusi (beberapa input diperbolehkan).</td><td>Setiap</td><td>Setiap</td><td>Baris terakhir dieksekusi dalam kode Anda.</td><td>response</td><td>Setiap</td></tr>
  <tr><td rowspan="3">Lex</td><td>Ucapan untuk dikirim ke bot.</td><td>inputText</td><td>String</td><td rowspan="3">Maksud yang diprediksi bot untuk ucapan tersebut.</td><td rowspan="3">predictedIntent</td><td rowspan="3">String</td></tr>
  <tr><td>[Atribut permintaan](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-request-attribs.html) apa pun untuk dikirim bersama ucapan.</td><td>requestAttributes</td><td>Objek</td></tr>
  <tr><td>[Atribut sesi](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-session-attribs.html) apa pun untuk dikirim bersama ucapan.</td><td>sessionAttributes</td><td>Objek</td></tr>
</tbody>
</table>