Blog

  • Fine-tune de um agente de busca com RL multi-turn no Amazon SageMaker AI

    O problema com agentes de busca baseados em LLMs

    Agentes de busca alimentados por grandes modelos de linguagem (LLMs) estão mudando a forma como empresas recuperam informações. Em vez de exigir que o usuário formule a consulta perfeita, esses agentes decidem autonomamente o que buscar, qual estratégia de recuperação usar e quando parar — tudo isso ao longo de múltiplas rodadas de interação, refinando a abordagem com base no que já foi recuperado.

    O problema é que fazer esse comportamento multi-etapas funcionar de forma confiável não é trivial. Nenhum modelo base chega pronto conhecendo as suas ferramentas ou o seu ambiente. Modelos menores raramente entregam comportamento multi-turn consistente. Modelos de fronteira funcionam, mas cobram caro em latência e custo.

    O fine-tuning surge como um terceiro caminho: você ensina diretamente a um modelo menor as ferramentas e o ambiente específicos do seu caso de uso. O resultado é a velocidade e o custo de um modelo menor com a confiabilidade que, de outra forma, só um modelo de fronteira entregaria.

    As abordagens tradicionais de fine-tuning, porém, têm limitações claras. O Ajuste Fino Supervisionado (SFT) depende de demonstrações de especialistas com trajetórias multi-turn ideais — caras de coletar e raramente disponíveis. O Aprendizado por Reforço (RL) de turno único, como o RL com recompensas verificáveis (RLVR), avalia uma resposta de cada vez. Mas um agente de busca toma decisões interdependentes ao longo de vários turnos, e otimizar um único passo de forma isolada ignora completamente essas dependências.

    O que se precisa é de uma abordagem que otimize o agente ao longo de toda a trajetória multi-turn. O sinal de recompensa só precisa refletir se o resultado final foi bom. É exatamente isso que o Aprendizado por Reforço Multi-turn (MTRL) oferece.

    O que é o Amazon SageMaker AI MTRL

    O Amazon SageMaker AI MTRL permite fazer fine-tuning de LLMs usando aprendizado por reforço em cenários de interação multi-turn. Ele enquadra uma tarefa agêntica como uma sequência de decisões, usa rollouts multi-turn para gerar dados de treinamento e otimiza o modelo com algoritmos de gradiente de política.

    Entre os principais recursos que a AWS destaca para o serviço:

    • Interface modular agente-ambiente: você define recompensas personalizadas, loops de ferramentas e formatos de conversa multi-turn com pouco código.
    • Execução serverless: RL agêntico em escala de produção com precificação por token, sem necessidade de provisionar ou gerenciar clusters de GPU.
    • Rollout assíncrono e coleta de trajetórias: geração e atualizações de gradiente rodam em paralelo com controle de desatualização off-policy, mantendo o treinamento rápido sem se afastar demais da política atual.
    • Biblioteca nativa de algoritmos: suporte a Otimização de Política Proximal (PPO), Otimização de Política por Amostragem de Importância Recortada (CISPO) e perdas de amostragem de importância (IS), combinadas com estimadores de vantagem baseados em grupos (GRPO, GRPO pass@k, RLOO e outros).
    • Treinamento retomável: execuções longas podem ser divididas em múltiplos jobs, superando o limite de tempo de um único job.
    • Observabilidade de trajetórias e recompensas: é possível inspecionar o que o agente fez turno a turno e ao longo dos passos de treinamento no MLflow gerenciado pelo Amazon SageMaker AI.
    • Jobs de avaliação: métricas de recompensa, pass@k e trajetórias podem ser verificadas antes do deploy em um endpoint do Amazon SageMaker AI ou no Amazon Bedrock.

    Ambiente e configuração do experimento

    O experimento descrito pela AWS utilizou os seguintes componentes:

    • Uma conta AWS com acesso ao Amazon SageMaker AI na região US West (Oregon) — us-west-2.
    • Datasets de treinamento e validação enviados ao Amazon Simple Storage Service (Amazon S3) no formato exigido pelo serviço.
    • Um endpoint de agente implantado que expõe ferramentas de busca BM25 e vetorial para o ambiente MTRL chamar durante os rollouts.

    O modelo escolhido para o fine-tuning foi o Qwen3.6-27B, suportado na região us-west-2. O agente de busca foi configurado com duas ferramentas disponíveis:

    • Busca lexical (BM25): encontra correspondências exatas de palavras-chave contando frequências de termos. Ideal para consultas com termos específicos ou identificadores.
    • Busca vetorial: converte consultas e documentos em vetores de embedding e calcula similaridades. Recomendada para consultas semânticas ou conceituais.

    O número de turnos por interação também foi limitado, evitando respostas excessivamente longas e incentivando um comportamento de busca mais eficiente.

    Datasets utilizados

    Para treinamento e teste, foram utilizados os seguintes conjuntos de dados públicos:

    • FRAMES (treino — HuggingFace): perguntas factuais multi-hop que exigem síntese de múltiplos artigos da Wikipedia.
    • BRIGHT (treino — HuggingFace): recuperação intensiva em raciocínio em 12 domínios, onde a relevância exige raciocínio e não apenas sobreposição de palavras-chave.
    • Enterprise RAG (treino — GitHub): benchmark com mais de 500.000 documentos corporativos sintéticos e 500 perguntas para treinar e avaliar sistemas de Geração Aumentada por Recuperação (RAG) em conhecimento interno de empresas.
    • ESCI (treino — GitHub): dataset multilíngue de busca de produtos que rotula pares consulta–produto como Exato, Substituto, Complementar ou Irrelevante.
    • Musique (treino — GitHub): dataset de perguntas e respostas construído compondo questões de um único salto em problemas desafiadores de raciocínio multi-hop.
    • MLQA (treino — HuggingFace): benchmark de perguntas e respostas extrativas paralelo em sete idiomas para avaliar compreensão entre línguas.
    • FreshStack (teste — HuggingFace): perguntas e respostas recentes de desenvolvedores sobre Stack Overflow e documentações em cinco tópicos.
    • WixQA (teste — HuggingFace): perguntas e respostas de suporte sobre a base de conhecimento da Wix.
    • BrowseComp-Plus (teste — GitHub): consultas de pesquisa profunda sobre aproximadamente 100.000 documentos da web verificados por humanos.
    • Wands (teste — HuggingFace): dataset de busca de produtos da Wayfair com mais de 42.000 julgamentos de relevância rotulados como Exato, Parcial ou Irrelevante.

    Os datasets foram pré-processados no formato reconhecido pelo serviço MTRL conforme a documentação oficial. Além disso, 5% das instâncias de treinamento de cada dataset foram reservadas para validação.

    Função de recompensa

    A métrica principal utilizada foi o nDCG@10 (Ganho Cumulativo Descontado Normalizado no rank 10). Trata-se de uma métrica padrão de recuperação de informações que mede o quão bem os 10 documentos recuperados correspondem ao ranking ideal. Ela recompensa sistemas que colocam documentos altamente relevantes no topo da lista — pontuação 1.0 significa ranking perfeito, 0.0 significa nenhum documento relevante recuperado.

    O nDCG@10 foi usado diretamente como função de recompensa no MTRL. É uma recompensa no nível da trajetória: o agente conclui toda a sua busca multi-turn e a recompensa reflete o quão bem os documentos finais recuperados correspondem ao gabarito.

    Quando o agente atinge o número máximo de turnos ou o limite de tokens de amostragem em um único turno, é atribuída uma recompensa de -1 para ensinar explicitamente o modelo a evitar esses modos de falha. Esse tipo de design de recompensa baseado em penalidade é eficaz para afastar o modelo de comportamentos indesejados sem precisar criar recompensas intermediárias complexas.

    Configuração do job de treinamento

    Um dos pontos destacados pela AWS é o baixo esforço de configuração necessário para começar. No experimento, apenas três hiperparâmetros foram alterados — todo o restante ficou nos valores padrão. O trecho de código abaixo mostra como configurar e iniciar o job de treinamento usando o SDK MultiTurnRLTrainer:

    from sagemaker.modules.train import MultiTurnRLTrainer
    
    trainer = MultiTurnRLTrainer(
        model_id="qwen3.6-27b",
        agent_endpoint="<your-agent-endpoint>",
        training_dataset_s3_uri="s3://amzn-s3-demo-bucket/datasets/train/",
        validation_dataset_s3_uri="s3://amzn-s3-demo-bucket/datasets/validation/",
        hyperparameters={
            "max_epochs": 1,
            "global_batch_size": 128,
            "rollout_max_concurrency": 32,
        },
        output_s3_uri="s3://amzn-s3-demo-bucket/output/",
    )
    
    trainer.train()

    Os três hiperparâmetros modificados foram:

    • max_epochs: 1 — controla quantas passagens completas sobre os dados de treinamento são realizadas.
    • global_batch_size: 128 — define o número de prompts por passo de treinamento.
    • rollout_max_concurrency: 32 — controla quantos rollouts rodam em paralelo durante a coleta de trajetórias.

    Decisões que normalmente exigem expertise em RL — como o algoritmo, o estimador de vantagem e os limites de desatualização off-policy — rodam com os valores padrão. Toda a jornada do modelo base até os resultados descritos a seguir exigiu apenas essa configuração.

    Vale mencionar que o treinamento MTRL pode durar vários dias e o serviço tem um limite de tempo padrão de 24 horas, ajustável pelo esquema JSON do CreateJob. Caso um job seja interrompido ou falhe por timeout ou erro de infraestrutura, é possível retomar o treinamento a partir de um checkpoint anterior com o suporte a retomada.

    Resultados obtidos

    O fine-tuning com MTRL melhorou o agente de busca em três dos quatro benchmarks de teste e o tornou substancialmente mais confiável em todos eles. Os maiores ganhos vieram no BrowseComp-Plus (+23,7% de nDCG@10) e no WixQA (+18,4%), com ganho menor no Wands e uma leve regressão no FreshStack.

    A melhoria na confiabilidade foi o resultado mais expressivo. No BrowseComp-Plus, a taxa de falhas caiu de 22,89% para 0,68%. Isso significa que o agente aprendeu não apenas a buscar melhor, mas também a concluir a tarefa dentro do orçamento de turnos e tokens.

    A tabela abaixo compara o modelo fine-tuned com o Qwen3.6-27B original nos quatro datasets de teste. As colunas são: tamanho do dataset (número de perguntas), nDCG@10 (o Ganho Cumulativo Descontado Normalizado — tarefas com falha recebem nDCG@10 igual a 0), taxa de falhas (percentual de perguntas onde o agente excede o limite de turnos ou tokens) e média de turnos por pergunta.

    • WixQA (400 perguntas): Qwen3.6-27B → 0,5725 | Qwen3.6-27B-finetune → 0,6781 (+18,4%) | Falhas: 0,67% → 0,17% | Turnos médios: 4,3 → 4,5
    • Wands (147 perguntas): Qwen3.6-27B → 0,5762 | Qwen3.6-27B-finetune → 0,6112 (+6%) | Falhas: 0,00% → 0,00% | Turnos médios: 2,2 → 2,9
    • FreshStack (672 perguntas): Qwen3.6-27B → 0,4112 | Qwen3.6-27B-finetune → 0,4089 (-0,6%) | Falhas: 0,20% → 0,05% | Turnos médios: 3,1 → 2,8
    • BrowseComp-Plus (830 perguntas): Qwen3.6-27B → 0,5136 | Qwen3.6-27B-finetune → 0,6354 (+23,7%) | Falhas: 22,89% → 0,68% | Turnos médios: 7,0 → 6,3

    Dois padrões se destacam nos dados: a melhora na qualidade de busca foi consistente na maioria dos benchmarks, e a redução de falhas foi dramática — especialmente no BrowseComp-Plus, que é o benchmark mais desafiador do conjunto.

    Principais aprendizados

    Com base nos resultados apresentados, a AWS destaca os seguintes pontos sobre o Amazon SageMaker AI MTRL:

    • Baixa barreira de entrada: as configurações padrão funcionam bem e não é necessária expertise profunda em RL para começar.
    • Infraestrutura serverless: sem necessidade de provisionar GPUs ou gerenciar clusters de treinamento distribuído — o modelo de cobrança é por token.
    • Treinamento retomável: execuções longas podem ser divididas em múltiplos jobs.
    • Otimização direta: o treinamento ocorre contra a métrica real da tarefa, não contra perdas proxy.
    • Observabilidade completa: é possível inspecionar trajetórias turno a turno no MLflow gerenciado pelo Amazon SageMaker AI para entender o que o agente aprendeu.

    Próximos passos

    Para quem quiser explorar essa abordagem, a AWS indica os seguintes pontos de partida:

    Após explorar a abordagem, lembre-se de limpar os recursos para evitar cobranças contínuas: interromper ou excluir o job de treinamento MTRL no console do Amazon SageMaker AI, remover os artefatos do modelo no Amazon S3 se não forem mais necessários e excluir os endpoints implantados para avaliação.

    Fonte

    Fine-tune a search agent with multi-turn RL on Amazon SageMaker AI (https://aws.amazon.com/blogs/machine-learning/fine-tune-a-search-agent-with-multi-turn-rl-on-amazon-sagemaker-ai/)

  • Como verificar milhares de contratos de locação por conformidade usando Amazon Quick e o padrão Adjudicated Query

    O problema de conformidade em escala

    Imagine um operador de portfólio imobiliário com 50.000 contratos de locação distribuídos por vários estados americanos. Cada estado tem suas próprias leis de locação — limites de multa por atraso, prazos de notificação, tetos para depósito de segurança — e essas leis mudam conforme o calendário legislativo, não conforme a conveniência do operador. Quando uma regulação muda, a equipe de conformidade precisa identificar quais contratos estão fora do padrão.

    Em volumes pequenos, um paralegal lê os contratos manualmente. A resposta é confiável porque há um humano por trás dela. A partir de certo volume, isso deixa de ser viável. O trabalho passa para software, e surge um novo problema: o resultado vira um número numa tela que ninguém consegue verificar de forma independente.

    Dois requisitos emergem dessa realidade:

    • Completude comprovável: afirmar “verificamos todos os 22.910 contratos do Texas” precisa ser verdadeiro e demonstrável. Um registro não avaliado deve ser reportado como não avaliado, nunca omitido silenciosamente.
    • Defensibilidade: uma conclusão pode ser contestada meses depois em litígio, auditoria ou fiscalização regulatória. Defendê-la exige saber qual versão de qual regra foi aplicada, a qual trecho de texto, por qual método, em qual data.

    Essas duas propriedades são o que distingue esse problema de uma busca corporativa comum. Geração Aumentada por Recuperação (RAG) resolve o problema de acessibilidade, mas não consegue satisfazer nenhuma das duas propriedades: busca por similaridade não tem um limiar que signifique “todos eles”, e uma amostra ranqueada nunca sabe o que excluiu. Text-to-SQL reduz a lacuna, mas carrega um risco estrutural: um predicado alucinado pode silenciosamente reduzir a população avaliada, e o número resultante parece exato mesmo quando o escopo está errado.

    O padrão Adjudicated Query

    A AWS publicou uma arquitetura de referência que resolve esse dilema com o que chamou de padrão Adjudicated Query. A ideia central é criar uma camada conversacional delimitada sobre um motor de regras determinístico. O modelo de linguagem faz exatamente duas coisas: traduz a pergunta em linguagem natural para uma chamada em um conjunto fixo de operações tipadas, e narra o resultado que retorna. Ele nunca escreve uma consulta, nunca define a população e nunca realiza uma determinação.

    Por trás dessa fronteira fica o motor de regras. As regras são dados versionados, não código. O motor conhece operadores de comparação genéricos — maior ou igual, menor ou igual, igual, existe — e não contém nenhuma ramificação nomeando uma jurisdição ou tópico específico. Uma mudança na lei é uma edição em uma linha do livro de regras, não um deploy de código.

    Cada varredura de conformidade produz um recibo de completude: um invariante afirmado onde conforme + em violação + ambíguo + ilegível deve ser igual ao total varrido. Esse invariante é calculado antes de qualquer dado ser persistido. Uma execução que não consegue contabilizar sua população nunca é concluída. Não existe caminho pelo qual um registro seja silenciosamente ignorado.

    Por que não RAG ou Text-to-SQL?

    A comparação entre as abordagens deixa claro o posicionamento do padrão:

    • Recuperação semântica (RAG): trabalha com amostras ranqueadas; completude de população é estruturalmente impossível; defensibilidade apenas parcial.
    • Consultas geradas (Text-to-SQL): completude alegada, mas não comprovável; risco de redução silenciosa da população; defensibilidade possível se bem modelado.
    • Motor de regras + BI (sem chat): completude exata e comprovada; totalmente defensável; mas sem camada conversacional.
    • Adjudicated Query: completude exata e comprovada; totalmente defensável; com acesso em linguagem natural.

    O padrão Adjudicated Query adiciona acesso em linguagem natural à combinação de motor de regras e Inteligência de Negócios (BI) sem sacrificar a garantia. É a escolha certa quando usuários responsáveis precisam de acesso conversacional e um registro perdido é uma responsabilidade legal, não apenas um inconveniente.

    Arquitetura de referência

    A arquitetura proposta conecta os componentes da seguinte forma: um analista de conformidade interage com duas superfícies no Amazon Quick — um agente de chat para fazer perguntas e um painel do Amazon QuickSight para navegar pelo conjunto completo de resultados.

    O agente de chat primeiro obtém um token OAuth do Amazon Cognito. Em seguida, envia requisições via Protocolo de Contexto de Modelo (MCP) por um Amazon API Gateway HTTP API, que valida o token antes de encaminhar para uma função AWS Lambda. Essa função hospeda o servidor MCP e o motor de regras, lê e escreve no Amazon Aurora Serverless v2 via RDS Data API, e chama o Amazon Bedrock apenas para o caminho exploratório de busca em cláusulas. O painel do Amazon QuickSight lê o mesmo banco Aurora diretamente por uma conexão de Nuvem Virtual Privada (VPC).

    Como as duas superfícies leem do mesmo armazenamento, o recibo de completude é uma única fonte de verdade. O agente de chat carrega o recibo de completude e um link para o painel. O painel carrega o volume completo, porque milhares de linhas não cabem numa mensagem de chat.

    A superfície de operações delimitada

    O servidor MCP expõe exatamente seis ferramentas, cada uma com uma semântica distinta:

    • sweep_compliance: varredura exaustiva da população contra as regras vigentes em uma data declarada. Resultado oficial — cada contrato contabilizado em um recibo calculado. Grava os achados.
    • simulate_rule_change: uma regra testada com um valor proposto contra a linha de base aprovada. Resultado exploratório — apenas contagens direcionais. Não registra nada.
    • explore_clauses: Top K por similaridade semântica dentro de uma população filtrada. Resultado interpretativo — amostra ranqueada. Não responde “quantos”.
    • get_finding: cadeia completa de evidências de um único achado. Drill-down em uma determinação específica.
    • list_rules: o livro de regras vigente em uma data, com versões, citações e aprovadores. Consulta de referência.
    • check_connection: verificação de disponibilidade do transporte, sem tocar em dados.

    Essa superfície delimitada elimina o caminho para o risco de redução silenciosa de população presente em consultas geradas. Como o modelo só pode selecionar entre um conjunto fixo de operações cuja lógica de população foi escrita, revisada e testada por pessoas, ele não tem como compor uma população errada.

    Componentes principais da arquitetura

    • Amazon Quick: interface conversacional e camada de orquestração do agente. Autentica no servidor MCP usando OAuth de dois fatores (2LO) via Amazon Cognito e cuida da descoberta de ferramentas e narração das respostas.
    • Amazon Aurora Serverless v2 (Postgres + pgvector): armazena o livro de regras, registros de contratos, status de extração e determinações em um único banco relacional. Colocar tudo em um banco torna o recibo de completude uma contagem SQL — uma forma econômica de tornar a garantia central inspecionável.
    • AWS Lambda: hospeda o servidor MCP (JSON-RPC 2.0 sobre HTTP streamável, usando enquadramento Server-Sent Events para respostas) e o motor de regras. Operações delimitadas se traduzem em SQL baseado em conjuntos usando valores de regras vinculados como parâmetros. Nenhuma linguagem natural chega à camada de consulta.
    • Amazon API Gateway HTTP API: porta de entrada com autorizador de Token Web JSON (JWT) respaldado pelo Amazon Cognito. Nenhuma rota não autenticada existe.
    • Amazon Bedrock: alimenta apenas o caminho exploratório, usando Amazon Titan Text Embeddings V2 (amazon.titan-embed-text-v2:0) para ranqueamento por similaridade semântica e Anthropic Claude Sonnet 5 para avaliação qualitativa de cláusulas. Não é consultado para determinações oficiais de conformidade.
    • Amazon QuickSight: conecta-se ao Aurora por uma conexão VPC e renderiza a tabela completa de achados, filtrável por varredura e banda de severidade.

    Regras de design não negociáveis

    A AWS estabelece um conjunto de princípios que não podem ser violados na implementação desse padrão:

    • Regras são dados. Uma mudança na lei é uma edição em linha no livro de regras. O motor não contém ramificações específicas de jurisdição.
    • Nenhuma linguagem natural chega ao SQL. Operadores selecionam templates fixos de SQL. Valores de regras são vinculados como parâmetros.
    • Determinístico antes da IA. Uma comparação numérica responde à varredura. Nenhum modelo é consultado.
    • Filtragem exata para completude; vetores apenas para ranqueamento. Similaridade nunca decide pertencimento à população.
    • Recibos são calculados, não escritos à mão. O invariante é afirmado antes de uma varredura ser confirmada.
    • Documentos ilegíveis são nomeados, não descartados. Cada contrato cai em exatamente um balde.
    • Achados são somente de adição. Não existe UPDATE ou DELETE contra achados na base de código.

    Tratando o modelo de sumarização como um renderizador não confiável

    Um elemento de design merece atenção especial: as salvaguardas para sobreviver à paráfrase do modelo de chat. Excluir o modelo do caminho de decisão mas colocá-lo de volta no caminho de entrega reintroduz risco no final da cadeia.

    Na prática, a AWS observou comportamentos problemáticos: um modelo removeu um prefixo de ressalva; uma tag de citação marcada como ilustrativa foi removida durante a paráfrase, e o modelo apresentou uma citação inventada como estatuto; um modelo extrapolou a partir de uma amostra de 20 linhas e inferiu um intervalo que não existia nos dados.

    Três técnicas endereçam isso:

    • Formule ressalvas como sufixos entre colchetes que não podem ser removidos, repetidos em vários níveis do payload — não como rótulos iniciais que parecem metadados removíveis.
    • Forneça os dados que tornam a resposta honesta a mais fácil. Calcule agregados reais sobre todos os registros e entregue-os ao modelo. Um modelo que tem o número real não precisa adivinhar a partir de uma amostra.
    • Repita rótulos de modo em múltiplos níveis estruturais (campo, string, resumo) para que pelo menos um sobreviva à paráfrase.

    Como implantar e executar o exemplo

    A implementação de referência completa está disponível no repositório de exemplo no GitHub. Ela inclui dados sintéticos (sem dados reais de contratos), geração determinística de corpus e testes de aceitação contra o stack implantado.

    Pré-requisitos

    • Uma conta AWS com acesso ao Amazon Bedrock habilitado para Amazon Titan Text Embeddings V2 e Anthropic Claude Sonnet 5 na região US East (N. Virginia) — us-east-1.
    • AWS CLI v2 com credenciais configuradas (aws sts get-caller-identity deve funcionar).
    • Python 3.12.
    • Node.js 24 para o AWS Cloud Development Kit (AWS CDK) CLI.

    Passo 1: Clonar o repositório

    git clone https://github.com/aws-samples/sample-quick-adjudicated-query.git
    cd sample-quick-adjudicated-query
    python3 -m venv .venv && .venv/bin/pip install -q -r requirements.txt

    Passo 2: Implantar a infraestrutura

    eval "$(mise env -s zsh)"
    export CDK_DEFAULT_ACCOUNT=$(aws sts get-caller-identity --query Account --output text)
    npx aws-cdk@2.261.0 bootstrap aws://$CDK_DEFAULT_ACCOUNT/us-east-1
    npx aws-cdk@2.261.0 deploy --outputs-file outputs.json

    A versão do CDK está fixada em 2.261.0 para corresponder ao requirements.txt. O provisionamento do Aurora leva aproximadamente 11 minutos. O stack implanta: Amazon Cognito (cliente 2LO), Amazon API Gateway com autorizador JWT, AWS Lambda (servidor MCP + motor de regras), Amazon Aurora Serverless v2 e rede do Amazon QuickSight.

    Passo 3: Popular dados e verificar

    PY=.venv/bin/python
    $PY db/migrate.py        # schema, livro de regras, views (7 verificações)
    $PY gen_corpus.py        # corpus determinístico + manifesto
    $PY ingest.py            # carregar + embeddings (tempo varia por ambiente)
    $PY setup_dashboard.py   # configuração do QuickSight
    $PY acceptance.py        # 28 verificações contra o stack ativo

    Passo 4: Registrar a integração MCP no Amazon Quick

    O Amazon Quick faz um snapshot da lista de ferramentas no momento do registro. Novas ferramentas ou ferramentas renomeadas não são detectadas até que a integração seja excluída e recriada. Implantar apenas a Lambda não é suficiente.

    python3 - <<'PY'
    import json
    o = json.load(open('outputs.json'))['QuickPocStack']
    for k in ('McpUrl', 'TokenEndpoint', 'ClientId', 'Scope'):
        print('%-14s %s' % (k, o[k]))
    PY

    Recupere o segredo do cliente do Amazon Cognito (lido a cada vez, nunca gravado em disco) e registre no Amazon Quick em Connectors > Create for your team > Model Context Protocol.

    Passo 5: Verificar a integração

    $PY show_payload.py check_connection   # transporte ativo
    $PY acceptance.py                       # 28/28 verificações

    Percorrendo a experiência

    Com o stack implantado, é possível executar uma varredura de conformidade diretamente pelo chat do Amazon Quick. Ao perguntar "Which Texas leases violate the late fee cap? Use rules effective 01/01/2026", o Amazon Quick identifica isso como uma varredura de conformidade e seleciona a ferramenta sweep_compliance. A ferramenta executa uma verificação exaustiva contra todos os contratos do Texas na população, aplicando as regras vigentes na data declarada. Nenhum modelo está envolvido na determinação.

    A resposta inclui uma amostra dos achados em não conformidade, o recibo de completude como contagens (por exemplo, 10.111 violações, 689 ambíguos e 20 ilegíveis), uma ressalva de dados sintéticos e um link para o painel do QuickSight. Deliberadamente, ela não tenta renderizar todos os registros na mensagem de chat.

    Para verificar o recibo de completude, basta checar o invariante: conforme + em violação + ambíguo + ilegível deve ser igual ao total da população varrida. No exemplo, as contagens somam o total de contratos do Texas, confirmando que cada registro caiu em exatamente um balde.

    O painel do QuickSight exibe cada achado da varredura — um por par contrato-regra — com a cadeia completa de evidências: ID do contrato, a regra que disparou, o valor extraído e o valor esperado. Cada determinação carrega sua citação de regra, versão e o texto verbatim da cláusula do contrato, então nada precisa ser reconstruído posteriormente.

    Considerações de segurança

    Como esse padrão é construído para trabalho de conformidade, a segurança faz parte do design, não é um complemento. A implementação de exemplo aplica as seguintes práticas:

    • Acesso apenas autenticado: todas as requisições chegam ao servidor MCP por uma HTTP API do Amazon API Gateway protegida por um autorizador JWT respaldado pelo Amazon Cognito. Nenhuma rota não autenticada existe.
    • Tratamento de segredos: o segredo do cliente do Amazon Cognito é lido no momento do registro e não é gravado em disco nem commitado no controle de versão.
    • Acesso mínimo ao modelo: a função de execução do AWS Lambda concede InvokeModel no Amazon Bedrock apenas para os ARNs específicos dos modelos usados no exemplo, não um wildcard sobre todos os modelos.
    • Isolamento de rede para o caminho de dados: o Amazon QuickSight acessa o Amazon Aurora Serverless v2 por uma conexão VPC, não por um endpoint público.
    • Sem linguagem natural no caminho de consulta: o motor de regras monta SQL apenas a partir de uma tabela fixa de operador-para-template com valores de regras vinculados como parâmetros — isso é uma propriedade de segurança tanto quanto de correção.
    • Achados auditáveis e somente de adição: não existe caminho de UPDATE ou DELETE na base de código, então o registro de conformidade não pode ser silenciosamente alterado após o fato.

    Um ponto importante sobre atribuição: o Amazon Quick autentica no servidor MCP máquina-a-máquina via fluxo de credenciais de cliente, então o token identifica a aplicação Amazon Quick, não o indivíduo que fez a pergunta no chat. Para o requisito de "por quem" na defensibilidade, a atribuição fica na camada de auditoria do Amazon Quick. Se você precisar que a atribuição seja registrada diretamente no armazenamento de conformidade, é necessário encaminhar um ID de usuário final do Amazon Quick para a chamada de ferramenta e persistí-lo na linha de varredura.

    Quando usar (e quando não usar) esse padrão

    O padrão Adjudicated Query se aplica quando: um registro perdido é uma responsabilidade legal em vez de um inconveniente; respostas podem ser contestadas meses depois; a lógica de governança é de propriedade externa e muda em seu próprio calendário; e o conjunto de registros é enumerável. Isso abrange conformidade de contratos, adjudicação de sinistros de seguros, triagem de sanções, controle de exportações, monitoramento de protocolos de ensaios clínicos, inspeção de código de construção, testes de controles de relatórios financeiros e verificação de credenciais.

    O padrão é pesado — um motor de regras, uma superfície de ferramentas delimitada e um recibo de completude. Essa maquinaria só vale a pena no problema certo. Evite o padrão em três casos:

    • As regras não são realmente determinísticas. O padrão funciona quando a conformidade é uma comparação limpa (taxa menor ou igual a um teto). Quando a decisão é um julgamento genuíno (se uma cláusula é abusiva), forçá-la nesse padrão esconde a subjetividade dentro da autoria de regras e faz o resultado parecer exato quando não é.
    • A completude não importa para a pergunta. Se o usuário quer apenas alguns exemplos representativos ou está explorando, o recibo de completude é sobrecarga para uma garantia que não é necessária. RAG é a resposta mais simples e correta para esse tipo de pergunta.
    • A própria população é imprecisa. O recibo prova que você cobriu cada registro na população, não que a população é a correta. Se a definição de "todos os contratos do Texas" é em si contestável, a garantia é precisa sobre o denominador errado.

    Conclusão

    O padrão Adjudicated Query resolve um problema real de conformidade em escala: como oferecer acesso conversacional a verificações de conformidade sem abrir mão das garantias de completude e defensibilidade que esse tipo de trabalho exige. A chave está em manter o modelo de linguagem fora do caminho de decisão — ele traduz perguntas e narra resultados, mas nunca toca nas determinações que produzem a garantia.

    Para começar, clone o repositório de exemplo, implante o stack, registre a integração MCP no Amazon Quick e experimente fazer sua primeira pergunta de conformidade.

    Fonte

    Sweep thousands of leases for compliance using Amazon Quick and the Adjudicated Query pattern (https://aws.amazon.com/blogs/machine-learning/sweep-thousands-of-leases-for-compliance-using-amazon-quick-and-the-adjudicated-query-pattern/)

  • AWS CLI ganha suporte a atualizações em massa e verificação de versões para o Agent Toolkit

    Novidades no Agent Toolkit para AWS

    A AWS anunciou a expansão dos comandos da Interface de Linha de Comando (CLI) da AWS para o Agent Toolkit para AWS, adicionando duas novas capacidades voltadas a facilitar a manutenção e atualização das skills de agentes de IA. A novidade foi disponibilizada ao final de setembro de 2026.

    O que é o Agent Toolkit para AWS

    Para contextualizar: o Agent Toolkit para AWS é composto por três elementos principais:

    • AWS MCP Server: fornece uma interface de agente segura e auditável para mais de 15.000 APIs da AWS;
    • Agent skills (habilidades de agente): orientações especializadas para agentes em áreas como armazenamento, redes, analytics e muito mais;
    • Plugins: pacotes que combinam o MCP Server com conjuntos curados de skills em uma única instalação.

    O toolkit é compatível com ferramentas populares de codificação assistida por IA como Kiro, Claude Code, Codex, Cursor, entre outras.

    Os dois novos comandos da AWS CLI

    Antes dessa atualização, quem utilizava o Agent Toolkit precisava verificar e atualizar cada skill instalada de forma individual — um processo manual e trabalhoso, especialmente para equipes com muitas skills em uso. Com as novas adições, esse fluxo ficou bem mais simples:

    • aws agent-toolkit check-skill-updates — compara todas as skills instaladas com as versões mais recentes disponíveis no registro, indicando quais estão desatualizadas;
    • aws agent-toolkit update-skill --all — atualiza todas as skills desatualizadas de uma só vez, com um único comando.

    Esses dois comandos se somam ao conjunto já existente de capacidades da AWS CLI para o Agent Toolkit, que já permitia instalar, pesquisar e configurar o AWS MCP Server e as skills de agentes.

    Por que isso importa para equipes de desenvolvimento

    Para times que trabalham com agentes de codificação e têm muitas skills instaladas — cobrindo domínios como serverless, armazenamento, redes e analytics — garantir que todas estejam na versão mais recente era um desafio operacional real. Com esses novos comandos, o processo de manutenção se torna muito mais ágil, reduzindo o risco de agentes operando com orientações desatualizadas.

    Como começar

    Para utilizar as novas funcionalidades, é necessário ter a versão 2.37.0 ou superior da AWS CLI instalada. A documentação completa está disponível na seção de AWS CLI do guia do usuário do Agent Toolkit para AWS.

    Vale destacar que o AWS MCP Server está disponível atualmente nas regiões US East (Norte da Virgínia) e Europe (Frankfurt).

    Fonte

    AWS CLI now supports bulk skill updates and version checks for the Agent Toolkit for AWS (https://aws.amazon.com/about-aws/whats-new/2026/09/aws-cli-agent-toolkit-update-skill/)

  • Amazon S3 Vectors ganha pré-filtragem de metadados com até 5x mais resultados em buscas filtradas

    O que mudou no Amazon S3 Vectors

    A AWS anunciou uma atualização relevante para o Amazon S3 Vectors: o serviço passa a suportar pré-filtragem de metadados em buscas por similaridade. Antes dessa mudança, os filtros de metadados eram aplicados após a busca vetorial — o que significava que, em cenários com filtros muito seletivos, boa parte dos resultados relevantes acabava descartada. Com a pré-filtragem, a avaliação dos filtros acontece antes da busca por similaridade, o que pode resultar em até 5 vezes mais vetores correspondentes retornados ao final da consulta.

    Novo operador de filtragem por prefixo

    Junto com a pré-filtragem, a AWS também introduziu o operador $startsWith, que permite filtrar valores com base em prefixos — útil especialmente para trabalhar com caminhos de arquivos e URLs. Essa adição amplia as opções de filtragem disponíveis no serviço e facilita a construção de consultas mais precisas em cenários do mundo real.

    Impacto para aplicações de RAG, agentes e busca semântica

    As melhorias têm impacto direto em aplicações que dependem de recuperação de informações com filtros, como sistemas de Geração Aumentada por Recuperação (RAG — Retrieval-Augmented Generation), fluxos de trabalho com agentes de IA e motores de busca semântica. Com resultados mais completos nas consultas filtradas, essas aplicações passam a entregar respostas mais relevantes e precisas para os usuários finais.

    Como ativar a pré-filtragem

    Para índices criados em novos buckets de vetores, a pré-filtragem já vem ativada por padrão — sem necessidade de alterar a forma como os vetores são gravados via PutVectors ou como as consultas são feitas via QueryVectors. Para índices já existentes, é possível ativar a pré-filtragem atualizando o índice com a API UpdateIndexMode. Antes de migrar definitivamente, também é possível comparar os dois modos de filtragem no mesmo índice, utilizando um parâmetro por consulta diretamente no QueryVectors.

    Disponibilidade e custo

    A pré-filtragem de metadados está disponível sem custo adicional em todas as regiões comerciais da AWS onde o Amazon S3 Vectors já está presente, incluindo as regiões da AWS China. A AWS informou que o processo de implantação está em andamento e deve ser concluído nos próximos dias.

    Para começar a usar, é possível acessar o recurso via AWS CLI, AWS SDKs ou pelo console do Amazon S3. Para mais detalhes técnicos, consulte a documentação oficial do Amazon S3 Vectors ou acompanhe a análise completa no AWS News Blog.

    Fonte

    Amazon S3 Vectors introduces metadata pre-filtering for up to 5x higher recall on filtered search (https://aws.amazon.com/about-aws/whats-new/2026/09/s3-vectors-introduces-metadata-pre-filtering/)

  • Consulte sinistros em linguagem natural com o Amazon Bedrock Knowledge Bases

    O desafio de consultar sinistros em linguagem natural

    Quem trabalha com seguros sabe bem o problema: as informações de um sinistro estão espalhadas por relatórios de ajustadores, estimativas de reparo, boletins de ocorrência, registros de pagamento e anexos digitalizados — nunca em um único campo pesquisável. Um segurado quer saber se o sinistro foi aprovado. Um ajustador precisa listar todos os sinistros de automóvel abertos acima de R$ 10.000 do mês passado. Ambas as tarefas exigem encontrar e combinar evidências com rapidez e precisão.

    Para resolver isso, a AWS publicou um guia técnico detalhado mostrando como construir um assistente de sinistros com o Amazon Bedrock Knowledge Bases — a capacidade de Geração Aumentada por Recuperação (RAG) totalmente gerenciada do Amazon Bedrock. O serviço cuida de toda a infraestrutura de análise, fragmentação, embeddings e armazenamento vetorial, permitindo criar uma interface conversacional que retorna respostas com citações diretas dos documentos de sinistro.

    Vale destacar que o tutorial usa registros sintéticos de sinistros e não descreve um deployment real de produção.

    Visão geral da solução

    A arquitetura tem dois fluxos principais: ingestão e recuperação.

    No fluxo de ingestão, os documentos de sinistro chegam ao Amazon S3 junto com arquivos de metadados auxiliares. Um job de ingestão sincroniza a fonte de dados S3 com a base de conhecimento, que analisa, fragmenta, embute e indexa tudo no armazenamento vetorial gerenciado.

    No fluxo de recuperação, a aplicação chama a API AgenticRetrieveStream com a pergunta, o histórico da conversa e filtros de metadados opcionais. Um modelo de fundação cria sub-consultas e repete a recuperação até reunir evidências suficientes. Em seguida, uma verificação de fundamentação contextual bloqueia respostas não suportadas pelos registros recuperados. O Amazon Bedrock transmite a resposta, os eventos de rastreamento e as citações em streaming.

    A recuperação agêntica via AgenticRetrieveStream planeja a resposta, decompõe perguntas complexas em sub-consultas e executa uma ou mais rodadas de recuperação — verificando se as evidências são suficientes antes de gerar a resposta final.

    Preparando os documentos e metadados

    A recomendação é armazenar um documento por sinistro no Amazon S3. A base de conhecimento lê PDFs, documentos Word e arquivos de texto diretamente em seu formato nativo.

    Para habilitar filtros, cada documento deve ter um arquivo de metadados auxiliar com o mesmo nome acrescido de .metadata.json. Por exemplo, para CLM-100482.pdf, o arquivo seria CLM-100482.pdf.metadata.json:

    {
      "metadataAttributes": {
        "claim_id": "CLM-100482",
        "claim_type": "auto",
        "status": "open",
        "date_filed": 20260709,
        "amount": 14250,
        "region": "us-west",
        "adjuster": "Martha Rivera",
        "policyholder": "Mary Major",
        "policy_number": "POL-AUTO-78432",
        "customer_id": "CUST-MM-1042",
        "household_id": "HHD-MM-1042",
        "document_type": "adjuster_report",
        "carrier": "Example Insurance",
        "has_subrogation": true,
        "has_litigation": false,
        "complexity_tier": "high"
      }
    }

    O arquivo auxiliar contém valores escalares de string, número e booleano. Alguns pontos importantes de design: datas devem ser armazenadas como inteiros no formato YYYYMMDD, pois os filtros de metadados comparam números, não strings. Isso permite filtros de intervalo como “registrado no mês passado”. Apenas um valor monetário comparável deve ficar no campo amount; reservas, pagamentos e retenções devem permanecer no texto do documento para que seus rótulos fiquem claros. Os arquivos auxiliares têm limite de 10 KB — consulte a documentação Connect to Amazon S3 for your knowledge base para o formato completo.

    Criando a base de conhecimento e ingerindo os sinistros

    A base de conhecimento é criada com o cliente bedrock-agent. Definindo o tipo como MANAGED, o Amazon Bedrock seleciona e opera o modelo de embedding automaticamente — sem necessidade de configurar um armazenamento vetorial. Veja a referência CreateKnowledgeBase para todos os parâmetros:

    import boto3
    
    bedrock_agent = boto3.client("bedrock-agent", region_name="us-west-2")
    
    kb = bedrock_agent.create_knowledge_base(
        name="insurance-claims-kb",
        description="Synthetic insurance claims for the claims assistant",
        roleArn="arn:aws:iam::111122223333:role/InsuranceClaimsKnowledgeBaseRole",
        knowledgeBaseConfiguration={
            "type": "MANAGED",
            "managedKnowledgeBaseConfiguration": {
                "embeddingModelType": "MANAGED"
            },
        },
    )
    kb_id = kb["knowledgeBase"]["knowledgeBaseId"]

    O roleArn é a função de serviço que concede à base de conhecimento permissão para ler o bucket S3 e usar o modelo de embedding gerenciado. Consulte como criar uma função de serviço para o Amazon Bedrock Knowledge Bases. Para criptografar o armazenamento vetorial gerenciado com uma chave gerenciada pelo cliente do Serviço de Gerenciamento de Chaves da AWS (AWS KMS), passe o ARN dela em serverSideEncryptionConfiguration.

    Em seguida, conecta-se o bucket S3 como fonte de dados, limitando a ingestão ao prefixo claims/:

    data_source = bedrock_agent.create_data_source(
        knowledgeBaseId=kb_id,
        name="claims-s3",
        dataSourceConfiguration={
            "type": "S3",
            "s3Configuration": {
                "bucketArn": "arn:aws:s3:::amzn-s3-demo-insurance-claims",
                "inclusionPrefixes": ["claims/"],
            },
        },
    )
    data_source_id = data_source["dataSource"]["dataSourceId"]

    Com a fonte de dados criada, inicia-se o job de ingestão para analisar, fragmentar, embutir e indexar os documentos. Esse job deve ser executado novamente sempre que documentos forem adicionados ou atualizados:

    bedrock_agent.start_ingestion_job(
        knowledgeBaseId=kb_id,
        dataSourceId=data_source_id,
    )

    O status pode ser verificado com get_ingestion_job ou pelo console do Amazon Bedrock. Quando o job conclui, os sinistros estão pesquisáveis. Veja a referência StartIngestionJob para detalhes.

    Consultando sinistros com a API AgenticRetrieveStream

    Com os sinistros ingeridos, a chamada à API usa o cliente bedrock-agent-runtime. A requisição tem três partes: messages (turnos da conversa), retrievers (até cinco bases de conhecimento, com filtros e limite de resultados opcionais) e agenticRetrieveConfiguration (modelo de planejamento e limite de iterações). Definindo generateResponse como True, o serviço retorna uma resposta em linguagem natural:

    bedrock_agent_runtime = boto3.client("bedrock-agent-runtime", region_name="us-west-2")
    
    response = bedrock_agent_runtime.agentic_retrieve_stream(
        messages=[
            {"role": "user", "content": {"text": "What is the status of claim CLM-100482?"}}
        ],
        retrievers=[
            {
                "configuration": {"knowledgeBase": {"knowledgeBaseId": kb_id}},
                "description": "Synthetic insurance claim records",
            }
        ],
        agenticRetrieveConfiguration={
            "foundationModelType": "MANAGED",
            "maxAgentIteration": 5,
        },
        generateResponse=True,
    )

    O stream de resposta emite três tipos de eventos: traceEvent (plano de recuperação, sub-consultas, ações de guardrail), responseEvent (texto incremental da resposta) e result (resultados de recuperação deduplicados, resposta completa e citações). O loop abaixo transmite os fragmentos da resposta em tempo real e retém o resultado final para renderizar as citações:

    answer = ""
    final_result = None
    
    for event in response["stream"]:
        if "traceEvent" in event:
            attributes = event["traceEvent"]["attributes"]
            print(f"[trace] {attributes.get('step')}: {attributes.get('status')}")
        elif "responseEvent" in event:
            chunk = event["responseEvent"]["text"]
            answer += chunk
            print(chunk, end="", flush=True)
        elif "result" in event:
            final_result = event["result"]

    Lendo o rastreamento do loop agêntico

    A função auxiliar abaixo imprime sub-consultas, buscas de documentos completos e ações de guardrail a partir dos eventos de rastreamento:

    def report_trace(trace_event):
        attributes = trace_event.get("attributes", {})
        print(f"[trace] {attributes.get('step')}: {attributes.get('status')}")
        for action in attributes.get("actions", []):
            if "retrieve" in action:
                sub_query = action["retrieve"].get("inputQuery", {}).get("text", "")
                print(f"  sub-query: {sub_query}")
            elif "fullDocumentExpansion" in action:
                document = action["fullDocumentExpansion"].get("documentId", "")
                print(f"  full document: {document}")
        for warning in attributes.get("warnings", []):
            if "guardrail" in warning:
                print(f"  guardrail: {warning['guardrail'].get('action')}")

    O loop agêntico funciona assim: o serviço planeja uma estratégia, cria sub-consultas, recupera evidências e verifica se são suficientes. Se necessário, executa outra rodada antes de gerar a resposta citada.

    Imagem original — fonte: Aws

    Renderizando citações

    Cada citação identifica um intervalo de caracteres na resposta e referencia entradas no array de resultados. O código abaixo imprime cada trecho citado ao lado do URI da fonte correspondente:

    generated = final_result["generatedResponse"]
    results = final_result["results"]
    
    for citation in generated.get("citations", []):
        span = generated["answer"][citation["startIndex"]:citation["endIndex"]]
        for reference in citation["references"]:
            source = results[reference["resultIndex"]]
            source_uri = source.get("metadata", {}).get("x-amz-bedrock-kb-source-uri")
            print(f'"{span}"\n -> {source_uri}')

    Perguntas de acompanhamento em conversa multi-turno

    Perguntas de acompanhamento dependem de turnos anteriores. Após uma resposta de status, um segurado pode perguntar “Quem é o ajustador responsável?” — e a palavra “responsável” precisa ser resolvida a partir do histórico da conversa. Basta manter o histórico na aplicação e enviá-lo completo a cada chamada:

    messages = [
        {"role": "user", "content": {"text": "What is the status of claim CLM-100482?"}},
        {"role": "assistant", "content": {"text": answer}},
        {"role": "user", "content": {"text": "Who is the adjuster assigned to it?"}},
    ]
    
    response = bedrock_agent_runtime.agentic_retrieve_stream(
        messages=messages,
        retrievers=[
            {"configuration": {"knowledgeBase": {"knowledgeBaseId": kb_id}}}
        ],
        agenticRetrieveConfiguration={"foundationModelType": "MANAGED"},
        generateResponse=True,
    )

    O serviço usa os turnos anteriores para resolver “it” ao sinistro CLM-100482 e recupera o ajustador desse sinistro.

    Escopo de recuperação com filtros de metadados

    Filtros de metadados restringem os documentos antes da busca semântica. Para uma consulta direta por ID de sinistro, usa-se um filtro de igualdade:

    retrievers = [
        {
            "configuration": {
                "knowledgeBase": {
                    "knowledgeBaseId": kb_id,
                    "retrievalOverrides": {
                        "filter": {"equals": {"key": "claim_id", "value": "CLM-100482"}}
                    },
                }
            }
        }
    ]

    Para sinistros de automóvel abertos acima de $10.000 registrados em julho de 2026, combinam-se condições com andAll:

    claims_filter = {
        "andAll": [
            {"equals": {"key": "claim_type", "value": "auto"}},
            {"equals": {"key": "status", "value": "open"}},
            {"greaterThan": {"key": "amount", "value": 10000}},
            {"greaterThanOrEquals": {"key": "date_filed", "value": 20260701}},
            {"lessThanOrEquals": {"key": "date_filed", "value": 20260731}},
        ]
    }
    
    response = bedrock_agent_runtime.agentic_retrieve_stream(
        messages=[
            {
                "role": "user",
                "content": {
                    "text": "Summarize the outstanding items on the open auto "
                            "claims over $10,000 filed in July."
                },
            }
        ],
        retrievers=[
            {
                "configuration": {
                    "knowledgeBase": {
                        "knowledgeBaseId": kb_id,
                        "retrievalOverrides": {
                            "filter": claims_filter,
                            "maxNumberOfResults": 50,
                        },
                    }
                }
            }
        ],
        agenticRetrieveConfiguration={"foundationModelType": "MANAGED"},
        generateResponse=True,
    )

    Como essa consulta pode corresponder a muitos sinistros, maxNumberOfResults é definido como 50 — um limite menor poderia omitir sinistros relevantes do resumo. Os operadores suportados incluem equals, notEquals, comparações numéricas, in, notIn, stringContains, listContains e lógicos andAll/orAll. Consulte Metadados e filtragem para confirmar o suporte a operadores. Se um filtro não retornar documentos, o recomendado é retornar uma mensagem clara como “Nenhum sinistro corresponde a esses critérios”.

    Resultados de avaliação

    A avaliação foi realizada em um corpus sintético de 30 documentos usando as APIs Retrieve e RetrieveAndGenerate (não AgenticRetrieveStream). O conjunto de 40 perguntas inclui consultas diretas, comparações, aliases, registros substituídos, pagamentos revertidos e texto instrucional dentro de documentos. Os resultados gerais foram:

    • Perguntas respondidas: 40 de 40
    • Respostas com citações: 40 de 40
    • Média de citações por resposta: 3,9
    • Recall de recuperação de fonte esperada: 90,5%
    • Recall de citação de fonte esperada: 81,2%
    • Fragmentos contradizendo o filtro solicitado: 0

    Nas 20 perguntas adversariais, o recall de recuperação foi de 96,7% e o recall de citação foi de 90,2%. Perguntas específicas de sinistro tiveram o melhor desempenho. Perguntas amplas de inventário sem filtros produziram os três resultados mais fracos. A cobertura de citações não garante completude da resposta — recomenda-se medir completude separadamente quando isso for relevante. Esses resultados usam documentos sintéticos e classificação automatizada; uma revisão humana no corpus real é necessária antes de expor o assistente a segurados.

    Segurança e governança

    Filtros de escopo por usuário autenticado

    Os filtros de metadados devem ser tratados como limite de acesso. O recomendado é derivar region ou customer_id da sessão autenticada, combiná-los com filtros de consulta usando andAll, e nunca aceitar o limite a partir do texto do usuário. O campo userContext também suporta filtragem de controle de acesso.

    Permissões do Gerenciamento de Identidade e Acesso (IAM)

    As permissões devem ser concedidas apenas para recuperação agêntica, acesso à base de conhecimento, streaming de modelo e ações de guardrail:

    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Effect": "Allow",
          "Action": "bedrock:AgenticRetrieveStream",
          "Resource": "*"
        },
        {
          "Effect": "Allow",
          "Action": [
            "bedrock:Retrieve",
            "bedrock:GetDocumentContent"
          ],
          "Resource": "arn:aws:bedrock:us-west-2:111122223333:knowledge-base/*"
        },
        {
          "Effect": "Allow",
          "Action": "bedrock:InvokeModelWithResponseStream",
          "Resource": "*"
        },
        {
          "Effect": "Allow",
          "Action": [
            "bedrock:GetGuardrail",
            "bedrock:ApplyGuardrail"
          ],
          "Resource": "*"
        }
      ]
    }

    O AWS CloudTrail registra chamadas ao Amazon Bedrock para auditoria. O Amazon S3 criptografa objetos em repouso por padrão — veja como configurar a criptografia padrão. É possível usar chaves AWS KMS gerenciadas pelo cliente tanto para o bucket quanto para o armazenamento vetorial gerenciado. O tráfego de API usa Segurança da Camada de Transporte (TLS).

    Fundamentação contextual com Amazon Bedrock Guardrails

    Adicionar uma verificação de fundamentação contextual do Amazon Bedrock Guardrails bloqueia respostas abaixo de limiares configurados de fundamentação (consistência com os documentos recuperados) e relevância (alinhamento com a pergunta do usuário). Para sinistros, limiares altos são recomendados — recusar uma resposta é mais seguro do que gerar conteúdo não suportado:

    bedrock = boto3.client("bedrock", region_name="us-west-2")
    
    guardrail = bedrock.create_guardrail(
        name="claims-assistant-guardrail",
        description="Contextual grounding for the claims assistant",
        contextualGroundingPolicyConfig={
            "filtersConfig": [
                {"type": "GROUNDING", "threshold": 0.85},
                {"type": "RELEVANCE", "threshold": 0.75},
            ]
        },
        blockedInputMessaging="I can't help with that request.",
        blockedOutputsMessaging="I can only answer questions using the claim records.",
    )
    guardrail_id = guardrail["guardrailId"]
    guardrail_version = bedrock.create_guardrail_version(
        guardrailIdentifier=guardrail_id
    )["version"]

    O guardrail é passado na chamada principal via policyConfiguration. A recuperação agêntica suporta a ação BLOCK: uma verificação de fundamentação reprovada bloqueia a resposta, e os eventos de rastreamento registram a intervenção. É fundamental manter uma pessoa no ciclo para revisar as evidências citadas e tomar a decisão final sobre o sinistro.

    Limpeza dos recursos

    Para evitar cobranças futuras, os recursos devem ser removidos ao final:

    # Excluir a base de conhecimento (também remove o armazenamento vetorial gerenciado)
    bedrock_agent.delete_knowledge_base(knowledgeBaseId=kb_id)
    
    # Excluir o guardrail
    bedrock.delete_guardrail(guardrailIdentifier=guardrail_id)

    Além disso, é necessário esvaziar e excluir o bucket S3 e remover a função e política IAM da base de conhecimento.

    Conclusão

    O guia da AWS demonstra como construir um assistente de sinistros com o Amazon Bedrock Knowledge Bases e documentos sintéticos no Amazon S3. A API AgenticRetrieveStream cuida de perguntas multi-parte, histórico de conversa, filtros de metadados, verificações de fundamentação, respostas em streaming e citações. O mesmo padrão se aplica a documentos de subscrição e atendimento de apólices. Para aprofundar, a AWS disponibiliza a documentação de uso de recuperação agêntica para consultar uma base de conhecimento.

    Fonte

    Query claims in natural language with Amazon Bedrock Knowledge Bases (https://aws.amazon.com/blogs/machine-learning/query-claims-in-natural-language-with-amazon-bedrock-knowledge-bases/)

  • OpenAI GPT-6 Astra agora suporta modo UltraFast no Amazon Bedrock

    O que foi anunciado

    A AWS anunciou a disponibilidade do modo UltraFast para o modelo GPT-6 Astra, da OpenAI, dentro do Amazon Bedrock. A novidade foi divulgada em 30 de setembro de 2026 e representa uma camada premium de velocidade para quem trabalha com workloads onde latência é um fator crítico.

    O que é o modo UltraFast

    O UltraFast é uma camada de velocidade premium desenvolvida especificamente para o GPT-6 Astra. De acordo com a OpenAI, esse modo entrega até 6x mais velocidade de inferência na Interface de Programação de Aplicações (API), com capacidade de processar até 300 tokens por segundo.

    Em termos práticos, isso significa respostas significativamente mais rápidas para aplicações que precisam reagir em tempo real — sem abrir mão da qualidade das respostas geradas pelo modelo.

    Para quais cenários o UltraFast faz sentido

    A AWS destaca que o modo UltraFast é especialmente indicado para aplicações sensíveis à latência, como:

    • Assistentes de codificação em tempo real — onde o desenvolvedor precisa de sugestões instantâneas enquanto escreve;
    • Agentes interativos — sistemas que precisam responder e agir de forma fluida em conversas ou fluxos automatizados;
    • Experiências voltadas ao cliente final — interfaces de atendimento, chatbots e produtos que exigem respostas rápidas e de alta qualidade para o usuário.

    Infraestrutura e segurança do Amazon Bedrock

    O GPT-6 Astra com UltraFast roda sobre o motor de inferência do Amazon Bedrock, que a AWS posiciona como a base para workloads de produção — entregando desempenho, segurança e confiabilidade. Os controles já estabelecidos no Bedrock permitem que equipes protejam seus workloads, governem o acesso e auditem a atividade de invocação dos modelos, sem precisar configurar infraestrutura adicional.

    Como começar a usar

    Para experimentar o GPT-6 Astra no modo UltraFast, é possível acessar diretamente o console do Amazon Bedrock ou utilizar as APIs suportadas de forma programática. Informações sobre Regiões AWS compatíveis, endpoints, APIs, funcionalidades, perfis de inferência e preços estão disponíveis na documentação oficial do Amazon Bedrock.

    Fonte

    OpenAI GPT-6 Astra now supports UltraFast mode on Amazon Bedrock (https://aws.amazon.com/about-aws/whats-new/2026/09/openai-gpt-6-astra-ultrafast-on-amazon-bedrock/)

  • Pipeline de produção musical com múltiplos agentes no Amazon Bedrock AgentCore Runtime Instances

    O problema: quando sessões serverless não são suficientes

    À medida que as arquiteturas de Inteligência Artificial (IA) evoluem de agentes únicos para sistemas multi-agentes, os requisitos de infraestrutura mudam significativamente. Um agente solitário respondendo a consultas de clientes funciona bem em ambiente serverless com sessões curtas. Mas quando três agentes precisam colaborar em um fluxo de trabalho criativo que se estende por vários dias, compartilhando contexto e construindo sobre os resultados uns dos outros, sessões limitadas a poucas horas simplesmente não resolvem.

    Para endereçar esse cenário, a AWS publicou um guia detalhado mostrando como implantar um pipeline de produção musical com o Amazon Bedrock AgentCore. O exemplo é prático: um agente roda um modelo generativo de áudio diretamente na Unidade de Processamento Gráfico (GPU) da instância, e outros dois agentes abrem o arquivo .wav gerado a partir de um volume compartilhado. O resultado final é uma faixa de áudio reproduzível — e uma arquitetura que serve de modelo para workloads muito além da música.

    MicroVM vs. Runtime Instances: qual a diferença?

    O Amazon Bedrock AgentCore oferece duas opções de computação para hospedar agentes. As MicroVMs são a opção serverless: inicialização rápida, isolamento de sessão e precificação baseada em consumo. As Runtime Instances são a opção mais recente: infraestrutura EC2 gerenciada pela AWS para fluxos de trabalho persistentes e de longa duração.

    Ambas as opções suportam frameworks customizados (CrewAI, LangGraph, LlamaIndex, Strands Agents), funcionam com o modelo fundacional de sua escolha e integram com MCP e A2A. A diferença está no modelo de computação subjacente:

    • Duração da sessão: MicroVM suporta até 8 horas; Runtime Instances suporta até 14 dias.
    • Agentes por instância: MicroVM hospeda um agente por runtime (1:1); Runtime Instances permite múltiplos agentes por instância EC2 (1:N).
    • Acesso a GPU: não disponível em MicroVM; disponível em Runtime Instances em famílias de instâncias compatíveis.
    • Persistência de sessão: MicroVM usa armazenamento com escopo de sessão; Runtime Instances usa armazenamento persistente via Amazon Elastic Block Store (EBS).
    • Precificação: MicroVM é baseada em consumo; Runtime Instances usa instâncias EC2 na sua conta, com suporte a AWS Savings Plans e Reservas de Capacidade sob Demanda (ODCRs).

    Um detalhe importante sobre a colocação: quando dois runtimes de agentes compartilham o mesmo capacity provider e são invocados com o mesmo runtimeSessionId, o AgentCore os coloca na mesma instância EC2. Ali, eles compartilham um sistema de arquivos e podem colaborar na mesma tarefa.

    Visão geral da solução: três agentes, uma instância GPU

    A solução demonstrada pela AWS é um sistema de produção musical com três agentes especializados, todos rodando na mesma instância GPU:

    • Agente de Composição (equipe de Audio AI): transforma a solicitação do produtor em um briefing musical usando o Claude Sonnet 4.6, depois renderiza o áudio real com o modelo generativo ACE-Step — um modelo fundacional de código aberto para geração de música — diretamente na GPU da instância. Empacotado como imagem de container no Amazon Elastic Container Registry (ECR).
    • Agente de Entrega (equipe de Engenharia de Áudio): lê a faixa renderizada do sistema de arquivos compartilhado, mede suas características técnicas, consulta o Claude Sonnet 4.6 para definir uma cadeia de processamento (equalização, compressão, limitação) baseada nessas medições, aplica o Processamento Digital de Sinal (DSP) real e mede novamente para confirmar que o resultado atingiu o alvo de entrega. Também empacotado como container no ECR.
    • Agente de Conformidade (equipe de Engenharia de Release): re-mede de forma independente a entrega finalizada, verifica os alvos declarados pelo agente de entrega e rastreia similaridade harmônica com o catálogo do estúdio. Se detectar uma correspondência, chama de volta o agente de composição para gerar uma alternativa. Entregue como arquivo zip no Amazon Simple Storage Service (S3).

    O que torna isso possível nas Runtime Instances é a combinação de quatro características: colocação via ID de sessão compartilhado, acesso a GPU (NVIDIA L4), persistência multi-dia com volumes EBS, e implantação independente por equipe.

    Pré-requisitos

    Antes de começar, é necessário ter:

    • Uma conta AWS com credenciais para criar infraestrutura (Funções de Gerenciamento de Identidade e Acesso (IAM), bucket S3, repositórios ECR, capacity provider e runtimes AgentCore).
    • Interface de Linha de Comando da AWS (AWS CLI) instalada e configurada.
    • Uma Nuvem Privada Virtual (VPC) com pelo menos uma sub-rede e grupo de segurança.
    • Acesso ao modelo Anthropic Claude Sonnet 4.6 habilitado no console do Amazon Bedrock.
    • Finch ou outra ferramenta de container compatível com OCI instalada localmente.
    • Python 3.10+ e boto3 ≥ 1.36.0 (versões anteriores não possuem create_capacity_provider).

    O código completo está disponível no repositório de exemplos do AgentCore no GitHub.

    Passo 1: Definindo os agentes

    O AgentCore Runtime Instances suporta qualquer framework de agentes. Neste exemplo, cada agente é uma aplicação Python construída com Strands Agents. Dois detalhes são frequentemente configurados incorretamente:

    Primeiro, o parâmetro do entrypoint deve se chamar context — o SDK faz dispatch pelo nome do parâmetro:

    @app.entrypoint
    def invoke(payload, context): # the parameter must be NAMED "context"
        session_id = getattr(context, "session_id", None) or "local-session"

    Segundo, o agente deve ser construído dentro do handler, não no escopo do módulo — um agente no escopo do módulo é compartilhado entre requisições concorrentes, e o Strands rejeita invocações reentrantes:

    def build_agent(session_id: str, track_id: str) -> Agent:
        return Agent(
            name=AGENT_NAME,
            model=BedrockModel(model_id=MODEL_ID, region_name=REGION),
            system_prompt=SYSTEM_PROMPT,
            session_manager=FileSessionManager(
                session_id=f"{session_id}-{AGENT_NAME}",
                storage_dir=str(track_path(track_id) / f".sessions-{AGENT_NAME}"),
            ),
        )

    O histórico da sessão persiste no volume via FileSessionManager, o que permite que uma sessão retomada dias depois lembre as decisões anteriores.

    Passo 2: Criando o capacity provider

    Um capacity provider informa ao AgentCore qual infraestrutura de computação provisionar. São necessárias duas funções IAM com propósitos distintos: uma função de operador (que o AgentCore assume para provisionar EC2) e uma função de execução (que o processo do agente assume em tempo de execução para chamar Bedrock e S3). Ambas devem ter bedrock-agentcore.amazonaws.com como entidade confiável.

    Um detalhe importante: nomes de capacity providers devem usar underscores — hífens não são permitidos.

    control = boto3.client("bedrock-agentcore-control", region_name=REGION)
    resp = control.create_capacity_provider(
        name="music_production_capacity",
        permissionsConfiguration={"capacityProviderOperatorRoleArn": operator_arn},
        computeConfiguration={
            "ec2Configuration": {
                "launchTemplateSource": {
                    "launchParameters": {
                        "operatingSystem": "LINUX_X86_64",
                        "instanceRequirements": {"allowedInstanceTypes": ["g6.xlarge"]},
                    }
                },
                "vpcConfiguration": {"subnets": subnets, "securityGroups": groups},
                "volumes": [
                    {"ebsConfiguration": {"name": "tracks", "sizeGiB": 20, "volumeType": "gp3", "encrypted": True}},
                    {"ebsConfiguration": {"name": "models", "sizeGiB": 60, "volumeType": "gp3", "encrypted": True, "throughput": 500}},
                ],
                "rootVolume": {"freeSpaceGiB": 30, "volumeType": "gp3"},
                "lifecycleConfiguration": {"idleInstanceTimeout": 600, "maxLifetime": 86400},
            }
        },
    )

    ⚠️ Capacidade de GPU: se houver InsufficientInstanceCapacity em múltiplas Zonas de Disponibilidade (AZs) ao tentar alocar uma instância GPU, é possível alternar para outro tipo, como g5.xlarge, atualizando allowedInstanceTypes.

    Passo 3: Implantando os runtimes de agentes

    Cada agente recebe seu próprio runtime. Quando dois runtimes compartilham um capacity provider e são invocados com o mesmo runtimeSessionId, o AgentCore os coloca na mesma instância EC2, onde compartilham um sistema de arquivos — é assim que o agente de entrega lê o .wav escrito pelo agente de composição.

    composition = control.create_agent_runtime(
        agentRuntimeName="music_production_composition",
        roleArn=execution_arn, # required
        agentRuntimeArtifact={"containerConfiguration": {"containerUri": image_uri}},
        protocolConfiguration={"serverProtocol": "HTTP"},
        capacityProviderConfiguration={"capacityProviderArn": cp_arn},
        filesystemConfigurations=[
            {"capacityProviderVolume": {"volumeName": "tracks", "mountPath": "/mnt/tracks"}},
            {"capacityProviderVolume": {"volumeName": "models", "mountPath": "/mnt/models"}},
        ],
        lifecycleConfiguration={"idleRuntimeSessionTimeout": 600, "maxLifetime": 86400},
        environmentVariables={"AWS_REGION": REGION, "WORKSPACE_DIR": "/mnt/tracks", "MODELS_DIR": "/mnt/models", "MODEL_ID": MODEL_ID},
    )

    O agente de conformidade usa um artefato diferente — um zip em vez de uma imagem de container — demonstrando que tipos de artefatos mistos coexistem no mesmo capacity provider:

    agentRuntimeArtifact={"codeConfiguration": {
        "code": {"s3": {"bucket": bucket, "prefix": key}},
        "runtime": "PYTHON_3_12",
        "entryPoint": ["compliance_agent.py"],
    }},

    Passo 4: Orquestrando o pipeline com sessão compartilhada

    A orquestração é feita passando o mesmo runtimeSessionId para cada invocação. A primeira chamada é a mais lenta, pois provisiona a instância. Todas as chamadas subsequentes são roteadas para a instância já em execução:

    session_id = f"music-production-{uuid.uuid4()}" # 33-100 characters
    
    invoke_agent(COMPOSITION_ARN, {"mode": "prepare"})
    invoke_agent(COMPOSITION_ARN, {"mode": "catalogue", "track_id": track_id, "duration_s": 20})
    invoke_agent(COMPOSITION_ARN, {"mode": "compose", "track_id": track_id, "duration_s": 30, "prompt": "Create an upbeat electronic track with heavy bass and synth melodies."})
    invoke_agent(DELIVERY_ARN, {"track_id": track_id, "platform": "spotify", "prompt": "Prepare this for streaming delivery."})
    result = invoke_agent(COMPLIANCE_ARN, {"track_id": track_id, "prompt": "Screen this delivery for release."})
    print(result["outcome"]) # cleared | review_required | not_cleared

    Em execução real em uma instância g6.xlarge na região us-east-2, o resultado observado foi:

    1. prepare model stack (GPU instance + torch + weights) 239s
       host  : ip-172-31-11-83.us-east-2.compute.internal
       stack : ready=True in 125s
    2. render back-catalogue  66s
    3. compose (renders audio on the GPU)  25s
       rendered : NVIDIA L4 in 8.98s (peak VRAM 7.63 GiB)
       audio 20.062s 48000Hz 2ch -7.5 LUFS peak 0.42 dBTP
    4. delivery (real DSP, verified by measurement)  41s
       read  : composition.wav <- written by another agent
       before  -7.5 LUFS peak 0.42 dBTP
       after  -14.0 LUFS peak -3.2 dBTP
       targets : loudness met, true peak held
    5. compliance screen  28s
       verdict : REVIEW REQUIRED
       screen  : 2 reference(s), closest catalogue_00.wav distance 0.0665 (review)
    -- collocation --
    All 5 steps were served by one instance, as intended.

    Ao chamar StopRuntimeSession, a instância entra em modo ocioso automaticamente. Não há cobranças de computação enquanto estiver ociosa. Ao invocar a sessão novamente, o AgentCore a retoma — desde que o roteamento aconteça na mesma Zona de Disponibilidade, pois volumes EBS são bloqueados por AZ.

    Passo 5: Atualizando agentes de forma independente

    Um dos pontos fortes dessa arquitetura é a implantação independente. Quando a equipe de Audio AI precisa enviar uma nova versão do agente de composição, ela atualiza apenas seu próprio runtime — os agentes de entrega e conformidade continuam rodando sem interrupção, sem necessidade de coordenação:

    control.update_agent_runtime(
        agentRuntimeId=composition_id, # all three are required
        roleArn=execution_arn,
        agentRuntimeArtifact={"containerConfiguration": {"containerUri": new_uri}},
        capacityProviderConfiguration={"capacityProviderArn": cp_arn},
    )

    Limpeza dos recursos

    O caminho mais direto para interromper cobranças de EC2 e EBS é excluir a sessão primeiro. Excluir uma sessão desprovisiona os recursos EC2: instância, interface de rede e volume EBS. Excluir o capacity provider também encerra e exclui suas sessões associadas, mas é necessário primeiro desassociar todos os runtimes — e essa desassociação é assíncrona:

    data = boto3.client("bedrock-agentcore", region_name=REGION)
    data.delete_capacity_provider_session(capacityProviderId=cp_id, sessionId=session_id)
    for rid in runtime_ids:
        control.delete_agent_runtime(agentRuntimeId=rid)
    control.delete_capacity_provider(capacityProviderId=cp_id)

    Em seguida, é necessário excluir os repositórios ECR, artefatos no S3, funções IAM e grupos de logs no Amazon CloudWatch.

    Padrões que vão além da música

    A música foi apenas um veículo conveniente para demonstrar padrões de arquitetura que se aplicam a qualquer workload que exija processamento pesado, persistência e colaboração entre agentes. Os mesmos princípios se encaixam em renderização 3D, simulação, inferência de modelos, processamento de mídia — ou qualquer pipeline onde um agente produz um artefato grande, um segundo agente o transforma, e um terceiro verifica o resultado antes de publicar.

    Para saber mais, consulte a documentação do Amazon Bedrock AgentCore. O código completo está disponível no repositório de exemplos do AgentCore. Para padrões avançados de orquestração como Graph, Swarm ou Workflow, consulte a documentação do Strands Agents.

    Fonte

    Build a multi-agent music production pipeline on Amazon Bedrock AgentCore Runtime Instances (https://aws.amazon.com/blogs/machine-learning/build-a-multi-agent-music-production-pipeline-on-amazon-bedrock-agentcore-runtime-instances/)

  • GPT-6.1 Sol chega ao Amazon Bedrock com raciocínio avançado para agentes de IA

    GPT-6.1 Sol agora disponível no Amazon Bedrock

    A AWS anunciou a disponibilidade geral do GPT-6.1 Sol no Amazon Bedrock. O modelo, desenvolvido pela OpenAI, chega como uma grande evolução em relação ao GPT-6 Sol, trazendo capacidades de raciocínio mais robustas para tarefas cotidianas — especialmente aquelas que envolvem agentes de IA, programação e uso profissional intensivo.

    Segundo a OpenAI, o GPT-6.1 Sol aproxima o desempenho do dia a dia do nível de inteligência do GPT-6 Astra, o modelo de topo da linha, mas a um custo muito mais acessível por tarefa. Isso representa uma mudança relevante para equipes que precisam de alta qualidade de raciocínio sem pagar o preço de um modelo de fronteira completo.

    Por que o raciocínio importa na economia de agentes de IA

    Para entender o valor do GPT-6.1 Sol, vale entender como os custos de um agente de IA se formam na prática. Quando um agente precisa completar uma tarefa, ele pode precisar coletar informações, acionar ferramentas, testar abordagens diferentes, se recuperar de erros e verificar o resultado final. Cada decisão tomada ao longo do caminho influencia o que vem a seguir.

    Um passo errado pode multiplicar interações com o modelo, chamadas a ferramentas, latência e até intervenções humanas antes de chegar a um resultado útil. O custo total de uma tarefa, portanto, não depende apenas do preço por token — depende também de quantas interações foram necessárias para concluir o trabalho com sucesso. É exatamente aí que a qualidade do raciocínio faz diferença: quanto melhor o modelo raciocina, menos passos ele precisa para chegar à resposta certa.

    Raciocínio mais forte para trabalho com agentes

    Engenharia de software com mais eficiência

    A engenharia de software é um dos casos que melhor ilustra como a qualidade do raciocínio afeta um fluxo de trabalho completo. Um agente pode precisar entender um repositório desconhecido, rastrear dependências, identificar onde fazer uma alteração e validar a implementação — tudo isso em sequência, com pouca margem para erro.

    De acordo com a OpenAI, o GPT-6.1 Sol iguala o desempenho do GPT-6 Astra no benchmark DeepSWE v1.1, a aproximadamente um quinto do custo por tarefa. Além disso, supera o melhor resultado anterior do GPT-6 Sol em 6,4 pontos percentuais, utilizando um esforço de raciocínio menor do que o necessário para atingir aquele resultado anterior.

    Para colocar esse raciocínio em prática no ciclo completo de desenvolvimento, o Codex pode ser configurado para usar o GPT-6.1 Sol no Amazon Bedrock. O Codex trabalha com repositórios, arquivos locais, terminais e ferramentas de desenvolvimento para escrever funcionalidades, corrigir bugs e executar testes. O acesso ao Codex é possível pelo aplicativo desktop, pela Interface de Linha de Comando (CLI) e por Ambientes de Desenvolvimento Integrado (IDEs) compatíveis.

    Para desenvolvimento na AWS especificamente, o Agent Toolkit para AWS conecta o Codex à documentação, APIs e serviços da AWS por meio de um único comando no terminal.

    Transformando informação em ação com documentos e ferramentas

    As mesmas capacidades de raciocínio se aplicam quando agentes precisam interpretar documentos complexos, selecionar as ferramentas certas e se adaptar a condições que mudam ao longo do processo. Segundo a OpenAI, o GPT-6.1 Sol se aproxima do GPT-6 Astra em análise de documentos complexos e melhora em relação ao GPT-6 Sol na execução de fluxos de trabalho com múltiplas etapas em ferramentas de negócios.

    Essas capacidades podem ser aplicadas tanto por meio de experiências prontas quanto por aplicações construídas pelos próprios times. No aplicativo desktop, o ChatGPT Work consegue reunir informações de arquivos e aplicações diversas e transformá-las em entregas concretas. Usando as APIs do Amazon Bedrock, também é possível construir ferramentas internas que sintetizam documentos, agentes que coordenam trabalho entre sistemas e aplicações voltadas ao cliente que avaliam múltiplas entradas.

    Reconhecer limitações e respeitar restrições

    Trabalhar de forma eficaz com ferramentas também exige que o agente saiba reconhecer quando uma ferramenta falhou, quando uma ação está restrita ou quando uma informação está faltando. Comunicar essas limitações permite que a aplicação ou o usuário intervenha antes que o agente continue com informações incompletas ou tome uma ação indesejada.

    Segundo a OpenAI, o GPT-6.1 Sol apresenta melhoras em relação ao GPT-6 Sol em avaliações desafiadoras de transparência, respeito à intenção do usuário e cumprimento de restrições explícitas. Ao construir com as APIs do Amazon Bedrock, é possível definir quais ferramentas estarão disponíveis para o modelo e determinar como a aplicação deve reagir quando uma ação precisar de aprovação ou não puder ser concluída. Esses controles no nível da aplicação complementam as melhorias do modelo, ajudando a manter pessoas envolvidas nos momentos em que um fluxo de trabalho chega a uma decisão crítica.

    Infraestrutura e segurança no Amazon Bedrock

    O Amazon Bedrock fornece a infraestrutura e os controles necessários para rodar o GPT-6.1 Sol em produção. O acesso ao modelo pode ser governado por políticas do Gerenciamento de Identidade e Acesso (IAM) da AWS, e as invocações podem ser auditadas pelo AWS CloudTrail.

    Para manter o tráfego dentro dos limites da rede, é possível usar endpoints de Nuvem Privada Virtual (VPC) com tecnologia AWS PrivateLink. A inferência é executada em infraestrutura com isolamento de hardware e acesso zero por operadores — nem mesmo os operadores da AWS têm acesso aos prompts e respostas durante a inferência.

    Os dados de inferência não são utilizados para treinamento do modelo, e o uso do GPT-6.1 Sol não exige que o cliente opte por compartilhar dados com a OpenAI. Para detecção automatizada de uso indevido, o tráfego sinalizado por classificadores é retido pela AWS por até 30 dias e processado de forma programática. É possível solicitar retenção zero de dados por meio da equipe de conta AWS. Consulte a documentação de retenção de dados para mais detalhes.

    Como começar a usar o GPT-6.1 Sol

    O GPT-6.1 Sol está disponível diretamente pelo console do Amazon Bedrock ou de forma programática pelas APIs compatíveis do Amazon Bedrock. Para informações sobre as Regiões AWS compatíveis, endpoints, APIs, funcionalidades, perfis de inferência e preços, consulte a documentação do Amazon Bedrock.

    Para equipes interessadas em entender como o Amazon Bedrock pode apoiar seus projetos, a AWS disponibiliza um canal de contato para iniciar a conversa.

    Fonte

    Bring near-Astra intelligence to everyday work with GPT-6.1 Sol on Amazon Bedrock (https://aws.amazon.com/blogs/machine-learning/bring-near-astra-intelligence-to-everyday-work-with-gpt-6-1-sol-on-amazon-bedrock/)

  • Fundamentos de Engenharia de Prompts para o Amazon Quick

    Por que a forma como você escreve um prompt muda tudo

    A AWS publicou um guia detalhado sobre engenharia de prompts voltado ao Amazon Quick, plataforma com recursos de Inteligência Artificial (IA) para automação, análise conversacional e agentes personalizados. O foco do material é mostrar como a estrutura das suas solicitações em linguagem natural determina diretamente a qualidade das respostas que a plataforma entrega.

    Este é o Parte 1 de uma série de dois artigos. Aqui, o foco está nos princípios universais e frameworks reutilizáveis que funcionam independentemente do componente do Quick que você estiver usando. A Parte 2 aprofunda técnicas específicas para Research, Flows, Sight, Chat Agents e Action Integrations.

    O exemplo dado no guia é bastante ilustrativo: quando um time pede ao Quick para “analisar dados de clientes”, o resultado tende a ser genérico. Mas quando a solicitação especifica “identificar os cinco principais clientes enterprise do setor de saúde com engajamento em queda no último trimestre, ranqueados por impacto em receita, com padrões de uso que se correlacionam com risco de churn”, a resposta se torna inteligência acionável. A diferença não está na capacidade da IA — está em como você se comunica com ela.

    Princípios fundamentais de prompting

    Antes de explorar frameworks específicos, o guia apresenta três princípios base que se aplicam a qualquer componente do Amazon Quick.

    Clareza por meio da especificidade

    Solicitações vagas produzem resultados vagos. O guia compara dois exemplos:

    • Genérico: “Mostre informações de vendas”
    • Específico: “Exiba as tendências mensais de receita da nossa divisão de software enterprise nos trimestres Q3 e Q4 de 2025, destacando as três linhas de produto com maior crescimento e identificando correlações com o lançamento da campanha de marketing do Q3”

    A versão específica define a métrica, o período, o escopo, o tipo de análise e o contexto de decisão. Cada detalhe adicional elimina uma suposição que a IA precisaria fazer por conta própria.

    Contexto direciona relevância

    Modelos de IA tomam decisões melhores quando entendem o contexto de negócio por trás da solicitação. Informar quem vai usar o resultado e que decisão ele precisa embasar faz com que a IA calibre a profundidade da análise, o formato de apresentação e a especificidade das recomendações.

    Exemplo do guia — sem contexto: “Crie uma análise de retenção de clientes”. Com contexto: “Vou apresentar para o time executivo na próxima semana sobre estratégias de retenção. Analise os dados de churn do segmento enterprise dos últimos seis meses, focando nos fatores que diferenciaram clientes que renovaram dos que não renovaram. O público precisa de recomendações acionáveis para aprovação imediata, com projeção de impacto na receita recorrente anual.”

    Exemplos ensinam melhor do que descrições

    Quando você precisa de um formato específico de saída, mostrar um modelo concreto funciona melhor do que descrever o que quer. Essa abordagem de few-shot learning (aprendizado por poucos exemplos) ensina à IA os seus requisitos exatos por demonstração, reduzindo ambiguidade e melhorando a precisão logo na primeira tentativa.

    Frameworks estruturados para prompts complexos

    Para casos de uso corporativos que exigem interações mais sofisticadas com a IA, o guia apresenta frameworks estruturados que garantem consistência e completude.

    Framework CRISPE: estrutura universal de prompts

    O CRISPE oferece um template abrangente para solicitações complexas. Cada elemento endereça uma dimensão diferente do prompt:

    • C — Contexto e restrições (Context and constraints): Define o ambiente de negócio e os limites da análise. Exemplo: “Estou analisando a eficiência do suporte ao cliente em uma plataforma SaaS com mais de 5.000 clientes enterprise. A análise deve excluir dados pessoais e focar no último ano fiscal.”
    • R — Papel e responsabilidade (Role and responsibility): Define a expertise e os objetivos da IA. Exemplo: “Atue como analista de sucesso do cliente especializado em otimização de operações de suporte. Seu objetivo é identificar gargalos no processo de resolução de tickets.”
    • I — Intenção e entradas (Intent and inputs): Declara o objetivo e fornece as fontes de dados necessárias.
    • S — Passos e escopo (Steps and scope): Divide a análise em fases claras, como: analisar tempos de resolução por categoria, identificar os três principais gargalos, comparar com benchmarks do setor, recomendar melhorias com cronogramas e projetar o impacto de cada recomendação.
    • P — Perspectiva e apresentação (Perspective and presentation): Define os pontos de vista a considerar e o formato de saída desejado.
    • E — Critérios de avaliação (Evaluation criteria): Estabelece as métricas de sucesso, como: implementável em um trimestre, sem necessidade de contratações significativas, com Retorno sobre Investimento (ROI) claro.

    Outros frameworks introduzidos na série

    O guia também apresenta frameworks especializados que serão detalhados na Parte 2 da série:

    • RADAR — Para recuperação de conhecimento em bases documentais: estrutura prompts em torno de estratégia de recuperação, abordagem de análise, documentos-alvo, formação da resposta e transparência de raciocínio.
    • ARCHITECT — Para construção de agentes personalizados: mapeia a configuração do agente em identidade, parâmetros de resposta, contexto e conhecimento, tratamento de casos especiais, padrões de interação, uso de ferramentas, diretrizes éticas, melhoria contínua e validação.
    • QUEST — Para consultas complexas a agentes: estrutura perguntas em torno de formulação da questão, contexto do usuário, requisitos explícitos, definição de escopo e saída-alvo.

    Técnicas avançadas para uso corporativo

    O guia apresenta técnicas para cenários onde prompts simples retornam resultados incompletos ou inconsistentes.

    Recuperação guiada por metadados

    Em ambientes corporativos com documentação extensa, referenciar documentos pelo nome, esclarecer siglas e terminologia interna e especificar quais bases de conhecimento pesquisar melhora significativamente a precisão da recuperação. Exemplo do guia: “No documento ‘Employee Handbook 2025.pdf’ localizado no espaço ‘HR Policies’, encontre a seção sobre trabalho remoto — especificamente requisitos de elegibilidade, política de reembolso de equipamentos e processo de aprovação.”

    Análise multiperspectiva

    Para decisões de negócio complexas, o guia recomenda solicitar análise a partir de múltiplos pontos de vista — por exemplo, financeiro, operacional e estratégico — com perguntas específicas para cada perspectiva e uma recomendação integrada ao final.

    Planejamento de cenários

    Para antecipar múltiplos futuros possíveis, a recomendação é estruturar o prompt com três ou quatro cenários nomeados, cada um contendo: premissas que o sustentam, implicações para o negócio, ações necessárias de preparação e indicadores de alerta antecipado. O objetivo é forçar a IA a pensar consequências de forma sistemática, não apenas oferecer previsões superficiais.

    Aplicação prática: automação de questionários de RFI

    O guia ilustra como esses princípios se combinam em um caso real: a automação do processamento de questionários de Solicitação de Informação (RFI). A tarefa tradicionalmente exige horas de trabalho manual — analisar planilhas Excel com múltiplas abas, transformar sub-perguntas em perguntas independentes e preparar respostas estruturadas.

    A solução descrita é um fluxo no Amazon Quick com um prompt cuidadosamente elaborado que inclui:

    • Regras de identificação para distinguir perguntas principais de sub-perguntas
    • Lógica de transformação para combinar contexto da pergunta pai com o texto da sub-pergunta
    • Restrições explícitas para preservar a formatação original e tratar sobreposições
    • Exemplos concretos do formato de saída esperado

    O resultado, segundo o guia da AWS, é o processamento automático de questionários em minutos — em vez de horas — com transformação inteligente e tratamento de erros via depuração conversacional.

    Como medir e melhorar a eficácia dos seus prompts

    O guia recomenda uma abordagem sistemática de avaliação contínua, considerando cinco dimensões:

    • Precisão: O resultado corresponde aos requisitos?
    • Consistência: Prompts similares produzem resultados similares?
    • Completude: Todas as informações necessárias estão incluídas?
    • Eficiência: Quantas iterações foram necessárias?
    • Usabilidade: Outros membros do time conseguem reutilizar e adaptar o prompt sem precisar reexplicar o contexto?

    Para melhorar continuamente, as recomendações incluem: documentar padrões bem-sucedidos em uma biblioteca de prompts, analisar falhas para identificar o que estava faltando, criar ciclos de feedback com os usuários, monitorar métricas como tempo economizado e número de iterações, compartilhar boas práticas entre times e revisar periodicamente prompts críticos para garantir que continuam eficazes.

    Próximos passos

    Para quem quer colocar esses padrões em prática, o guia da AWS sugere:

    Fonte

    Prompt engineering fundamentals for Amazon Quick (https://aws.amazon.com/blogs/machine-learning/prompt-engineering-fundamentals-for-amazon-quick/)

  • Engenharia de Prompts no Amazon Quick: Padrões e Armadilhas por Componente

    Cada componente do Amazon Quick tem sua própria lógica

    Na Parte 1 desta série, a AWS cobriu os fundamentos da engenharia de prompts no Amazon Quick: especificidade, definição de contexto, exemplos de poucos disparos (few-shot) e o framework CRISPE para requisições complexas. Esses princípios são universais. Agora, no segundo post, a AWS vai além e mostra como cada componente do Quick interpreta prompts de maneira diferente — e quais padrões entregam os melhores resultados em cada um.

    Seja usando o Quick Research para análises de mercado, o Quick Flows para automação, o Quick Sight para visualização de dados, agentes de chat para acesso ao conhecimento interno ou integrações de ações para fluxos entre sistemas, as técnicas a seguir ajudam a sair de resultados genéricos para entregas precisas e acionáveis.

    Quick Research: defina o objetivo, não a busca

    O Quick Research funciona assim: você fornece um objetivo, o agente o divide em subtópicos, pesquisa em fontes corporativas e externas e entrega um relatório estruturado com citações. Um objetivo vago produz um relatório superficial. Um objetivo preciso produz algo que você pode usar de verdade.

    Defina a meta, o público e o foco

    A documentação da AWS é direta: seja específico sobre o que você quer alcançar, para quem e por quê. Um bom objetivo nomeia o tema, delimita o período, identifica o público e indica quais saídas importam mais. Exemplo:

    “Analise a adoção de IA generativa em sistemas hospitalares dos EUA nos últimos 12 meses. Concentre-se em duas áreas: ferramentas de suporte à decisão clínica e automação administrativa (agendamento, faturamento, gestão de prontuários). Escreva os resultados para um público executivo de TI em saúde que está decidindo onde investir a seguir.”

    Antes de escrever seu objetivo, vale se perguntar: qual decisão essa pesquisa vai embasar? Quem vai ler? O que faria esse leitor dizer “era exatamente isso que eu precisava”?

    Decomponha tópicos complexos em sub-perguntas

    O Quick Research já divide objetivos em subtópicos automaticamente, mas fazer parte desse trabalho você mesmo melhora os resultados. Para pesquisas multifacetadas, liste as perguntas específicas que você quer respondidas. Isso dá ao agente uma direção mais clara e reduz a chance de ele seguir tangentes.

    Escolha bem as fontes e revise o plano

    O Quick Research acessa dados corporativos via Quick Index, mais de 200 fontes de notícias confiáveis e bases de dados premium como S&P Global, FactSet, IDC, dados de patentes dos EUA e PubMed. Após inserir o objetivo, selecione quais fontes incluir e revise o plano de pesquisa gerado. Uma análise competitiva não precisa do PubMed. Uma revisão de literatura clínica não precisa de artigos de notícias. Restringir as fontes foca o agente e reduz o ruído.

    Quick Flows: a diferença está nos detalhes do prompt

    A diferença entre um fluxo que economiza cinco minutos e um que economiza cinco horas muitas vezes está em como o prompt foi escrito. O Quick Flows transforma descrições em linguagem natural em fluxos de trabalho automatizados, mas a especificidade, a estrutura e o contexto que você fornece moldam diretamente o que você recebe.

    Seja específico sobre o quê, quando e onde

    O erro mais comum é descrever o que você quer sem especificar como, quando ou para quem. Compare:

    Antes: “Crie um relatório a partir dos nossos dados de vendas.”

    Depois: “Toda segunda-feira às 8h, busque os dados de vendas da semana anterior no CRM, calcule a receita total e os 10 produtos mais vendidos por unidades, gere um resumo em PDF de uma página e envie por e-mail para a lista de distribuição dos gerentes de vendas.”

    O segundo prompt fornece ao Quick Flows âncoras concretas: um cronograma, uma fonte de dados, cálculos específicos, um formato de saída e um destino de entrega. Cada detalhe se mapeia para uma etapa no fluxo resultante. Ao definir gatilhos, seja explícito tanto sobre o horário quanto sobre as condições. “Toda segunda-feira às 8h” é claro. “Quando novos dados chegarem” é vago.

    Estruture lógicas complexas como etapas numeradas

    Para fluxos com mais de duas ou três operações, escreva o prompt como uma sequência numerada. O Quick Flows suporta ramificações condicionais, laços de repetição e entradas do usuário, e etapas numeradas se mapeiam naturalmente para sua estrutura interna. Exemplo:

    “Construa um fluxo que faça o seguinte: 1. Aceite um relatório de despesas enviado (PDF ou imagem) como entrada. 2. Extraia o valor total, nome do fornecedor, data e categoria da despesa do documento. 3. Se o total ultrapassar R$ 500, encaminhe para o canal Slack da equipe financeira para aprovação. 4. Após a aprovação, registre a despesa na planilha do Google Sheets com todos os campos extraídos mais o timestamp de aprovação.”

    Essa estrutura facilita a depuração: se a etapa 3 não estiver funcionando, você sabe exatamente onde procurar.

    Refine por conversa, não por reescrita

    Com o runtime agêntico do Quick Flows, é possível refinar fluxos por conversa após a construção inicial. Em vez de reescrever o prompt inteiro, use instruções de acompanhamento direcionadas. O Quick Flows retém o contexto do prompt original, então os ajustes constroem sobre o que já existe.

    Quick Sight: estruture a consulta como uma pergunta de negócio

    Com o Amazon Quick Sight, você explora dados por meio de consultas conversacionais. A chave é estruturar as requisições de análise especificando a pergunta de negócio, as dimensões relevantes, os cálculos necessários e as preferências de visualização.

    Elementos de uma boa consulta analítica

    Toda consulta eficaz no Quick Sight inclui: a pergunta de negócio (que decisão ou insight você busca), as métricas (medidas quantitativas a analisar), as dimensões (como agrupar, filtrar ou segmentar os dados), o período de tempo, o tipo de visualização e análises adicionais (linhas de tendência, limites, marcadores estatísticos ou períodos de comparação). Omitir qualquer um desses elementos força o Quick Sight a adivinhar — o que geralmente produz uma visualização tecnicamente correta, mas inútil.

    Padrões de análise por tipo

    • Série temporal: “Plote o volume de tickets de suporte ao cliente por nível de prioridade nos últimos 12 meses como um gráfico de linhas empilhadas. Adicione uma linha de tendência para o volume total.”
    • Comparativo: “Compare o tamanho médio de negócios por setor e representante de vendas no Q4 2025. Mostre como gráfico de barras agrupadas ordenado por tamanho de negócio decrescente.”
    • Relação: “Construa um gráfico de dispersão do valor vitalício do cliente versus frequência de uso do produto. Codifique os pontos por nível de assinatura e adicione uma linha de regressão.”
    • Distribuição: “Gere um histograma dos tempos de conclusão de projetos nos últimos seis meses. Use intervalos de duas semanas e sobreponha o tempo-alvo como linha de referência vertical.”
    • Geográfico: “Mostre um mapa de calor da distribuição de clientes na América do Norte usando intensidade de cor para representar concentração de receita.”

    Refinamento e campos calculados

    Ao trabalhar com Tópicos (coleções de dados otimizadas para consultas conversacionais), enquadre as perguntas em torno de resultados de negócio, não de mecânicas de dados. Após gerar uma visualização inicial, refine por acompanhamentos conversacionais. Use linguagem natural para fórmulas:

    “Adicione um campo calculado chamado ‘Pontuação de Saúde do Cliente’ que combina probabilidade de renovação (peso 40%), tendência de uso do produto (peso 35%) e frequência de tickets de suporte (peso 25%, inverso — menos tickets significa mais saudável). Mostre como um índice de 0 a 100.”

    Agentes de chat do Quick: identidade, conhecimento e limites

    Os agentes de chat do Amazon Quick trazem IA conversacional para dentro da organização. Você controla a identidade do agente, conecta bases de conhecimento da empresa, define limites de comportamento e publica para a equipe. A qualidade da experiência depende de quão cuidadosamente você configura o agente.

    Defina uma identidade clara

    O campo de identidade no Modo Construtor define a base de cada resposta. Uma identidade forte nomeia o papel, define a expertise e traça limites claros. Exemplo:

    “Você é um Consultor de Otimização de Custos em Nuvem para nossa equipe de FinOps. Sua expertise cobre gestão de custos AWS, planejamento de instâncias reservadas, análise de planos de economia e dimensionamento correto de recursos. Responda apenas a perguntas sobre otimização de custos em nuvem. Se uma pergunta estiver fora desse escopo, diga isso e sugira a equipe certa para contatar.”

    Sem esses limites, agentes tendem a responder perguntas fora de sua expertise com respostas confiantes, mas não confiáveis. Revise periodicamente a identidade do agente conforme as necessidades da equipe evoluem.

    Conecte as fontes certas e defina instruções de fallback

    Vincular Quick Spaces ao agente determina de quais informações ele pode se valer. Seja deliberado: um agente conectado a todos os Quick Spaces da organização vai trazer conteúdo irrelevante. Combine as fontes de conhecimento com o papel definido do agente.

    Igualmente importante é instruir o agente sobre o que fazer quando não tiver uma resposta. Sem instruções explícitas, agentes preenchem lacunas com respostas plausíveis, mas fabricadas. Exemplo de instrução:

    “Quando você não tiver informações suficientes para responder com confiança, diga: ‘Não tenho isso na minha base de conhecimento atual. Entre em contato com [equipe relevante] ou consulte [recurso específico] para orientações atualizadas.’ Nunca adivinhe ou fabrique uma resposta.”

    Crie prompts sugeridos que ensinam bons hábitos

    Os prompts sugeridos são a primeira coisa que os usuários veem. Eles definem expectativas e modelam a especificidade com que o agente performa melhor. Sugestões vagas como “Pergunte sobre custos” ensinam usuários a escrever prompts vagos. Sugestões específicas ensinam hábitos melhores:

    • “Quais famílias de instâncias EC2 na nossa conta de produção têm a menor utilização nos últimos 30 dias, e quanto economizaríamos ao dimensioná-las corretamente?”
    • “Compare o impacto de custo de migrar nosso uso de RDS sob demanda para um plano reservado de 1 ano versus um plano de economia de 3 anos.”

    Integrações de ações: parâmetros completos e sequenciamento claro

    Com conectores de ação, o Quick pode interagir com sistemas externos como Jira, Slack, Confluence e Salesforce. Prompts eficazes incluem intenção clara, todos os parâmetros necessários e sequenciamento adequado.

    Especificação de parâmetros

    Forneça todas as informações necessárias de antemão. Parâmetros incompletos forçam o sistema a fazer perguntas de acompanhamento ou fazer suposições. Exemplo para criação de um ticket no Jira:

    “Crie um ticket no Jira com estes detalhes: Projeto: SUPORTE-AO-CLIENTE | Tipo: Bug | Resumo: ‘[Nome do Cliente] — [Breve Descrição]’ | Prioridade: Alta | Responsável: engenheiro de suporte de plantão | Labels: reportado-pelo-cliente, precisa-triagem | Descrição: Inclua os passos de reprodução, comportamento esperado vs. real e o nível de conta do cliente.”

    Sequenciamento de ações

    Para fluxos com múltiplas etapas, estruture com dependências claras. Numere os passos, especifique condições e deixe explícito qual saída de cada etapa alimenta a próxima. Exemplo:

    “Execute estas etapas em ordem: 1. Pesquise no espaço Confluence ‘Documentação do Produto’ páginas existentes sobre [tópico]. 2. Se uma página existir, atualize-a com o novo conteúdo e adicione uma nota de revisão. 3. Se nenhuma página existir, crie uma usando nosso template padrão. 4. Poste um resumo do que mudou (ou foi criado) no canal #product-docs do Slack com um link.”

    Revisão antes de executar operações destrutivas

    Para operações destrutivas ou em massa, estruture os prompts para incluir uma etapa de revisão antes da execução. Peça ao sistema que gere um relatório de resumo primeiro e só aja após sua aprovação explícita. Construa essa etapa de revisão diretamente no prompt, sem depender apenas de salvaguardas do sistema.

    Armadilhas comuns a evitar

    A AWS lista os erros mais frequentes por categoria:

    Gerais: linguagem vaga que permite múltiplas interpretações; sobrecarregar prompts únicos com muitos requisitos; assumir contexto que a IA não tem; não especificar o formato de saída; não testar com casos extremos realistas; não documentar padrões bem-sucedidos para reuso.

    Quick Research: escrever consultas de busca em vez de objetivos de pesquisa; omitir o contexto do público; pular a revisão do plano de pesquisa.

    Quick Flows: sobrecarregar um único prompt com muitas operações; pular definições de entrada do usuário; ignorar condições de erro e tratamento de falhas.

    Quick Sight: usar métricas vagas sem especificar agregação; não informar contexto de tempo; dimensões pouco claras para agrupamento; comparações ambíguas sem uma linha de base.

    Agentes de chat: identidade vaga sem domínios de expertise definidos; vincular espaços com informações desatualizadas; não fornecer instruções de fallback; lançar sem testar no modo Preview.

    Integrações de ações: requisições de ação vagas sem parâmetros necessários; dependências pouco claras entre ações; não planejar para falhas ou problemas de autenticação; pular etapas de revisão em operações destrutivas.

    Colocando em prática: um plano de quatro semanas

    A AWS sugere uma abordagem em fases para aplicar essas técnicas:

    • Semana 1 — Fundação: identifique seus três casos de uso mais comuns no Quick; reescreva prompts existentes usando o framework CRISPE da Parte 1; documente os resultados antes e depois.
    • Semana 2 — Foco no componente: escolha um componente (Quick Research, Quick Flows, Quick Sight ou agentes de chat); aplique os padrões específicos do componente a fluxos reais; crie templates de prompt reutilizáveis.
    • Semana 3 — Técnicas avançadas: implemente recuperação orientada por metadados nas bases de conhecimento; construa um agente personalizado usando o framework ARCHITECT; crie um Quick Flow complexo com lógica condicional.
    • Semana 4 — Escala e compartilhamento: documente seus prompts mais eficazes em uma biblioteca compartilhada; treine membros da equipe nos padrões bem-sucedidos; estabeleça mecanismos de feedback para melhoria contínua.

    Próximos passos

    Para quem quer aprofundar a prática de engenharia de prompts no Amazon Quick, a AWS disponibiliza os seguintes recursos:

    Fonte

    Prompt engineering by Quick component: Patterns and pitfalls (https://aws.amazon.com/blogs/machine-learning/prompt-engineering-by-quick-component-patterns-and-pitfalls/)