Belangrijkste inzichten

Het draaien van Gemma 4 lokaal duurt minder dan 5 minuten met Ollama: installeer Ollama, voer één commando uit, en je hebt een volledig capabel AI-model draaiend op je eigen hardware met nul API-kosten, nul data die je machine verlaat, en nul gebruiksbeperkingen onder Apache 2.0. Het E2B-model draait op elke laptop. Het 26B MoE-model past op een enkele RTX 4090 en levert kwaliteit die wedijvert met modellen die 10x meer actieve parameters hebben.

Draai Gemma 4 lokaal: De volledige gids

Waarom Gemma 4 lokaal draaien?

Voordat we in de installatie duiken, is dit waarom lokale inferentie belangrijk is in 2026:

• Privacy — Je data verlaat nooit je machine. Er worden geen prompts naar externe servers verzonden. Cruciaal voor eigen code, juridische documenten, medische gegevens of andere gevoelige informatie.
• Kosten — Nul kosten per token na de eenmalige investering in hardware. Grootverbruikers besparen honderden dollars per maand vergeleken met API-prijzen.
• Latency — Geen netwerkvertragingen. De E2B- en E4B-modellen reageren in milliseconden op moderne hardware.
• Betrouwbaarheid — Geen API-limieten, geen storingen, geen beleidswijzigingen van providers. Je model is altijd beschikbaar.
• Aanpasbaarheid — Fine-tune, quantize en wijzig het model vrij onder Apache 2.0.
• Offline toegang — Werkt zonder internetverbinding zodra het model is gedownload.

Gemma 4 is bijzonder goed geschikt voor lokale implementatie omdat Google de kleinere modellen specifiek heeft ontworpen voor gebruik aan de rand van het netwerk en op apparaten zelf. De E2B- en E4B-modellen zijn geen bijzaak — het zijn eersteklas modellen die zijn geoptimaliseerd voor de beperkingen van lokale hardware.

Vereisten

Hardwarevereisten per model

Belangrijkste inzicht: Als je een laptop hebt die na 2022 is gemaakt, kun je E2B of E4B draaien. Als je een RTX 4090 (24GB VRAM) of een Apple M-serie Mac met 32GB+ RAM hebt, kun je de 26B MoE of 31B Dense draaien met 4-bit quantisatie.

Softwarevereisten

• Besturingssysteem: macOS, Linux, of Windows
• Ollama: Versie 0.6+ (download van ollama.com)
• GPU-stuurprogramma's (optioneel): NVIDIA CUDA 12+ voor NVIDIA-GPU's, geen extra stuurprogramma's nodig voor Apple Silicon

Stap 1: Installeer Ollama

macOS

Download van ollama.com/download of gebruik Homebrew:

brew install ollama

Linux

Installatiescript van één regel:

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

Windows

Download het installatiebestand van ollama.com/download en voer het uit. Ollama draait als een achtergrondservice op Windows.

Controleer de installatie

ollama --version

Je zou ollama version 0.6.x of hoger moeten zien. Als je een versienummer ziet, is Ollama correct geïnstalleerd.

Bron: Ollama installatiehandleiding

Stap 2: Haal een Gemma 4-model op

Kies het model dat bij je hardware past:

Voor laptops en lichte werklasten

# Kleinste model — draait op elke moderne laptop (5GB RAM)
ollama pull gemma4:e2b

# Klein model met bredere capaciteiten (5-9GB RAM)
ollama pull gemma4:e4b

Voor desktops met een toegewezen GPU

# Beste efficiëntie — vlaggenschipkwaliteit met 3.8B actieve parameters (18GB RAM)
ollama pull gemma4:26b-moe

# Hoogste kwaliteit — volledige 31B parameters (20GB RAM)
ollama pull gemma4:31b

Quantisatie specificeren

Standaard haalt Ollama de aanbevolen quantisatie op voor elk model (meestal Q4_K_M voor een goede balans tussen kwaliteit en grootte). Je kunt verschillende quantisaties specificeren:

# Hogere kwaliteit, grotere omvang
ollama pull gemma4:31b-q5_K_M

# Kleinere omvang, iets lagere kwaliteit
ollama pull gemma4:31b-q3_K_M

# Volledige precisie (vereist veel meer RAM)
ollama pull gemma4:31b-fp16

