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.
# Cree un flujo de trabajo de IA end-to-end generativo con Amazon Bedrock Flows
Amazon Bedrock Flows le ofrece la posibilidad de utilizar modelos básicos compatibles (FMs) para crear flujos de trabajo mediante la vinculación de solicitudes, modelos fundamentales y otros AWS servicios para crear soluciones. end-to-end
Con los flujos, puede crear rápidamente flujos de trabajo de IA generativos complejos mediante un generador visual, integrarlos fácilmente con las ofertas de Amazon Bedrock FMs, como las bases de conocimiento y otros AWS servicios, por ejemplo, AWS Lambda mediante la transferencia de datos entre ellos, e implementar flujos de trabajo inmutables para pasar de las pruebas a la producción con unos pocos clics.
Consulte los siguientes recursos para obtener más información sobre Flujos de Amazon Bedrock:
+ El precio de Flujos de Amazon Bedrock depende de los recursos que utilice. Por ejemplo, si invoca un flujo con un nodo de solicitud que usa un modelo Amazon Titan, se le cobrará por invocar ese modelo. Para obtener más información, consulte [Precios de Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/).
+ Para ver las cuotas de los flujos, consulte [Puntos de conexión y cuotas de Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html) en la Referencia general de AWS.
A continuación, se muestran algunos ejemplos de tareas para las que puede crear un flujo en Amazon Bedrock:
+ **Crear y enviar una invitación por correo electrónico**: cree un flujo que conecte un nodo de petición, un nodo de base de conocimiento y un nodo de función de Lambda. Proporcione la siguiente petición para generar el cuerpo de un correo electrónico: **Send invite to John Smith’s extended team for in-person documentation read for an hour at 2PM EST next Tuesday**. Tras procesar la petición, el flujo consulta una base de conocimiento para buscar las direcciones de correo electrónico del equipo ampliado de John Smith y, a continuación, envía la entrada a una función de Lambda para enviar la invitación a todos los miembros del equipo de la lista.
+ **Solucionar los problemas utilizando el mensaje de error y el ID del recurso que está causando el error**: el flujo busca las posibles causas del error en una base de conocimiento de documentación, extrae los registros del sistema y otra información pertinente sobre el recurso y actualiza las configuraciones y valores defectuosos del recurso.
+ **Generar informes**: cree un flujo para generar métricas para los principales productos. El flujo busca las métricas de ventas en una base de datos, las agrega, genera un informe resumido de las principales compras de productos y publica el informe en el portal especificado.
+ **Ingerir datos de un conjunto de datos específico**: proporcione una petición como la siguiente: **Start ingesting new datasets added after 3/31 and report failures**. El flujo comienza a preparar los datos para la ingesta y sigue informando sobre el estado. Una vez finalizada la preparación de los datos, el flujo inicia el proceso de ingesta filtrando los datos que han producido un error. Una vez completada la ingesta de datos, el flujo resume los errores y publica un informe de errores.
Flows for Amazon Bedrock le permite vincular fácilmente los modelos básicos (FMs), las solicitudes y otros AWS servicios para crear, probar y ejecutar sus flujos rápidamente. Puede gestionar los flujos mediante el generador visual de la consola de Amazon Bedrock o mediante el APIs.
Los pasos generales para crear, probar e implementar un flujo son los siguientes:
**Creación del flujo:**
1. Especifique un nombre para el flujo, una descripción y los permisos de IAM correspondientes.
1. Diseñe el flujo decidiendo qué nodos desea utilizar.
1. Cree o defina todos los recursos que necesita para cada nodo. Por ejemplo, si planea usar una AWS Lambda función, defina las funciones que necesita para que el nodo complete su tarea.
1. Añada nodos al flujo, configúrelos y cree conexiones entre los nodos enlazando la salida de un nodo con la entrada de otro nodo del flujo.
**Prueba del flujo:**
1. Prepare el flujo para que los cambios más recientes se apliquen al *borrador de trabajo* del flujo, que es una versión del flujo que puede utilizar para probar y actualizar de forma iterativa el flujo.
1. Pruebe el flujo invocándolo con entradas de ejemplo para ver las salidas que produce.
1. Cuando la configuración de un flujo le parezca adecuada, puede crear una instantánea del mismo publicando una *versión*. La versión conserva la definición del flujo tal como estaba en el momento de la creación. Las versiones son inmutables porque actúan como una instantánea del flujo en el momento en que se ha creado.
**Implementación del flujo:**
1. Cree un alias que apunte a la versión del flujo que desee utilizar en la aplicación.
1. Configure la aplicación para realizar solicitudes `InvokeFlow` al alias. Si necesita volver a una versión anterior o actualizar por una más reciente, puede cambiar la configuración de enrutamiento del alias.
**Topics**
+ [Funcionamiento de Flujos de Amazon Bedrock](flows-how-it-works.md)
+ [Regiones y modelos que admiten flujos](flows-supported.md)
+ [Requisitos previos de Flujos de Amazon Bedrock](flows-prereq.md)
+ [Creación y diseño de un flujo en Amazon Bedrock](flows-create.md)
+ [Consulta de información sobre los flujos en Amazon Bedrock](flows-view.md)
+ [Modificación de un flujo de Amazon Bedrock](flows-modify.md)
+ [Inclusión de barreras de protección en su flujo de Amazon Bedrock](flows-guardrails.md)
+ [Prueba de un flujo en Amazon Bedrock](flows-test.md)
+ [Ejecución de flujos de Amazon Bedrock de forma asincrónica](flows-create-async.md)
+ [Implementación de un flujo en la aplicación mediante versiones y alias](flows-deploy.md)
+ [Invocar una AWS Lambda función de un flujo de Amazon Bedrock en una cuenta diferente AWS](flow-cross-account-lambda.md)
+ [Conversación con un flujo de Amazon Bedrock](flows-multi-turn-invocation.md)
+ [Ejecución de ejemplos de código de Flujos de Amazon Bedrock](flows-code-ex.md)
+ [Eliminación de un flujo en Amazon Bedrock](flows-delete.md)
# Funcionamiento de Flujos de Amazon Bedrock
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
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
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
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
Utilice los siguientes tipos de nodo para controlar la lógica del flujo.
### Nodo de entrada de flujo
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
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
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
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
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
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
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
Utilice los siguientes tipos de nodos para gestionar los datos del flujo:
### Nodo de solicitud
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
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
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
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
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
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
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
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
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
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
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
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
**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
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**
[\[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**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/flows-nodes.html)
# Regiones y modelos que admiten flujos
Amazon Bedrock Flows es compatible con lo siguiente: Regiones de AWS
+ ap-northeast-1
+ ap-northeast-2
+ ap-northeast-3
+ ap-south-1
+ ap-south-2
+ ap-southeast-1
+ ap-southeast-2
+ ca-central-1
+ eu-central-1
+ eu-central-2
+ eu-north-1
+ eu-south-1
+ eu-south-2
+ eu-west-1
+ eu-west-2
+ eu-west-3
+ sa-east-1
+ us-east-1
+ us-east-2
+ us-gov-east-1
+ us-gov-west-1
+ us-west-2
Los modelos que se admiten en Flujos de Amazon Bedrock dependen de los nodos que utilice en el flujo:
+ Nodo de petición: puede utilizar la administración de peticiones con cualquier modelo de texto compatible con la API de [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html). Para obtener una lista de los modelos admitidos, consulte [Modelos y características del modelo compatibles](conversation-inference-supported-models-features.md).
+ Nodo de agente: para obtener una lista de los modelos admitidos, consulte [Regiones compatibles para Agentes para Amazon Bedrock](agents-supported.md).
+ Nodo de base de conocimientos: para obtener una lista de los modelos admitidos, consulte [Modelos y regiones admitidos para las bases de conocimiento de Amazon Bedrock](knowledge-base-supported.md).
Para ver una tabla de los modelos compatibles en cada región, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
# Requisitos previos de Flujos de Amazon Bedrock
Antes de crear un flujo, revise los siguientes requisitos previos y determine cuáles debe cumplir:
1. Definir o crear recursos para uno o más nodos que tiene previsto agregar al flujo:
+ Para un nodo de petición: cree una petición con la administración de peticiones. 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). Si va a definir las peticiones en línea al crear el nodo en el flujo, no tiene que crear una petición en la administración de peticiones.
+ Para un nodo de base de conocimiento: cree una base de conocimiento que vaya a utilizar en el flujo. 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).
+ Para un nodo de agente: cree un agente que vaya a utilizar en el flujo. Para obtener más información, consulte [Automatización de las tareas en la aplicación mediante agentes de IA](agents.md).
+ Para un nodo de almacenamiento de S3: cree un bucket de S3 para almacenar una salida de un nodo del flujo.
+ Para un nodo de recuperación de S3: cree un objeto de S3 en un bucket desde el que recuperar datos para el flujo. El objeto S3 debe ser una cadena codificada en UTF-8.
+ Para un nodo Lambda: defina una AWS Lambda función para la lógica empresarial que planea implementar en el flujo. Para obtener más información, consulte la [Guía para desarrolladores de AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/).
+ Para un nodo de Amazon Lex: cree un bot de Amazon Lex para identificar las intenciones. Para obtener más información, consulte la [Guía para desarrolladores de Amazon Lex](https://docs.aws.amazon.com/lex/latest/dg/).
1. Para utilizar flujos, debe tener dos roles distintos:
1. **Función de usuario**: la función de IAM que utilice para iniciar sesión Consola de administración de AWS o realizar llamadas a la API debe tener permisos para llevar a cabo acciones relacionadas con los flujos.
Si tu rol tiene la [AmazonBedrockFullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonBedrockFullAccess)política adjunta, no necesitas configurar permisos adicionales para este rol. Para restringir los permisos de un rol a únicamente las acciones que se utilizan para los flujos, asocie la siguiente política basada en identidades a un rol de IAM:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "FlowPermissions",
"Effect": "Allow",
"Action": [
"bedrock:CreateFlow",
"bedrock:UpdateFlow",
"bedrock:GetFlow",
"bedrock:ListFlows",
"bedrock:DeleteFlow",
"bedrock:ValidateFlowDefinition",
"bedrock:CreateFlowVersion",
"bedrock:GetFlowVersion",
"bedrock:ListFlowVersions",
"bedrock:DeleteFlowVersion",
"bedrock:CreateFlowAlias",
"bedrock:UpdateFlowAlias",
"bedrock:GetFlowAlias",
"bedrock:ListFlowAliases",
"bedrock:DeleteFlowAlias",
"bedrock:InvokeFlow",
"bedrock:TagResource",
"bedrock:UntagResource",
"bedrock:ListTagsForResource"
],
"Resource": "*"
}
]
}
```
------
Puede restringir aún más los permisos omitiendo [acciones](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-actions) o especificando [recursos](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-resources) y [claves de condición](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-conditionkeys). Una identidad de IAM puede llamar a las operaciones de la API en recursos específicos. Si especifica una operación de la API que no se puede utilizar en el recurso especificado en la política, Amazon Bedrock devuelve un error.
1. **Rol de servicio**: un rol que permite a Amazon Bedrock realizar acciones en su nombre. Debe especificar este rol al crear o actualizar un flujo. Puede crear un [[rol de servicio](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-role) de AWS Identity and Access Management personalizado](flows-permissions.md).
**nota**
Si planea usar la consola de Amazon Bedrock para crear automáticamente un rol al crear un flujo, no es necesario configurar este rol manualmente.
# Creación y diseño de un flujo en Amazon Bedrock
En esta sección, aprenderá a crear y diseñar flujos con la consola de Amazon Bedrock. Para ayudarle a empezar, los flujos que cree con la consola están configurados para ejecutarse con un único nodo de petición. En esta sección también se incluyen más ejemplos y plantillas para crear distintos tipos de flujos.
Si quiere usar el SDK de AWS para crear un flujo, consulte [Ejecución de ejemplos de código de Flujos de Amazon Bedrock](flows-code-ex.md).
**Topics**
+ [Creación de su primer flujo en Amazon Bedrock](flows-get-started.md)
+ [Diseño de un flujo en Amazon Bedrock](flows-design.md)
+ [Prueba de flujos de ejemplo](flows-ex.md)
+ [Uso de una plantilla para crear un flujo de Amazon Bedrock](flows-templates.md)
# Creación de su primer flujo en Amazon Bedrock
Siempre que crea un flujo, la consola de Amazon Bedrock crea un flujo de inicio para usted. El flujo incluye un nodo **Entrada de flujo**, un nodo **Petición** y un nodo **Salida de flujo**. Al ejecutar el flujo, deberá introducir un tema para el flujo que utiliza el nodo de petición para resumir el tema. Para poder ejecutar los flujos, debe definir el modelo para la petición.
Para crear un flujo, debe proporcionar un nombre y una descripción del flujo. De forma predeterminada, Amazon Bedrock crea un rol de servicio con los permisos adecuados. También puede especificar un rol de servicio existente.
Amazon Bedrock siempre cifra sus datos en reposo. De forma predeterminada, Amazon Bedrock cifra estos datos mediante una clave administrada de AWS. Si lo desea, puede cifrar los datos de ejecución del flujo mediante una clave administrada por el cliente. Para obtener más información, consulte [Cifrado de los recursos de Flujos de Amazon Bedrock](encryption-flows.md).
Una vez que haya terminado con el flujo de inicio, o si no lo necesita, puede continuar creando su flujo. Le recomendamos que lea [Funcionamiento de Flujos de Amazon Bedrock](flows-how-it-works.md) para familiarizarse con los conceptos y términos de los flujos de Amazon Bedrock y para obtener información sobre los tipos de nodos que están disponibles. Para obtener más información, consulte [Diseño de un flujo en Amazon Bedrock](flows-design.md).
**Cómo crear su primer flujo**
1. Inicie sesión en la Consola de administración de AWS con una identidad de IAM que tenga permisos para usar la consola de Amazon Bedrock. A continuación, abra la consola de Amazon Bedrock en [https://console.aws.amazon.com/bedrock/](https://console.aws.amazon.com/bedrock).
1. Seleccione **Flujos de Amazon Bedrock** en el panel de navegación de la izquierda.
1. En la sección **Flujos de Amazon Bedrock**, seleccione **Crear flujo**.
1. Indique un **Nombre** para el flujo y, opcionalmente, una **Descripción**.
1. En **Nombre del rol de servicio**, elija una de las siguientes opciones:
+ **Crear y usar un nuevo rol de servicio**: deje que Amazon Bedrock cree un rol de servicio para usted.
+ **Usar un rol de servicio existente**: seleccione un rol de servicio personalizado que haya configurado previamente. Para obtener más información, consulte [Creación de un rol de servicio para Flujos de Amazon Bedrock en Amazon Bedrock](flows-permissions.md).
1. (Opcional) Cifre su flujo con una clave administrada por el cliente de la siguiente manera:
1. Seleccione **Configuraciones adicionales**.
1. En **Selección de clave de KMS**, seleccione **Personalizar la configuración de cifrado (avanzado)**. A continuación, realice una de las operaciones siguientes en **Elegir una clave de AWS KMS**:
+ Para utilizar una clave existente, introduzca el ARN o busque la clave que desee utilizar.
+ Para crear una clave nueva, elija **Crear una clave de AWS KMS** para abrir la consola de AWS Key Management Service y [cree la clave](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html). Cuando cree la clave, anote el ARN de la clave. De vuelta en la consola de Amazon Bedrock, introduzca el ARN de la clave en **Elegir una clave de AWS KMS**.
Para obtener más información, consulte [Cifrado de los recursos de Flujos de Amazon Bedrock](encryption-flows.md)
1. Seleccione **Crear**. Amazon Bedrock crea el flujo de inicio y lo dirige al **generador de flujos**.
1. En la sección **Generador de flujos**, el panel central (el lienzo) muestra un nodo **Entrada de flujo**, un nodo **Petición** y un nodo **Salida de flujo**. Los nodos ya están conectados entre sí.
1. En el lienzo, seleccione el nodo **petición**.
1. En el panel del generador de flujos, seleccione la sección **Configuraciones**.
1. En **Nombre del nodo**, asegúrese de que esté seleccionada la opción **Definir en nodo**.
1. En **Seleccionar un modelo**, seleccione el modelo que desea usar.
1. Seleccione **Guardar** para guardar el flujo.
1. En el panel **Probar flujo** de la derecha, introduzca un tema para que el flujo lo resuma.
1. Seleccione **Ejecutar** para ejecutar el flujo. El flujo muestra el tema resumido.
# Diseño de un flujo en Amazon Bedrock
En esta sección, diseñará un flujo de Amazon Bedrock. Antes de diseñar un flujo, le recomendamos que lea [Funcionamiento de Flujos de Amazon Bedrock](flows-how-it-works.md) para familiarizarse con los conceptos y términos de Flujos de Amazon Bedrock y para obtener información sobre los tipos de nodos que están disponibles. Para ver ejemplos de flujos que puede probar, consulte [Prueba de flujos de ejemplo](flows-ex.md).
**Creación del flujo**
1. Si aún no se encuentra en el **generador de flujos**, haga lo siguiente:
1. Inicie sesión en la Consola de administración de AWS con una identidad de IAM que tenga permisos para usar la consola de Amazon Bedrock. A continuación, abra la consola de Amazon Bedrock en [https://console.aws.amazon.com/bedrock/](https://console.aws.amazon.com/bedrock).
1. Seleccione **Flujos de Amazon Bedrock** en el panel de navegación de la izquierda. A continuación, elija un flujo en la sección **Flujos de Amazon Bedrock**.
1. Seleccione **Editar en generador de flujos**.
1. En la sección **Generador de flujos**, el panel central muestra un nodo **Entrada de flujo** y un nodo **Salida de flujo**. Estos son los nodos de entrada y salida de su flujo.
1. Haga lo siguiente para añadir y configurar nodos:
1. En el panel **Generador de flujos**, seleccione **Nodos**.
1. Arrastre el nodo que desee usar para el primer paso del flujo y colóquelo en el panel central.
1. Los círculos en los nodos son puntos de conexión. Para conectar el nodo de entrada de flujo al segundo nodo, arrastre una línea desde el círculo del nodo **Entrada de flujo** hasta el círculo de la sección **Entrada** del nodo que acaba de añadir.
1. Seleccione el nodo que acaba de añadir.
1. En la sección **Configurar** del panel **Generador de flujos**, proporcione las configuraciones del nodo seleccionado y defina los nombres, los tipos de datos y las expresiones para las entradas y salidas del nodo.
1. En el panel **Generador de flujos**, seleccione **Nodos**.
1. Repita los pasos para agregar y configurar los nodos restantes del flujo.
**nota**
Si utiliza un rol de servicio que Amazon Bedrock haya creado automáticamente para usted, el rol se actualizará con los permisos adecuados a medida que añada nodos. Sin embargo, si utiliza un rol de servicio personalizado, debe agregar los permisos adecuados a la política asociada al rol de servicio consultando [Creación de un rol de servicio para Flujos de Amazon Bedrock en Amazon Bedrock](flows-permissions.md).
1. Conecte la **Salida** del último nodo del flujo con la **Entrada** del nodo **Salida del flujo**. Puede tener varios nodos **Salida de flujo**. Para añadir nodos de salida de flujo adicionales, arrastre el nodo **Salida de flujo** y suéltelo junto al nodo en el que desee que se detenga el flujo. Asegúrese de establecer conexiones entre los dos nodos.
1. Continúe con el siguiente procedimiento para [Prueba de un flujo en Amazon Bedrock](flows-test.md) o regrese a él más tarde. Elija **Guardar** para continuar con el siguiente paso. Para volver más tarde, seleccione **Guardar y salir**.
**Eliminación de un nodo o una conexión**
Durante el proceso de creación del flujo, es posible que tenga que eliminar un nodo o las conexiones de los nodos.
**Eliminación de un nodo**
1. Seleccione el nodo que desee eliminar.
1. En el panel **Generador de flujos**, seleccione el icono de eliminación (![\[Trapezoid-shaped diagram showing data flow from source to destination through AWS Transfer Family.\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/icons/trash.png)).
**nota**
Si utiliza un rol de servicio que Amazon Bedrock haya creado automáticamente para usted, el rol se actualizará con los permisos adecuados a medida que añada nodos. Sin embargo, si elimina nodos, no se eliminarán los permisos correspondientes. Le recomendamos que elimine los permisos que ya no necesite. Para ello, siga los pasos que se indican en [Modificación de un rol](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_modify.html).
**Eliminación de etiquetas de una conexión**
+ En la página **Generador de flujos**, coloque el cursor sobre la conexión que desea eliminar hasta que aparezca el icono de expansión y, a continuación, arrastre la conexión para separarla del nodo.
A la hora de crear un flujo se aplican los siguientes requisitos:
+ El flujo debe tener solo un nodo de entrada de flujo y al menos un nodo de salida de flujo.
+ No puede incluir las entradas de un nodo de entrada de flujo.
+ No puede incluir las salidas de un nodo de salida de flujo.
+ Cada salida de un nodo debe estar conectada a una entrada de un nodo descendente (en la API, esto se hace a través de una [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html) con una [FlowDataConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowDataConnectionConfiguration.html)).
+ Cada condición (incluida la predeterminada) de un nodo de condición debe estar conectada a un nodo descendente (en la API, esto se hace a través de una [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html) con una [FlowConditionalConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConditionalConnectionConfiguration.html)).
A la hora de crear un flujo se deben cumplir los siguientes requisitos:
+ Primero debe configurar el tipo de datos para la salida del nodo de entrada de flujo. Este tipo de datos debe coincidir con lo que espera enviar como entrada al invocar el flujo.
+ Cuando defina las entradas de un flujo mediante expresiones, compruebe que el resultado coincide con el tipo de datos que ha elegido para la entrada.
+ Si incluye un nodo iterador, incluya un nodo recopilador descendente después de enviar la salida a través de los nodos que necesite. El nodo recopilador devolverá las salidas de una matriz.
# Prueba de flujos de ejemplo
En este tema se proporcionan algunos ejemplos de flujos que puede probar para empezar a utilizar Flujos de Amazon Bedrock. También puede usar plantillas para crear un flujo inicial. Para obtener más información, consulte [Uso de una plantilla para crear un flujo de Amazon Bedrock](flows-templates.md).
Expanda un ejemplo para ver cómo crearlo en la consola de Amazon Bedrock:
**Topics**
+ [Creación de un flujo con una sola petición](flows-ex-prompt.md)
+ [Creación de un flujo con un nodo de condición](flows-ex-condition.md)
# Creación de un flujo con una sola petición
La siguiente imagen muestra un flujo que consiste en una única petición, definida como insertada en el nodo. La petición genera una lista de reproducción de canciones a partir de una entrada de objeto JSON que incluye el género y el número de canciones que se van a incluir en la lista de reproducción.
![\[Ejemplo del uso de un nodo de petición con dos variables.\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/flows/flows-prompt.png)
**Generación y prueba de este flujo en la consola**
1. Para crear un flujo, siga las instrucciones de [Creación de su primer flujo en Amazon Bedrock](flows-get-started.md).
1. Para configurar el nodo de petición, haga lo siguiente:
1. Seleccione el nodo **Petición** del panel central.
1. Seleccione la pestaña **Configurar** en el panel **Generador de flujos**.
1. Introduzca **MakePlaylist** en el campo **Nombre de nodo**.
1. Seleccione **Definir en el nodo**.
1. Configure las siguientes configuraciones para la petición:
1. En **Seleccionar el modelo**, seleccione un modelo para ejecutar la inferencia en la petición.
1. En el cuadro de texto **Mensaje**, indique **Make me a \$1\$1genre\$1\$1 playlist consisting of the following number of songs: \$1\$1number\$1\$1.**. Esto crea dos variables que aparecerán como entradas en el nodo.
1. (Opcional) Modifique las **Configuraciones de inferencia**.
1. (Opcional) Si el modelo lo admite, puede configurar el **almacenamiento en caché** de peticiones para el mensaje de la petición. Para obtener más información, consulte [Creación y diseño de un flujo en Amazon Bedrock](flows-create.md).
1. Expanda la sección **Entradas**. Los nombres de las entradas se rellenan previamente con las variables del mensaje de la petición. Configure las entradas del siguiente modo:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/flows-ex-prompt.html)
Esta configuración significa que el nodo de petición espera un objeto JSON que contenga un campo denominado `genre` que se asigne a la entrada de `genre` y un campo denominado `number` que se asigne a la entrada de `number`.
1. No puede modificar la **Salida**. Será la respuesta del modelo, que se devuelve en forma de cadena.
1. Elija el nodo **Entrada de flujo** y seleccione la pestaña **Configurar**. Para **Objeto**, seleccione **Tipo**. Esto significa que la invocación del flujo esperará recibir un objeto JSON.
1. Para completar el flujo, conecte los nodos de la siguiente manera:
1. Arrastre una conexión desde el nodo de salida del nodo de **Entrada de flujo** hasta la entrada de **género** en el nodo de petición **MakePlaylist**.
1. Arrastre una conexión desde el nodo de salida del nodo de **Entrada de flujo** hasta la entrada de **número** en el nodo de petición **MakePlaylist**.
1. Arrastre una conexión desde el nodo de salida de la salida **modelCompletion** del nodo de petición **MakePlaylist** a la entrada **document** del nodo **Salida de flujo**.
1. Seleccione **Guardar** para guardar el flujo. El flujo ahora debería estar preparado para realizar pruebas.
1. Pruebe el flujo especificando el siguiente objeto JSON en el panel **Probar flujo** de la derecha. Seleccione **Ejecutar**. El flujo debería devolver una respuesta del modelo.
```
{
"genre": "pop",
"number": 3
}
```
# Creación de un flujo con un nodo de condición
La siguiente imagen muestra un flujo con un nodo de condición que devuelve uno de los tres valores posibles en función de la condición que se cumpla:
![\[Ejemplo del uso de un nodo de condición con dos condiciones.\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/flows/flows-condition.png)
**Generación y prueba de este flujo en la consola:**
1. Para crear un flujo, siga las instrucciones de [Creación de su primer flujo en Amazon Bedrock](flows-get-started.md).
1. Elimine el nodo **Petición** del panel central.
1. Para configurar el nodo de condición, haga lo siguiente:
1. En el panel de la izquierda **Generador de flujos**, seleccione **Nodos**.
1. Arrastre un nodo de **Condición** al flujo en el panel central.
1. Seleccione la pestaña **Configurar** en el panel **Generador de flujos**.
1. Expanda la sección **Entradas**. Configure las entradas del siguiente modo:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/flows-ex-condition.html)
Esta configuración significa que el nodo de condición espera un objeto JSON que contenga los campos `retailPrice`, `marketPrice` y `type`.
1. Para configurar las condiciones, haga lo siguiente:
1. En la sección **Condiciones**, puede cambiar el nombre de la condición. A continuación, añada la siguiente condición en el cuadro de texto **Condición**: **(retailPrice > 10) and (type == "produce")**.
1. Puede agregar otra condición en **Agregar una condición**. También puede cambiar el nombre de la segunda condición. A continuación, añada la siguiente condición en el cuadro de texto **Condición**: **(retailPrice < marketPrice)**.
1. Elija el nodo **Entrada de flujo** y seleccione la pestaña **Configurar**. Para **Objeto**, seleccione **Tipo**. Esto significa que la invocación del flujo esperará recibir un objeto JSON.
1. Agregue nodos de salida de flujo para tener un total de tres. Configúrelos de la siguiente manera en la pestaña **Configurar** del panel **Generador de flujos** de cada nodo de salida del flujo:
1. Defina el tipo de entrada del primer nodo de salida del flujo como **String** y la expresión como **\$1.data.action[0]** para devolver el primer valor de la matriz en el campo `action` del objeto entrante.
1. Defina el tipo de entrada del segundo nodo de salida del flujo como **String** y la expresión como **\$1.data.action[1]** para devolver el segundo valor de la matriz en el campo `action` del objeto entrante.
1. Defina el tipo de entrada del tercer nodo de salida del flujo como **String** y la expresión como **\$1.data.action[2]** para devolver el tercer valor de la matriz en el campo `action` del objeto entrante.
1. Conecte la primera condición al primer nodo de salida de flujo, la segunda condición al segundo nodo de salida de flujo y la condición predeterminada al tercer nodo de salida de flujo.
1. Para completar el flujo, conecte las entradas y salidas de todos los nodos de la siguiente manera:
1. Arrastre una conexión desde el nodo de salida del nodo de **Entrada de flujo** hasta la entrada **retailPrice** del nodo de condición.
1. Arrastre una conexión desde el nodo de salida del nodo de **Entrada de flujo** hasta la entrada **marketPrice** del nodo de condición.
1. Arrastre una conexión desde el nodo de salida del nodo de **Entrada de flujo** hasta la entrada **type** del nodo de condición.
1. Arrastre una conexión desde la salida del nodo de **Entrada de flujo** hasta la entrada del **documento** en cada uno de los tres nodos de salida.
1. Seleccione **Guardar** para guardar el flujo. El flujo ahora debería estar preparado para realizar pruebas.
1. Pruebe el flujo especificando los siguientes objetos JSON en el panel **Probar flujo** de la derecha. Seleccione **Ejecutar** para cada entrada:
1. El siguiente objeto cumple la primera condición (el `retailPrice` es superior a 10 y `type` es “produce”) y devuelve el primer valor de `action` (“don't buy”):
```
{
"retailPrice": 11,
"marketPrice": 12,
"type": "produce",
"action": ["don't buy", "buy", "undecided"]
}
```
**nota**
Aunque se cumplan tanto la primera como la segunda condiciones, la primera tiene prioridad, ya que es la primera.
1. El siguiente objeto cumple la segunda condición (el `retailPrice` es inferior al `marketPrice`) y devuelve el segundo valor de `action` (“buy”):
```
{
"retailPrice": 11,
"marketPrice": 12,
"type": "meat",
"action": ["don't buy", "buy", "undecided"]
}
```
1. El siguiente objeto no cumple ni la primera condición (el `retailPrice` es superior a 10, pero `type` no es “produce”) ni la segunda condición (el `retailPrice` no es inferior al `marketPrice`), por lo que se devuelve el tercer valor de `action` (“undecided”):
```
{
"retailPrice": 11,
"marketPrice": 11,
"type": "meat",
"action": ["don't buy", "buy", "undecided"]
}
```
# Uso de una plantilla para crear un flujo de Amazon Bedrock
Para ayudarle a empezar a definir y orquestar Flujos de Amazon Bedrock, puede utilizar plantillas para crear flujos para una variedad de configuraciones de flujo. Por ejemplo, puede usar una plantilla para ver un flujo que incluya una base de conocimiento o un flujo que utilice condiciones para dirigir la lógica del flujo.
Puede acceder a las plantillas desde el repositorio de GitHub de [Ejemplos de Flujos de Amazon Bedrock](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file). La consola de Amazon Bedrock también proporciona un enlace al repositorio en la página de lienzo de un flujo.
Las plantillas de flujo se proporcionan como [plantillas JSON](https://github.com/aws-samples/amazon-bedrock-flows-samples/tree/main/templates) para cada definición de flujo compatible y como un script de Python que se utiliza para crear y ejecutar el flujo. También puede acceder al flujo desde la consola de Amazon Bedrock.
El repositorio proporciona las siguientes plantillas:
+ [Flujo de base de conocimiento](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#1-knowledgebase-flow-1): muestra cómo integrar y consultar una [base de conocimiento](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#1-knowledgebase-flow-1), incluidas RAG (Generación aumentada por recuperación) y la búsqueda y recuperación de bases de conocimiento.
+ [Flujo de agente de conversación de varios turnos](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#2-multi-turn-conversation-agent-flow-1): muestra cómo mantener conversaciones interactivas y detalladas con un flujo. Para obtener más información, consulte [Conversación con un flujo de Amazon Bedrock](flows-multi-turn-invocation.md).
+ [Flujo de condiciones](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#3-conditions-flow-1): muestra cómo realizar la lógica condicional y la ramificación dentro de un flujo.
+ [Flujo de nodo de petición con barrera de protección](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#4-prompt-node-with-guardrail-flow-1): muestra cómo proteger un nodo de petición con una barrera de protección.
+ [Flujo de iterador y recopilador](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#5-iterator--collector-flow-1): muestra cómo procesar varias entradas y agregar respuestas.
+ [Flujo de varios agentes](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#5-iterator--collector-flow-1): muestra flujos de trabajo basados en varios agentes, incluida la colaboración entre múltiples agentes y la delegación de tareas.
Para poder ejecutar el script, debe crear los recursos de Amazon Bedrock, como una base de conocimiento o un agente, que utiliza el flujo. Es responsabilidad suya eliminar estos recursos cuando ya no los necesite.
Para crear y ejecutar un flujo a partir de una plantilla, ejecute el script (`flow_manager.py`). El script solicita cualquier información adicional que necesite, como la plantilla de flujo que desea utilizar y los identificadores de los recursos que necesita la plantilla. Puede incluir una petición de prueba para probar el flujo.
Si lo desea, puede configurar la región de AWS en la que desea que se cree el flujo. El script crea los recursos necesarios con un conjunto predeterminado de [permisos de rol de IAM](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#iam-role-permissions). También puede elegir usar un rol de IAM que haya creado.
Si desea utilizar el flujo de la consola de Amazon Bedrock, no utilice el parámetro `--cleanup`, ya que elimina el flujo una vez que el script lo ejecuta. Si no usa `--cleanup`, tendrá que eliminar el flujo cuando ya no lo necesite.
Para obtener más información, consulte [https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file\$1how-to-use](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#how-to-use).
# Consulta de información sobre los flujos en Amazon Bedrock
Para saber cómo ver información sobre un flujo, seleccione la pestaña correspondiente al método que prefiera y siga los pasos:
------
#### [ Console ]
**Para consultar los detalles de un flujo**
1. Inicie sesión en la Consola de administración de AWS con una identidad de IAM que tenga permisos para usar la consola de Amazon Bedrock. A continuación, abra la consola de Amazon Bedrock en [https://console.aws.amazon.com/bedrock/](https://console.aws.amazon.com/bedrock).
1. Seleccione **Flujos de Amazon Bedrock** en el panel de navegación de la izquierda. A continuación, en la sección **Flujos de Amazon Bedrock**, seleccione un flujo.
1. Consulte los detalles del flujo en el panel **Detalles del flujo**.
------
#### [ API ]
Para obtener información sobre un flujo, envíe una solicitud [GetFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlow.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) y especifique el ARN o el ID del flujo como `flowIdentifier`.
Para mostrar información sobre los flujos, envíe una solicitud [ListFlows](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlows.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Puede especificar los siguientes parámetros opcionales:
****
| Campo | Descripción breve |
| --- | --- |
| maxResults | El número máximo de resultados que se devuelven en una respuesta. |
| nextToken | Si hay más resultados que el número que ha especificado en el campo maxResults, la respuesta devolverá un valor nextToken. Para ver el siguiente lote de resultados, envíe el valor nextToken en otra solicitud. |
------
# Modificación de un flujo de Amazon Bedrock
Para obtener información sobre cómo modificar un flujo, seleccione la pestaña correspondiente al método que prefiera y siga los pasos:
------
#### [ Console ]
**Cómo modificar los detalles de un flujo**
1. Inicie sesión en la Consola de administración de AWS con una identidad de IAM que tenga permisos para usar la consola de Amazon Bedrock. A continuación, abra la consola de Amazon Bedrock en [https://console.aws.amazon.com/bedrock/](https://console.aws.amazon.com/bedrock).
1. Seleccione **Flujos de Amazon Bedrock** en el panel de navegación de la izquierda. A continuación, en la sección **Flujos de Amazon Bedrock**, seleccione un flujo.
1. En la sección **Detalles del flujo**, elija **Editar**.
1. Puede editar el nombre y la descripción, y asociar un rol de servicio diferente al flujo.
1. Seleccione **Guardar cambios**.
**Cómo modificar un flujo**
1. Si aún no se encuentra en el **generador de flujos**, haga lo siguiente:
1. Inicie sesión en la Consola de administración de AWS con una identidad de IAM que tenga permisos para usar la consola de Amazon Bedrock. A continuación, abra la consola de Amazon Bedrock en [https://console.aws.amazon.com/bedrock/](https://console.aws.amazon.com/bedrock).
1. Seleccione **Flujos de Amazon Bedrock** en el panel de navegación de la izquierda. A continuación, elija un flujo en la sección **Flujos de Amazon Bedrock**.
1. Seleccione **Editar en generador de flujos**.
1. Añada, elimine y modifique nodos y conexiones según sea necesario. Para obtener más información, consulte [Creación y diseño de un flujo en Amazon Bedrock](flows-create.md) y [Tipos de nodos para el flujo](flows-nodes.md).
1. Cuando haya terminado de modificar el flujo, elija **Guardar** o **Guardar y salir**.
------
#### [ API ]
Para editar un flujo, envíe una solicitud [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Incluya tanto los campos que quiere mantener como los campos que quiere modificar. Para obtener más información sobre los campos de la solicitud, consulte [Creación y diseño de un flujo en Amazon Bedrock](flows-create.md).
------
# Inclusión de barreras de protección en su flujo de Amazon Bedrock
Flujos de Amazon Bedrock se integra con Barreras de protección para Amazon Bedrock para que pueda identificar y bloquear o filtrar el contenido no deseado de su flujo. Para obtener información sobre cómo aplicar barreras de protección a los tipos de nodos de un flujo, consulte la siguiente tabla:
****
| Tipo de nodo | Consola | API |
| --- | --- | --- |
| Nodo de petición | Al [crear](flows-create.md) o [actualizar](flows-modify.md) un flujo, seleccione el nodo de petición y especifique la barrera de protección en la sección Configurar. | Cuando defina el nodo de petición en el campo nodes de una solicitud [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html) o [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html), incluya un campo guardrailConfiguration en [PromptFlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PromptFlowNodeConfiguration.html). |
| Nodo de base de conocimientos | Al [crear](flows-create.md) o [actualizar](flows-modify.md) un flujo, seleccione el nodo de base de conocimiento y especifique la barrera de protección en la sección Configurar. Solo puede incluir una barrera de protección al generar respuestas en función de los resultados recuperados. | Cuando defina el nodo de base de conocimiento en el campo nodes de una solicitud [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html) o [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html), incluya un campo guardrailConfiguration en [KnowledgeBaseFlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_KnowledgeBaseFlowNodeConfiguration.html). Solo puede incluir una barrera de protección cuando utilice RetrieveAndGenerate, por lo que debe incluir un modelId. |
Para obtener más información acerca de las medidas de seguridad, consulte [Detección y filtrado del contenido dañino mediante Barreras de protección para Amazon Bedrock](guardrails.md).
Para obtener más información sobre los tipos de nodos, consulte [Tipos de nodos para el flujo](flows-nodes.md).
# Prueba de un flujo en Amazon Bedrock
Después de crear un flujo, dispondrá de un *borrador de trabajo*. El borrador de trabajo es una versión del flujo que puede utilizar para realizar compilaciones y pruebas de forma iterativa. Cada vez que realice cambios en el flujo, se actualizará el borrador de trabajo.
Después de probar el flujo, Amazon Bedrock primero verifica lo siguiente y lanza una excepción si dicha verificación falla:
+ la conectividad entre todos los nodos de flujo,
+ hay al menos un nodo de salida de flujo configurado,
+ los tipos de variables de entrada y salida coinciden según sea necesario,
+ las expresiones de condición son válidas y se proporciona un resultado predeterminado.
Si la verificación no se realiza correctamente, tendrá que corregir los errores antes de poder probar y validar el rendimiento del flujo. A continuación, se indican los pasos para probar un flujo. Seleccione la pestaña correspondiente al método que prefiera y siga los pasos:
------
#### [ Console ]
**Prueba del flujo**
1. Si aún no se encuentra en el **Generador de flujos**, haga lo siguiente:
1. Inicie sesión en la Consola de administración de AWS con una identidad de IAM que tenga permisos para usar la consola de Amazon Bedrock. A continuación, abra la consola de Amazon Bedrock en [https://console.aws.amazon.com/bedrock/](https://console.aws.amazon.com/bedrock).
1. Seleccione **Flujos de Amazon Bedrock** en el panel de navegación de la izquierda. A continuación, en la sección **Flujos de Amazon Bedrock**, seleccione el flujo que desee probar.
1. Seleccione **Editar en generador de flujos**.
1. En la **página Generador de flujos**, en el panel de la derecha, introduzca una entrada para invocar el flujo. Compruebe que el tipo de datos de entrada coincide con el tipo de datos de salida configurado para el nodo de entrada de flujo.
1. Seleccione **Ejecutar**.
1. Los nodos o conexiones de la configuración de flujo que desencadenan errores se resaltan en rojo y los que activan advertencias se resaltan en amarillo. Lea los mensajes de error y las advertencias, corrija los problemas identificados, guarde el flujo y vuelva a ejecutar la prueba.
**nota**
Debe guardar el flujo para que los cambios que haya realizado se apliquen al probar el flujo.
1. (Opcional) Para ver las entradas, las salidas y la duración de la ejecución de cada nodo, seleccione **Mostrar rastro** en la respuesta. Para obtener más información, consulte [Seguimiento de cada paso del flujo viendo su rastro en Amazon BedrockSeguimiento de cada paso del flujo viendo su rastro](flows-trace.md). Para volver al generador visual, seleccione **Ocultar rastro** o seleccione el icono para contraer.
1. Cuando el rendimiento del flujo le parezca adecuado, seleccione **Guardar y salir**.
1. Puede continuar con la iteración al crear el flujo. Cuando el flujo le parezca adecuado y quiera implementarlo en producción, cree una versión del flujo y un alias que apunte hacia la versión. Para obtener más información, consulte [Implementación de un flujo en la aplicación mediante versiones y alias](flows-deploy.md).
------
#### [ API ]
Para probar su flujo, envíe una solicitud [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html) con un [punto de conexión en tiempo de ejecución de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-rt). Incluya el ARN o el ID del flujo en el campo `flowIdentifier` y el ARN o el ID del alias que se va a usar en el campo `flowAliasIdentifier`.
Para ver las entradas y salidas de cada nodo, establezca el campo `enableTrace` en `TRUE`. Para obtener más información, consulte [Seguimiento de cada paso del flujo viendo su rastro en Amazon BedrockSeguimiento de cada paso del flujo viendo su rastro](flows-trace.md).
El cuerpo de la solicitud especifica la entrada del flujo y tiene el siguiente formato:
```
{
"inputs": [
{
"content": {
"document": "JSON-formatted string"
},
"nodeName": "string",
"nodeOutputName": "string"
}
],
"enableTrace": TRUE | FALSE
}
```
Proporcione la entrada en el campo `document`, indique un nombre para la entrada en el campo `nodeName` y proporcione un nombre para la entrada en el campo `nodeOutputName`.
La respuesta se devuelve en un flujo. Cada evento devuelto contiene la salida de un nodo en el campo `document`, el nodo que se ha procesado en el campo `nodeName` y el tipo de nodo del campo `nodeType`. Estos eventos tienen el siguiente formato:
```
{
"flowOutputEvent": {
"content": {
"document": "JSON-formatted string"
},
"nodeName": "string",
"nodeType": "string"
}
}
```
Si finaliza el flujo, también se devuelve un campo `flowCompletionEvent` con el `completionReason`. Si hay un error, se devuelve el campo de error correspondiente.
------
# Seguimiento de cada paso del flujo viendo su rastro en Amazon Bedrock
Cuando invoca un flujo, puede consultar el *rastro* para ver las entradas y salidas de cada nodo. El rastro le ayuda a rastrear la ruta desde la entrada hasta la respuesta que devuelve. Puede usar el rastro para solucionar los errores que se producen, identificar los pasos que conducen a un resultado inesperado o a un cuello de botella de rendimiento y considerar formas de mejorar el flujo.
Para consultar el rastro, haga lo siguiente:
+ En la consola, siga los pasos de la pestaña **Consola** en [Prueba de un flujo en Amazon Bedrock](flows-test.md) y seleccione **Mostrar rastro** en la respuesta de la invocación del flujo.
+ En la API, establezca el campo `enableTrace` en `true` en una solicitud [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html). Cada `flowOutputEvent` de la respuesta se devuelve junto con un `flowTraceEvent`.
Cada evento de rastreo incluye el nombre del nodo que recibió una entrada o produjo una salida y la fecha en que se procesó la entrada o la salida. Seleccione una pestaña para obtener más información sobre un tipo de evento de rastreo:
------
#### [ FlowTraceConditionNodeResultEvent ]
Este tipo de rastreo identifica qué condiciones se cumplen para un nodo de condición y le ayuda a identificar la rama o ramas del flujo que se activan durante la invocación. El siguiente objeto JSON muestra el aspecto de un [FlowTraceEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowTraceEvent.html) para el resultado de un nodo de condición:
```
{
"trace": {
"conditionNodeOutputTrace": {
"nodeName": "string",
"satisfiedConditions": [
{
"conditionName": "string"
},
...
],
"timestamp": timestamp
}
}
}
```
------
#### [ FlowTraceNodeInputEvent ]
Este tipo de rastreo muestra la entrada que se envió a un nodo. Si el destino del evento es un nodo iterador pero procede de un nodo recopilador, el campo `iterationIndex` indica el índice del elemento de la matriz del que proviene la entrada. El siguiente objeto JSON muestra el aspecto de un [FlowTraceEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowTraceEvent.html) para la entrada en un nodo.
```
{
"trace": {
"nodeInputTrace": {
"fields": [
{
"content": {
"document": JSON object
},
"nodeInputName": "string"
},
...
],
"nodeName": "string",
"timestamp": timestamp,
"iterationIndex": int
}
}
}
```
------
#### [ FlowTraceNodeOutputEvent ]
Este tipo de rastro muestra la salida producida por un nodo. Si el evento procede de un nodo iterador pero llega antes de un nodo recopilador, el campo `iterationIndex` indica el índice del elemento de la matriz del que proviene la salida. El siguiente objeto JSON muestra el aspecto de un [FlowTraceEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowTraceEvent.html) para la salida de un nodo.
```
{
"trace": {
"nodeOutputTrace": {
"fields": [
{
"content": {
"document": JSON object
},
"nodeOutputName": "string"
},
...
],
"nodeName": "string",
"timestamp": timestamp,
"iterationIndex": int
}
}
}
```
------
# Ejecución de flujos de Amazon Bedrock de forma asincrónica
Con las ejecuciones de flujos, puede ejecutar los flujos de Amazon Bedrock de forma asincrónica. Esto permite que los flujos se ejecuten durante más tiempo y, además, proporciona el control para que la aplicación pueda realizar otras tareas.
Cuando ejecuta un flujo mediante la consola Amazon Bedrock o con la [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html)operación, el flujo se ejecuta hasta que finaliza o se agota el tiempo de espera a una hora (lo que ocurra primero). Cuando realiza una ejecución de flujo, el flujo puede mantenerse activo durante mucho más tiempo: los nodos individuales pueden ejecutarse hasta cinco minutos y todo el flujo puede estar ejecutándose hasta 24 horas.
**nota**
La ejecución de flujos está en versión preliminar para Amazon Bedrock y está sujeta a cambios.
## Permisos necesarios para realizar ejecuciones de flujos
+ Asegúrese de que el rol de servicio de Amazon Bedrock tenga los permisos necesarios. Para obtener más información, consulte [Creación de un rol de servicio para Flujos de Amazon Bedrock en Amazon Bedrock](flows-permissions.md).
+ (Opcional) Cifre los datos de ejecución del flujo con una clave administrada AWS KMS por el cliente. Para obtener más información, consulte [Cifrado de los recursos de Flujos de Amazon Bedrock](encryption-flows.md).
## Creación y administración de una ejecución de flujo
Puede crear una ejecución de flujo en la consola o mediante la [StartFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_StartFlowExecution.html)operación.
------
#### [ Console ]
1. Para crear un flujo, siga las instrucciones de [Creación y diseño de un flujo en Amazon Bedrock](flows-create.md).
1. Cree un alias para el flujo siguiendo las instrucciones de [Creación de un alias de un flujo en Amazon Bedrock](flows-alias-create.md).
1. Si aún no se encuentra en el **Generador de flujos**, haga lo siguiente:
1. Inicie sesión Consola de administración de AWS con una identidad de IAM que tenga permisos para usar la consola Amazon Bedrock. A continuación, abra la consola de Amazon Bedrock en [https://console.aws.amazon.com/bedrock.](https://console.aws.amazon.com/bedrock)
1. Seleccione **Flujos de Amazon Bedrock** en el panel de navegación de la izquierda y, a continuación, elija su flujo.
1. Seleccione la pestaña **Ejecuciones** y, a continuación, seleccione **Crear ejecución**.
1. En el cuadro de diálogo **Crear ejecución**, introduzca lo siguiente:
1. En **Nombre**, introduzca un nombre para la ejecución del flujo.
1. En **Seleccionar alias**, elija el alias del flujo que desea utilizar.
1. En **Entrada de petición**, introduzca la petición con la que desee iniciar el flujo.
1. Elija **Crear** para crear la ejecución del flujo y empezar a ejecutarla.
1. En la página de detalles del flujo, seleccione la pestaña **Ejecuciones** y anote el estado de la ejecución del flujo en **Estado de ejecución**.
1. (Opcional) Elija una ejecución para abrir el flujo y ver el resumen de la ejecución.
En **Salida de ejecución**, verá la salida del flujo.
1. (Opcional) Para detener la ejecución de un flujo, seleccione la ejecución y elija **Detener**.
------
#### [ API ]
**Iniciar una ejecución de flujo**
Para ejecutar una ejecución de flujo, envíe una [StartFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_StartFlowExecution.html)solicitud con un [punto de ejecución de Agents for Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-rt). En la solicitud, especifique el ID de flujo y el ID de alias del flujo que desea ejecutar. También puede especificar lo siguiente:
+ **inputs**: matriz que contiene el nodo [input](flows-nodes.md#flows-nodes-input) desde el que desea que comience a ejecutarse el flujo. La entrada que se va a enviar al nodo de entrada del flujo de peticiones se especifica en el campo `content`.
+ **name**: un nombre para la ejecución del flujo.
```
{
"inputs": [{
"nodeName": "FlowInputNode",
"nodeOutputName": "document",
"content": {
"document": "Test"
}
}],
"name": "MyExecution"
}
```
La respuesta es el Nombre de recurso de Amazon (ARN) de la ejecución del flujo. Puede usar el `executionArn` para sondear el estado actual del flujo, por ejemplo, cuando finaliza la ejecución del flujo o cuando un nodo de condición evalúa sus condiciones.
```
{
"executionArn": "arn:aws:bedrock:us-west-2:111122223333:flow/FLOWID/alias/TSTALIASID/execution/MyExecution"
}
```
**Seguimiento del progreso de una ejecución de flujo**
Utilice la [GetFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GetFlowExecution.html)operación para obtener el estado actual de un flujo que identifique por su ARN de ejecución. El estado de un flujo es `Running`, `Succeeded`, `Failed`, `TimedOut` o `Aborted`.
```
{
"endedAt": null,
"errors": null,
"executionArn": "arn:aws:bedrock:us-west-2:111122223333:flow/FLOWID/alias/TSTALIASID/execution/MyExecution",
"flowAliasIdentifier": "TSTALIASID",
"flowIdentifier": "FLOWID",
"flowVersion": "DRAFT",
"startedAt": "2025-03-20T23:32:28.899221162Z",
"status": "Running"
}
```
Los errores (como un nodo de Lambda cuyo tiempo de espera se ha agotado) se devuelven en la matriz `errors` como en el siguiente ejemplo:
```
"errors": [{
"nodeName": "LambdaNode1",
"errorType": "ExecutionTimedOut",
"message": "Call to lambda function timed out"
}],
```
**Obtención de los resultados de una ejecución de flujo**
Amazon Bedrock escribe las salidas de un flujo en los nodos [output](flows-nodes.md#flows-nodes-output) del flujo. Puede obtener las salidas una vez que se complete el flujo o mientras el flujo está en funcionamiento (según su caso de uso).
Si desea que el flujo se complete primero, llame a `GetFlowExecution` y asegúrese de que el valor del campo `status` en la respuesta sea `Succeeded`.
Para obtener una lista de los eventos de salida de la ejecución del flujo, realice una llamada a [ListFlowExecutionEvents](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_ListFlowExecutionEvents.html). En la respuesta, compruebe si hay objetos `flowOutputEvent` en `flowExecutionEvents`. Por ejemplo, puede obtener la salida de un flujo en el campo `content`:
```
{
"flowOutputEvent": {
"content": {
"document": "The model response."
},
"nodeName": "FlowOutputNode"
}
}
```
Puede limitar la salida de `ListFlowExecutions` a solo los nodos de entrada y salida estableciendo el parámetro de consulta `eventType` en `Flow`.
**Ver eventos**
Para ayudar a depurar la ejecución del flujo, puede utilizar la [ListFlowExecutionEvents](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_ListFlowExecutionEvents.html)operación para ver los eventos que generan los nodos mientras se ejecuta el flujo. Establezca el parámetro de consulta `eventType` en `Node` para ver las entradas y salidas de todos los nodos (incluidos los nodos intermedios) de la respuesta, de forma similar a la del siguiente ejemplo:
```
{
"flowExecutionEvents": [{
"nodeOutputEvent": {
"fields": [{
"content": {
"document": "History book"
},
"name": "document"
}],
"nodeName": "FlowInputNode",
"timestamp": "2025-05-05T18:38:56.637867516Z"
}
},
{
"nodeInputEvent": {
"fields": [{
"content": {
"document": "History book"
},
"name": "book"
}],
"nodeName": "Prompt_1",
"timestamp": "2025-05-05T18:38:57.434600163Z"
}
},
{
"nodeOutputEvent": {
"fields": [{
"content": {
"document": "Here's a summary of the history book."
},
"name": "modelCompletion"
}],
"nodeName": "Prompt_1",
"timestamp": "2025-05-05T18:39:06.034157077Z"
}
},
{
"nodeInputEvent": {
"fields": [{
"content": {
"document": "Here's a summary of the history book."
},
"name": "document"
}],
"nodeName": "FlowOutputNode",
"timestamp": "2025-05-05T18:39:06.453128251Z"
}
}
]
}
```
**Obtención de una instantánea de la ejecución de un flujo**
Amazon Bedrock realiza automáticamente una instantánea de la definición y los metadatos de un flujo cuando se inicia la ejecución de un flujo. Esto resulta útil, ya que un flujo se puede actualizar mientras se ejecuta de forma asíncrona. Para recuperar esta instantánea, llama a la [GetExecutionFlowSnapshot](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GetExecutionFlowSnapshot.html)operación. La respuesta incluye los siguientes campos del flujo:
+ **customerEncryptionKeyArn**: el ARN de la clave que cifra AWS KMS el flujo.
+ **definition**: la [definición](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowDefinition.html) del flujo.
+ **executionRoleArn**— El ARN de la función de servicio de IAM que utiliza la ejecución del flujo.
+ **flowAliasIdentifier**— El seudónimo del flujo.
+ **flowIdentifier**: el ID del flujo.
+ **flowVersion**: la versión del flujo.
```
{
"customerEncryptionKeyArn": null,
"definition": "{flow-definition}",
"executionRoleArn": "arn:aws:iam::111122223333:role/name",
"flowAliasIdentifier": "TSTALIASID",
"flowIdentifier": "FLOWID",
"flowVersion": "DRAFT"
}
```
**Enumeración de las ejecuciones de un flujo**
Puede obtener una lista de las ejecuciones de su flujo llamando a la [ListFlowExecutions](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_ListFlowExecutions.html)operación. La respuesta incluye una `flowExecutionSummaries` matriz con información sobre cada una de las ejecuciones del flujo en curso Región de AWS para un flujo o un alias de flujo. Cada elemento incluye información como el ARN de ejecución, la hora de inicio y el estado actual del flujo.
```
{
"flowExecutionSummaries": [{
"createdAt": "2025-03-11T23:21:02.875598966Z",
"endedAt": null,
"executionArn": "arn:aws:bedrock:us-west-2:111122223333:flow/FLOWID/alias/TSTALIASID/execution/MyExecution",
"flowAliasIdentifier": "TSTALIASID",
"flowIdentifier": "FLOWID",
"flowVersion": "DRAFT",
"status": "Running"
}]
}
```
**Detención de la ejecución en curso de un flujo**
Si necesita detener la ejecución de un flujo en ejecución, llame a la [StopFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_StopFlowExecution.html)operación y pase el ID del flujo, el ID de alias del flujo y el ID de ejecución del flujo correspondientes a la ejecución que desee detener.
------
## Estados de ejecución del flujo
La ejecución de un flujo puede tener uno de los siguientes estados:
+ **Running**: la ejecución del flujo está en curso.
+ **Succeeded**: la ejecución del flujo se completó correctamente.
+ **Failed**: la ejecución del flujo ha fallado debido a un error.
+ **TimedOut**— La ejecución del flujo superó el tiempo de ejecución máximo de 24 horas.
+ **Abortado**: la ejecución del flujo se detuvo manualmente mediante la [StopFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_StopFlowExecution.html)operación.
Las ejecuciones de un flujo que ya no se están ejecutando se eliminan automáticamente después de 90 días.
## Prácticas recomendadas para ejecuciones de flujo
Tenga en cuenta lo siguiente al usar ejecuciones de flujo:
+ Compruebe periódicamente el estado de ejecución del flujo [GetFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GetFlowExecution.html)hasta que el flujo alcance un estado terminal (que es cualquier otro que no sea`Running`).
+ Cuando la ejecución del flujo alcance un estado terminal, [ListFlowExecutionEvents](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_ListFlowExecutionEvents.html)utilícelo para obtener los resultados del flujo. Por ejemplo, puede usar estos resultados para crear una lógica en torno a su flujo.
+ Obtenga una instantánea de la ejecución de su flujo y [GetExecutionFlowSnapshot](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GetExecutionFlowSnapshot.html)utilícela como ayuda para la depuración si surgen problemas con la ejecución.
# Implementación de un flujo en la aplicación mediante versiones y alias
Al crear un flujo por primera vez, tiene una versión de borrador de trabajo (`DRAFT`) y un alias de prueba (`TSTALIASID`) que apunta a la versión de borrador de trabajo creada. Al realizar cambios en el flujo, los cambios se aplican al borrador de trabajo y, por lo tanto, se trata de la versión más reciente del flujo. Itere el borrador de trabajo hasta que quede conforme con el comportamiento del flujo. A continuación, puede configurar el flujo para la implementación mediante la creación de *versiones* de dicho flujo.
Una *versión* es una instantánea que conserva el recurso tal como estaba en el momento de su creación. Puede seguir modificando el borrador de trabajo y crear versiones del flujo según sea necesario. Amazon Bedrock crea las versiones en orden numérico, empezando por 1. Las versiones son inmutables porque actúan como una instantánea del flujo en el momento en que se ha creado. Para actualizar un flujo que haya implementado en producción, debe crear una nueva versión a partir del borrador de trabajo y realizar llamadas al alias que apunta a esa versión.
Para implementar un flujo, debe crear un *alias* que apunte a una versión del flujo. A continuación, realice solicitudes `InvokeFlow` a ese alias. Los alias le permiten cambiar de forma eficiente entre distintas versiones del flujo sin que tenga que realizar un seguimiento de la versión. Por ejemplo, puede cambiar un alias para que apunte a una versión anterior del flujo si hay cambios que deba revertir rápidamente.
En los temas siguientes se describe cómo crear versiones y alias del flujo.
**Topics**
+ [Creación de una versión de un flujo en Amazon Bedrock](flows-version-create.md)
+ [Consulta de información sobre las versiones de los flujos en Amazon Bedrock](flows-version-view.md)
+ [Eliminación de una versión de un flujo en Amazon Bedrock](flows-version-delete.md)
+ [Creación de un alias de un flujo en Amazon Bedrock](flows-alias-create.md)
+ [Consulta de información sobre los alias de los flujos en Amazon Bedrock](flows-alias-view.md)
+ [Modificación de un alias de un flujo en Amazon Bedrock](flows-alias-modify.md)
+ [Eliminación de un alias de un flujo en Amazon Bedrock](flows-alias-delete.md)
# Creación de una versión de un flujo en Amazon Bedrock
Cuando la configuración del flujo le parezca adecuada, cree una versión inmutable del flujo a la que puede apuntar con un alias. Para obtener información sobre cómo crear una versión de un flujo, seleccione la pestaña correspondiente al método que prefiera y siga los pasos:
------
#### [ Console ]
**Cómo crear una versión de sus flujos de Amazon Bedrock**
1. Inicie sesión en la Consola de administración de AWS con una identidad de IAM que tenga permisos para usar la consola de Amazon Bedrock. A continuación, abra la consola de Amazon Bedrock en [https://console.aws.amazon.com/bedrock/](https://console.aws.amazon.com/bedrock).
1. Seleccione **Flujos de Amazon Bedrock** en el panel de navegación de la izquierda. A continuación, elija un flujo en la sección **Flujos de Amazon Bedrock**.
1. En la sección **Versiones**, seleccione **Publicar versión**.
1. Una vez publicada la versión, aparece un banner de confirmación en la parte superior.
------
#### [ API ]
Para crear una versión de un flujo, envíe una solicitud [CreateFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowVersion.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) y especifique el ARN o el ID del flujo como `flowIdentifier`.
La respuesta devuelve un ID y un ARN para la versión. Las versiones se crean de forma incremental, empezando por 1.
------
# Consulta de información sobre las versiones de los flujos en Amazon Bedrock
Para obtener más información sobre cómo ver la información de las versiones de un flujo, seleccione la pestaña correspondiente al método que prefiera y siga los pasos:
------
#### [ Console ]
**Cómo ver la información sobre una versión de un flujo**
1. Inicie sesión en la [Consola de administración de AWS](https://console.aws.amazon.com/) e inicie sesión en su cuenta. Navegue hasta Amazon Bedrock.
1. En el panel de navegación de la izquierda, seleccione **Flujos**. A continuación, en la sección **Flujos**, seleccione el flujo que quiera ver.
1. Elija la versión que desee ver en la sección **Versiones**.
1. Para ver los detalles sobre los nodos y las configuraciones asociadas a la versión del flujo, seleccione el nodo y consulte los detalles en el panel **Generador de flujos**. Para realizar modificaciones en el flujo, utilice el borrador de trabajo y cree una versión nueva.
------
#### [ API ]
Para obtener información sobre una versión del flujo, envíe una solicitud [GetFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowVersion.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) y especifique el ARN o el ID del flujo como `flowIdentifier`. En el campo `flowVersion`, especifique el número de versión.
Para mostrar información de todas las versiones de un flujo, envíe una solicitud [ListFlowVersions](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowVersions.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) y especifique el ARN o el ID del flujo como `flowIdentifier`. Puede especificar los siguientes parámetros opcionales:
****
| Campo | Descripción breve |
| --- | --- |
| maxResults | El número máximo de resultados que se devuelven en una respuesta. |
| nextToken | Si hay más resultados que el número que ha especificado en el campo maxResults, la respuesta devolverá un valor nextToken. Para ver el siguiente lote de resultados, envíe el valor nextToken en otra solicitud. |
------
# Eliminación de una versión de un flujo en Amazon Bedrock
Para obtener información sobre cómo eliminar una versión de un flujo, seleccione la pestaña correspondiente al método que prefiera y siga los pasos:
------
#### [ Console ]
**Cómo eliminar una versión de un flujo**
1. Inicie sesión en la [Consola de administración de AWS](https://console.aws.amazon.com/) e inicie sesión en su cuenta. Navegue hasta Amazon Bedrock.
1. En el panel de navegación de la izquierda, seleccione **Flujos**. A continuación, elija un flujo en la sección **Flujos**.
1. Elija **Eliminar**.
1. Aparece un cuadro de diálogo que le advierte sobre las consecuencias de la eliminación. Para confirmar que desea eliminar la versión, escriba **delete** en el campo de entrada y, a continuación, seleccione **Eliminar**.
1. Aparece un banner para informarle de que se va a eliminar la versión. Cuando se complete la eliminación, aparecerá un banner de confirmación.
------
#### [ API ]
Para eliminar una versión de un flujo, envíe una solicitud [DeleteFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowVersion.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Especifique el ARN o el ID del flujo en el campo `flowIdentifier` y la versión que se va a eliminar en el campo `flowVersion`.
------
# Creación de un alias de un flujo en Amazon Bedrock
Para invocar un flujo, primero debe crear un alias que apunte a una versión del flujo. Para obtener más información sobre cómo crear un alias, seleccione la pestaña correspondiente al método que prefiera y siga los pasos:
------
#### [ Console ]
**Cómo crear un alias para los flujos de Amazon Bedrock**
1. Inicie sesión en la Consola de administración de AWS con una identidad de IAM que tenga permisos para usar la consola de Amazon Bedrock. A continuación, abra la consola de Amazon Bedrock en [https://console.aws.amazon.com/bedrock/](https://console.aws.amazon.com/bedrock).
1. Seleccione **Flujos de Amazon Bedrock** en el panel de navegación de la izquierda. A continuación, elija un flujo en la sección **Flujos**.
1. En la sección **Alias**, elija **Crear alias**.
1. Introduzca un nombre exclusivo para el alias y proporcione una descripción (opcional).
1. Seleccione una de las siguientes opciones:
+ Para crear una nueva versión, elija **Crear una nueva versión y asociarla a este alias**.
+ Para usar una versión existente, elija **Usar una versión existente para asociar este alias**. En el menú desplegable, elija la versión a la que desea asociar el alias.
1. Seleccione **Crear alias**. En la parte superior aparece un banner de confirmación.
------
#### [ API ]
Para crear un alias que apunte a una versión del flujo, envíe una solicitud [CreateFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowAlias.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt).
Los siguientes campos son obligatorios:
****
| Campo | Descripción básica |
| --- | --- |
| flowIdentifier | El ARN o el ID del flujo para el que se va a crear un alias. |
| nombre | Un nombre para el alias. |
| routingConfiguration | Especifique la versión a la que desea asignar el alias en el campo flowVersion. |
Los siguientes campos son opcionales:
****
| Campo | Caso de uso |
| --- | --- |
| description | Para proporcionar una descripción del alias. |
| clientToken | Para evitar la reduplicación de la solicitud. |
------
La creación de un alias produce un recurso con un identificador y un nombre de recurso de Amazon (ARN) que puede especificar al invocar un flujo desde su aplicación. Para obtener más información sobre cómo invocar un flujo, consulte [Prueba de un flujo en Amazon Bedrock](flows-test.md).
# Consulta de información sobre los alias de los flujos en Amazon Bedrock
Para saber cómo ver información sobre los alias de un flujo, seleccione la pestaña correspondiente al método que prefiera y siga los pasos:
------
#### [ Console ]
**Visualización de los detalles de un alias**
1. Inicie sesión en la [Consola de administración de AWS](https://console.aws.amazon.com/) e inicie sesión en su cuenta. Navegue hasta Amazon Bedrock.
1. En el panel de navegación de la izquierda, seleccione **Flujos**. A continuación, elija un flujo en la sección **Flujos**.
1. Elija el alias que desea ver en la sección **Alias**.
1. Puede ver el nombre y la descripción del alias y las etiquetas asociadas al mismo.
------
#### [ API ]
Para obtener información sobre un alias del flujo, envíe una solicitud [GetFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowAlias.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) y especifique el ARN o el ID del flujo como `flowIdentifier`. En el campo `aliasIdentifier`, especifique el ID o el ARN del alias.
Para mostrar información para todos los alias de un flujo, envíe una solicitud [ListFlowAliass](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowAliass.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) y especifique el ARN o el ID del flujo como `flowIdentifier`. Puede especificar los siguientes parámetros opcionales:
****
| Campo | Descripción breve |
| --- | --- |
| maxResults | El número máximo de resultados que se devuelven en una respuesta. |
| nextToken | Si hay más resultados que el número que ha especificado en el campo maxResults, la respuesta devolverá un valor nextToken. Para ver el siguiente lote de resultados, envíe el valor nextToken en otra solicitud. |
------
# Modificación de un alias de un flujo en Amazon Bedrock
Para obtener más información sobre cómo modificar un alias de un flujo, seleccione la pestaña correspondiente al método que prefiera y siga los pasos:
------
#### [ Console ]
**Modificación de un alias**
1. Inicie sesión en la [Consola de administración de AWS](https://console.aws.amazon.com/) e inicie sesión en su cuenta. Navegue hasta Amazon Bedrock.
1. En el panel de navegación de la izquierda, seleccione **Flujos**. A continuación, elija un flujo en la sección **Flujos**.
1. En la sección **Alias**, elija el botón de opción junto al alias que desea editar.
1. Puede editar el nombre y la descripción del alias. Además, se puede realizar una de las siguientes acciones:
+ Para crear una nueva versión y asociarla a este alias, elija **Crear una nueva versión y asociarla a este alias**.
+ Para asociar este alias a una versión existente diferente, seleccione **Usar una versión existente y asociarle este alias**.
1. Seleccione **Guardar**.
------
#### [ API ]
Para actualizar un alias, envíe una solicitud [UpdateFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlowAlias.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). En la solicitud, incluya tanto los campos que quiera mantener como los campos que quiera modificar.
------
# Eliminación de un alias de un flujo en Amazon Bedrock
Para obtener más información sobre cómo eliminar un alias de un flujo, seleccione la pestaña correspondiente al método que prefiera y siga los pasos:
------
#### [ Console ]
**Eliminación de un alias**
1. Inicie sesión en la [Consola de administración de AWS](https://console.aws.amazon.com/) e inicie sesión en su cuenta. Navegue hasta Amazon Bedrock.
1. En el panel de navegación de la izquierda, seleccione **Flujos**. A continuación, elija un flujo en la sección **Flujos**.
1. Para elegir el alias que desea eliminar, elija el botón de opción situado junto al alias que desea eliminar en la sección **Alias**.
1. Elija **Eliminar**.
1. Aparece un cuadro de diálogo que le advierte sobre las consecuencias de la eliminación. Para confirmar que desea eliminar el alias, escriba **delete** en el campo de entrada y, a continuación, elija **Eliminar**.
1. Aparece un banner para informarle de que el alias se va a eliminar. Cuando se complete la eliminación, aparecerá un banner de confirmación.
------
#### [ API ]
Para eliminar un alias de flujo, envíe una solicitud [DeleteFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowAlias.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Especifique el ARN o el ID del flujo en el campo `flowIdentifier` y el ARN o el ID del alias que se va a eliminar en el campo `aliasIdentifier`.
------
# Invocar una AWS Lambda función de un flujo de Amazon Bedrock en una cuenta diferente AWS
Un flujo de Amazon Bedrock puede invocar una AWS Lambda función que se encuentre en una AWS cuenta diferente a la del flujo. Utilice el siguiente procedimiento para configurar la función de Lambda (*cuenta A*) y el flujo (*cuenta B*).
**Para configurar un flujo de flujo para llamar a una función Lambda en otra cuenta AWS**
1. En la cuenta A (función de Lambda), añada una política basada en recursos a la función de Lambda, utilizando el rol de ejecución de flujo de la cuenta B como la entidad principal. Para obtener más información, consulte [Concesión de acceso a las funciones de Lambda a otras cuentas](https://docs.aws.amazon.com/lambda/latest/dg/permissions-function-cross-account.html) en la documentación de *AWS Lambda*.
1. En la cuenta B (flujo de Amazon Bedrock), añada el permiso para la operación [invoke](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html) al rol de ejecución de flujo para el ARN de la función de Lambda que esté utilizando. Para obtener más información, consulte [Actualización de los permisos de un rol](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_update-role-permissions.html) en la documentación de *AWS Identity and Access Management*.
# Conversación con un flujo de Amazon Bedrock
**nota**
La característica de conversación de varios turnos de Flujos de Amazon Bedrock está en versión preliminar para Amazon Bedrock y está sujeta a cambios.
La conversación en varios turnos de Amazon Bedrock Flow permite back-and-forth conversaciones dinámicas entre usuarios y flujos, similares a un diálogo natural. Cuando un nodo de agente requiere aclaraciones o contexto adicional, puede pausar de forma inteligente la ejecución del flujo y solicitar al usuario información específica. Esto crea una experiencia más interactiva y con mayor contexto, ya que el nodo puede adaptar su comportamiento en función de las respuestas de los usuarios. Por ejemplo, si una consulta inicial de un usuario es ambigua o está incompleta, el nodo puede hacer preguntas de seguimiento para recopilar los detalles necesarios. Una vez que el usuario proporciona la información solicitada, el flujo reanuda la ejecución sin problemas con la entrada enriquecida, lo que garantiza resultados más precisos y pertinentes. Esta capacidad es particularmente útil en escenarios complejos en los que una sola interacción puede no ser suficiente para comprender y abordar completamente las necesidades del usuario.
**Topics**
+ [Cómo procesar una conversación de varios turnos en un flujo](#flows-multi-turn-invocation-how)
+ [Creación y ejecución de un flujo de ejemplo](#flows-multi-turn-invocation-example-flow)
## Cómo procesar una conversación de varios turnos en un flujo
Para utilizar una conversación de varios turnos en un flujo, necesita un [nodo de agente](flows-nodes.md#flows-nodes-agent) conectado a un agente de Amazon Bedrock. Al ejecutar el flujo, se produce una conversación de varios turnos cuando el agente necesita más información del usuario para poder continuar. En esta sección se describe un flujo que utiliza un agente con las siguientes instrucciones:
```
You are a playlist creator for a radio station.
When asked to create a playlist, ask for the number of songs,
the genre of music, and a theme for the playlist.
```
Para obtener información acerca de la creación de un agente, consulte [Automatización de las tareas en la aplicación mediante agentes de IA](agents.md).
### Paso 1: inicio del flujo
Para iniciar un flujo, se llama a la [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html)operación. Incluya el contenido inicial que desea enviar al flujo. En el siguiente ejemplo, el campo `document` contiene una solicitud para *crear una lista de reproducción*. Cada conversación tiene un identificador único (*ID de ejecución*) que identifica la conversación dentro del flujo. Para obtener el ID de ejecución, no envíe el campo `executionID` en su primera llamada a `InvokeFlow`. La respuesta de `InvokeFlow` incluye el ID de ejecución. En el código, utilice el identificador para realizar un seguimiento de varias conversaciones e identificar una conversación en las siguientes llamadas a la operación `InvokeFlow`.
A continuación, se muestra un ejemplo de solicitud JSON para `InvokeFlow`.
```
{
"flowIdentifier": "XXXXXXXXXX",
"flowAliasIdentifier": "YYYYYYYYYY",
"inputs": [
{
"content": {
"document": "Create a playlist."
},
"nodeName": "FlowInputNode",
"nodeOutputName": "document"
}
]
}
```
### Paso 2: recuperación de las solicitudes del agente
Si el nodo de agente del flujo decide que necesita más información del usuario, el flujo de respuesta (`responseStream`) de `InvokeFlow` incluye un objeto del evento `FlowMultiTurnInputRequestEvent`. El evento tiene la información solicitada en el campo `content` (`FlowMultiTurnInputContent`). En el siguiente ejemplo, la solicitud del campo `document` es para obtener información sobre el número de canciones, el género musical y el tema de la lista de reproducción. Luego, en su código, necesita obtener esa información del usuario.
A continuación se muestra un objeto JSON `FlowMultiTurnInputRequestEvent` de ejemplo:
```
{
"nodeName": "AgentsNode_1",
"nodeType": "AgentNode",
"content": {
"document": "Certainly! I'd be happy to create a playlist for you. To make sure it's tailored to your preferences, could you please provide me with the following information:
1. How many songs would you like in the playlist?
2. What genre of music do you prefer?
3. Is there a specific theme or mood you'd like for the playlist? Once you provide these details, I'll be able to create a customized playlist just for you."
}
}
```
Como el flujo no puede continuar hasta que se reciban más entradas, también emite un evento `FlowCompletionEvent`. Un flujo siempre emite `FlowMultiTurnInputRequestEvent` antes que `FlowCompletionEvent`. Si el valor de `completionReason` en el evento `FlowCompletionEvent` es `INPUT_REQUIRED`, el flujo necesita más información para poder continuar.
A continuación se muestra un objeto JSON `FlowCompletionEvent` de ejemplo:
```
{
"completionReason": "INPUT_REQUIRED"
}
```
### Paso 3: envío de la respuesta del usuario al flujo
Envíe la respuesta del usuario al flujo volviendo a llamar a la operación `InvokeFlow`. Asegúrese de incluir el `executionId` de la conversación.
A continuación, se muestra código JSON de ejemplo para la solicitud a `InvokeFlow`. El campo `document` contiene la respuesta del usuario.
```
{
"flowIdentifier": "AUS7BMHXBE",
"flowAliasIdentifier": "4KUDB8VBEF",
"executionId": "b6450554-f8cc-4934-bf46-f66ed89b60a0",
"inputs": [
{
"content": {
"document": "1. 5 songs 2. Welsh rock music 3. Castles"
},
"nodeName": "AgentsNode_1",
"nodeInputName": "agentInputText"
}
]
}
```
Si el flujo necesita más información, crea más eventos `FlowMultiTurnInputRequestEvent`.
### Paso 4: finalización del flujo
Cuando no se necesita más información, el flujo emite un evento `FlowOutputEvent` que contiene la respuesta final.
A continuación se muestra un objeto JSON `FlowOutputEvent` de ejemplo:
```
{
"nodeName": "FlowOutputNode",
"content": {
"document": "Great news! I've created a 5-song Welsh rock playlist centered around the theme of castles.
Here's the playlist I've put together for you: Playlist Name: Welsh Rock Castle Anthems
Description: A 5-song Welsh rock playlist featuring songs about castles
Songs:
1. Castell y Bere - Super Furry Animals
2. The Castle - Manic Street Preachers
3. Caerdydd (Cardiff Castle) - Stereophonics
4. Castell Coch - Catatonia
5. Chepstow Castle - Feeder
This playlist combines Welsh rock bands with songs that reference castles or specific Welsh castles.
Enjoy your castle-themed Welsh rock music experience!"
}
}
```
El flujo también emite un evento `FlowCompletionEvent`. El valor de `completionReason` es `SUCCESS`.
A continuación se muestra un objeto JSON `FlowCompletionEvent` de ejemplo:
```
{
"completionReason": "SUCCESS"
}
```
El siguiente diagrama de secuencia muestra los pasos de un flujo de varios turnos.
![\[Pasos del flujo para una conversación de varios turnos\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/flows/flows-multi-turn-steps.png)
## Creación y ejecución de un flujo de ejemplo
En este ejemplo, se crea un flujo que utiliza un agente para crear listas de reproducción para una emisora de radio. El agente hace preguntas aclaratorias para determinar el número de canciones, el género musical y el tema de la lista de reproducción.
**Cómo crear el flujo**
1. Cree un agente en la consola de Amazon Bedrock siguiendo las instrucciones de [Creación y configuración de agentes manualmente](agents-create.md).
+ Para el paso *2.d*, introduzca **You are a playlist creator for a radio station. When asked to create a playlist, ask for the number of songs, the genre of music, and a theme for the playlist.**
+ Para el paso *2.e*, en **Entrada de usuario**, elija **Activado**. De este modo, el agente podrá solicitar más información, según sea necesario.
1. Cree el flujo siguiendo las instrucciones de [Creación y diseño de un flujo en Amazon Bedrock](flows-create.md). Asegúrese de que el flujo tenga un nodo de entrada, un nodo de agentes y un nodo de salida.
1. Vincule el nodo de agentes al agente que creó en el paso 1. El flujo debe ser similar al de la siguiente imagen:
![\[Flujo de una conversación de varios turnos\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/flows/flows-multi-turn.png)
1. Ejecute el flujo en la consola de Amazon Bedrock. Para realizar las pruebas, puede rastrear los pasos que sigue el flujo. Para obtener más información, consulte [Prueba de un flujo en Amazon Bedrock](flows-test.md).
El siguiente ejemplo de código Python muestra cómo usar el flujo.
Para ejecutar el código, especifique lo siguiente:
+ `region_name`— La AWS región en la que está ejecutando el flujo.
+ `FLOW_ID`: el ID del flujo.
+ `FLOW_ALIAS_ID`: el ID de alias del flujo.
Para obtener información sobre cómo obtener el IDs, consulte[Consulta de información sobre los flujos en Amazon Bedrock](flows-view.md). El código solicita que se envíe una solicitud inicial al flujo y pide más información según sea necesario para el flujo. El código no gestiona otras solicitudes del agente, como las solicitudes de llamada a AWS Lambda funciones. Para obtener más información, consulte [Funcionamiento de los agentes de Amazon Bedrock](agents-how.md). Mientras se ejecuta, el código genera objetos `FlowTraceEvent` que puede usar para rastrear la ruta desde la entrada hasta la respuesta que devuelve el flujo. Para obtener más información, consulte [Seguimiento de cada paso del flujo viendo su rastro en Amazon BedrockSeguimiento de cada paso del flujo viendo su rastro](flows-trace.md).
```
"""
Runs an Amazon Bedrock flow and handles muli-turn interaction for a single conversation.
"""
import logging
import boto3
import botocore
import botocore.exceptions
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def invoke_flow(client, flow_id, flow_alias_id, input_data, execution_id):
"""
Invoke an Amazon Bedrock flow and handle the response stream.
Args:
client: Boto3 client for Amazon Bedrock agent runtime
flow_id: The ID of the flow to invoke
flow_alias_id: The alias ID of the flow
input_data: Input data for the flow
execution_id: Execution ID for continuing a flow. Use the value None on first run.
Returns:
Dict containing flow_complete status, input_required info, and execution_id
"""
response = None
request_params = None
if execution_id is None:
# Don't pass execution ID for first run.
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"inputs": [input_data],
"enableTrace": True
}
else:
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"executionId": execution_id,
"inputs": [input_data],
"enableTrace": True
}
response = client.invoke_flow(**request_params)
if "executionId" not in request_params:
execution_id = response['executionId']
input_required = None
flow_status = ""
# Process the streaming response
for event in response['responseStream']:
# Check if flow is complete.
if 'flowCompletionEvent' in event:
flow_status = event['flowCompletionEvent']['completionReason']
# Check if more input us needed from user.
elif 'flowMultiTurnInputRequestEvent' in event:
input_required = event
# Print the model output.
elif 'flowOutputEvent' in event:
print(event['flowOutputEvent']['content']['document'])
elif 'flowTraceEvent' in event:
logger.info("Flow trace: %s", event['flowTraceEvent'])
return {
"flow_status": flow_status,
"input_required": input_required,
"execution_id": execution_id
}
if __name__ == "__main__":
session = boto3.Session(profile_name='default', region_name='YOUR_FLOW_REGION')
bedrock_agent_client = session.client('bedrock-agent-runtime')
# Replace these with your actual flow ID and alias ID
FLOW_ID = 'YOUR_FLOW_ID'
FLOW_ALIAS_ID = 'YOUR_FLOW_ALIAS_ID'
flow_execution_id = None
finished = False
# Get the intial prompt from the user.
user_input = input("Enter input: ")
flow_input_data = {
"content": {
"document": user_input
},
"nodeName": "FlowInputNode",
"nodeOutputName": "document"
}
logger.info("Starting flow %s", FLOW_ID)
try:
while not finished:
# Invoke the flow until successfully finished.
result = invoke_flow(
bedrock_agent_client, FLOW_ID, FLOW_ALIAS_ID, flow_input_data, flow_execution_id)
status = result['flow_status']
flow_execution_id = result['execution_id']
more_input = result['input_required']
if status == "INPUT_REQUIRED":
# The flow needs more information from the user.
logger.info("The flow %s requires more input", FLOW_ID)
user_input = input(
more_input['flowMultiTurnInputRequestEvent']['content']['document'] + ": ")
flow_input_data = {
"content": {
"document": user_input
},
"nodeName": more_input['flowMultiTurnInputRequestEvent']['nodeName'],
"nodeInputName": "agentInputText"
}
elif status == "SUCCESS":
# The flow completed successfully.
finished = True
logger.info("The flow %s successfully completed.", FLOW_ID)
except botocore.exceptions.ClientError as e:
print(f"Client error: {str(e)}")
logger.error("Client error: %s", {str(e)})
except Exception as e:
print(f"An error occurred: {str(e)}")
logger.error("An error occurred: %s", {str(e)})
logger.error("Error type: %s", {type(e)})
```
# Ejecución de ejemplos de código de Flujos de Amazon Bedrock
En los siguientes ejemplos de código se supone que cumple los siguientes requisitos previos:
1. Configurar un rol para tener permisos para las acciones de Amazon Bedrock. Si no lo tiene, consulte [Inicio rápido](getting-started.md).
1. Configurar las credenciales para usar la API de AWS. Si no lo tiene, consulte [Introducción a la API](getting-started-api.md).
1. Crear un rol de servicio para que realice las acciones relacionadas con el flujo en su nombre. Si no lo tiene, consulte [Creación de un rol de servicio para Flujos de Amazon Bedrock en Amazon Bedrock](flows-permissions.md).
Para crear un flujo, envíe una solicitud [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Para ver el código de ejemplo, consulte [Ejecución de ejemplos de código de Flujos de Amazon Bedrock](#flows-code-ex)
Los siguientes campos son obligatorios:
****
| Campo | Descripción básica |
| --- | --- |
| nombre | Nombre para el flujo |
| executionRoleArn | ARN del [rol de servicio con permisos para crear y administrar flujos](flows-permissions.md) |
Los siguientes campos son opcionales:
****
| Campo | Caso de uso |
| --- | --- |
| definición | Contiene los nodes y connections que componen el flujo. |
| description | Para describir el flujo. |
| etiquetas | Para asociar etiquetas con el flujo. Para obtener más información, consulte [Etiquetado de los recursos de Amazon Bedrock](tagging.md). |
| customerEncryptionKeyArn | Cifrar el recurso con una clave de KMS. Para obtener más información, consulte [Cifrado de los recursos de Flujos de Amazon Bedrock](encryption-flows.md). |
| clientToken | Para garantizar que la solicitud de la API se complete solo una vez. Para obtener más información, consulte [Ensuring idempotency](https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-idempotency.html). |
Si bien el campo `definition` es opcional, es necesario para que el flujo funcione. Puede optar por crear primero un flujo sin la definición y actualizar el flujo más adelante.
Para cada nodo de la lista de `nodes`, especifique el tipo de nodo en el campo `type` y proporcione la configuración correspondiente del nodo en el campo `config`. Para obtener más información sobre la estructura de API de los distintos tipos de nodo, consulte [Tipos de nodos para el flujo](flows-nodes.md).
Para probar algunos ejemplos de código para Flujos de Amazon Bedrock, seleccione la pestaña correspondiente al método que prefiera y siga los pasos:
------
#### [ Python ]
1. Cree un flujo con una solicitud [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) con los siguientes nodos:
+ un nodo de entrada,
+ un nodo de petición con una petición definida en línea que crea una lista de reproducción de música con dos variables (`genre` y `number`),
+ un nodo de salida que devuelva la finalización del modelo.
Ejecute el siguiente fragmento de código para cargar AWS SDK para Python (Boto3), crear un cliente de Agentes para Amazon Bedrock y crear un flujo con los nodos (sustituya el campo `executionRoleArn` por el ARN del rol de servicio que ha creado para el flujo):
```
# Import Python SDK and create client
import boto3
client = boto3.client(service_name='bedrock-agent')
# Replace with the service role that you created. For more information, see https://docs.aws.amazon.com/bedrock/latest/userguide/flows-permissions.html
FLOWS_SERVICE_ROLE = "arn:aws:iam::123456789012:role/MyFlowsRole"
# Define each node
# The input node validates that the content of the InvokeFlow request is a JSON object.
input_node = {
"type": "Input",
"name": "FlowInput",
"outputs": [
{
"name": "document",
"type": "Object"
}
]
}
# This prompt node defines an inline prompt that creates a music playlist using two variables.
# 1. {{genre}} - The genre of music to create a playlist for
# 2. {{number}} - The number of songs to include in the playlist
# It validates that the input is a JSON object that minimally contains the fields "genre" and "number", which it will map to the prompt variables.
# The output must be named "modelCompletion" and be of the type "String".
prompt_node = {
"type": "Prompt",
"name": "MakePlaylist",
"configuration": {
"prompt": {
"sourceConfiguration": {
"inline": {
"modelId": "amazon.nova-lite-v1:0",
"templateType": "TEXT",
"inferenceConfiguration": {
"text": {
"temperature": 0.8
}
},
"templateConfiguration": {
"text": {
"text": "Make me a {{genre}} playlist consisting of the following number of songs: {{number}}."
}
}
}
}
}
},
"inputs": [
{
"name": "genre",
"type": "String",
"expression": "$.data.genre"
},
{
"name": "number",
"type": "Number",
"expression": "$.data.number"
}
],
"outputs": [
{
"name": "modelCompletion",
"type": "String"
}
]
}
# The output node validates that the output from the last node is a string and returns it as is. The name must be "document".
output_node = {
"type": "Output",
"name": "FlowOutput",
"inputs": [
{
"name": "document",
"type": "String",
"expression": "$.data"
}
]
}
# Create connections between the nodes
connections = []
# First, create connections between the output of the flow input node and each input of the prompt node
for input in prompt_node["inputs"]:
connections.append(
{
"name": "_".join([input_node["name"], prompt_node["name"], input["name"]]),
"source": input_node["name"],
"target": prompt_node["name"],
"type": "Data",
"configuration": {
"data": {
"sourceOutput": input_node["outputs"][0]["name"],
"targetInput": input["name"]
}
}
}
)
# Then, create a connection between the output of the prompt node and the input of the flow output node
connections.append(
{
"name": "_".join([prompt_node["name"], output_node["name"]]),
"source": prompt_node["name"],
"target": output_node["name"],
"type": "Data",
"configuration": {
"data": {
"sourceOutput": prompt_node["outputs"][0]["name"],
"targetInput": output_node["inputs"][0]["name"]
}
}
}
)
# Create the flow from the nodes and connections
response = client.create_flow(
name="FlowCreatePlaylist",
description="A flow that creates a playlist given a genre and number of songs to include in the playlist.",
executionRoleArn=FLOWS_SERVICE_ROLE,
definition={
"nodes": [input_node, prompt_node, output_node],
"connections": connections
}
)
flow_id = response.get("id")
```
1. Muestre los flujos de la cuenta, incluido el que acaba de crear, ejecutando el siguiente fragmento de código para realizar una solicitud [ListFlows](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlows.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.list_flows()
```
1. Obtenga información sobre el flujo que acaba de crear ejecutando el siguiente fragmento de código para realizar una solicitud [GetFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlow.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.get_flow(flowIdentifier=flow_id)
```
1. Prepare el flujo para que se apliquen los cambios más recientes del borrador de trabajo y esté listo para la versión. Ejecute el siguiente fragmento de código para realizar una solicitud [PrepareFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PrepareFlow.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.prepare_flow(flowIdentifier=flow_id)
```
1. Cree la versión del borrador de trabajo del flujo para crear una instantánea estática del flujo y, a continuación, obtenga la información sobre el trabajo mediante las siguientes acciones:
1. Cree una versión ejecutando el siguiente fragmento de código para realizar una solicitud [CreateFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowVersion.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
response = client.create_flow_version(flowIdentifier=flow_id)
flow_version = response.get("version")
```
1. Muestre todas las versiones del flujo ejecutando el siguiente fragmento de código para realizar una solicitud [ListFlowVersions](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowVersions.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.list_flow_versions(flowIdentifier=flow_id)
```
1. Obtenga información sobre la versión ejecutando el siguiente fragmento de código para realizar una solicitud [GetFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowVersion.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.get_flow_version(flowIdentifier=flow_id, flowVersion=flow_version)
```
1. Cree un alias que apunte a la versión del flujo creado y, a continuación, recupere la información del flujo realizando las siguientes acciones:
1. Cree una alias y apúntelo hacia la versión que acaba de crear ejecutando el siguiente fragmento de código para realizar una solicitud [CreateFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowAlias.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
response = client.create_flow_alias(
flowIdentifier=flow_id,
name="latest",
description="Alias pointing to the latest version of the flow.",
routingConfiguration=[
{
"flowVersion": flow_version
}
]
)
flow_alias_id = response.get("id")
```
1. Muestre todos los alias del flujo ejecutando el siguiente fragmento de código para realizar una solicitud [ListFlowAliass](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowAliass.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.list_flow_aliases(flowIdentifier=flow_id)
```
1. Obtenga información sobre el alias que acaba de crear ejecutando el siguiente fragmento de código para realizar una solicitud [GetFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowAlias.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.get_flow_alias(flowIdentifier=flow_id, aliasIdentifier=flow_alias_id)
```
1. Ejecute el siguiente fragmento de código para crear un cliente de tiempo de ejecución para agentes de Amazon Bedrock e invoque un flujo. La solicitud rellena las variables de la petición del flujo y devuelve la respuesta del modelo para realizar una solicitud [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html) con un [punto de conexión en tiempo de ejecución de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-rt):
```
client_runtime = boto3.client('bedrock-agent-runtime')
response = client_runtime.invoke_flow(
flowIdentifier=flow_id,
flowAliasIdentifier=flow_alias_id,
inputs=[
{
"content": {
"document": {
"genre": "pop",
"number": 3
}
},
"nodeName": "FlowInput",
"nodeOutputName": "document"
}
]
)
result = {}
for event in response.get("responseStream"):
result.update(event)
if result['flowCompletionEvent']['completionReason'] == 'SUCCESS':
print("Flow invocation was successful! The output of the flow is as follows:\n")
print(result['flowOutputEvent']['content']['document'])
else:
print("The flow invocation completed because of the following reason:", result['flowCompletionEvent']['completionReason'])
```
La respuesta debería devolver una lista de reproducción de música pop con tres canciones.
1. Elimine el alias, la versión y el flujo que ha creado con las siguientes acciones:
1. Elimine el alias ejecutando el siguiente fragmento de código para realizar una solicitud [DeleteFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowAlias.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.delete_flow_alias(flowIdentifier=flow_id, aliasIdentifier=flow_alias_id)
```
1. Elimine la versión ejecutando el siguiente fragmento de código para realizar una solicitud [DeleteFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowVersion.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.delete_flow_version(flowIdentifier=flow_id, flowVersion=flow_version)
```
1. Elimine el flujo ejecutando el siguiente fragmento de código para realizar una solicitud [DeleteFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlow.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.delete_flow(flowIdentifier=flow_id)
```
------
# Eliminación de un flujo en Amazon Bedrock
Si ya no necesita un flujo, puede eliminarlo. Los flujos que elimine se conservan en los servidores de AWS durante un máximo de catorce días. Para obtener más información sobre cómo eliminar un flujo, seleccione la pestaña correspondiente al método que prefiera y siga los pasos:
------
#### [ Console ]
**Para eliminar un flujo**
1. Inicie sesión en la Consola de administración de AWS con una identidad de IAM que tenga permisos para usar la consola de Amazon Bedrock. A continuación, abra la consola de Amazon Bedrock en [https://console.aws.amazon.com/bedrock/](https://console.aws.amazon.com/bedrock).
1. Seleccione **Flujos de Amazon Bedrock** en el panel de navegación de la izquierda. A continuación, en la sección **Flujos de Amazon Bedrock**, seleccione el flujo que desea eliminar.
1. Elija **Eliminar**.
1. Aparece un cuadro de diálogo que le advierte sobre las consecuencias de la eliminación. Para confirmar que desea eliminar el flujo, escriba **delete** en el campo de entrada y, a continuación, seleccione **Eliminar**.
1. Aparece un banner para informarle de que el flujo se va a eliminar. Cuando se complete la eliminación, aparecerá un banner de confirmación.
------
#### [ API ]
Para eliminar un flujo, envíe una solicitud [DeleteFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlow.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) y especifique el ARN o el ID del flujo como `flowIdentifier`.
------