Ollama ha un’integrazione ufficiale con Claude Code da gennaio 2026: un solo comando, un modello locale compatibile con tool calling, e Claude Code smette di parlare con i server Anthropic per usare la GPU che hai sul tavolo. Questa guida ti porta dal nulla a un setup funzionante, con dati di performance reali per ogni fascia di hardware — così sai cosa aspettarti prima di scaricare 15GB di pesi.
Cosa ottieni alla fine
Claude Code che usa un LLM locale come backend: stesse scorciatoie da tastiera, stessa interfaccia CLI, stessa capacità di leggere file e eseguire comandi nel terminale — ma l’inferenza avviene sulla tua GPU, senza inviare codice a server esterni e senza consumare crediti Anthropic. Utile per sessioni lunghe su codebase private, ambienti senza internet, o semplicemente per ridurre i costi su task ripetitivi.
Hardware: cosa ti serve e cosa ti aspetta
Il parametro che governa tutto è la VRAM. La regola pratica è: il modello deve stare interamente in VRAM per avere performance accettabili. Se il modello trabocca sulla RAM di sistema, la velocità crolla da 50-100 token/s a 3-10 token/s — inutilizzabile in modo interattivo.
| GPU | VRAM | Modelli consigliati | Token/s (14B Q4) | Note |
|---|---|---|---|---|
| RTX 5090 | 32GB | 70B Q4, 32B Q8 | ~110 tok/s | Nessun compromesso |
| RTX 4090 | 24GB | 70B Q4, 32B Q5-Q8 | 95 tok/s (13B), 52 tok/s (70B) | Riferimento assoluto per consumer |
| RTX 3090 (usata) | 24GB | 70B Q4, 32B Q5-Q8 | ~42 tok/s (70B) | Miglior valore: stesso VRAM 4090 a metà prezzo |
| RTX 4080 Super | 20GB | 32B Q4-Q6, 14B Q8 | 38 tok/s (34B) | Buon compromesso VRAM/velocità |
| RTX 4070 Ti Super | 16GB | 14B Q8, 27B Q4 | 70 tok/s (14B), 30 tok/s (Mixtral 8x7B) | Miglior rapporto qualità/prezzo per AI locale |
| RTX 4070 / RX 9070 | 12GB | 7-8B Q8, 14B Q4 | 22-60 tok/s (7-14B) | Entry-level, ottimo per modelli 7-14B |
| RTX 4060 Ti | 8GB | 7B Q4-Q6, 4B Q8 | 50-80 tok/s (7B Q4) | Solo modelli piccoli — Gemma 4 E4B, Phi-4 |
| Apple M3/M4 (unified) | 16-96GB shared | Fino a 70B se RAM sufficiente | 30-60 tok/s (14B) | MLX backend, efficiente su Apple Silicon |
| CPU only (nessuna GPU) | — | 3-4B, max 7B Q4 | 3-8 tok/s | Solo per test o Phi-4 mini |
Insight chiave: la velocità di generazione dipende quasi linearmente dalla bandwidth della memoria. Formula approssimata: tok/s ≈ bandwidth_GB/s ÷ dimensione_modello_GB. RTX 4090 ha 1.008 GB/s di bandwidth; un modello da 8B Q4 (~4.5GB) genera circa 224 tok/s. Nella pratica si ottiene meno per overhead, ma l’ordine di grandezza è questo.
Quale modello scegliere per Claude Code
Non tutti i modelli funzionano con Claude Code: il requisito non negoziabile è il tool calling nativo. Claude Code usa i tool per leggere file, eseguire comandi, scrivere codice — senza tool calling il modello risponde come una chat normale e Claude Code si rompe. Inoltre il system prompt di Claude Code è circa 20k token, quindi servono modelli con context window di almeno 32k.
| Modello | VRAM Q4 | Context | Tool calling | SWE-Bench | Consigliato per |
|---|---|---|---|---|---|
qwen3-coder-next:q4_K_M |
52GB (multi-GPU) | 256k | ✅ nativo | 74,2% | Multi-GPU o uso via tag :cloud |
qwen3-coder:14b |
9GB | 256k | ✅ nativo | ~65%* | GPU 12-16GB — scelta principale 2026 |
qwen3:14b |
9GB | 40k | ✅ nativo | — | GPU 12-16GB, ragionamento + coding generico |
qwen3:8b |
5GB | 40k | ✅ nativo | — | GPU 8GB, leggero |
gemma4:27b |
17GB | 128k | ✅ nativo | — | GPU 20-24GB, multimodale |
deepseek-r2:32b |
20GB | 128k | ✅ nativo | — | GPU 24GB, reasoning avanzato |
qwen2.5-coder:14b |
9GB | 128k | ✅ nativo | 57% | Fallback collaudato su GPU 12GB+ |
phi4:14b |
9GB | 16k | ✅ nativo | — | GPU 12GB, il più veloce su CPU |
* Benchmark ufficiali qwen3-coder:14b non ancora pubblicati al momento della guida — stima basata sulla famiglia Qwen3.
Scelta consigliata per GPU 12-16GB: qwen3-coder:14b — generazione successiva rispetto a Qwen 2.5-coder, context window doppia (256k), tool calling migliorato. Se non disponibile su Ollama al momento in cui leggi, qwen2.5-coder:14b è il fallback collaudato.
Qwen3-Coder-Next: il modello più potente della famiglia con SWE-Bench al 74,2% — tra i migliori in assoluto per coding. Architettura MoE con 80B parametri totali e solo 3B attivi per token: l’inferenza è veloce, ma i pesi pesano 52GB in Q4 e richiedono multi-GPU per girare in locale. Per chi non ha l’hardware, il tag :cloud punta all’API Qwen invece di girare localmente.
Step 1 — Installa Ollama
# macOS (Homebrew)
brew install ollama
# macOS / Linux (script ufficiale)
curl -fsSL https://ollama.com/install.sh | sh
# Windows
# Scarica il .exe installer da https://ollama.com/download/windows
# Dopo l'installazione, Ollama gira come servizio in backgroundVerifica che Ollama sia in ascolto:
ollama --version
curl http://localhost:11434/api/tags # deve rispondere con JSONSu Linux con GPU NVIDIA, Ollama rileva automaticamente CUDA. Se non vedi la GPU usata:
# Verifica CUDA disponibile
nvidia-smi
# Verifica che Ollama veda la GPU
ollama infoStep 2 — Scarica il modello
# Consigliato per la maggior parte degli utenti (GPU 12GB+)
ollama pull qwen2.5-coder:14b
# GPU 8GB
ollama pull qwen2.5-coder:7b
# GPU 20-24GB, per task multimodali
ollama pull gemma4:27b
# Variante ottimizzata per tool use con Claude Code
ollama pull hhao/qwen2.5-coder-toolsIl download varia da 5GB (7B Q4) a 17GB (27B Q4). Usa una connessione cablata. Puoi monitorare lo stato con ollama ps — i modelli restano in VRAM per 5 minuti dopo l’ultimo uso, poi vengono scaricati automaticamente.
Step 3 — Avvia Claude Code con il modello locale
Ollama ha un’integrazione ufficiale con Claude Code tramite il comando ollama launch claude, disponibile da Ollama 0.6.x:
# Metodo 1 — Comando integrato ufficiale (consigliato)
ollama launch claude --model qwen2.5-coder:14b
# Con variante tool-use ottimizzata
ollama launch claude --model hhao/qwen2.5-coder-tools
# Gemma 4 con context 64k (variante ottimizzata per contesti lunghi)
ollama launch claude --model gemma4-26b-64kQuesto comando configura automaticamente le variabili d’ambiente e lancia Claude Code con il modello specificato. È il modo più semplice.
Se preferisci configurare manualmente (utile per setup persistenti o script):
# Metodo 2 — Variabili d'ambiente manuali
export ANTHROPIC_BASE_URL="http://localhost:11434"
export ANTHROPIC_API_KEY="ollama"
claude --model qwen2.5-coder:14b
# Per rendere il cambio permanente in ~/.zshrc o ~/.bashrc:
echo 'alias claude-local="ANTHROPIC_BASE_URL=http://localhost:11434 ANTHROPIC_API_KEY=ollama claude --model qwen2.5-coder:14b"' >> ~/.zshrc
source ~/.zshrc
# Poi basta digitare: claude-localStep 4 — Verifica che tool calling funzioni
Dopo l’avvio, testa immediatamente che i tool siano attivi. In Claude Code digita:
/helpSe vedi la lista dei comandi disponibili, il modello sta rispondendo. Per testare il tool filesystem:
list the files in the current directorySe il modello elenca i file reali (non risponde genericamente), il tool calling funziona correttamente. Se risponde con “Non posso accedere al filesystem” o simili, il modello non supporta tool calling — prova un modello diverso dalla tabella sopra.
Performance attese nella pratica
La velocità che senti durante l’uso dipende dal task:
- Time to first token: 1-3 secondi — il tempo che passa dal prompt alla prima parola della risposta. Dipende dalla latenza di inference, non dalla velocità di generazione.
- Generazione codice breve (<200 token): su RTX 4070 con qwen2.5-coder:14b Q4 = circa 2-4 secondi. Fluido per uso interattivo.
- Risposte lunghe (500+ token): 8-15 secondi su GPU da 16GB. Accettabile.
- Task agentico (legge 10 file, scrive funzione, esegue test): 30-120 secondi — l’LLM fa molte chiamate sequenziali ai tool. La velocità dipende anche dall’I/O del filesystem.
Confronto diretto con Claude Sonnet via API: su task di coding semplice la differenza è 3-5x in velocità a favore dell’API cloud, ma per sessioni lunghe su codebase privata il modello locale ammortizza il tempo con la privacy e il costo zero per token.
Step 5 (opzionale) — Interfaccia web con Open WebUI
Per chi vuole anche una chat web oltre al CLI di Claude Code:
# Installa Open WebUI via Docker
docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -e OLLAMA_BASE_URL=http://host.docker.internal:11434 -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main
# Apri nel browser
open http://localhost:3000Open WebUI si connette allo stesso Ollama locale e ti dà un’interfaccia simile a ChatGPT per i tuoi modelli — utile per test veloci senza aprire Claude Code.
Risoluzione problemi comuni
- Tool calling non funziona / Claude Code si rompe: il modello non supporta function calling. Usa
qwen2.5-coder:14bohhao/qwen2.5-coder-tools. - Context window overflow: errore “context length exceeded”. Il system prompt di Claude Code è ~20k token. Assicurati di usare un modello con context ≥32k. Qwen2.5-coder:14b ha 128k token — non ha questo problema.
- Risposta lentissima (3-5 tok/s): il modello sta facendo CPU offloading perché non entra in VRAM. Verifica con
ollama psla percentuale GPU. Soluzione: scarica una versione più piccola o con quantizzazione più aggressiva (Q4 invece di Q8). - GPU non rilevata su Linux: Ollama richiede driver NVIDIA 535+ e CUDA 11.3+. Verifica con
nvidia-smienvcc --version. - Ollama si disconnette dopo pochi secondi: il modello viene scaricato dalla VRAM dopo 5 minuti di inattività per default. Puoi aumentare il timeout:
OLLAMA_KEEP_ALIVE=24h ollama serve. - Su Mac: modello lento nonostante Apple Silicon: assicurati di usare Ollama 0.6+ che usa il backend MLX nativo invece di llama.cpp. Verifica con
ollama infoche il backend sia MLX.
Risorse
- docs.ollama.com/integrations/claude-code — integrazione ufficiale
- ollama.com/library — catalogo modelli con VRAM richiesta
- hhao/qwen2.5-coder-tools — variante ottimizzata tool use
- Home GPU LLM Leaderboard — benchmark token/s per GPU aggiornati
Guida testata su macOS e Linux con Ollama 0.6.x e Claude Code — aprile 2026. I benchmark tok/s sono indicativi e variano con driver, quantizzazione e carico del sistema.