Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Funcionamiento de Flujos de Amazon Bedrock
<a name="flows-how-it-works"></a>

Flujos de Amazon Bedrock le permite crear flujos de trabajo de IA generativa mediante la conexión de nodos. Cada uno de los nodos se corresponde con un paso del flujo que invoca Amazon Bedrock o un recurso relacionado. Para definir las entradas y salidas de los nodos, utilice expresiones para especificar cómo se debe interpretar la entrada. Para comprender mejor estos conceptos, revise los siguientes temas:

**Topics**
+ [Definiciones clave de Flujos de Amazon Bedrock](key-definitions-flow.md)
+ [Uso de expresiones para definir las entradas extrayendo la parte relevante de una entrada completa en Flujos de Amazon Bedrock](flows-expressions.md)
+ [Tipos de nodos para el flujo](flows-nodes.md)

# Definiciones clave de Flujos de Amazon Bedrock
<a name="key-definitions-flow"></a>

En la siguiente lista se muestran los conceptos básicos de Flujos de Amazon Bedrock.
+ **Flujo**: un flujo es un constructo que consta de un nombre, una descripción, permisos, un conjunto de nodos y conexiones entre nodos. Cuando se invoca un flujo, la entrada de la invocación se envía a través de cada nodo del flujo hasta llegar a un nodo de salida. La respuesta de la invocación devuelve el resultado final.
+ **Nodo**: un nodo es un paso dentro de un flujo. Para cada nodo, debe configurar el nombre, la descripción, la entrada, la salida y cualquier otra configuración adicional. La configuración de un nodo varía según su tipo. Para obtener más información acerca de los distintos tipos de nodos, consulte [Tipos de nodos para el flujo](flows-nodes.md).
+ **Conexión**: en Flujos de Amazon Bedrock se utilizan dos tipos de conexión:
  + Se establece una **conexión de datos** entre la salida de un nodo (el *nodo de origen*) y la entrada de otro nodo (el *nodo de destino*) que envía datos desde un nodo ascendente a un nodo descendente. En la consola de Amazon Bedrock, las conexiones de datos se representan con líneas grises continuas.
  + Se establece una **conexión condicional** entre una condición de un nodo de condición y un nodo descendente que envía datos desde el nodo que precede al nodo de condición a un nodo descendente si se cumple la condición. En la consola de Amazon Bedrock, las conexiones condicionales se representan como líneas de puntos de color púrpura.
+ **Expresiones**: una expresión define la manera de extraer una entrada de la entrada completa que entra en un nodo. Para obtener más información sobre como escribir expresiones, consulte [Uso de expresiones para definir las entradas extrayendo la parte relevante de una entrada completa en Flujos de Amazon BedrockDefinición de entradas con expresiones](flows-expressions.md).
+ **Generador de flujos**: el generador de flujos es una herramienta de la consola de Amazon Bedrock para crear y editar flujos a través de una interfaz visual. Utilice la interfaz visual para arrastrar y soltar nodos en la interfaz y configurar las entradas y salidas de dichos nodos para definir su flujo.
+ En las siguientes secciones, utilizaremos los siguientes términos:
  + **Entrada completa**: es la entrada completa que se envía desde el nodo anterior al nodo actual.
  + **Ascendente**: hace referencia a los nodos que aparecen en una fase anterior del flujo.
  + **Descendente**: hace referencia a los nodos que aparecen en una fase posterior del flujo.
  + **Entrada**: un nodo puede tener varias entradas. Las expresiones se utilizan para extraer las partes relevantes de la entrada completa y utilizarlas en cada entrada individual. En el generador de flujos de la consola de Amazon Bedrock, una entrada aparece en forma de círculo en la periferia izquierda de un nodo. Conecte cada entrada a una salida de un nodo ascendente.
  + **Salida**: un nodo puede tener varias salidas. En el generador de flujos de la consola de Amazon Bedrock, una salida aparece en forma de círculo en la periferia izquierda de un nodo. Conecte cada salida a al menos una entrada en un nodo descendente.
  + **Ramificación**: si se envía una salida desde un nodo a más de un nodo, o si se incluye un nodo de condición, la ruta del flujo se dividirá en varias ramificaciones. Cada ramificación puede producir potencialmente otra salida en la respuesta de invocación del flujo.

