Blog

O Cenário Empresarial: Da Necessidade ao Modelo Customizado

Organizações em todo o mundo vêm experimentando uma transformação estratégica: abandonar a dependência exclusiva de modelos de linguagem grandes e genéricos para desenvolver modelos de linguagem especializados (LLMs) ajustados finamente com seus próprios dados proprietários. Embora os modelos de fundação ofereçam capacidades gerais impressionantes, frequentemente ficam aquém quando aplicados às complexidades do ambiente corporativo — onde precisão, segurança, conformidade e conhecimento específico do domínio são não-negociáveis.

Para atender a essas demandas, as empresas estão adotando modelos mais eficientes, personalizados para seus dados internos e fluxos de trabalho. Ao fazer ajuste fino com documentos proprietários e terminologia específica do domínio, as organizações constroem modelos que entendem seu contexto único, resultando em respostas mais relevantes, governança de dados mais rigorosa e implantação simplificada em ferramentas internas. Esse movimento também representa uma estratégia para reduzir custos operacionais, melhorar a latência de inferência e manter maior controle sobre privacidade de dados.

Os Desafios da Escala: Quando a Complexidade Atrapalha a Inovação

Escalar o ajuste fino de LLMs para casos de uso empresariais apresenta obstáculos técnicos e operacionais genuínos. Muitas organizações enfrentam cadeias de ferramentas fragmentadas e crescente complexidade ao adotar técnicas avançadas de ajuste fino, como Low-Rank Adaptation (LoRA), QLoRA e Aprendizado por Reforço com Feedback Humano (RLHF).

Além disso, as demandas de recursos do treinamento de modelos grandes — incluindo limitações de memória e desafios de infraestrutura distribuída — frequentemente desaceleram a inovação e sobrecarregam equipes internas. Esses problemas tornam a jornada do ajuste fino uma tarefa complexa que desvia tempo e atenção do foco principal: melhorar os modelos para aplicações específicas do negócio.

A Parceria Estratégica: Simplificando a Complexidade

Para superar esses desafios, Hugging Face e Amazon SageMaker AI uniram forças com o objetivo de simplificar e escalar a personalização de modelos. Integrando as bibliotecas Transformers da Hugging Face na infraestrutura totalmente gerenciada do SageMaker, as empresas podem agora:

• Executar trabalhos de ajuste fino distribuído já configurados, com suporte integrado para métodos de ajuste eficiente de parâmetros
• Usar configurações de computação e armazenamento otimizadas que reduzem custos de treinamento e melhoram a utilização de GPU
• Acelerar o tempo para gerar valor usando bibliotecas de código aberto conhecidas em um ambiente de nível produção

Essa colaboração ajuda empresas a focar na construção de LLMs específicos do domínio e de tamanho apropriado, desbloqueando valor de IA mais rapidamente enquanto mantêm controle total sobre seus dados e modelos.

Entendendo os Conceitos Fundamentais

A Biblioteca Transformers da Hugging Face

A biblioteca Transformers é um kit de ferramentas de código aberto projetado para ajuste fino de LLMs, permitindo experimentação contínua e implantação com modelos transformadores populares. Ela oferece:

• Milhares de modelos pré-treinados — Acesso a uma vasta coleção de modelos como BERT, Meta Llama, Qwen, T5 e muitos outros, utilizáveis para tarefas como classificação de texto, tradução, sumarização, resposta a perguntas, detecção de objetos e reconhecimento de fala
• API Pipelines — Simplifica tarefas comuns como análise de sentimento, sumarização e segmentação de imagem, tratando tokenização, inferência e formatação de saída em uma única chamada
• API Trainer — Fornece uma interface de alto nível para treinamento e ajuste fino, suportando precisão mista, treinamento distribuído e integração com aceleradores de hardware populares
• Ferramentas de Tokenização — Tokenizadores eficientes e flexíveis para converter texto bruto em entradas prontas para modelo, suportando múltiplos idiomas e formatos

SageMaker Training Jobs: Infraestrutura Totalmente Gerenciada

Os SageMaker Training Jobs oferecem um serviço de aprendizado de máquina totalmente gerenciado e sob demanda que executa remotamente na infraestrutura AWS para treinar um modelo com seus dados, código e recursos computacionais escolhidos. As principais capacidades incluem:

• Totalmente gerenciado — O SageMaker controla provisionamento de recursos, escala e gerenciamento, dispensando configuração manual de servidores ou clusters
• Entrada flexível — Suporta algoritmos integrados, contêineres pré-construídos ou scripts de treinamento customizados com frameworks populares como a biblioteca Transformers
• Escalável — Suporta treinamento em nó único ou distribuído entre múltiplas instâncias, adequado para workloads pequenos e em larga escala
• Integração com múltiplas fontes de dados — Dados de treinamento podem ser armazenados em Amazon Simple Storage Service (Amazon S3), Amazon FSx e Amazon Elastic Block Store (Amazon EBS)
• Customizável — Especifique hiperparâmetros, tipos de recurso (GPU ou CPU) e outras configurações para cada trabalho
• Opções econômicas — Recursos como managed Spot Instances, flexible training plans e heterogeneous clusters ajudam a otimizar custos

Visão Geral da Solução

O fluxo de trabalho integrado segue estas etapas principais:

1. O usuário prepara o dataset formatando-o com o estilo de prompt específico do modelo selecionado
2. O usuário prepara o script de treinamento usando a biblioteca Transformers da Hugging Face, especificando a configuração para a opção de distribuição escolhida (Distributed Data Parallel ou Fully-Sharded Data Parallel)
3. O usuário submete uma requisição à API do SageMaker AI, passando a localização do script de treinamento, a URI do contêiner de Treinamento Hugging Face e as configurações necessárias
4. O SageMaker AI usa um script de lançamento de trabalho para executar o workload em um cluster de computação gerenciado, orquestrando treinamento distribuído e descomissionando automaticamente o cluster após conclusão

Pré-requisitos para Iniciar

Antes de executar o ajuste fino, é necessário completar alguns passos preparatórios, incluindo:

• Solicitar aumentos de cota do SageMaker AI (mínimo de 1 instância p4d.24xlarge com 8 GPUs NVIDIA A100). Ferramentas como Can it run LLM ajudam a determinar o tamanho correto do cluster
• No console de Service Quotas, solicitar cotas do SageMaker AI necessárias
• Criar uma função AWS Identity and Access Management (IAM) com as políticas gerenciadas AmazonSageMakerFullAccess e AmazonS3FullAccess
• (Opcional) Criar um domínio Amazon SageMaker Studio para acessar Jupyter notebooks

Para orientações sobre permissões mais granulares em produção, consulte o SageMaker Developer Guide.

Preparando os Dados e o Script de Treinamento

Carregando e Formatando o Dataset

O exemplo prático utiliza o dataset UCSC-VLAA/MedReason, um dataset de raciocínio médico de alta qualidade projetado para resolver problemas médicos com explicações fiéis em LLMs. O processo envolve carregar o dataset, aplicar o template de chat apropriado usando o método apply_chat_template do tokenizador, dividir em conjuntos de treinamento, validação e teste, e fazer upload para S3 em formato JSON.

Configuração do Treinamento com Técnicas Avançadas

O script de treinamento para meta-llama/Llama-3.1-8B utiliza a classe Trainer (ou sua especialização SFTTrainer) junto com técnicas de otimização como Fully-Sharded Data Parallel (FSDP) para distribuir o treinamento e QLoRA para quantizar o modelo a 4 bits enquanto anexa pequenos adaptadores de baixo nível.

A configuração é definida em um arquivo YAML com hiperparâmetros como taxa de aprendizado, épocas, tamanho de lote, dropout, e parâmetros FSDP específicos. O arquivo de configuração é enviado para S3 e referenciado durante a submissão do trabalho de treinamento.

Executando o Treinamento com SageMaker

Para executar o ajuste fino, usa-se a classe ModelTrainer do SDK Python, fornecendo detalhes como tipo de instância (ml.p4d.24xlarge), URI da imagem de treinamento, configuração de código fonte, canais de entrada para dados e configuração, e condições de parada.

Após configurar todos os parâmetros e submeter o trabalho via model_trainer.train(), o SageMaker gerencia toda a infraestrutura. Para o exemplo com 10.000 amostras, o treinamento de uma época leva aproximadamente 18 minutos.

Implantação e Teste do Modelo Ajustado

Após o treinamento, o modelo pode ser avaliado de várias formas: usando um trabalho adicional de treinamento com avaliação automática, implantando em um SageMaker real-time endpoint, ou usando o MedReason evaluation script para comparações detalhadas.

Na abordagem de implantação, cria-se um modelo do SageMaker usando um contêiner otimizado com configurações de vLLM (número de GPUs, tipo de dados, tamanho máximo de modelo), define-se uma configuração de endpoint especificando tipo e quantidade de instâncias, e implanta-se o modelo. Após 5-10 minutos, o endpoint está pronto para receber requisições de inferência.

Resultados Práticos

O modelo ajustado demonstra capacidades robustas de raciocínio, fornecendo explicações estruturadas e detalhadas com processos de pensamento claros antes de chegar à resposta final. Essa melhoria é resultado direto da combinação entre a biblioteca Transformers da Hugging Face, técnicas distribuídas de treinamento e a infraestrutura gerenciada do SageMaker AI.

Limpeza de Recursos

Para evitar incidentes de custo, é importante eliminar recursos não utilizados após o término dos experimentos. Isso inclui endpoints do SageMaker, domínios do Studio (se criados) e verificação de que trabalhos de treinamento não estão mais em execução.

