Reducir costos de LLM un 60% sin empeorar tu producto

La demo era barata. El lanzamiento no. Esa es la historia de casi todas las funciones de IA que he lanzado — un prototipo vistoso que cuesta centavos, seguido de una factura de producción que escala linealmente con el éxito. La buena noticia: la mayor parte de ese gasto es evitable, y recortarlo rara vez significa un peor producto. Tras hacer esto en un par de productos, suelo terminar en el mismo lugar: alrededor de 60% menos de costo para una salida que los usuarios no distinguen.

No hay un único truco. Son tres hábitos, apilados.

1. Usa caché con agresividad — la mayoría de los prompts se repiten

El token más barato es el que nunca envías. En el uso real, una porción sorprendente de las solicitudes son casi duplicadas: la misma pregunta frecuente formulada de tres maneras, el mismo documento resumido dos veces, el mismo system prompt con una variable mínima cambiada. Una caché basada en el prompt normalizado colapsa todo eso en una sola llamada pagada.

Empieza con una caché de coincidencia exacta — es trivial y funciona más de lo que crees. Luego añade una caché semántica: genera el embedding del prompt entrante y, si está dentro de un umbral de similitud con algo que ya respondiste, sirve la respuesta guardada.

llm/cache.ts

// Caché semántica: reutiliza una respuesta si existe un prompt parecido.
async function cachedComplete(prompt: string) {
  const embedding = await embed(prompt);
  const hit = await vectors.search(embedding, { threshold: 0.96 });
  if (hit) return hit.answer;          // $0 — servido desde caché

  const answer = await complete(prompt);
  await vectors.put(embedding, answer);
  return answer;
}

Una advertencia: una caché semántica es una perilla de calidad, no solo de costo. Si pones el umbral demasiado holgado servirás una respuesta obsoleta a una pregunta sutilmente distinta. Lo mantengo conservador (0,95–0,97 de coseno) y excluyo cualquier cosa sensible al tiempo.

2. Enruta las solicitudes al modelo más pequeño capaz de hacer el trabajo

No toda solicitud merece tu modelo más caro. Clasificar intención, extraer un campo, formatear JSON, responder una consulta simple — un modelo pequeño o local resuelve esto por una fracción del precio. Reserva el modelo de frontera para el razonamiento genuinamente difícil.

El patrón es un enrutador barato frente a tus modelos. Un clasificador diminuto (a menudo un modelo local pequeño vía Ollama) decide el nivel, y solo el nivel difícil llega a la API premium.

llm/router.ts

type Tier = "local" | "small" | "frontier";

const MODELS: Record<Tier, string> = {
  local:    "llama3:8b",        // $0, corre en nuestra máquina
  small:    "gpt-4o-mini",
  frontier: "gpt-4o",
};

async function route(task: Task): Promise<Tier> {
  if (task.kind === "classify" || task.kind === "extract") return "local";
  if (task.tokens < 800 && !task.needsReasoning) return "small";
  return "frontier";
}

Mide antes de enrutar. Registra la calidad por tarea (una señal de pulgar o un set de evaluación) antes de degradar un modelo. La ganancia solo es real si el nivel más barato mantiene la calidad — de lo contrario cambiaste dólares por tickets de soporte.

3. Ajusta el contexto al tamaño justo — pagas por token, en ambos sentidos

La tercera palanca es el propio prompt. Los equipos meten documentos enteros en el contexto "por si acaso", y luego pagan por cada token de entrada y ven crecer la latencia. La recuperación lo arregla: trae los pocos fragmentos que de verdad importan y deja el resto en disco.

Recorta el system prompt. Las instrucciones largas se pagan en cada llamada. Mueve las reglas estables a un fine-tune o a un preámbulo conciso y bien probado.
Recupera, no vacíes. Los k fragmentos más relevantes le ganan al documento entero — más barato y normalmente más preciso, porque el modelo no se distrae.
Limita la salida. Define max_tokens con intención. "Sé conciso" en el prompt más un tope duro ahorra más de lo que la gente espera.

La factura del modelo es una decisión de producto. Trata los tokens como cualquier otro recurso que perfilarías y optimizarías — porque a escala, es exactamente lo que son.

Juntándolo todo

Apilados, se potencian. La caché elimina las repeticiones. El enrutamiento abarata a los sobrevivientes. El tamaño justo encoge lo que queda. Ninguno toca la experiencia del usuario — si acaso, la recuperación y los prompts más ajustados hacen las respuestas más nítidas. El 60% no es un número de titular que ingenié al revés; es más o menos donde aterriza esto una vez que los tres hábitos están en su lugar y dejaste de pagar precios de frontera por preguntas sobre la política de reembolsos.

Si estás construyendo una función de IA y la factura empieza a doler, empieza por la caché — es la victoria más rápida — y luego añade el enrutador. Puedes lanzar ambos en una tarde, y tu equipo de finanzas lo notará para fin de mes.