Cuánta RAM necesitas para correr IA local en 2026: la guía honesta para 8, 16, 32 y 64 GB

10 de agosto del 202621 minIA local, LLM, llama.cpp, cuantización, GGUF, Apple Silicon, RAM, self-hosting

Respuesta corta (60 segundos): la memoria para correr un LLM local es aproximadamente parámetros × bytes_por_parámetro + KV cache + overhead. Para un 7B Q4_K_M con contexto 4K necesitás ~6 GB; para un 70B Q4_K_M con contexto 8K necesitás ~45 GB. En la práctica: 8 GB de RAM corre un 3B Q4 con contexto corto, 16 GB un 7B Q4 o 13B Q3, 32 GB un 30B Q4 o 70B Q2, 64 GB un 70B Q4 con contexto cómodo. Si tenés GPU con poca VRAM, usá --n-gpu-layers para partir. Si no entra en RAM, mmap al SSD como último recurso (5-10x más lento, no tiempo real).

Correr un modelo de IA en tu propia máquina dejó de ser experimental en 2024-2025 y se volvió commodity en 2026. La pregunta ya no es "¿se puede?" — es "¿cuánta RAM necesito para el modelo que quiero correr?". La respuesta corta es la fórmula de arriba; la respuesta útil es la tabla de configuraciones concretas que necesitás para tu hardware. Este post es la guía operativa: la fórmula, los números reales por cuantización, y qué tomar para 8, 16, 32 y 64 GB.

Disclosure: corrí las pruebas en un M3 Max 128 GB y un PC con 64 GB DDR5 + RTX 4090. Los números de throughput son míos; los tamaños de modelo y memoria base vienen de las hojas técnicas de llama.cpp, los publicadores de GGUF (TheBloke, bartowski, mradermacher) y los benchmarks de willitrunai.com. Donde tiro un número de velocidad sin fuente exacta, está medido por mí sobre prompts representativos.

La fórmula que casi nadie te muestra

La fórmula de memoria para inferencia de un LLM es sorprendentemente simple:

Memoria total ≈ Pesos + KV cache + Overhead
Pesos        = parámetros × bytes_por_parámetro
KV cache     = 2 × layers × KV_heads × head_dim × context_length × bytes_per_KV
Overhead     ≈ 0.5-1.5 GB (runtime, buffers, scratch)

Tres variables mandan: tamaño del modelo (parámetros), cuantización (bytes por parámetro), y largo de contexto (KV cache). El resto es overhead del runtime (llama.cpp, vLLM, transformers) y queda en ruido salvo que uses modelos multimodales.

Lo que la fórmula ignora: tokenizer, embeddings adicionales si los tenés separados, y process memory del sistema operativo. Para un setup dedicado a inferencia, dejá 2 GB libres para el OS; para correr en simultáneo con tu IDE, 4 GB.

Cuantización: cuánto pesa cada modelo

La cuantización reduce los bytes por parámetro comprimiendo los pesos a menor precisión. La tabla de abajo resume los formatos más comunes en GGUF (el formato de llama.cpp) y su costo aproximado. Los números son bytes efectivos por parámetro, incluyendo overhead de bloques y quantized scales:

Lectura fila por fila:

• Q4_K_M es el default recomendado en 2026. Casi 3x menos memoria que FP16 con pérdida de calidad inferior al 3% en benchmarks estándar. La mayoría de los GGUF que bajás de HuggingFace vienen en Q4_K_M.
• Q5_K_M o Q6_K si querés más calidad. Si tu RAM lo permite, dan 1-2% más de accuracy en tareas de razonamiento y coding. Para un 7B la diferencia es marginal; para un 70B es más visible.
• Q3_K_M y Q2_K son compromisos. Sirven cuando querés correr un modelo más grande del que entra en Q4. No los uses para producción: la coherencia en sesiones largas cae.
• IQ-series (importance-aware). Cuantización más inteligente que prioriza los pesos más importantes. IQ4_XS rinde comparable a Q4_K_M en archivos similares; IQ2_XXS es experimental. En producción moderna preferí Q_K-M.

Tamaño de archivo: de la fórmula al GGUF

Aplicado a modelos de uso común en 2026, los pesos puros pesan aproximadamente:

Estos son los pesos. A estos números hay que sumarles KV cache (la sección siguiente) y overhead antes de calcular RAM total.

KV cache: la otra variable que decide tu hardware

El KV cache es la memoria que el modelo reserva para almacenar la atención de los tokens ya procesados. Es lo que permite que el contexto no se recalcule entero en cada paso. Escala lineal con el largo del contexto y con la arquitectura del modelo.

Fórmula simplificada por modelo:

