Di quanta RAM ho bisogno per eseguire Gemma 4 localmente?

Gemma 4 E2B e E4B funzionano con appena 5GB di RAM con quantization a 4-bit — qualsiasi laptop moderno è adatto. Il modello 26B MoE richiede circa 18GB di RAM (entra nei 24GB di VRAM di una RTX 4090). Il modello 31B Dense richiede circa 20GB di RAM. Per l'esecuzione solo su CPU, aggiungere il 20-30% di RAM in più rispetto alla dimensione del peso del modello.

Quale modello Gemma 4 dovrei scegliere per l'uso locale?

Per laptop senza una GPU dedicata: E2B (più veloce, più leggero). Per laptop con una GPU o desktop: E4B (qualità migliore, comunque leggero). Per desktop con una RTX 4090 o equivalente: 26B MoE (miglior rapporto qualità-prestazioni). Per workstation con oltre 24GB di VRAM: 31B Dense (massima qualità). Il 26B MoE è la scelta ideale per la maggior parte degli sviluppatori.

Gemma 4 è gratuito da usare localmente?

Sì. Gemma 4 è rilasciato sotto licenza Apache 2.0, che permette un uso illimitato, incluse le applicazioni commerciali. Anche Ollama è gratuito e open source. L'unico costo è l'hardware. Non ci sono costi per le API, limiti di utilizzo o restrizioni di licenza.

Quanto è veloce Gemma 4 localmente rispetto alle API cloud?

Su una RTX 4090, Gemma 4 E4B genera 80-120 tokens per secondo. Il 26B MoE genera 30-50 tokens/sec. Il 31B Dense genera 20-35 tokens/sec. Le API cloud come Google AI Studio potrebbero essere più veloci per i modelli più grandi, ma aggiungono una latenza di rete di 100-500ms per richiesta. Per l'uso interattivo, l'inferenza locale sui modelli più piccoli sembra istantanea.

Posso usare Gemma 4 localmente come API per le mie applicazioni?

Sì. Ollama espone una REST API locale sulla porta 11434 che è compatibile con il formato delle API di OpenAI. Qualsiasi applicazione, framework o strumento che supporti le API di OpenAI può connettersi a Gemma 4 locale puntando l'URL di base a http://localhost:11434/v1. Questo include Python, Node.js e la maggior parte dei framework AI.

Gemma 4 supporta l'accelerazione GPU con Ollama?

Sì. Ollama rileva e utilizza automaticamente le GPU NVIDIA (CUDA), Apple Silicon (Metal) e le GPU AMD (ROCm). Non è necessaria alcuna configurazione aggiuntiva: se la tua GPU ha abbastanza VRAM per contenere il modello, Ollama la utilizzerà automaticamente. NVIDIA ha anche rilasciato versioni di Gemma 4 ottimizzate per RTX per ulteriori guadagni prestazionali.

Punto Chiave

Eseguire Gemma 4 localmente richiede meno di 5 minuti con Ollama: installa Ollama, esegui un comando e avrai un modello AI completamente capace in esecuzione sul tuo hardware con zero costi di API, zero dati che lasciano la tua macchina e zero restrizioni d'uso sotto licenza Apache 2.0. Il modello E2B gira su qualsiasi laptop. Il modello 26B MoE si adatta a una singola RTX 4090 e offre una qualità che rivaleggia con modelli con un numero di parametri attivi 10 volte superiore.

Esegui Gemma 4 Localmente: La Guida Completa

Perché eseguire Gemma 4 localmente?

Prima di immergersi nella configurazione, ecco perché l'inferenza locale è importante nel 2026:

Privacy — I tuoi dati non lasciano mai la tua macchina. Nessun prompt inviato a server esterni. Fondamentale per codice proprietario, documenti legali, dati medici o qualsiasi informazione sensibile.
Costo — Zero costi per token dopo l'investimento iniziale nell'hardware. Gli utenti intensivi risparmiano centinaia di dollari al mese rispetto ai prezzi delle API.
Latenza — Nessun viaggio di rete andata e ritorno. I modelli E2B e E4B rispondono in millisecondi su hardware moderno.
Affidabilità — Nessun limite di frequenza API, nessuna interruzione, nessun cambiamento nelle politiche del provider. Il tuo modello è sempre disponibile.
Personalizzazione — Effettua fine-tune, quantize e modifica il modello liberamente sotto Apache 2.0.
Accesso offline — Funziona senza una connessione internet una volta scaricato il modello.

Gemma 4 è particolarmente adatto per il deployment locale perché Google ha progettato i modelli più piccoli specificamente per l'uso edge e on-device. I modelli E2B e E4B non sono un ripiego — sono modelli di prima classe ottimizzati per i vincoli dell'hardware locale.

Prerequisiti

Requisiti Hardware per Modello

Modello	RAM minima	VRAM consigliata	Viabile solo CPU?	Spazio su disco
E2B (4-bit)	5 GB	4 GB	Sì	~1.5 GB
E4B (4-bit)	5 GB	4 GB	Sì	~2.8 GB
E4B (FP16)	9 GB	9 GB	Lento	~9 GB
26B MoE (4-bit)	18 GB	16 GB	Molto lento	~15 GB
26B MoE (FP16)	52 GB	48 GB	No	~52 GB
31B Dense (4-bit)	20 GB	18 GB	Molto lento	~18 GB
31B Dense (FP16)	62 GB	48 GB+	No	~62 GB

Punto chiave: Se hai un laptop prodotto dopo il 2022, puoi eseguire E2B o E4B. Se hai una RTX 4090 (24GB VRAM) o un Apple M-series Mac con 32GB+ RAM, puoi eseguire il 26B MoE o il 31B Dense con quantizzazione a 4-bit.

Requisiti Software

Sistema operativo: macOS, Linux, o Windows
Ollama: Versione 0.6+ (scarica da ollama.com)
Driver GPU (opzionale): NVIDIA CUDA 12+ per GPU NVIDIA, nessun driver extra necessario per Apple Silicon

Step 1: Installa Ollama

macOS

Scarica da ollama.com/download o usa Homebrew:

brew install ollama

Linux

Script di installazione in una riga:

curl -fsSL https://ollama.com/install.sh | sh

Windows

Scarica l'installer da ollama.com/download ed eseguilo. Ollama gira come un servizio in background su Windows.

Verifica l'Installazione

ollama --version

Dovresti vedere ollama version 0.6.x o superiore. Se vedi un numero di versione, Ollama è installato correttamente.

Fonte: Guida all'installazione di Ollama

Step 2: Scarica un Modello Gemma 4

Scegli il modello che corrisponde al tuo hardware:

Per Laptop e Carichi di Lavoro Leggeri

# Modello più piccolo — gira su qualsiasi laptop moderno (5GB RAM)
ollama pull gemma4:e2b

# Modello piccolo con capacità più ampie (5-9GB RAM)
ollama pull gemma4:e4b

Per Desktop con una GPU Dedicata

# Migliore efficienza — qualità flagship a 3.8B parametri attivi (18GB RAM)
ollama pull gemma4:26b-moe

# Massima qualità — 31B parametri completi (20GB RAM)
ollama pull gemma4:31b

Specificare la Quantizzazione

Per impostazione predefinita, Ollama scarica la quantizzazione consigliata per ogni modello (solitamente Q4_K_M per un buon equilibrio tra qualità e dimensioni). Puoi specificare diverse quantizzazioni:

# Qualità superiore, dimensioni maggiori
ollama pull gemma4:31b-q5_K_M

# Dimensioni ridotte, qualità leggermente inferiore
ollama pull gemma4:31b-q3_K_M

# Precisione completa (richiede molta più RAM)
ollama pull gemma4:31b-fp16