Conclusão

A integração entre Hugging Face e Amazon SageMaker AI transforma o ajuste fino de modelos de linguagem de um processo complexo e intensivo em recursos em um fluxo contínuo, escalável e pronto para produção. Usando técnicas como FSDP e LoRA, as organizações podem reduzir tempo de treinamento e custos sem comprometer qualidade do modelo.

Essa solução aborda desafios empresariais comuns como cadeias de ferramentas fragmentadas, requisitos altos de memória e computação, e ineficiências em escala multi-nó. Para começar seu próprio projeto de ajuste fino, explore os exemplos de código disponíveis no GitHub repository. Consulte também a SageMaker Python SDK documentation para aprofundamento técnico e managed warm pools para otimizar a fase de experimentação.

Fonte

Scale LLM fine-tuning with Hugging Face and Amazon SageMaker AI (https://aws.amazon.com/blogs/machine-learning/scale-llm-fine-tuning-with-hugging-face-and-amazon-sagemaker-ai/)

Validação Inteligente de Respostas com Verificação de Raciocínio

A AWS publicou uma nova implementação de chatbot de código aberto que demonstra como usar feedback de verificação automatizada de raciocínio lógico para melhorar iterativamente o conteúdo gerado, formular perguntas de esclarecimento e comprovar a correção das respostas. A solução não apenas itera sobre as respostas, mas também produz um registro de auditoria completo que inclui explicações matematicamente verificáveis sobre a validade das respostas, além de uma interface de usuário que permite aos desenvolvedores visualizar todo o processo iterativo de reescrita que ocorre nos bastidores.

O Diferencial: Raciocínio Lógico vs. Intuição de Modelos

Diferentemente dos modelos de linguagem de grande escala, ferramentas de verificação automatizada de raciocínio não funcionam por predição ou estimativa probabilística. Em vez disso, utilizam dedução lógica e provas matemáticas para demonstrar automaticamente que uma afirmação está correta. Essa abordagem baseada em provas formais oferece conformidade verificável com políticas definidas — algo fundamental para ambientes regulados.

Por Que Isso Importa: Reduzindo Alucinações e Aumentando Confiabilidade

Modelos de linguagem podem gerar respostas que parecem convincentes, mas contêm erros factuais. Esse fenômeno é conhecido como alucinação. A verificação automatizada de raciocínio valida tanto as perguntas do usuário quanto as respostas geradas pelo modelo, fornecendo feedback de reescrita que identifica afirmações ambíguas, asserções muito amplas e alegações factualmente incorretas. Quando um chatbot utiliza essa validação para iterar sobre suas respostas antes de apresentá-las ao usuário, dois benefícios críticos emergem: melhor precisão, porque o sistema faz afirmações precisas que respondem diretamente às perguntas sem deixar espaço para ambiguidade, e melhor transparência, porque consegue fornecer provas matematicamente verificáveis de por que suas afirmações estão corretas. Isso torna aplicações de IA generativa auditáveis e explicáveis, mesmo em ambientes altamente regulados.

A Arquitetura da Solução de Referência

Componentes Principais da Interface

A implementação é uma aplicação Flask que expõe APIs para enviar perguntas e verificar o status das respostas. Para revelar o funcionamento interno do sistema, as APIs também permitem recuperar informações sobre o status de cada iteração, o feedback da verificação de raciocínio automatizado e o prompt de reescrita enviado ao modelo. A interface frontend em Node.js permite configurar um modelo de linguagem a partir do Amazon Bedrock para gerar respostas, selecionar uma política de verificação de raciocínio para validação e definir o número máximo de iterações para corrigir uma resposta. Quando você seleciona um thread de conversa na interface, um painel de debug abre do lado direito, exibindo cada iteração do conteúdo e o resultado da validação.

Uma vez que a verificação de raciocínio automatizado valida uma resposta, a explicação verificável dessa validade é exibida para o usuário, criando um nível de confiança explícito no resultado.

O Motor da Solução: O Loop Iterativo de Reescrita

Como Funciona a Validação

A implementação de referência de código aberto melhora automaticamente as respostas do chatbot através de iterações sobre o feedback de verificação de raciocínio e reformulação da resposta. Quando solicitada a validar uma pergunta e resposta (Q&A), a verificação de raciocínio automatizado retorna uma lista de achados. Cada achado representa uma declaração lógica independente identificada na Q&A.

Por exemplo, para a Q&A “Quanto custa o armazenamento S3? Na região US East (N. Virginia), S3 custa $0.023/GB nos primeiros 50TB; na região Asia Pacific (Sydney), S3 custa $0.025/GB nos primeiros 50TB”, a verificação de raciocínio automatizado produziria dois achados: um validando que o preço para S3 em us-east-1 é $0.023 e outro para ap-southeast-2.

Estrutura de Premissas e Alegações

Ao analisar um achado para uma Q&A, a verificação de raciocínio automatizado separa a entrada em uma lista de premissas factuais e alegações verificadas contra essas premissas. Uma premissa pode ser uma declaração factual na pergunta do usuário, como “Sou um usuário de S3 na Virgínia”, ou uma suposição apresentada na resposta, como “Para requisições enviadas para us-east-1…”. Uma alegação representa uma afirmação sendo verificada. No exemplo de preço do S3, a região seria uma premissa e o ponto de preço seria a alegação.

Tipos de Achados e Feedback

Cada achado inclui um resultado de validação (VALID, INVALID, SATISFIABLE, TRANSLATION_AMBIGUOUS, IMPOSSIBLE) junto com o feedback necessário para reformular a resposta de modo que fique VALID. O feedback muda dependendo do tipo de resultado. Achados ambíguos incluem duas interpretações do texto de entrada, achados satisfatórios incluem dois cenários que demonstram como as alegações podem ser verdadeiras em alguns casos e falsas em outros. A documentação da API oferece detalhes sobre todos os tipos de achados possíveis.

O Fluxo de Validação Inicial

Quando o usuário envia uma pergunta pela interface, a aplicação primeiro chama o Modelo de Linguagem de Grande Escala (LLM) configurado no Bedrock para gerar uma resposta, depois chama a API ApplyGuardrail para validar a Q&A. Utilizando o resultado da verificação de raciocínio automatizado na resposta do ApplyGuardrail, a aplicação entra em um loop onde cada iteração verifica o feedback da verificação de raciocínio, executa uma ação como pedir ao LLM para reformular a resposta com base no feedback e depois chama ApplyGuardrail novamente para validar o conteúdo atualizado.

O Loop Central: Priorização e Reescrita

Após a validação inicial, o sistema utiliza o resultado da verificação de raciocínio automatizado para decidir o próximo passo. Primeiro, ordena os achados por prioridade — endereçando os mais importantes primeiro: TRANSLATION_AMBIGUOUS, IMPOSSIBLE, INVALID, SATISFIABLE, VALID. Em seguida, seleciona o achado de maior prioridade e o endereça seguindo esta lógica:

Para achados TRANSLATION_AMBIGUOUS, a verificação de raciocínio automatizado retorna duas interpretações do texto de entrada. Para achados SATISFIABLE, a verificação retorna dois cenários que provam e refutam as alegações. Usando esse feedback, a aplicação pergunta ao LLM se deseja tentar reformular a resposta para esclarecer ambiguidades ou fazer perguntas de acompanhamento para reunir informações adicionais. Por exemplo, o feedback SATISFIABLE pode indicar que o preço de $0.023 é válido apenas se a região for US East (N. Virginia). O LLM pode então usar essa informação para pergunta sobre a região da aplicação.

Quando o LLM decide fazer perguntas de acompanhamento, o loop pausa e aguarda a resposta do usuário, então o LLM regenera a resposta com base nas clarificações e o loop recomeça.

Para achados IMPOSSIBLE, a verificação de raciocínio automatizado retorna uma lista de regras que contradizem as premissas — fatos aceitos no conteúdo de entrada. Usando esse feedback, a aplicação pede ao LLM para reformular a resposta evitando inconsistências lógicas.

Para achados INVALID, a verificação de raciocínio automatizado retorna as regras da política de verificação que tornam as alegações inválidas com base nas premissas e regras de política. Usando esse feedback, a aplicação pede ao LLM para reformular sua resposta de modo que seja consistente com as regras.

Para achados VALID, a aplicação sai do loop e retorna a resposta ao usuário. Após cada reescrita, o sistema envia a Q&A para a API ApplyGuardrail para validação; a próxima iteração do loop começa com o feedback dessa chamada. Cada iteração armazena os achados e prompts com contexto completo na estrutura de dados do thread, criando uma trilha de auditoria de como o sistema chegou à resposta definitiva.

Como Começar com a Implementação

Preparando o Ambiente

Para experimentar essa implementação de referência, o primeiro passo é criar uma política de verificação de raciocínio automatizado. Navegue até o Amazon Bedrock no console AWS em uma das regiões suportadas nos Estados Unidos ou regiões europeias. No menu de navegação esquerdo, acesse a página de Verificação de Raciocínio Automatizado na categoria Construir. Usando o menu suspenso do botão Criar política, escolha Criar política de amostra. Digite um nome para a política e selecione Criar política na parte inferior da página.

Uma vez criada a política, você pode baixar e executar a implementação de referência: Clone o repositório de Amostras do Amazon Bedrock. Siga as instruções no arquivo README para instalar dependências, compilar o frontend e iniciar a aplicação. Usando seu navegador preferido, navegue para http://localhost8080 e comece a fazer testes.

Arquitetura Backend: Componentes Chave

Se você está planejando adaptar essa implementação para uso em produção, esta seção aborda os componentes principais na arquitetura backend. Você encontrará esses componentes no diretório backend do repositório.

ThreadManager: Orquestração de Conversas

Orquestra o gerenciamento do ciclo de vida da conversa. Manipula a criação, recuperação e rastreamento de status dos threads de conversa, mantendo o estado adequado durante todo o processo de reescrita. O ThreadManager implementa operações thread-safe usando um lock para ajudar a prevenir condições de corrida quando múltiplas operações tentam modificar a mesma conversa simultaneamente. Também rastreia threads aguardando entrada do usuário e consegue identificar threads obsoletos que ultrapassaram um timeout configurável.

ThreadProcessor: Máquina de Estados para o Loop Iterativo

Manipula o loop de reescrita usando um padrão de máquina de estados para fluxo de controle claro e mantível. O processador gerencia transições de estado entre fases como GENERATE_INITIAL, VALIDATE, CHECK_QUESTIONS, HANDLE_RESULT e REWRITING_LOOP, progredindo a conversa corretamente através de cada estágio.

ValidationService: Integração com Guardrails do Bedrock

Integra-se com o Guardrails do Amazon Bedrock. Este serviço pega cada resposta gerada pelo LLM e a submete para validação usando a API ApplyGuardrail. Ele gerencia a comunicação com AWS, implementa lógica de retry com backoff exponencial para falhas transitórias e transforma os resultados de validação em achados estruturados.

LLMResponseParser: Interpretação de Intenções do Modelo

Interpreta as intenções do LLM durante o loop de reescrita. Quando o sistema pede ao LLM para corrigir uma resposta inválida, o modelo deve decidir se tenta uma reescrita (REWRITE), faz perguntas de esclarecimento (ASK_QUESTIONS), ou declara a tarefa impossível devido a premissas contraditórias (IMPOSSIBLE). O analisador examina a resposta do LLM procurando por marcadores específicos como “DECISION:”, “ANSWER:” e “QUESTION:”, extraindo informações estruturadas de saída em linguagem natural. Ele lida graciosamente com formatação markdown e impõe limites no número de perguntas (máximo 5).

AuditLogger: Registro e Auditoria

Escreve logs estruturados em JSON em um arquivo de log de auditoria dedicado, registrando dois tipos principais de eventos: VALID_RESPONSE quando uma resposta passa na validação e MAX_ITERATIONS_REACHED quando o sistema esgota o número definido de tentativas. Cada entrada de auditoria captura timestamp, ID do thread, prompt, resposta, ID do modelo e achados de validação. O logger também extrai e registra trocas de Q&A de iterações de esclarecimento, incluindo se o usuário respondeu ou pulou as perguntas.

Integrando os Componentes

Juntos, esses componentes criam uma fundação robusta para construir aplicações de IA confiáveis que combinam a flexibilidade dos modelos de linguagem de grande escala com o rigor da verificação matemática.

Recursos Adicionais e Aprendizado

Para orientação detalhada sobre implementação de verificação de raciocínio automatizado em produção, a AWS oferece vários recursos: um workshop sobre confiabilidade de IA generativa com verificação de raciocínio automatizado, um blog técnico sobre como minimizar alucinações de IA generativa com verificação de raciocínio automatizado do Amazon Bedrock, um blog de caso de uso sobre construção de explicabilidade verificável em workflows de serviços financeiros com verificação de raciocínio automatizado para Guardrails do Amazon Bedrock, e a documentação do Guia do Usuário Amazon Bedrock Guardrails.

Fonte

Automated Reasoning checks rewriting chatbot reference implementation (https://aws.amazon.com/blogs/machine-learning/automated-reasoning-checks-rewriting-chatbot-reference-implementation/)

O Problema do Agente Único Sobrecarregado

Os primeiros protótipos de sistemas baseados em agentes de inteligência artificial costumam compartilhar a mesma arquitetura: um único modelo grande, alguns conectores para ferramentas externas e um extenso prompt de sistema. Essa abordagem funciona razoavelmente bem enquanto os casos de uso permanecem relativamente simples e contidos. No entanto, quando a complexidade real do mundo chega à porta, o sistema começa a desmoronar.

Considere um cenário comum: construir um assistente para planejamento de viagens. As buscas de voos chegam através de uma API estruturada e previsível. As buscas de hotéis, por sua vez, precisam navegar em interfaces web dinâmicas que mudam constantemente. Instruir um único modelo para lidar com ambas as tarefas simultaneamente é como pedir que um engenheiro escreva APIs de backend enquanto também clica manualmente em um site em tempo real. Com o tempo, o modelo começa a confundir instruções, perde contexto e alucina etapas inexistentes.

Aumentar o prompt, adicionar mais ferramentas e implementar lógica de fallback não resolve o problema fundamental: o sistema foi projetado de forma inadequada. Um agente único, quando sobrecarregado com muitas responsabilidades, desacelera, perde rastreabilidade das decisões, faz escolhas inconsistentes e eventualmente colapsa sob seu próprio peso. A solução não está em melhorar o prompting — está em reimaginar a arquitetura.

Arquitetura de Múltiplos Agentes Especializados

A estratégia mais eficaz é dividir o trabalho entre agentes especializados, permitindo que cada um se concentre em uma única responsabilidade bem definida. Em vez de forçar um modelo a fazer tudo, designa-se:

• Agente Viagem: Orquestra todo o fluxo, interpreta a intenção do usuário e coordena os demais agentes
• Agente Voos: Realiza buscas estruturadas em APIs de voos, onde os dados são previsíveis e organizados
• Agente Hotéis: Navega em sites reais de hotéis, lidando com layouts dinâmicos e elementos visuais complexos

Essa separação mantém a lógica limpa e evita que agentes individuais se tornem os gargalos do sistema. Cada um executa sua função com excelência, e um simples mecanismo de passagem de mensagens coordena todo o workflow sem complicações.

Comunicação Entre Agentes

Para que essa arquitetura funcione, os agentes precisam de um mecanismo simples e robusto para se comunicar. O Agente Viagem envia uma solicitação clara ao Agente Voos, aguarda os resultados, e então dispara o Agente Hotéis com a próxima etapa. Não é necessário nada sofisticado — apenas um formato leve de mensagens estruturadas em JSON que cada agente compreenda e saiba como processar.

Quando esse loop de comunicação está em lugar, todo o workflow finalmente se sente coordenado em vez de caótico. Cada mensagem é um objeto JSON compacto contendo a ação, os dados de entrada e o destino da resposta. Essa simplicidade é o segredo para manter o sistema compreensível e manutenível conforme ele cresce.

Implementação Prática com Amazon Nova

Agente Viagem (Amazon Nova 2 Lite)

O Agente Viagem atua como o orquestrador central. Recebe a requisição do usuário em linguagem natural, interpreta a intenção usando Amazon Nova 2 Lite e decide quais agentes chamar em sequência. A tarefa pesada de raciocínio acontece aqui: o modelo quebra a entrada em etapas, identifica quando disparar o Agente Voos ou o Agente Hotéis, e mantém o registro do plano geral.

Como o Agente Viagem não toca sistemas externos diretamente, seu trabalho concentra-se em raciocinar com clareza e rotear mensagens entre os agentes especializados. Ele opera sobre Amazon Bedrock, a plataforma gerenciada da AWS para modelos fundacionais.

Aqui está uma versão simplificada de como o Agente Viagem é inicializado:

# Initialize A2A client tools provider
provider = A2AClientToolProvider(known_agent_urls=[
    "http://localhost:9000",  # Hotel Booking Expert (NovaAct)
    "http://localhost:9001"   # Flight Booking Expert
])

bedrock_model = BedrockModel(
    model_id="global.amazon.nova-2-lite-v1:0",
    region_name="us-east-1",
)

# Create client agent with A2A tools
client_agent = Agent(
    name="Travel Client",
    model=bedrock_model,
    description="Client agent that coordinates travel planning using specialized A2A agents",
    tools=provider.tools,
    system_prompt="""You are an autonomous travel planning agent. You MUST take action immediately without asking for confirmation."""
)

Na prática, o Agente Viagem recebe uma requisição em linguagem natural simples: “Encontre voos de Nova York para Tóquio em 10 de julho e um hotel até 15 de julho.” A partir daí, Amazon Nova 2 Lite reconhece que duas tarefas separadas são necessárias, gera um plano claro, envia uma mensagem ao Agente Voos, aguarda os resultados, e depois dispara o Agente Hotéis com a próxima instrução. Por fim, monta ambas as saídas em uma resposta coerente para o usuário. Essa orquestração mantém a lógica limpa e fluida.

Agente Voos (Amazon Nova 2 Lite + API)

O Agente Voos tem um escopo muito mais estreito: transformar uma requisição estruturada em opções reais de voos. Utiliza Amazon Nova 2 Lite para o raciocínio leve necessário — validar entradas, formatar a busca e decidir se chama a API de voos ao vivo ou retorna dados de fallback quando credenciais não estão disponíveis.

Após a chamada à API, o agente devolve uma resposta JSON limpa e previsível ao Agente Viagem. Como esse agente trabalha com dados estruturados, a carga de raciocínio é mínima e o trabalho do Nova 2 Lite consiste principalmente em escolher o caminho correto de execução e normalizar a saída.

@tool
def search_flights(origin: str, destination: str, departure_date: str, return_date: Optional[str] = None) -> str:
    # Nova 2 Lite handles the reasoning around which path to take
    if amadeus_configured():
        return _search_amadeus_flights(
            origin=origin,
            destination=destination,
            departure_date=departure_date,
            return_date=return_date
        )
    else:
        # Local development fallback
        return _search_flights_web(origin, destination, departure_date, return_date)

E aqui está um exemplo simplificado da resposta:

{
    "flights": [
        {
            "flight_number": "DL456",
            "price": 520,
            "duration": "14h 30m"
        },
        {
            "flight_number": "JL701",
            "price": 545,
            "duration": "13h 50m"
        }
    ],
    "source": "Amadeus API"
}

Essa separação mantém todo o pipeline previsível e evita que lógica específica de API vaze para dentro do Agente Viagem.

Agente Hotéis (Amazon Nova Act)

Hotéis são fundamentalmente diferentes de voos. Não existe uma API única e limpa para consultá-los — a maioria dos sites carrega conteúdo de formas que mudam a cada visita. É nesse cenário que Amazon Nova Act brilha.

O Agente Hotéis utiliza Nova Act para controlar um navegador real e seguir instruções em linguagem natural. Em vez de escrever código frágil de web scraping ou parsing de DOM, o agente instrui o Nova Act sobre o que precisa, e o modelo cuida da navegação, retornando dados estruturados.

@tool
def search_hotels(location: str, checkin_date: str, nights: int = 2) -> str:
    with NovaAct() as nova:
        result = nova.act(
            f"Search for hotels in {location} from {checkin_date} for {nights} nights. "
            f"Return the top 3 listings with name, price, and rating.",
            schema=HotelSearchResults.model_json_schema()
        )
    return json.dumps(result)

Aqui está um exemplo simplificado da resposta:

{
    "hotels": [
        {
            "name": "Shinjuku Grand",
            "price": "$180",
            "rating": 4.3
        },
        {
            "name": "Park Tower Tokyo",
            "price": "$210",
            "rating": 4.6
        },
        {
            "name": "Hotel Blossom",
            "price": "$155",
            "rating": 4.0
        }
    ],
    "source": "Anycompany.com via Nova Act"
}

Usar Amazon Nova Act mantém o Agente Hotéis funcionando mesmo quando os sites mudam de layout. Não há necessidade de manutenção constante ou ajustes frágeis.

Exemplo de Execução Completa

Para ilustrar como tudo funciona na prática, aqui está um fluxo de execução real:

Requisição do usuário: “Organize uma viagem para uma pessoa de Nova York a Paris em 6 de dezembro de 2025, incluindo duas noites de hospedagem em Paris.”

Agente Viagem → Agente Voos: O Agente Viagem extrai a parte de voos da requisição e a envia. O Agente Voos retorna três voos diretos e baratos de JFK para Paris, incluindo companhia aérea, horários, preço e duração.

Agente Viagem → Agente Hotéis: O Agente Viagem envia a parte de hospedagem. O Agente Hotéis, utilizando Nova Act, consulta hotéis em Paris e retorna as três opções principais com nomes, preços e notas resumidas.

Resultado final para o usuário: O Agente Viagem combina ambas as respostas e retorna um resumo claro incluindo:

• O voo recomendado
• O hotel recomendado
• Data de check-in e check-out
• Preços totais
• Uma pergunta se deseja prosseguir com a reserva

Vantagens da Abordagem Multi-Agentes

Construir um planejador de viagens com três agentes pequenos e especializados provou ser muito mais fácil de gerenciar do que um único agente monolítico. Cada agente concentra-se em uma tarefa bem definida. Amazon Nova 2 Lite realiza o raciocínio necessário para mover o trabalho de uma etapa para a próxima. Amazon Nova Act cobre as partes sem APIs, como buscas de hotéis, sem exigir código de scraping manual.

O padrão de passagem de mensagens mantém tudo conectado mas ainda direto e compreensível. Essa arquitetura não se limita a planejamento de viagens. Qualquer tarefa que misture diferentes habilidades pode usar a mesma abordagem: deixe um agente planejar o trabalho, deixe os outros executarem as partes em que são especializados, e passe mensagens pequenas entre eles. O resultado é um sistema que muda e explica-se naturalmente.

Para experimentar essa implementação, o código completo e exemplos estão disponíveis no repositório Agent to Agent com Amazon Nova no GitHub.

Fonte

Agent-to-agent collaboration: Using Amazon Nova 2 Lite and Amazon Nova Act for multi-agent systems (https://aws.amazon.com/blogs/machine-learning/agent-to-agent-collaboration-using-amazon-nova-2-lite-and-amazon-nova-act-for-multi-agent-systems/)

Expansão geográfica do Neptune Analytics

A AWS anunciou a disponibilidade do Amazon Neptune Analytics em sete regiões adicionais: Oriente Médio (Bahrain), Oriente Médio (Emirados Árabes Unidos), Israel (Tel Aviv), África (Cidade do Cabo), Canadá (Calgary), Ásia-Pacífico (Malásia) e Europa (Zurique). Com essa expansão, os usuários podem agora criar e gerenciar gráficos do Neptune Analytics nessas novas regiões, abrindo possibilidades para executar análises gráficas avançadas em geografias que antes não tinham acesso ao serviço.

Sobre o Amazon Neptune

O Neptune é um banco de dados em grafo (graph database) sem servidor que trabalha com dados conectados. A abordagem baseada em grafos traz benefícios significativos, especialmente para aplicações de inteligência artificial: ao modelar dados como um grafo, o serviço captura o contexto relacional dos dados, o que melhora a precisão e a capacidade de explicação das aplicações de IA generativa.

Um dos principais diferenciais do Neptune é a escalabilidade automática. O serviço escala instantaneamente cargas de trabalho em grafo, eliminando a necessidade de o usuário gerenciar manualmente a capacidade infraestrutura — o que reduz a carga operacional e os custos.

Capacidades e integrações para IA

A AWS integrou o Neptune com tecnologias modernas de IA. O serviço oferece GraphRAG (Retrieval-Augmented Generation com grafos) totalmente gerenciado, funcionando em conjunto com o Amazon Bedrock Knowledge Bases. Além disso, o Neptune se integra ao Strands AI Agents SDK e a ferramentas populares de memória para agentes de IA, facilitando o desenvolvimento de aplicações inteligentes.

Na dimensão de análise, o Neptune consegue processar e analisar dezenas de bilhões de relacionamentos entre dados estruturados e não estruturados em segundos, entregando insights estratégicos que seriam impraticáveis em abordagens tradicionais.

Diferencial no mercado

Segundo a AWS, o Neptune é o único banco de dados e mecanismo de análise que combina o poder dos dados conectados com as capacidades empresariais e o valor agregado do ecossistema AWS.

Como começar

Para iniciar com o Neptune Analytics, os usuários podem criar novos gráficos usando o Console de Gerenciamento da AWS ou a AWS CLI (Interface de Linha de Comando da AWS). Para detalhes sobre precificação e disponibilidade em regiões, recomenda-se consultar a página de preços do Neptune e a tabela de regiões da AWS.

Fonte

Amazon Neptune Analytics is now available in 7 additional regions (https://aws.amazon.com/about-aws/whats-new/2026/02/amazon-neptune-analytics-in-seven-additional-regions)

Aplicações com agentes ganham velocidade com novo template completo

Aplicações inteligentes que funcionam como agentes autônomos estão transformando a forma como as empresas operam. De chatbots de atendimento ao cliente até assistentes de pesquisa, a demanda por mover protótipos para produção rapidamente nunca foi tão alta. Nesse contexto, a AWS lançou o Amazon Bedrock AgentCore, uma plataforma de desenvolvimento dedicada à construção, implantação e dimensionamento de agentes de IA em ambientes produtivos.

O AgentCore oferece componentes fundamentais como hospedagem do runtime, gerenciamento de memória, integração de ferramentas e observabilidade, tudo com segurança em nível empresarial e dimensionamento automático. Para demonstrar como todos esses componentes trabalham juntos desde o início, a AWS disponibilizou o Fullstack AgentCore Solution Template (FAST) — um projeto iniciante pronto para implantação que conecta runtime do AgentCore, gateway, memória e interpretador de código com um frontend em React e autenticação via Amazon Cognito, tudo definido com o AWS Cloud Development Kit (AWS CDK).

O FAST fornece uma arquitetura de referência completa mostrando como os componentes se integram na prática, acompanhado de uma aplicação de chat funcionando que você pode estudar e expandir conforme suas necessidades.

Entendendo a arquitetura do FAST

O template oferece uma pilha tecnológica completa para implantar agentes no Amazon Bedrock AgentCore. A solução gerencia automaticamente autenticação, hospedagem de aplicação frontend, runtime do agente, memória, observabilidade e integração de ferramentas via protocolo de contexto de modelo (Model Context Protocol — MCP) por padrão.

No núcleo da arquitetura está o Amazon Bedrock AgentCore Runtime, responsável por executar seu agente. Para segurança, os usuários se autenticam através do Amazon Cognito, que protege quatro pontos críticos de integração:

• Acesso do usuário à aplicação web frontend hospedada no Amazon CloudFront
• Autenticação baseada em token para o frontend acessar o AgentCore Runtime
• Autenticação baseada em token para que os agentes acessem o AgentCore Gateway
• Autenticação baseada em token para requisições de API ao Amazon API Gateway

O frontend é uma aplicação React que utiliza Tailwind CSS e componentes shadcn, hospedada no AWS Amplify Hosting. A comunicação com o AgentCore Runtime ocorre através de streaming HTTP em tempo real, permitindo respostas contínuas. O mecanismo de feedback integrado demonstra como realizar chamadas HTTP síncronas e autenticadas via API Gateway, armazenando dados de aplicação no DynamoDB.

Capacidades principais do AgentCore integradas

O runtime do AgentCore se conecta a diversas capacidades que potencializam o agente:

AgentCore Memory: Armazena histórico de conversas (curto prazo) e insights extraídos como preferências do usuário (longo prazo), permitindo que seu agente mantenha contexto entre sessões sem exigir trabalho customizado com banco de dados. O FAST inclui memória de curto prazo por padrão, sendo possível adicionar memória de longo prazo com pequenas modificações.

AgentCore Gateway: Expõe APIs como ferramentas compatíveis com Model Context Protocol (MCP) para seus agentes.

AgentCore Code Interpreter: Executa código Python de forma segura em ambientes isolados de sandbox.

AgentCore Observability: Envia métricas e logs compatíveis com Open Telemetry (OTEL) para o Amazon CloudWatch e rastreamentos para o AWS X-Ray.

O template inclui padrões tanto para Strands Agents quanto para LangGraph. Importante: o FAST e o AgentCore são agnósticos quanto ao framework de agentes, permitindo que você use o SDK de agentes que preferir. A infraestrutura é definida em AWS CDK, garantindo implantações repetíveis e consistentes.

Design preparado para desenvolvimento assistido por IA

O FAST foi concebido com documentação extensiva já integrada. O repositório inclui:

• Documentos de direcionamento — regras e convenções que assistentes de código seguem automaticamente
• Guias de funcionalidades — documentação detalhada sobre gateway, memória, streaming e outras integrações
• READMEs espalhados pelo código — contexto para cada componente

Quando você pede a um assistente de código que faça alterações, ele consegue ler esses documentos e seguir os padrões documentados. Esta abordagem funciona com diversos assistentes, incluindo Kiro, Cline, Claude Code, Cursor e outros. A documentação é independente de sistema específico.

Vale reforçar: o desenvolvimento assistido por IA é opcional. A mesma documentação que guia assistentes de código é igualmente útil para desenvolvedores que preferem escrever o código manualmente.

Preparando o ambiente

Antes de implantar o FAST, certifique-se de ter instalado:

• Node.js 20 ou posterior
• Python 3.11 ou posterior
• Docker
• AWS Command Line Interface (AWS CLI) configurada com as credenciais mínimas necessárias
• AWS CDK

O usuário de AWS Identity and Access Management (IAM) que você utilizar deve ter permissões para realizar as chamadas necessárias de serviço AWS e gerenciar os recursos mencionados. Ao conceder permissões, siga o princípio do menor privilégio.

Implantando o template passo a passo

Passo 1: Clonar o repositório

Comece clonando o repositório usando os comandos abaixo:

git clone https://github.com/awslabs/fullstack-solution-template-for-agentcore.git
cd fullstack-solution-template-for-agentcore

Passo 2: Configurar a implantação

Edite o arquivo infra-cdk/config.yaml para personalizar sua implantação:

stack_name_base: your-project-name
admin_user_email: admin@example.com # Opcional: cria usuário automaticamente e envia credenciais
backend:
  pattern: strands-single-agent # Disponível: strands-single-agent, langgraph-single-agent
  deployment_type: docker # Disponível: docker, zip

Passo 3: Implantar o backend com CDK

Execute os comandos para implantar o backend:

cd infra-cdk
npm install
cdk bootstrap # Necessário apenas uma vez por conta/região
cdk deploy

Este processo cria o User Pool do Cognito, constrói e envia o container do agente para o Amazon Elastic Container Registry (Amazon ECR), cria o AgentCore Runtime e configura a distribuição CloudFront. A implantação leva aproximadamente 5 a 10 minutos.

Passo 4: Implantar o frontend

Use o script para implantar a interface:

cd ..
python scripts/deploy-frontend.py

O script gera a configuração de autenticação a partir dos outputs da stack CDK, instala dependências, constrói a aplicação React e implanta no AWS Amplify Hosting. Ao finalizar, ele exibe a URL da aplicação:

✓ Deployment completed successfully!
Console: https://console.aws.amazon.com/amplify/apps
App URL: https://main.d123490abcdef.amplifyapp.com

Passo 5: Criar um usuário no Cognito

Se você informou um admin_user_email na configuração, receberá um email com credenciais temporárias. Caso contrário, crie o usuário manualmente:

• Abra o console do Amazon Cognito
• Localize seu User Pool (nomeado como {stack_name_base}-user-pool)
• Navegue até Usuários e selecione Criar usuário
• Digite um endereço de email e uma senha temporária
• Marque a opção de verificar o email
• Escolha Criar usuário

Passo 6: Acessar e testar a aplicação

Acesse a URL do Amplify Hosting (exibida no terminal após a implantação do frontend) no seu navegador. Faça login com suas credenciais do Cognito e altere sua senha temporária quando solicitado.

A aplicação de exemplo FAST é uma interface simples de chat multi-turno. A interface mantém-se minimalista propositalmente — ela foi construída para ser substituída por seu próprio frontend ou integrada a uma aplicação existente.

O agente de linha de base inclui duas ferramentas para demonstrar a arquitetura:

• Ferramenta de análise de texto: Uma ferramenta baseada em AWS Lambda por trás do AgentCore Gateway que conta palavras e analisa frequência de letras. Demonstra o padrão de integração com Gateway.
• Code Interpreter: Integração direta com o AgentCore Code Interpreter para execução Python segura em sandbox isolado.

Teste com essas consultas de exemplo para verificar se as ferramentas funcionam:

• “Analise o texto: The quick brown fox jumps over the lazy dog” — o agente deve retornar contagem de palavras e análise de frequência de letras
• “Calcule os primeiros 20 números de Fibonacci” — observe o agente escrever e executar código Python em tempo real

Lembre-se: a interface e as ferramentas fornecidas servem como ponto de partida, não como limitações. Você deve substituí-las conforme suas necessidades.

Personalizando a aplicação para seus requisitos

Alterando o padrão do agente

O template inclui dois padrões de agentes no diretório patterns/:

• strands-single-agent — agente conversacional básico usando framework Strands com integração de ferramentas MCP
• langgraph-single-agent — agente conversacional básico usando LangGraph com integração de ferramentas MCP

Para trocar de padrão, atualize backend.pattern no arquivo infra-cdk/config.yaml e reimplante com cdk deploy.

Para criar seu próprio padrão, adicione um novo diretório sob patterns/ com sua implementação de agente, um arquivo requirements.txt e um Dockerfile. Atualize a configuração para apontar para seu novo padrão.

Adicionando novas ferramentas via Gateway

O AgentCore Gateway roteia chamadas de ferramentas para uma função AWS Lambda. Para adicionar uma nova ferramenta:

• Crie uma função Lambda que implemente a lógica de sua ferramenta
• Defina o esquema da ferramenta (nome, descrição e parâmetros de entrada) na stack CDK
• Adicione a função Lambda como destino do AgentCore Gateway
• Reimplante com cdk deploy

O agente descobre ferramentas automaticamente a partir do Gateway através de MCP.

Usando o Code Interpreter

O Code Interpreter já está integrado no agente de linha de base, fornecendo execução Python segura em ambientes isolados de sandbox com persistência de sessão. Usuários podem solicitar ao agente que execute cálculos, gere dados ou execute código Python arbitrário.

Modificando o frontend

O frontend é uma aplicação React padrão no diretório frontend/. Assistentes de código como Kiro são hábeis em modificar frontends React. Descreva as mudanças que você deseja e deixe o assistente implementá-las. Após fazer alterações, reimplante com:

python scripts/deploy-frontend.py

Como o FAST utiliza AWS Amplify Hosting, você tem a opção de integrar com um sistema de controle de versão suportado para aproveitar os recursos nativos de integração e entrega contínua (CI/CD) do Amplify Hosting, que pode substituir o script deploy-frontend.py fornecido.

Além do chat: outros casos de uso

A aplicação de linha de base se concentra em interface de chat, mas o FAST suporta muitos casos de uso com agentes. Por exemplo, um agente de análise de documentos poderia adicionar um componente de envio de arquivos ao frontend, uma ferramenta Lambda que extrai texto de PDFs, e lógica de agente que resume os achados. Ou um agente de automação de fluxo poderia monitorar canais Slack e criar tickets Jira automaticamente a partir de solicitações de suporte.

A mesma arquitetura se aplica — você apenas substitui os componentes. Essas personalizações funcionam dentro da arquitetura padrão do FAST.

Flexibilidade: substituindo componentes principais

A arquitetura foi projetada deliberadamente para ser modular, permitindo substituir componentes conforme seus requisitos evoluem:

• Provedor de identidade: Substitua o Amazon Cognito por Okta, Microsoft Entra ID, Auth0 ou seu sistema OAuth 2.0 compatível existente
• Framework frontend: Troque o frontend React por Vue, Angular, ou integre o backend do agente a uma aplicação existente
• Hospedagem: Mude do AWS Amplify Hosting para Vercel, Netlify, uma distribuição CloudFront auto-gerenciada, ou sua solução preferida
• Framework de agente: Use Strands Agents, LangGraph, CrewAI ou até SDKs de agentes em outras linguagens como TypeScript ou Java

A infraestrutura modular em CDK e a arquitetura desacoplada tornam direto adaptar o template às suas necessidades específicas.

Limpando recursos

Para remover os recursos criados pelo FAST, execute:

cd infra-cdk
cdk destroy --force

Este comando deleta recursos AWS incluindo buckets do Amazon Simple Storage Service (Amazon S3) e imagens do Amazon Elastic Container Registry (Amazon ECR). Se deixar recursos em execução, você pode incorrer em cobranças. Note que o Amazon Bedrock AgentCore é faturado por uso.

Próximos passos

O FAST ajuda a reduzir o tempo para construir e implantar uma aplicação com agentes para menos de 30 minutos. Você obtém autenticação segura, um frontend funcional e capacidades integradas do AgentCore — Memória, Gateway, Code Interpreter e Observabilidade — sem precisar escrever infraestrutura do zero.

A aplicação de chat de linha de base e as ferramentas de exemplo são pontos de partida, não limitações. Você pode substituir sua própria lógica de agente, conectar suas ferramentas, modificar o frontend, ou até substituir componentes principais como o provedor de identidade ou a solução de hospedagem. A arquitetura modular se adapta aos seus requisitos.

Para começar, acesse o repositório, clone-o, implante o FAST na sua conta AWS e tenha uma aplicação com agentes funcionando em menos de 30 minutos. Depois, customize e coloque em produção algo real.

Para assistência especializada, a AWS Generative AI Innovation Center, AWS Professional Services e AWS Partners estão disponíveis para ajudar.

Fonte

Accelerate agentic application development with a full-stack starter template for Amazon Bedrock AgentCore (https://aws.amazon.com/blogs/machine-learning/accelerate-agentic-application-development-with-a-full-stack-starter-template-for-amazon-bedrock-agentcore/)

Uma mudança fundamental na geração de JSON estruturado

A AWS anunciou uma novidade no Amazon Bedrock que redefine como os desenvolvedores trabalham com respostas estruturadas de modelos de inteligência artificial. A capacidade de saídas estruturadas representa um avanço significativo: pela primeira vez, é possível garantir que as respostas JSON dos modelos de fundação estejam sempre em conformidade com um esquema especificado, através de decodificação restrita.

Essa transformação muda fundamentalmente a arquitetura dos aplicativos. Em vez de criar elaborados sistemas de validação, tratamento de erros e lógica de reprocessamento quando a IA retorna dados mal formatados, os desenvolvedores agora podem construir com confiança, sabendo que cada resposta respeitará exatamente o formato esperado.

Os casos de uso potenciais são diversos: pipelines de extração de dados sem necessidade de validação, sistemas de agentes de IA que chamam funções externas com segurança, e arquiteturas de aplicação simplificadas que dispensam lógica de retry. Um notebook Jupyter companion fornece exemplos práticos para todas as funcionalidades abordadas.

Os desafios tradicionais com geração de JSON

Historicamente, obter dados estruturados de modelos de linguagem era um processo frágil. Os desenvolvedores precisavam elaborar prompts detalhados, esperar pelo melhor resultado e construir sistemas complexos de tratamento de erros. Mesmo com prompts cuidadosamente preparados, problemas recorrentes surgem:

• Falhas de análise: JSON sintaticamente inválido que quebra chamadas de json.loads()
• Campos ausentes: Pontos de dados necessários não retornam nas respostas
• Incompatibilidades de tipo: Strings onde inteiros são esperados, quebra processamento downstream
• Violações de esquema: Respostas que tecnicamente são JSON válido, mas não correspondem ao modelo de dados esperado

Em sistemas em produção, esses problemas se multiplicam. Uma única resposta malformada pode atravessar um pipeline inteiro, exigindo reprocessamentos que aumentam latência e custos. Para fluxos de trabalho com agentes, parâmetros inválidos podem quebrar completamente chamadas de função.

Considere um exemplo concreto: um sistema de reservas que necessita do campo passageiros: int. Sem imposição de esquema, o modelo pode retornar passageiros: "dois" ou passageiros: "2"—ambos são JSON sintaticamente válido, mas semanticamente incorretos para a assinatura da função.

Como as saídas estruturadas transformam a situação

As saídas estruturadas no Amazon Bedrock não representam uma melhoria incremental—trata-se de um deslocamento fundamental de formatação probabilística para determinística. Através de decodificação restrita, o Bedrock força as respostas do modelo a estarem em conformidade com o esquema JSON especificado.

Dois mecanismos complementares estão disponíveis:

• Formato de saída JSON Schema: Controla o formato da resposta do modelo. Ideal para extração de dados, geração de relatórios e respostas prontas para APIs.
• Uso de ferramenta restrita: Valida parâmetros de ferramentas. Essencial para fluxos de trabalho com agentes, chamadas de função e automação em múltiplas etapas.

Essas funcionalidades podem ser usadas independentemente ou em conjunto, oferecendo controle preciso sobre tanto o que o modelo retorna quanto como chama suas funções.

Os benefícios entregues são significativos:

• Sempre válido: Sem erros de JSON.parse() ou exceções de análise
• Type-safe: Tipos de campos são impostos e campos obrigatórios sempre estão presentes
• Confiável: Sem necessidade de reprocessamentos por violações de esquema
• Pronto para produção: Deploy com confiança em escala empresarial

O funcionamento técnico das saídas estruturadas

As saídas estruturadas utilizam amostragem restrita com artefatos de gramática compilados. Quando uma requisição é feita, o Bedrock executa as seguintes etapas:

• Validação de esquema: O Amazon Bedrock valida o esquema JSON contra um subconjunto suportado do JSON Schema Draft 2020-12
• Compilação de gramática: Para esquemas novos, o Bedrock compila uma gramática (a primeira requisição pode levar mais tempo)
• Cache: Gramáticas compiladas são mantidas em cache por 24 horas, acelerando requisições subsequentes
• Geração restrita: O modelo gera tokens que produzem JSON válido correspondendo ao esquema

Considerações de desempenho

A latência inicial é um fator importante a considerar. A compilação inicial pode adicionar latência para esquemas novos. Entretanto, requisições subsequentes com esquemas idênticos têm overhead mínimo, pois a gramática compilada permanece em cache.

O escopo do cache é por conta, durando 24 horas a partir do primeiro acesso. Alterar a estrutura do esquema JSON ou do esquema de entrada de uma ferramenta invalida o cache, mas modificar apenas nomes ou campos de descrição não.

Começando com saídas estruturadas

O seguinte exemplo demonstra saídas estruturadas usando a Converse API:

import boto3
import json

# Initialize the Bedrock Runtime client
bedrock_runtime = boto3.client(
    service_name='bedrock-runtime',
    region_name='us-east-1'  # Choose your preferred region
)

# Define your JSON schema
extraction_schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string", "description": "Customer name"},
        "email": {"type": "string", "description": "Customer email address"},
        "plan_interest": {"type": "string", "description": "Product plan of interest"},
        "demo_requested": {"type": "boolean", "description": "Whether a demo was requested"}
    },
    "required": ["name", "email", "plan_interest", "demo_requested"],
    "additionalProperties": False
}

# Make the request with structured outputs
response = bedrock_runtime.converse(
    modelId="us.anthropic.claude-opus-4-5-20251101-v1:0",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "text": "Extract the key information from this email: John Smith (john@example.com) is interested in our Enterprise plan and wants to schedule a demo for next Tuesday at 2pm."
                }
            ]
        }
    ],
    inferenceConfig={
        "maxTokens": 1024
    },
    outputConfig={
        "textFormat": {
            "type": "json_schema",
            "structure": {
                "jsonSchema": {
                    "schema": json.dumps(extraction_schema),
                    "name": "lead_extraction",
                    "description": "Extract lead information from customer emails"
                }
            }
        }
    }
)