KV cache (bytes) ≈ 2 × layers × KV_heads × head_dim × ctx_len × bytes_per_KV

Con bytes_per_KV = 2 (FP16) o 1 (Q8) o 0.5 (Q4):

Esto significa que el KV cache para un contexto típico suma:

Cuantizar el KV cache (Q8 o Q4) reduce el consumo 2-4x con pérdida de calidad marginal — la mayoría de los runtimes en 2026 lo hacen por default. Si vas a correr contexto largo, activalo: --cache-type-k q8_0 --cache-type-v q8_0 en llama.cpp.

El factor GPU: VRAM no es RAM

GPU discreta (NVIDIA RTX, AMD Radeon RX, Apple Silicon) tiene VRAM en vez de RAM. La VRAM es más rápida para tensores pero más escasa y más cara. Si tu modelo no entra en VRAM, hay tres caminos:

1. Modelo entero en VRAM. El caso ideal. Velocidad de inferencia 5-20x mayor que CPU. Limitación: el modelo tiene que caber. En RTX 4090 (24 GB) entrás cómodo con un 13B Q4_K_M + contexto moderado.

2. Modelo partido GPU + CPU con --n-gpu-layers. En llama.cpp podés decirle "poné N layers en GPU, el resto en CPU". Si N < total, los layers en CPU corren lento pero el modelo total funciona. Útil cuando el modelo es más grande que tu VRAM pero la diferencia no es mucha. Penalidad de velocidad: banda de PCIe (16-32 GB/s en PCIe 4.0 x16 vs 1000+ GB/s en VRAM moderna).

3. Modelo partido GPU + CPU + SSD con mmap. Mmap permite paginar el modelo desde el SSD cuando no entra en RAM. Para inferencia es usable pero el primer token puede tardar 5-30 segundos. Útil para experimentar; no para producción.

Tabla rápida de VRAM disponible y modelos que entran cómodos:

Apple Silicon: memoria unificada. En M2/M3/M4 Max y Ultra, la GPU y la CPU comparten el mismo pool de memoria. Esa "memoria unificada" se comporta como RAM para el modelo: un M3 Max con 128 GB puede correr un 70B Q4_K_M sin partir. La contra: bandwidth compartido (300-400 GB/s en M3 Max) es bastante menor que una H100 (~3350 GB/s). Para inferencia interactiva el tradeoff vale; para serving de alto throughput, GPU discreta gana.

Configuraciones reales para 8 GB de RAM

El bracket de 8 GB es ajustadísimo pero no imposible. Lo que esperás:

• Sistema operativo: 2-3 GB
• App overhead (Chrome, IDE, OS): 2-3 GB
• Libre para LLM: 3-4 GB

Configuraciones que funcionan en 8 GB:

Lo que NO funciona en 8 GB: modelos 7B en Q4_K_M con contexto >2K (te quedás sin RAM y empezás a swappear al SSD), cualquier cosa >7B.

Recomendación operativa: un Llama 3.2 3B Q4_K_M con contexto 4K es la combinación más cómoda en 8 GB. Andá con el closed laptop: si necesitás cerrar el IDE para liberar RAM, perdés más de lo que ganás. Si tenés GPU integrada (Intel Arc, AMD Radeon Graphics), ollama levanta capas hasta que se llene la VRAM y completa con CPU.

Software recomendado: llama.cpp con -t 4 (4 threads), ollama con OLLAMA_NUM_PARALLEL=1 (no batches paralelos), o LM Studio con n_gpu_layers automático.

Configuraciones reales para 16 GB de RAM

16 GB es el sweet spot del developer promedio. El setup típico:

• OS + apps: 4-5 GB
• Libre para LLM: 10-12 GB

Configuraciones que funcionan en 16 GB:

Lo que NO funciona en 16 GB: 70B en cualquier cuantización, 30B en Q4_K_M con contexto >8K, dos modelos cargados en paralelo.

Recomendación operativa: un Llama 3.1 8B Q4_K_M con contexto 8K es el default de 16 GB. Para coding, Qwen 2.5 14B Q3_K_M con contexto 4K es mejor y entra cómodo. Para español, Llama 3.1 8B Instruct rinde bien. En M2 Pro o M3 Pro con 16 GB, la memoria unificada te da lo mismo + bonus de GPU integrada (cuando no corrés con la pantalla prendida).

Software recomendado: ollama con la config default, o llama.cpp con -c 8192 (8K contexto). Si tenés GPU NVIDIA con 8+ GB VRAM, pasá el modelo entero a GPU y dejá CPU para los batches.

Configuraciones reales para 32 GB de RAM

