

本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# Amazon Bedrock 流程的運作方式
<a name="flows-how-it-works"></a>

Amazon Bedrock Flows 可讓您透過連接節點來建置生成式 AI 工作流程，每個節點對應於調用 Amazon Bedrock 或相關資源流程中的步驟。若要定義節點的輸入和輸出，您可以使用運算式來指定如何解譯輸入。為了更了解這些概念，請檢閱下列主題：

**Topics**
+ [Amazon Bedrock 流程的關鍵定義](key-definitions-flow.md)
+ [使用表達式在 Amazon Bedrock 流程中擷取整個輸入的相關部分來定義輸入](flows-expressions.md)
+ [流程的節點類型](flows-nodes.md)

# Amazon Bedrock 流程的關鍵定義
<a name="key-definitions-flow"></a>

以下清單向您介紹 Amazon Bedrock Flows 的基本概念。
+ **流程** – 流程是由名稱、描述、許可、節點集合和節點之間連線組成的建構模組。調用流程時，調用中的輸入會透過流程的每個節點傳送，直到達到輸出節點為止。調用的回應會傳回最終輸出。
+ **節點** – 節點是流程中的步驟。對於每個節點，您可以設定其名稱、描述、輸入、輸出和任何其他組態。節點的組態會根據其類型而有所不同。若要進一步了解不同的節點類型，請參閱 [流程的節點類型](flows-nodes.md)。
+ **連線** – Amazon Bedrock 流程中使用的連線有兩種類型：
  + **資料連線**會在一個節點 (*來源節點*) 的輸出與另一個節點 (*目標節點*) 的輸入之間繪製，並將資料從上游節點傳送至下游節點。在 Amazon Bedrock 主控台中，資料連線是實心灰色線條。
  + 在條件節點和下游節點中的條件之間繪製**條件式連線**，並在滿足條件時，從條件節點之前的節點將資料傳送至下游節點。在 Amazon Bedrock 主控台中，條件式連線是虛線的紫色線條。
+ **表達式** – 表達式定義如何從進入節點的整個輸入擷取輸入。若要了解如何撰寫表達式，請參閱 [使用表達式在 Amazon Bedrock 流程中擷取整個輸入的相關部分來定義輸入使用表達式定義輸入](flows-expressions.md)。
+ **流程建置器** – 流程建置器是 Amazon Bedrock 主控台上的工具，可透過視覺化界面建置和編輯流程。您可以使用視覺化界面將節點拖放到界面上，並設定這些節點的輸入和輸出來定義流程。
+ 在下列各節中，我們將使用下列術語：
  + **整個輸入** – 從上一個節點傳送至目前節點的整個輸入。
  + **上游** – 意指先前在流程中發生的節點。
  + **下游** – 意指稍後在流程中發生的節點。
  + **輸入** – 節點可以有多個輸入。您可以使用表達式來擷取整個輸入的相關部分，以用於每個個別輸入。在 Amazon Bedrock 主控台流程建置器中，輸入會在節點的左側邊緣顯示為圓圈。將每個輸入連線至上游節點的輸出。
  + **輸出** – 節點可以有多個輸出。在 Amazon Bedrock 主控台流程建置器中，輸出會在節點右側邊緣顯示為圓圈。將每個輸出連線至下游節點中的至少一個輸入。
  + **分支** – 如果節點的輸出傳送到多個節點，或如果包含條件節點，流程的路徑會分割成多個分支。每個分支都可能在流程調用回應中產生另一個輸出。

# 使用表達式在 Amazon Bedrock 流程中擷取整個輸入的相關部分來定義輸入
<a name="flows-expressions"></a>