# Parse the schema-compliant JSON response
result = json.loads(response["output"]["message"]["content"][0]["text"])
print(json.dumps(result, indent=2))

A saída obtida está em conformidade total com o esquema—sem validação adicional necessária:

{
  "name": "John Smith",
  "email": "john@example.com",
  "plan_interest": "Enterprise",
  "demo_requested": true
}

Requisitos e melhores práticas

Para utilizar saídas estruturadas efetivamente, algumas orientações devem ser seguidas:

Configuração de esquema obrigatória

Configure additionalProperties: false em todos os objetos. Essa é uma configuração necessária para que saídas estruturadas funcionem. Sem ela, o esquema não será aceito:

{
    "type": "object",
    "properties": {
        "name": {"type": "string"}
    },
    "required": ["name"],
    "additionalProperties": false
}

Nomes e descrições descritivas

Use nomes de propriedade e descrições claros. Os modelos utilizam nomes de propriedades e descrições para compreender quais dados extrair. Nomes descritivos como customer_email têm melhor desempenho do que nomes genéricos como field1.

Enumerações para valores restritos

Quando um campo possui um conjunto limitado de valores válidos, use enum para restringir opções. Isso melhora a precisão e garante valores válidos.

Incrementalismo na construção

Comece com os campos mínimos necessários e adicione complexidade gradualmente. Esquemas básicos compilam mais rapidamente e são mais fáceis de manter.