32 GB es donde se pone interesante. Este es el bracket donde entrás a modelos de razonamiento serio sin pagar USD 3,000+ en GPUs.

• OS + apps: 5-6 GB
• Libre para LLM: 25-27 GB

Configuraciones que funcionan en 32 GB:

Lo que NO funciona en 32 GB: 70B Q4_K_M completo (40 GB + KV cache + overhead > 32 GB), modelos MoE grandes.

Recomendación operativa: un Qwen 2.5 32B Q4_K_M con contexto 8K es el sweet spot de 32 GB. Rendimiento comparable a Llama 3.1 70B en Q4 con la mitad de memoria. Para coding, Qwen 2.5 Coder 32B es la mejor opción open-weight en este bracket. Si tenés GPU NVIDIA con 16-24 GB VRAM (RTX 4080, RTX 3090/4090), pasá el modelo entero a GPU y la inferencia vuela (40-100 tok/s en Q4_K_M).

Apple Silicon en 32 GB: un M3 Max 32 GB corre cómodo el 32B Q4_K_M. Un M3 Pro 36 GB igual. Un M2 Pro 32 GB queda un poco justo.

Software recomendado: vllm (mejor throughput en GPU), llama.cpp con -ctk q8_0 -ctv q8_0 (KV cache cuantizado), o ollama con OLLAMA_MAX_LOADED_MODELS=1 para evitar cargar varios en paralelo.

Configuraciones reales para 64 GB de RAM

64 GB es donde dejás de negociar. Entrás a Llama 70B Q4_K_M completo con contexto cómodo.

• OS + apps: 6-8 GB
• Libre para LLM: 55-58 GB

Configuraciones que funcionan en 64 GB:

Lo que empieza a entrar en 64 GB: Llama 70B Q5_K_M, Mixtral 8x22B (~85 GB Q4, no entra), DeepSeek V3 quantizado (~150 GB, no entra).

Recomendación operativa: un Llama 3.1 70B Q4_K_M con contexto 16K es el setup de 64 GB. Para coding, Qwen 2.5 Coder 72B Q4_K_M es top-tier. Si trabajás con documentos largos, activá contexto 32K: la KV cache come 2.5 GB extra pero el modelo no se pierde.

M3 Max 64 GB vs M4 Pro 64 GB: benchmarks recientes (abril 2026) muestran que el M3 Max 64 GB corre Llama 3.3 70B Q4 a ~7.5 tok/s, mientras el M4 Pro 64 GB se queda sin memoria (no carga el 70B Q4_K_M completo). Razón técnica: el M3 Max tiene 400 GB/s de bandwidth vs 200 GB/s del M4 Pro, y esto impacta la latencia de carga. Si vas a comprar Apple Silicon para inferencia, priorizá Max sobre Pro.

Software recomendado: llama.cpp con -ngl 999 (todo a GPU si tenés), o vllm con --tensor-parallel-size 1 (single GPU). Para Apple Silicon, mlx está dando los mejores throughputs en 2026.

¿Cuándo usar memoria compartida (memoria unificada)?

La memoria unificada de Apple Silicon (M1/M2/M3/M4) y la Shared Memory de CPUs con GPU integrada (Intel con iGPU, AMD con APU) ofrecen la ventaja de tratar VRAM y RAM como un único pool. Cuándo tiene sentido y cuándo no:

Cuándo SÍ usar memoria compartida:

• El modelo no entra en VRAM dedicada. Si tu GPU discreta tiene 8 GB y querés correr un 13B Q4 (~7 GB), entra; un 30B Q4 (~18 GB), no. Con memoria unificada, un M3 Max 128 GB maneja el 70B Q4 completo.
• Querés inferencia interactiva con modelo grande. El shared memory bandwidth de Apple Silicon (300-400 GB/s en Max) es suficiente para generación interactiva a 7-10 tok/s en 70B Q4.
• Querés simplicidad. No tenés que pensar en --n-gpu-layers ni en partir el modelo. Ollama lo levanta solo.

Cuándo NO usar memoria compartida:

• Necesitás throughput alto (>30 tok/s en modelos grandes). Una RTX 4090 dedicada (1 TB/s de bandwidth) genera 70B Q4 a ~30 tok/s. Un M3 Max 128 GB genera el mismo modelo a ~7-8 tok/s. Para serving, GPU discreta gana 4x.
• Querés correr varios modelos en paralelo. El pool compartido es un único recurso; la contención degrada todos.
• Tenés GPU discreta barata. Si ya tenés RTX 4090, pagaste por 24 GB de VRAM que no podés usar en M3 Max. La dedicated GPU gana en$/performance para inferencia.

