Ollama en 8 GB de RAM: qué modelos funcionan en 2026

Hai un laptop con 8 GB di RAM e vuoi eseguire l'IA localmente? Questo articolo è un'analisi: cosa funziona, cosa funziona a malapena, e cosa non vale nemmeno la pena scaricare. Senza illusioni, con modelli e comandi specifici per ogni attività. Se non hai ancora familiarità con Ollama, inizia con l'articolo introduttivo su cos'è Ollama e perché è necessario.

📚 Indice dell'articolo

• 📌 RAM e memoria disponibile
• 📌 Codice e sostituzione di Copilot
• 📌 Testo e modelli di chat
• 📌 Ragionamento e logica
• 📌 CPU vs GPU vs Apple Silicon
• 📌 Quantizzazione (Q4 vs Q8)
• 📌 Configurazione Ollama per 8 GB
• 📌 Cosa non funziona su 8 GB
• 📌 Test di velocità reali
• ❓ FAQ
• ✅ Conclusioni

🎯 Quanta RAM rimane effettivamente per il modello

Risposta breve: Con 8 GB di RAM, sono disponibili effettivamente 4-5 GB per il modello AI. Il resto viene preso dal sistema operativo, dal browser e dai processi di base. Questo determina la regola principale: su 8 GB, i modelli fino a 3-7B parametri in quantizzazione a 4 bit funzionano comodamente.

8 GB di RAM non sono 8 GB per il modello. Sono 8 GB meno il SO, meno Chrome, meno tutto quello che hai dimenticato di chiudere.

Prima di scegliere un modello, è necessario comprendere il budget di memoria effettivo. Ecco una tipica distribuzione su un sistema con 8 GB di RAM:

• ✔️ Sistema operativo: 1.5–2.5 GB (macOS è più vicino a 2.5, Windows - 2, Linux - 1.5)
• ✔️ Browser (5-10 schede): 1–2 GB
• ✔️ IDE (VS Code / IntelliJ): 0.5–1.5 GB
• ✔️ Processi in background: 0.3–0.5 GB

Resto per il modello: 3–5 GB.

Secondo LocalLLM.in, un modello da 7B parametri in quantizzazione Q4_K_M occupa circa 4-5 GB, più 1-2 GB per la cache KV e l'overhead di sistema. Ciò significa: un modello da 7B su 8 GB è possibile, ma al limite, ed è meglio chiudere tutto il superfluo.

Regola pratica per 8 GB:

• ✔️ Zona di comfort: modelli da 1-3B parametri (Q4_K_M) - rimane spazio per IDE e browser
• ✔️ Zona di lavoro: modelli da 7-8B parametri (Q4_K_M) - è necessario chiudere tutto il superfluo
• ❌ Zona rossa: modelli da 13B+ - blocchi garantiti o swap su disco

Conclusione: Prima di scegliere un modello, chiudi il browser, controlla ollama ps e guarda la memoria rimanente effettiva. Su 8 GB, ogni gigabyte vale oro.

🎯 Per il codice: quale modello sostituirà Copilot su 8 GB

Completamento automatico del codice Per il completamento automatico del codice su 8 GB, la migliore scelta nel 2026 è Qwen3.5:4b o Phi-4 Mini (3.8B) in quantizzazione Q4_K_M. Qwen3.5:4b è uscito a marzo 2026 e ha sostituito Qwen 2.5 Coder come raccomandazione principale: nativamente multimodale, modalità di pensiero e 256K di contesto, con la stessa richiesta di memoria di ~2.5 GB.

GitHub Copilot costa $10/mese. Un modello locale per il codice costa $0/mese e funziona offline. La domanda è solo quale modello funzionerà sul tuo hardware.

La codifica è un'attività in cui anche i modelli piccoli possono essere utili. Completamento automatico, generazione di funzioni, spiegazione del codice, scrittura di test: per questo non serve GPT-4, serve un modello veloce e preciso che capisca la sintassi.

Migliori modelli per il codice su 8 GB

1. Qwen3.5:4b (Q4_K_M) — ~2.5 GB RAM

Uscito il 2 marzo 2026 come parte della piccola serie Qwen3.5 (0.8B, 2B, 4B, 9B). Rispetto al predecessore Qwen 2.5 Coder 3B, è un salto di qualità con la stessa richiesta di memoria. Il modello è nativamente multimodale (testo, immagini, video), supporta la modalità di pensiero e il tool calling nativo, e la finestra di contesto di 256K token copre la maggior parte delle codebase reali. Licenza Apache 2.0 - gratuita per uso commerciale. Se la multimodalità non è necessaria e vuoi il massimo sui benchmark di codice, considera qwen3:4b (aprile 2026): secondo Ollama Library, Qwen3-4B per qualità delle risposte si avvicina a Qwen2.5-72B-Instruct con una dimensione di 2.5 GB.

ollama pull qwen3.5:4b
ollama run qwen3.5:4b "Scrivi una funzione di ordinamento di array in Python"

# Alternativa - codice puro, senza multimodalità
ollama pull qwen3:4b
ollama run qwen3:4b "Trova l'errore in questo codice Java: ..."

