Modelli AI in Locale con Ollama: Guida Completa 2026
Perché usare modelli AI in locale nel 2026
Nel 2026 il costo delle API cloud non è più l’unica variabile da considerare. Privacy, latenza, dipendenza da terzi e limiti di rate sono diventati ostacoli concreti per chi costruisce prodotti reali. Ollama risolve tutti questi problemi in un colpo solo: ti permette di scaricare ed eseguire modelli open-source — Llama 3, Mistral, Gemma, Qwen e dozzine di altri — direttamente sulla tua macchina, con un’interfaccia REST identica a quella di OpenAI.
Il pubblico di CyberAlchimista lo conosce bene: pagare token per ogni prototipo, ogni script di test o ogni pipeline di automazione è uno spreco. Con un hardware moderno — anche un MacBook M-series o una GPU mid-range — puoi avere un LLM sempre acceso, zero latenza di rete, zero costi variabili. Se stai già sperimentando con le tool use di Claude API per agenti, saprai che avere un modello locale per i task ripetitivi può ridurre la fattura mensile del 70-80%.
In questa guida vediamo tutto: installazione, configurazione, i modelli più utili per i developer, l’integrazione con JavaScript/Python, e come scegliere il modello giusto per ogni caso d’uso. Per un confronto con le API cloud, leggi anche Confronto LLM 2026: Claude vs GPT-4o vs Gemini.
Installazione e primo avvio di Ollama
Installare Ollama è banale: un singolo comando su macOS/Linux, un installer su Windows. Il daemon rimane in background e serve una REST API sulla porta 11434.
# macOS / Linux
curl -fsSL https://ollama.com/install.sh | sh
# Verifica installazione
ollama --version
# Scarica ed esegui Llama 3.1 8B (4.7 GB)
ollama pull llama3.1
# Chat interattiva nel terminale
ollama run llama3.1
# Oppure Mistral 7B (più leggero, ottimo per italiano)
ollama pull mistral
# Gemma 3 9B (Google, ottimo ragionamento)
ollama pull gemma3:9bUna volta avviato, Ollama espone automaticamente un endpoint compatibile con le API di OpenAI su http://localhost:11434/v1. Questo significa che puoi riusare librerie esistenti semplicemente cambiando baseURL. Il modello viene caricato in RAM (o VRAM se hai una GPU) al primo utilizzo e rimane in cache per le richieste successive.
Su macOS con Apple Silicon, Ollama usa il Metal Performance Shaders per l’accelerazione GPU automatica. Su Linux con NVIDIA, basta avere i driver CUDA installati. Su Windows c’è il supporto sperimentale DirectML. In tutti i casi, senza GPU il modello gira sulla CPU — più lento ma funzionante.
🔧 Pro tip: Su un MacBook Pro M3 con 16 GB di RAM,
llama3.1:8bgenera circa 30-40 token/secondo. Su un M3 Max con 64 GB si arriva a 80+ token/s con modelli da 70B in quantizzazione Q4.
I modelli più utili per developer nel 2026
Non tutti i modelli sono uguali. La scelta dipende dall’hardware disponibile e dal task. Ecco una mappa pratica:
- llama3.1:8b — il punto di partenza. Eccellente per codice, chat, summarization. Gira bene con 8 GB di RAM.
- llama3.1:70b — qualità vicina a GPT-4o per task complessi. Richiede 48+ GB di RAM o GPU da 40+ GB VRAM.
- mistral:7b — veloce, leggero, ottimo per italiano. Window da 32k token. Ideale per summarization di documenti lunghi.
- codestral:22b — specializzato nel codice. Supporta 80+ linguaggi, FIM (Fill-in-the-Middle) per completamenti inline.
- gemma3:9b — ottimo rapporto qualità/dimensioni. Context window da 128k. Forte nel ragionamento multilingue.
- qwen2.5-coder:14b — il migliore per codice tra i modelli sotto i 20B. Supporta TypeScript, Python, Rust nativamente.
- deepseek-r1:14b — reasoning model con chain-of-thought esplicito. Perfetto per debug e architettura.
Per chi lavora con Drizzle ORM o stack TypeScript moderni, qwen2.5-coder:14b è spesso la scelta migliore: capisce il type system di TypeScript e genera query type-safe senza allucinazioni sui nomi dei metodi.
Integrazione con JavaScript e TypeScript
Ollama espone due API: quella nativa (/api/chat, /api/generate) e quella compatibile OpenAI (/v1/chat/completions). L’SDK ufficiale è disponibile per JavaScript, Python, Go e Rust.
import Ollama from "ollama";
// Client nativo con streaming
const client = new Ollama({ host: "http://localhost:11434" });
async function chatWithLocalModel(prompt: string, model = "llama3.1") {
const stream = await client.chat({
model,
messages: [{ role: "user", content: prompt }],
stream: true,
});
let fullResponse = "";
for await (const chunk of stream) {
process.stdout.write(chunk.message.content);
fullResponse += chunk.message.content;
}
return fullResponse;
}
// Uso con il modello di codice
async function reviewCode(code: string): Promise<string> {
const response = await client.chat({
model: "qwen2.5-coder:14b",
messages: [
{
role: "system",
content: "Sei un senior developer TypeScript. Fai code review concisa.",
},
{ role: "user", content: "Analizza: " + code },
],
});
return response.message.content;
}
// Compatibilita OpenAI SDK (drop-in replacement)
import OpenAI from "openai";
const openai = new OpenAI({
baseURL: "http://localhost:11434/v1",
apiKey: "ollama", // qualsiasi stringa, non verificata
});
const res = await openai.chat.completions.create({
model: "mistral",
messages: [{ role: "user", content: "Ciao, come stai?" }],
});La compatibilità OpenAI è particolarmente utile se stai migrando un progetto esistente: cambia solo baseURL e apiKey, il resto del codice rimane invariato. Se hai già implementato lo streaming con Claude API in JavaScript, il pattern è identico.
Integrazione con Python e automazioni
Python rimane il linguaggio dominante per automazioni AI. La libreria ollama è minimale e Pythonica, ma funziona anche con requests semplici o con langchain-community per chi usa LangChain.
import ollama
import json
from typing import Generator
# Chat semplice
def ask(prompt: str, model: str = "llama3.1") -> str:
response = ollama.chat(
model=model,
messages=[{"role": "user", "content": prompt}]
)
return response["message"]["content"]
# Streaming con yield
def stream_response(prompt: str, model: str = "mistral") -> Generator:
stream = ollama.chat(
model=model,
messages=[{"role": "user", "content": prompt}],
stream=True
)
for chunk in stream:
yield chunk["message"]["content"]
# Uso con requests (nessuna dipendenza extra)
import requests
def ollama_generate(prompt: str, model: str = "llama3.1") -> str:
r = requests.post(
"http://localhost:11434/api/generate",
json={"model": model, "prompt": prompt, "stream": False},
timeout=120
)
r.raise_for_status()
return r.json()["response"]
# Pipeline: estrai JSON strutturato da testo libero
def extract_json(text: str) -> dict:
schema = '{"nome": "string", "email": "string", "budget": "number"}'
prompt = "Estrai le info dal testo e restituisci SOLO JSON valido.\n"
prompt += "Schema: " + schema + "\n"
prompt += "Testo: " + text + "\nJSON:"
raw = ask(prompt, model="llama3.1")
raw = raw.strip().lstrip("```json").lstrip("```").strip()
return json.loads(raw)
# Uso
result = extract_json(
"Sono Marco Rossi, marco@example.com, budget 5000 euro"
)
print(result) # {"nome": "Marco Rossi", "email": "...", "budget": 5000}Questo approccio si integra perfettamente con pipeline di automazione come n8n o workflow custom. Se stai costruendo automazioni più complesse, dai un’occhiata a come automatizzare la gestione email con n8n e Claude — molti dei pattern sono riusabili con Ollama al posto delle API cloud.
Modelfile: personalizzare i modelli con system prompt e parametri
Ollama permette di creare modelli personalizzati con Modelfile, simili ai Dockerfile ma per LLM. Puoi definire un system prompt fisso, modificare temperatura, top-k, top-p e creare alias specifici per progetto.
# Crea Modelfile per un assistente TypeScript dedicato
cat > Modelfile << 'ENDOFFILE'
FROM llama3.1
SYSTEM "Sei un assistente tecnico specializzato in TypeScript e Node.js. Rispondi in italiano, fornisci esempi concreti, segnala bug di type safety."
PARAMETER temperature 0.2
PARAMETER top_k 40
PARAMETER top_p 0.9
PARAMETER num_ctx 8192
PARAMETER stop "Human:"
PARAMETER stop "User:"
ENDOFFILE
# Compila il modello personalizzato
ollama create dev-assistant -f Modelfile
# Eseguilo
ollama run dev-assistant
# Verifica i modelli disponibili
ollama list
# Rimuovi un modello non piu necessario
ollama rm gemma3:9bI Modelfile sono particolarmente potenti per team: puoi versionarli su Git, distribuirli ai colleghi e garantire che tutti usino lo stesso comportamento del modello. La temperature 0.2 rende le risposte più deterministiche e adatte al codice; alzala a 0.7-0.9 per task creativi.
💡 Pro tip: Usa
num_ctx 32768per modelli che supportano context window lunghe (Mistral, Gemma 3). Il default è spesso 2048, insufficiente per analizzare file di codice interi.
Ollama come backend per RAG e agenti
Uno dei casi d’uso più potenti è usare Ollama come backend per sistemi RAG (Retrieval-Augmented Generation). Ollama supporta anche i modelli di embedding — nomic-embed-text e mxbai-embed-large — che puoi usare per vettorializzare documenti senza dipendere da API esterne.
import ollama
import numpy as np
from typing import List, Tuple
# Genera embedding con modello locale
def embed(text: str) -> List[float]:
response = ollama.embeddings(
model="nomic-embed-text",
prompt=text
)
return response["embedding"]
# Cosine similarity
def cosine_sim(a: List[float], b: List[float]) -> float:
a_np, b_np = np.array(a), np.array(b)
return float(np.dot(a_np, b_np) / (np.linalg.norm(a_np) * np.linalg.norm(b_np)))
# RAG minimalista senza framework
class SimpleRAG:
def __init__(self, llm_model: str = "llama3.1"):
self.llm_model = llm_model
self.docs: List[Tuple[str, List[float]]] = []
def add_document(self, text: str) -> None:
self.docs.append((text, embed(text)))
def search(self, query: str, top_k: int = 3) -> List[str]:
query_emb = embed(query)
scored = [(cosine_sim(query_emb, emb), t) for t, emb in self.docs]
scored.sort(reverse=True)
return [t for _, t in scored[:top_k]]
def ask(self, question: str) -> str:
ctx = "\n\n".join(self.search(question))
prompt = "Contesto:\n" + ctx + "\n\nDomanda: " + question + "\nRisposta:"
resp = ollama.chat(
model=self.llm_model,
messages=[{"role": "user", "content": prompt}]
)
return resp["message"]["content"]
# Utilizzo
rag = SimpleRAG(llm_model="mistral")
rag.add_document("Ollama supporta macOS, Linux e Windows.")
rag.add_document("Llama 3.1 70B richiede almeno 48 GB di RAM.")
print(rag.ask("Quanta RAM serve per Llama 3.1 70B?"))Se vuoi un’implementazione RAG più robusta con gestione dei chunk e metadati, leggi la guida su RAG con Claude API step-by-step: i concetti sono identici, basta sostituire il client.
🎯 Pro tip: Combina Ollama con Supabase pgvector per un sistema RAG production-ready completamente open source e senza costi variabili. Il costo totale scende a zero oltre l’hardware iniziale.
FAQ e Domande Frequenti
Ollama è adatto alla produzione o solo per sviluppo locale?
Ollama è nato per lo sviluppo locale, ma può essere usato in produzione su server dedicati. Supporta più richieste concorrenti (configura OLLAMA_NUM_PARALLEL), ha un’API stabile e può essere messo dietro un reverse proxy come Nginx o Caddy. Per workload enterprise con SLA rigorosi, valuta alternative come vLLM o LM Studio Server che offrono batching più avanzato e ottimizzazione throughput.
I modelli locali sono più lenti delle API cloud?
Dipende dall’hardware. Un MacBook M3 Pro genera 30-50 token/s con modelli 8B — paragonabile alla velocità percepita di GPT-4o in streaming. Su GPU NVIDIA RTX 4090 si arriva a 100+ token/s con modelli 13B. La latenza iniziale (“time to first token”) è più bassa perché non c’è overhead di rete. Per modelli 70B+ su hardware consumer, la velocità scende e le API cloud diventano più convenienti in termini di tempo.
Posso usare Ollama con modelli quantizzati per risparmiare VRAM?
Sì, quasi tutti i modelli su Ollama sono distribuiti in versioni quantizzate (Q4_K_M, Q5_K_M, Q8_0). La quantizzazione Q4 riduce le dimensioni del 50-60% con una perdita di qualità percepita minima nella maggior parte dei task. Ad esempio, llama3.1:70b-instruct-q4_K_M richiede circa 40 GB invece di 140 GB. Specifica la quantizzazione nel pull: ollama pull llama3.1:70b-instruct-q4_K_M.
Come scelgo tra Ollama e le API cloud come Claude o GPT-4o?
La regola pratica: usa Ollama per prototipi, task ripetitivi, dati sensibili e quando vuoi costi fissi. Usa le API cloud (Claude, GPT-4o, Gemini) per task che richiedono la massima qualità, ragionamento complesso o multimodalità avanzata. Una strategia ibrida è spesso ottimale: routing intelligente che manda i task semplici al modello locale e quelli complessi alle API cloud. Per un confronto dettagliato dei modelli cloud, consulta il nostro confronto LLM 2026.
Conclusione
Ollama ha abbassato la barriera d’ingresso per i modelli AI locali a un singolo comando. Nel 2026, con modelli come Llama 3.1, Mistral e Qwen2.5-Coder che raggiungono qualità vicina ai top cloud per molti task, non c’è più motivo di pagare token per ogni prototipo o pipeline interna.
La strategia vincente è ibrida: Ollama per task ripetitivi, dati sensibili e sviluppo locale; API cloud per reasoning avanzato e multimodalità. Inizia con llama3.1:8b o mistral:7b, misura la qualità sul tuo caso d’uso specifico, poi scala. L’hardware che hai già è probabilmente sufficiente per cominciare.
Suggerimenti e Risorse
🔧 Strumento: Open WebUI (github.com/open-webui/open-webui) — interfaccia ChatGPT-like per Ollama, self-hosted, con gestione conversazioni, RAG integrato e plugin. Installabile in un container Docker in 2 minuti.
💡 Consiglio: Per scegliere il modello giusto, consulta LM Arena Leaderboard (lmarena.ai) che aggiorna mensilmente i benchmark di qualità per modelli open-source. Non fidarti solo dei parametri: testa sul tuo dataset reale.
🎯 Strategia: Usa la variabile d’ambiente
OLLAMA_MODELSper salvare i modelli su un disco esterno o NAS invece che sul disco principale. I modelli 70B occupano 40+ GB ciascuno e si accumulano velocemente.
