Personalize o comportamento do seu Amazon Bedrock Agent com orquestração personalizada - Amazon Bedrock

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

Personalize o comportamento do seu Amazon Bedrock Agent com orquestração personalizada

O Amazon Bedrock oferece a opção de personalizar a estratégia de orquestração do seu agente. A orquestração personalizada oferece controle total de como você deseja que seus agentes lidem com tarefas em várias etapas, tomem decisões e executem fluxos de trabalho.

Com a orquestração personalizada, você pode criar Amazon Bedrock Agents que podem implementar uma lógica de orquestração específica para seu caso de uso. Isso inclui fluxos de trabalho complexos de orquestração, etapas de verificação ou processos de várias etapas em que os agentes devem realizar várias ações antes de chegar a uma resposta final.

Para usar a orquestração personalizada para seu agente, crie uma função do AWS Lambda que descreva sua lógica de orquestração. A função controla como o agente responde à entrada fornecendo instruções ao processo de tempo de execução do Bedrock sobre quando e como invocar o modelo, quando invocar as ferramentas de ações e, em seguida, determinando a resposta final.

A opção de orquestração personalizada está disponível em todas as regiões da AWS onde o Amazon Bedrock Agents está disponível.

Você pode configurar a orquestração personalizada na API AWS Management Console ou por meio dela. Antes de continuar, verifique se sua AWS Lambda função está pronta para o teste.

Console

No console, você pode configurar a orquestração personalizada depois de criar o agente. Configure-os ao editar o agente.

Para visualizar ou editar a orquestração personalizada para seu agente

  1. Faça login na função AWS Management Console usando uma função do IAM com as permissões do Amazon Bedrock e abra o console do Amazon Bedrock em. https://console.aws.amazon.com/bedrock/

  2. No painel de navegação à esquerda, escolha Agentes. Escolha um agente na seção Agentes.

  3. Na página de detalhes do agente, na seção Rascunho de trabalho, selecione Rascunho de trabalho.

  4. Na página Rascunho de trabalho, na seção Estratégia de orquestração, escolha Editar.

  5. Na página Estratégia de orquestração, na seção Detalhes da estratégia de orquestração, escolha Orquestração personalizada.

  6. Para a função Lambda de orquestração personalizada, escolha a função Lambda no menu suspenso e, em Versão da função, escolha a versão.

  7. Para permitir que o agente use o modelo ao gerar respostas, ative Ativar modelo. Se essa configuração estiver desativada, o agente não a usará.

  8. Um banner verde aparece na parte superior da página indicando que as alterações foram salvas com sucesso.

  9. Para salvar as configurações, escolha uma das seguintes opções:

    1. Para permanecer na mesma janela para que você possa alterar dinamicamente a AWS Lambda função enquanto testa seu agente atualizado, escolha Salvar.

    2. Para salvar as configurações e retornar à página Rascunho de trabalho, escolha Salvar e sair.

  10. Para testar a orquestração personalizada do seu agente, escolha Preparar na janela Teste.

API

Para configurar a orquestração personalizada usando as operações de API, envie uma UpdateAgentsolicitação (consulte o link para ver os formatos de solicitação e resposta e detalhes do campo) com um endpoint de tempo de construção do Agents for Amazon Bedrock. Especifique o objeto como. orchestrationType CUSTOM_ORCHESTRATION

Exemplo de carga útil de orquestração no React

A seguir está um exemplo de reação que mostra a orquestração da cadeia de pensamento. Neste exemplo, após cada etapa, o agente do Amazon Bedrock solicita que o modelo preveja a próxima ação. Observe que o primeiro estado de qualquer conversa é sempreSTART. Eventos são as respostas que a função envia como resposta aos agentes do Amazon Bedrock.

