Entra en cualquier hilo sobre LLM locales y la discusión es sobre GPUs. Benchmarks de VRAM, tarjetas de 24 GB, CUDA contra ROCm, si la 3060 sigue siendo la tarjeta del pueblo. Mientras tanto, el número que decide de verdad si tu modelo corre está en la otra ranura, sin benchmarks ni marketing: cuánta RAM tiene la máquina.
La VRAM vende el sueño. La RAM decide si el modelo arranca — y cuánto contexto sobrevive cuando lo hace.
Lo probé en la máquina que tengo delante mientras escribía este post: un escritorio Ryzen con 32 GB de RAM y una GeForce RTX 3060 con 12 GB de VRAM. Descargué llama3.1:8b — la página dice 4,9 GB. Mira lo que reservó de verdad:

Todo el argumento cabe en una pantalla. Un «modelo de 4,9 GB» reservó 7,0 GB antes de responder un solo prompt — un impuesto de contexto del 43 % — y se quedó con 7.963 de los 12.288 MiB de VRAM. Los pesos nunca fueron el presupuesto. El contexto lo era.
De dónde salen los gigabytes extra
Las notas de memoria de llama.cpp detallan la aritmética que las páginas de descarga omiten: memoria total = pesos del modelo + caché KV + buffer de cómputo. Solo el primer término es constante. La caché KV crece linealmente con la longitud del contexto, y el buffer de cómputo con el batch. Ollama envuelve llama.cpp, así que la misma ley aplica — por eso ollama ps reportó 7,0 GB para un tag de 4,9 GB con ventana de 32.000 tokens, todo residente en GPU.
Un modelo cuantizado no es un compromiso. Es admitir que la memoria siempre fue el presupuesto real.
Por eso existe la escalera de cuantización GGUF. Q4 no es una religión; es lo que hace que la aritmética de memoria quepa en el hardware que la gente tiene. Y por eso dos configuraciones «idénticas» de 8B no se parecen en nada: mismo modelo, otra longitud de contexto, otras máquinas.
La tabla que nadie consulta antes de comprar
Tres clases de modelos, ambos tipos de memoria, una tarjeta de 12 GB y 32 GB de RAM — la configuración que miles de desarrolladores tienen de verdad:
| Clase de modelo (Q4) | Descarga | Cargado + ctx 32k | En 12 GB de VRAM | En 32 GB de RAM |
|---|---|---|---|---|
7–8B (llama3.1:8b) | 4,9 GB | 7,0 GB (medido) | 100% GPU, ~8 GiB usados | casi ni se nota |
13–14B (qwen2.5:14b) | 9,0 GB | ~12 GB | empieza el offload | perfecto |
27–32B (gemma3:27b) | 17 GB | ~20 GB o más | el CPU carga el peso | la única razón por la que corre |
Relee las dos últimas filas. Solo con VRAM, un 14B con contexto real ya es un trabajo de offload repartido, y un 27B es imposible. Con 32 GB de RAM, ambos son simplemente lentos. Esa diferencia — entre imposible y lento — es toda la diferencia práctica entre VRAM y RAM. Si cabe en VRAM, va rápido. Si cabe en RAM, funciona. Si no cabe en ninguna, estás haciendo swap al NVMe y el tiempo pierde el sentido.
El offload va por PCIe, y el FAQ de Ollama es directo con el coste: las capas que no caben en la GPU corren en la CPU, y el rendimiento se desploma cuando la parte de GPU se encoge. Nadie elige ese trade-off a conciencia. Ocurre en silencio, capa a capa, y el síntoma es solo «los modelos locales están sobrevalorados».
El libro de cuentas honesto
Lo que se rompió o sorprendió mientras escribía esto, en orden:
- El propio 43 %. Esperaba que el 8B ocupara «más o menos su tamaño de archivo». Reservó 7,0 GB contra 4,9 GB descargados. Si a mí me sorprendió, les sorprende a todos los que leen fichas técnicas en vez de
ps. - La sesión de capturas. Mi primera captura tomó la ventana equivocada. La segunda funcionó, y es la de arriba. Las pruebas son un flujo de trabajo, no una vibria — y un ciclo pull → captura →
ollama rmmantiene el disco honesto. - Lo que no se rompió: la GPU nunca se desbordó. 8B con 32k de contexto en 12 GB es de verdad cómodo. La tarjeta está bien. Lo mal calibrado es el discurso alrededor de la tarjeta.
Nada de esto dice que las GPUs no importen — la línea de 100% GPU en la captura es la razón por la que generar se sintió instantáneo. Significa que la GPU es la segunda pregunta. La elección entre Ollama y llama.cpp va después de saber qué cabe, no antes.
La regla que vale la pena guardar
RAM necesaria = archivo del modelo + caché KV para tu contexto real + 4 GB de ser una computadora. Para 7–8B en Q4, 16 GB son cómodos. Para 14B–32B, 32 GB dejan de ser lujo y pasan a ser el punto. Compra VRAM por la velocidad que quieres al contexto que usas; compra RAM por todo lo que cargarás algún día.
Mira
ollama psuna vez y la religión de las fichas técnicas se apaga en silencio.
Así que, dos preguntas. Cuando specifiques tu próxima máquina, ¿compras VRAM para los benchmarks que vas a publicar — o RAM para los modelos que de verdad vas a ejecutar? Y siendo honesto: ¿cuántos de los modelos que descargaste a las 2 a.m. borraste antes del desayuno? Yo lo hice esta noche, en pleno post. Dime en los comentarios que no soy el único — y de qué lado de la línea RAM/VRAM está tu equipo.
FAQ
¿Cuánta RAM necesitas para ejecutar un LLM local?
El tamaño del archivo del modelo, más el contexto, más tu escritorio. Con 16 GB vas sobrado con modelos 7–8B en Q4; 32 GB es lo que convierte un 14–32B en herramienta diaria y no en demo.
¿Qué importa más para LLM locales, VRAM o RAM?
La VRAM decide la velocidad cuando todo cabe en ella. La RAM decide si el modelo arranca y cuánto contexto sobrevive. El offload por PCIe entre ambas es el punto medio lento que nadie disfruta.
¿Por qué un modelo usa más memoria cargado que su tamaño de descarga?
La caché KV y los buffers de cómputo crecen con la longitud del contexto. llama.cpp documenta la aritmética: pesos + caché KV + buffer de cómputo, y solo el primer número aparece en la página de descarga.
— mrsaynothing
— mrsaynothing
Opinions load-tested before shipping. Mostly.
Comenta esta entrada en dev.to dev.to ↗
Get the next argument by email
One email per post. Agree or tear it apart.
¿qué es esto?SSH Permission denied (publickey): la solución real
¿Te gustan estos artículos? Hago esto para vivir. contrátame