De download duurt enkele minuten, afhankelijk van je internetverbinding. Modelgroottes variëren van ~1.5GB (E2B 4-bit) tot ~62GB (31B FP16).

Stap 3: Draai Gemma 4

Interactieve chat

ollama run gemma4:e4b

Dit opent een interactieve chatsessie. Typ je prompt en druk op Enter:

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

Het model zal direct in je terminal reageren. Typ /bye om af te sluiten.

Enkele prompt (niet-interactief)

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

Met Thinking Mode

Gemma 4 ondersteunt een configureerbare thinking mode voor complexe taken. Schakel dit in door een system prompt toe te voegen:

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

Voor wiskunde, logica en complexe analysetaken verbetert de thinking mode de kwaliteit van het antwoord aanzienlijk. Het model zal 4,000+ tokens aan interne redenering genereren voordat het zijn definitieve reactie produceert.

Stap 4: Gebruik de lokale API

Ollama stelt een REST API beschikbaar op localhost:11434 die compatibel is met het OpenAI API-formaat. Dit betekent dat elke tool of bibliotheek die de API van OpenAI ondersteunt, verbinding kan maken met je lokale Gemma 4 met een simpele wijziging van de URL.

Test de API met 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
}'

OpenAI-compatibel eindpunt

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

Bron: Ollama API-documentatie

Stap 5: Integreer met je applicatie

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"]

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

Python met OpenAI SDK

from openai import OpenAI

# Verwijs naar lokale Ollama in plaats van OpenAI
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Ollama vereist geen echte 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);

Gebruik met 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)

Gebruik met 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)

Uitleg over quantisatie-opties

Quantisatie vermindert de modelgrootte en het geheugengebruik door getallen met een lagere precisie te gebruiken om modelgewichten weer te geven. De afweging is tussen kwaliteit en resourcegebruik:

Q4_K_M is de ideale balans voor de meeste gebruikers. Het kwaliteitsverschil met FP16 is klein genoeg dat de resultaten voor de meeste taken niet te onderscheiden zijn, terwijl de geheugenbesparing van 75% het verschil maakt tussen "heeft een server nodig" en "draait op mijn laptop."

De juiste quantisatie kiezen

Voor Gemma 4 E2B/E4B: Gebruik de standaard (Q4_K_M). Deze modellen zijn al klein genoeg dat hogere quantisatie de gebruikerservaring niet wezenlijk verandert.

