Ollama: modelos locales con un comando

No toda llamada al modelo necesita uno de frontera, pero lo fácil es mandarlas todas al mismo de todas formas, y la cuenta y la exposición de datos crecen igual de rápido. Ollama vuelve realmente cómoda la opción barata. Un comando baja un modelo de pesos abiertos cuantizado y lo sirve en localhost detrás de una API REST y un endpoint compatible con OpenAI, así las llamadas que no necesitan genialidad dejan de pagarla. Acá va qué es la herramienta, dónde queda de verdad la línea entre local y frontera, un quickstart listo para pegar y las concesiones que el README se salta, empezando por las cuentas de memoria que deciden si siquiera llega a arrancar.

01 · Qué es en realidad

Ollama baja modelos de pesos abiertos cuantizados (Llama, Qwen, Gemma, Mistral y otros) y los sirve en local con dos interfaces: una API REST nativa en el puerto 11434 y un endpoint compatible con OpenAI en /v1. El segundo es la ganancia silenciosa. Cualquier cliente o SDK que ya hable el formato de chat-completions de OpenAI puede apuntar a localhost y funcionar sin tocar nada, así prototipas contra un modelo local y luego cambias la base URL sin reescribir código.

Los archivos del modelo están cuantizados, con los pesos comprimidos de floats de 16 bits a enteros de unos 4 bits. Eso es lo que permite que un modelo de 7B parámetros quepa en unos pocos gigabytes en vez de decenas. Ollama te maneja la descarga, el cacheo y el servir, y deja un modelo residente en memoria entre requests para que la segunda llamada no pague de nuevo el costo de carga.

Dos cosas lo vuelven algo más que un script de descarga:

• Un runtime, muchos modelos. Bajas por nombre y tag (llama3.1:8b, qwen2.5:7b), y Ollama mete y saca el modelo residente según van llegando los requests. No andas manejando archivos de pesos ni flags de inferencia a mano.
• Una puerta con forma de OpenAI. Como el endpoint /v1 imita la API de OpenAI, el mismo request que le mandarías a un proveedor hosteado funciona contra localhost. Eso convierte "local para lo barato, hosteado para lo difícil" en un cambio de config y no en dos codebases.

02 · Cuándo usarlo (y cuándo no)

Usa un modelo local con Ollama cuando el trabajo es de alto volumen, bajo riesgo o sensible a la privacidad: los casos donde pagar precios de frontera por llamada es tirar el dinero, o donde los datos no deberían salir de la máquina.

• Clasificación y enrutamiento. Etiquetar tickets, ordenar intenciones, decidir cuál de tres ramas toma un request. Un modelo local pequeño da de sobra, y sale gratis por llamada.
• Redacción y prefiltrado. Quita PII, descarta el spam obvio o puntúa relevancia antes de que algo toque una API de pago o salga de tu infraestructura.
• Desarrollo offline y sin red. Itera prompts y las conexiones del pipeline en un avión o en un entorno cerrado, sin red y sin un medidor por token corriendo.
• El primer pase barato. Este es el patrón que más uso. Pones un modelo local pequeño como filtro o etiquetador, y escalas a Claude solo los casos que de verdad están difíciles. La mayoría de las entradas nunca necesita el modelo caro. Las pocas que sí, igual lo reciben.

No lo uses para razonamiento de calidad final en tareas difíciles. Un modelo de 7B no es uno de frontera, y fingir lo contrario te da respuestas seguras y equivocadas. El encuadre honesto es por niveles, no reemplazo: local para el piso, frontera para el techo.

Cómo se compara

• vs. una API de frontera hosteada (Claude, etc.) Son trabajos distintos. El modelo hosteado gana en calidad de razonamiento y no te pide hardware. Ollama gana en costo marginal, latencia a localhost y en mantener los datos en casa. Los mejores setups usan ambos, con un router decidiendo por llamada.
• vs. llama.cpp pelado o vLLM. Esos te dan más control y, en el caso de vLLM, muchísimo más throughput bajo carga concurrente. Ollama cede parte de ese techo a cambio de un registro de modelos, manejo automático de memoria y la comodidad de un solo comando. Arranca con Ollama y gradúate a vLLM cuando ya estés sirviendo concurrencia de verdad.
• vs. un gateway compatible con OpenAI delante de modelos hosteados. Un gateway enruta y factura entre proveedores. Ollama es el proveedor local que pondrías detrás de ese gateway. Se complementan: el gateway puede mandar las llamadas fáciles a tu máquina con Ollama y las difíciles hacia arriba.

03 · Quickstart

Instala Ollama, baja un modelo pequeño con un tag exacto y llámalo. Fijar el tag importa, y hay más sobre eso abajo.

# descarga un modelo específico y fijado (no un "latest" flotante)
ollama pull qwen2.5:7b

# endpoint REST nativo
curl http://localhost:11434/api/generate \
  -d '{"model":"qwen2.5:7b","prompt":"Clasifica: solicitud de reembolso. Solo la etiqueta.","stream":false}'