設定節點的輸入時，您必須根據將進入節點的整個輸入來進行定義。整個輸入可以是字串、數字、布林值、陣列或物件。若要定義與整個輸入相關的輸入，您可以使用以 [JsonPath](https://github.com/json-path/JsonPath) 為基礎的支援表達式子集。每個表達式都必須以 `$.data` 開頭，這是指整個輸入。使用表達式時，請注意下列事項：
+ 如果整個輸入是字串、數字或布林值，則您可用來定義個別輸入的唯一表達式是 `$.data`
+ 如果整個輸入是陣列或物件，您可以使用擷取一部分來定義個別輸入。

舉例來說，若要了解如何使用表達式，則假設整個輸入是下列 JSON 物件：

```
{
    "animals": {
        "mammals": ["cat", "dog"],
        "reptiles": ["snake", "turtle", "iguana"]
    },
    "organisms": {
        "mammals": ["rabbit", "horse", "mouse"],
        "flowers": ["lily", "daisy"]
    },
    "numbers": [1, 2, 3, 5, 8]
}
```

您可以使用下列表達式來擷取輸入的一部分 (範例參照從上述 JSON 物件傳回的內容)：


****  

| 表達式 | 意義 | 範例 | 範例結果 | 
| --- | --- | --- | --- | 
| \$1.data | 整個輸入。 | \$1.data | 整個物件 | 
| \$1name\$1 | JSON 物件中稱為名稱之欄位的值。 | \$1.data.numbers | [1, 2, 3, 5, 8] | 
|  (int) | 陣列中 int 指定的索引成員。 | \$1.data.animals.reptiles[2] | iguana | 
| [int1, int2, ...] | 陣列中每個 int 所指定索引的成員。 | \$1.data.numbers[0, 3] | [1, 5] | 
| [int1:int2] | 由陣列中 int1 (含) 和 int2 (不含) 之間索引的項目組成的陣列。省略 int1 或 int2 等同於標記陣列的開頭或結尾。 | \$1.data.organisms.mammals[1:] | ["horse", "mouse"] | 
| \$1 | 可以用來取代 name 或 int 的萬用字元。如果有多個結果，則會在陣列中傳回結果。 | \$1.data.\$1.mammals | [["cat", "dog"], ["rabbit", "horse", "mouse"]] | 

# 流程的節點類型
<a name="flows-nodes"></a>

Amazon Bedrock 流程提供下列可建置流程的節點類型。設定節點時，請提供下列欄位：
+ 名稱：輸入節點的唯一名稱。
+ 類型：在主控台中，您可以拖放要使用的節點類型。在 API 中，使用 `type` 欄位和 `configuration` 欄位中對應的 [FlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNodeConfiguration.html)。
+ 輸入：為每個輸入提供下列資訊：
  + 名稱：輸入的名稱。有些節點具有您必須使用的預先定義名稱或類型。若要了解哪些節點具有預先定義的名稱，請參閱[邏輯節點類型](#flows-nodes-logic-table)。
  + 表達式：定義要用作個別輸入的整個輸入部分。如需詳細資訊，請參閱[使用表達式在 Amazon Bedrock 流程中擷取整個輸入的相關部分來定義輸入使用表達式定義輸入](flows-expressions.md)。
  + 類型：輸入的資料類型。在執行時期達到此節點時，Amazon Bedrock 會將表達式套用至整個輸入，並驗證結果是否符合資料類型。
+ 輸出：為每個輸出提供下列資訊：
  + 名稱：輸出的名稱。有些節點具有您必須使用的預先定義名稱或類型。若要了解哪些節點具有預先定義的名稱，請參閱[邏輯節點類型](#flows-nodes-logic-table)。
  + 類型：輸出的資料類型。在執行時期達到此節點時，Amazon Bedrock 會驗證節點輸出是否符合資料類型。
+ 組態：您可以在主控台中在節點頂端定義節點特定的欄位。在 API 中，使用適當的 [FlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNodeConfiguration.html) 並填寫其欄位。

每個節點類型如下所述，並在 API 中提供其結構。展開區段以進一步了解該節點類型。

## 用於控制流程邏輯的節點
<a name="flows-nodes-logic"></a>

使用下列節點類型來控制流程的邏輯。

### 流程輸入節點
<a name="flows-nodes-input"></a>

每個流程僅包含一個流程輸入節點，且必須以其作為開頭。流程輸入節點會從 `InvokeFlow` 請求取得 `content`、驗證資料類型，並將其傳送至下列節點。

以下顯示 API 中輸入 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html) 物件的一般結構：

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

### 流程輸出節點
<a name="flows-nodes-output"></a>

流程輸出節點會根據定義的表達式，從上一個節點擷取輸入資料並將其傳回。在主控台中，輸出是在測試視窗中選擇**執行**後傳回的回應。在 API 中，會在 `InvokeFlow` 回應中 `flowOutputEvent` 的 `content` 欄位中傳回輸出。流程可以有多個流程輸出節點。

如果流程中有多個分支，則流程可以有多個流程輸出節點。

以下顯示輸出 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html) 物件的一般結構：

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

### 條件節點
<a name="flows-nodes-condition"></a>

條件節點會根據定義的條件，將資料從先前的節點傳送至不同的節點。條件節點可以接受多個輸入。

如需範例，請參閱 [使用條件節點建立流程](flows-ex-condition.md)。

**定義條件節點**

1. 視需要新增任意數量的輸入，以評估您計劃新增的條件。

1. 輸入每個輸入的名稱、指定預期的類型，然後撰寫表達式從整個輸入中擷取相關部分。

1. 將每個輸入連結到上游節點中的相關輸出。

1. 視需要新增任意數量的條件。

1. 對於每個條件：

   1. 輸入條件的名稱。

   1. 使用關聯式和邏輯運算子來定義條件，此條件會將輸入與其他輸入或常數相比較。
**注意**  
系統會依序評估條件。若有多個條件同時滿足，則優先採用較早出現的條件。

   1. 將每個條件連結到您想要在滿足條件時傳送資料的下游節點。

#### 條件表達式
<a name="flows-nodes-condition-expr"></a>

若要定義條件，您可以依其名稱參考輸入，並使用下列任一關聯式運算子將其與值進行比較：


****  

| 運算子 | 意義 | 支援的資料類型 | 範例使用方式 | 範例意義 | 
| --- | --- | --- | --- | --- | 
| == | 等於 (資料類型也必須相等) | 字串、數字、布林值 | A == B | 如果 A 等於 B | 
| \$1= | 不等於 | 字串、數字、布林值 | A \$1= B | 如果 A 不等於 B | 
| > | Greater than | Number | A > B | 如果 A 大於 B | 
| >= | 大於或等於 | Number | A >= B | 如果 A 大於或等於 B | 
| < | Less than | Number | A < B | 如果 A 小於 B | 
| <= | 小於或等於 | Number | A <= B | 如果 A 小於或等於 B | 

您可以將輸入與其他輸入或條件表達式中的常數相比較。例如，如果您有一個名為 `profit` 的數值輸入，另一個名為 `expenses` 的數值輸入，則 **profit > expenses** 或 **profit <= 1000** 都是有效的表達式。

您可以使用下列邏輯運算子來結合表達式，以因應更複雜的條件。我們建議您使用括號來解析表達式分組中模棱兩可的情況：


****  

| 運算子 | 意義 | 範例使用方式 | 範例意義 | 
| --- | --- | --- | --- | 
| 及 | 兩個表達式都是 true | (A < B) 和 (C == 1) | 如果兩個表達式都是 true：[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/bedrock/latest/userguide/flows-nodes.html) | 
| 或 | 至少一個表達式為 true | (A \$1= 2) 或 (B > C) | 如果任一表達式為 true：[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/bedrock/latest/userguide/flows-nodes.html) | 
| 非 | 表達式不是 true | 不是 (A > B) | 如果 A 不大於 B (相當於 A <= B) | 

在 API 中，當傳送 [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html) 或 [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html) 請求時，您可以在 `definition` 欄位中定義下列項目：

1. `nodes` 陣列中的條件 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html) 物件。一般格式如下 (請注意，條件節點沒有 `outputs`)：

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