⚠️ Nota sulla modalità di pensiero: in Qwen3.5:4b la modalità di pensiero è disponibile tramite il comando /think nella chat di Ollama. Per il completamento automatico e risposte rapide, usa /no_think: il modello risponde due volte più velocemente senza perdita di qualità su compiti semplici.

2. Phi-4 Mini (3.8B) — ~2.3 GB RAM

Secondo SitePoint, Phi-4 Mini è uno dei pochi modelli che funziona comodamente su sistemi con 8 GB, producendo 15-20 token/sec su un MacBook Air M1 o un laptop Linux economico. Gestisce bene il completamento automatico, spiegazioni semplici e compiti di chat leggeri.

ollama pull phi4-mini
ollama run phi4-mini "Spiega la differenza tra HashMap e TreeMap in Java"

3. DeepSeek Coder 1.3B (Q4_K_M) — ~1 GB RAM

Il modello più leggero per il codice. Ideale per il completamento automatico in IDE: veloce, non appesantisce il sistema, può essere tenuto in esecuzione in background insieme a VS Code, browser e terminale. Se il compito principale è l'autocompletamento inline, e non una chat completa, questo modello è ancora attuale.

ollama pull deepseek-coder:1.3b
ollama run deepseek-coder:1.3b

Cosa scegliere?

• DeepSeek Coder 1.3B — completamento automatico in background, lavoro con browser aperto
• Qwen3.5:4b — generazione di funzioni, spiegazione del codice, analisi di screenshot UI
• Qwen3:4b — massimo sui compiti di codice senza multimodalità
• Phi-4 Mini — modello universale per codice e compiti di testo

Conclusione: Su 8 GB si può codificare con IA locale. Qwen3.5:4b è il maggiore aggiornamento in questa categoria negli ultimi mesi: stessa richiesta di memoria di Qwen 2.5 Coder 3B, ma modalità di pensiero, contesto 256K e multimodalità nativa inclusi. Non aspettarti la qualità di GPT-4, ma per il completamento automatico quotidiano, la generazione di boilerplate e le spiegazioni del codice, questo è più che sufficiente.

🎯 Per testo e comunicazione: chat, traduzione

Per compiti di testo Per compiti di testo su 8 GB, la scelta ottimale è Llama 3.2 3B per chat generale, Gemma 4 E4B per un equilibrio tra qualità e multimodalità, o Phi-4 Mini se è necessaria analisi e lavoro su CPU. Tutti e tre lasciano spazio per altro software e funzionano stabilmente senza aggiornamenti hardware.

Non ogni compito richiede GPT-4. Riassumere un testo, rispondere a una domanda, riassumere un articolo: con questo si occupa un modello che pesa meno di un film in 4K.

I compiti di testo sono la categoria più ampia: dalla semplice chat all'analisi di documenti e traduzione. Su 8 GB c'è molta scelta. Se hai già scaricato qwen3.5:4b dalla sezione precedente, gestisce bene anche i compiti di testo grazie alla multimodalità nativa e al contesto di 256K. Ma se cerchi una raccomandazione specializzata proprio per il testo, ecco un elenco aggiornato.

Migliori modelli per testo su 8 GB

1. Llama 3.2 3B (Q4_K_M) — ~2 GB RAM

Secondo StudyHUB, Llama 3.1/3.2 è il modello più popolare su Ollama con oltre 111 milioni di download. La versione 3B è alleggerita, ma mantiene la qualità nelle conversazioni generali, riassunti e risposte a domande. Supporta 8 lingue. Il piccolo Llama 4 Scout, uscito nel 2026, è un modello MoE da 17B parametri attivi, quindi non è adatto per 8 GB, motivo per cui Llama 3.2 3B rimane la scelta migliore nella famiglia.

ollama pull llama3.2:3b
ollama run llama3.2:3b "Riassumi il punto principale di questo testo: ..."

2. Gemma 4 E4B (Q4_K_M) — ~3 GB RAM

Modello di Google DeepMind, uscito nell'aprile 2026. A differenza del vecchio Gemma 2B, è un modello multimodale completo: accetta testo e immagini, ha una modalità di pensiero per compiti più complessi e una finestra di contesto di 128K. Allo stesso tempo, si adatta comodamente a 8 GB, lasciando spazio per IDE e browser. Se in precedenza utilizzavi gemma:2b, E4B è un sostituto diretto con qualità sostanzialmente migliore. Maggiori dettagli sull'architettura e le dimensioni dei modelli sono nell'articolo Gemma 4: panoramica completa - dimensioni, licenza, confronto con Gemma 3.

ollama pull gemma4:e4b
ollama run gemma4:e4b "Scrivi una breve descrizione per questo prodotto: ..."

⚠️ Nota: se hai bisogno del minimo assoluto di RAM e il vecchio gemma:2b (~1.6 GB) ti andava bene, è ancora disponibile. Ma per nuove installazioni, consiglio subito E4B. La modalità di pensiero in Gemma 4 può essere attivata e disattivata: come funziona e quando disattivarla, leggi nell'articolo Modalità di ragionamento in Gemma 4: come attivarla, quando è necessaria e quanto costa.

