Tipos de nodos en flujo - Amazon Bedrock
Nodos para controlar la lógica de flujoNodos para gestionar los datos del flujoTablas de resumen de los tipos de nodo

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.

Tipos de nodos en flujo

Amazon Bedrock Flows proporciona los siguientes tipos de nodos para crear su flujo. Al configurar un nodo, debe rellenar 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, utilice el type campo y el FlowNodeConfigurationconfigurationcampo correspondiente.

  • Entradas: proporciona la siguiente información para cada entrada:

  • 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.

    • 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 FlowNodeConfigurationy 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 de flujo

Utilice los siguientes tipos de nodos para controlar la lógica del 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 FlowNodeobjeto 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 FlowNodeobjeto de salida:

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

Definición de un nodo de condición

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

  2. 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.

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

  4. Agregue todas las condiciones que necesite.

  5. Para cada condición:

    1. Escriba un nombre para la condición.

    2. 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.

    3. 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
!= No igual que Cadena, número, booleano A != 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
y Ambas expresiones son verdaderas (A < B) y (C == 1) Ambas expresiones son verdaderas:

  • A es menor que B

  • C es igual a 1
o Al menos una expresión es verdadera (A != 2) o (B > C) Si alguna de las expresiones es verdadera:

  • A no es igual a B

  • B es mayor que C
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 UpdateFlowsolicitud CreateFlowo solicitud:

  1. Un FlowNodeobjeto 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"
                },
                ...
            ]
        }
    }
}

  2. Para cada entrada en el nodo de condición, un FlowConnectionobjeto de la connections matriz. Incluya un FlowDataConnectionConfigurationobjeto 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"
        }
    }
}

  3. Para cada condición (incluida la condición por defecto) del nodo de condición, un FlowConnectionobjeto de la connections matriz. Incluya un FlowConditionalConnectionConfigurationobjeto en el configuration campo del FlowConnection objeto. El formato general del FlowConnectionobjeto 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.

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 FlowNodeobjeto iterador:

{
    "name": "string",
    "type": "Iterator",
    "inputs": [
        {
            "name": "array",
            "type": "String | Number | Boolean | Object | 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 FlowNodeobjeto 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
    }
}

Nodos para gestionar los datos del flujo

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

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 Comience con 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 FlowNodeobjeto 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 object (see below),
            "guardrailConfiguration": {
                "guardrailIdentifier": "string",
                "guardrailVersion": "string"
            }
        }
    }
}