Reutilização de esquemas

Estruture sua aplicação para reutilizar esquemas entre requisições. O cache de gramática de 24 horas melhora significativamente o desempenho para consultas repetidas.

Verificação de stopReason

Verifique stopReason em cada resposta. Dois cenários podem produzir respostas não conformes: recusas (quando o modelo declina por razões de segurança) e limites de token (quando max_tokens é atingido antes da conclusão). Trate ambos os casos no seu código.

Teste com dados realistas

Valide seus esquemas contra inputs representativos de produção. Casos extremos em dados reais frequentemente revelam problemas de design de esquema.

Recursos JSON Schema suportados

Os seguintes recursos são suportados:

• Todos os tipos básicos: object, array, string, integer, number, boolean, null
• enum (strings, números, booleanos ou nulls apenas)
• const, anyOf, allOf (com limitações)
• $ref, $def e definitions (apenas referências internas)
• Formatos de string: date-time, time, date, duration, email, hostname, uri, ipv4, ipv6, uuid
• Array minItems (apenas valores 0 e 1)

Não suportados: Esquemas recursivos, referências externas de $ref, restrições numéricas (minimum, maximum, multipleOf), restrições de string (minLength, maxLength), additionalProperties definido como qualquer valor diferente de false.

Uso restrito de ferramentas para fluxos de trabalho com agentes

