Girare modelli AI sul tuo hardware senza pagare abbonamenti, senza mandare dati in cloud, e senza aspettarti miracoli.
Da "ho sentito che posso girare ChatGPT a casa" a "so scegliere il modello giusto per quello che mi serve"
"Un modello locale che risponde in 30 secondi è meglio di nessun modello. A volte. Dipende."
No, non stai "girando ChatGPT". Ma qualcosa di interessante sì.
I modelli AI in cloud (ChatGPT, Claude, Gemini) sono come un ristorante stellato dove puoi ordinare quello che vuoi, il cuoco è fantastico, ma ogni piatto costa, devi fare la fila, e il cuoco sente tutto quello che dici al tavolo. L'IA locale è come avere un cuoco a casa: più lento, meno bravo sui piatti difficili, ma sempre disponibile, gratuito dopo l'investimento iniziale, e non riporta niente a nessuno. La scelta dipende da cosa cucini e quanto ti importa della privacy.
La GPU è tutto. La RAM è tutto. La CPU quasi non conta.
Un modello AI è fondamentalmente una moltiplicazione di matrici enormi. La GPU è progettata per fare esattamente questo in parallelo — migliaia di core piccoli invece di pochi core grossi. La VRAM (memoria della GPU) è il vero collo di bottiglia: il modello deve starci tutto dentro. Se il modello non ci sta in VRAM, finisce in RAM di sistema, che è 10-50x più lenta. Se non ci sta nemmeno lì, va su disco: a quel punto vai a fare una passeggiata mentre aspetti la risposta.
Regola pratica per stimare quanta VRAM serve un modello:
# Quantizzazione = riduzione della precisione per risparmiare memoria
# Q4 = 4 bit per parametro (~50% di un float16), qualità ok
# Q8 = 8 bit per parametro, qualità quasi identica al pieno
VRAM (GB) ≈ (parametri in miliardi) × (bit / 8) + ~2GB overhead
Llama 3.1 8B a Q4: 8 × 0.5 = ~5 GB VRAM # RTX 3060 12GB: ✓
Llama 3.1 8B a Q8: 8 × 1 = ~10 GB VRAM # RTX 3080 10GB: ✓ (giusto)
Mistral 7B a Q4: 7 × 0.5 = ~5 GB VRAM # GTX 1660 6GB: ✗ (troppo corta)
Llama 3 70B a Q4: 70 × 0.5 = ~38 GB VRAM # solo RTX 4090 o più GPU
Llama 3 70B a Q8: 70 × 1 = ~74 GB VRAM # server grade (A100, H100)
# Se il modello non sta in VRAM, Ollama usa la RAM di sistema (molto più lento)
# Velocità approssimativa: VRAM >> RAM >>> DiscoFunziona? Sì. È usabile? Dipende dalla tua soglia di dolore. Modelli piccoli (Phi-3 mini 3.8B, Gemma 2B) rispondono in 10-30 secondi su CPU decente. Utile per esperimentare.
Il sweet spot per cominciare seriamente. Llama 3.1 8B a Q4 ci sta comodamente. Risposte in 20-40 t/s: abbastanza fluido per uso quotidiano.
Qui si fa sul serio. La RTX 4090 con 24GB di VRAM è il riferimento per uso consumer-enthusiast. Puoi girare modelli da 13B a qualità piena o 34B quantizzati.
Due RTX 4090 = 48GB VRAM: Llama 70B a qualità piena. In alternativa: Mac Studio M2 Ultra con 192GB di memoria unificata copre qualsiasi cosa con la banda memoria del SoC. Non economico, ma impressionante.
| Hardware | Modello | Token/sec | Usabilità |
|---|---|---|---|
| CPU moderna (no GPU) | Phi-3 mini 3.8B Q4 | ~5-10 t/s | lento |
| RTX 3060 12GB | Llama 3.1 8B Q4 | ~35-50 t/s | ok |
| RTX 3090 24GB | Llama 3.1 8B Q8 | ~80-100 t/s | fluido |
| RTX 4090 24GB | Llama 3.1 8B Q8 | ~120-150 t/s | veloce |
| M3 Pro 36GB | Llama 3.1 8B Q8 | ~60-80 t/s | fluido |
| M3 Max 96GB | Llama 3.3 70B Q4 | ~25-35 t/s | ok |
| RTX 4090 (VRAM overflow in RAM) | Llama 3 70B Q4 | ~3-8 t/s | doloroso |
Per riferimento: leggere testo a schermo comodamente richiede ~15-20 t/s. Sotto quella soglia senti la latenza.
L'ecosistema open-weight cresce ogni settimana. Qui le scelte sensate.
Il riferimento open-weight per uso generale. Llama 3.1 8B è il punto di partenza perfetto: gira su hardware modesto, risponde in italiano discretamente, ottimo per coding e chat. Il 70B è significativamente migliore ma richiede hardware serio.
Il team francese ha prodotto modelli storicamente efficienti per le dimensioni. Mistral 7B è compatto e veloce. Mixtral 8×7B usa Mixture-of-Experts (attiva solo 2 expert per token): qualità da 47B con costi da 13B.
I modelli di Google per uso locale. Gemma 2 2B è eccezionale per le dimensioni: gira su qualsiasi cosa e batte modelli più grandi di altri in molti benchmark. Gemma 3 27B multimodale (testo + immagini).
La famiglia Qwen di Alibaba ha sorpreso tutti con qualità eccellente per le dimensioni e ottimo supporto multilingua (cinese + italiano molto buono). QwQ-32B è specializzato in ragionamento con risultati vicini ai top cloud su math/coding.
DeepSeek ha scosso il mercato con modelli che battono GPT-4 su coding a una frazione del costo. DeepSeek-R1 ragiona step-by-step come o1. La versione distillata 14B locale è impressionante. Nota: è cinese, valuta le implicazioni privacy.
Specializzato su coding, batte Llama e Mistral sul codice a pari dimensioni. Il 7B è ideale come modello di autocomplete locale (tipo Copilot ma privato). Il 32B è tra i migliori modelli locali per codice.
Microsoft ha dimostrato che dimensioni ridotte + dati di training curati = risultati notevoli. Phi-4 14B batte molti modelli più grandi su math e coding. Ottimo per chi ha hardware limitato ma vuole risultati decenti.
I pionieri del multimodale open-source. Descrivi immagini, fai domande su screenshot, analizza diagrammi. Non è al livello di GPT-4V ma funziona localmente.
Il modello multimodale locale più completo al momento. Analizza immagini, documenti, screenshot con qualità superiore ai predecessori. Richiede ~20GB VRAM a Q4.
Un comando per installare, uno per scaricare un modello, uno per usarlo. Fine.
Ollama è il Docker dei modelli AI. Come Docker astrae la complessità di far girare container, Ollama astrae la complessità di far girare modelli GGUF (il formato quantizzato). Gestisce il download, la quantizzazione, l'accelerazione GPU, il server HTTP, e l'interfaccia CLI. Tu scrivi ollama run llama3.1 e lui fa tutto il resto.
# macOS
brew install ollama
# oppure dal sito: curl -fsSL https://ollama.com/install.sh | sh
# Linux (una riga, fa tutto)
curl -fsSL https://ollama.com/install.sh | sh
# Windows: installer .exe da ollama.com
# Verifica che funzioni
ollama --version
ollama version is 0.x.x
# Ollama gira come servizio in background su :11434
ollama serve # solo se non parte in automatico# Scarica e avvia in chat interattiva
ollama run llama3.1 # 8B, ~5GB download
ollama run llama3.1:70b # 70B, ~40GB download
ollama run mistral # Mistral 7B
ollama run qwen2.5-coder:7b # per coding
ollama run deepseek-r1:14b # reasoning locale
ollama run phi4 # Microsoft Phi-4 14B
ollama run gemma3:27b # Google Gemma 3, multimodale
# Una domanda singola senza chat interattiva
ollama run llama3.1 "traduci in italiano: hello world"
# Lista modelli scaricati
ollama list
# Rimuovi un modello (libera spazio)
ollama rm mistral
# Vedi quanto VRAM/RAM sta usando
ollama psOllama espone un'API REST compatibile (in gran parte) con OpenAI. Qualsiasi app che parla con OpenAI può puntare a Ollama cambiando solo l'URL.
# Chiamata base all'API (endpoint /api/generate)
curl http://localhost:11434/api/generate \
-d '{"model":"llama3.1","prompt":"spiega kubernetes in 2 righe","stream":false}'
# Endpoint compatibile OpenAI (per drop-in replacement)
curl http://localhost:11434/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "llama3.1",
"messages": [{"role":"user","content":"ciao, come stai?"}]
}'
# Python con libreria ollama
pip install ollama
# client.py
import ollama
response = ollama.chat(model='llama3.1', messages=[
{'role': 'user', 'content': 'Spiega Docker in 3 righe'}
])
print(response['message']['content'])
# Oppure con libreria openai, cambiando solo base_url
from openai import OpenAI
client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
response = client.chat.completions.create(model="llama3.1", ...)Come il Dockerfile per i container, il Modelfile ti permette di creare versioni personalizzate di un modello con system prompt fissi, parametri custom, template diversi.
# Modelfile
FROM llama3.1
# Temperatura: 0.0 = deterministico, 1.0 = creativo
PARAMETER temperature 0.2
# Context window
PARAMETER num_ctx 8192
# System prompt fisso
SYSTEM """
Sei un assistente tecnico per sistemisti. Rispondi sempre in italiano.
Sii conciso e diretto. Se non sai qualcosa, dillo chiaramente.
Quando mostri comandi, usa blocchi di codice.
"""
# Crea il modello custom
ollama create mio-assistente -f Modelfile
ollama run mio-assistenteollama run hf.co/bartowski/Llama-3.1-8B-Instruct-GGUF. Se un modello non è nel registry ufficiale di Ollama, cercalo su Hugging Face con il tag GGUF.
Ollama è il motore. Questi sono i sedili, il volante e il cruscotto.
L'interfaccia grafica per chi vuole tutto incluso senza terminale. Scarica modelli da Hugging Face con una ricerca, li gestisce, li gira con un click, e include una chat integrata + server API. Disponibile per Mac, Windows, Linux.
Un'interfaccia web tipo ChatGPT da girare localmente sopra Ollama (o qualsiasi backend compatibile). Docker compose e sei operativo in 2 minuti. Features: chat con più modelli, gestione conversazioni, RAG integrato, image generation, multi-user.
docker run -d \
-p 3000:8080 \
--add-host=host.docker.internal:host-gateway \
-v open-webui:/app/backend/data \
--name open-webui \
ghcr.io/open-webui/open-webui:main
# Poi vai su http://localhost:3000La soluzione all-in-one per RAG (Retrieval Augmented Generation) locale. Carica PDF, Word, pagine web, codice — lui li indicizza e puoi farci domande. Supporta Ollama come backend, ha UI desktop e versione server. Ideale per "parla con i tuoi documenti" senza mandare niente in cloud.
Il progetto più "infrastrutturale": drop-in replacement dell'API OpenAI, supporta modelli GGUF, diffusion models, TTS, STT. Pensato per chi vuole sostituire OpenAI nelle proprie applicazioni senza toccare il codice. Più complesso da configurare ma più flessibile.
Plugin per VS Code e JetBrains che usa modelli locali (o cloud) come Copilot alternativo. Autocomplete, chat nel contesto del codice, refactoring, generazione di test. Con Ollama + qwen2.5-coder ottieni un Copilot privato gratuito.
{
"models": [{
"title": "Llama locale",
"provider": "ollama",
"model": "llama3.1"
}],
"tabAutocompleteModel": {
"title": "Qwen coder",
"provider": "ollama",
"model": "qwen2.5-coder:7b"
}
}Tool CLI di Simon Willison per interagire con qualsiasi LLM (locale e cloud) da terminale. Ottimo per scripting, pipe, automazioni. cat file.txt | llm "riassumi" è tutto quello che devi sapere per capire il potenziale.
pip install llm llm-ollama
llm install llm-ollama
# Usa modello ollama
llm -m ollama/llama3.1 "spiega il CAP theorem"
# Pipe dal terminale
git diff | llm -m ollama/llama3.1 "scrivi un commit message"
cat error.log | llm "cosa significa questo errore?"I task dove i modelli locali rendono bene. Aspettative realistiche incluse.
Autocomplete, spiegazione di codice, refactoring, docstring. Con un 8B decente: buono. Con 32B+: molto buono. Alternativa reale a Copilot per uso privato.
Fai domande su PDF, manuali, documentazione interna. Funziona bene se i documenti sono in italiano e le domande sono precise. Non è magia, è un motore di ricerca intelligente.
Riassumere testi lunghi, estrarre punti chiave, trasformare bullet point in testo. Task semplice dove anche 7B funziona bene.
EN→IT e IT→EN funzionano bene anche sui modelli piccoli. Lingue meno comuni: risultati variabili. Non al livello di DeepL ma accettabile per uso interno.
Categorizzare ticket di supporto, email, feedback. Ottimo caso d'uso per automazione: nessun dato esce, costo zero, basta un 7B.
Email, report, documentazione tecnica, YAML di configurazione. Dato un contesto chiaro, i modelli locali producono output utile anche in italiano.
Da testo non strutturato a JSON. "Estrai nome, data e importo da questa fattura" funziona sorprendentemente bene anche su 7B con un buon prompt.
FAQ aziendale, primo livello di supporto, assistente per documentazione interna. Combinato con RAG: soluzione utile e completamente privata.
Generare script bash/python per task ripetitivi, convertire comandi tra sistemi operativi, debug di regex. I coding model da 7B ci riescono spesso al primo colpo.
Un benchmark pratico e onesto di Llama 3.1 8B Q4 su hardware tipico (RTX 3060 12GB):
| Task | Qualità | Note |
|---|---|---|
| Spiegare codice esistente | buona | Molto utile, raramente sbaglia il senso |
| Scrivere funzione semplice | buona | Python/JS funzionano bene, assembly no |
| Scrivere funzione complessa | variabile | Spesso funziona, a volte inventa API che non esistono |
| Debug di errori | buona | Ottimo se gli dai l'errore completo + contesto |
| Riassumere documenti | buona | Affidabile, un po' meccanico |
| Ragionamento matematico | mediocre | Aritmetica ok, algebra/calcolo: ci sbaglia spesso |
| Ragionamento complesso multi-step | debole | Usa DeepSeek-R1 o i modelli cloud per questo |
| Rispondere in italiano corretto | accettabile | Si difende, qualche errore di concordanza |
| Generare codice sicuro | variabile | Sempre revisionare manualmente |
Le aspettative irrealistiche che uccidono i progetti locali.
Llama 70B è eccellente ma non è GPT-4o, e tantomeno Claude 3.5 Sonnet. Su benchmark standard ha un gap misurabile. Per molti task quotidiani non importa. Per task complessi, importa eccome.
Una RTX 3060 12GB è ottima per modelli fino a 8B. Per il 70B devi mettere la mano al portafoglio o usare l'architettura ibrida. Girare un 70B con overflow in RAM non è un'esperienza piacevole.
Probabilmente no, a meno che i tuoi task siano molto specifici e ben definiti. L'approccio più efficace è ibrido: locale per il 70-80% del lavoro di routine, cloud per il 20% che richiede qualità superiore.
I modelli open-weight sono addestrati prevalentemente in inglese. Rispondono in italiano ma commettono più errori, usano costruzioni anglicizzate, e a volte switching di lingua. Migliora con Qwen (ha più dati multilingua) ma non sparisce.
Non è locale vs cloud. È locale + cloud al posto giusto.
Immagina di avere un assistente locale sempre disponibile per le banalità quotidiane (rispondi a email semplici, trova info nel manuale, formatta questo CSV) e un consulente esterno che chiami quando hai bisogno di qualcosa di vero (strategia complessa, problema non banale, documento critico). Non mandi tutto al consulente perché costa. Non affidi tutto all'assistente perché sbaglia sui task difficili. Usi entrambi in modo intelligente.
| Criterio | Usa Locale | Usa Cloud |
|---|---|---|
| Dati | Dati sensibili, confidenziali, PII | Dati pubblici o non critici |
| Complessità | Task semplici e ripetitivi | Ragionamento complesso, multistep |
| Volume | Tante richieste, costo sarebbe alto | Poche richieste critiche |
| Latenza | Quando il delay è accettabile | Quando serve risposta rapida |
| Connettività | Offline, VPN aziendale rigida | Con internet disponibile |
| Lingua | Inglese o lingue con molti dati | Italiano di qualità, dialetti |
Uno strumento che espone un'unica API OpenAI-compatibile e smista le chiamate verso qualsiasi backend: Ollama locale, OpenAI, Anthropic, Gemini. Cambi il backend nel config, non nel codice.
model_list:
- model_name: fast-local
litellm_params:
model: ollama/llama3.1
api_base: http://localhost:11434
- model_name: smart-cloud
litellm_params:
model: claude-sonnet-4-6
api_key: sk-ant-...
- model_name: coding
litellm_params:
model: ollama/qwen2.5-coder:7b
api_base: http://localhost:11434
# La tua app chiama sempre localhost:4000
# LiteLLM smista in base al model sceltoUn pattern utile: prova prima il cloud (risultato migliore), in caso di errore/rate limit/offline usa il locale come fallback. Implementabile con qualsiasi SDK OpenAI-compatibile.
def ask(prompt, prefer_cloud=True):
if prefer_cloud:
try:
return openai_client.chat(prompt)
except (RateLimitError, APIError):
pass # fallback al locale
return ollama_client.chat(prompt)
# Oppure con LiteLLM fallback nativo:
completion(
model="claude-sonnet-4-6",
fallbacks=["ollama/llama3.1"],
messages=[...]
)Esempi concreti da implementare oggi, non ipotesi astratte.
Il caso d'uso più immediato: sostituire GitHub Copilot con un modello locale per il 90% dell'autocomplete quotidiano. Zero dati che escono, zero abbonamento.
ollama pull qwen2.5-coder:7b — è il miglior rapporto qualità/velocità per autocomplete.
Plugin per VS Code o JetBrains. È gratuito, open source. Configura il model provider come "Ollama" e il tab autocomplete model.
Nel config di Continue aggiungi Claude o GPT-4 per quando hai bisogno di ragionamento complesso. Tab = locale, chat = scegli tu.
Continue indicizza il tuo repo locale. Con @codebase nel prompt, il modello vede l'intero progetto. Domande tipo "come funziona il sistema di autenticazione in questo progetto" diventano utili.
Il caso d'uso killer per le aziende: "parla con i nostri manuali/procedure/contratti" senza mandare niente a OpenAI.
pip install langchain-community langchain-ollama chromadb pymupdf
# rag_locale.py
from langchain_community.document_loaders import PyMuPDFLoader
from langchain_ollama import OllamaEmbeddings, OllamaLLM
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain.chains import RetrievalQA
# 1. Carica i tuoi documenti
loader = PyMuPDFLoader("manuale_aziendale.pdf")
docs = loader.load()
# 2. Spezzali in chunk
splitter = RecursiveCharacterTextSplitter(chunk_size=500)
chunks = splitter.split_documents(docs)
# 3. Crea embeddings locali (nomic-embed-text)
embeddings = OllamaEmbeddings(model="nomic-embed-text")
db = Chroma.from_documents(chunks, embeddings, persist_directory="./db")
# 4. Fai domande
llm = OllamaLLM(model="llama3.1")
qa = RetrievalQA.from_chain_type(llm=llm, retriever=db.as_retriever())
risposta = qa.invoke("Qual è la procedura per le ferie?")
print(risposta["result"])
# Scarica anche il modello di embedding
ollama pull nomic-embed-textClassificare ticket di supporto, estrarre entità da email, taggare documenti. Con un 7B e lo stesso loop:
import ollama, json
def classifica(testo):
resp = ollama.chat(
model="llama3.1",
messages=[{
"role": "user",
"content": f"""Classifica questo ticket.
Rispondi SOLO con JSON valido.
Categorie: bug, feature, billing, other
Priorità: low, medium, high
Ticket: {testo}
Risposta JSON:"""
}],
format="json"
)
return json.loads(resp["message"]["content"])
print(classifica("Il login non funziona da stamattina"))
# → {"categoria": "bug", "priorità": "high"}Con modelli multimodali (LLaVA, Gemma 3) puoi analizzare screenshot, diagrammi, foto di errori — localmente.
# Scarica un modello con visione
ollama pull llava:13b
# oppure: ollama pull gemma3:27b (migliore)
import ollama, base64
with open("screenshot_errore.png", "rb") as f:
img = base64.b64encode(f.read()).decode()
resp = ollama.chat(
model="llava:13b",
messages=[{
"role": "user",
"content": "Cosa mostra questo screenshot? C'è qualche errore?",
"images": [img]
}]
)
print(resp["message"]["content"])Il motivo per cui molte aziende stanno guardando a questo con interesse.
Mandare prompt a un'API cloud significa (a seconda del fornitore e dei termini):
Codice proprietario, contratti, comunicazioni interne. L'IA locale è l'unica opzione sensata senza un accordo enterprise con il fornitore cloud.
HIPAA (USA), GDPR (EU): processare dati sanitari richiede accordi specifici. Locale elimina il problema alla radice.
Contratti, atti, comunicazioni avvocato-cliente. Molti ordini professionali vietano o limitano il cloud per questi dati.
I problemi che incontrerai quasi certamente. Con le soluzioni.
Causa probabile: il modello non sta in VRAM e sta girando su RAM di sistema (o disco).
Verifica: esegui ollama ps mentre il modello gira. Controlla la colonna "SIZE" e se dice "100% GPU" o meno.
Soluzioni:
1. Usa un modello più piccolo o più quantizzato: ollama pull llama3.1:8b-instruct-q4_K_M invece della versione Q8.
2. Su Linux/Windows con GPU NVIDIA: verifica che CUDA sia installato correttamente e che Ollama usi la GPU (nvidia-smi durante una generazione deve mostrare utilizzo GPU).
3. Chiudi altre applicazioni che usano VRAM (giochi, altre istanze di modelli).
4. Su macOS con Apple Silicon: Ollama usa automaticamente la memoria unificata, dovrebbe andare bene nativamente.
Su NVIDIA: verifica che CUDA Toolkit sia installato. nvidia-smi deve funzionare. Se Ollama non trova CUDA, usa la CPU come fallback silenzioso.
Su AMD (Linux): installa ROCm. Ollama supporta AMD su Linux tramite ROCm ma la configurazione è più complessa.
Su AMD (Windows): supporto parziale tramite DirectML. Risultati variabili, controlla le release notes di Ollama.
Su Intel Arc: supporto sperimentale tramite SYCL/oneAPI. Ancora acerbo.
I modelli tendono a rispondere nella lingua in cui sono stati addestrati prevalentemente (inglese). Per forzare l'italiano:
Soluzione 1 - System prompt: crea un Modelfile con SYSTEM "Rispondi sempre e solo in italiano. Non usare mai l'inglese."
Soluzione 2 - Nel prompt: inizia il prompt con "Rispondimi in italiano:" o terminalo con "(rispondi in italiano)".
Soluzione 3 - Cambia modello: Qwen2.5 e Qwen2.5-Coder hanno dati di training multilingua più bilanciati e si comportano meglio in italiano rispetto a Llama.
Realtà: su modelli piccoli (7B) il comportamento in italiano è meno affidabile. Con modelli da 14B+ migliora significativamente.
Le allucinazioni sono più frequenti sui modelli locali rispetto ai top cloud. Non spariscono mai completamente, ma si riducono con queste pratiche:
1. Fornisci il contesto: "Basandoti SOLO sul seguente testo, rispondi a..." riduce l'invenzione di informazioni.
2. Chiedi incertezza: aggiungi al system prompt "Se non sei sicuro, di' esplicitamente 'Non lo so' invece di inventare".
3. Abbassa la temperatura: PARAMETER temperature 0.1 nel Modelfile rende le risposte più conservative e meno creative (anche meno allucinate).
4. Usa RAG per i fatti: se hai bisogno di informazioni precise da documenti, usa RAG invece di affidarti alla memoria del modello.
5. Accetta il limite: per task che richiedono fatti precisi (leggi, dati storici, documentazione tecnica), usa il cloud o il RAG. Non fidarti della memoria del modello locale.
Il problema classico Docker: il container non riesce a raggiungere Ollama che gira sull'host.
Se Ollama gira in un container separato nello stesso docker network, usa il nome del container come host invece di localhost.
Il modello richiede più memoria di quella disponibile (RAM + VRAM combinata).
Soluzioni:
1. Scarica una versione più quantizzata: invece di :latest usa :8b-instruct-q4_0 (la versione più leggera).
2. Prova un modello più piccolo: da 7B a 3B, da 13B a 7B.
3. Su macOS: chiudi le app che usano molta memoria (browser con molte tab, Xcode, ecc.).
4. Aumenta la swap/page file (aiuta ma rallenta molto).
5. Verifica la stima VRAM con la formula: parametri × quantizzazione + 2GB overhead.
Tutto quello che devi ricordare in una pagina. Stampala, appendila.