El PromptFlowNodeSourceConfigurationobjeto 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 (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 barandilla de Amazon Bedrock Guardrails a su solicitud o a la respuesta generada a partir de ella, incluya el guardrailConfiguration campo y especifique el ID o el ARN de la barandilla en el campo y la versión de la barandilla en el guardrailIdentifier campo. guardrailVersion

Un nodo de agente le permite enviar un mensaje a un agente, que organiza entre los recursos asociados y los recursos asociados para identificar FMs y llevar a cabo acciones en nombre del usuario final. Para obtener más información, consulte Automatice las tareas en su 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 conversaciones interactivas entre los usuarios y el agente durante la ejecución del flujo. Cuando un nodo de agente requiere información o aclaraciones adicionales, puede pausar la ejecución del flujo y solicitar información específica al usuario. Una vez que el usuario proporciona la información solicitada, el nodo agente continúa procesando la nueva entrada. Esto continúa hasta que el nodo agente tenga toda la información necesaria para completar su ejecución

A continuación se muestra la estructura general de un FlowNodeobjeto 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 conocimientos le permite enviar una consulta a una base de conocimientos desde las bases de conocimiento de Amazon Bedrock. Para obtener más información, consulte Recupere datos y genere respuestas de IA con las bases de conocimiento de Amazon Bedrock.

En la configuración, proporcione lo knowledgeBaseId mínimo. Si lo desea, puede incluir los siguientes campos según su caso de uso:

  • modelId— Incluya un ID de modelo para usarlo si desea generar una respuesta basada en los resultados recuperados. Para devolver los resultados obtenidos en forma de matriz, omita el ID del modelo.

  • guardrailConfiguration— Incluya el ID o el ARN de la barandilla, definidos en Amazon Bedrock Guardrails en el guardrailIdentifier campo y la versión de la barandilla en el campo. guardrailVersion

    nota

    Las barandillas solo se pueden aplicar cuando se utilizan en un nodo de la base de conocimientos. RetrieveAndGenerate

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 de la base FlowNodede 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 en el flujo en una ubicación 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 FlowNodeobjeto 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.

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 FlowNodeobjeto 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 Lambda en un flujo, Amazon Bedrock envía un evento de entrada a la función 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

{
    "name": "string",
    "type": "LambdaFunction",
    "inputs": [
       {
            "name": "string",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        ...
    ],
    "outputs": [
        {
            "name": "functionResponse",
            "type": "String | Number | Boolean | Object | Array"
        }
    ],
    "configuration": {
        "lambdaFunction": {
            "lambdaArn": "string"
        }
    }
}

Evento de entrada 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 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 salida del nodo Lambda.

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.

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.

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 FlowNodeobjeto 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.

  • Actualmente, solo los nodos Condición, Petición y Función de Lambda permiten múltiples entradas que puede definir usted mismo.

Tipos de nodo de lógica
Información de entrada Información de salida
Tipo de nodo Input Nombre Tipo Output Nombre Tipo
Entrada N/A N/A N/A El campo content en la solicitud InvokeFlow. document Cualquiera
Salida Datos que se devolverán en la respuesta de InvokeFlow. document Cualquiera N/A N/A N/A
Condición

Datos que se enviarán en función de una condición.

(se permiten múltiples entradas)

 Cualquiera Cualquiera

Datos que se enviarán en función de una condición.

(especifique las condiciones para las diferentes rutas)

 Cualquiera Cualquiera
Iterador Matriz a la que desee aplicar los siguientes nodos de forma iterativa a cada miembro. array Matriz Cada elemento de la matriz arrayItem Cualquiera
Tamaño de la matriz de entrada arraySize Número
Colector Iteración que desea consolidar en una matriz arrayItem Cualquiera Matriz con todas las salidas del nodo anterior anexadas collectedArray Matriz
Tamaño de la matriz de salida arraySize Número
Tipos de nodo de procesamiento de datos
Información de entrada Información de salida
Tipo de nodo Input Nombre Tipo Output Nombre Tipo
Petición

Valor para rellenar una variable en la petición

(se permiten múltiples entradas)

 ${variable-name} Cualquiera Respuesta devuelta por el modelo modelCompletion Cadena
Almacenamiento de S3 Datos para almacenar en un bucket de S3 content Cualquiera URI de la ubicación de S3 s3Uri Cadena
Es la clave de objeto que se va a usar para el objeto S3. objectKey Cadena
Recuperación de S3 Es la clave de objeto que se va a usar para el objeto S3. objectKey Cadena Son los datos que se deben recuperar de un bucket de S3. s3Content Cualquiera
Agente Es la petición del usuario que se envía al agente. agentInputText Cadena Es la respuesta devuelta por el agente. agentResponse Cadena
Cualquier atributo de petición para enviar junto con la petición. promptAttributes Objeto
Cualquier atributo de sesión para enviar junto con la petición. sessionAttributes Objeto
Base de conocimientos Es la consulta que se debe enviar a la base de conocimientos. retrievalQuery Cadena Son los resultados devueltos o la respuesta generada de la base de conocimientos. retrievalResults Matriz
Función de Lambda

Son los datos que se van a enviar a la función.

(se permiten múltiples entradas)

 Cualquiera Es la respuesta devuelta por la función. functionResponse Cualquiera
Lex Es el enunciado que se va a enviar al bot. inputText Cadena Es la intención que el bot predice para el enunciado. predictedIntent Cadena
Cualquier atributo de solicitud que se va a enviar junto con el enunciado. requestAttributes Objeto
Cualquier atributo de sesión que se va a enviar junto con el enunciado. sessionAttributes Objeto