1. 對於條件節點中的每個輸入，`connections` 陣列中的 [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html) 物件。在 `FlowConnection` 物件的 `configuration` 欄位中包含 [FlowDataConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowDataConnectionConfiguration.html) 物件。`FlowConnection` 物件的一般格式如下：

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

1. 對於條件節點中的每個條件 (包括預設條件)，`connections` 陣列中的 [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html) 物件。在 `FlowConnection` 物件的 `configuration` 欄位中包含 [FlowConditionalConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConditionalConnectionConfiguration.html) 物件。[FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html) 物件的一般格式如下：

   ```
   {
       "name": "string",
       "source": "string",
       "target": "string",
       "type": "Conditional",
       "configuration": {
           "conditional": {
               "condition": "string"
           }
       }
   }
   ```

   使用關聯式和邏輯運算子來定義將此條件 `source` 節點連結到下游 `target` 節點的 `condition`。針對預設條件，請將條件指定為 **default**。

### 迭代器節點
<a name="flows-nodes-iterator"></a>

迭代器節點採用陣列，並反覆將其項目作為輸出傳回下游節點。迭代器節點的輸入會逐一處理，而不是彼此平行處理。流程輸出節點會傳回不同回應中每個輸入的最終結果。除了陣列的大小之外，您也可以使用迭代器節點中下游收集器節點，來收集反覆運算的回應，並將其傳回為陣列。

