¿Cuánta VRAM necesitas para usar un modelo de IA en local?

Para usar un modelo de IA en tu propio ordenador, la pregunta que decide todo es cuánta memoria de vídeo (VRAM) necesita. La respuesta tiene tres partes: los pesos del modelo, la caché KV, que guarda la conversación, y un margen para el propio programa. Los pesos dependen del tamaño del modelo y de cuánto se comprime (la cuantización). La caché depende de la arquitectura y de cuánto texto le das. Esa segunda parte es la que casi nadie explica, y por eso un modelo que «cabe» puede fallar al pegarle un documento largo.

La calculadora usa la misma fórmula que comprobamos con 13 archivos de modelos reales (cómo lo comprobamos).

Qué tarjeta te basta según el modelo

Con 8.192 tokens de contexto (una conversación larga o unas cuantas páginas de texto), estas son las cifras de los modelos abiertos más descargados:

En la práctica:

• 8 GB (RTX 5060, RTX 4060): modelos de 4.000 a 8.000 millones de parámetros en Q4_K_M y con poco contexto. Qwen3 8B se queda en unos 7,3 GB con 8.192 tokens: entra, pero justo.
• 12 GB (RTX 5070, RTX 4070): modelos de hasta unos 14.000 millones en Q4_K_M con poco contexto. Qwen3 14B necesita unos 11,5 GB.
• 16 GB (RTX 5080, RTX 5070 Ti, RTX 5060 Ti de 16 GB): la mayoría de modelos medianos. gpt-oss-20b, de OpenAI, ronda los 15 GB; la propia OpenAI dice que funciona «within 16GB of memory».
• 24 y 32 GB (RTX 4090, RTX 5090): modelos de 24.000 a 35.000 millones en Q4_K_M, como Qwen3 32B (unos 23 GB con 8.192 tokens).
• 70.000 millones o más: no caben en ninguna tarjeta de consumo. Llama 3.3 70B necesita unos 43 GB solo para los pesos en Q4_K_M.

Cuánta VRAM tiene cada tarjeta NVIDIA

La memoria y el ancho de banda salen de la tabla comparativa de NVIDIA:

La VRAM decide qué cabe; el ancho de banda decide la velocidad. Para escribir cada palabra (token) nueva, la tarjeta lee una vez todos los pesos activos, así que hay un techo de ancho de banda ÷ tamaño de los pesos. Con Qwen3 8B en Q4_K_M (5,0 GB), ese techo es de unos 358 tokens por segundo en una RTX 5090 (1.792 GB/s) y de unos 89 en una RTX 5060 (448 GB/s). La velocidad real es menor, porque también se lee la caché, pero la proporción entre tarjetas se mantiene. No hemos medido velocidades reales: son límites teóricos, no pruebas.

La fórmula, en tres líneas

• Pesos (bytes) = parámetros × bits por peso ÷ 8. Un modelo de 8.000 millones de parámetros en Q4_K_M (4,89 bits por peso, según la medición de llama.cpp) ocupa unos 5 GB.
• Caché KV (bytes) = 2 × capas × cabezas KV × dimensión por cabeza × bytes por valor × tokens de contexto. El 2 corresponde a las claves y los valores. Con la precisión por defecto (16 bits), cada valor ocupa 2 bytes.
• Margen: sumamos 1 GiB para búferes de cálculo y el controlador de la tarjeta. Es un supuesto nuestro, no una medición: cambia según el programa, el tamaño de lote y la GPU.

Los datos de arquitectura salen del config.json de cada modelo en Hugging Face (num_hidden_layers, num_key_value_heads, head_dim). La calculadora los trae para 12 modelos; para cualquier otro, elige «Otro modelo» y cópialos.

Cuantización: qué significan Q4_K_M y Q8_0

Cuantizar es guardar cada peso con menos bits. llama.cpp publica los bits por peso medidos en Llama 3.1 8B: Q4_K_M usa 4,89 (4,58 GiB), Q5_K_M 5,70, Q6_K 6,56, Q8_0 8,50 (7,95 GiB) y F16 16 (14,96 GiB). Son algo más de 4, 5 u 8 porque cada bloque guarda también factores de escala.

Según llama.cpp, cuantizar «may introduce some accuracy loss», y esa pérdida la mide con la perplejidad. Cuánto importa depende del modelo y de la tarea. Si un modelo va justo, prueba el formato siguiente antes de comprar más memoria.