# endpoint compatible con OpenAI, la misma forma que ya habla tu SDK
curl http://localhost:11434/v1/chat/completions \
  -d '{"model":"qwen2.5:7b","messages":[{"role":"user","content":"hola"}]}'

Como el endpoint es compatible con OpenAI, la mayoría de los SDKs funcionan cambiando solo la base URL y poniendo cualquier string no vacío como key. Acá va el patrón del primer pase barato. Etiqueta en local gratis y escala a Claude solo cuando el modelo local no esté seguro:

import OpenAI from "openai"

const local = new OpenAI({ baseURL: "http://localhost:11434/v1", apiKey: "ollama" })

async function triage(text: string) {
  const r = await local.chat.completions.create({
    model: "qwen2.5:7b",
    messages: [{ role: "user", content: `Etiqueta como spam|valido|inseguro: ${text}` }],
  })
  const label = r.choices[0].message.content?.trim().toLowerCase()
  // solo los casos "inseguro" llegan alguna vez al modelo caro
  return label === "inseguro" ? await escalarAClaude(text) : label
}

Corre Ollama en su propio contenedor con un límite fijo de CPU/memoria y un volumen con nombre para el cache de modelos, y la máquina se vuelve predecible. El servidor de inferencia no puede ahogar al resto de tu VPS, y los modelos que bajaste sobreviven a un redeploy.

04 · La trampa de la memoria

Este es el que tumba a la gente en una máquina pequeña, así que se lleva su propia sección. El costo de memoria de un modelo no es solo su cantidad de parámetros. Es el nivel de cuantización más el largo de contexto, y la ventana de contexto es la parte que todo el mundo olvida. Los pesos quizá quepan en 5 GB, pero un contexto largo llena un cache key-value que crece con cada token que le metes, y ese cache vive en la misma RAM o VRAM. Un modelo de 7B que carga sin problema con un contexto de 2K puede irse a swap o reventar por OOM en 32K.

La regla práctica: mide la huella residente contra tu hardware real antes de meter el modelo en un pipeline, no después de que te tumbe la máquina a las 2 de la madrugada.

• Elige la cuantización a conciencia. Un quant más agresivo (más pequeño, más rápido, un poco más bruto) frente a uno más liviano (más grande, más fino) es una concesión real. En un VPS modesto, el quant más pequeño de un modelo capaz casi siempre le gana a un quant más grande que no te cabe.
• Pon tope al contexto. Fija un largo de contexto que de verdad hayas probado en memoria, y rechaza o trunca las entradas que lo pasen en vez de dejar que el cache KV se desborde de tu RAM.
• Vigila el swap, no solo el OOM. Un modelo que se va a swap no se cae. Se pone dolorosamente lento, que es más difícil de diagnosticar que un error limpio de falta de memoria. Si la inferencia local de pronto tarda diez segundos, revisa si estás paginando a disco.

05 · Concesiones sin maquillaje

Ollama es de verdad útil, pero ni es gratis del todo ni es un reemplazo de Claude:

• La calidad tiene techo, y es más bajo. Los modelos pequeños de pesos abiertos son verdaderos caballos de batalla para tareas acotadas, y bastante más flojos en razonamiento difícil. Úsalos donde "suficientemente bueno y gratis" le gana a "excelente y medido", y en ningún lado donde equivocarse salga caro.
• El throughput es limitado. Ollama sirve requests bien para un solo desarrollador o un servicio de poco tráfico, pero no viene hecho para alta concurrencia. Cuando llega la carga real, ya estás hablando de vLLM o de una flota, no de un solo proceso de Ollama.
• Ahora la capa de inferencia es tu problema. Las actualizaciones, el disco que se come el cache de modelos, el margen de memoria y mantener el puerto fuera del internet público corren todos por tu cuenta. Ese aislamiento es justo lo que quieres en trabajo de privacidad, pero es superficie operativa que no tenías con una API hosteada.
• La compatibilidad con OpenAI es cercana, no perfecta. La mayoría de las llamadas de chat-completion mapean limpio, pero algunas funciones específicas del proveedor y comportamientos de borde no. No des por hecho que cada parámetro que usabas contra una API hosteada sobrevive el cambio. Prueba las llamadas que de verdad haces.

En mi día a día esto se gana su lugar como el piso de un nivel, no como todo el stack. Uso un modelo local pequeño en Ollama como primer pase barato, filtrando, etiquetando, redactando en la propia máquina, y mando a Claude solo las llamadas difíciles y de alto riesgo. La ganancia no es que el modelo local sea igual de listo. Es que la mayoría de las entradas nunca necesitaron el modelo listo de entrada. Fija tus tags, haz las cuentas de memoria antes de hacer deploy, mantén honesta la línea entre local y frontera, y Ollama le pega un mordisco real al costo y a la exposición de datos sin pretender ser algo que no es.