以下顯示迭代器 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html) 物件的一般結構：

```
{
    "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
    }
}
```

### 收集器節點
<a name="flows-nodes-collector"></a>

除了陣列的大小之外，收集器節點還會採用反覆輸入，並以陣列的形式將其傳回。您可以在迭代器節點的下游使用收集器節點，在將反覆運算的項目傳送至若干節點後進行收集。

以下顯示收集器 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html) 物件的一般結構：

```
{
    "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 迴圈節點
<a name="flows-nodes-dowhile"></a>

DoWhile 迴圈節點會重複執行一系列節點，而指定的條件仍為 true。迴圈在評估條件之前至少執行一次，因此非常適合需要執行動作的情況，然後檢查是否應該根據結果重複執行。

DoWhile 迴圈節點會取得輸入資料，並將其傳遞至迴圈內文。每次迭代後都會評估條件，以決定是否要繼續迴圈或結束。只要條件評估為 true，或未超過 `maxIterations`，迴圈就會繼續。

以下顯示 DoWhile 迴圈 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html) 物件的一般結構：

```
{
    "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"
        }
    }
}
```

在組態中：
+ `condition`：布林表達式，可決定是否要繼續迴圈。使用與條件節點相同的關聯式和邏輯運算子。每次迭代後都會評估條件。
+ `maxIterations`：迭代數量的上限。預設為 10。您必須指定正數。此參數可協助您避免無限迴圈。

**注意**  
`maxIterations` 參數的預設值為 10，且只接受正數。當條件變為 false 或達到迭代次數上限時，迴圈就會結束。

## 用於處理流程中資料的節點
<a name="flows-nodes-data"></a>

使用下列節點類型來處理流程中的資料：

### 提示節點
<a name="flows-nodes-prompt"></a>

提示節點會定義要在流程中使用的提示。您可以使用提示管理中的提示，或在節點中以內嵌的方式定義提示。如需詳細資訊，請參閱[在 Amazon Bedrock 中使用提示管理來建構和存放可重複使用的提示](prompt-management.md)。

如需範例，請參閱 [嘗試範例流程](flows-ex.md)。

提示節點的輸入是填入變數的值。輸出是從模型產生的回應。

以下顯示提示 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html) 物件的一般結構：

```
{
    "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) 物件取決於您使用提示管理的提示，還是以內嵌的方式定義提示：
+ 如果您使用提示管理中的提示，則物件應位於下列一般結構中：

  ```
  {
      "resource": {
          "promptArn": "string"
      }
  }
  ```
+ 如果您以內嵌的方式定義提示，請遵循 [使用提示管理建立提示](prompt-management-create.md) 的 API 索引標籤中定義變體的指引 (但請注意，此物件中沒有 `name` 欄位)。您使用的物件應位於下列一般結構中：

  ```
  {
      "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",
              ...
          }
      }
  }
  ```

若要將防護機制從 Amazon Bedrock 防護機制套用至提示或從中產生的回應，請包含 `guardrailConfiguration` 欄位，並在 `guardrailIdentifier` 欄位指定防護機制的 ID 或 ARN，並在 `guardrailVersion` 欄位指定防護機制的版本。

### 代理程式節點
<a name="flows-nodes-agent"></a>

代理程式節點可讓您將提示傳送給代理程式，該代理程式會在 FM 與相關資源之間協調，以識別和執行最終使用者的動作。如需詳細資訊，請參閱[使用 AI 代理程式自動執行應用程式中的任務](agents.md)。

在組態中，指定要使用之代理程式別名的 Amazon Resource Name (ARN)。節點的輸入是代理程式的提示，以及任何相關聯的[提示或工作階段屬性](agents-session-state.md)。節點會將代理程式的回應傳回作為輸出。

代理程式節點可以支援多回合調用，在流程執行期間啟用使用者與代理程式之間的互動對話。當代理程式節點需要其他資訊或說明時，其可以暫停流程執行，並向使用者請求特定輸入。一旦使用者提供請求的資訊，代理程式節點會繼續處理新的輸入。這會持續到代理程式節點擁有完成其執行所需的所有必要資訊為止

以下顯示代理程式 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html) 物件的一般結構：

```
{
    "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"
        }
    }
}
```