Il download richiederà alcuni minuti a seconda della tua connessione internet. Le dimensioni dei modelli variano da ~1.5GB (E2B 4-bit) a ~62GB (31B FP16).

Step 3: Esegui Gemma 4

Chat Interattiva

ollama run gemma4:e4b

Questo apre una sessione di chat interattiva. Digita il tuo prompt e premi Invio:

>>> What are the key differences between REST and GraphQL APIs?

Il modello risponderà direttamente nel tuo terminale. Digita /bye per uscire.

Prompt Singolo (Non Interattivo)

echo "Explain the Builder design pattern in Python with an example" | ollama run gemma4:26b-moe

Con Modalità Thinking

Gemma 4 supporta una modalità thinking configurabile per compiti complessi. Abilitala aggiungendo un system prompt:

ollama run gemma4:31b --system "Think step by step before answering. Show your reasoning process."

Per compiti di matematica, logica e analisi complessa, la modalità thinking migliora significativamente la qualità della risposta. Il modello genererà oltre 4,000 tokens di ragionamento interno prima di produrre la sua risposta finale.

Step 4: Usa l'API Locale

Ollama espone una API REST su localhost:11434 che è compatibile con il formato API di OpenAI. Ciò significa che qualsiasi strumento o libreria che supporta l'API di OpenAI può connettersi al tuo Gemma 4 locale con un semplice cambio di URL.

Testare l'API con curl

curl http://localhost:11434/api/generate -d '{
  "model": "gemma4:26b-moe",
  "prompt": "Write a Python function to parse CSV files with error handling",
  "stream": false
}'

Endpoint Compatibile con OpenAI

curl http://localhost:11434/v1/chat/completions -d '{
  "model": "gemma4:26b-moe",
  "messages": [
    {"role": "user", "content": "Explain async/await in JavaScript"}
  ]
}'

Fonte: Documentazione API di Ollama

Step 5: Integra con la Tua Applicazione

Python

import requests

def ask_gemma(prompt, model="gemma4:26b-moe"):
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    return response.json()["response"]

# Utilizzo
answer = ask_gemma("What is the time complexity of merge sort?")
print(answer)

Python con SDK OpenAI

from openai import OpenAI

# Punta a Ollama locale invece di OpenAI
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Ollama non richiede una vera API key
)

response = client.chat.completions.create(
    model="gemma4:26b-moe",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a React hook for debounced search"}
    ]
)
print(response.choices[0].message.content)

Node.js / TypeScript

const response = await fetch("http://localhost:11434/v1/chat/completions", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "gemma4:26b-moe",
    messages: [
      { role: "user", content: "Explain the Observer pattern with a TypeScript example" }
    ]
  })
});

const data = await response.json();
console.log(data.choices[0].message.content);

Utilizzo con LangChain

from langchain_community.llms import Ollama

llm = Ollama(model="gemma4:26b-moe")
response = llm.invoke("Summarize the key principles of clean architecture")
print(response)

Utilizzo con LlamaIndex

from llama_index.llms.ollama import Ollama

llm = Ollama(model="gemma4:26b-moe", request_timeout=120.0)
response = llm.complete("What are the SOLID principles in software engineering?")
print(response)

Spiegazione delle Opzioni di Quantizzazione

La quantizzazione riduce le dimensioni del modello e l'uso della memoria utilizzando numeri a precisione inferiore per rappresentare i pesi del modello. Il compromesso è tra qualità e utilizzo delle risorse:

Quantizzazione	Bit per peso	Impatto sulla qualità	Risparmio di memoria	Ideale per
FP16	16 bits	Nessuno (qualità completa)	Baseline	Server con ampia VRAM
Q8_0	8 bits	Trascurabile	~50%	Inferenza locale di alta qualità
Q6_K	6 bits	Molto lieve	~62%	Uso locale orientato alla qualità
Q5_K_M	5 bits	Lieve	~69%	Buon equilibrio
Q4_K_M	4 bits	Piccolo	~75%	Default consigliato
Q3_K_M	3 bits	Moderato	~81%	Hardware limitato
Q2_K	2 bits	Significativo	~87%	Vincoli estremi

