As contas de IA crescem mais rápido do que a maioria das equipes espera. Aqui estão maneiras práticas de reduzir custos de LLM por meio de roteamento de modelo, armazenamento em cache, prompts mais curtos e melhor monitoramento.
O primeiro projeto de lei de IA geralmente parece inofensivo. Você conecta uma API, envia um recurso e a fatura parece um erro de arredondamento. Então o uso aumenta, alguém adiciona um widget de chat a cada página e, alguns meses depois, o setor financeiro pergunta por que um item de linha triplicou.
Já vi esse padrão com frequência suficiente para saber que não é um problema de preço. É um problema de design. A maioria dos aplicativos envia mais tokens do que o necessário, para um modelo maior do que o necessário, com muito mais frequência do que o necessário.
A boa notícia é que você pode cortar custos substancialmente sem prejudicar a qualidade. Aqui estão as técnicas que mais importam, aproximadamente na ordem em que eu as testaria.
Meça antes de otimizar
Você não pode cortar o que não pode ver. Antes de alterar qualquer coisa, registre-os para cada solicitação:
-
Recurso ou endpoint que fez a chamada
-
Modelo usado
-
Contagens de tokens de entrada e saída
-
Latência
-
Se o usuário obteve um resultado útil (até mesmo um polegar para cima ou para baixo).
Em seguida, agrupe os dados por recurso. Na maioria dos aplicativos, dois ou três recursos geram a maior parte dos gastos e raramente são aqueles que as pessoas adivinham. Um resumidor de plano de fundo executado em todos os documentos pode facilmente superar seu chamativo chatbot.
Acompanhe também o custo por resultado bem-sucedido, não apenas o custo por chamada. Um modelo barato que falha na metade das vezes e força novas tentativas pode custar mais do que um modelo mais caro que acerta.
Use o menor modelo que faça o trabalho
O desperdício mais comum é usar um modelo de primeira linha para tudo. Classificação, extração, marcação, reescritas curtas e decisões de roteamento raramente precisam da opção mais capaz. Modelos menores são mais rápidos e muito mais baratos por token e, para tarefas restritas, geralmente apresentam o mesmo desempenho.
Uma abordagem simples é construir um pequeno conjunto de avaliação de 50 a 100 exemplos reais com boas respostas conhecidas e, em seguida, executá-lo em alguns tamanhos de modelo. Escolha o mais barato que supere sua barra de qualidade. Repita quando novos modelos forem lançados, porque o nível barato continua melhorando.
Depois de saber o que cada camada pode suportar, adicione roteamento. Envie solicitações fáceis para o modelo pequeno e escale apenas quando necessário:
píton
def resposta(consulta: str) -> str:
# Primeira passagem barata: classifique a dificuldade
nível = small_model.classify(query) # “simples” | “complexo”
se nível == “simples”:
retornar modelo_pequeno.generate(consulta)
retornar large_model.generate(consulta)
Você também pode usar uma verificação de confiança. Deixe o modelo pequeno responder primeiro e aumente se sinalizar incerteza ou falhar em uma etapa de validação, como uma verificação de esquema JSON. Mesmo um roteador básico que lide com 60 a 70 por cento do tráfego com o modelo mais barato causa um impacto visível.
Corte suas solicitações
Cada token que você envia custa dinheiro e os prompts tendem a aumentar com o tempo. Alguém adiciona uma instrução para corrigir um bug, outro adiciona três exemplos e logo cada solicitação carrega mil fichas de bagagem.
Audite seus prompts da mesma forma que revisaria o código antigo:
-
Remova instruções repetidas. Dizer “seja conciso” de quatro maneiras não ajuda.
-
Reduza os exemplos. Dois bons exemplos de poucas tacadas geralmente correspondem ao desempenho de oito.
-
Encurte o prompt do sistema. Palavras simples e diretas superam a dramatização elaborada.
-
Não reenvie o que não mudou. Em aplicativos de bate-papo, resuma os turnos mais antigos em vez de repetir toda a história.
-
Retire o lixo das entradas. Tags HTML, clichês, assinaturas e texto de navegação aumentam os documentos sem nenhum benefício.
Após cada corte, execute novamente seu conjunto de avaliação. Se a qualidade for mantida, fique com o troco. Se cair, coloque as fichas de volta. O corte imediato é fácil de exagerar, então deixe os dados decidirem.
Armazenar em cache agressivamente
O pedido mais barato é aquele que você nunca faz. Existem três níveis de cache que vale a pena conhecer.
Cache de correspondência exata. Se os usuários costumam fazer perguntas idênticas ou se seu pipeline processa a mesma entrada duas vezes, armazene a resposta codificada por um hash do prompt. Isso é fácil de construir e surpreendentemente eficaz para recursos do tipo FAQ.
Cache semântico. Para perguntas semelhantes, mas não idênticas (“como faço para redefinir minha senha” versus “etapas de redefinição de senha”), incorpore a consulta e procure uma correspondência aproximada em um armazenamento de vetores. Se a similaridade ultrapassar um limite ajustado, retorne a resposta armazenada. Tenha cuidado aqui. Defina o limite de forma conservadora e evite-o para qualquer coisa personalizada ou urgente, ou você fornecerá respostas erradas com confiança.
Cache de prompt do provedor. Muitos provedores agora descontam prefixos de prompt repetidos. Se suas solicitações compartilham um início longo e estável, como um grande prompt do sistema, um documento de política ou um resumo da base de código, estruture os prompts de modo que o conteúdo estático venha primeiro e a mudança de entrada do usuário venha por último. Essa ordem permite que o provedor reutilize a parte armazenada em cache a uma taxa mais baixa. Verifique a documentação do seu provedor para obter as regras exatas, porque os comprimentos mínimos e as janelas de expiração são diferentes.
Limite a saída
Os tokens de entrada recebem a maior parte da atenção, mas os tokens de saída normalmente têm preços mais altos e também demoram mais para serem gerados. Os modelos são tagarelas por padrão.
-
Defina um max_tokens sensato para cada recurso.
-
Peça o formato que você precisa: “Responder em duas frases” ou “Retornar apenas JSON”.
-
Use resultados estruturados em vez de prosa de formato livre quando uma máquina, e não uma pessoa, ler o resultado.
-
Evite pedir ao modelo que reformule a pergunta ou acrescente gentilezas.
Um recurso que retorna 150 tokens em vez de 500 é mais barato e parece mais rápido. Os usuários raramente reclamam de respostas mais curtas quando as respostas estão certas.
Agrupe tudo o que não for urgente
Nem todas as tarefas de IA precisam de uma resposta em tempo real. A geração de relatórios noturnos, classificação em massa, marcação de conteúdo, incorporações para um backlog e limpeza de dados podem esperar. Muitos provedores oferecem endpoints em lote que processam solicitações de forma assíncrona, normalmente com um desconto significativo em comparação com chamadas padrão.
Analise suas cargas de trabalho e faça uma pergunta simples: alguém notaria se isso terminasse em algumas horas em vez de alguns segundos? Caso contrário, mova-o para lote. É uma das vitórias mais fáceis da lista porque a alteração do código é pequena e a qualidade permanece a mesma.
Torne a recuperação mais inteligente
Se você usar a geração de recuperação aumentada, sua janela de contexto provavelmente é onde o dinheiro vaza. A versão preguiçosa coloca os 10 principais blocos em cada prompt, sejam eles relevantes ou não.
Melhores hábitos:
-
Recupere menos, classifique melhor. Use um reclassificador para poder enviar três pedaços fortes em vez de dez medíocres.
-
Pedaço pensativo. Pedaços muito grandes carregam ruído e pedaços muito pequenos perdem significado. Teste alguns tamanhos em relação a questões reais.
-
Ignore a recuperação quando ela não for necessária. Uma saudação ou um simples acompanhamento não necessita de pesquisa documental.
-
Filtre com metadados. Limitar por produto, data ou idioma antes da pesquisa vetorial melhora a relevância e reduz o contexto.
Uma boa recuperação reduz custos e geralmente melhora as respostas, uma vez que o modelo vê menos material que distrai.
Considere o ajuste fino ou destilação, mais tarde
Depois que você tiver tráfego estável e de alto volume em uma tarefa restrita, um modelo menor treinado para esse trabalho poderá substituir um modelo grande e geral. A destilação, onde os resultados de um modelo forte são usados para treinar um modelo mais barato, é uma rota comum. Você pagará adiantado pela preparação de dados e pelo treinamento e, posteriormente, economizará em cada ligação.
Eu não começaria aqui. Ele adiciona trabalho de manutenção e só compensa em grande escala, então esgote primeiro as opções mais simples. Mas se uma tarefa representa a maior parte da sua conta e os requisitos raramente mudam, ela merece uma análise adequada.
Adicione grades de proteção para que os custos não surpreendam você
A otimização significa pouco se um ciclo descontrolado puder queimar o orçamento de um mês durante a noite. Vale a pena ter algumas proteções desde o primeiro dia:
-
Limites de taxa por usuário e por recurso. Impeça que um usuário pesado ou um script incorreto domine o uso.
-
Alertas de orçamento e limites máximos. Seja avisado em 50 e 80% e corte recursos não críticos em 100%.
-
Tente novamente os limites com espera. Novas tentativas ilimitadas em chamadas com falha multiplicam os custos silenciosamente.
-
Tempos limite. Não deixe uma solicitação travada ser executada e gerar tokens indefinidamente.
-
Proteção de loop para agentes. Limite o número de etapas e chamadas de ferramentas por tarefa.
Os agentes merecem menção especial. Um agente de múltiplas etapas pode fazer dezenas de chamadas de modelo para uma única solicitação de usuário, cada uma carregando um contexto crescente. Estabeleça um limite máximo para as etapas e registre o custo total de cada execução para ver quais fluxos de trabalho valem a pena.
Uma lista de verificação rápida
Tokens de registro, modelo e recurso para cada chamada.
Encontre os três principais fatores de custo.
Teste modelos menores em um conjunto de avaliação.
Encaminhe solicitações fáceis para modelos baratos.
Corte os prompts e reduza as saídas.
Armazene as correspondências exatas em cache e considere o cache semântico e de provedor.
Mova o trabalho não urgente para o lote.
Aperte a recuperação.
Adicione orçamentos, limites e proteção de loop.
Revise tudo quando novos modelos e preços chegarem.
Considerações finais
Cortar custos de IA não significa extrair qualidade do seu produto. Trata-se de ser deliberado: o modelo certo, a quantidade certa de contexto e nenhum trabalho repetido. As equipes que fazem isso bem geralmente acabam com aplicativos mais rápidos como bônus, porque menos tokens significam respostas mais rápidas.
Comece com a medição, escolha o maior gerador de custos e corrija-o primeiro. Uma mudança bem direcionada, como rotear solicitações simples para um modelo menor, geralmente economiza mais de semanas de solicitações de ajuste fino. Então continue verificando, porque os preços, os modelos e seu próprio uso continuarão mudando.