3. Phi-4 Mini (3.8B) — ~2.3 GB RAM

Secondo LocalAIMaster, Phi-4 Mini è uno dei pochi modelli da 3-4B che, secondo i risultati MMLU, si avvicina a Llama 3.1 8B, utilizzando il 40% in meno di memoria. La finestra di contesto di 128K token consente di analizzare documenti lunghi, un aggiornamento significativo rispetto a Phi-3 Mini. Secondo PromptQuorum, su CPU i7-12700 senza GPU, il modello produce 12 token/sec, la migliore prestazione tra gli scenari solo CPU nella sua classe. Adatto per Raspberry Pi 4/5 e qualsiasi laptop senza grafica discreta.

ollama pull phi4-mini
ollama run phi4-mini "Traduci in ucraino: The quick brown fox jumps over the lazy dog"

Cosa scegliere?

• ✔️ Chat generale e domande-risposte → Llama 3.2 3B
• ✔️ Multimodalità (testo + immagini) e migliore qualità → Gemma 4 E4B
• ✔️ Analisi, documenti lunghi e solo CPU → Phi-4 Mini
• ✔️ Un unico strumento per codice e testo → Qwen3.5:4b (vedi sezione precedente)

Conclusione: Per compiti di testo, 8 GB sono un territorio confortevole. I modelli da 2-4B funzionano velocemente, lasciano spazio per altri programmi e offrono una qualità sufficiente per la maggior parte delle esigenze quotidiane. Phi-4 Mini ha sostituito Phi-3 Mini come standard negli scenari solo CPU: migliore qualità, contesto 128K, stessa richiesta di memoria.

🎯 Per ragionamento, logica, debug del codice

Per compiti che richiedono pensiero passo dopo passo - matematica, problemi logici, debug di codice complesso - su 8 GB ci sono tre opzioni reali: DeepSeek R1 8B come classico modello "pensante", Qwen3:8b per ragionamento multilingue, e Phi-4 Mini Reasoning come opzione più leggera con chain-of-thought completo a soli ~2.3 GB di RAM.

Un modello normale risponde subito. Un modello di ragionamento pensa prima, passo dopo passo, e poi risponde. Come la differenza tra "rispondere a caso" e "calcolare su carta".

I modelli di ragionamento sono una categoria relativamente nuova. Funzionano secondo il principio chain-of-thought: suddividono il compito in passaggi, verificano i risultati intermedi, e solo dopo formano la risposta finale. Nel 2026 questa categoria si è ampliata notevolmente: la modalità di ragionamento è ora presente non solo nei modelli pesanti da 8B, ma anche nelle versioni compatte da 3-4B.

Cosa funziona su 8 GB

1. DeepSeek R1 8B (Q4_K_M) — ~5 GB RAM

Secondo StudyHUB, DeepSeek R1 è un modello "pensante", analogo a OpenAI o1. Su compiti di matematica, puzzle logici e ragionamento tecnico, fornisce risultati migliori di Llama 3.1 della stessa dimensione. Prima della risposta finale, genera passaggi di ragionamento visibili nei tag <think>, utile per il debug per capire perché il modello è arrivato a tale conclusione. Compromesso: risponde più lentamente e richiede quasi tutta la memoria disponibile su un sistema da 8 GB.

ollama pull deepseek-r1:8b
ollama run deepseek-r1:8b "Trova l'errore in questa query SQL: SELECT * FROM users WHERE id = '5' AND active = true GROUP HAVING count > 1"

⚠️ Importante: DeepSeek R1 8B occupa ~5 GB di RAM. Su un sistema da 8 GB, questo è al limite: è necessario chiudere browser, IDE e tutto il superfluo. Su macOS con memoria unificata funziona più stabilmente che su Windows con grafica integrata.

2. Qwen3:8b (Q4_K_M) — ~4.6 GB RAM

Secondo LocalLLM.in, Qwen3:8b è una forte alternativa per compiti di ragionamento, specialmente in matematica e scenari multilingue. Supporta la modalità di pensiero in Ollama: può essere attivata tramite /think e disattivata tramite /no_think direttamente in chat, senza riavviare il modello. Se prevedi un aggiornamento, qwen3.5:9b (marzo 2026) è costruito sulla stessa architettura, ma con RL migliorato e multimodalità nativa, con requisiti di RAM simili.

ollama pull qwen3:8b
ollama run qwen3:8b "Risolvi: se 3x + 7 = 22, quanto vale x?"

# Alternativa più recente con multimodalità
ollama pull qwen3.5:9b

3. Phi-4 Mini Reasoning (3.8B) — ~2.3 GB RAM

Variante di ragionamento specializzata di Microsoft, disponibile in Ollama come phi4-mini-reasoning. Secondo Morph, è l'unico modello di ragionamento completo per 8 GB che lascia spazio per il lavoro parallelo di IDE e browser. Sviluppato appositamente per la risoluzione multi-passo di problemi matematici in ambienti con memoria limitata: calcoli simbolici, dimostrazioni formali, condizioni testuali complesse. A differenza di DeepSeek R1 8B, occupa metà della memoria e lascia il sistema reattivo. Su compiti complessi è inferiore ai modelli da 8B, ma per il debug e l'analisi quotidiana è sufficiente.

