No mês passado, quando o financeiro me mandou a fatura, achei que ela tinha se enganado. As chamadas cresceram 40% em relação ao mês anterior, mas a fatura saltou de pouco mais de seis dígitos para quase o triplo. Pela lógica linear, no máximo pagaríamos quarenta por cento a mais. De onde veio o resto?
Baixei os logs de chamadas dos últimos trinta dias e os cortei por modelo, por endpoint e por número de tentativas. O problema não estava no "volume", estava na "estrutura". Quatro pontos ocultos de sangramento, cada um mais dissimulado que o outro.
Começando pelo mais chamativo: o modelo de ponta fazendo trabalho braçal. Temos um módulo de reconhecimento de intenção que, na verdade, se contentaria com um modelo leve. No início, para simplificar, o penduramos direto no modelo de ponta mais caro, e ninguém nunca mexeu nisso. Esse tipo de tráfego representa mais de sessenta por cento do total de requisições, mas contribui com um valor de negócio baixíssimo. Reexecutei tudo com camadas de modelos, empurrando classificação, extração e validação de formato para modelos pequenos, deixando para o modelo de ponta apenas as requisições que realmente exigem raciocínio. Esse custo cai para um terço ou metade do original. Não subestime essa ação: ela não exige mudar a lógica de negócio, só o roteamento.
Como fazer a divisão em camadas, concretamente? Dividi por tipo de tarefa em três níveis: o primeiro é classificação e reconhecimento de intenção, com entrada curta, saída curta e lógica simples, que um modelo pequeno aguenta tranquilamente; o segundo é extração de informação e validação de formato, que exige um pouco de compreensão semântica mas não raciocínio em múltiplas etapas, usando um modelo intermediário; o terceiro, só então, é o raciocínio complexo em múltiplas etapas, geração de textos longos e preenchimento de código, que fica com o modelo de ponta. Depois da divisão, comparei: nas tarefas do primeiro nível, a precisão no modelo pequeno caiu menos de dois pontos percentuais, mas o custo por chamada caiu quase noventa por cento. O segundo nível é mais sutil: a diferença de F1 entre o modelo intermediário e o de ponta nas tarefas de extração é inferior a 0,03, mas o custo difere em cinco vezes. Fazendo a conta, fica claro: o dinheiro gasto a mais antes era pura preguiça.
A segunda armadilha é mais traiçoeira. Tempestade de retentativas. O limite de timeout de algum endpoint upstream estava apertado demais; a rede oscilava um pouco e o cliente retentava, a retentativa dava timeout de novo, e retentava outra vez. Nos logs, dá para ver a mesma requisição sendo disparada quatro ou cinco vezes, queimando Tokens a cada vez, enquanto o usuário só vê uma falha. Esse consumo inútil não aparece na fatura de forma evidente, mas pode chegar a cerca de vinte por cento. A ação é simples: transformar as retentativas em retentativas idempotentes com backoff, afrouxar o limite de timeout e fazer deduplicação de requisições no servidor. Depois disso, os Tokens inúteis caem pela maior parte.
Aqui vale detalhar alguns parâmetros-chave. Afrouxamos o timeout de 3 segundos para 15 segundos, mudamos o número de retentativas de ilimitado para no máximo duas, e adotamos backoff exponencial com jitter — a primeira retentativa espera 1 segundo, a segunda espera 2 segundos, com jitter aleatório para evitar o efeito manada. No lado do servidor, adicionamos uma impressão digital da requisição: a mesma impressão só é processada uma vez em 60 segundos, e as requisições seguintes retornam diretamente o resultado em cache. Depois da mudança, acompanhei por uma semana inteira: a taxa de retentativas caiu de 18% para menos de 4%, e o consumo de Tokens inúteis foi cortado em mais de setenta por cento. Houve ainda um ganho inesperado: as reclamações de timeout dos usuários diminuíram, porque, com o limite mais folgado, aquelas requisições que teriam dado certo mas eram cortadas cedo demais agora retornam normalmente.
A terceira é o contexto longo sem poda. Nossa interface de conversa, por padrão, enfia todo o histórico para dentro; quando o usuário chega à vigésima rodada, os Tokens de entrada são mais de dez vezes os da primeira. Mas, na prática, a maior parte do histórico é inútil para a resposta atual. Com janela deslizante mais compressão por resumo, mantendo apenas as últimas rodadas em texto original e um resumo rolante, o lado da entrada cai de quarenta a sessenta por cento. Há um detalhe: o próprio resumo também gasta Tokens, então a janela não pode ser comprimida demais; é preciso achar o ponto de inflexão.
Testamos vários conjuntos de parâmetros e acabamos fixando na combinação "últimas cinco rodadas em texto original + resumo rolante". O resumo rolante não é regenerado a cada rodada, mas atualizado a cada três rodadas, comprimindo as conversas mais antigas em um resumo de no máximo duzentas palavras. Assim, o volume de Tokens de entrada caiu de mais de oito mil na vigésima rodada para pouco mais de três mil, uma redução superior a sessenta por cento. Mas também testei comprimir para manter apenas as duas últimas rodadas, e o resultado foi uma queda evidente na qualidade das respostas: quando o usuário perguntava sobre o contexto, o modelo frequentemente respondia coisas sem nexo. Então esse ponto de inflexão realmente existe, e é preciso testá-lo conforme o cenário de negócio. Nossa experiência é: o tamanho da janela não deve ficar abaixo das três últimas rodadas, e a frequência de atualização do resumo não deve ser maior que uma vez a cada duas rodadas; caso contrário, o dinheiro economizado com Tokens não compensa o prejuízo à experiência do usuário.
A quarta é a baixa taxa de acerto do cache. Requisições iguais ou altamente semelhantes chegam repetidamente, e nós as inferimos de novo a cada vez. Prompts de sistema, templates fixos e perguntas frequentes, conteúdos totalmente cacheáveis, tinham taxa de acerto inferior a dez por cento na época. Depois de adicionar uma camada de cache semântico, requisições repetidas retornam diretamente; a proporção economizada depende da repetição do negócio, e no nosso caso fica entre vinte e trinta por cento.
Vale falar um pouco mais sobre o cache semântico. O cache exato só acerta requisições idênticas, mas, no cenário real, muitas requisições têm "o mesmo sentido com palavras diferentes". Por exemplo, o usuário pergunta "como faço reembolso" e "qual é o processo de reembolso": a correspondência exata não acerta, mas o cache semântico sim. A solução que usamos é: vetorizar a entrada, fazer busca de vizinho mais próximo aproximado na base de cache e, se a similaridade ultrapassar o limite, retornar diretamente o resultado em cache. O limite é crucial: alto demais, a taxa de acerto não sobe; baixo demais, é fácil retornar respostas irrelevantes. Fixamos em 0,92, e a taxa de acerto subiu de menos de 10% para 34%, sem nenhuma reclamação de usuário dizendo que a resposta não fazia sentido. Para prompts de sistema e templates fixos é ainda mais simples: basta fazer cache de prefixo, com taxa de acerto próxima de 100%.
Somando as quatro ações, depois rodamos com cobrança por uso mais camadas de modelos, e a fatura voltou para cerca de 1,2 vez a de antes do crescimento, enquanto o volume de chamadas continuava com aquele aumento de 40%. A propósito, no meio do caminho testamos o token8341 para acesso unificado a múltiplos modelos: uma única Key alterna entre vários provedores, e, com o roteamento e os critérios de cobrança unificados, investigar esse tipo de problema estrutural ficou bem mais fácil.
Mais um ponto facilmente ignorado: monitoramento e atribuição. A razão fundamental pela qual esses quatro problemas demoraram tanto para serem descobertos é que nossa fatura só era emitida por dimensão de modelo e endpoint, sem corte por "tipo de tarefa" e "impressão digital da requisição". Depois, adicionei uma camada de etiquetas de chamada: cada requisição recebe etiquetas de tipo de tarefa, se foi retentativa, se acertou o cache e número de rodadas de contexto. Quando a fatura sai, fica evidente qual etapa está queimando dinheiro. Esse sistema de etiquetas em si não economiza dinheiro, mas sem ele você simplesmente não sabe onde o dinheiro foi gasto.
Alerta para evitar armadilhas: não comece trocando para modelos mais baratos. Primeiro desmonte a estrutura de chamadas e veja; muitas vezes o dinheiro não é gasto no preço unitário, mas na repetição e redundância que você nem percebe. A otimização de preço unitário é o último passo, não o primeiro.
Autor: Zhao Qiming
Data de publicação: 9 de novembro de 2026