Quinto módulo del Curso de GPU para IA y arranque del bloque intermedio. Se acabó la teoría: hoy tu máquina genera sus primeros tokens. La herramienta es Ollama, y todo lo del bloque básico — VRAM, cuantización, el stack — se convierte en decisiones concretas frente a la terminal.

La tesis del módulo

Correr un LLM local hoy es un comando. La complejidad real no está en instalarlo, sino en elegir bien: qué modelo, en qué tamaño, para qué VRAM. Eso es exactamente lo que el bloque básico te enseñó a responder.

Qué es Ollama

Ollama es un runtime de inferencia que empaqueta tres cosas: el motor (por debajo usa llama.cpp, que veremos en el módulo 6), un gestor de modelos (descarga, versiona y cachea archivos GGUF) y un servidor con API. Trae sus librerías CUDA incluidas: en la torre del Módulo 3, solo necesitas el driver al día.

Se instala con el instalador oficial de ollama.com (Windows, Mac, Linux). En Mac usa Metal automáticamente; en Windows/Linux detecta tu GPU NVIDIA (o AMD soportada) y si no hay, cae a CPU.

El primer modelo

ollama run llama3.2

Eso descarga un modelo chico (3B, ya cuantizado) y abre un chat en la terminal. La primera vez tarda lo que tarde la descarga; después, el modelo carga desde disco a la VRAM en segundos.

Los comandos del día a día:

ollama pull qwen2.5:7b     # descargar sin abrir chat
ollama list                # qué modelos tienes en disco
ollama ps                  # qué está cargado y DÓNDE (GPU/CPU)

ollama ps es tu verificador del bloque básico en acción: la columna de procesador dice 100% GPU si el modelo cupo entero en VRAM. Si dice algo como 40%/60% CPU/GPU, hubo offloading — el modelo no cupo y parte quedó en RAM: funciona, pero mucho más lento. Es la señal de que toca un modelo más chico o más cuantizado.

Elegir modelo según tu VRAM

La cuenta del Módulo 4, convertida en recetario:

Tu VRAM	Qué correr cómodo	Ejemplos en Ollama
8 GB	3–7B en Q4	`llama3.2`, `mistral`, `phi3`
12 GB	7–8B en Q4 con contexto amplio	`llama3.1:8b`, `qwen2.5:7b`
16–24 GB	13–14B holgado, ~30B justo	`qwen2.5:14b`, `gemma2:27b`
32+ GB / Mac 64+	30–70B cuantizado	`llama3.3:70b` en Macs grandes

Los nombres de modelo envejecen rápido — al escribir esto ya existen qwen3, gemma3 y llama4 — pero el criterio no cambia: mira parámetros y cuantización contra tu VRAM. Los dos puntos del nombre (qwen2.5:7b) son el tag: variante y tamaño. Sin tag, Ollama trae el tamaño por defecto — que no siempre es el que tu VRAM quiere. Mira siempre el tag antes de descargar.

Medir lo que aprendiste

ollama run llama3.2 --verbose

Con --verbose, al final de cada respuesta aparecen las métricas — la que importa es eval rate: tus tokens por segundo reales. Compárala con la regla de servilleta del Módulo 2 (ancho de banda ÷ tamaño del modelo): vas a ver que el orden de magnitud calza. Ese número es tu línea base para todo lo que optimices después.

La API: donde esto se pone serio

Mientras Ollama está abierto, sirve una API HTTP en el puerto 11434. Y lo importante: expone una interfaz compatible con OpenAI, así que todo el ecosistema de agentes que ya conoces funciona apuntándola a tu máquina:

from openai import OpenAI

cliente = OpenAI(
    base_url="http://localhost:11434/v1",  # tu máquina, no la nube
    api_key="ollama",                      # requerido por el cliente; Ollama lo ignora
)

respuesta = cliente.chat.completions.create(
    model="qwen2.5:7b",
    messages=[{"role": "user", "content": "Explica qué es la VRAM en una frase."}],
)
print(respuesta.choices[0].message.content)

 tu agente / chat / script
        │  http://localhost:11434/v1
        ▼
 ┌─────────────────────────────┐
 │ Ollama: runtime + modelos   │
 └──────────────┬──────────────┘
                ▼
     GPU (o CPU si no alcanzó)

La consecuencia es enorme: cualquier framework que hable con OpenAI habla con tu GPU — LangGraph, el SDK que uses, tus scripts. Cambias la base_url y tus agentes pasan de pagar por token a correr gratis en tu escritorio. Sin costo por llamada, sin datos saliendo de tu máquina, sin límites de rate.

Ojo: el contexto por defecto de Ollama es corto. Si le pasas documentos largos y “olvida” el principio, no es el modelo: es la ventana. Se ajusta con el parámetro num_ctx — recordando del Módulo 2 que más contexto = más KV cache = más VRAM.

Errores comunes

Descargar el tamaño por defecto sin mirar el tag. Un :70b en una GPU de 12 GB va a “funcionar”… a paso de piedra vía CPU.
Ignorar ollama ps. Es la diferencia entre saber y suponer dónde corre tu modelo. 100% GPU o hay algo que ajustar.
Juzgar la velocidad con el primer mensaje. La primera respuesta incluye la carga del modelo a VRAM; mide desde la segunda.
Esperar calidad de GPT-4 en un 3B. Un modelo local chico es un excelente asistente acotado, no un frontier model. Elegir bien la tarea es parte del oficio.

La frase para llevarse

“La API es la misma, la URL es la tuya: el día que apuntaste base_url a localhost, tus agentes dejaron de pagar arriendo.”

Qué viene

Módulo 6: llama.cpp a fondo — el motor que Ollama esconde. Control fino del offloading capa por capa, GGUF directo de Hugging Face, llama-server y los benchmarks de verdad.

GPU para IA — Módulo 5: tu primer LLM local con Ollama