ollama pull phi4-mini-reasoning
ollama run phi4-mini-reasoning "Trova la complessità dell'algoritmo e spiega passo dopo passo: ..."

Cosa scegliere?

• ✔️ Debug del codice e problemi logici → DeepSeek R1 8B
• ✔️ Matematica e ragionamento multilingue → Qwen3:8b o Qwen3.5:9b
• ✔️ Ragionamento con IDE e browser aperti → Phi-4 Mini Reasoning (~2.3 GB, chain-of-thought completo)

Conclusione: Il ragionamento su 8 GB nel 2026 non è più solo "al limite del comfort". Phi-4 Mini Reasoning consente di ottenere un pensiero passo dopo passo con ~2.3 GB di RAM, senza dover chiudere tutto il superfluo. Per compiti più complessi, DeepSeek R1 8B e Qwen3:8b rimangono lo standard, ma richiedono quasi tutta la memoria disponibile. Se prevedi di lavorare regolarmente con compiti di ragionamento pesanti, un aggiornamento a 16 GB aprirà l'accesso alla classe 14B, dove la differenza di qualità è già sostanziale.

🎯 CPU vs GPU vs Apple Silicon — donde 8 GB significan cosas distintas

8 GB en un Mac M1 y 8 GB en un portátil Windows con Intel ofrecen experiencias completamente diferentes. Apple Silicon utiliza memoria unificada (unified memory), donde toda la memoria está disponible para la CPU y la GPU simultáneamente. En un PC convencional, la RAM y la VRAM son grupos separados, y para los modelos de IA, esto es crítico.

Un Mac M1 con 8 GB es una estación de trabajo totalmente capaz para IA local. Un portátil Windows con 8 GB e Intel HD Graphics es una lucha por cada megabyte.

Apple Silicon (M1/M2/M3/M4) — el mejor escenario para 8 GB

En Apple Silicon, toda la memoria operativa es memoria unificada. Esto significa que la parte de la GPU del chip tiene acceso a los mismos 8 GB que la CPU. Ollama utiliza automáticamente Metal para la aceleración — sin configuraciones adicionales.

Resultado: un modelo 7B en Q4_K_M en un M1 con 8 GB genera 15–20 tokens/seg — suficiente para un uso interactivo cómodo. Según los datos de SitePoint, Phi-4 Mini en un MacBook Air M1 alcanza aproximadamente 15–20 tok/s, lo que basta para el trabajo diario.

⚠️ Nota sobre MLX: En marzo de 2026, Ollama 0.19 cambió al backend MLX de Apple, que ofrece hasta 2x de aumento de velocidad en Apple Silicon. Sin embargo, según datos de RunAIHome, MLX actualmente requiere un mínimo de 32 GB de memoria unificada; los Mac con 8 GB y 16 GB permanecen en el backend Metal anterior sin cambios en la velocidad. Si planeas actualizar a un Mac con 32 GB+ — MLX será una mejora notable. Si te mantienes con 8 GB — las cifras de la tabla inferior siguen vigentes.

Windows / Linux con GPU dedicada (RTX 3060, RTX 4060) — buen escenario

Si tienes una tarjeta gráfica dedicada con 6–8 GB de VRAM, el modelo se carga completamente en la memoria de la GPU, y la RAM del sistema queda libre para el SO y el software. Según datos de LocalLLM.in, en una RTX 4060 (8 GB VRAM), un modelo 7B genera más de 40 tokens/seg — la opción más rápida de todas.

Windows / Linux sin GPU (Intel HD / AMD Radeon iGPU) — escenario complejo

Sin una GPU dedicada, el modelo trabaja completamente en la CPU. Ollama se ejecutará igual, pero la velocidad cae a 3–6 tokens/seg para modelos 7B. Para modelos más ligeros de 3B (Phi-4 Mini, Llama 3.2 3B), la velocidad real en una CPU moderna es de 10–12 tok/s — totalmente aceptable para tareas diarias. Según datos de LocalLLM.in, la inferencia solo con CPU es aceptable para tareas por lotes, pero resulta frustrante para el uso interactivo con modelos grandes.

Además, la RAM del sistema se comparte entre el SO, el software y el modelo — en 8 GB es un espacio muy reducido.

Tabla resumen

Conclusión: Si tienes un Mac M1+ con 8 GB, estás en la mejor posición para la IA local con hardware de presupuesto. El nuevo backend MLX de Ollama ofrece una mejora de 2x, pero por ahora requiere 32 GB+; para los Mac de 8 GB, la velocidad sigue siendo la misma. Si usas Windows sin GPU, enfócate en modelos 3B: dan 10–12 tok/s en la CPU y mantienen el sistema receptivo. Más detalles sobre la instalación en diferentes sistemas operativos — en el artículo Cómo instalar Ollama en Mac, Windows y Linux.

🎯 Cuantización en términos sencillos: Q4 vs Q8 y qué elegir en hardware débil

Respuesta corta: La cuantización es la compresión de un modelo, lo que reduce su tamaño de 2 a 4 veces con una pérdida mínima de calidad. En 8 GB, la opción óptima es Q4_K_M: el mejor equilibrio entre tamaño, velocidad y calidad de respuesta.

