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

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 imediato

O Amazon Bedrock fornece os seguintes tipos de nós para criar seu fluxo imediato. 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. NoAPI, use o type campo e o correspondente FlowNodeConfigurationno configuration campo.

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

  • Saídas — Forneça 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, consulteTipos de nós lógicos.

    • 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ó. NoAPI, use o apropriado FlowNodeConfiguratione preencha seus campos.

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

Nodes para controlar a lógica de fluxo imediato

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

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

O seguinte mostra a estrutura geral de um FlowNodeobjeto de entrada noAPI:

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

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

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

Veja a seguir 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ó condicional envia dados do nó anterior para nós diferentes, dependendo das condições definidas. Um nó condicional pode receber várias entradas.

Para ver um exemplo, consulte Crie um fluxo com um nó de condição.

Para definir um nó de condição

  1. Adicione quantas entradas forem necessárias para avaliar as condições que você planeja 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 à saída relevante de um nó upstream.

  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 em ordem. Se mais de uma condição for satisfeita, a condição anterior terá precedência.

    3. Conecte cada condição ao nó downstream 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 a um valor usando qualquer um dos seguintes operadores relacionais:

Operador Significado Tipos de dados compatíveis Exemplo de uso Exemplo de significado
== Igual a (o tipo de dados também deve ser igual) Cadeia de caracteres, número, booleano A == B Se A é igual a B
!= Não é igual a Cadeia de caracteres, número, booleano UM! = 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 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 ou igual a B

Você pode comparar as 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 chamadaexpenses, ambas profit > expenses profit <= 1000 são expressões válidas.

Você pode usar os seguintes operadores lógicos para combinar expressões para condições mais complexas. Recomendamos que você use parênteses para resolver ambigüidades no agrupamento de expressões:

Operador Significado Exemplo de uso Exemplo de significado
e 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
ou Pelo menos uma expressão é verdadeira (UMA! = 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)

NoAPI, 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 FlowConnection objeto é 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": "Data",
    "configuration": {
        "condition": "default",
        "condition": "string"
        ...
    }
}

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

Um nó iterador pega uma matriz e retorna iterativamente seus itens como saída para o nó downstream. 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 a jusante 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ê pode usar um nó coletor a jusante de um nó iterador para coletar os itens iterados depois de enviá-los por 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 imediato

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

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 Crie e armazene avisos reutilizáveis com o gerenciamento de alertas no Amazon Bedrock.

Para ver um exemplo, consulte Comece com exemplos de fluxos imediatos.

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

Veja a seguir a estrutura geral de um FlowNodeobjeto 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)
        }
    }
}

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 Prompt management, o objeto deverá estar na seguinte estrutura geral:

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

  • Se você definir um prompt embutido, siga as orientações para definir uma variante na API guia de Crie um prompt usando o gerenciamento de prompts (observe que não há nenhum name campo nesse objeto, no entanto). O objeto que você usa 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,
                "topK": int,
                "topP": float
            }
        }
    }
}

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

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

nota

Atualmente, o agente não oferece suporte a invocações em vários turnos. Você não pode configurar o retorno do controle para o agente em um fluxo.

O seguinte mostra 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. Para obter mais informações, consulte Recupere dados e gere respostas de IA com bases de conhecimento.

Na configuração, forneça o ID da base de conhecimento e um ID do modelo para usar se você quiser gerar uma resposta com base nos resultados recuperados. Para retornar os resultados recuperados como uma matriz, omita o ID do modelo. 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",
            "type": "Array | String"
        }
    ],
    "configuration": {
        "knowledgeBase": {
            "knowledgeBaseId": "string",
            "modelId": "string"
        }
    }
}

Um nó de armazenamento S3 permite que você armazene dados no fluxo em um local do Amazon S3. Na configuração, você especifica o bucket 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 a localização URI do S3 como 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 que você recupere dados de um local do Amazon S3 para introduzi-los no fluxo. Na configuração, você especifica o bucket do S3 do qual recuperar os dados. A entrada no nó é a chave do objeto. O nó retorna o conteúdo no local do S3 como saída.

nota

Atualmente, os dados no local do S3 devem ser uma string codificada UTF em -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ó de função Lambda permite chamar uma função Lambda na qual você pode definir código para realizar a lógica de negócios. Quando você inclui um nó Lambda em um fluxo de prompt, o Amazon Bedrock envia um evento de entrada para a função Lambda que você especifica.

Na configuração, especifique o Amazon Resource Name (ARN) da função Lambda. Defina as entradas a serem enviadas no evento de entrada do Lambda. Você pode escrever 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 imediato

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

{
   "messageVersion": "1.0",
   "flow": {
        "flowArn": "string",
        "flowAliasArn": "string"
   },
   "node": {
        "name": "string",
        "nodeInputs": [
            {
               "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ó Lambda, enquanto o valor do value campo é preenchido com toda a entrada no nó após ser resolvido pela expressão. Por exemplo, se toda a entrada no nó for [1, 2, 3] e a expressão for$.data[1], o valor enviado no evento de entrada para a função Lambda seria. 2

Para obter mais informações sobre eventos no Lambda, consulte Conceitos do Lambda no AWS Lambda Guia do desenvolvedor.

Resposta Lambda para um fluxo imediato

Ao escrever uma função Lambda, você define a resposta retornada por ela. Essa resposta é retornada ao seu fluxo de prompts 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 um 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 exclusão para o Amazon Lex, consulte Políticas de exclusão de serviços de IA.

Um nó Lex permite que você chame 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 Guia do desenvolvedor do Amazon Lex.

Na configuração, especifique o Amazon Resource Name (ARN) do alias do bot a ser usado e a localidade a ser usada. As entradas no nó são o enunciado e quaisquer atributos de solicitação ou de sessão que o acompanham. O nó retorna a intenção identificada como saída.

nota

Atualmente, o nó Lex não suporta conversas em vários turnos. Um nó 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ós

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

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

  • Se um tipo estiver marcado como Qualquer, você poderá especificar qualquer um dos seguintes tipos de dados: Cadeia de caracteres, Número, Booleano, Objeto, Matriz. Caso contrário, você deverá usar o tipo especificado na tabela.

  • Atualmente, somente os nós de função Condition, Prompt e Lambda permitem várias entradas que você mesmo pode definir.

Tipos de nós lógicos
Informações de entrada Informações de saída
Tipo de nó Entrada Nome Tipo Saída Nome Tipo
Entrada N/D N/D N/D O content campo na InvokeFlow solicitação. document Any
Saída Dados a serem retornados na InvokeFlow resposta. 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 os seguintes nós iterativamente a cada membro. array Array Cada item da matriz arrayItem Any
O tamanho da matriz de entrada arraySize Número
Colecionador 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ós de processamento de dados
Informações de entrada Informações de saída
Tipo de nó Entrada Nome Tipo Saída Nome 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 S3 Dados a serem armazenados em um bucket do S3. content Any A localização URI do S3. s3Uri String
A chave do objeto a ser usada para o objeto S3. objectKey String
Recuperação do S3 A chave do objeto para o objeto S3 objectKey String Os dados a serem recuperados de um bucket do S3. s3Content Any
Atendente A solicitação a ser enviada ao agente. agentInputText String A resposta retornou do agente. agentResponse String
Qualquer atributo de prompt a ser enviado junto com o prompt. promptAttributes Objeto
Qualquer atributo de sessão a ser enviado junto 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 Lambda

Dados a serem enviados para a função.

(várias entradas permitidas)

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