BroadRouter
Começar

Log de uso de API de LLM: custo por usuário e recurso, sem PII

Pela equipe da BroadNet Inference · 4 min de leitura · Publicado em

Envolva toda chamada de LLM em uma única função que registra modelo, recurso, ID de usuário com hash, tokens de prompt, em cache, de raciocínio e de saída, custo, latência, status e o request ID do provedor. Calcule o custo a partir de uma tabela de preços, não da fatura. Registre metadados por padrão; se precisar guardar o texto do prompt, mascare-o antes de gravar e defina uma retenção curta.

Os painéis dos provedores dizem quanto você gastou. Raramente dizem qual recurso ou qual cliente gastou, e não conseguem dizer por que a conta disparou na terça-feira. O seu próprio log de uso consegue. Este post mostra o esquema do log, um wrapper que o preenche, como calcular o custo por chamada e como deixar dados pessoais de fora. O que fazer com os números está em outros posts: custo por usuário e precificação de SaaS e orçamentos e proteções contra loops.

O que registrar em cada chamada de LLM?

Uma linha por tentativa, novas tentativas incluídas:

Campo Exemplo Por quê
ts 2026-11-14T09:12:03Z Séries temporais, linha do tempo de incidentes
feature support_reply Custo por recurso
user_hash hmac:4f1c… Custo por usuário sem guardar a identidade
tenant acme Custo por cliente em apps B2B
model broadnet/deepseek-v4.1-flash Consulta de preço, comparação entre modelos
prompt_tokens 18.240 Custo de entrada
cached_tokens 16.384 Entrada em cache é mais barata; acompanhe a taxa de cache
reasoning_tokens 612 Custo oculto de saída em modelos de raciocínio
completion_tokens 1.104 Custo de saída (inclui raciocínio)
cost_usd calculado O número que o financeiro pede
latency_ms, ttft_ms 4.210 / 690 Regressões de desempenho
status 200, 429, 503 Taxas de erro e de novas tentativas
request_id valor de X-Request-ID Chamados de suporte e contestação de faturas
prompt_version support-v14 Liga mudanças de custo a mudanças de prompt

Nada de texto do prompt, nada de texto da resposta. Eles vêm depois, e só com mascaramento.

Como calcular o custo por chamada?

Leia o bloco usage e precifique cada tipo de token separadamente. A BroadNet publica preços em formato legível por máquina no pricing.json, com preços por 1M para entrada, entrada em cache e saída de cada modelo:

import json, urllib.request

PRICES = {m["id"]: m for m in json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))["models"]}

def call_cost(model: str, usage) -> float:
    p = PRICES[model]
    details = getattr(usage, "prompt_tokens_details", None)
    cached = (getattr(details, "cached_tokens", 0) or 0) if details else 0
    new_input = usage.prompt_tokens - cached
    return (
        new_input * (p.get("input_per_m") or 0)
        + cached * (p.get("cached_input_per_m") or p.get("input_per_m") or 0)
        + usage.completion_tokens * (p.get("output_per_m") or 0)
    ) / 1_000_000

Guarde o arquivo de preços em cache e atualize-o uma vez por dia em vez de baixá-lo a cada chamada. Dois erros fáceis: precificar tokens em cache como entrada nova (superestima o custo) e esquecer que os tokens de raciocínio já estão dentro de completion_tokens (não some duas vezes).

Como fica o wrapper de logging?

import hashlib, hmac, os, time, logging
from openai import OpenAI

log = logging.getLogger("llm.usage")
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
HASH_KEY = os.environ["USAGE_HASH_KEY"].encode()

def user_hash(user_id: str) -> str:
    return "hmac:" + hmac.new(HASH_KEY, user_id.encode(), hashlib.sha256).hexdigest()[:16]

def chat(*, feature: str, user_id: str, prompt_version: str, **kwargs):
    t0 = time.perf_counter()
    row = {"feature": feature, "user_hash": user_hash(user_id),
           "model": kwargs["model"], "prompt_version": prompt_version}
    try:
        raw = client.chat.completions.with_raw_response.create(**kwargs)
        resp = raw.parse()
        u = resp.usage
        d = getattr(u, "completion_tokens_details", None)
        row.update(
            status=200,
            request_id=raw.headers.get("x-request-id"),
            prompt_tokens=u.prompt_tokens,
            cached_tokens=getattr(getattr(u, "prompt_tokens_details", None), "cached_tokens", 0) or 0,
            reasoning_tokens=(getattr(d, "reasoning_tokens", 0) or 0) if d else 0,
            completion_tokens=u.completion_tokens,
            cost_usd=round(call_cost(kwargs["model"], u), 6),
        )
        return resp
    except Exception as e:
        row.update(status=getattr(e, "status_code", "error"),
                   request_id=getattr(getattr(e, "response", None), "headers", {}).get("x-request-id"))
        raise
    finally:
        row["latency_ms"] = int((time.perf_counter() - t0) * 1000)
        log.info("llm_call", extra={"llm": row})

with_raw_response dá acesso aos cabeçalhos, então você pode guardar o X-Request-ID. Para chamadas em streaming, adicione stream_options={"include_usage": True} e preencha a linha a partir do último chunk, como mostra o post sobre streaming com SSE. Mantenha a HASH_KEY secreta e estável: o mesmo usuário sempre gera o mesmo hash, mas o hash não pode ser revertido sem a chave.