La cuantización es como el JPEG para las fotos. El archivo es más pequeño, la diferencia apenas se nota. Pero si comprimes demasiado, la calidad caerá notablemente.

Cuando veas etiquetas en el nombre de un modelo en Ollama como :7b-q4_0, :8b-instruct-q8_0 o :3b-q4_k_m — esto denota el nivel de cuantización. El número después de «q» es la cantidad de bits por parámetro.

Niveles de cuantización: qué significan las etiquetas

• ✔️ Q8 (8-bits): máxima calidad, mayor tamaño. Para un modelo 7B — ~8 GB. No cabe en 8 GB de RAM.
• ✔️ Q5_K_M (5-bits): variante intermedia entre Q4 y Q8. Para un 7B — ~5.5 GB. Adecuado para 8 GB de RAM solo si hay una GPU con 6–8 GB de VRAM y se necesita mayor precisión.
• ✔️ Q4_K_M (4-bits, K-quant medium): equilibrio óptimo. Para un 7B — ~4–5 GB. Recomendado para sistemas de 8 GB.
• ✔️ Q4_K_S (4-bits, K-quant small): un poco más pequeño que Q4_K_M, calidad ligeramente inferior.
• ✔️ IQ4_XS (importance matrix, 4-bits): formato más nuevo de 2025–2026. Según datos de RunAIHome, ofrece casi la misma calidad que Q4_K_M, pero ocupa ~400 MB menos para un modelo 8B. Útil cuando Q4_K_M apenas cabe. Disponible como etiqueta en Hugging Face, no siempre presente en la biblioteca de Ollama.
• ⚠️ Q2_K (2-bits): tamaño mínimo (~2.5 GB para 7B), pero degradación notable de la calidad. Opción extrema.

El sufijo «K» significa métodos de cuantización más nuevos (K-quant), que distribuyen la precisión de forma más inteligente entre las capas del modelo. Las etiquetas K-quant son siempre mejores que las variantes legacy (q4_0, q4_1) con el mismo tamaño.

Cuánto pesan los modelos de diferentes cuantizaciones

Datos según LocalAIMaster y RunAIHome.

Regla para 8 GB: elige siempre Q4_K_M. Si no cabe — reduce el tamaño del modelo (3B en lugar de 7B), no el nivel de cuantización (Q2 en lugar de Q4). Un modelo más pequeño con Q4 dará mejor calidad que uno más grande con Q2. Excepción: si Q4_K_M literalmente no cabe por 100–400 MB — prueba IQ4_XS, si esa etiqueta existe para el modelo deseado en Hugging Face.

Más detalles sobre técnicas de compresión y su impacto en la calidad — en el artículo Cuantización de modelos: INT4, INT8 — qué es y cómo influye en la calidad.

Conclusión: Q4_K_M es el estándar de oro para 8 GB y en 2026 esto no ha cambiado. No cedas a la tentación de descargar Q8 «por calidad» — el modelo no entrará en memoria y obtendrás intercambio (swap) a disco. La única opción nueva en el horizonte es IQ4_XS: tamaño un poco menor manteniendo la calidad, pero por ahora no para todos los modelos.

🎯 Configuración de Ollama para el máximo rendimiento en hardware débil

Cinco variables de entorno y un hábito (cerrar lo innecesario) — es todo lo que necesitas para exprimir al máximo tus 8 GB. La configuración toma un minuto, pero la diferencia en estabilidad es notable.

En hardware potente, Ollama «simplemente funciona». En hardware débil, hay que ayudarle a no malgastar memoria en cosas que no necesitas.

Por defecto, Ollama puede mantener varios modelos en memoria simultáneamente y procesar solicitudes paralelas. En 8 GB esto es un lujo innecesario. Aquí tienes el conjunto mínimo de optimizaciones:

Variables de entorno básicas

# Mantener solo un modelo en memoria (por defecto puede haber más)
export OLLAMA_MAX_LOADED_MODELS=1

# Una solicitud paralela (sin competencia por memoria)
export OLLAMA_NUM_PARALLEL=1

# Reducir la ventana de contexto — ahorra 200–800 MB de RAM
export OLLAMA_CTX_SIZE=2048

Nuevas variables para GPU / Apple Silicon (Ollama 0.19+)

Si ejecutas Ollama en GPU (NVIDIA, AMD) o Apple Silicon (M1+) — establece adicionalmente estas dos variables. Reducen el KV-cache a la mitad sin una pérdida notable de calidad para la mayoría de las tareas.

# Flash Attention — requisito previo obligatorio para la cuantización de KV-cache
export OLLAMA_FLASH_ATTENTION=1

# KV-cache en 8-bits — el doble de RAM libre para el caché con mínima pérdida de calidad
export OLLAMA_KV_CACHE_TYPE=q8_0

⚠️ Importante: según datos de ModelPiper, OLLAMA_KV_CACHE_TYPE solo funciona si está activado OLLAMA_FLASH_ATTENTION=1 — sin él, la variable se ignora. Para sistemas solo con CPU, estas dos variables no tendrán efecto. En Apple Silicon, el backend Metal (Mac de 8 GB) puede generar una ralentización del 5–10% en la generación, pero una estabilidad significativamente mejor en contextos largos.

