As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Tipos de nó para o fluxo
<a name="flows-nodes"></a>

O Amazon Bedrock fornece os tipos de nó a seguir para criar um fluxo. Ao configurar um nó, forneça os seguintes campos:
+ Nome: insira um nome para o nó.
+ Tipo: no console, você arrasta e solta o tipo de nó a ser usado. Na API, use o `type` campo e o correspondente [FlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNodeConfiguration.html)no `configuration` campo.
+ Entradas: forneça as seguintes informações para cada entrada:
  + Nome: um nome para a entrada. Alguns nós têm nomes ou tipos predefinidos que você deve usar. Para saber quais têm nomes predefinidos, consulte [Tipos de nó lógico](#flows-nodes-logic-table).
  + Expressão: defina a parte de toda a entrada a ser usada como a entrada individual. Para obter mais informações, consulte [Usar expressões para definir entradas extraindo a parte relevante de uma entrada inteira nos fluxos do Amazon BedrockDefinir entradas com expressões](flows-expressions.md).
  + Tipo: o tipo de dados para a entrada. Quando esse nó é alcançado em tempo de execução, o Amazon Bedrock aplica a expressão a toda a entrada e valida se o resultado corresponde ao tipo de dados.
+ Saídas: fornece as seguintes informações para cada saída:
  + Nome: um nome para a saída. Alguns nós têm nomes ou tipos predefinidos que você deve usar. Para saber quais têm nomes predefinidos, consulte [Tipos de nó lógico](#flows-nodes-logic-table).
  + Tipo: o tipo de dados para a saída. Quando esse nó é alcançado em tempo de execução, o Amazon Bedrock valida se a saída do nó corresponde ao tipo de dados.
+ Configuração: no console, você define campos específicos do nó na parte superior do nó. Na API, use o apropriado [FlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNodeConfiguration.html)e preencha seus campos.

Cada tipo de nó é descrito abaixo, e a estrutura na API é fornecida. Expanda uma seção para saber mais sobre esse tipo de nó.

## Nós para controlar a lógica do fluxo
<a name="flows-nodes-logic"></a>

Use os tipos de nó a seguir para controlar a lógica do fluxo.

### Nó de entrada do fluxo
<a name="flows-nodes-input"></a>

Cada fluxo só contém um nó de entrada do fluxo e deve começar com ele. O nó de entrada do fluxo obtém o `content` da solicitação `InvokeFlow`, valida o tipo de dados e o envia ao nó subsequente.

Veja a seguir a estrutura geral de um [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto de entrada na API:

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

### Nó de saída do fluxo
<a name="flows-nodes-output"></a>

Um nó de saída do fluxo extrai os dados de entrada do nó anterior, com base na expressão definida, e os retorna. No console, a saída será a resposta retornada depois de escolher **Executar** na janela de teste. Na API, a saída é retornada no campo `flowOutputEvent` do `content` na resposta `InvokeFlow`. Um fluxo pode ter vários nós de saída de fluxo.

Um fluxo pode ter vários nós de saída do fluxo se houver várias ramificações no fluxo.

O seguinte mostra a estrutura geral de um [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto de saída:

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

### Nó de condição
<a name="flows-nodes-condition"></a>

Um nó de condição envia dados do nó anterior para nós diferentes, dependendo das condições definidas. Um nó de condição pode obter várias entradas.

Para ver um exemplo, consulte [Criar um fluxo com um nó de condição](flows-ex-condition.md).

**Como definir um nó de condição**

1. Adicione quantas entradas você precisar para avaliar as condições que você pretende adicionar.

1. Insira um nome para cada entrada, especifique o tipo esperado e escreva uma expressão para extrair a parte relevante de toda a entrada.

1. Conecte cada entrada a uma saída relevante de um nó precedente.

1. Adicione quantas condições você precisar.

1. Para cada condição:

   1. Insira um nome para a condição.

   1. Use operadores lógicos e relacionais para definir uma condição que compara entradas com outras entradas ou com uma constante.
**nota**  
As condições são avaliadas na ordem. Se mais de uma condição for atendida, a condição anterior terá precedência.

   1. Conecte cada condição ao nó subsequente para o qual você deseja enviar os dados, se essa condição for atendida.

#### Expressões de condição
<a name="flows-nodes-condition-expr"></a>

Para definir uma condição, você se refere a uma entrada pelo nome e a compara com um valor usando qualquer um dos seguintes operadores relacionais:


****  

| Operador | Significado | Tipos de dados compatíveis | Exemplo de uso | Significado do exemplo | 
| --- | --- | --- | --- | --- | 
| == | Igual a (o tipo de dados também deve ser igual a) | String, número, booliano | A == B | Se A for igual a B | 
| \$1= | Não é igual a | String, número, booliano | A \$1= B | Se A não for igual a B | 
| > | Maior que | Número | A > B | Se A for maior que B | 
| >= | Maior ou igual a | Número | A >= B | Se A for maior que ou igual a B | 
| < | Menor que | Número | A < B | Se A for menor que B | 
| <= | Menor ou igual a | Número | A <= B | Se A for menor que ou igual a B | 

Você pode comparar entradas com outras entradas ou com uma constante em uma expressão condicional. Por exemplo, se você tiver uma entrada numérica chamada `profit` e outra chamada `expenses`, **profit > expenses** ou **profit <= 1000** é uma expressão válida.

Você pode usar os operadores lógicos a seguir a fim de combinar expressões para condições mais complexas. É recomendável usar parênteses para resolver ambiguidades no agrupamento de expressões:


****  

| Operador | Significado | Exemplo de uso | Significado do exemplo | 
| --- | --- | --- | --- | 
| and | Ambas as expressões são verdadeiras | (A < B) e (C == 1) | Se ambas as expressões forem verdadeiras: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/flows-nodes.html) | 
| or | Pelo menos uma expressão é verdadeira | (A \$1= 2) ou (B > C) | Se alguma das expressões for verdadeira: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/flows-nodes.html) | 
| not | A expressão não é verdadeira | não (A > B) | Se A não for maior que B (equivalente a A <= B) | 

Na API, você define o seguinte no `definition` campo ao enviar uma [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html)solicitação [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html)ou:

1. Um [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto condicional na `nodes` matriz. O formato geral é o seguinte (observe que os nós de condição não têm`outputs`):

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

1. Para cada entrada no nó condicional, um [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)objeto na `connections` matriz. Inclua um [FlowDataConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowDataConnectionConfiguration.html)objeto no `configuration` campo do `FlowConnection` objeto. O formato geral do objeto `FlowConnection` é o seguinte:

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

1. Para cada condição (incluindo a condição padrão) no nó da condição, um [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)objeto na `connections` matriz. Inclua um [FlowConditionalConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConditionalConnectionConfiguration.html)objeto no `configuration` campo do `FlowConnection` objeto. O formato geral do [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)objeto é o seguinte:

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

   Use operadores relacionais e lógicos para definir o `condition` que conecta esse nó de condição `source` a um nó `target` subsequente. Para a condição padrão, especifique a condição como **default**.

### Nó iterador
<a name="flows-nodes-iterator"></a>

Um nó iterador pega uma matriz e retorna iterativamente os itens como saída para o nó subsequente. As entradas para o nó iterador são processadas uma a uma e não paralelamente umas às outras. O nó de saída de fluxo retorna o resultado final de cada entrada em uma resposta diferente. Você também pode usar um nó coletor subsequente do nó iterador para coletar as respostas iteradas e retorná-las como uma matriz, além do tamanho da matriz.

O seguinte mostra a estrutura geral de um [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto iterador:

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

### Nó coletor
<a name="flows-nodes-collector"></a>

Um nó coletor recebe uma entrada iterada, além do tamanho que a matriz terá, e a retorna como uma matriz. Você poderá usar um nó coletor subsequente de um nó iterador para coletar os itens iterados depois de enviá-los por meio de alguns nós.

Veja a seguir a estrutura geral de um [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto coletor:

```
{
    "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 nó de loop
<a name="flows-nodes-dowhile"></a>

Um nó de DoWhile loop executa uma sequência de nós repetidamente enquanto uma condição especificada permanece verdadeira. O loop é executado pelo menos uma vez antes de avaliar a condição, tornando-o ideal para cenários em que é necessária realizar uma ação e depois verificar se ela deve ser repetida com base no resultado.

O nó do DoWhile loop pega os dados de entrada e os passa pelo corpo do loop. Depois de cada iteração, a condição é avaliada para determinar se o loop deve continuar ou ser interrompido. O loop continuará enquanto a condição for avaliada como verdadeira ou valor `maxIterations` não for excedido.

Veja a seguir a estrutura geral de um [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto de 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"
        }
    }
}
```

Na configuração:
+ `condition`: uma expressão booliana que determina se o loop deve continuar. Use os mesmos operadores relacionais e lógicos dos nós condicionais. A condição é avaliada após cada iteração.
+ `maxIterations`: o número máximo de iterações. O padrão é 10. Você deve especificar um número positivo. Esse parâmetro ajuda a evitar loops infinitos.

**nota**  
O parâmetro `maxIterations` tem um valor padrão de 10 e só aceita números positivos. O loop é interrompido quando a condição se torna falsa ou o número máximo de iterações é atingido.

## Nós para processar dados no fluxo
<a name="flows-nodes-data"></a>

Use os seguintes tipos de nó para processar dados no fluxo:

### Nó de prompt
<a name="flows-nodes-prompt"></a>

Um nó de prompt define um prompt a ser usado no fluxo. Você pode usar um prompt do Gerenciamento de Prompts ou definir um em linha no nó. Para obter mais informações, consulte [Construir e armazenar prompts reutilizáveis com o Gerenciamento de Prompts do Amazon Bedrock](prompt-management.md).

Para ver um exemplo, consulte [Experimentar fluxos de exemplo](flows-ex.md).

As entradas para o nó de prompt são valores para preencher as variáveis. A saída é a resposta gerada pelo modelo.

Veja a seguir a estrutura geral de um [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto 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"
            }
        }
    }
}
```

O [PromptFlowNodeSourceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PromptFlowNodeSourceConfiguration.html)objeto depende se você usa um prompt do Gerenciamento de prompts ou se você o define em linha:
+ Se você usar um prompt do Gerenciamento de Prompts, o objeto deverá estar na seguinte estrutura geral:

  ```
  {
      "resource": {
          "promptArn": "string"
      }
  }
  ```
+ Se você definir um prompt em linha, siga as diretrizes para definir uma variante na guia API de [Criar um prompt usando o Gerenciamento de Prompts](prompt-management-create.md) (não há nenhum campo `name` nesse objeto, no entanto). O objeto usado deve estar na seguinte estrutura geral:

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

Para aplicar uma barreira de proteção das Barreiras de Proteção do Amazon Bedrock ao seu prompt ou à resposta gerada com base nele, inclua o campo `guardrailConfiguration` e especifique o ID ou ARN da barreira de proteção no campo `guardrailIdentifier` e a versão da barreira de proteção no campo `guardrailVersion`.

### Nó de agente
<a name="flows-nodes-agent"></a>

Um nó de agente permite que você envie uma solicitação a um agente, que orquestra entre os FMs recursos associados para identificar e executar ações para um usuário final. Para obter mais informações, consulte [Automatizar tarefas em sua aplicação usando agentes de IA](agents.md).

Na configuração, especifique o nome do recurso da Amazon (ARN) do alias do agente a ser usado. As entradas no nó são o prompt do agente e qualquer [prompt ou atributo de sessão](agents-session-state.md) associados. O nó retorna a resposta do agente como uma saída.

Um nó de agente pode comportar invocações de vários turnos, permitindo conversas interativas entre os usuários e o agente durante a execução do fluxo. Quando um nó de agente exige informações ou esclarecimentos adicionais, ele pode pausar a execução do fluxo e solicitar informações específicas do usuário. Depois que o usuário fornece as informações solicitadas, o nó do agente continua o respectivo processamento com a nova entrada. Isso continua até que o nó do agente tenha todas as informações necessárias para concluir a respectiva execução.

O seguinte mostra a estrutura geral de um [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto agente:

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

### Nó da base de conhecimento
<a name="flows-nodes-kb"></a>

Um nó da base de conhecimento permite que você envie uma consulta usando bases de conhecimento do Amazon Bedrock. Para obter mais informações, consulte [Recuperar dados e gerar respostas de IA com as Bases de Conhecimento do Amazon Bedrock](knowledge-base.md).

Na configuração, forneça, no mínimo, `knowledgeBaseId`. Como opção, você pode incluir os seguintes campos, dependendo do seu caso de uso:
+ `modelId`: inclua um [ID de modelo](models-supported.md) para usar se você quiser gerar uma resposta com base nos resultados recuperados. Para apresentar os resultados recuperados como uma matriz, omita o ID do modelo.
+ `guardrailConfiguration`: inclua o ID ou ARN da barreira de proteção, definido nas Barreiras de Proteção do Amazon Bedrock no campo `guardrailIdentifier`, e a versão da barreira de proteção no campo `guardrailVersion`.
**nota**  
As barreiras de proteção só podem ser aplicadas quando `RetrieveAndGenerate` estiver sendo usado em um nó da base de conhecimento.

A entrada no nó é a consulta à base de conhecimento. A saída é a resposta do modelo, como uma string, ou uma matriz dos resultados recuperados.

Veja a seguir a estrutura geral de um [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto da base de conhecimento:

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

### Nó de armazenamento S3
<a name="flows-nodes-storage"></a>

Um nó de armazenamento do S3 permite a você armazenar dados no fluxo em um bucket do Amazon S3. Na configuração, você especifica o bucket do S3 a ser usado para armazenamento de dados. As entradas no nó são o conteúdo a ser armazenado e a [chave do objeto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html). O nó retorna o URI do local do S3 como a saída.

Veja a seguir a estrutura geral de um [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto de armazenamento do 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 de recuperação S3
<a name="flows-nodes-retrieval"></a>

Um nó de recuperação do S3 permite a você recuperar dados de um local do Amazon S3 para introduzi-los no fluxo. Na configuração, você especifica o bucket do S3 do qual recupera os dados. A entrada no nó é a [chave do objeto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html). O nó retorna o conteúdo do local do S3 como a saída.

**nota**  
Atualmente, os dados no local do S3 devem ser uma string codificada em UTF-8.

O seguinte mostra a estrutura geral de um objeto de recuperação [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)do S3:

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

### Código da função do Lambda
<a name="flows-nodes-lambda"></a>

Um nó da função do Lambda permite a você chamar uma função do Lambda na qual pode definir o código para realizar a lógica de negócios. Quando você inclui um nó do Lambda em um fluxo, o Amazon Bedrock envia um evento de entrada à função do Lambda especificada.

Na configuração, especifique o nome do recurso da Amazon (ARN) da função do Lambda. Defina entradas a serem enviadas no evento de entrada do Lambda. Você pode escrever um código com base nessas entradas e definir o que a função retorna. A resposta da função é retornada na saída.

Veja a seguir a estrutura geral de um objeto de função [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"
        }
    }
}
```

#### Evento de entrada do Lambda para um fluxo
<a name="flows-nodes-lambda-input"></a>

O evento de entrada enviado para uma função do Lambda em um nó do Lambda tem o seguinte formato:

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

Os campos de cada entrada correspondem aos campos que você especifica ao definir o nó do Lambda, e o valor do campo `value` é preenchido com toda a entrada do no nó depois de resolvido pela expressão. Por exemplo, se toda a entrada no nó fosse `[1, 2, 3]` e a expressão fosse `$.data[1]`, o valor enviado no evento de entrada para a função do Lambda seria `2`.

Para obter mais informações sobre eventos do Lambda, consulte [Lambda concepts](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-event) no [AWS Lambda Developer Guide](https://docs.aws.amazon.com/lambda/latest/dg/).

#### Resposta do Lambda a um fluxo
<a name="flows-nodes-lambda-response"></a>

Ao escrever uma função do Lambda, você define a resposta exibida por ela. Essa resposta é exibida para o fluxo como a saída do nó do Lambda.

### Nó de código em inline
<a name="flows-nodes-inline-code"></a>

Um nó de código inline permite que você escreva e execute código diretamente em seu fluxo, possibilitando transformações de dados, lógica personalizada e integrações sem usar uma função externa do Lambda. Quando você inclui um nó de código embutido em seu fluxo, o Amazon Bedrock executa seu código em um ambiente isolado e AWS gerenciado que não é compartilhado com ninguém e não tem acesso à Internet.

**nota**  
O nó de código inline está em uma versão prévia do Amazon Bedrock e está sujeito a alterações.

Na configuração do nó, especifique o código a ser executado e a linguagem de programação (no momento, `Python_3` é a única opção). Defina entradas que seu código possa acessar como variáveis. O resultado da última linha executada em seu código é exibido como a saída do nó.

O exemplo a seguir mostra a estrutura geral de um [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto de código embutido:

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

#### Considerações ao usar nós de código inline
<a name="flows-nodes-inline-code-usage"></a>

Ao usar nós de código inline no seu fluxo, considere o seguinte:

**Importante**  
Recomendamos que você teste seu código antes de adicioná-lo a um nó de código inline.
+ Não há suporte para nós de código inline na [execução de fluxo assíncrono](flows-create-async.md).
+ No momento, a única linguagem de programação compatível para nós de código inline é Python 3.12 (`Python_3)`.
+ O código inline funciona como uma sessão interativa do Python. Somente o resultado da última linha executada é capturado e exibido como saída do nó.
+ A saída do console do Python (como a saída da função `print`) não é capturada.
+ As entradas para o nó de código inline estão disponíveis como variáveis do Python em seu código. Use o nome exato da entrada do nó para fazer referência a ele.
+ Configure os tipos de entrada e saída corretamente para evitar erros de runtime. Você pode configurar até cinco entradas de nó.
+ Você pode ter até cinco nós de código inline por fluxo.
+ Você pode ter no máximo 25 nós de código inline em execução por Conta da AWS.
+ Seu código não pode ultrapassar 5 MB.

#### Entradas de nó de código inline
<a name="flows-nodes-inline-code-input"></a>

As entradas que você define para um nó de código inline estão disponíveis como variáveis do Python em seu código. Por exemplo, se você definir uma entrada chamada `userData`, poderá acessá-la diretamente no seu código como `userData`.

O valor de cada entrada é preenchido com base na expressão que você define. Por exemplo, se a entrada para o nó for `{"name": "John", "age": 30}` e a expressão for `$.name`, o valor da variável de entrada será `"John"`.

#### Saída de nó de código inline
<a name="flows-nodes-inline-code-output"></a>

O resultado da última linha executada em seu código é exibido como a saída do nó do código inline. Essa saída está disponível para os nós subsequentes do fluxo.

Por exemplo, o seguinte código exibe um dicionário como saída do nó:

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

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

### Nó do Lex
<a name="flows-nodes-lex"></a>

**nota**  
O nó Lex depende do serviço Amazon Lex, que pode armazenar e usar o conteúdo do cliente para o desenvolvimento e a melhoria contínua de outros AWS serviços. Como AWS cliente, você pode optar por não ter seu conteúdo armazenado ou usado para melhorias no serviço. Para saber como implementar uma política de recusa do Amazon Lex, consulte [AI services opt-out policies](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html).

Um nó do Lex permite a você chamar um bot do Amazon Lex para processar um enunciado usando processamento de linguagem natural e identificar uma intenção, com base na definição do bot. Para obter mais informações, consulte o [Amazon Lex Developer Guide](https://docs.aws.amazon.com/lex/latest/dg/).

Na configuração, especifique o nome do recurso da Amazon (ARN) do alias do bot e a localidade a serem usados. As entradas no nó são o enunciado e todos os [atributos de solicitação](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-request-attribs.html) ou os [atributos de sessão](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-request-attribs.html) que o acompanham. O nó retorna a intenção identificada como a saída.

**nota**  
Atualmente, o nó do Lex não dá suporte a conversas multiturno. Um nó do Lex só pode processar um enunciado.

O seguinte mostra a estrutura geral de um [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto 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"
        }
    }
}
```

## Tabelas de resumo para tipos de nó
<a name="flows-nodes-summary-table"></a>

As tabelas a seguir resumem as entradas e as saídas permitidas para cada tipo de nó. Observe o seguinte:
+ Se um nome estiver marcado como **Qualquer**, você poderá fornecer qualquer string como o nome. Do contrário, você deve usar o valor especificado na tabela.
+ Se um tipo estiver marcado como **Qualquer**, você poderá especificar qualquer um dos seguintes tipos de dados: String, Número, Booliano, Objeto, Matriz. Do contrário, você deve usar o tipo especificado na tabela.
+ É possível definir várias entradas para os nós **Condição**, **Prompt**, **Função do Lambda** e **Código inline**.


**Tipos de nó lógico**  
<a name="flows-nodes-logic-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/flows-nodes.html)


**Tipos de nó de processamento de dados**  
<a name="flows-nodes-data-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/flows-nodes.html)