Tipos de nós em fluxo - Amazon Bedrock
Nodes para controlar a lógica de fluxoNodes para lidar com dados no fluxoTabelas de resumo para tipos de nó

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

Tipos de nós em fluxo

O Amazon Bedrock Flows fornece os seguintes tipos de nós para criar seu fluxo. Ao configurar um nó, você precisa fornecer os seguintes campos:

  • Nome: insira um nome para o nó.

  • Tipo: no console, você arrasta e solta o tipo de nó a ser usado. Na API, use o type campo e o correspondente FlowNodeConfigurationno configuration campo.

  • Entradas: forneça as seguintes informações para cada entrada:

  • Saídas: fornece as seguintes informações para cada saída:

    • Nome: um nome para a saída. Alguns nós têm nomes ou tipos predefinidos que você deve usar. Para saber quais têm nomes predefinidos, consulte Tipos de nó lógico.

    • Tipo: o tipo de dados para a saída. Quando esse nó é alcançado em tempo de execução, o Amazon Bedrock valida se a saída do nó corresponde ao tipo de dados.

  • Configuração: no console, você define campos específicos do nó na parte superior do nó. Na API, use o apropriado FlowNodeConfiguratione preencha seus campos.

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

Nodes para controlar a lógica de fluxo

Use os seguintes tipos de nós para controlar a lógica do seu fluxo.

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

Veja a seguir a estrutura geral de um FlowNodeobjeto de entrada na API:

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

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

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

O seguinte mostra a estrutura geral de um FlowNodeobjeto de saída:

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

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

Para obter um exemplo, consulte Criar um fluxo com um nó de condição.

Como definir um nó de condição

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

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

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

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

  5. Para cada condição:

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

    2. Use operadores lógicos e relacionais para definir uma condição que compara entradas com outras entradas ou com uma constante.

      nota

      As condições são avaliadas na ordem. Se mais de uma condição for atendida, a condição anterior terá precedência.

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

Expressões de condição

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

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

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

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

Operador Significado Exemplo de uso Significado do exemplo
and Ambas as expressões são verdadeiras (A < B) e (C == 1) Se ambas as expressões forem verdadeiras:

  • A é menor que B

  • C é igual a 1
or Pelo menos uma expressão é verdadeira (A != 2) ou (B > C) Se alguma das expressões for verdadeira:

  • A não é igual a B

  • B é maior que C
not A expressão não é verdadeira não (A > B) Se A não for maior que B (equivalente a A <= B)

Na API, você define o seguinte no definition campo ao enviar uma UpdateFlowsolicitação CreateFlowou:

  1. Um FlowNodeobjeto condicional na nodes matriz. O formato geral é o seguinte (observe que os nós de condição não têmoutputs):

    {
    "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 no nó condicional, um FlowConnectionobjeto na connections matriz. Inclua um FlowDataConnectionConfigurationobjeto no configuration campo do FlowConnection objeto. O formato geral do objeto FlowConnection é o seguinte:

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

  3. Para cada condição (incluindo a condição padrão) no nó da condição, um FlowConnectionobjeto na connections matriz. Inclua um FlowConditionalConnectionConfigurationobjeto no configuration campo do FlowConnection objeto. O formato geral do FlowConnectionobjeto é o seguinte:

    {
    "name": "string",
    "source": "string",
    "target": "string",
    "type": "Condition",
    "configuration": {
        "conditional": "default",
        ...
    }
}

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

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

O seguinte mostra a estrutura geral de um 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
    }
}

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

Veja a seguir a estrutura geral de um FlowNodeobjeto coletor:

{
    "name": "string",
    "type": "Collector",
    "inputs": [
        {
            "name": "arrayItem",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        {
            "name": "arraySize",
            "type": "Number"
        }
    ],
    "outputs": [
        {
            "name": "collectedArray",
            "type": "Array"
        },
    ],
    "configuration": {
        "collector": CONTEXT-DEPENDENT
    }
}

Nodes para lidar com dados no fluxo

Use os seguintes tipos de nós para lidar com dados em seu fluxo:

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

Para obter um exemplo, consulte Comece com exemplos de fluxos.

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

A seguir, mostramos a estrutura geral de um FlowNodeobjeto de prompt:

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

O PromptFlowNodeSourceConfigurationobjeto depende se você usa um prompt do Gerenciamento de prompts ou se você o define em linha:

  • Se você usar um prompt do Gerenciamento de Prompts, o objeto deverá estar na seguinte estrutura geral:

    {
    "resource": {
        "promptArn": "string"
    }
}

  • Se você definir um prompt em linha, siga as diretrizes para definir uma variante na guia API de Criar um prompt usando o Gerenciamento de Prompts (não há nenhum campo name nesse objeto, no entanto). O objeto usado deve estar na seguinte estrutura geral:

    {
    "inline": {
        "modelId": "string",
        "templateType": "TEXT",
        "templateConfiguration": {
            "text": {
                "text": "string",
                "inputVariables": [
                    {
                        "name": "string"
                    },
                    ...
                ]
            }
        },
        "inferenceConfiguration": {
            "text": {
                "maxTokens": int,
                "stopSequences": ["string", ...],
                "temperature": float,
                "topP": float
            }
        },
        "additionalModelRequestFields": {
            "key": "value",
            ...
        }
    }
}

Para aplicar uma grade de proteção do Amazon Bedrock Guardrails à sua solicitação ou à resposta gerada a partir dela, inclua o guardrailConfiguration campo e especifique a ID ou ARN da grade de proteção no guardrailIdentifier campo e a versão da grade de proteção no campo. guardrailVersion

Um nó de agente permite que você envie uma solicitação a um agente, que orquestra entre os FMs recursos associados para identificar e executar ações para um usuário final. Para obter mais informações, consulte Automatize tarefas em seu aplicativo usando agentes de IA.

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

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

A seguir, mostramos a estrutura geral de um 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"
        }
    }
}

Um nó da base de conhecimento permite que você envie uma consulta para uma base de conhecimento das Bases de Conhecimento Amazon Bedrock. Para obter mais informações, consulte Recupere dados e gere respostas de IA com as bases de conhecimento Amazon Bedrock.

Na configuração, forneça o knowledgeBaseId mínimo. Opcionalmente, você pode incluir os seguintes campos, dependendo do seu caso de uso:

  • modelId— Inclua um ID de modelo para usar se você quiser gerar uma resposta com base nos resultados recuperados. Para apresentar os resultados recuperados como uma matriz, omita o ID do modelo.

  • guardrailConfiguration— Inclua a ID ou ARN da grade de proteção, definida no Amazon Bedrock Guardrails no guardrailIdentifier campo e a versão da grade de proteção no campo. guardrailVersion

    nota

    As grades de proteção só podem ser aplicadas quando usadas RetrieveAndGenerate em um nó da base de conhecimento.

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

Veja a seguir a estrutura geral de um FlowNodeobjeto da base de conhecimento:

{
    "name": "string",
    "type": "KnowledgeBase",
    "inputs": [
       {
            "name": "retrievalQuery",
            "type": "String",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "retrievalResults" | "outputText",
            "type": "Array | String"
        }
    ],
    "configuration": {
        "knowledgeBase": {
            "knowledgeBaseId": "string",
            "modelId": "string",
            "guardrailConfiguration": {
                "guardrailIdentifier": "string",
                "guardrailVersion": "string"
            }
        }
    }
}

Um nó de armazenamento do S3 permite a você armazenar dados no fluxo em um local do Amazon S3. Na configuração, você especifica o bucket do S3 a ser usado para armazenamento de dados. As entradas no nó são o conteúdo a ser armazenado e a chave do objeto. O nó retorna o URI do local do S3 como a saída.

Veja a seguir a estrutura geral de um FlowNodeobjeto de armazenamento do S3:

{
    "name": "string",
    "type": "Storage",
    "inputs": [
        {
            "name": "content",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        {
            "name": "objectKey",
            "type": "String",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "s3Uri",
            "type": "String"
        }
    ],
    "configuration": {
        "retrieval": {
            "serviceConfiguration": {
                "s3": {
                    "bucketName": "string"
                }
            }
        }
    }
}

Um nó de recuperação do S3 permite a você recuperar dados de um local do Amazon S3 para introduzi-los no fluxo. Na configuração, você especifica o bucket do S3 do qual recupera os dados. A entrada no nó é a chave do objeto. O nó retorna o conteúdo do local do S3 como a saída.

nota

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

O seguinte mostra a estrutura geral de um objeto de recuperação FlowNodedo S3:

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

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

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

O seguinte mostra a estrutura geral de um FlowNodeobjeto de função λ:

{
    "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 um fluxo

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

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

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

Para obter mais informações sobre eventos do Lambda, consulte Lambda concepts no AWS Lambda Developer Guide.

Resposta Lambda para um fluxo

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

nota

O nó Lex depende do serviço Amazon Lex, que pode armazenar e usar o conteúdo do cliente para o desenvolvimento e a melhoria contínua de outros AWS serviços. Como AWS cliente, você pode optar por não ter seu conteúdo armazenado ou usado para melhorias no serviço. Para saber como implementar uma política de recusa do Amazon Lex, consulte AI services opt-out policies.

Um nó do Lex permite a você chamar um bot do Amazon Lex para processar um enunciado usando processamento de linguagem natural e identificar uma intenção, com base na definição do bot. Para obter mais informações, consulte o Amazon Lex Developer Guide.

Na configuração, especifique o nome do recurso da Amazon (ARN) do alias do bot e a localidade a serem usados. As entradas no nó são o enunciado e todos os atributos de solicitação ou os atributos de sessão que o acompanham. O nó retorna a intenção identificada como a saída.

nota

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

O seguinte mostra a estrutura geral de um 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"
        }
    }
}

Tabelas de resumo para tipos de nó

As tabelas a seguir resumem as entradas e as saídas permitidas para cada tipo de nó. Observe o seguinte:

  • Se um nome estiver marcado como Qualquer, você poderá fornecer qualquer string como o nome. Do contrário, você deve usar o valor especificado na tabela.

  • Se um tipo estiver marcado como Qualquer, você poderá especificar qualquer um dos seguintes tipos de dados: String, Número, Booliano, Objeto, Matriz. Do contrário, você deve usar o tipo especificado na tabela.

  • Atualmente, somente os nós Condição, Prompt e Função do Lambda permitem várias entradas que você possa definir por conta própria.

Tipos de nó lógico
Informações de entrada Informações de saída
Tipo de nó Entrada Name Tipo Saída Name Tipo
Entrada N/D N/D N/D O campo content na solicitação InvokeFlow. document Any
Saída Dados a serem retornados na resposta InvokeFlow. document Any N/D N/D N/D
Condição

Dados a serem enviados com base em uma condição.

(várias entradas permitidas)

 Any Any

Dados a serem enviados com base em uma condição.

(especifique condições para caminhos diferentes)

 Any Any
Iterador Uma matriz para a qual você deseja aplicar iterativamente os nós a seguir a cada membro. array Array Cada item da matriz arrayItem Any
O tamanho da matriz de entrada arraySize Número
Coletor Uma iteração que você deseja consolidar em uma matriz. arrayItem Any Uma matriz com todas as saídas do nó anterior anexadas. collectedArray Array
O tamanho da matriz de saída arraySize Número
Tipos de nó de processamento de dados
Informações de entrada Informações de saída
Tipo de nó Entrada Name Tipo Saída Name Tipo
Prompt

Um valor para preencher uma variável no prompt.

(várias entradas permitidas)

 ${variable-name} Any A resposta retornada pelo modelo. modelCompletion String
Armazenamento do S3 Dados a serem armazenados em um bucket do S3. content Any O URI do local do S3. s3Uri String
A chave de objeto a ser usada para o objeto do S3. objectKey String
Recuperação do S3 A chave de objeto para o objeto do S3. objectKey String Os dados a serem recuperados de um bucket do S3. s3Content Any
Agente O prompt a ser enviado ao agente. agentInputText String A resposta exibida do agente. agentResponse String
Qualquer atributo de prompt a ser enviado com o prompt. promptAttributes Objeto
Qualquer atributo de sessão a ser enviado com o prompt. sessionAttributes Objeto
Base de conhecimento A consulta a ser enviada para a base de conhecimento. retrievalQuery String Os resultados retornados ou a resposta gerada pela base de conhecimento. retrievalResults Array
Função do Lambda

Dados a serem enviados para a função.

(várias entradas permitidas)

 Any A resposta retornada pela função. functionResponse Any
Lex O enunciado a ser enviado para o bot. inputText String A intenção que o bot prevê para o enunciado. predictedIntent String
Qualquer atributo de solicitação a ser enviado com o enunciado. requestAttributes Objeto
Qualquer atributo de sessão a ser enviado com o enunciado. sessionAttributes Objeto