Tipos de nó para o fluxo

Cada fluxo só contém um nó de entrada do 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.

Isto mostra a estrutura geral de um objeto FlowNode 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.

Isto mostra a estrutura geral de um objeto FlowNode 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.

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:

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:

Na API, você define o seguinte no campo definition ao enviar uma solicitação CreateFlow ou UpdateFlow:

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.

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

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.

Isto mostra a estrutura geral de um objeto FlowNode 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
    }
}

Um nó de loop DoWhile executa uma sequência de nós repetidamente enquanto uma condição especificada permanece verdadeira. O loop é executado pelo menos uma vez antes de avaliar a condição, tornando-o ideal para cenários em que é necessária realizar uma ação e depois verificar se ela deve ser repetida com base no resultado.

O nó do loop DoWhile obtém os dados de entrada e os transmite por meio do corpo do loop. Depois de cada iteração, a condição é avaliada para determinar se o loop deve continuar ou ser interrompido. O loop continuará enquanto a condição for avaliada como verdadeira ou valor maxIterations não for excedido.

Isto mostra a estrutura geral de um objeto FlowNode do loop DoWhile:

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

Na configuração:

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 Experimentar fluxos de exemplo.

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

Isto mostra a estrutura geral de um objeto FlowNode 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 objeto PromptFlowNodeSourceConfiguration depende se você usa um prompt do Gerenciamento de Prompts ou se o define em linha:

Para aplicar uma barreira de proteção das Barreiras de Proteção do Amazon Bedrock ao seu prompt ou à resposta gerada com base nele, inclua o campo guardrailConfiguration e especifique o ID ou ARN da barreira de proteção no campo guardrailIdentifier e a versão da barreira de proteção no campo guardrailVersion.

Um nó de agente permite que você envie um prompt a um agente, que orquestra entre FMs e recursos associados para identificar e realizar ações para um usuário final. Para obter mais informações, consulte Automatizar tarefas em sua aplicação 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ó de agente pode comportar 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ó de 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 o respectivo processamento com a nova entrada. Isso continua até que o nó do agente tenha todas as informações necessárias para concluir a respectiva execução.

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

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

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

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.

Isto mostra a estrutura geral de um objeto FlowNode 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 bucket 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.

Isto mostra a estrutura geral de um objeto FlowNode de armazenamento 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.

Isto mostra a estrutura geral de um objeto FlowNode de recuperação do 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ó do Lambda em um fluxo, o Amazon Bedrock envia um evento de entrada à função do Lambda especificada.

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.

Isto mostra a estrutura geral de um objeto FlowNode da função do 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 do 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 do Lambda a um fluxo

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

Um nó de código inline permite que você escreva e execute código diretamente em seu fluxo, possibilitando transformações de dados, lógica personalizada e integrações sem usar uma função externa do Lambda. Quando você inclui um nó de código inline em seu fluxo, o Amazon Bedrock executa o código em um ambiente isolado e gerenciado pela AWS que não é compartilhado com ninguém e não tem acesso à internet.

Na configuração do nó, especifique o código a ser executado e a linguagem de programação (no momento, Python_3 é a única opção). Defina entradas que seu código possa acessar como variáveis. O resultado da última linha executada em seu código é exibido como a saída do nó.

Isto mostra a estrutura geral de um objeto FlowNode um código inline:

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

Considerações ao usar nós de código inline

Ao usar nós de código inline no seu fluxo, considere o seguinte:

Entradas de nó de código inline

As entradas que você define para um nó de código inline estão disponíveis como variáveis do Python em seu código. Por exemplo, se você definir uma entrada chamada userData, poderá acessá-la diretamente no seu código como userData.

O valor de cada entrada é preenchido com base na expressão que você define. Por exemplo, se a entrada para o nó for {"name": "John", "age": 30} e a expressão for $.name, o valor da variável de entrada será "John".

Saída de nó de código inline

O resultado da última linha executada em seu código é exibido como a saída do nó do código inline. Essa saída está disponível para os nós subsequentes do fluxo.

Por exemplo, o seguinte código exibe um dicionário como saída do nó:

# Process input data
result = {"processed": True, "data": userData}

# The last line's result is returned as the node output
result

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.

Isto mostra a estrutura geral de um objeto FlowNode do 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"
        }
    }
}