BedrockIA Generativa
Nível de dificuldade: Intermediário (3 de 5)
No Bedrock, decidir se o passo precisa de modelo corta mais custo que trocar de modelo
A AWS propõe uma pergunta antes da escolha de modelo no Bedrock: o passo do workflow precisa mesmo de uma chamada de IA generativa, ou uma regra em código resolve mais rápido e mais barato?
Quem constrói agentes ou pipelines de IA generativa sobre o Amazon Bedrock costuma discutir qual modelo usar em cada etapa. O AWS Machine Learning Blog propõe uma pergunta anterior a essa: a etapa precisa de modelo algum?
A resposta muda a conta. Segundo o post, o maior alavancador de custo num sistema de IA generativa não é qual modelo você escolhe, é quantas vezes você chama modelo nenhum.
O padrão que nasce no protótipo e sobrevive em produção
O caminho é sempre parecido: uma chamada ao modelo resolve um passo do protótipo, e vira o padrão para o próximo passo. Validar input, reformatar o corpo de uma requisição, escolher uma rota: tudo acaba passando pelo mesmo endpoint de inferência.
Em volume de protótipo, ninguém percebe o custo de uma chamada a mais. Em volume de produção, o post aponta três efeitos que se acumulam: o gasto cresce junto com o número de requisições, mesmo nos passos de baixo valor; a latência empilha, porque cada chamada de modelo numa cadeia soma centenas de milissegundos; e a saída pode variar, porque a mesma entrada nem sempre retorna a mesma resposta, o que complica teste e auditoria.
Cada lançamento de modelo novo reabre o debate de qual modelo usar, mas a pergunta anterior, se o passo precisa de modelo, raramente é feita. É nela que o post foca, antes mesmo da discussão de right-sizing que o AWS Well-Architected Generative AI Lens já cobre.
As três perguntas antes de qualquer chamada
O fluxograma proposto passa cada passo do workflow por três perguntas, nesta ordem, parando na primeira que servir:
- Uma regra consegue checar o sucesso? Formato, schema, palavra-chave ou faixa numérica contam como regra.
- Um modelo pode escrever a regra uma única vez (uma expressão regular, um JSON Schema), em vez de rodar toda chamada?
- O passo escolhe uma resposta entre opções fixas, como uma rota, uma classe ou sim/não?
Se a resposta às três for não, o passo é aberto de verdade e vai para um modelo certo para o tamanho da tarefa.
O post ilustra com um assistente de suporte ao cliente, mapeando cinco passos:
| Passo | Caminho no fluxograma | Onde roda |
|---|---|---|
| Checar formato de número de pedido | Regra resolve sozinha | Validação de request no Amazon API Gateway, ou AWS Lambda |
| Rotear mensagem por intenção | Regra resolve parte, o resto é residual | AWS Step Functions Choice state com JSONata; residual vai para chamada de decisão restrita |
| Extrair número de rastreio de e-mail da transportadora | Modelo escreve a regra uma vez (regex) | Código, como padrão commitado em Lambda |
| Escolher uma de quatro filas de suporte | Resposta vem de lista fixa | Chamada de decisão restrita; casos incertos escalam para o modelo |
| Redigir resposta ao cliente | Tarefa aberta | Modelo certo no Amazon Bedrock, o menor que atenda o requisito |
O que se perde ao mandar regra para o modelo
O post resume o trade-off numa tabela que vale reproduzir, porque é exatamente o que muda a fatura:
| Propriedade | Código determinístico | Chamada de modelo |
|---|---|---|
| Custo por invocação | Ordens de grandeza menor | Por token, relevante em escala |
| Latência | Milissegundos de um dígito ou menos | Centenas de milissegundos |
| Correção numa regra bem especificada | Exata | Alta, mas com taxa de erro não nula |
| Auditabilidade | A regra fica no controle de versão | Mais difícil de explicar a um auditor |
| Comportamento ao longo do tempo | Estável até você mudar | Muda quando troca de versão do modelo, ou quando uma versão é descontinuada |
O ponto prático: temperatura zero reduz variação, mas não garante saída idêntica. Guardrails e model evaluation no Bedrock ajudam a medir e conter esse risco, mas não eliminam o problema que uma regra simplesmente não tem.
Decidir não é gerar: a chamada de decisão restrita
Entre a regra e a geração aberta fica a maior parte dos passos de roteamento e classificação. Eles não precisam de texto gerado, precisam de uma resposta entre opções que você já definiu, como as filas de suporte do exemplo.
O post lista quatro formas de construir isso na AWS:
- Modelo pequeno no Bedrock com structured output, limitando a resposta a um enum de opções mais
unsure, que dispara escalonamento. É julgamento do modelo, não um score calibrado, então vale checar contra dado rotulado antes de usar para decidir escalonamento. - Similaridade de embedding, usando um modelo de embeddings do Bedrock e o exemplo rotulado mais próximo, com o limiar do score ajustado em dado rotulado.
- Strands Decider, projeto open source experimental sob licença Apache 2.0, que escolhe entre opções ou pontua contra uma rubrica e devolve confiança calibrada. O README do projeto reporta que respostas com confiança de 0,9 ou mais acertam cerca de 95% em tarefas curtas de classificação, mas como é experimental, o próprio post recomenda validar com dado próprio antes de produção. Hospeda-se, por exemplo, num endpoint do Amazon SageMaker AI.
- Classificador treinado no Amazon SageMaker AI, que devolve probabilidades por classe com baixa latência e custo, uma vez que haja dado rotulado de treino.
O schema abaixo, do próprio post, limita a resposta a quatro filas mais unsure. O Bedrock exige que todo objeto do schema defina additionalProperties como false:
{
"type": "object",
"properties": {
"queue": {
"type": "string",
"enum": ["billing", "technical", "account", "other", "unsure"]
}
},
"required": ["queue"],
"additionalProperties": false
}O atalho determinístico antes de qualquer chamada
O post chama de fast path rodar a checagem determinística primeiro e mandar ao modelo só o que a regra não resolve. No roteamento de intenção, muita mensagem carrega um sinal inequívoco, como "estorno" ou "resetar minha senha", que um match de palavra-chave resolve em milissegundos de um dígito.
Se regras resolvem 95% das requisições, só 1 em 20 chega ao modelo, antes de qualquer economia vinda da escolha do modelo em si (a própria AWS marca essa conta como aritmética ilustrativa, não benchmark). O exemplo de Step Functions Choice state com JSONata do post mostra isso:
"KeywordFastPath": {
"Type": "Choice",
"QueryLanguage": "JSONata",
"Choices": [
{
"Condition": "{% $contains($states.input.message, /refund/i) %}",
"Next": "RefundFlow"
},
{
"Condition": "{% $contains($states.input.message, /reset (my )?password/i) %}",
"Next": "PasswordResetFlow"
}
],
"Default": "ConstrainedDecisionCall"
}Um detalhe que o post destaca e que vale levar a sério: deixar um modelo redigir a regex uma vez é diferente de rodar o modelo toda chamada, mas a regex ainda precisa de revisão e teste contra casos bons e ruins antes de ir para produção. Evite quantificadores aninhados como (a+)+, que podem travar o matching em certos inputs (ReDoS).
Quando o passo é mesmo aberto, dimensione o modelo certo
Para o que sobra de verdadeiramente aberto, como redigir uma resposta ou resumir um documento, o post recomenda escolher o modelo mais barato e rápido que atenda um piso de qualidade, não o modelo mais novo. Isso exige definir antes da comparação: piso de qualidade medido num conjunto de avaliação próprio (golden evaluation set), teto de custo por requisição ou por resultado bem-sucedido, alvo de latência em p95 ou p99, e eventuais restrições de conformidade, como residência de dado.
O Bedrock Intelligent Prompt Routing roteia cada requisição para um modelo adequado dentro de uma família suportada, e o Bedrock Model Distillation transfere conhecimento de um modelo maior para um menor e mais barato, ajustado à sua tarefa.
Tratar a escolha de modelo como configuração testada, não decisão definitiva
O post sugere ir além de testar contra ground truth uma vez: manter um conjunto de avaliação por tarefa rodando em integração contínua; tratar queda abaixo do piso de qualidade como regressão, mesmo com modelo mais barato; colocar a escolha de modelo atrás de uma flag de configuração para reverter a troca; e usar o oráculo certo, checando regra contra ground truth e reservando avaliação por modelo-juiz para saída aberta. Para detectar deriva, o post recomenda amostrar requisições já resolvidas por regra e rodá-las em sombra por um modelo, reclassificando o passo quando divergirem.
Por onde começar
O post fecha com quatro passos práticos, nesta ordem:
- Instrumentar cada chamada como código determinístico, decisão restrita ou chamada de modelo, e acompanhar custo por resultado bem-sucedido.
- Mover para código os passos que uma regra resolve, geralmente a maior e mais segura economia.
- Adicionar chamadas de decisão restrita para passos de escolha fixa, com escalonamento para quando o sistema estiver incerto.
- Testar todo modelo novo contra o conjunto de avaliação próprio antes de torná-lo padrão.
A recomendação final do AWS Machine Learning Blog é direta: escolha um workflow de alto volume e meça quanto dele nunca precisou de modelo. É um exercício de instrumentação, não de arquitetura nova, e costuma mostrar que boa parte da fatura do Bedrock está pagando decisão que uma regra em AWS Lambda resolveria antes, mais rápido e de forma auditável.
Fonte: AWS Machine Learning Blog
Serviços neste textoBedrockAgentes
Leve para a sua IA
Decida com o seu assistente, com o contexto deste texto já montado.
1. O que você quer saber
Ver o prompt
Li no AWS Hub: "No Bedrock, decidir se o passo precisa de modelo corta mais custo que trocar de modelo" (https://awshub.com.br/ia/no-bedrock-decidir-se-o-passo-precisa-de-modelo-corta-mais-custo-que-trocar-de-m). Resumo: A AWS propõe uma pergunta antes da escolha de modelo no Bedrock: o passo do workflow precisa mesmo de uma chamada de IA generativa, ou uma regra em código resolve mais rápido e mais barato? Fonte oficial: https://aws.amazon.com/blogs/machine-learning/cut-generative-ai-costs-code-for-rules-models-for-judgment/ Serviços: Bedrock, Agentes Minha stack: [descreva em uma linha: serviços, linguagem, volume, região] Isso muda alguma coisa na minha arquitetura? O que eu faria diferente a partir de amanhã?