Como atribuir custo a usuários e recursos?

Com as linhas acima em qualquer banco SQL, a atribuição é uma consulta:

SELECT feature, model,
       count(*)                          AS calls,
       sum(cost_usd)                     AS cost,
       sum(cached_tokens)::float / nullif(sum(prompt_tokens), 0) AS cache_rate,
       avg(completion_tokens)            AS avg_out
FROM llm_calls
WHERE ts >= now() - interval '7 days'
GROUP BY feature, model
ORDER BY cost DESC;

Troque feature por user_hash ou tenant para ver o custo por cliente. Três desdobramentos compensam rápido:

  1. O 1% de usuários mais caros. Muitas vezes é um único loop ou um bot. Uma cache_rate em queda é o outro sinal de alerta precoce; a calculadora de cache de prompt mostra quanto vale cada ponto de taxa de cache.
  2. Custo por resultado bem-sucedido, não por chamada: cruze com os seus próprios eventos de sucesso.
  3. Fatia de novas tentativas. Linhas com status 429 ou 5xx mostram quanto você gasta com falhas; veja como lidar com erros 429.

Como manter PII fora dos logs de LLM?

O log mais seguro não tem texto de prompt nenhum. Quando você precisar do texto, para depuração ou avaliações, siga estes passos na ordem:

  1. Amostre. Guarde texto de uma pequena fração das chamadas e das falhas, não de tudo.
  2. Mascare antes de gravar. Rode o mascaramento no processo que grava o log. Mascarar depois significa que o texto bruto já está no disco e nos backups.
  3. Combine detectores. Regex para dados estruturados, uma ferramenta de NER para nomes e endereços.
  4. Guarde separado. Coloque o texto em outra tabela ou bucket, com acesso mais restrito e retenção curta, ligado pelo request_id.
  5. Nunca registre segredos. O cheat sheet de logging da OWASP inclui tokens de acesso, senhas e chaves de criptografia entre os dados a excluir; a chave de API entra nessa lista.

Uma camada mínima de regex:

import re
PATTERNS = [
    (re.compile(r"[\w.+-]+@[\w-]+\.[\w.-]+"), "[EMAIL]"),
    (re.compile(r"\+?\d[\d\s().-]{7,}\d"), "[PHONE]"),
    (re.compile(r"\b(?:\d[ -]?){13,19}\b"), "[CARD]"),
    (re.compile(r"\b(sk|key|bearer)[-_ ]?[A-Za-z0-9]{16,}\b", re.I), "[SECRET]"),
]
def redact(text: str) -> str:
    for pat, label in PATTERNS:
        text = pat.sub(label, text)
    return text

Isso pega os casos óbvios e deixa passar nomes, endereços e qualquer coisa fora do comum. O Microsoft Presidio acrescenta reconhecimento de entidades para esses casos, e o README dele diz com todas as letras que não há garantia de que ele encontre todas as informações sensíveis. Conte com falhas: retenção curta e acesso restrito limitam o estrago quando algo escapa.

Onde a BroadNet Inference se encaixa

A BroadNet Inference devolve o bloco usage com tokens em cache e de raciocínio quando o modelo os informa, um X-Request-ID em toda resposta e um arquivo público de preços que você pode carregar para calcular custos. Do lado dela, prompts e respostas são processados para a requisição e não são retidos; ela guarda só registros sem conteúdo, como tempos, contagens de tokens e custo (como funciona a retenção zero de dados). Isso faz dos seus próprios logs a única cópia de qualquer texto de prompt, então as regras de mascaramento acima definem a sua retenção real. As requisições de chat da BroadNet não têm campo de metadados por usuário, então a atribuição fica no seu wrapper. Para orçamentos separados por equipe, use chaves separadas; o guia de chaves explica rótulos e allow-lists.

Perguntas frequentes

Como acompanhar o custo de API de LLM por usuário?

Marque cada chamada com um identificador de usuário, leia o bloco usage da resposta, multiplique as contagens de tokens pela sua tabela de preços e grave uma linha de log por chamada. Agrupe pela marca de usuário. Use um ID com hash em vez de um e-mail.

Devo registrar prompts e respostas completos?

Não por padrão. É neles que ficam os dados pessoais. Registre contagens de tokens e metadados de toda chamada e guarde o texto completo só de chamadas amostradas ou com falha, depois do mascaramento, com um período de retenção curto.

Por que meu custo calculado difere da fatura do provedor?

Geralmente porque tokens em cache foram precificados como entrada nova, tokens de raciocínio ficaram de fora da saída ou novas tentativas não foram registradas. Registre todas as tentativas, inclusive as que falharam e devolveram usage.

Como obter o uso de tokens de uma resposta em streaming?

Defina include_usage como true em stream_options. O último chunk passa a trazer o bloco usage com uma lista choices vazia.

Que ferramenta de mascaramento de PII usar em logs de LLM?

Comece com regex para dados estruturados, como e-mails, telefones e números de cartão, e adicione uma ferramenta baseada em NER, como o Microsoft Presidio, para nomes e endereços. O próprio README do Presidio diz que ele não garante encontrar tudo.

Ler em MarkdownPerguntar ao ChatGPTPerguntar ao ClaudePerguntar ao Perplexity