El contexto también ocupa memoria

La caché crece en línea recta con el contexto. En Llama 3.1 8B, a 16 bits, ocupa exactamente 1 GiB con 8.192 tokens, 4 GiB con 32.768 y 16 GiB con sus 131.072 tokens máximos: tres veces y media lo que ocupan sus pesos en Q4_K_M.

Ollama elige el contexto por ti según la VRAM: 4K con menos de 24 GiB, 32K entre 24 y 48 GiB y 256K a partir de 48 GiB (así lo escribe su documentación). Para agentes, búsquedas web y herramientas de programación recomienda al menos 64.000 tokens. Si lo subes, comprueba con ollama ps que la columna PROCESSOR sigue diciendo «100% GPU».

Dos ajustes reducen la caché:

• Caché cuantizada: la variable OLLAMA_KV_CACHE_TYPE admite f16 (por defecto), q8_0 (más o menos la mitad de memoria, que según Ollama normalmente no se nota en la calidad) y q4_0 (un cuarto, con una pérdida que puede notarse más con contextos largos).
• Menos contexto: si tus preguntas son cortas, 4.096 u 8.192 tokens bastan, y la memoria que ahorras puede ir a una cuantización mejor.

Por qué algunos modelos nuevos necesitan mucha menos memoria

Muchos modelos recientes no guardan todo el contexto en todas las capas. Algunas capas solo miran los últimos cientos o miles de tokens (ventana deslizante) y otras usan atención lineal, cuya memoria no crece con el contexto. Las calculadoras que tratan todas las capas igual se equivocan mucho con ellos:

El ahorro depende del programa: llama.cpp guarda una caché reducida para las capas de ventana deslizante por defecto (su opción --swa-full, que la desactiva, viene apagada).

Modelos de mezcla de expertos

Qwen3-Coder 30B-A3B o gpt-oss-20b son modelos de mezcla de expertos: en cada token solo trabajan unos pocos. Según sus fichas, Qwen3-Coder activa 3.300 de sus 30.500 millones de parámetros y gpt-oss-20b, 3.600 de 21.000 millones. Todos los expertos tienen que estar cargados, así que la memoria depende del tamaño total; la velocidad, del activo. Por eso van mucho más rápidos de lo que su tamaño sugiere.

En un Mac

En los Mac con chip Apple, la tarjeta gráfica usa la misma memoria unificada que el resto del sistema: lo que cuenta es la memoria total del Mac menos lo que usan macOS y tus aplicaciones. LM Studio recomienda al menos 16 GB y dice que en los Mac de 8 GB hay que quedarse con modelos pequeños y contextos modestos.

Si el modelo no cabe

1. Usa una cuantización menor (Q4_K_M en lugar de Q6_K) o un modelo más pequeño de la misma familia.
2. Reduce el contexto o cuantiza la caché.
3. Reparte el modelo entre la GPU y la CPU. Ollama lo hace solo cuando no cabe en la VRAM, y ollama ps muestra el reparto. Funciona, pero cada capa que va en la CPU hace más lenta la respuesta.
4. Añade otra tarjeta. Ollama reparte el modelo entre varias GPU cuando no cabe en una, según su documentación.

Para instalarlo todo paso a paso, mira cómo instalar Ollama y usar IA en local.

Cómo lo comprobamos

Comparamos la fórmula de los pesos con el tamaño real de 13 archivos GGUF que publica unsloth en Hugging Face, de Qwen3 4B a Llama 3.3 70B, en Q4_K_M y Q8_0. Todas las estimaciones quedan a menos de un 3 % del archivo real: Qwen3-8B en Q4_K_M pesa 5,03 GB y la fórmula da 5,01 (-0,3 %); Qwen3-32B pesa 19,76 GB y la fórmula da 20,04 (+1,4 %); Llama 3.3 70B pesa 42,52 GB y la fórmula da 43,16 (+1,5 %). Gemma 3 y Mistral Small salen algo por encima (+2,1 % y +2,5 %) porque su recuento de parámetros incluye un codificador de imágenes que va en otro archivo.

La caché KV es aritmética exacta sobre la arquitectura publicada; las pruebas automáticas de esta página la comparan con valores conocidos (Llama 3.1 8B: 16 GiB con 131.072 tokens). Lo que no hemos medido es el margen de ejecución, que fijamos en 1 GiB, ni la velocidad real.