Tipos de nodos para el 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 objeto FlowNode de entrada en la API:

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

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 objeto FlowNode de entrada:

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

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.

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:

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:

En la API, se define lo siguiente en el campo definition cuando se envía una solicitud CreateFlow o UpdateFlow

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 objeto FlowNode 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
    }
}

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 objeto FlowNode colector:

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

Un nodo de bucle DoWhile ejecuta una secuencia de nodos varias veces 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 bucle DoWhile 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 bucle DoWhile en un objeto FlowNode:

{
    "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:

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.

Para ver un ejemplo, consulta Prueba de flujos de ejemplo.

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 objeto FlowNode de petición:

{
    "name": "string",
    "type": "prompt",
    "inputs": [
        {
            "name": "content",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        ...
    ],
    "outputs": [
        {
            "name": "modelCompletion",
            "type": "String"
        }
    ],
    "configuration": {
        "prompt": {
            "sourceConfiguration": PromptFlowNodeSourceConfiguration object (see below),
            "guardrailConfiguration": {
                "guardrailIdentifier": "string",
                "guardrailVersion": "string"
            }
        }
    }
}

El objeto PromptFlowNodeSourceConfiguration depende de si utiliza una petición de la Administración de peticiones o si la define en línea:

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.

Un nodo de agente permite enviar una petición a un agente, que se orquesta entre los FM y los recursos asociados para identificar y llevar a cabo acciones para un usuario final. Para obtener más información, consulte Automatización de las tareas en la aplicación mediante agentes de IA.

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 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 FlowNode de agente:

{
    "name": "string",
    "type": "Agent",
    "inputs": [
       {
            "name": "agentInputText"
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        {
            "name": "promptAttributes"
            "type": "Object",
            "expression": "string"
        },
        {
            "name": "sessionAttributes"
            "type": "Object",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "agentResponse",
            "type": "String"
        }
    ],
    "configuration": {
        "agent": {
            "agentAliasArn": "string"
        }
    }
}

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.

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:

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 objeto FlowNode 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"
            }
        }
    }
}

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. El nodo devuelve el URI de la ubicación de S3 como salida.

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

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. El nodo devuelve el contenido de la ubicación de S3 como salida.

A continuación, se muestra la estructura general de un objeto FlowNode de recuperación de S3:

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

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 FlowNode de una función de 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 en la Guía para desarrolladores de AWS Lambda.

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.

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 insertado en el flujo, Amazon Bedrock ejecuta el código en un entorno administrado de AWS aislado que no se comparte con nadie y no tiene acceso a Internet.

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.

A continuación, se muestra la estructura general de un objeto FlowNode de código insertado:

{
    "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:

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

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.

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 o atributo de sesión que lo acompañe. El nodo devuelve la intención identificada como salida.

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