### 知識庫節點
<a name="flows-nodes-kb"></a>

知識庫節點可讓您從 Amazon Bedrock 知識庫將查詢傳送至知識庫。如需詳細資訊，請參閱[使用 Amazon Bedrock 知識庫擷取資料並產生 AI 回應](knowledge-base.md)。

在組態中至少提供 `knowledgeBaseId`。根據使用案例，您可以選擇包含下列欄位：
+ `modelId`：如果您想要根據擷取的結果產生回應，請包含要使用的[模型 ID](models-supported.md)。若要以陣列傳回擷取的結果，請省略模型 ID。
+ `guardrailConfiguration`：包含 `guardrailIdentifier` 欄位中 Amazon Bedrock 防護機制中定義的防護機制 ID 或 ARN，以及 `guardrailVersion` 欄位中防護機制的版本。
**注意**  
只有在知識庫節點中使用 `RetrieveAndGenerate` 時，才能套用防護機制。

節點的輸入是對知識庫的查詢。輸出可以是模型回應、字串或擷取結果的陣列。

以下顯示知識庫 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html) 物件的一般結構：

```
{
    "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"
            }
        }
    }
}
```

### S3 儲存節點
<a name="flows-nodes-storage"></a>

S3 儲存節點可讓您將資料存放在 Amazon S3 儲存貯體的流程中。您可以在組態中指定要用於資料儲存的 S3 儲存貯體。節點的輸入是要存放的內容和[物件金鑰](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html)。此節點會傳回 S3 位置的 URI 作為其輸出。

以下顯示 S3 儲存 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html) 物件的一般結構：

```
{
    "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"
                }
            }
        }
    }
}
```

### S3 擷取節點
<a name="flows-nodes-retrieval"></a>

S3 擷取節點可讓您從 Amazon S3 位置擷取資料，以引入流程。您可以在組態中指定要從中擷取資料的 S3 儲存貯體。節點的輸入是[物件金鑰](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html)。節點會傳回 S3 位置中的內容作為輸出。

**注意**  
目前，S3 位置中的資料必須是 UTF-8 編碼字串。

以下顯示 S3 擷取 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html) 物件的一般結構：

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

### Lambda 函式節點
<a name="flows-nodes-lambda"></a>

Lambda 函式節點可讓您呼叫 Lambda 函式，您可以在其中定義程式碼來執行商業邏輯。當您在流程中包含 Lambda 節點時，Amazon Bedrock 會將輸入事件傳送至您指定的 Lambda 函式。

在組態中，指定 Lambda 函式的 Amazon Resource Name (ARN)。定義要在 Lambda 輸入事件中傳送的輸入。您可以根據這些輸入編寫程式碼，並定義函數傳回的內容。會在輸出傳回函數回應。

以下顯示 Lambda 函式 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html) 物件的一般結構：

```
{
    "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"
        }
    }
}
```

#### 流程的 Lambda 輸入事件
<a name="flows-nodes-lambda-input"></a>

傳送至 Lambda 節點中 Lambda 函式的輸入事件格式如下：

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

每個輸入的欄位，與您在定義 Lambda 節點時指定的欄位相符，而 `value` 欄位的值，會填入在表達式解析後在節點中的完整輸入內容。例如，如果節點的完整輸入是 `[1, 2, 3]` 且表達式是 `$.data[1]`，則在輸入事件中傳送至 Lambda 函式的值會是 `2`。