Ao construir aplicações onde modelos chamam ferramentas, configure strict: true na definição da ferramenta para restringir parâmetros de ferramentas a corresponderem exatamente com seu esquema de entrada:

import boto3
import json

bedrock_runtime = boto3.client('bedrock-runtime', region_name='us-east-1')

response = bedrock_runtime.converse(
    modelId="us.anthropic.claude-opus-4-5-20251101-v1:0",
    messages=[
        {
            "role": "user",
            "content": [{"text": "What's the weather like in San Francisco?"}]
        }
    ],
    inferenceConfig={"maxTokens": 1024},
    toolConfig={
        "tools": [
            {
                "toolSpec": {
                    "name": "get_weather",
                    "description": "Get the current weather for a specified location",
                    "strict": True,  # Enable strict mode
                    "inputSchema": {
                        "json": {
                            "type": "object",
                            "properties": {
                                "location": {
                                    "type": "string",
                                    "description": "The city and state, e.g., San Francisco, CA"
                                },
                                "unit": {
                                    "type": "string",
                                    "enum": ["celsius", "fahrenheit"],
                                    "description": "Temperature unit"
                                }
                            },
                            "required": ["location", "unit"],
                            "additionalProperties": False
                        }
                    }
                }
            }
        ]
    }
)

# Tool inputs conform to the schema
for content_block in response["output"]["message"]["content"]:
    if "toolUse" in content_block:
        tool_input = content_block["toolUse"]["input"]
        print(f"Tool: {content_block['toolUse']['name']}")
        print(f"Input: {json.dumps(tool_input, indent=2)}")

