¿Cuánta VRAM necesitas para ejecutar un LLM local?
La respuesta corta: la suficiente para contener el archivo del modelo más su memoria de trabajo. Un modelo típico de 8B necesita unos 5 GB con el popular ajuste de 4 bits, unos 8,5 GB a 8 bits y 16 GB sin cuantizar. Esta guía convierte tu tarjeta gráfica — o tu RAM del sistema, si no tienes tarjeta — en una respuesta concreta para cada tamaño de modelo habitual.
Última actualización: noviembre de 2026 · Editor: LibreAI · Por el equipo de LibreAI · Cifras calculadas a partir del número de parámetros de los modelos y de los tamaños publicados de los archivos GGUF — el método está al final de esta página
Conclusiones clave
- Los pesos dominan. VRAM necesaria ≈ el tamaño del archivo del modelo en disco, más un margen aproximado del 10–20 % para la caché KV y los búferes del motor en contextos de chat.
- Un modelo de 8B en Q4_K_M (≈4,9 GB) es el punto de entrada: cualquier tarjeta gráfica de 8 GB lo ejecuta por completo en la GPU.
- Una tarjeta de 24 GB (clase RTX 3090 / 4090) ejecuta un modelo de 32B en Q4_K_M con margen de sobra; un modelo de 70B necesita 48 GB con ese ajuste, o descarga parcial a la RAM.
- No tener GPU no es un callejón sin salida: la misma tabla de tamaños se lee como RAM del sistema para la ejecución solo con CPU: más lenta, pero funciona.
- gpt-oss-20b fue diseñado para tarjetas de 16 GB; gpt-oss-120b necesita una GPU de clase 80 GB o un Mac con mucha memoria.
La respuesta corta
Un modelo de lenguaje en memoria tiene tres partes: los pesos (el propio archivo del modelo), la caché KV (la memoria de trabajo del modelo sobre tu conversación, que crece con la longitud del contexto) y los búferes del motor. En un uso normal de chat, los pesos son el 80–95 % del total, así que el tamaño del archivo del modelo en disco es la cifra por la que hay que empezar. La cuantización es lo que hace viable el hardware doméstico: almacenar cada peso en unos 4 bits en lugar de 16 reduce el archivo aproximadamente a la cuarta parte, con un pequeño coste de calidad. Cada cifra de esta página es un tamaño real de archivo GGUF, o un cálculo directo a partir de uno.
VRAM por tamaño de modelo y cuantización
Solo los pesos, en GB: el tamaño del archivo del modelo que descargas. Las mismas cifras valen para la RAM del sistema en la ruta solo con CPU. Añade margen para la caché KV y los búferes (siguiente sección) antes de comparar con tu tarjeta.
| Tamaño del modelo | FP16 | Q8_0 (8 bits) | Q4_K_M (4 bits) | Q2_K (2 bits) |
|---|---|---|---|---|
| ~1B | 2,0 | 1,1 | 0,8 | 0,6 |
| ~3B | 6,4 | 3,4 | 2,0 | 1,3 |
| ~8B | 16 | 8,5 | 4,9 | 3,0 |
| ~14B | 30 | 16 | 9,0 | 5,6 |
| ~32B | 65 | 35 | 20 | 12 |
| ~70B | 141 | 75 | 43 | 26 |
| gpt-oss-20b (MoE) | — | — | ≈14 (MXFP4 nativo) | — |
| gpt-oss-120b (MoE) | — | — | ≈65 (MXFP4 nativo) | — |
Los modelos de mezcla de expertos (MoE), como gpt-oss, almacenan todos sus expertos, así que el número total de parámetros define el tamaño del archivo aunque solo una parte del modelo esté activa en cada token.
La caché KV: por qué la longitud del contexto consume memoria
La caché KV es la memoria del modelo sobre todo lo dicho hasta ahora, y crece de forma lineal con la longitud del contexto. Un modelo de 8B con el diseño de Llama 3.1 almacena unos 0,13 MB de caché por token en precisión completa, así que una conversación de 8.000 tokens suma aproximadamente 1 GB, y un contexto de 32.000 tokens suma unos 4 GB. Los modelos más grandes almacenan más por token. La mayoría de los motores también pueden cuantizar la caché, reduciéndola a la mitad o a la cuarta parte con un pequeño coste de calidad. Regla práctica: añade 1–2 GB sobre los pesos para un chat normal, y 4 GB o más si piensas darle al modelo documentos largos.
¿Qué cabe en tu tarjeta gráfica?
«Cabe» aquí significa que todo el modelo permanece en la GPU con un contexto de chat normal: la configuración rápida. Las tarjetas nombradas son ejemplos de cada nivel (una RTX 3060 tiene 12 GB, una RTX 4060 tiene 8 GB, y una RTX 4090 y una RX 7900 XTX tienen 24 GB).
| Tu VRAM | La configuración completa en GPU más grande y cómoda |
|---|---|
| 4–6 GB | Un modelo de 3B en Q4_K_M; uno de 8B solo con capas descargadas a la RAM |
| 8 GB | Un modelo de 8B en Q4_K_M: el punto óptimo de entrada |
| 12 GB | Un modelo de 8B en Q8_0, o uno de 14B en Q4_K_M |
| 16 GB | Un modelo de 14B en Q8_0, o gpt-oss-20b en su MXFP4 nativo |
| 24 GB | Un modelo de 32B en Q4_K_M, con margen para un contexto largo |
| 32 GB | Un modelo de 32B en Q8_0, o uno de 70B con una cuantización baja de clase 3 bits |
| 48 GB | Un modelo de 70B en Q4_K_M, por completo en la GPU |
| 80 GB | gpt-oss-120b, o un modelo de 70B en Q8_0 |
Ejemplo práctico: una tarjeta de 8 GB, paso a paso
Tomemos un equipo de sobremesa con una RTX 4060 (8 GB). Descargas un modelo de 8B en Q4_K_M: el archivo pesa 4,9 GB. Lo cargas en llama.cpp o en Ollama con un contexto de 8.000 tokens: la caché KV suma alrededor de 1 GB y los búferes unos cientos de MB; en total, unos 6,3 GB, con un margen cómodo en la tarjeta. El mismo modelo en Q8_0 (un archivo de 8,5 GB) no cabe por completo, así que el motor descarga algunas capas a la RAM del sistema y la generación se vuelve notablemente más lenta. Esa es exactamente la decisión para la que existe esta página: elige la cuantización que cabe, no el archivo más grande.
¿Sin tarjeta gráfica? La ruta solo con CPU
Todo lo anterior se lee igual sustituyendo VRAM por RAM del sistema: el archivo del modelo vive en la RAM. Una ejecución con CPU de un modelo de 8B en Q4_K_M necesita los mismos ~5 GB de RAM para los pesos, más espacio para el sistema operativo: 16 GB de RAM total es viable, y 32 GB es cómodo y también cubre un modelo de 14B en Q4_K_M. La velocidad la marca el ancho de banda de memoria, no el número de núcleos: espera una cifra de un solo dígito de tokens por segundo con una CPU de sobremesa típica en un modelo de 8B: suficiente para resúmenes, trabajos por lotes y tareas nocturnas, pero lento para un chat en vivo. El modo híbrido busca el equilibrio: llama.cpp y KoboldCpp pueden mantener parte del modelo en una GPU pequeña y el resto en la RAM.
Apple Silicon: un único bloque de memoria
Los Mac con chips de la serie M comparten un único bloque de memoria entre la CPU y la GPU, así que la columna de VRAM pasa a ser la memoria total de tu Mac menos lo que necesitan macOS y tus aplicaciones: deja libre aproximadamente una cuarta parte. En la práctica: un Mac de 16 GB ejecuta bien un modelo de 8B en Q4_K_M y uno de 14B en Q4_K_M de forma ajustada; 32 GB ejecuta uno de 32B en Q4_K_M; 64 GB ejecuta uno de 70B en Q4_K_M; y un Mac de 128 GB es la configuración que alberga gpt-oss-120b. Aplicaciones de escritorio como Jan y GPT4All lo dejan todo en dos clics en macOS.
¿Qué motor deberías usar?
Una vez decidido el tamaño, el motor decide cómo se carga el modelo. La categoría LLM locales del catálogo cubre el campo; los puntos de partida habituales son llama.cpp (el motor GGUF sobre el que se construye la mayoría de herramientas, con el control más fino sobre la descarga y la caché), Ollama (modelos con un solo comando y una API), Jan y GPT4All (aplicaciones de escritorio, amables con la CPU), KoboldCpp (un ejecutable único pensado para configuraciones híbridas GPU/RAM), text-generation-webui (una interfaz web completa), WebLLM (se ejecuta en el navegador sobre WebGPU, dentro de los límites de memoria del navegador) y vLLM (para servir a muchos usuarios a la vez: otra apuesta, el rendimiento total por encima del ajuste doméstico). La página de cada proyecto indica sus propios requisitos documentados.
¿Cuánta VRAM necesito para un modelo de 8B?
Unos 5 GB en Q4_K_M, 8,5 GB en Q8_0 y 16 GB en FP16 para los pesos; añade aproximadamente 1–2 GB para la caché KV y los búferes en contextos de longitud de chat. Una tarjeta gráfica de 8 GB es el mínimo cómodo para la versión de 4 bits, y la configuración doméstica más habitual.
¿Son suficientes 8 GB de VRAM para ejecutar LLM locales?
Sí: es el punto de entrada estándar. Ejecuta modelos de 7–8B en Q4_K_M por completo en la GPU, y modelos más pequeños de 1–3B a 8 bits o en precisión completa. No basta para un modelo de 14B sin descargar algunas capas a la RAM del sistema, lo cual funciona pero va más lento.
¿Cuál es el modelo más grande que puedo ejecutar con 24 GB de VRAM?
Un modelo de 32B en Q4_K_M — unos 20 GB de pesos — cabe por completo, con espacio de sobra para un contexto largo. Un modelo de 70B en Q4_K_M (unos 43 GB) no cabe: necesita descarga parcial a la RAM, una cuantización menor o una segunda GPU.
¿Puedo ejecutar un LLM local sin GPU?
Sí. Con CPU, tu RAM del sistema hace el papel de la VRAM y se aplica la misma tabla de tamaños: un modelo de 8B en Q4_K_M necesita unos 5 GB de RAM para sus pesos. La generación es mucho más lenta, normalmente una cifra de un solo dígito de tokens por segundo para un modelo de 8B en una CPU de sobremesa, pero funciona, y a las tareas por lotes la espera les da igual.
¿Qué significa Q4_K_M?
Es un formato de cuantización de GGUF: los pesos se almacenan con unos 4 bits cada uno — unos 0,6 bytes por parámetro contando los factores de escala — y los tensores más sensibles se mantienen a mayor precisión (el esquema «K»; la «M» es el tamaño medio). Es el equilibrio estándar entre tamaño de archivo y calidad de respuesta para el hardware doméstico, y la columna por la que la mayoría de lectores debería guiarse.
¿Más VRAM hace que un modelo vaya más rápido?
No directamente. La VRAM decide qué cabe; la velocidad de generación viene del ancho de banda de memoria y de la capacidad de cálculo. La VRAM extra solo ayuda a la velocidad de forma indirecta: manteniendo todo el modelo, y un contexto más largo, en la GPU en lugar de desbordar a la RAM del sistema.
¿Cuánta memoria necesita gpt-oss-120b?
Sus pesos en MXFP4 rondan los 65 GB, así que está pensado para GPU de centro de datos de clase 80 GB, o para un Mac con 96 GB o más de memoria unificada. Su hermano menor, gpt-oss-20b (unos 14 GB de pesos), fue diseñado para ejecutarse en una sola tarjeta de 16 GB.
Cómo se calculan estas cifras
Los tamaños de archivo de la tabla son los tamaños GGUF publicados de modelos representativos de cada clase de tamaño (las familias Llama, Qwen, Mistral y Gemma), y la columna FP16 es simplemente el número de parámetros × 2 bytes. Los tamaños cuantizados siguen los bytes por peso de cada formato (Q8_0 ≈ 1,06; Q4_K_M ≈ 0,6; Q2_K ≈ 0,35 bytes por parámetro). Las cifras de la caché KV se calculan a partir de la arquitectura de Llama 3.1 8B: 32 capas, 8 cabezas KV y cabezas de 128 dimensiones. En esta página no se citan velocidades de referencia, porque la velocidad depende de tu hardware exacto, de los controladores y de la configuración del motor; cada proyecto del catálogo indica sus propios requisitos en su página. Si una cifra de aquí contradice la documentación de un proyecto, manda la documentación del proyecto: cuéntanoslo desde la página de contacto y lo corregiremos.
Véase también: Open-Source AI Statistics 2026, con datos del mismo catálogo verificado.