Q4_K_M è il punto di equilibrio ideale per la maggior parte degli utenti. La differenza di qualità rispetto a FP16 è così piccola che la maggior parte dei compiti produce risultati indistinguibili, mentre il risparmio di memoria del 75% fa la differenza tra "necessita di un server" e "gira sul mio laptop".

Scegliere la Giusta Quantizzazione

Per Gemma 4 E2B/E4B: Usa il default (Q4_K_M). Questi modelli sono già abbastanza piccoli che una quantizzazione più elevata non cambia in modo significativo l'esperienza dell'utente.

Per Gemma 4 26B MoE: Q4_K_M si adatta a 18GB di RAM, il che rientra nei 24GB di VRAM di una RTX 4090 con spazio per la KV cache. Se hai 48GB+ di VRAM (A6000, doppia GPU), considera Q8_0 per una qualità marginalmente migliore.

Per Gemma 4 31B Dense: Q4_K_M a 20GB entra in una RTX 4090 con margini stretti. Q5_K_M produce risultati leggermente migliori ma richiede ~24GB, consumando tutta la VRAM disponibile. Se hai 32GB+ di VRAM (RTX 5090, A6000), Q6_K o Q8_0 valgono l'aggiornamento.

Ottimizzazione delle Prestazioni

GPU Offloading

Ollama sposta automaticamente i layer del modello sulla GPU quando la VRAM è disponibile. Se solo una parte del modello entra nella VRAM, Ollama divide il carico tra GPU e CPU. Puoi controllarlo:

# Forza tutti i layer sulla GPU (fallisce se la VRAM è insufficiente)
OLLAMA_NUM_GPU=999 ollama run gemma4:26b-moe

# Forza solo CPU (utile per test)
OLLAMA_NUM_GPU=0 ollama run gemma4:e4b

Configurazione della Context Window

Per impostazione predefinita, Ollama usa una context window di 2048 tokens per efficienza. Per utilizzare le piene capacità di contesto di Gemma 4:

# Imposta la context window a 32K tokens
ollama run gemma4:26b-moe --num-ctx 32768

# Imposta la context window a 128K tokens (richiede più RAM)
ollama run gemma4:26b-moe --num-ctx 131072

Importante: Context window più grandi consumano più RAM per la KV cache. Una context window da 128K sul modello 31B può richiedere 8-16GB di RAM aggiuntiva oltre ai pesi del modello. Inizia con 32K e aumenta solo se il tuo caso d'uso lo richiede.

Richieste Contemporanee

Ollama supporta la gestione di più richieste simultaneamente:

# Permette fino a 4 richieste contemporanee
OLLAMA_NUM_PARALLEL=4 ollama serve

Ogni richiesta contemporanea aggiunge un sovraccarico di memoria per la sua KV cache. Su una GPU da 24GB che esegue il 26B MoE a Q4_K_M (~18GB), hai circa 6GB di margine — sufficienti per 2-3 richieste contemporanee con contesti brevi.

Impostazioni Keep-Alive

Per impostazione predefinita, Ollama mantiene i modelli caricati in memoria per 5 minuti dopo l'ultima richiesta. Regola questo parametro per il tuo caso d'uso:

# Mantieni il modello caricato per 1 ora
OLLAMA_KEEP_ALIVE=3600 ollama serve

# Mantieni il modello caricato indefinitamente
OLLAMA_KEEP_ALIVE=-1 ollama serve

# Scarica immediatamente dopo ogni richiesta (risparmia memoria)
OLLAMA_KEEP_ALIVE=0 ollama serve

Ottimizzazione NVIDIA RTX

NVIDIA ha rilasciato build ottimizzate di Gemma 4 per GPU RTX. Queste ottimizzazioni includono:

