Los paneles de los proveedores le dicen cuánto gastó. Rara vez le dicen qué función o qué cliente lo gastó, y no pueden decirle por qué la factura se disparó el martes. Su propio registro de uso sí puede. Este artículo muestra el esquema del registro, un envoltorio que lo rellena, cómo calcular el costo por llamada y cómo mantener fuera los datos personales. Qué hacer con las cifras se trata en otros artículos: costo por usuario y precios de SaaS y presupuestos y protecciones contra bucles.
¿Qué debe registrar de cada llamada al LLM?
Una fila por intento, reintentos incluidos:
| Campo | Ejemplo | Por qué |
|---|---|---|
ts |
2026-11-14T09:12:03Z | Series temporales, cronologías de incidentes |
feature |
support_reply |
Costo por función |
user_hash |
hmac:4f1c… |
Costo por usuario sin guardar su identidad |
tenant |
acme |
Costo por cliente en aplicaciones B2B |
model |
broadnet/deepseek-v4.1-flash | Consulta de precios, comparación de modelos |
prompt_tokens |
18,240 | Costo de entrada |
cached_tokens |
16,384 | La entrada en caché es más barata; siga la tasa de caché |
reasoning_tokens |
612 | Costo de salida oculto en los modelos de razonamiento |
completion_tokens |
1,104 | Costo de salida (incluye el razonamiento) |
cost_usd |
calculado | La cifra que pide finanzas |
latency_ms, ttft_ms |
4,210 / 690 | Regresiones de rendimiento |
status |
200, 429, 503 | Tasas de error y de reintento |
request_id |
valor de X-Request-ID |
Tickets de soporte y disputas de facturación |
prompt_version |
support-v14 |
Vincula los cambios de costo con los cambios de prompt |
Sin texto del prompt ni de la respuesta. Eso viene después, y solo con ocultación de datos.
¿Cómo se calcula el costo por llamada?
Lea el bloque usage y ponga precio a cada tipo de token por separado. BroadNet publica precios legibles por máquina en pricing.json, con precios por 1M para entrada, entrada en caché y salida 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 en caché el archivo de precios y actualícelo a diario en lugar de descargarlo en cada llamada. Dos errores fáciles: cobrar los tokens en caché como entrada nueva (sobrestima el costo) y olvidar que los tokens de razonamiento ya están dentro de completion_tokens (no los sume dos veces).
¿Cómo es el envoltorio de registro?
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 le da las cabeceras, así que puede guardar el X-Request-ID. Para llamadas en streaming, añada stream_options={"include_usage": True} y rellene la fila a partir del último fragmento, como se muestra en el artículo sobre streaming SSE. Mantenga HASH_KEY en secreto y estable: el mismo usuario siempre produce el mismo hash, pero el hash no se puede revertir sin la clave.
¿Cómo se atribuye el costo a usuarios y funciones?
Con las filas anteriores en cualquier almacén SQL, la atribución es una sola 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;
Cambie feature por user_hash o tenant para obtener el costo por cliente. Tres comprobaciones posteriores rinden rápido:
- El 1 % de usuarios con más costo. A menudo es un solo bucle o un bot. Una
cache_rateque baja es la otra alerta temprana; la calculadora de caché de prompts muestra cuánto vale cada punto de tasa de caché. - Costo por resultado exitoso, no por llamada: crúcelo con sus propios eventos de éxito.
- Proporción de reintentos. Las filas con estado 429 o 5xx muestran cuánto gasta en fallos; vea cómo manejar los errores 429.
¿Cómo se mantiene la PII fuera de los registros de LLM?
El registro más seguro no tiene ningún texto de prompt. Cuando necesite el texto, para depurar o para evaluaciones, siga estos pasos en orden:
- Muestree. Guarde el texto de una pequeña parte de las llamadas y de los fallos, no de todo.
- Oculte antes de escribir. Ejecute la ocultación en el proceso que escribe el registro. Ocultar después significa que el texto sin procesar ya está en disco y en las copias de seguridad.
- Combine detectores por capas. Regex para datos estructurados, una herramienta de NER para nombres y direcciones.
- Almacene por separado. Ponga el texto en otra tabla o bucket con acceso más restringido y retención corta, vinculado por
request_id. - Nunca registre secretos. El OWASP Logging Cheat Sheet incluye los tokens de acceso, las contraseñas y las claves de cifrado entre los datos que se deben excluir; la clave de API pertenece a esa lista.
Una capa 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
Esto detecta los casos obvios y no detecta nombres, direcciones ni nada inusual. Microsoft Presidio añade reconocimiento de entidades para esos casos, y su README dice claramente que no hay garantía de que encuentre toda la información sensible. Cuente con que algo se escapará: una retención corta y un acceso restringido limitan el daño cuando ocurra.
Dónde encaja BroadNet Inference
BroadNet Inference devuelve el bloque usage con los tokens en caché y de razonamiento cuando el modelo los informa, un X-Request-ID en cada respuesta y un archivo de precios público que puede cargar para calcular costos. Por su parte, los prompts y las respuestas se procesan para la solicitud y no se conservan; solo guarda registros sin contenido, como tiempos, cantidades de tokens y costo (cómo funciona la retención cero de datos). Eso convierte sus propios registros en la única copia de cualquier texto de prompt, así que las reglas de ocultación anteriores determinan su retención real. Las solicitudes de chat de BroadNet no tienen un campo de metadatos por usuario, así que la atribución vive en su envoltorio. Para presupuestos separados por equipo, use claves separadas; la guía de claves explica las etiquetas y las listas de permitidos.