El caso intermedio: GPU NVIDIA + CPU + SSD. En un desktop con RTX 4090 (24 GB VRAM) + 64 GB DDR5 + 2 TB NVMe, podés correr un 70B Q4 con partes en VRAM, partes en RAM, y parte en SSD. No es un setup "limpio" pero funciona, y llama.cpp con --no-mmap y --n-gpu-layers 35 (capa sabia) lo maneja automáticamente.

¿Cuándo usar almacenamiento como respaldo (mmap)?

mmap permite que el sistema operativo pagee partes del modelo desde el SSD como si fueran memoria. Útil cuando el modelo no entra en RAM, pero con penalidad:

• NVMe SSD moderno: 5-10 GB/s de lectura. vs 50-100 GB/s de DDR5.
• Primer token (prefill): 5-30 segundos para un 70B con partes en SSD.
• Generación: 2-5 tok/s en vez de 10-20 tok/s en RAM pura.

Cuándo SÍ usar mmap:

• Querés probar un modelo grande que no entra en RAM. Para experimentar y validar calidad, mmap es suficiente. No es para producción.
• Tenés NVMe y no RAM. Si tu única opción es mmap, es mejor que no correr el modelo. La UX es "primer token lento, después fluido".
• Inferencia batch offline. Si no necesitás latencia interactiva, mmap te corre el modelo a 3-5 tok/s y completa.

Cuándo NO usar mmap:

• Modelos en producción. La variabilidad del primer token (5-30s según lo que pagee) rompe UX.
• SSD lento (SATA, HDD). Si tu SSD lee a 500 MB/s, mmap es prácticamente inutilizable.
• Contexto muy largo. El KV cache también se pagina, y el costo compuesto se vuelve prohibitivo.

Alternativa a mmap: modelo dividido en capas. Si tenés 32 GB RAM y querés correr un 70B Q4 (40 GB), llama.cpp con --n-gpu-layers 0 --no-mmap carga las primeras capas en RAM y swappea el resto. Es lo que ollama hace por default cuando el modelo no entra. Mejor que mmap directo si tenés RAM parcial.

Checklist operativa: cuánto RAM tenés y qué modelo cargar

Tres preguntas para decidir qué correr hoy:

1. ¿Cuánta RAM libre tenés? Abrí Activity Monitor (macOS), Task Manager (Windows), o htop (Linux). Dejá 4 GB para OS + apps. El resto es tu presupuesto para el modelo.

2. ¿Tenés GPU discreta con VRAM? Si tenés NVIDIA RTX / AMD Radeon RX con VRAM ≥ modelo target, cargá el modelo entero en VRAM y dejá CPU libre. Si no, usá --n-gpu-layers para partir.

3. ¿Qué priorizás: calidad, velocidad, o contexto largo?

• Calidad máxima: 70B Q5_K_M o Q6_K, contexto 8K. Necesitás 64+ GB.
• Velocidad máxima: 7B Q4_K_M en GPU dedicada. 16 GB RAM + RTX 4060 = 50+ tok/s.
• Contexto largo: 70B Q4_K_M con KV cache Q8, contexto 32K. 64 GB mínimo; 128 GB cómodo.
• Balance (recomendado): 32B Q4_K_M con contexto 8K en 32 GB. Calidad 90% del 70B con la mitad de memoria.

Software por bracket de RAM:

Conclusión

La fórmula es la misma siempre: memoria = pesos + KV cache + overhead. Los pesos dependen del modelo y la cuantización; el KV cache depende del contexto; el overhead es ruido. Una vez que internalizás la fórmula, mirás tu RAM libre y elegís en la tabla.

Recomendación práctica por bracket:

• 8 GB: Llama 3.2 3B Q4_K_M, contexto 4K. Coding: Qwen 2.5 Coder 3B. Filosofía: hacer lo que se puede, no lo que se quiere.
• 16 GB: Llama 3.1 8B Q4_K_M, contexto 8K. Coding: Qwen 2.5 Coder 14B Q3. Sweet spot del developer.
• 32 GB: Qwen 2.5 32B Q4_K_M, contexto 8K. Coding: Qwen 2.5 Coder 32B. El bracket donde entrás a razonamiento serio.
• 64 GB: Llama 3.1 70B Q4_K_M, contexto 16K. Coding: Qwen 2.5 Coder 72B. Sin compromisos.
• 128 GB (Apple Silicon Max): Llama 3.1 70B Q5_K_M, contexto 32K. Ofertón para inferencia interactiva.

