Calculadora de VRAM para LLM: ¿puedo ejecutar este LLM en local?
Calcula cuánta memoria de GPU necesita un LLM local con tu cuantización y longitud de contexto, si cabe en tu GPU o tu Mac y a qué velocidad irá.
8,03B parámetros. Atención: 32 capas x 8 cabezas KV x 128 dim..
Oscuro: pesos · Azul: caché KV · Gris: sobrecarga. Aquí GB significa GiB (1024³ bytes), la unidad en la que se vende la memoria de las GPU.
| GPU / Mac | Utilizable | Veredicto | Velocidad est. |
|---|---|---|---|
| RTX 3060 12 GB 360 GB/s | 12 GB | Cabe | ~39 tok/s |
| RTX 4060 Ti 16 GB 288 GB/s | 16 GB | Cabe | ~31 tok/s |
| RTX 4070 Super 12 GB 504 GB/s | 12 GB | Cabe | ~55 tok/s |
| RTX 4080 Super 16 GB 736 GB/s | 16 GB | Cabe | ~80 tok/s |
| RTX 5080 16 GB 960 GB/s | 16 GB | Cabe | ~104 tok/s |
| RTX 3090 24 GB 936 GB/s | 24 GB | Cabe | ~102 tok/s |
| RTX 4090 24 GB 1008 GB/s | 24 GB | Cabe | ~110 tok/s |
| RTX 5090 32 GB 1792 GB/s | 32 GB | Cabe | ~195 tok/s |
| Radeon RX 7900 XTX 24 GB 960 GB/s | 24 GB | Cabe | ~104 tok/s |
| RTX 6000 Ada 48 GB 960 GB/s | 48 GB | Cabe | ~104 tok/s |
| A100 40 GB 1555 GB/s | 40 GB | Cabe | ~169 tok/s |
| A100 80 GB (SXM) 2039 GB/s | 80 GB | Cabe | ~222 tok/s |
| H100 80 GB (SXM) 3350 GB/s | 80 GB | Cabe | ~364 tok/s |
| H200 141 GB 4800 GB/s | 141 GB | Cabe | ~522 tok/s |
| Ryzen AI Max+ 395 (96 GB to GPU) 256 GB/s | 96 GB | Cabe | ~28 tok/s |
| Mac M2/M3/M4, 16 GB 100 GB/s | 10.7 GB | Cabe | ~11 tok/s |
| Mac M3/M4, 24 GB 120 GB/s | 16.1 GB | Cabe | ~13 tok/s |
| Mac M4 Pro, 48 GB 273 GB/s | 36 GB | Cabe | ~30 tok/s |
| Mac M4 Max, 64 GB 546 GB/s | 48 GB | Cabe | ~59 tok/s |
| Mac M4 Max, 128 GB 546 GB/s | 96 GB | Cabe | ~59 tok/s |
| Mac M2 Ultra, 192 GB 800 GB/s | 144 GB | Cabe | ~87 tok/s |
| Mac M3 Ultra, 512 GB 819 GB/s | 384 GB | Cabe | ~89 tok/s |
"Justo" significa a menos de un 10 % del límite: puede cargar, pero un navegador u otra aplicación pueden hacer que se pase. La velocidad es la de generación con un solo usuario, estimada como el 65 % del ancho de banda de memoria dividido entre los bytes leídos por token; el procesamiento del prompt es más rápido, y las cifras reales varían según el runtime. Apple Silicon puede dar a la GPU por defecto unos dos tercios (hasta 36 GB) o tres cuartos (con más memoria) de la RAM.
Se calcula en tu navegador. Nada de lo que introduces se envía a ningún sitio. Ver todas las herramientas gratis.
¿Encontraste un problema o algo que podría mejorar? Leemos todos los mensajes y lo arreglamos rápido.
Esta calculadora de VRAM para LLM responde a la pregunta “¿puedo ejecutar este LLM en local?” estimando la memoria que necesita un modelo en tu GPU o tu Mac: los pesos con la cuantización elegida, la caché KV para tu longitud de contexto y la sobrecarga del entorno de ejecución. Elige un modelo abierto popular o introduce un número de parámetros, escoge una cuantización como Q4_K_M y verás el total junto a un veredicto de cabe, justo o no cabe para tarjetas gráficas habituales y equipos con Apple Silicon, con una velocidad de generación aproximada para cada uno.
La mayoría de las estimaciones rápidas multiplican los parámetros por los bytes por peso y se quedan ahí, lo que se acerca con prompts cortos y falla mucho con los largos. Un modelo Llama 3.1 8B en Q4_K_M necesita unos 4.6 GB para los pesos, pero su caché KV pasa de 1 GB con un contexto de 8K a 16 GB con 128K. Los presets de esta página incluyen la disposición real de atención de cada modelo (cabezas de consulta agrupadas, ventanas deslizantes, la atención latente de DeepSeek), así que la caché KV se calcula como la reservan realmente llama.cpp y vLLM. Las fórmulas están explicadas más abajo y los cálculos tienen pruebas unitarias contrastadas con tamaños reales de archivos GGUF.
Cómo usarla
- Elige un modelo de la lista, o Personalizado para introducir un número de parámetros (y, para una caché KV exacta, los valores de capas, cabezas KV y dimensión de cabeza del config.json del modelo).
- Elige la cuantización que piensas descargar. Q4_K_M es el punto de partida habitual para los modelos GGUF en llama.cpp, Ollama y LM Studio.
- Indica la longitud de contexto que vas a usar realmente y el número de secuencias en paralelo (1 para chat personal, más para un servidor).
- Lee el total y el desglose, y después el veredicto para cada GPU o Mac. Justo significa a menos de un 10 % del límite.
- Si no cabe, prueba una cuantización menor, un contexto más corto, una caché KV en Q8_0 o un modelo con menos parámetros.
Preguntas frecuentes
¿Cuánta VRAM necesito para ejecutar un modelo de 8B?
Unos 6.5 GB para Llama 3.1 8B en Q4_K_M con un contexto de 8K: 4.6 GB de pesos, 1 GB de caché KV y menos de 1 GB de sobrecarga. Cabe en una GPU de 8 GB y holgadamente en una RTX 3060 de 12 GB. En FP16 el mismo modelo necesita unos 17 GB, lo que significa una tarjeta de 24 GB. La longitud de contexto importa: con el contexto completo de 128K, la caché KV ocupa por sí sola 16 GB.
¿Puedo ejecutar un modelo de 70B en una GPU de 24 GB?
No entero en la VRAM. Llama 3.3 70B en Q4_K_M necesita unos 40 GB para los pesos y unos 45 GB en total con un contexto de 8K; incluso Q2_K necesita unos 30 GB. Las opciones son dos GPU de 24 GB, una tarjeta de 48 GB, un Mac con 64 GB o más de memoria unificada, o descargar parte del modelo a la RAM del sistema, lo que funciona pero es varias veces más lento.
¿Qué es la caché KV y por qué crece con el contexto?
Durante la generación, el modelo guarda un vector de clave y otro de valor por cada token anterior en cada capa, para no recalcularlos con cada token nuevo. Su tamaño es 2 x capas x cabezas KV x dimensión de cabeza x longitud de contexto x bytes por valor. Para Llama 3.1 8B (32 capas, 8 cabezas KV, dimensión de cabeza 128, FP16) son 128 KB por token: 1 GB con 8K tokens y 16 GB con 128K. Los modelos con atención de consultas agrupadas, capas de ventana deslizante (Gemma) o atención latente (DeepSeek) necesitan mucho menos.
¿Qué cuantización debo usar?
Q4_K_M es el término medio estándar: alrededor de un tercio del tamaño en FP16 con una pequeña pérdida de calidad para la mayoría de los usos. Usa Q5_K_M o Q6_K si caben, Q8_0 cuando quieras resultados prácticamente idénticos al original, y evita Q3 y Q2 en modelos de menos de unos 30B de parámetros, donde la caída de calidad se nota. Un modelo más grande en Q4 suele superar a uno más pequeño en Q8 con el mismo tamaño de archivo.
¿Es mejor un Mac o una GPU NVIDIA para LLM locales?
Un Mac admite modelos más grandes; una GPU NVIDIA ejecuta más rápido los que caben. Apple Silicon comparte una única reserva de memoria entre CPU y GPU, así que un Mac de 128 GB puede cargar un modelo de 70B que ninguna tarjeta gráfica de consumo puede, pero su ancho de banda de memoria (546 GB/s en un M4 Max) es aproximadamente la mitad de los 1008 GB/s de una RTX 4090, y la velocidad de generación depende del ancho de banda. Por defecto, macOS deja que la GPU use unos dos tercios de la RAM en equipos de hasta 36 GB y unas tres cuartas partes en los mayores.
¿Qué precisión tiene la estimación de tokens por segundo?
Es una guía aproximada, normalmente con un margen de un 30 % para la generación de un solo usuario. Generar cada token implica leer de memoria una vez los pesos activos y la caché KV, así que la velocidad es aproximadamente el ancho de banda de memoria dividido entre los bytes por token; la herramienta supone que se alcanza el 65 % del ancho de banda máximo. El procesamiento del prompt depende del cómputo y es mucho más rápido, los modelos MoE añaden la sobrecarga del enrutamiento, y el entorno de ejecución, los controladores y los ajustes cambian las cifras reales.
Las fórmulas que usa esta calculadora
Memoria total = pesos del modelo + caché KV + sobrecarga del entorno de ejecución. Todos los tamaños están en GiB (1024³ bytes), que es la unidad en la que se vende la memoria de las GPU: una RTX 4090 de “24 GB” tiene 24 GiB.
Pesos = parámetros x bits por peso / 8. En las k-quants de GGUF, los bits por peso son valores efectivos medidos en archivos reales, porque cada tipo de cuantización mezcla precisiones entre tensores: Q8_0 8.5, Q6_K 6.57, Q5_K_M 5.70, Q4_K_M 4.89, IQ4_XS 4.43, Q3_K_M 4.00, Q2_K 3.17 (de los archivos GGUF de Llama 3.1 8B; los modelos más grandes salen hasta un 5 % más pequeños). AWQ y GPTQ usan pesos de 4 bits con una escala por cada 128 pesos (unos 4.16 bits) y mantienen los embeddings y la capa de salida en 16 bits; gpt-oss incluye los pesos de sus expertos en MXFP4 (4.25 bits) con la atención y los embeddings en BF16.
Caché KV = 2 x capas x cabezas KV x dimensión de cabeza x tokens x bytes por valor x secuencias en paralelo. La atención de consultas agrupadas es la razón de que kv_heads (8 en Llama 3 70B) sea mucho menor que el número de cabezas de atención (64). Las capas de ventana deslizante guardan como máximo su ventana (1024 tokens en Gemma 3, 128 en la mitad de las capas de gpt-oss). DeepSeek V3 y R1 guardan un latente de 576 valores por capa y por token en lugar de las claves y los valores completos. FP16 usa 2 bytes por valor, una caché Q8_0 unos 1.06 y Q4_0 unos 0.56.
Sobrecarga = 0.75 GiB + 3 % de los pesos, que cubre el contexto de CUDA o Metal y los búferes de cómputo. Los entornos de ejecución reales varían en unos cientos de megabytes. Velocidad = ancho de banda de memoria x 0.65 / (bytes de pesos activos + la caché KV de una secuencia).
Tamaños por cuantización de un vistazo
Solo los pesos, según esta calculadora, para Llama 3.1 8B y Llama 3.3 70B:
• FP16 / BF16: 15.0 GB y 131.5 GB
• Q8_0: 7.9 GB y 69.9 GB
• Q6_K: 6.1 GB y 54.0 GB
• Q5_K_M: 5.3 GB y 46.8 GB
• Q4_K_M: 4.6 GB y 40.2 GB
• Q3_K_M: 3.7 GB y 32.9 GB
• Q2_K: 3.0 GB y 26.1 GB
Suma la caché KV de tu contexto y alrededor de 1 GB de sobrecarga para saber lo que debe caber en la GPU.
Modelos de mezcla de expertos: la memoria de un modelo grande, la velocidad de uno pequeño
Un modelo de mezcla de expertos (MoE) como Qwen3 30B-A3B, Mixtral 8x7B, gpt-oss o DeepSeek R1 contiene muchas subredes expertas, pero solo usa unas pocas para cada token. Todas tienen que estar en memoria, así que la memoria depende del número total de parámetros. La velocidad depende de los parámetros activos, porque solo se leen esos pesos en cada token.
Por eso Qwen3 30B-A3B en Q4_K_M necesita unos 19 GB, la memoria de un modelo denso de 30B, pero genera texto a la velocidad de uno de 3B. Y también por eso los modelos MoE encajan bien en los Mac y en otros equipos con mucha memoria más lenta: la limitación es la capacidad, y el ancho de banda importa menos.
DeepSeek R1, con 671B de parámetros, es el caso extremo: unos 380 GB en Q4_K_M, más de lo que cabe en cualquier equipo de consumo, aunque solo tiene 37B de parámetros activos por token.
Herramientas gratis relacionadas
- Calculadora de costes de API de LLM — Compara el coste de tu carga de trabajo en más de 40 modelos, con caché, descuentos por lotes, tramos de contexto largo y tokens de razonamiento. Precios con fuente y fecha.
- Contador de tokens — Cuenta los tokens exactos de los modelos de OpenAI, estímalos para Claude, Gemini y Llama, consulta el coste y mira cómo se divide el texto en tokens.
- Calculadora de ROI de IA — Estima cuántas horas y cuánto dinero podría ahorrar cada año tu empresa automatizando una tarea repetitiva.