Kernel CUDA personalizzati per il meccanismo di attention di Gemma 4
Integrazione TensorRT-LLM per un'inferenza più veloce
Supporto Flash Attention per un ridotto utilizzo della memoria durante l'inferenza a lungo contesto
Gestione ottimizzata della KV cache per un migliore throughput

Installare Gemma 4 Ottimizzato per NVIDIA

Se hai una GPU serie RTX 4000 o 5000:

# Controlla la tua GPU
nvidia-smi

# Scarica la versione ottimizzata per NVIDIA (se disponibile in Ollama)
ollama pull gemma4:31b-nvidia

In alternativa, usa AI Workbench di NVIDIA o TensorRT-LLM direttamente per le massime prestazioni. Le versioni ottimizzate per NVIDIA possono fornire un'inferenza del 30-50% più veloce sulle GPU RTX rispetto alle build standard di Ollama.

Benchmark delle Prestazioni nel Mondo Reale

Misurati su configurazioni hardware comuni:

Tokens per Secondo (Velocità di Generazione)

Modello	RTX 4090 (24GB)	RTX 3090 (24GB)	M3 Max (36GB)	Solo CPU (32GB)
E2B (Q4)	~150 tok/s	~120 tok/s	~100 tok/s	~30 tok/s
E4B (Q4)	~100 tok/s	~80 tok/s	~70 tok/s	~15 tok/s
26B MoE (Q4)	~40 tok/s	~30 tok/s	~25 tok/s	~3 tok/s
31B Dense (Q4)	~30 tok/s	~20 tok/s	~20 tok/s	~2 tok/s

Contesto: La velocità di lettura umana è di circa 4-5 tokens al secondo. Qualsiasi modello che genera sopra i 10 tok/s sembra "istantaneo" per l'uso interattivo. I modelli E2B e E4B sono abbastanza veloci per lo streaming in tempo reale su quasi ogni hardware.

Tempo per il Primo Token (Latenza)

Modello	RTX 4090	M3 Max	Solo CPU
E2B	<100ms	<200ms	<500ms
E4B	<200ms	<300ms	~1s
26B MoE	~500ms	~1s	~5s
31B Dense	~800ms	~1.5s	~8s

Per le applicazioni interattive, il tempo per il primo token conta più della velocità di generazione. I modelli E2B e E4B iniziano a generare quasi istantaneamente anche su CPU, rendendoli ideali per interfacce di chat in tempo reale.

Casi d'Uso Comuni

Assistente di Coding Locale

Usa Gemma 4 come assistente di coding privato che non invia mai il tuo codice a server esterni:

ollama run gemma4:26b-moe --system "You are an expert software engineer. When given code, analyze it for bugs, suggest improvements, and explain your reasoning. Be concise and practical."

Abbinalo a estensioni di VS Code come Continue o Twinny che supportano Ollama come backend.

Analisi di Documenti

Elabora documenti sensibili localmente:

echo "Analyze this contract clause and identify potential risks: [paste clause]" | ollama run gemma4:31b

Con 256K di contesto, il modello 31B può elaborare documenti fino a ~750 pagine — sufficienti per la maggior parte dei contratti, documenti di ricerca e documentazione tecnica.

RAG Locale (Retrieval-Augmented Generation)

Combina Gemma 4 con un database vettoriale locale per un sistema RAG completamente privato:

from langchain_community.llms import Ollama
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import Chroma

# Usa Gemma 4 sia per gli embeddings che per la generazione
embeddings = OllamaEmbeddings(model="gemma4:e4b")
llm = Ollama(model="gemma4:26b-moe")

# Crea il vector store dai tuoi documenti
vectorstore = Chroma.from_documents(documents, embeddings)

# Interroga con RAG
retriever = vectorstore.as_retriever()
docs = retriever.get_relevant_documents("What is our refund policy?")
context = "\n".join([doc.page_content for doc in docs])
response = llm.invoke(f"Based on this context:\n{context}\n\nAnswer: What is our refund policy?")