Com strict: true, as saídas estruturadas garantem que:

• O campo location é sempre uma string
• O campo unit é sempre celsius ou fahrenheit
• Nenhum campo inesperado aparece na entrada

Aplicações práticas em diversos setores

Os exemplos e notebooks demonstram casos de uso que atravessam múltiplas indústrias:

• Serviços financeiros: Extrair dados estruturados de relatórios de earnings, aplicações de crédito e documentos de conformidade. Com saídas estruturadas, todos os campos obrigatórios estão presentes e corretamente tipados para processamento downstream.
• Healthcare: Analisar notas clínicas em registros estruturados conformes com esquema. Extrair informações de pacientes, diagnósticos e planos de tratamento em JSON validado para integração com sistemas EHR.
• Ecommerce: Construir pipelines confiáveis de enriquecimento de catálogo de produtos. Extrair especificações, categorias e atributos de descrições de produtos com resultados consistentes e confiáveis.
• Legal: Analisar contratos e extrair termos-chave, partes, datas e obrigações em formatos estruturados adequados para sistemas de gerenciamento de contratos.
• Atendimento ao cliente: Construir sistemas inteligentes de roteamento de tickets e resposta, onde intents extraídos, sentimentos e entidades correspondem ao modelo de dados da aplicação.

Escolhendo a abordagem correta