En macOS / Linux, añade todas las líneas a ~/.zshrc o ~/.bashrc. En Windows — configúralas a través de las variables de entorno del sistema o el perfil de PowerShell.

Antes de ejecutar el modelo

Suena banal, pero en 8 GB es crítico:

• ✔️ Cierra el navegador o deja máximo 2–3 pestañas
• ✔️ Cierra Slack, Discord, Spotify — cada programa consume 200–500 MB
• ✔️ Verifica el uso actual: ollama ps mostrará los modelos cargados
• ✔️ Si el modelo anterior sigue en memoria — ollama stop nombre_del_modelo

Modelfile para ajuste fino

Si quieres más control — crea un Modelfile con parámetros optimizados:

FROM phi4-mini
PARAMETER num_ctx 2048
PARAMETER num_thread 4
PARAMETER temperature 0.7

num_ctx 2048 — reduce la ventana de contexto (menos RAM para KV-cache). num_thread 4 — limita la cantidad de hilos de CPU para que el sistema permanezca receptivo.

Guía paso a paso sobre la instalación y primera ejecución — en el artículo Cómo instalar Ollama en Mac, Windows y Linux: guía completa 2026.

Conclusión: Tres variables básicas + cerrar programas innecesarios = trabajo estable en 8 GB. Si tienes GPU o Apple Silicon — añade OLLAMA_FLASH_ATTENTION=1 y OLLAMA_KV_CACHE_TYPE=q8_0: según la documentación oficial de Ollama, esto reduce a la mitad el consumo de memoria para el KV-cache con una pérdida de calidad mínima. Sin la configuración básica, incluso un modelo ligero puede provocar intercambio (swap) a disco.

🎯 Lo que NO deberías intentar con 8 GB — mi experiencia

Respuesta corta: Modelos 13B+, cualquier modelo con cuantización Q8, e intentar ejecutar dos modelos simultáneamente — es una garantía de frustración en 8 GB. He probado esto en mi Mac M1 — para que tú no tengas que hacerlo.

Cualquiera que haya trabajado con Ollama en 8 GB ha pasado por lo mismo: "¿Y si el 13B entra al final?". No, no entrará. Ya lo probé.

Trabajando con Ollama en un Mac M1 con 8 GB de memoria unificada, probé decenas de modelos de diferentes tamaños. Aquí tienes una lista honesta de lo que no funciona — o funciona tan mal que sería mejor que no funcionara.

❌ Modelos 13B y superiores

Llama 3.3 13B, Qwen3 14B, CodeLlama 13B — incluso con cuantización Q4 requieren 8–9 GB solo para los pesos del modelo. Suma el KV-cache, el sistema operativo, y obtendrás un sistema que intercambia datos constantemente con el disco (swap). Intenté ejecutar Llama 3.1 13B Q4 — tardó 5 minutos en cargar, luego generaba 1–2 tokens por segundo con pausas constantes. Es inutilizable para uso interactivo.

❌ Cualquier modelo 7B con cuantización Q8

La versión Q8 de un modelo 7B pesa unos 8 GB — esto es toda tu memoria operativa. El SO no desaparece mágicamente. Probé Mistral 7B Q8 — el sistema se congeló un minuto después de iniciar. Usa siempre Q4_K_M para modelos 7B en sistemas de 8 GB.

❌ Dos modelos simultáneamente

Ollama puede mantener varios modelos en memoria. En 16 GB es útil — cambias entre modelos instantáneamente. En 8 GB es la receta perfecta para un "swap-storm" (tormenta de intercambio). Mantén OLLAMA_MAX_LOADED_MODELS=1 y no olvides ollama stop antes de cargar otro modelo.

❌ Ventanas de contexto grandes (8K+ tokens)

Cada duplicación de la ventana de contexto son cientos de megabytes adicionales para el KV-cache. En 8 GB, mantén el contexto en 2048–4096 tokens como máximo. No podrás pasarle a un modelo un documento de 10 páginas entero, tendrás que dividirlo en partes. Ayuda parcialmente usar OLLAMA_FLASH_ATTENTION=1 + OLLAMA_KV_CACHE_TYPE=q8_0 de la sección de configuración — reducen el KV-cache a la mitad y permiten trabajar con mayor seguridad en el nivel de 4096 tokens. Pero 8K+ en 8 GB sigue siendo zona de riesgo.

❌ Modelos MoE con gran huella de memoria (Mixtral, Llama 4 Scout, Qwen3.6)

La arquitectura MoE (Mixture of Experts) es engañosa por sus nombres. Mixtral 8x7B activa solo 2 de 8 "expertos" por token — pero los 8 deben estar en memoria simultáneamente, y eso son 26+ GB en Q4. Lo mismo ocurre con los nuevos modelos de 2026: Llama 4 Scout parece un "17B", pero realmente requiere ~10 GB en Q4 — por encima del límite de 8 GB. Qwen3.6 35B-A3B activa solo 3B de parámetros por token, pero mantiene en memoria todos los 35B — eso son 24 GB. La regla es simple: mira el tamaño total del modelo en la Ollama Library, no la cantidad de parámetros activos.