Costruire Funzionalità AI nelle Applicazioni

Per gli sviluppatori che costruiscono applicazioni con capacità AI, eseguire Gemma 4 localmente tramite l'API di Ollama è la via più veloce per un prototipo funzionante. L'API compatibile con OpenAI significa che puoi iniziare con Gemma 4 locale per lo sviluppo e passare alle API cloud per la produzione senza cambiare il codice dell'applicazione.

Piattaforme come ZBuild possono gestire l'infrastruttura dell'applicazione — frontend, backend, autenticazione, database — mentre tu ti concentri sul livello di integrazione AI. Punta l'endpoint AI della tua applicazione a localhost:11434 durante lo sviluppo e passa a un endpoint cloud quando sei pronto a scalare.

Risoluzione dei Problemi

Errori "Out of memory"

Se vedi errori di memoria:

Prova una quantizzazione più piccola: ollama pull gemma4:31b-q3_K_M
Riduci la context window: --num-ctx 4096
Chiudi altre applicazioni che utilizzano intensamente la GPU
Passa a un modello più piccolo: il 26B MoE offre una qualità vicina al 31B con un costo di memoria inferiore

Velocità di Generazione Lenta

Se la generazione è più lenta del previsto:

Controlla l'utilizzo della GPU: nvidia-smi (dovrebbe mostrare un alto utilizzo della GPU)
Assicurati che il modello entri interamente nella VRAM — l'offloading parziale su CPU è drasticamente più lento
Riduci --num-ctx per liberare VRAM per il calcolo
Controlla se altri processi stanno usando la GPU

Modello non Trovato

Se ollama run gemma4:26b-moe fallisce:

# Elenca i modelli disponibili
ollama list

# Cerca modelli Gemma 4
ollama search gemma4

# Scarica il modello specifico
ollama pull gemma4:26b-moe

Connessione API Rifiutata

Se le applicazioni non riescono a connettersi a localhost:11434:

# Controlla se Ollama è in esecuzione
ollama list

# Avvia il server Ollama manualmente
ollama serve

# Controlla la porta
curl http://localhost:11434/api/tags

Albero Decisionale per la Selezione del Modello

Usa questo per scegliere rapidamente il modello giusto:

Hai una GPU dedicata con 16GB+ di VRAM?

Sì → Vuoi la massima qualità o la massima efficienza?
- Massima qualità → gemma4:31b (Q4_K_M, richiede 20GB)
- Massima efficienza → gemma4:26b-moe (Q4_K_M, richiede 18GB)
No → Hai 8GB+ di RAM?
- Sì → gemma4:e4b (Q4_K_M, qualità migliore)
- No → gemma4:e2b (Q4_K_M, gira su 5GB)

Per la maggior parte degli sviluppatori con un desktop moderno o un PC da gaming: Inizia con gemma4:26b-moe. Offre il miglior rapporto qualità-risorse dell'intera famiglia Gemma 4.

Cosa Puoi Costruire

Con Gemma 4 in esecuzione locale, hai un backend AI a costo zero per:

Applicazioni di chat con totale privacy della conversazione
Strumenti di analisi del codice che lavorano su codebase proprietarie
Pipeline di elaborazione documenti per dati sensibili
Assistenti AI locali che funzionano offline
Prototipi di funzionalità AI prima di impegnarsi nei costi delle API cloud
Modelli ottimizzati (fine-tuned) per compiti specifici di dominio (Apache 2.0 lo permette liberamente)

La licenza Apache 2.0 significa che tutto ciò che costruisci è tuo — nessuna restrizione d'uso, nessuna condivisione dei ricavi, nessuna approvazione necessaria. Eseguilo localmente, distribuiscilo sui tuoi server, incorporalo nei tuoi prodotti. Ecco come appare l'AI veramente aperta.

Eseguire Gemma 4 localmente in 5 minuti: Guida completa all'installazione di Ollama (2026)