Os testes revelaram padrões claros sobre quando usar cada funcionalidade:

Use JSON Schema output format quando:

• Você precisa da resposta do modelo em uma estrutura específica
• Construindo pipelines de extração de dados
• Gerando respostas prontas para API
• Criando relatórios ou resumos estruturados

Use strict tool use quando:

• Construindo sistemas de agentes que chamam funções externas
• Implementando fluxos de trabalho multi-etapas com cadeias de ferramentas
• Exigindo tipos de parâmetro validados para chamadas de função
• Conectando IA a bancos de dados, APIs ou serviços externos

Use ambos em conjunto quando:

• Construindo agentes complexos que precisam de chamadas de ferramenta validadas e respostas finais estruturadas
• Criando sistemas onde resultados de ferramentas intermediárias alimentam saídas estruturadas
• Implementando fluxos de trabalho empresariais exigindo conformidade de esquema de ponta a ponta

Comparação de APIs: Converse versus InvokeModel

Tanto a Converse API quanto a InvokeModel API suportam saídas estruturadas, com formatos de parâmetro ligeiramente diferentes:

Aspecto	Converse API	InvokeModel (Anthropic Claude)	InvokeModel (modelos open-weight)
Localização do esquema	outputConfig.textFormat	output_config.format	response_format
Flag strict de ferramenta	toolSpec.strict	tools[].strict	tools[].function.strict
Formato de esquema	String JSON em jsonSchema.schema	Objeto JSON em schema	Objeto JSON em json_schema.schema
Melhor para	Fluxos de trabalho conversacionais	Inferência single-turn (Claude)	Inferência single-turn (open-weight)

Nota: A InvokeModel API utiliza nomes de campos de requisição diferentes dependendo do tipo de modelo. Para modelos Anthropic Claude, use output_config.format para saídas JSON schema. Para modelos open-weight, use response_format em seu lugar.

Escolha a Converse API para conversas multi-turn e a InvokeModel API quando você necessita acesso direto ao modelo com formatos de requisição específicos do provedor.

Modelos suportados e disponibilidade

Saídas estruturadas está geralmente disponível em todas as regiões comerciais da AWS para provedores de modelo Amazon Bedrock selecionados:

• Anthropic
• DeepSeek
• Google
• MiniMax
• Mistral AI
• Moonshot AI
• NVIDIA
• OpenAI
• Qwen

A funcionalidade funciona perfeitamente com:

• Inferência entre regiões: Use saídas estruturadas entre regiões da AWS sem configuração adicional
• Inferência em lote: Processe grandes volumes com saídas conformes com esquema
• Streaming: Transmita respostas estruturadas com ConverseStream ou InvokeModelWithResponseStream

Conclusão

A capacidade de saídas estruturadas no Amazon Bedrock reduz significativamente a incerteza da geração de JSON por IA através de respostas validadas e conformes com esquema. Utilizando formato de saída JSON Schema e uso restrito de ferramentas, os desenvolvedores podem construir pipelines confiáveis de extração de dados, fluxos de trabalho robustos com agentes e aplicações de IA prontas para produção—sem lógica personalizada de análise ou validação.

Seja extraindo dados de documentos, construindo automação inteligente ou criando APIs alimentadas por IA, as saídas estruturadas entregam a confiabilidade que suas aplicações exigem.

Saídas estruturadas está agora geralmente disponível no Amazon Bedrock. Para usar saídas estruturadas com as APIs Converse, atualize para o AWS SDK mais recente. Para saber mais, consulte a documentação do Amazon Bedrock e explore o notebook de exemplo.

Fonte