function react_chain_of_thought_orchestration(event) {
                    const incomingState = event.state;
                    
                    let payloadData = '';
                    let responseEvent = '';
                    let responseTrace = '';
                    let responseAttribution = '';
                    
                    if (incomingState == 'START') {
                        // 1. Invoke model in start
                        responseEvent = 'INVOKE_MODEL';
                        payloadData = JSON.stringify(intermediatePayload(event));
                    }
                    else if (incomingState == 'MODEL_INVOKED') {
                       const stopReason = modelInvocationStopReason(event);
                       if (stopReason == "tool_use") {
                           // 2.a. If invoke model predicts tool call, then we send INVOKE_TOOL event
                           responseEvent = 'INVOKE_TOOL';
                              payloadData = toolUsePayload(event);
                    } 
                    else if (stopReason == "end_turn") {
                         // 2.b. If invoke model predicts an end turn, then we send FINISH event
                         responseEvent = 'FINISH';
                         payloadData = getEndTurnPayload(event);
                      }
                    }
                    else if (incomingState == 'TOOL_INVOKED') {
                        // 3. After a tool invocation, we again ask LLM to predict what should be the next step
                        responseEvent = 'INVOKE_MODEL';
                        payloadData = intermediatePayload(event);
                    } 
                    else {
                       // Invalid incoming state
                       throw new Error('Invalid state provided!');
                    }
                    
                       // 4. Create the final payload to send back to BedrockAgent
                       const payload = createPayload(payloadData, responseEvent, responseTrace, ...);
                       return JSON.stringify(payload);
                    }

Exemplo de carga útil de orquestração no Lambda

O exemplo a seguir mostra a orquestração da cadeia de pensamento. Neste exemplo, após cada etapa, o agente do Amazon Bedrock solicita que o modelo preveja a próxima ação. Observe que o primeiro estado de qualquer conversa é sempreSTART. Eventos são as respostas que a função envia como resposta aos agentes do Amazon Bedrock.

A estrutura de carga útil para orquestração Lambda

{
    "version": "1.0",
    "state": "START | MODEL_INVOKED | TOOL_INVOKED | APPLY_GUARDRAIL_INVOKED | user-defined",
    "input": {
        "text": "user-provided text or tool results in converse format"
    },
    "context": {
        "requestId": "invoke agent request id",
        "sessionId": "invoke agent session id",
        "agentConfiguration": {
            "instruction": "agent instruction>,
            "defaultModelId": "agent default model id",
            "tools": [{
                    "toolSpec": {...} 
                }
                ...
            ],
            "guardrails": {
                "version": "guardrail version",
                "identifier": "guardrail identifier"
            }
        },
        "session": [{
            "agentInput": "input utterance provided in invokeAgent",
            "agentOutput": "output response from invokeAgent",
            "intermediarySteps": [{
                "orchestrationInput": {
                    "state": "START | MODEL_INVOKED | TOOL_INVOKED | APPLY_GUARDRAIL_INVOKED | user defined",
                    "text": "..."
                },
                "orchestrationOutput": {
                    "event": "INVOKE_MODEL | INVOKE_TOOL | APPLY_GUARDRAIL | FINISH | user defined",
                    "text": "Converse API request or text"
                }
            }]
        }],
        "sessionAttributes": {
            key value pairs
        },
        "promptSessionAttributes": {
            key value pairs
        }
    }
}

A estrutura de carga útil da orquestração lambda

{
    "version": "1.0",
    "actionEvent": "INVOKE_MODEL | INVOKE_TOOL | APPLY_GUARDRAIL | FINISH | user defined",
    "output": {
        "text": "Converse API request for INVOKE_MODEL, INVOKE_TOOL, APPLY_GUARDRAIL or text for FINISH",
        "trace": {
            "event": {
                "text": "Trace message to emit as event in InvokeAgent response"
            }
        }
    },
    "context": {
        "sessionAttributes": {
            key value pairs
        },
        "promptSessionAttributes": {
            key value pairs
        }
    }
}

Exemplo de um START_STATE enviado do Amazon Bedrock Agents para o orquestrador Lambda

{
    "version": "1.0",
    "state": "START",
    "input": {
        "text": "{\"text\":\"invoke agent input text\"}"
    },
    "context": {
        ...
    }
}

Em resposta, se a orquestração Lambda decidir enviar uma resposta INVOKE_MODEL EVENT, ela poderá ser semelhante à seguinte:

{
    "version": "1.0",
    "actionEvent": "INVOKE_MODEL",
    "output": {
        "text": "converse API request",
        "trace": {
            "event": {
                "text": "debug trace text"
            }
        }
    },
    "context": {}
}

Exemplo de um INVOKE_TOOL_EVENT usando Converse API 

{
    "version": "1.0",
    "actionEvent": "INVOKE_TOOL",
    "output": {
        "text": "{\"toolUse\":{\"toolUseId\":\"unique id\",\"name\":\"tool name\",\"input\":{}}}"
    }
}