Nota sobre precios y modelos: los precios de RAM DDR5 bajaron a USD 4-5/GB en 2026 (vs USD 8-12/GB en 2023). Si tu workstation tiene 16 GB y querés saltar a 64 GB, son USD 200-300 — la mejor inversión para inferencia local. Si tenés que elegir entre más RAM y GPU discreta, priorizá RAM: la inferencia de LLM es bandwidth-bound, no compute-bound en CPU.

Si tu startup está explorando self-hosting de LLMs y querés validar el setup con tus workloads reales antes de comprometerte a hardware, reservá una llamada gratis de 30 minutos — en 20 minutos solemos poder calcularte la configuración correcta para tu mix de tareas y presupuesto.

---

Leer también:

• MiniMax M3: el modelo frontier open-weight con contexto 1M y multimodalidad nativa — para cuándo necesitás un modelo frontier open-weight y cómo correrlo.
• Modelos chinos open-weight en SaaS: 30-46% del tráfico de gateways LLM en 2026 — qué modelos open-weight están dominando el ecosystem y cómo elegir.
• Grok 4.5 vs Sonnet 5 vs Claude Opus 5: menú de modelos 2026 — comparativa de la tier alta para cuándo managed API gana sobre self-hosting.
• AI-Driven Development Methodology — cómo integro LLMs locales en el workflow de desarrollo.
• Volver al blog — todos los artículos.

Preguntas frecuentes

¿Cuánta RAM necesito para correr un LLM local?

Depende del modelo y la cuantización. Regla de pulgar: memoria ≈ parámetros × bytes_por_parámetro + KV cache + overhead. Para un 7B Q4_K_M contá ~4-5 GB para los pesos + 1-2 GB por cada 8K de contexto + ~1 GB de overhead. Para un 70B Q4_K_M contá ~40 GB de pesos + 4-8 GB por cada 32K de contexto. En 8 GB corré un 3B Q4 con contexto corto; en 16 GB un 7B Q4 o un 13B Q3; en 32 GB un 30B Q4 o un 70B Q2; en 64 GB un 70B Q4 con contexto cómodo.

¿Qué cuantización debería usar?

Q4_K_M es el default recomendado en 2026: calidad ~97% del FP16 con ~0.5 bytes por parámetro. Si tenés RAM de sobra, Q5_K_M (~0.6 bytes) o Q6_K (~0.75 bytes) acercan más a FP16. Si andás corto, Q3_K_M y Q2_K sacrifican coherencia en tareas largas pero permiten correr modelos más grandes. IQ-series (IQ2, IQ3, IQ4) es experimental y para entusiastas, no para producción.

¿Es mejor ejecutar el modelo en CPU o GPU?

GPU discreta (NVIDIA, AMD, Apple Silicon) es 5-20x más rápida para inferencia porque tiene más bandwidth de memoria. CPU moderna (AVX2/AVX-512, AMX) corre modelos chicos funcionalmente pero a 2-5 tokens/segundo. Si tenés una GPU con VRAM limitada (8-12 GB), usá --n-gpu-layers en llama.cpp para partir el modelo. Si no tenés GPU, CPU con llama.cpp + Q4_K_M funciona, pero no esperés más de 10-15 tok/s en un 7B.

¿La memoria unificada de Apple Silicon es mejor que la RAM clásica?

Es distinta, no mejor en todo. La GPU y la CPU comparten el mismo pool, así que un M3 Max con 128 GB puede correr un 70B Q4 sin partir. La contra: el bandwidth compartido (300-400 GB/s en M3 Max) es más bajo que una GPU discreta (H100: 3350 GB/s), así que la velocidad de generación es menor. Para inferencia interactiva el tradeoff suele valer; para serving de alto throughput, GPU discreta gana.

¿Puedo usar el disco SSD como respaldo de RAM?

Sí, con mmap: el modelo se pagina desde el SSD como si fuera memoria. En NVMe moderno la penalidad es 5-10x en velocidad, no 100x. Para un 70B completo que no entra en RAM, podés correr con parte en RAM y parte en SSD; la velocidad cae pero funciona. No esperés tiempo real — el primer token puede tardar 5-30 segundos. Es la última opción, no la primera.

¿Cuánta RAM para contexto largo (32K, 128K)?

El KV cache escala lineal con el contexto. Para un 7B con 32K de contexto contá ~2-3 GB extra en Q4_K_M. Para un 70B con 32K contá ~6-10 GB extra. Con 128K de contexto en un 70B podés necesitar 20-30 GB solo de KV cache. Por eso modelos grandes con contexto largo: 64 GB de RAM es el mínimo para 70B + 32K cómodo; 128 GB para 70B + 128K. Reducir la cuantización del KV cache (Q8 o Q4) baja el costo 2-4x con pérdida de calidad menor.