如需詳細資訊，請參閱《[AWS Lambda 開發人員指南](https://docs.aws.amazon.com/lambda/latest/dg/)》中的 [Lambda 概念](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-event)。

#### 流程的 Lambda 回應
<a name="flows-nodes-lambda-response"></a>

當您撰寫 Lambda 函式時，您可以定義其傳回的回應。此回應會傳回至流程作為 Lambda 節點的輸出。

### 內嵌程式碼節點
<a name="flows-nodes-inline-code"></a>

內嵌程式碼節點可讓您直接在流程中編寫和執行程式碼，不需使用外部 Lambda 函式即可啟用資料轉換、自訂邏輯和整合。當您在流程中包含內嵌程式碼節點時，Amazon Bedrock 會在未與任何人共用且無法存取網際網路的隔離受 AWS 管環境中執行您的程式碼。

**注意**  
內嵌程式碼節點是 Amazon Bedrock 的預覽版本，且可能隨時變更。

在節點組態中，指定要與程式設計語言一起執行的程式碼 (`Python_3` 目前是唯一的選項）。定義您的程式碼可存取的輸入作為變數。程式碼中最後執行的一行的結果將作為節點輸出傳回。

下列範例顯示內嵌程式碼 [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html) 物件的一般結構：

```
{
    "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"
        }
    }
}
```

#### 使用內嵌程式碼節點時的考量事項
<a name="flows-nodes-inline-code-usage"></a>

在流程中使用內嵌程式碼節點時，請考量下列事項：

**重要**  
我們建議您先測試程式碼，再將其新增至內嵌程式碼節點。
+ [非同步流程執行](flows-create-async.md)中不支援內嵌程式碼節點。
+ 目前，內嵌程式碼節點支援的唯一程式設計語言是 Python 3.12 (`Python_3)`。
+ 內嵌程式碼會作為互動式 Python 工作階段執行。只會擷取最後執行的一行的結果，並將其作為節點輸出傳回。
+ Python 主控台輸出 (例如來自 `print` 函數的輸出) 則不會擷取。
+ 內嵌程式碼節點的輸入會在您的程式碼中作為 Python 變數提供使用。使用確切名稱來參考節點輸入。
+ 正確設定輸入和輸出類型，以避免執行時期錯誤。您最多可以設定五個節點輸入。
+ 每個流程最多可以有五個內嵌程式碼節點。
+ 每個 AWS 帳戶最多可以有 25 個執行中的內嵌程式碼節點。
+ 您的程式碼不可超過 5 MB。

#### 內嵌程式碼節點輸入
<a name="flows-nodes-inline-code-input"></a>

您為內嵌程式碼節點定義的輸入會在程式碼中作為 Python 變數提供使用。例如，如果您定義名為 `userData` 的輸入，則可以直接在程式碼中將其存取為 `userData`。

會根據您定義的表達式填入每個輸入的值。例如，如果節點的輸入是 `{"name": "John", "age": 30}`，則表達式是 `$.name`，則輸入變數的值會是 `"John"`。

#### 內嵌程式碼節點輸出
<a name="flows-nodes-inline-code-output"></a>

程式碼中最後執行的一行的結果將作為內嵌程式碼節點的輸出傳回。此輸出可供流程中的後續節點使用。

例如，下列程式碼會傳回字典作為節點輸出：

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

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

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

**注意**  
Lex 節點依賴 Amazon Lex 服務，該服務可能會存放和使用客戶內容，以開發和持續改善其他服務 AWS 。身為 AWS 客戶，您可以選擇不儲存內容或將其用於改善服務。若要了解如何為 Amazon Lex 實作選擇退出政策，請參閱 [AI 服務選擇退出政策](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html)。

Lex 節點可讓您呼叫 Amazon Lex 機器人，使用自然語言處理來處理表達用語，並根據機器人定義識別意圖。如需詳細資訊，請參閱《[Amazon Lex 開發人員指南](https://docs.aws.amazon.com/lex/latest/dg/)》。

在組態中，指定要使用之機器人別名的 Amazon Resource Name (ARN) 和要使用的地區設定。節點的輸入是表達用語和任何隨附的[請求屬性](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-request-attribs.html)或[工作階段屬性](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-request-attribs.html)。節點會傳回已識別的意圖作為輸出。

**注意**  
目前，Lex 節點不支援多回合對話。單一 Lex 節點只能處理單一表達用語。

以下顯示 Lex [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html) 物件的一般結構：

```
{
    "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"
        }
    }
}
```

## 節點類型的摘要資料表
<a name="flows-nodes-summary-table"></a>

下表摘要說明每個節點類型允許的輸入和輸出。注意下列事項：
+ 如果名稱標記為**任何**，則可以提供任何字串作為名稱。否則，您必須使用資料表中指定的值。
+ 如果類型標記為**任何**，您可以指定下列任何資料類型：字串、數字、布林值、物件、陣列。否則，您必須使用資料表中指定的類型。
+ 您可以為**條件**、**提示**、**Lambda 函式**和**內嵌程式碼**節點定義多個輸入。


**邏輯節點類型**  
<a name="flows-nodes-logic-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/bedrock/latest/userguide/flows-nodes.html)


**資料處理節點類型**  
<a name="flows-nodes-data-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/bedrock/latest/userguide/flows-nodes.html)