❌ Modo de pensamiento (Thinking mode) sin límite de contexto

Qwen3:8b, Qwen3.5:9b y Phi-4 Mini Reasoning generan "thinking tokens" antes de la respuesta final — a veces miles de tokens de razonamiento interno. En tareas complejas, la cadena de razonamiento (thinking chain) puede ocupar 2000–5000 tokens incluso antes de que el modelo comience a responder. Junto con un contexto grande, esto llena el KV-cache sin que te des cuenta: el modelo simplemente se ralentiza o empieza a usar el swap. Solución: mantén OLLAMA_CTX_SIZE=2048 y desactiva el modo de pensamiento con el comando /no_think para tareas simples, donde el razonamiento paso a paso no es necesario.

Regla general: si ollama run tarda más de 30 segundos en cargar y la primera respuesta llega después de un minuto — el modelo es demasiado grande para tu sistema. No esperes a que "caliente" — ciérralo y elige un modelo más pequeño.

Comparativa de modelos por tamaño, calidad y tareas — en el artículo Top 10 modelos de Ollama en 2026: cuál elegir.

Conclusión: Yo mismo pasé por esto — pensaba que un modelo más grande daría mejor resultado, descargué un 13B, esperé un minuto para la primera respuesta y lo borré. Instalé un 3B — y la productividad aumentó de inmediato. En 8 GB, la mejor estrategia es elegir un modelo que funcione rápido y estable, en lugar de sufrir con uno que "casi cabe". En 2026 se añadió otra trampa — el thinking mode: los nuevos modelos piensan en voz alta y consumen silenciosamente tu contexto incluso antes de la primera palabra de respuesta.

🎯 Pruebas: qué esperar en la práctica

Respuesta corta: En un Mac M1 de 8 GB, el modelo 3B produce 20-30 tokens/seg, y el modelo 7-9B, 10-15 tokens/seg. En Windows solo con CPU, es de dos a tres veces más lento para modelos grandes, pero los modelos 3B en CPUs modernas dan 10-12 tokens/seg, lo cual ya es cómodo. A continuación, una tabla resumen para orientación.

Los benchmarks en internet a menudo se realizan en un sistema limpio sin otro software. En la realidad, con VS Code abierto y 5 pestañas de Chrome, las cifras serán menores. Por eso, estas pruebas se acercan más a la realidad.

Tabla resumen de rendimiento

Los datos son orientativos, basados en los resultados de LocalLLM.in, SitePoint y LocalAIMaster. La velocidad real depende de la carga del sistema, el tamaño de la ventana de contexto y los procesos en segundo plano. Para GPU y Apple Silicon, activar OLLAMA_FLASH_ATTENTION=1 puede dar un impulso adicional en contextos largos.

¿Qué significan estas cifras en la práctica?

• ✔️ 15+ tok/s: chat interactivo cómodo: la respuesta aparece más rápido de lo que puedes leer
• ✔️ 8–15 tok/s: se puede trabajar, pero se nota un retraso en respuestas largas
• ⚠️ 3–6 tok/s: aceptable para tareas puntuales (depuración, análisis), frustrante en chat activo
• ❌ <3 tok/s: el modelo es demasiado grande para este sistema

Conclusión: Para el trabajo diario en 8 GB, enfócate en modelos de 3-4B: dan 20+ tok/s en Apple Silicon y 8-12 tok/s en CPU, manteniendo el sistema receptivo. Phi-4 Mini destaca con el mejor rendimiento en CPU de su clase (~12 tok/s), significativamente mejor que Phi-3 Mini, a la que reemplaza. Los modelos de 7-9B (Qwen3:8b, DeepSeek R1 8B) son para tareas específicas, cuando estás dispuesto a cerrar todo lo innecesario y esperar.

❓ Preguntas frecuentes (FAQ)

¿Se puede ejecutar Ollama en un portátil con 8 GB de RAM?

Sí. Los modelos de 1-4B parámetros (Phi-4 Mini, Llama 3.2 3B, Gemma 4 E4B) funcionan cómodamente en cualquier sistema con 8 GB. Los modelos de 7-9B funcionan al límite: es necesario cerrar programas innecesarios. Más detalles en la guía de instalación de Ollama.

¿Cuál es el mejor modelo para 8 GB de RAM?

Depende de la tarea. Para código: Qwen3.5:4b o Qwen3:4b. Para texto y chat: Llama 3.2 3B o Gemma 4 E4B. Para razonamiento y depuración: DeepSeek R1 8B (al límite de 8 GB) o Phi-4 Mini Reasoning (~2.3 GB, una versión más ligera con chain-of-thought). Una herramienta para todo: Qwen3.5:4b: multimodal, 256K de contexto, modo de pensamiento. Una comparación completa de modelos se encuentra en el artículo Top 10 modelos de Ollama en 2026.

¿Se necesita GPU para Ollama?

