Guia de implementação de orçamentos de tokens

Orçamentos de tokens são a camada operacional do controle de custos de LLM. A atribuição informa aonde o dinheiro vai; orçamentos evitam que vá para lugares que você não deseja. Sem orçamentos, um único loop de agente mal configurado ou um aumento no tráfego de usuários pode consumir uma alocação mensal em horas. Este guia cobre como implementar quatro tipos de orçamentos de tokens em produção, com pseudocódigo para cada padrão.

Tipos de orçamento

Limites por solicitação

O orçamento mais simples: limite cada solicitação com max_tokens. Isso não é opcional - cada solicitação de produção deve ter um limite explícito de tokens de saída. Sem ele, uma resposta verbosa do modelo pode consumir tokens inesperados e inflacionar a latência.

// Aplicação de orçamento por solicitação
function chameLLM(prompt, config):
    resposta = provedor.completar(
        prompt: prompt,
        modelo: config.modelo,
        max_tokens: config.max_tokens_saida,    // limite rígido
        temperatura: config.temperatura
    )
    if resposta.uso.tokens_totais > config.limite_aviso:
        log.aviso("Solicitação excedeu limite suave",
            tokens: resposta.uso.tokens_totais,
            limite: config.limite_aviso
        )
    return resposta

Cotas por equipe

As cotas por equipe requerem um contador compartilhado que persista entre solicitações. O padrão: verifique o orçamento restante antes de cada chamada, rejeite ou degrade se o orçamento se esgotar.

// Cota de equipe com contador apoiado por Redis
function verificarOrçamentoEquipe(idEquipe, tokensEstimados):
    chave = "orçamento:" + idEquipe + ":" + periodoAtual()
    restante = redis.obter(chave) or obterCotaEquipe(idEquipe)

    if restante < tokensEstimados:
        if restante < tokensEstimados * 0.1:
            return NEGAR    // limite rígido: rejeitar solicitação
        else:
            return DEGRADAR   // limite suave: usar modelo mais barato

    return PERMITIR

function registrarUso(idEquipe, tokensReais):
    chave = "orçamento:" + idEquipe + ":" + periodoAtual()
    redis.decrementar(chave, tokensReais)
    restante = redis.obter(chave)
    if restante < obterCotaEquipe(idEquipe) * 0.2:
        alerta.cotaBaixa(idEquipe, restante)

Orçamentos por período de tempo

Orçamentos por período de tempo envolvem cotas de equipe com uma janela de tempo. A diferença chave: você precisa de um mecanismo de período de carência. Quando uma equipe atinge 80% de seu orçamento mensal, envie um alerta. Com 100%, permita um período de carência configurável (por exemplo, 24 horas) antes que o cumprimento rígido entre em vigor. Isso evita que uma equipe seja bloqueada no meio de uma tarefa no último dia do mês.

// Orçamento por período com período de carência
function aplicarOrçamento(idEquipe):
    uso = obterUsoPeriodo(idEquipe, mesAtual())
    limite = obterLimiteOrcamentoMensalEquipe(idEquipe)

    if uso < limite * 0.8:
        return PERMITIR

    if uso < limite * 1.0:
        alerta.avisoOrcamento(idEquipe, uso, limite)
        return PERMITIR   // zona de aviso suave

    if uso < limite * 1.1 and dentroPeriodoCarencia(idEquipe):
        alerta.orcamentoExcedido(idEquipe, uso, limite)
        return PERMITIR   // período de carência: permitir excesso

    return NEGAR  // parada rígida

Orçamentos por fluxo de trabalho

Agentes e pipelines multi-etapa precisam de orçamentos em dois níveis: por etapa (evita que uma única etapa consuma demais) e por execução (evita que todo o pipeline exceda sua alocação). Acompanhe ambos no contexto do fluxo de trabalho.

// Rastreador de orçamento de fluxo de trabalho
class OrçamentoFluxo:
    construtor(maxPorEtapa, maxTotal):
        this.maxPorEtapa = maxPorEtapa
        this.maxTotal = maxTotal
        this.gasto = 0

    function executarEtapa(fnEtapa, prompt):
        if this.gasto >= this.maxTotal:
            return respostaReserva("Orçamento excedido")

        resposta = chameLLM(prompt, {
            max_tokens: min(this.maxPorEtapa,
                           this.maxTotal - this.gasto)
        })

        this.gasto += resposta.uso.tokens_totais
        return resposta

Degradação graciosa quando o orçamento é excedido

Não simplesmente retorne um erro quando um orçamento é atingido. Degrade graciosamente. Mude para um modelo mais barato (GPT-4o-mini em vez de GPT-4o), reduza o tamanho da janela de contexto, pule etapas de processamento opcionais ou retorne um resultado parcial com uma nota de que o processamento completo requer aprovação de orçamento. A experiência do usuário deve degradar, não quebrar.

// Cadeia de degradação
function chamarComDegradacao(prompt, config):
    if verificarOrçamento(config.idEquipe, MODELO_COMPLETO):
        return chameLLM(prompt, { modelo: config.modeloPrimario })

    if verificarOrçamento(config.idEquipe, MODELO_BARATO):
        log.info("Degradando modelo por orçamento")
        return chameLLM(prompt, { modelo: config.modeloReserva })

    if verificarOrçamento(config.idEquipe, TOKENS_MINIMOS):
        truncado = truncarContexto(prompt, 50%)
        return chameLLM(truncado, {
            modelo: config.modeloReserva,
            max_tokens: 256
        })

    return cacheadoOuFallback(prompt)

Monitoração da saúde do orçamento

Acompanhe três métricas: taxa de consumo (tokens consumidos por hora vs. orçamento), previsão (no ritmo atual, quando o orçamento se esgotará) e contagem de substituições (quantas vezes o período de carência foi usado). Se o uso do período de carência exceder 10% do total de solicitações, o orçamento está definido muito baixo para a carga de trabalho.

Relacionado

• Governança de orçamento de LLM - políticas organizacionais por trás dos orçamentos.
• Grades de proteção de despesas de agentes - padrões de orçamento para agentes autônomos.
• Como limitar custos de inferência - controles de custo do lado do provedor.

Quer isso aplicado aos seus próprios gastos com LLM? O FinOps LLM executa uma auditoria gratuita dos seus custos de IA e mostra onde estão as economias. Agendar auditoria gratuita →

Voltar à pesquisa