Voor Gemma 4 26B MoE: Q4_K_M past in 18GB RAM, wat binnen de 24GB VRAM van een RTX 4090 valt, met ruimte voor de KV cache. Als je 48GB+ VRAM hebt (A6000, dubbele GPU's), overweeg dan Q8_0 voor marginaal betere kwaliteit.

Voor Gemma 4 31B Dense: Q4_K_M met 20GB past in een RTX 4090 met krappe marges. Q5_K_M levert iets betere resultaten maar vereist ~24GB, waardoor al het beschikbare VRAM wordt verbruikt. Als je 32GB+ VRAM hebt (RTX 5090, A6000), zijn Q6_K of Q8_0 de upgrade waard.

Prestatie-optimalisatie

GPU-offloading

Ollama verplaatst model-lagen automatisch naar de GPU wanneer er VRAM beschikbaar is. Als slechts een deel van het model in het VRAM past, verdeelt Ollama het tussen GPU en CPU. Je kunt dit beheren:

# Forceer alle lagen naar de GPU (mislukt bij onvoldoende VRAM)
OLLAMA_NUM_GPU=999 ollama run gemma4:26b-moe

# Forceer alleen CPU (nuttig om te testen)
OLLAMA_NUM_GPU=0 ollama run gemma4:e4b

Configuratie van het contextvenster

Standaard gebruikt Ollama een contextvenster van 2048 tokens voor efficiëntie. Om de volledige contextcapaciteiten van Gemma 4 te benutten:

# Stel het contextvenster in op 32K tokens
ollama run gemma4:26b-moe --num-ctx 32768

# Stel het contextvenster in op 128K tokens (vereist meer RAM)
ollama run gemma4:26b-moe --num-ctx 131072

Belangrijk: Grotere contextvensters verbruiken meer RAM voor de KV cache. Een contextvenster van 128K op het 31B-model kan 8-16GB extra RAM vereisen bovenop de modelgewichten. Begin met 32K en verhoog dit alleen als je gebruikssituatie dit vereist.

Gelijktijdige verzoeken

Ollama ondersteunt het gelijktijdig verwerken van meerdere verzoeken:

# Sta maximaal 4 gelijktijdige verzoeken toe
OLLAMA_NUM_PARALLEL=4 ollama serve

Elk gelijktijdig verzoek voegt geheugenoverhead toe voor de bijbehorende KV cache. Op een 24GB GPU die de 26B MoE draait op Q4_K_M (~18GB), heb je ongeveer 6GB over — genoeg voor 2-3 gelijktijdige verzoeken met korte contexten.

Keep-alive-instellingen

Standaard houdt Ollama modellen 5 minuten in het geheugen geladen na het laatste verzoek. Pas dit aan voor jouw gebruikssituatie:

# Houd model 1 uur geladen
OLLAMA_KEEP_ALIVE=3600 ollama serve

# Houd model onbeperkt geladen
OLLAMA_KEEP_ALIVE=-1 ollama serve

# Verwijder direct na elk verzoek uit geheugen (bespaart geheugen)
OLLAMA_KEEP_ALIVE=0 ollama serve

NVIDIA RTX-optimalisatie

NVIDIA heeft geoptimaliseerde versies van Gemma 4 uitgebracht voor RTX-GPU's. Deze optimalisaties omvatten:

• Aangepaste CUDA-kernels voor het attention-mechanisme van Gemma 4
• TensorRT-LLM integratie voor snellere inferentie
• Flash Attention ondersteuning voor verminderd geheugengebruik tijdens inferentie met een lange context
• Geoptimaliseerd KV cache management voor een betere doorvoer

Installeren van de door NVIDIA geoptimaliseerde Gemma 4

Als je een RTX 4000 of 5000-serie GPU hebt:

# Controleer je GPU
nvidia-smi

# Haal de NVIDIA-geoptimaliseerde versie op (indien beschikbaar in Ollama)
ollama pull gemma4:31b-nvidia

Gebruik anders NVIDIA's AI Workbench of TensorRT-LLM direct voor maximale prestaties. De NVIDIA-geoptimaliseerde versies kunnen 30-50% snellere inferentie bieden op RTX-GPU's vergeleken met standaard Ollama-builds.

Prestatiebenchmarks uit de praktijk

Gemeten op gangbare hardwareconfiguraties:

Tokens per seconde (Generatiesnelheid)

Context: De menselijke leessnelheid is ongeveer 4-5 tokens per seconde. Elk model dat meer dan 10 tok/s genereert, voelt "direct" aan bij interactief gebruik. De E2B- en E4B-modellen zijn snel genoeg voor real-time streaming op bijna elke hardware.

Tijd tot eerste token (Latency)

Voor interactieve applicaties is de tijd tot het eerste token belangrijker dan de generatiesnelheid. De E2B- en E4B-modellen beginnen bijna onmiddellijk met genereren, zelfs op een CPU, wat ze ideaal maakt voor real-time chatinterfaces.

Veelvoorkomende toepassingen

Lokale programmeerassistent

Gebruik Gemma 4 als een privé programmeerassistent die je code nooit naar externe servers verzendt:

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."

Koppel dit aan VS Code-extensies zoals Continue of Twinny die Ollama als backend ondersteunen.

Documentanalyse

Verwerk gevoelige documenten lokaal:

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

Met een context van 256K kan het 31B-model documenten tot ~750 pagina's verwerken — voldoende voor de meeste contracten, onderzoeksrapporten en technische documentatie.

Lokale RAG (Retrieval-Augmented Generation)

Combineer Gemma 4 met een lokale vector-database voor een volledig privaat RAG-systeem:

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

# Gebruik Gemma 4 voor zowel embeddings als generatie
embeddings = OllamaEmbeddings(model="gemma4:e4b")
llm = Ollama(model="gemma4:26b-moe")

# Maak een vector store op basis van je documenten
vectorstore = Chroma.from_documents(documents, embeddings)

# Bevragen met 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?")

AI-functies inbouwen in applicaties

Voor ontwikkelaars die applicaties bouwen met AI-mogelijkheden, is het lokaal draaien van Gemma 4 via de API van Ollama het snelste pad naar een werkend prototype. De OpenAI-compatibele API betekent dat je kunt beginnen met lokale Gemma 4 voor ontwikkeling en kunt overstappen naar cloud-API's voor productie zonder de applicatiecode te wijzigen.

Platformen zoals ZBuild kunnen de infrastructuur van de applicatie afhandelen — frontend, backend, authenticatie, database — terwijl jij je concentreert op de AI-integratielaag. Verwijs het AI-eindpunt van je applicatie naar localhost:11434 tijdens de ontwikkeling en wissel naar een cloud-eindpunt wanneer je klaar bent om te schalen.

Probleemoplossing

"Out of memory" fouten

Als je geheugenfouten ziet:

1. Probeer een kleinere quantisatie: ollama pull gemma4:31b-q3_K_M
2. Verklein het contextvenster: --num-ctx 4096
3. Sluit andere GPU-intensieve applicaties
4. Schakel over naar een kleiner model: de 26B MoE levert bijna 31B-kwaliteit bij lagere geheugenkosten

Trage generatiesnelheid

Als het genereren trager is dan verwacht:

1. Controleer het GPU-gebruik: nvidia-smi (zou een hoog GPU-gebruik moeten tonen)
2. Zorg ervoor dat het model volledig in het VRAM past — gedeeltelijke CPU-offloading is aanzienlijk trager
3. Verlaag --num-ctx om VRAM vrij te maken voor berekeningen
4. Controleer of andere processen de GPU gebruiken

Model niet gevonden

Als ollama run gemma4:26b-moe mislukt:

# Toon beschikbare modellen
ollama list

# Zoek naar Gemma 4 modellen
ollama search gemma4

# Haal het specifieke model op
ollama pull gemma4:26b-moe

API-verbinding geweigerd

Als applicaties geen verbinding kunnen maken met localhost:11434:

# Controleer of Ollama draait
ollama list

# Start de Ollama-server handmatig
ollama serve

# Controleer de poort
curl http://localhost:11434/api/tags

Beslisboom voor modelselectie

Gebruik dit om snel het juiste model te kiezen:

Heb je een toegewezen GPU met 16GB+ VRAM?

• Ja → Wil je maximale kwaliteit of maximale efficiëntie?
  • Maximale kwaliteit → gemma4:31b (Q4_K_M, vereist 20GB)
  • Maximale efficiëntie → gemma4:26b-moe (Q4_K_M, vereist 18GB)
• Nee → Heb je 8GB+ RAM?
  • Ja → gemma4:e4b (Q4_K_M, betere kwaliteit)
  • Nee → gemma4:e2b (Q4_K_M, draait op 5GB)

Voor de meeste ontwikkelaars met een moderne desktop of gaming-pc: Begin met gemma4:26b-moe. Het biedt de beste kwaliteit-tot-resource verhouding in de hele Gemma 4 familie.

Wat je kunt bouwen

Met Gemma 4 lokaal draaiend, heb je een gratis AI-backend voor:

• Chat-applicaties met volledige privacy van gesprekken
• Code-analyse tools die werken op bedrijfseigen codebases
• Documentverwerkings-pipelines voor gevoelige gegevens
• Lokale AI-assistenten die offline werken
• Prototype AI-functies voordat je je vastlegt aan cloud API-kosten
• Fine-tuned modellen voor domeinspecifieke taken (Apache 2.0 staat dit vrij toe)

De Apache 2.0 licentie betekent dat alles wat je bouwt van jou is — geen gebruiksbeperkingen, geen winstdeling, geen goedkeuring nodig. Draai het lokaal, implementeer het op je servers, integreer het in je producten. Dit is hoe echt open AI eruitziet.

Bronnen

• Gemma 4 Aankondiging - Google Blog
• Gemma 4 op Ollama
• Ollama Installatiehandleiding
• Ollama API Documentatie
• NVIDIA Gemma 4 RTX Optimalisatie
• Gemma 4 Technisch Rapport - Google DeepMind
• Gemma 4 Hugging Face Modellen
• Continue.dev - Lokale AI-codeassistent
• LangChain Ollama Integratie
• Google AI voor ontwikkelaars - Gemma