No, Ollama también funciona en CPU. Pero con GPU (discreta o Apple Silicon) la velocidad es 3-10 veces mayor. En un sistema solo con CPU y 8 GB, limítate a modelos de 3B o menos para un trabajo cómodo. Phi-4 Mini es la mejor opción para solo CPU: ~12 tok/s en un i7 moderno sin ninguna GPU.

¿Qué es mejor: un modelo 7B en Q2 o un 3B en Q4?

Casi siempre, un 3B en Q4. La cuantización agresiva (Q2) reduce significativamente la calidad de las respuestas, especialmente en tareas complejas. Un modelo más pequeño con cuantización normal dará un mejor resultado. Si Q4_K_M literalmente no cabe por unos cientos de MB, prueba IQ4_XS para el mismo modelo, si esa etiqueta existe en Hugging Face.

¿Puede Ollama en 8 GB reemplazar a ChatGPT?

Para tareas diarias: resumen, preguntas sencillas, generación de código, sí. Para multimodalidad básica (análisis de imágenes, capturas de pantalla), también: Gemma 4 E4B y Qwen3.5:4b aceptan imágenes directamente. Para análisis complejo de varios pasos, trabajo con contexto grande y tareas que requieren máxima precisión, los modelos en la nube son aún más potentes. El enfoque óptimo es híbrido: Ollama para tareas regulares, ChatGPT/Claude para las complejas. Más detalles en el artículo Ollama vs ChatGPT vs Claude: cuándo la IA local es mejor.

¿Cuánto espacio en disco se necesita?

Un modelo 3-4B en Q4 ocupa aproximadamente 2-2.5 GB en disco. Tres modelos para diferentes tareas: 6-8 GB. Ollama almacena los modelos en ~/.ollama, los modelos descargados se pueden eliminar con el comando ollama rm nombre_del_modelo.

¿Vale la pena actualizar a 16 GB?

Si planeas trabajar regularmente con IA local, definitivamente sí. 16 GB dan acceso a modelos de 13-14B, modelos de 7B completos en calidad Q8, trabajo cómodo con ventanas de contexto grandes y aceleración MLX en Ollama 0.19+ en Apple Silicon (actualmente requiere 32 GB+). La diferencia en capacidades entre 8 y 16 GB es la mayor en todo el espectro.

✅ Conclusiones

8 GB de RAM no son una sentencia para la IA local, pero es un límite que requiere decisiones conscientes. Lo principal:

• ✔️ Modelos 3-4B: zona de confort: Phi-4 Mini, Llama 3.2 3B, Qwen3.5:4b, Gemma 4 E4B funcionan rápido y estable, dejando espacio para IDE y navegador
• ✔️ Modelos 7-9B: zona de trabajo: DeepSeek R1 8B, Qwen3:8b funcionan al límite, pero dan una calidad notablemente mejor para tareas específicas
• ✔️ Q4_K_M: la única opción de cuantización sensata en 8 GB: un modelo más pequeño con Q4 siempre es mejor que uno más grande con Q2
• ✔️ Apple Silicon con 8 GB: la mejor opción económica: la memoria unificada da una ventaja sobre los sistemas solo con CPU
• ✔️ Modelos 13B+, Q8, dos modelos simultáneamente, modo de pensamiento sin límite de contexto: no vale la pena: probado, no funciona o es inestable

Yo mismo uso este enfoque: mantengo varios modelos para diferentes tareas: uno para código, otro para texto, uno aparte para depuración. Cada modelo tiene su punto fuerte, y en lugar de uno grande, que puede no caber en memoria, es mejor tener 2-3 ligeros especializados. Cambiar entre ellos a través de ollama run es cuestión de segundos.

Si recién empiezas, instala Ollama con nuestra guía, descarga phi4-mini y pruébalo. En cinco minutos tendrás una IA local funcionando, sin suscripciones, sin internet, sin envío de datos al exterior.

Y si necesitas un sitio web, blog o aplicación web con integración de funcionalidad de IA, escríbenos a WebsCraft, te ayudaremos a implementarlo.

📖 Fuentes

• Ollama Model Library — registro oficial de modelos
• Ollama — documentación oficial y FAQ — OLLAMA_FLASH_ATTENTION, OLLAMA_KV_CACHE_TYPE
• Ollama Blog — MLX en Apple Silicon (marzo de 2026)
• LocalLLM.in — Ollama VRAM Requirements: Complete 2026 Guide
• LocalLLM.in — Best Local LLMs for 8GB VRAM
• SitePoint — Best Local LLM Models 2026: Developer Comparison
• LocalAIMaster — Best Ollama Models 2026: 15 Ranked
• LocalAIMaster — Best AI Models for 8GB RAM in 2026
• LocalAIMaster — Ollama RAM & VRAM Calculator: Every Model
• LocalAIMaster — Phi-4 Mini: Microsoft's Best Small Model (3.8B)
• StudyHUB — Best Ollama Models in 2026: Top 10 Ranked
• ModelPiper — OLLAMA_KV_CACHE_TYPE: KV Cache Memory Optimization
• RunAIHome — Ollama MLX en Apple Silicon 2026: qué ha cambiado para la serie M
• Morph — Best Ollama Models: 12 Ranked for Coding, RAG & Agents (June 2026)