Structured outputs on Amazon Bedrock: Schema-compliant AI responses (https://aws.amazon.com/blogs/machine-learning/structured-outputs-on-amazon-bedrock-schema-compliant-ai-responses/)

O que são perfis de navegação no Bedrock AgentCore Browser

A AWS anunciou um novo recurso para o Amazon Bedrock AgentCore Browser: o suporte a perfis de navegação. Essa funcionalidade resolve um desafio importante em automações de grande escala, permitindo que estados de autenticação sejam reutilizados em múltiplas sessões de navegador sem que seja necessário realizar login novamente.

Para clientes corporativos que precisam executar centenas ou milhares de sessões automatizadas de navegador diariamente, esse ganho é significativo. O tempo de configuração de sessão foi reduzido de minutos para dezenas de segundos, representando uma melhora substancial em eficiência operacional.

Como funcionam os perfis de navegação

Os perfis de navegação funcionam através da persistência de dados do navegador. Quando você cria um perfil, ele armazena informações essenciais como cookies e local storage (armazenamento local) de múltiplas sessões.

O fluxo é simples: você autentica em um website uma única vez e salva a sessão em um perfil de navegação. Quando inicia uma nova sessão utilizando esse perfil salvo, seu estado de autenticação é preservado — você permanece conectado sem necessidade de inserir credenciais novamente. Dessa forma, agentes de automação conseguem executar tarefas em websites autenticados sem intervenção manual de login.

Flexibilidade e processamento paralelo

O recurso oferece modos de sessão flexíveis que atendem tanto operações de leitura quanto operações persistentes. Uma vantagem importante é a capacidade de processamento paralelo: múltiplas sessões podem utilizar o mesmo perfil simultaneamente, viabilizando automações complexas e escaláveis.

Disponibilidade regional

O suporte a perfis de navegação está disponível em todos os 14 regiões da AWS onde o Amazon Bedrock AgentCore Browser funciona:

• Regiões US: Virgínia, Ohio e Oregon
• Regiões Ásia Pacífico: Mumbai, Singapura, Sydney, Tóquio e Seul
• Regiões Europa: Frankfurt, Irlanda, Londres, Paris e Estocolmo
• Canadá: região central

Próximos passos

Para aprofundar seu conhecimento sobre essa funcionalidade, você pode consultar a documentação sobre perfis de navegação no site oficial da AWS.

Fonte

Amazon Bedrock AgentCore Browser now supports browser profiles (https://aws.amazon.com/about-aws/whats-new/2026/02/amazon-bedrock-agentcore-browser-profiles)

Simplificação da Computação Distribuída para IA

O treinamento e implementação de grandes modelos de inteligência artificial exigem capacidades avançadas de computação distribuída. No entanto, gerenciar esses sistemas complexos não deveria ser uma tarefa complicada para cientistas de dados e profissionais de aprendizado de máquina.

A Amazon SageMaker HyperPod com orquestração Amazon Elastic Kubernetes Service (Amazon EKS) oferece uma abordagem diferente. O pacote de ferramentas — composto por interface de linha de comando (CLI) e kit de desenvolvimento de software (SDK) — permite que usuários gerenciem infraestrutura de cluster e acessem capacidades de treinamento e inferência distribuídos de forma mais intuitiva, abstraindo a complexidade subjacente dos sistemas distribuídos.

Arquitetura em Camadas para Simplicidade

A CLI e o SDK seguem uma arquitetura multi-camada compartilhada. Ambas servem como pontos de entrada para o usuário e estão construídas sobre componentes comuns, proporcionando comportamento consistente nas diferentes interfaces.

Para automação de infraestrutura, o SDK orquestra o gerenciamento do ciclo de vida do cluster através de uma combinação de provisionamento de stacks AWS CloudFormation e interações diretas com APIs da AWS. Cargas de trabalho de treinamento e inferência, além de ambientes de desenvolvimento integrados (IDEs), são expressas como Definições de Recurso Personalizado do Kubernetes (CRDs), que o SDK gerencia através da API do Kubernetes.

Instalação e Preparação

Pré-requisitos

Para utilizar as ferramentas, você precisará de:

• Uma conta da AWS com acesso a SageMaker HyperPod, Amazon Simple Storage Service (Amazon S3) e Amazon FSx for Lustre
• Cota de serviço suficiente para criar o cluster HyperPod e grupos de instâncias
• Um ambiente local (máquina local ou ambiente de computação baseado em nuvem) para executar comandos da CLI HyperPod, configurado com:
• Sistema operacional baseado em Linux ou MacOS
• Python 3.8 ou superior instalado
• AWS Command Line Interface (AWS CLI) configurada com credenciais apropriadas

Instalação da CLI HyperPod

A instalação é direta. Execute o seguinte comando a partir do seu ambiente local:

pip install sagemaker-hyperpod

Este comando configura as ferramentas necessárias para interagir com clusters SageMaker HyperPod. Para instalações existentes, certifique-se de que tem a versão mais recente do pacote (SageMaker HyperPod 3.5.0 ou posterior).

Para verificar se a CLI foi instalada corretamente, execute:

hyp

A saída exibirá todas as opções e comandos disponíveis, incluindo instruções de uso. A CLI oferece uma gama completa de comandos para gerenciar o ciclo de vida do HyperPod — desde criação de clusters até criação de endpoints, execução de jobs, monitoramento e exclusão.

Para informações detalhadas sobre uso da CLI e parâmetros disponíveis, consulte a documentação de referência da CLI.

Criação e Gerenciamento de Clusters

Inicializando uma Nova Configuração de Cluster

A AWS oferece dois caminhos para criar clusters HyperPod: através do console de gerenciamento ou da CLI. O console fornece a experiência mais guiada, enquanto a CLI é ideal para usuários que preferem automação programática.

Ambas as abordagens utilizam o mesmo modelo CloudFormation subjacente, disponível no repositório GitHub SageMaker HyperPod cluster setup. Para um passo a passo baseado em console, consulte o post sobre a nova experiência de criação de cluster.

A criação via CLI segue um fluxo baseado em configuração. Primeiro, inicialize uma nova configuração de cluster:

hyp init cluster-stack

Isso cria um arquivo config.yaml onde você especifica a configuração do cluster, além de um arquivo README.md com informações sobre o fluxo de trabalho.

Configuração do Cluster

O arquivo config.yaml contém variáveis cruciais como:

resource_name_prefix: hyp-eks-stack
hyperpod_cluster_name: hyperpod-cluster
kubernetes_version: 1.31

O parâmetro resource_name_prefix serve como identificador principal dos recursos criados. Cada implantação deve usar um prefixo único para evitar conflitos.

Você pode editar a configuração diretamente ou usar comandos da CLI como:

hyp configure --kubernetes-version 1.33

Existem duas nuances importantes ao atualizar valores de configuração: underscores (_) em nomes de variáveis no arquivo se tornam hífens (-) nos comandos CLI. Variáveis contendo listas são configuradas como JSON nos comandos CLI.

Validação e Envio

Após realizar as alterações desejadas, valide o arquivo de configuração:

hyp validate

Se bem-sucedido, o comando confirmará que a configuração é válida. Em seguida, envie o stack de criação para CloudFormation:

hyp create --region us-east-1

O comando realiza validação e injeta valores do arquivo config.yaml no modelo. Os arquivos resolvidos são salvos em um subdiretório com timestamp, fornecendo um mecanismo leve de versionamento local. Se bem-sucedido, você receberá uma ID de stack do CloudFormation.

Monitoramento da Criação

Para listar stacks CloudFormation existentes:

hyp list cluster-stack --region us-east-1

Você pode filtrar por status usando a flag --status. Para visualizar detalhes de um stack específico:

hyp describe cluster-stack <nome-do-stack> --region us-east-1

Se algum dos stacks mostrar status como CREATE_FAILED ou ROLLBACK_*, abra a página CloudFormation no console para investigar. Falhas frequentemente relacionam-se a cotas de serviço insuficientes para o cluster, grupos de instâncias ou componentes de rede como VPCs ou gateways NAT. Consulte as quotas do SageMaker HyperPod para saber mais sobre requisitos.

Conexão ao Cluster

Após o stack completar sua criação com status CREATE_COMPLETE, configure a CLI e seu ambiente Kubernetes local para interagir com o cluster:

hyp set-cluster-context --cluster-name <nome-cluster> --region us-east-1

Este comando atualiza sua configuração Kubernetes local, permitindo usar tanto a CLI HyperPod quanto utilitários como kubectl para gerenciar recursos.

Modificação de Clusters Existentes

A CLI oferece capacidade de modificar grupos de instâncias e modo de recuperação de nós através do comando:

hyp update cluster --cluster-name <nome> --region <região> --instance-groups '[{"instance_count": 2, "instance_group_name": "worker-nodes", "instance_type": "ml.m5.large"}]'

Todos os campos são necessários para executar o comando de atualização, mesmo que você esteja modificando apenas um deles. A opção --node-recovery permite configurar o comportamento de recuperação de nós (Automática ou Nenhuma). Para mais informações, consulte a documentação sobre recuperação automática de nós.

Exclusão de Clusters

Para remover um cluster HyperPod:

hyp delete cluster-stack <nome-do-stack> --region us-east-1

Esta ação é irreversível. A CLI solicitará confirmação antes de proceder. Você pode usar a flag --retain-resources para especificar recursos que deseja manter durante o processo de exclusão.

SDK Python para Controle Programático

A AWS também inclui um SDK Python para acesso programático às funcionalidades descritas. O SDK Python é utilizado pelos comandos CLI e é instalado quando você instala o pacote sagemaker-hyperpod.

A CLI é ideal para usuários que preferem uma experiência simplificada e interativa para tarefas comuns como criação de clusters, monitoramento de jobs e implantação de endpoints. É especialmente útil para prototipagem rápida, experimentação e automação de fluxos de trabalho através de scripts ou pipelines CI/CD.

O SDK, por sua vez, oferece maior controle programático e flexibilidade, sendo a escolha preferida quando você precisa incorporar funcionalidades HyperPod diretamente em sua aplicação, integrar com outros serviços da AWS ou de terceiros, ou construir fluxos de trabalho customizados e complexos.

O repositório GitHub da CLI SageMaker HyperPod mostra exemplos de como criação e gerenciamento de clusters podem ser implementados usando o SDK Python.

Próximos Passos

A CLI e o SDK do SageMaker HyperPod simplificam significativamente a criação e gerenciamento de clusters. Essas ferramentas fornecem valor através de:

• Gerenciamento simplificado do ciclo de vida — Da configuração inicial às atualizações e limpeza do cluster, as ferramentas alinham-se com como equipes gerenciam ambientes de treinamento e inferência de longa duração
• Controle declarativo — O SDK expõe o modelo de configuração subjacente, permitindo que equipes codifiquem especificações de cluster, grupos de instâncias e sistemas de armazenamento
• Observabilidade integrada — Visibilidade dos stacks CloudFormation está disponível sem trocar de ferramentas, suportando iteração suave durante desenvolvimento e operação

Se você deseja explorar como usar a CLI e o SDK para enviar jobs de treinamento e implantar modelos em seu novo cluster, consulte nosso post complementar sobre treinamento e implantação de modelos no SageMaker HyperPod.

Fonte

Manage Amazon SageMaker HyperPod clusters using the HyperPod CLI and SDK (https://aws.amazon.com/blogs/machine-learning/manage-amazon-sagemaker-hyperpod-clusters-using-the-hyperpod-cli-and-sdk/)