# Uso de expresiones para definir las entradas extrayendo la parte relevante de una entrada completa en Flujos de Amazon Bedrock
<a name="flows-expressions"></a>

Al configurar las entradas de un nodo, debe definirlas en relación con toda la entrada que entrará en el nodo. La entrada de datos completa puede ser una cadena, un número, un valor booleano, una matriz o un objeto. Para definir una entrada en relación con la entrada completa, debe utilizar un subconjunto de expresiones compatibles basadas en [JsonPath](https://github.com/json-path/JsonPath). Cada expresión debe empezar por `$.data`, que hace referencia a toda la entrada. Tenga en cuenta lo siguiente para usar expresiones:
+ Si la entrada completa es una cadena, un número o un booleano, la única expresión que puede utilizar para definir una entrada individual es `$.data`.
+ Si la entrada completa es una matriz o un objeto, puede extraer una parte de ella para definir una entrada individual.

Para entender cómo usar las expresiones, supongamos que la entrada completa es el siguiente objeto JSON:

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

Puede usar las siguientes expresiones para extraer una parte de la entrada (los ejemplos hacen referencia a lo que se devolvería del objeto JSON anterior):


****  

| Expresión | Significado | Ejemplo | Ejemplo de resultado | 
| --- | --- | --- | --- | 
| \$1.data | Es la entrada completa. | \$1.data | Es el objeto completo. | 
| .name | Es el valor de un campo llamado name en un objeto JSON. | \$1.data.numbers | [1, 2, 3, 5, 8] | 
| [int] | Es el miembro del índice identificado con int en una matriz. | \$1.data.animals.reptiles[2] | iguana | 
| [int1, int2, ...] | Son los miembros del índice identificados con int en una matriz. | \$1.data.numbers[0, 3] | [1, 5] | 
| [int1:int2] | Matriz que consta de los elementos de los índices entre int1 (incluidos) e int2 (excluidos) de una matriz. Omitir int1 o int2 equivale a marcar el principio o el final de la matriz. | \$1.data.organisms.mammals[1:] | ["horse", "mouse"] | 
| \$1 | Es un comodín que se puede usar en lugar de un name o int. Si hay varios resultados, estos se devuelven en una matriz. | \$1.data.\$1.mammals | [["cat", "dog"], ["rabbit", "horse", "mouse"]] | 

# Tipos de nodos para el flujo
<a name="flows-nodes"></a>

Flujos de Amazon Bedrock proporciona los siguientes tipos de nodos para crear un flujo. Al configurar un nodo, debe proporcionar los siguientes campos:
+ Nombre: introduzca un nombre para el nodo.
+ Tipo: en la consola, arrastre y suelte el tipo de nodo que se va a utilizar. En la API, usa el `type` campo y [FlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNodeConfiguration.html)el `configuration` campo correspondiente.
+ Entradas: proporciona la siguiente información para cada entrada:
  + Nombre: nombre para la entrada. Algunos nodos tienen nombres o tipos predefinidos que debe usar. Para saber cuáles tienen nombres predefinidos, consulte [Tipos de nodo de lógica](#flows-nodes-logic-table).
  + Expresión: defina la parte de la entrada completa que se utilizará como entrada individual. Para obtener más información, consulte [Uso de expresiones para definir las entradas extrayendo la parte relevante de una entrada completa en Flujos de Amazon BedrockDefinición de entradas con expresiones](flows-expressions.md).
  + Tipo: tipo de datos de la entrada. Cuando se llega a este nodo en tiempo de ejecución, Amazon Bedrock aplica la expresión a la entrada completa y valida que el resultado coincida con el tipo de datos.
+ Salidas: proporcione la siguiente información para cada salida:
  + Nombre: nombre para la salida. Algunos nodos tienen nombres o tipos predefinidos que debe usar. Para saber cuáles tienen nombres predefinidos, consulte [Tipos de nodo de lógica](#flows-nodes-logic-table).
  + Tipo: es el tipo de datos de la salida. Cuando se llega a este nodo en tiempo de ejecución, Amazon Bedrock valida que la salida del nodo coincida con el tipo de datos.
+ Configuración: en la consola, debe definir los campos específicos del nodo en la parte superior del nodo. En la API, usa lo apropiado [FlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNodeConfiguration.html)y rellena sus campos.

A continuación, se describe cada tipo de nodo y se proporciona su estructura en la API. Expanda una sección para obtener más información sobre ese tipo de nodo.

## Nodos para controlar la lógica del flujo
<a name="flows-nodes-logic"></a>

Utilice los siguientes tipos de nodo para controlar la lógica del flujo.

### Nodo de entrada de flujo
<a name="flows-nodes-input"></a>

Cada flujo contiene solo un nodo de entrada de flujo y debe empezar por él. El nodo de entrada de flujo toma el `content` de la solicitud `InvokeFlow`, valida el tipo de datos y los envía al siguiente nodo.

A continuación se muestra la estructura general de un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto de entrada en la API:

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

### Nodo de salida de flujo
<a name="flows-nodes-output"></a>

Un nodo de salida de flujo extrae los datos de entrada del nodo anterior, en función de la expresión definida, y los devuelve. En la consola, el resultado es la respuesta que se devuelve tras seleccionar **Ejecutar** en la ventana de prueba. En la API, el resultado se devuelve en el campo `content` de `flowOutputEvent` en la respuesta de `InvokeFlow`. Un flujo puede tener varios nodos de salida de flujo.

Un flujo puede tener varios nodos de salida de flujo si hay varias ramificaciones en el flujo.

A continuación se muestra la estructura general de un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto de salida:

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

### Nodo de condición
<a name="flows-nodes-condition"></a>

Un nodo de condición envía datos desde el nodo anterior a diferentes nodos, en función de las condiciones definidas. Un nodo de condición puede recibir múltiples entradas.

Para ver un ejemplo, consulta [Creación de un flujo con un nodo de condición](flows-ex-condition.md).

**Definición de un nodo de condición**

1. Agregue todas las entradas que necesite para evaluar las condiciones que tiene previsto añadir.

1. Introduzca un nombre para cada entrada, especifique el tipo que desee y escriba una expresión para extraer la parte pertinente de la entrada completa.

1. Conecte cada entrada a la salida correspondiente de un nodo ascendente.

1. Agregue todas las condiciones que necesite.

1. Para cada condición:

   1. Escriba un nombre para la condición.

   1. Utilice operadores lógicos y relacionales para definir una condición que compare las entradas con otras entradas o con una constante.
**nota**  
Las condiciones se evalúan en orden. Si se cumple más de una condición, prevalece la anterior.

   1. Conecte cada condición al nodo descendente al que desea enviar los datos si se cumple esa condición.

#### Expresiones de condición
<a name="flows-nodes-condition-expr"></a>

Para definir una condición, se hace referencia a una entrada por su nombre y se compara con un valor mediante cualquiera de los siguientes operadores relacionales:


****  

| Operador | Significado | Tipos de datos compatibles | Ejemplo de uso | Ejemplo de significado | 
| --- | --- | --- | --- | --- | 
| == | Igual a (el tipo de datos también debe ser igual) | Cadena, número, booleano | A == B | Si A es igual a B | 
| \$1= | No igual que | Cadena, número, booleano | A \$1= B | Si A no es igual a B | 
| > | Mayor que | Número | A > B | Si A es mayor que B | 
| >= | Mayor o igual que | Número | A >= B | Si A es mayor o igual que B | 
| < | Menor que | Número | A < B | Si A es menor que B | 
| <= | Menor o igual que | Número | A <= B | Si A es menor o igual que B | 

Puede comparar las entradas con otras entradas o con una constante de una expresión condicional. Por ejemplo, si tiene una entrada numérica llamada `profit` y otra llamada `expenses`, ambas **profit > expenses** o **profit <= 1000** son expresiones válidas.

Puede usar los siguientes operadores lógicos para combinar expresiones para condiciones más complejas. Se recomienda utilizar paréntesis para resolver las ambigüedades en la agrupación de expresiones:


****  

| Operador | Significado | Ejemplo de uso | Ejemplo de significado | 
| --- | --- | --- | --- | 
| and | Ambas expresiones son verdaderas | (A < B) y (C == 1) | Ambas expresiones son verdaderas: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/flows-nodes.html) | 
| o | Al menos una expresión es verdadera | (A \$1= 2) o (B > C) | Si alguna de las expresiones es verdadera: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/flows-nodes.html) | 
| not | La expresión no es verdadera | no (A > B) | Si A no es mayor que B (equivale a A <= B) | 

En la API, se define lo siguiente en el `definition` campo cuando se envía una [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html)solicitud [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html)o solicitud:

1. Un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto de condición de la `nodes` matriz. El formato general es el siguiente (tenga en cuenta que los nodos de condición no tienen `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 en el nodo de condición, un [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)objeto de la `connections` matriz. Incluya un [FlowDataConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowDataConnectionConfiguration.html)objeto en el `configuration` campo del `FlowConnection` objeto. El formato general del objeto `FlowConnection` es el siguiente:

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

1. Para cada condición (incluida la condición predeterminada) del nodo de condición, un [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)objeto de la `connections` matriz. Incluya un [FlowConditionalConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConditionalConnectionConfiguration.html)objeto en el `configuration` campo del `FlowConnection` objeto. El formato general del [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)objeto es el siguiente:

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

   Utilice operadores lógicos y relacionales para definir la `condition` que conecta este nodo de condición de `source` con un nodo descendente de `target`. Para la condición predeterminada, especifique la condición como **default**.

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

Un nodo iterador toma una matriz y devuelve los elementos que contiene de forma iterativa como salida al nodo descendente. Las entradas en el nodo iterador se procesan una por una y no en paralelo entre sí. El nodo de salida del flujo devuelve el resultado final de cada entrada en una respuesta diferente. También puede usar un nodo recopilador descendente del nodo iterador para recopilar las respuestas iteradas y devolverlas en forma de matriz, además del tamaño de la matriz.

A continuación se muestra la estructura general de un [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
    }
}
```

### Nodo recopilador
<a name="flows-nodes-collector"></a>

Un nodo recopilador toma una entrada iterada, además del tamaño que tendrá la matriz, y la devuelve en forma de matriz. Puede utilizar un nodo recopilador descendente de un nodo iterador para recopilar los elementos iterados después de enviarlos a través de algunos nodos.

A continuación se muestra la estructura general de un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto recopilador:

```
{
    "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 nodo de bucle
<a name="flows-nodes-dowhile"></a>

Un nodo de DoWhile bucle ejecuta una secuencia de nodos repetidamente mientras se cumple una condición específica. El bucle se ejecuta al menos una vez antes de evaluar la condición, por lo que es ideal para situaciones en las que es necesario realizar una acción y, a continuación, comprobar si debe repetirse en función del resultado.

El nodo del DoWhile bucle toma los datos de entrada y los pasa a través del cuerpo del bucle. Después de cada iteración, se evalúa la condición para determinar si se debe continuar con el bucle o salir. El bucle continúa mientras la condición se evalúe como verdadera o no se supere el valor de `maxIterations`.

A continuación se muestra la estructura general de un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto de DoWhile bucle:

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

En la configuración:
+ `condition`: una expresión booleana que determina si se debe continuar con el bucle. Utilice los mismos operadores lógicos y relacionales como nodos de condición. La condición se evalúa después de cada iteración.
+ `maxIterations`: el número máximo de iteraciones. El valor predeterminado es 10. Debe especificar un número positivo. Este parámetro le ayuda a evitar bucles infinitos.

**nota**  
El parámetro `maxIterations` tiene un valor predeterminado de 10 y solo acepta números positivos. El bucle se termina cuando la condición pasa a ser falsa o se alcanza el número máximo de iteraciones.

## Nodos para gestionar los datos en el flujo
<a name="flows-nodes-data"></a>

Utilice los siguientes tipos de nodos para gestionar los datos del flujo:

### Nodo de solicitud
<a name="flows-nodes-prompt"></a>

Un nodo de petición define una petición que se va a utilizar en el flujo. Puede utilizar una petición de la Administración de peticiones o definir una en línea en el nodo. Para obtener más información, consulte [Creación y almacenamiento de peticiones reutilizables con la administración de peticiones en Amazon Bedrock](prompt-management.md).

Para ver un ejemplo, consulta [Prueba de flujos de ejemplo](flows-ex.md).

Las entradas en el nodo de petición son valores para rellenar las variables. La salida es la respuesta generada por el modelo.

A continuación se muestra la estructura general de un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto de solicitud:

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

El [PromptFlowNodeSourceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PromptFlowNodeSourceConfiguration.html)objeto depende de si utiliza una solicitud de Prompt Management o si la define en línea:
+ Si utiliza una petición de la Administración de peticiones, el objeto debe tener la siguiente estructura general:

  ```
  {
      "resource": {
          "promptArn": "string"
      }
  }
  ```
+ Si define una petición en línea, siga las instrucciones para definir una variante en la pestaña API de [Creación de una petición con la administración de peticiones](prompt-management-create.md) (sin embargo, tenga en cuenta que este objeto no incluye ningún campo `name`). El objeto que use debe tener la siguiente estructura general:

  ```
  {
      "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 una barrera de protección de Barreras de protección para Amazon Bedrock a su petición o a la respuesta generada a partir de ella, incluya el campo `guardrailConfiguration` y especifique el ID o el ARN de la barrera de protección en el campo `guardrailIdentifier` y la versión de la barrera de protección en el campo `guardrailVersion`.

### Nodo agente
<a name="flows-nodes-agent"></a>

Un nodo de agente permite enviar un mensaje a un agente, que organiza entre los recursos asociados FMs y los recursos asociados para identificar y llevar a cabo acciones en nombre del usuario final. Para obtener más información, consulte [Automatización de las tareas en la aplicación mediante agentes de IA](agents.md).

En la configuración, especifique el nombre de recurso de Amazon (ARN) del alias del agente que se usará. Las entradas del nodo son la petición del agente y cualquier [petición o atributo de sesión](agents-session-state.md) asociados. El nodo devuelve la respuesta del agente como salida.

Un nodo de agente puede admitir invocaciones de varios turnos, lo que permite mantener conversaciones interactivas entre los usuarios y el agente durante la ejecución del flujo. Cuando un nodo de agente requiere aclaraciones o información adicional, puede pausar la ejecución del flujo y solicitar al usuario información específica. Una vez que el usuario proporciona la información solicitada, el nodo de agente continúa procesando la nueva entrada. Este proceso continúa hasta que el nodo de agente tenga toda la información necesaria para completar su ejecución

A continuación se muestra la estructura general de un objeto agente [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"
        }
    }
}
```

### nodo de la base de conocimientos
<a name="flows-nodes-kb"></a>

Un nodo de base de conocimiento permite enviar una consulta a una base de conocimiento de Bases de conocimiento de Amazon Bedrock. Para obtener más información, consulte [Recuperación de datos y generación de respuestas de IA con Bases de conocimiento de Amazon Bedrock](knowledge-base.md).

En la configuración, proporcione el `knowledgeBaseId` como mínimo. Si lo desea, puede incluir los siguientes campos en función de su caso de uso:
+ `modelId`: incluya un [ID de modelo](models-supported.md) para utilizarlo si desea generar una respuesta basada en los resultados obtenidos. Para devolver los resultados obtenidos en forma de matriz, omita el ID del modelo.
+ `guardrailConfiguration`: incluya el ID o el ARN de la barrera de protección, definido en Barreras de protección para Amazon Bedrock en el campo `guardrailIdentifier` y la versión de la barrera de protección en el campo `guardrailVersion`.
**nota**  
Las barreras de protección solo se pueden aplicar cuando se utiliza `RetrieveAndGenerate` en un nodo de base de conocimiento.

La entrada en el nodo es la consulta a la base de conocimientos. El resultado es la respuesta del modelo, que puede ser una cadena o una matriz de los resultados obtenidos.

A continuación se muestra la estructura general de un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto de la base de conocimientos:

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

### Nodo de almacenamiento S3
<a name="flows-nodes-storage"></a>

Un nodo de almacenamiento de S3 le permite almacenar datos del flujo en un bucket de Amazon S3. En la configuración, debe especificar el bucket de S3 que se utilizará para el almacenamiento de datos. Las entradas en el nodo son el contenido que se va a almacenar y la [clave del objeto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html). El nodo devuelve el URI de la ubicación de S3 como salida.

A continuación se muestra la estructura general de un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objeto de almacenamiento de 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"
                }
            }
        }
    }
}
```

### Nodo de recuperación de S3
<a name="flows-nodes-retrieval"></a>

Un nodo de recuperación de S3 le permite recuperar datos de una ubicación de Amazon S3 para introducirlos en el flujo. En la configuración, debe especificar el bucket de S3 desde el que se van a recuperar los datos. La entrada en el nodo es la [clave del objeto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html). El nodo devuelve el contenido de la ubicación de S3 como salida.

**nota**  
En la actualidad, los datos de la ubicación de S3 deben estar codificados en UTF-8.

A continuación se muestra la estructura general de un objeto de recuperación [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)de S3:

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

### Nodo de la función de Lambda
<a name="flows-nodes-lambda"></a>

Un nodo de función de Lambda le permite llamar a una función de Lambda en la que puede definir código para llevar a cabo la lógica empresarial. Cuando incluye un nodo de Lambda en un flujo, Amazon Bedrock envía un evento de entrada a la función de Lambda que especifique.

En la configuración, especifique el nombre de recurso de Amazon (ARN) de la función de Lambda. Defina las entradas a enviar en el evento de entrada de Lambda. Puede escribir código en función de estas entradas y definir lo que devuelve la función. La respuesta de la función se devuelve como en la salida.

A continuación se muestra la estructura general de un objeto de función [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 de Lambda para un flujo
<a name="flows-nodes-lambda-input"></a>

El evento de entrada enviado a una función de Lambda en un nodo de Lambda tiene el siguiente formato:

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

Los campos de cada entrada coinciden con los campos que especifique al definir el nodo de Lambda, mientras que el valor del campo `value` se rellena con la entrada completa del nodo una vez resuelto por la expresión. Por ejemplo, si la entrada completa del nodo es `[1, 2, 3]` y la expresión es `$.data[1]`, el valor enviado en el evento de entrada a la función de Lambda sería `2`.

Para obtener más información sobre los eventos en Lambda, consulte los [conceptos de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-event) en la [Guía para desarrolladores de AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/).

#### Respuesta de Lambda para un flujo
<a name="flows-nodes-lambda-response"></a>

Cuando se escribe una función de Lambda, usted define la respuesta que va a devolver. Esta respuesta se devuelve al flujo como la salida del nodo de Lambda.

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

Un nodo de código insertado le permite escribir y ejecutar código directamente en el flujo, lo que permite transformaciones de datos, lógica personalizada e integraciones sin utilizar una función de Lambda externa. Cuando incluye un nodo de código en línea en su flujo, Amazon Bedrock ejecuta el código en un entorno AWS gestionado y aislado que no se comparte con nadie y que no tiene acceso a Internet.

**nota**  
La característica de nodo de código insertado está en versión preliminar para Amazon Bedrock y está sujeta a cambios.

En la configuración del nodo, especifique el código que se va a ejecutar junto con el lenguaje de programación (actualmente, `Python_3` es la única opción). Defina las entradas a las que puede acceder el código como variables. El resultado de la última línea ejecutada en el código se devuelve como la salida del nodo.

El siguiente ejemplo muestra la estructura general de un objeto de código en línea: [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"
        }
    }
}
```

#### Consideraciones sobre el uso de nodos de código insertado
<a name="flows-nodes-inline-code-usage"></a>

Cuando utilice nodos de código insertado en su flujo, tenga en cuenta lo siguiente:

**importante**  
Le recomendamos que pruebe el código antes de añadirlo a un nodo de código insertado.
+ Los nodos de código insertado no se admiten en la [ejecución de flujos asíncronos](flows-create-async.md).
+ Actualmente, el único lenguaje de programación compatible con los nodos de código insertado es Python 3.12 (`Python_3)`.
+ El código insertado actúa como una sesión interactiva de Python. Solo se captura el resultado de la última línea ejecutada y se devuelve como salida del nodo.
+ La salida de la consola de Python (como la salida de la función `print`) no se captura.
+ Las entradas para el nodo de código insertado están disponibles como variables de Python en el código. Use el nombre exacto de la entrada del nodo para hacer referencia a ellos.
+ Configure los tipos de entrada y salida correctamente para evitar errores en tiempo de ejecución. Puede configurar hasta cinco entradas de nodo.
+ Puede tener hasta cinco nodos de código insertados por flujo.
+ Puede tener un máximo de 25 nodos de código insertados en ejecución por Cuenta de AWS.
+ El código no puede superar los 5 MB.

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

Las entradas que define para un nodo de código insertado están disponibles como variables de Python en el código. Por ejemplo, si define una entrada llamada `userData`, puede acceder a ella directamente en su código como `userData`.

El valor de cada entrada se rellena en función de la expresión que defina. Por ejemplo, si la entrada al nodo fuera `{"name": "John", "age": 30}` y la expresión fuera `$.name`, el valor de la variable de entrada sería `"John"`.

#### Salida del nodo de código insertado
<a name="flows-nodes-inline-code-output"></a>

El resultado de la última línea ejecutada en el código se devuelve como la salida del nodo de código insertado. Esta salida está disponible para los nodos siguientes del flujo.

Por ejemplo, el código siguiente devuelve un diccionario como la salida del nodo:

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

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

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

**nota**  
El nodo Lex se basa en el servicio Amazon Lex, que puede almacenar y utilizar el contenido del cliente para el desarrollo y la mejora continua de otros AWS servicios. Como AWS cliente, puede optar por que su contenido no se almacene o se utilice para mejorar el servicio. Para obtener más información sobre cómo implementar una política de exclusión para Amazon Lex, consulte [Políticas de exclusión de servicios de IA](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html).

Un nodo de Lex le permite llamar a un bot de Amazon Lex para procesar un enunciado mediante el procesamiento del lenguaje natural e identificar una intención, en función de la definición del bot. Para obtener más información, consulte la [Guía para desarrolladores de Amazon Lex](https://docs.aws.amazon.com/lex/latest/dg/).

En la configuración, especifique el nombre de recurso de Amazon (ARN) del alias del bot y la configuración regional que se usarán. Las entradas en el nodo son el enunciado y cualquier [atributo de solicitud](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-request-attribs.html) o [atributo de sesión](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-request-attribs.html) que lo acompañe. El nodo devuelve la intención identificada como salida.

**nota**  
En la actualidad, el nodo de Lex no admite conversaciones de varios turnos. Un nodo de Lex solo puede procesar un enunciado.

A continuación se muestra la estructura general de un [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"
        }
    }
}
```

## Tablas de resumen de los tipos de nodo
<a name="flows-nodes-summary-table"></a>

En las siguientes tablas se resumen las entradas y salidas permitidas para cada tipo de nodo. Tenga en cuenta lo siguiente:
+ Si un nombre está marcado como **Cualquiera**, puede proporcionar cualquier cadena como nombre. De lo contrario, tendrá que usar el valor especificado en la tabla.
+ Si un tipo está marcado como **Cualquiera**, puede especificar cualquiera de los siguientes tipos de dato: cadena, número, booleano, objeto o matriz. De lo contrario, tendrá que usar el tipo especificado en la tabla.
+ Puede definir varias entradas para los nodos de **condición**, **petición**, **función de Lambda** y **código insertado**.


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


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