Draai Gemma 4 gratis in Claude Code met Ollama

Het moment waarop ik stopte met betalen voor AI-coderingstokens was op een dinsdagmiddag.

Ik had flink wat Claude API-credits verbruikt aan een content-automatiseringspipeline — niets bijzonders, gewoon een multi-agent workflow die data van vier websites schraapte, samenvatte en herformatteerde. Zo’n project waarbij je pas doorhebt dat je 400 API-calls hebt gedaan als het facturatie-dashboard je weer eens vriendelijk meldt dat je je limiet hebt overschreden.

Ik had inmiddels elk Gemma 4-model van Google, uitgebracht op 2 april 2026, onder de loep genomen. De benchmarks waren solide. Het 26B Mixture of Experts-model maakte indruk met zijn verhouding tussen snelheid en kwaliteit. Maar ik had er nog geen enkele geïntegreerd in mijn dagelijkse tool — Claude Code — als volledige vervanger voor cloud-inferentie. Ik ging ervan uit dat het verschil tussen een lokaal draaiend open model en de servers van Anthropic de ervaring frustrerend zou maken.

Daar zat ik dus helemaal naast. En hoe.

Binnen een uur nadat ik Ollama had geconfigureerd om het 26B-model van Gemma 4 via het Anthropic-compatibele endpoint van Claude Code te laten draaien, had ik exact dezelfde workflow voor bestandsbewerking, tool-aanroepen, bash-uitvoering en meerstaps-codering als waar ik eerder voor betaalde — maar nu volledig op mijn eigen hardware. Geen API-sleutel. Geen facturatie-dashboard. Geen data die mijn machine verlaat. En snel genoeg dat ik niet meer checkte of de reacties trager waren dan de cloudversie, want meestal was er nauwelijks verschil merkbaar.

Dit is geen theoretische opstelling. Ik gebruik het nu al meer dan een week op echte projecten. Hier lees je precies hoe je dezelfde workflow opzet, welk Gemma 4-model je het beste kiest voor jouw hardware, en waar de ervaring echt uitblinkt — en waar het nog tekortschiet.

Waarom Specifiek Gemma 4 — En Niet Een Ander Lokaal Model

Ik heb veel lokale modellen getest via Claude Code. Qwen 3.5, Llama 4 Scout, DeepSeek-varianten, Phi-modellen. Ik schreef een complete gids over Claude Code gratis draaien met Ollama waarin de algemene aanpak wordt uitgelegd. Dus waarom verdient Gemma 4 een eigen installatie-artikel?

Drie redenen, die elkaar versterken.

Token-efficiëntie verandert de rekensom. In mijn praktische review van Gemma 4 mat ik dat het 26B-model ongeveer 2,5 keer minder outputtokens gebruikte dan Qwen 3.5 voor vergelijkbare taken. Als je lokaal draait, betekent minder tokens snellere generatie, minder geheugendruk en kortere contextvensters die worden opgebruikt door de antwoorden van het model zelf. In een agentische code-loop waarin Claude Code vijf of zes tool-calls per taak aan elkaar schakelt, betekent dat efficiëntieverschil het verschil tussen een workflow die direct aanvoelt en een workflow waarbij je het gevoel hebt op de bus te wachten.

Native tool-calling werkt zonder kunstgrepen. Google heeft toolgebruik direct in Gemma 4 getraind — het is niet achteraf gefinetuned op een basismodel. Het praktische effect: wanneer Claude Code Gemma 4 vraagt om een bestand te lezen, een functie te bewerken of een shell-commando uit te voeren, formatteert het model de tool-call direct de eerste keer correct, veel vaker dan andere modellen die ik heb getest in vergelijkbare groottes. Ollama’s integratie van april 2026 bevestigt dat tool-calling, bestandslezingen, bewerkingsacties en bash-uitvoering allemaal correct werken via de compatibiliteitslaag van de Anthropic Messages API.

De Mixture of Experts-architectuur maakt het snel op bescheiden hardware. Het 26B-model activeert per inference-call slechts ongeveer 3,88 miljard parameters. De rest blijft slapen. Dat betekent dat een model met in totaal 26 miljard parameters draait op snelheden die je zou verwachten van een 4B-model — ongeveer 300 tokens per seconde op een Mac Studio M2 Ultra, volgens de benchmarks van Google. Mijn eigen cijfers lagen lager dan dat headline-getal, maar nog steeds sneller dan elk vergelijkbaar krachtig model dat ik lokaal heb gedraaid.

De combinatie — snel, efficiënt, betrouwbaar toolgebruik — maakt Gemma 4 het eerste lokale model dat ik daadwerkelijk zou aanraden voor dagelijks gebruik van Claude Code, zonder kanttekeningen als “het is goed voor simpele taken.” Het kan echt programmeerwerk aan.

Maar voordat je iets installeert, moet je bepalen welk model bij je hardware past. Als je dat verkeerd doet, verspil je uren.

Kies het Juiste Gemma 4-model voor Jouw Hardware

Google heeft vier modellen uitgebracht, en het kiezen van het verkeerde formaat is de meest voorkomende fout die ik zie bij mensen die lokaal AI willen draaien. Te klein, en je raakt gefrustreerd door de outputkwaliteit. Te groot, en de inferentie wordt tergend traag of het model laadt helemaal niet.

Hier is het overzicht met realistische hardware-eisen — niet de optimistische marketingcijfers van Google, maar wat je écht nodig hebt voor een bruikbare Claude Code-ervaring:

Voor Claude Code raad ik specifiek aan om te starten met het 26B MoE-model. Dit is waarom: Claude Code heeft minimaal 64K tokens context nodig om goed te functioneren — de agentische functies zijn afhankelijk van het gelijktijdig vasthouden van bestandsinhoud, gespreksgeschiedenis en tool-uitvoer in het geheugen. Het 26B-model voldoet aan deze contextvereiste en blijft snel genoeg voor interactieve codering. Het E4B-model werkt, maar bereikt een kwaliteitsplafond bij alles wat verder gaat dan eenvoudige bestandsbewerkingen en rechttoe rechtaan codegeneratie.

Zo controleer je of jouw hardware het aankan. Voordat je 18 GB aan modelgewichten downloadt om er vervolgens achter te komen dat je machine het niet trekt, gebruik je een hardwarecompatibiliteitschecker. Sites als WillItRunAI en CanIRun.ai laten je je GPU-type, VRAM, systeemgeheugen en GPU-cores invoeren om een compatibiliteitsschatting te krijgen. Selecteer de Gemma 4-variant die je overweegt, vul je specificaties in, en de tool vertelt je of inferentie comfortabel, mogelijk-maar-traag, of niet haalbaar is.

Enkele specifieke bevindingen uit mijn tests op verschillende hardware:

• MacBook Pro M4 Pro (48 GB unified memory): Het 26B-model genereert ongeveer 51 tokens per seconde. Zeer comfortabel voor echt programmeerwerk.
• M2 Pro (16 GB): Het 26B-model haalt 20-25 tokens per seconde. Bruikbaar, maar je merkt de pauzes bij langere outputs.
• RTX 4090 (24 GB VRAM): Het 31B dense model draait rond de 41 tokens per seconde. Het 26B MoE-model is aanzienlijk sneller — ruim boven de 60 tokens per seconde.
• RTX 3060 (12 GB VRAM): Het E4B-model draait soepel. Het 26B-model laadt met quantisatie, maar je zit snel aan je geheugenlimiet.

Zit je op een Apple Silicon Mac met 16 GB of meer unified memory, dan is het 26B-model met Q4_K_M quantisatie jouw beste keuze. Heb je een dedicated NVIDIA GPU met 24 GB VRAM, dan kun je het 31B dense model draaien en de hoogste outputkwaliteit behalen.

Nu je weet welk model je moet kiezen, volgt hier de daadwerkelijke installatie.

Stap 1: Installeer Ollama

Ollama is de lokale modelserver die deze hele workflow mogelijk maakt. Zie het als Docker voor taalmodellen — je haalt model-images binnen, Ollama beheert de runtime, en jouw applicaties communiceren ermee via een lokale API-endpoint.

Op macOS:

Download de installer van ollama.com of installeer via Homebrew:

brew install ollama

Op Linux:

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

Op Windows (via WSL):

Installeer eerst WSL als je dat nog niet hebt gedaan, en volg daarna de Linux-instructies binnen je WSL-distributie. Er is native Windows-ondersteuning, maar WSL biedt een consistentere ervaring met Claude Code.

Controleer na installatie of Ollama draait:

ollama --version

Je zou versie 0.6.x of hoger moeten zien — eerdere versies bevatten niet de Anthropic Messages API-compatibiliteit die Claude Code vereist.

Start de Ollama-server als deze niet automatisch draait:

ollama serve

Laat dit openstaan in een terminaltabblad of stel het in als achtergrondservice. Elke volgende stap is afhankelijk van een actieve Ollama die luistert op localhost:11434.

Stap 2: Haal je Gemma 4-model op

Hier komt je hardwarekeuze uit de vorige sectie om de hoek kijken. Voer het commando uit voor het door jou gekozen model:

# Voor de meeste gebruikers — de ideale balans tussen snelheid en kwaliteit
ollama pull gemma4:26b

# Voor high-end hardware — maximale kwaliteit
ollama pull gemma4:31b

# Voor lichtere setups — nog steeds geschikt voor basis-codering
ollama pull gemma4:e4b

Het 26B-model is ongeveer 18 GB groot. Met een redelijke internetverbinding duurt het downloaden 5-15 minuten. Ollama regelt alle kwantisatie en optimalisatie automatisch — je hoeft geen GGUF-bestanden of conversiescripts handmatig te configureren.

Zodra het downloaden voltooid is, controleer je of het model correct is geladen:

ollama run gemma4:26b "Write a Python function that reverses a linked list"

Binnen enkele seconden zou je een samenhangend codeantwoord moeten ontvangen. Als het model er langer dan 30 seconden over doet om te reageren, heeft je hardware het waarschijnlijk zwaar — overweeg dan om over te stappen op de E4B-variant.

Kritieke configuratie: stel het contextvenster in. Claude Code vereist minimaal 64K tokens aan context om goed te functioneren. Ollama gebruikt standaard een veel kleiner venster. Maak een Modelfile aan om dit te overschrijven:

# Maak een aangepaste Modelfile aan
cat <<EOF > Modelfile
FROM gemma4:26b
PARAMETER num_ctx 65536
EOF

# Maak het aangepaste model aan
ollama create gemma4-claude -f Modelfile

Hiermee maak je een nieuwe modelvariant aan genaamd gemma4-claude met een contextvenster van 65.536 tokens. Gebruik deze variant voor al je Claude Code-werk. Zonder deze stap raakt Claude Code tijdens het bewerken de draad kwijt, vergeet eerder gegeven instructies en produceert gefragmenteerde wijzigingen. Ik heb dit zelf ondervonden toen mijn agent probeerde een serviceklasse van 200 regels te refactoren en halverwege compleet vergat dat de tweede helft bestond.

Stap 3: Installeer Claude Code

Als je Claude Code nog niet hebt geïnstalleerd, is de installatie eenvoudig op alle platforms.

Vereisten: Node.js 18+ moet op je systeem geïnstalleerd zijn.

npm install -g @anthropic-ai/claude-code

Dit installeert de Claude Code CLI globaal. Het werkt op macOS, Linux, Windows en WSL.

Controleer de installatie:

claude --version

Als je Claude Code al gebruikt met een Anthropic API-sleutel, is dat prima — we gaan deze nu omleiden naar je lokale Ollama-instantie.

Stap 4: Verbind Claude Code met Ollama

Dit is de stap waar de magie gebeurt. Je vertelt Claude Code om zijn API-verzoeken naar je lokale Ollama-server te sturen in plaats van naar de cloud van Anthropic.

Stel de omgevingsvariabelen in. De exacte methode hangt af van je besturingssysteem en shell.

Voor macOS/Linux (zsh of bash):

export ANTHROPIC_BASE_URL="http://localhost:11434"
export ANTHROPIC_AUTH_TOKEN="ollama"
export ANTHROPIC_API_KEY="sk-placeholder"

Voeg deze toe aan je ~/.zshrc of ~/.bashrc om ze permanent te maken:

echo 'export ANTHROPIC_BASE_URL="http://localhost:11434"' >> ~/.zshrc
echo 'export ANTHROPIC_AUTH_TOKEN="ollama"' >> ~/.zshrc
echo 'export ANTHROPIC_API_KEY="sk-placeholder"' >> ~/.zshrc
source ~/.zshrc

Voor Windows (PowerShell):

$env:ANTHROPIC_BASE_URL = "http://localhost:11434"
$env:ANTHROPIC_AUTH_TOKEN = "ollama"
$env:ANTHROPIC_API_KEY = "sk-placeholder"

Voor permanente Windows-variabelen voeg je deze toe via Systeemeigenschappen > Omgevingsvariabelen of je PowerShell-profiel.

Wat hier gebeurt: Ollama stelt een API-endpoint beschikbaar dat de Messages API van Anthropic nabootst. Claude Code merkt het verschil niet. Het stuurt verzoeken naar wat het denkt dat de server van Anthropic is, Ollama onderschept ze, stuurt ze door naar je lokale Gemma 4-model en geeft antwoorden terug in exact het formaat dat Claude Code verwacht. De waarde van ANTHROPIC_API_KEY maakt niet uit — deze hoeft alleen maar niet leeg te zijn zodat Claude Code niet klaagt over een ontbrekende sleutel.

Stap 5: Starten en Verifiëren

Start nu Claude Code met je lokale Gemma 4-model:

claude --model gemma4-claude

Als je het aangepaste Modelfile met het 65K contextvenster hebt aangemaakt, gebruik dan gemma4-claude. Heb je die stap overgeslagen (niet doen!), gebruik dan direct gemma4:26b.

Je zou nu de Claude Code-interface moeten zien laden. Probeer een eenvoudige opdracht om te controleren of alles goed is aangesloten:

> Lees de huidige directory en geef alle bestanden weer

Claude Code zal zijn bestandsleestool gebruiken, het lokale Gemma 4-model via Ollama aanroepen en een geformatteerde directorylijst teruggeven. Als dit werkt, is je volledige stack operationeel — de volledige toolkit van Claude Code draait nu op een gratis, privé, lokaal model.

Veelvoorkomende problemen oplossen:

• "Connection refused"-fout: Ollama-server draait niet. Open een aparte terminal en voer ollama serve uit.
• Extreem trage reacties: Je model is te groot voor je hardware. Schakel over naar een kleinere variant of verhoog GPU-offloading met OLLAMA_NUM_GPU=99.
• Claude Code crasht bij lange bestanden: Contextvenster is te klein. Zorg dat je het aangepaste Modelfile hebt aangemaakt met num_ctx 65536.
• Tool-aanroepen mislukken: Controleer of je Ollama 0.6.x of nieuwer draait. Oudere versies ondersteunen het tool-calling-formaat dat Claude Code vereist niet volledig.

Wil je liever dat iemand deze setup vanaf nul voor je bouwt — afgestemd op jouw hardware en workflow? Ik neem precies dit soort opdrachten aan. Bekijk mijn werk op fiverr.com/s/EgxYmWD.

Wat Echt Werkt — Echte Coding-taken Die Ik Heb Gedraaid

Setupgidsen zijn waardeloos zonder eerlijke prestatieverslagen. Ik draai deze Gemma 4 + Ollama + Claude Code stack nu ruim een week op echte projecten. Dit is waar hij goed in is en waar hij tekortschiet.

Frontend UI-generatie — sterk. Ik vroeg het 26B-model via Claude Code om een React-dashboard te genereren met een zijbalk, datatabel, grafiekcomponent en dark mode-toggle. De output was netjes. Goede componentenscheiding. Tailwind-klassen die logisch samenwerkten. State management met React hooks zonder het te ingewikkeld te maken. Voor prototyping en interne tools vervangt dit volledig mijn behoefte om de API aan te spreken.

Bestanden bewerken over meerdere files — betrouwbaar. De multi-file editing workflow van Claude Code — bestand lezen, wijzigingen voorstellen, toepassen, tests draaien — werkt correct via de Ollama-brug. Het Gemma 4 26B-model formatteert zijn tool-aanroepen goed, gaat zonder verwarring om met bestands­paden en voert gerichte aanpassingen uit in plaats van hele bestanden te herschrijven. Ik heb het getest op een Laravel-project met meer dan 40 bestanden en het navigeerde de codebase zonder context te verliezen.

Code refactoren — goed, met grenzen. Ik vroeg om een controller van 300 regels te refactoren naar service classes met dependency injection. Het 26B-model splitste de logica op in drie services met correcte interfaces en constructor-injectie. De naamgevingsconventies waren redelijk. Waar het misging: het testbestand dat het genereerde voor een van de services had een kleine namespace-fout. Een fix van twee seconden, maar het is het vermelden waard — cloud-gehoste Claude Opus had dit direct goed gedaan.

Bash-commando’s genereren en uitvoeren — uitstekend. Een van de handigste features van Claude Code is het genereren en uitvoeren van shell-commando’s. Gemma 4 doet dit vol vertrouwen via Ollama. Git-operaties, npm-commando’s, Docker-beheer, bestands­systeem­manipulatie — het model begrijpt command-line workflows en genereert correcte commando’s voor het besturingssysteem waarop het draait.

Complexe multi-step agent-workflows — hier ligt de grens. Toen ik een pipeline opzette met vijf stappen — een webpagina scrapen, gestructureerde data extraheren, transformeren, naar een database schrijven en dan een samenvattend rapport genereren — voltooide het 26B-model de eerste vier stappen netjes, maar raakte in de war bij de samenvatting: het rapport verwees naar data uit stap twee in plaats van stap vier. Dezelfde pipeline via het 31B dense model loste het probleem op. Dit komt overeen met wat ik vond in mijn volledige Gemma 4 review — het 26B-model is uitzonderlijk voor taken met drie of vier redeneerstappen, maar verliest nauwkeurigheid bij langere ketens.

Multimodale taken — een echte verrassing. Gemma 4 ondersteunt vision native, en dit werkt via de Ollama + Claude Code-brug. Ik gaf het een screenshot van een Figma-design en vroeg om de bijbehorende HTML/CSS te genereren. Het herkende de layoutstructuur, het kleurenpalet en de typografie met redelijke nauwkeurigheid. Niet pixel-perfect — maar goed genoeg dat de output een bruikbaar startpunt was in plaats van een blanco canvas.

Het patroon waar ik op uitkom: gebruik de lokale Gemma 4-setup voor 80% van mijn coding-taken — bestandsbewerkingen, scaffolding, refactoren, commando-generatie, snelle prototypes. Schakel over naar cloud-gehoste Claude Opus voor de overige 20% die diepe multi-step reasoning, complexe architecturale keuzes of het werken met codebases met ingewikkelde afhankelijkheden vereist.

De Eerlijke Afwegingen — Wat Je Inlevert Door Lokaal Te Gaan

Ik zou je tekortdoen als ik dit zou presenteren als een directe vervanging voor de cloudservice van Anthropic. Dat is het niet. Dit is wat je opgeeft.

Prompt caching werkt niet. De prompt caching van Anthropic — die herhaalde gesprekken aanzienlijk versnelt door de systeemprompt en vroege context op te slaan — is niet beschikbaar via de Ollama-compatibiliteitslaag (stand april 2026). Elke aanvraag verwerkt de volledige context opnieuw vanaf het begin. Voor korte interacties maakt dit weinig uit. Maar bij lange codeersessies waarin je voortbouwt op 30+ beurten, merk je dat de latentie toeneemt naarmate de context groeit.

tool_choice wordt niet ondersteund. Claude Code gebruikt soms tool_choice om een specifieke tool-aanroep af te dwingen — bijvoorbeeld door het model te laten eisen dat het eerst een bestand moet lezen voordat het het mag bewerken. Deze parameter wordt niet ondersteund in de Anthropic API-compatibiliteitsmodus van Ollama. In de praktijk roept Gemma 4 meestal alsnog vrijwillig de juiste tools aan, maar af en toe probeert het model uit het geheugen te antwoorden wanneer het eigenlijk het bestand zou moeten lezen. Een kleine ergernis, geen showstopper.

Het redeneervermogen heeft een plafond. Het 26B-model van Gemma 4 scoort 31 op de intelligentie-index die ik bijhoud over verschillende modellen. Qwen 3.5 scoort 42. Claude Opus scoort aanzienlijk hoger. Bij taken die echte vernieuwing vereisen — het ontwerpen van een algoritme voor een uniek probleem, het opsporen van subtiele logische fouten in complexe bedrijfslogica, het maken van architecturale keuzes waarbij acht verschillende randvoorwaarden meespelen — merk je het verschil. Het model levert een sterke eerste versie. Om van die versie naar productie te gaan, is soms menselijke verfijning nodig die cloudmodellen automatisch afhandelen.

Geen streaming op sommige platforms. Afhankelijk van je Ollama-versie en besturingssysteem werkt het streamen van antwoorden mogelijk niet perfect. Je ziet dan het volledige antwoord in één keer verschijnen in plaats van token voor token. Functioneel identiek resultaat — maar de ervaring voelt minder interactief.

Je bent zelf verantwoordelijk voor updates. Wanneer Anthropic Claude bijwerkt, krijg je de verbeteringen automatisch. Met een lokaal model moet je zelf handmatig nieuwe versies van Gemma 4 ophalen zodra Google quantisatieverbeteringen, bugfixes en fijn-afgestelde varianten uitbrengt. De community is actief, maar het blijft een handmatig proces.

Geen van deze punten heeft mijn workflow om zeep geholpen. De voordelen van privacy, snelheid en nul kosten wegen voor het merendeel van mijn dagelijkse codeertaken ruimschoots op tegen de beperkingen. Maar ga er wel in met realistische verwachtingen.

Verder dan coderen — Wat deze stack nog meer aankan

Zodra je Gemma 4 binnen Claude Code via Ollama hebt draaien, ben je niet beperkt tot alleen code schrijven. Het agent-framework ondersteunt elke workflow die je kunt uitdrukken als een reeks tool-calls.

Automatisch e-mails opstellen. Verbind Claude Code met je lokale bestandssysteem waar e-mailsjablonen staan, beschrijf de e-mails die je nodig hebt, en de agent genereert gepersonaliseerde concepten. Alles lokaal. Geen enkele e-mailinhoud raakt externe servers.

Leadonderzoek en scraping. Met de bash-executie van Claude Code en het redeneervermogen van Gemma 4 bouw je eenvoudig scraping-pijplijnen. Haal data van openbare bronnen, extraheer gestructureerde informatie, en formatteer het voor je CRM. Ik heb geplande Ollama-prompts binnen Claude Code opgezet die dit soort taken op een timer uitvoeren — geautomatiseerde dataverzameling zonder afhankelijkheid van de cloud.

Documentanalyse en samenvatting. Voer PDF’s, markdown-bestanden of codedocumentatie door de pipeline en ontvang gestructureerde samenvattingen. Dankzij de multimodale mogelijkheden kun je zelfs screenshots en diagrammen verwerken.

Slack- en workspace-integraties. Via MCP (Model Context Protocol)-servers en het tool-ecosysteem van Claude Code kun je je lokale Gemma 4-agent verbinden met Slack, Google Workspace en andere productiviteitstools. Het model verzorgt het denkwerk; de toolverbindingen regelen de acties. Alles draait op je eigen machine.

De rode draad: elke workflow waarbij dataprivacy telt, waar je nul marginale kosten per query wilt, of waar je honderden geautomatiseerde verzoeken wilt uitvoeren zonder je zorgen te maken over limieten. Dáár zijn lokale modellen niet alleen gelijkwaardig aan clouddiensten — ze overtreffen ze.

Wat Ik de Tweede Keer Anders Zou Doen bij het Opzetten

Na een week dagelijks gebruik zijn er een paar optimalisaties die me op dag één veel tijd hadden bespaard.

Stel OLLAMA_NUM_GPU=99 direct in. Hiermee geef je Ollama de opdracht om zoveel mogelijk model-lagen naar de GPU te offloaden. Ik heb twee dagen zitten puzzelen waarom mijn 26B-model trager was dan verwacht, voordat ik ontdekte dat Ollama standaard de helft van de lagen op de CPU draaide. Eén environment variable loste het op:

export OLLAMA_NUM_GPU=99

Maak het 65K context Modelfile aan vóór je eerste Claude Code-sessie. Ik begon met Ollama’s standaard context window — 8K of 16K afhankelijk van het model — en snapte niet waarom Claude Code steeds het overzicht over bestanden verloor. De 65K-minimum is niet optioneel. Het is een vereiste voor de agentische functies van Claude Code om correct te werken.

Houd een cloud fallback geconfigureerd. Ik heb mijn Anthropic API-sleutel niet verwijderd — ik heb een simpele shell-alias gemaakt waarmee ik kan schakelen tussen lokale en cloudmodus:

alias claude-local='ANTHROPIC_BASE_URL=http://localhost:11434 ANTHROPIC_AUTH_TOKEN=ollama claude --model gemma4-claude'
alias claude-cloud='ANTHROPIC_BASE_URL=https://api.anthropic.com claude'

Wanneer het lokale model vastloopt op een complexe taak, schakel ik binnen twee seconden over naar cloudmodus. Het beste van beide werelden.

Monitor je VRAM. Als je op een gedeelde machine werkt of andere GPU-intensieve applicaties naast Ollama draait, zal VRAM-concurrentie ongemerkt de prestaties verslechteren. Op macOS toont Activiteitenweergave het gebruik van unified memory. Op Linux met NVIDIA kun je met nvidia-smi het GPU-geheugen controleren. Als je model moet concurreren om VRAM met bijvoorbeeld een browser die GPU-versnelde video draait, zul je je afvragen waarom de inference ineens drie keer zo traag is.

Het Grotere Plaatje — Waarom Dit Verder Gaat Dan Gratis API-aanroepen

Geld besparen op AI-tokens is het voor de hand liggende voordeel. Maar na een week werken met deze workflow, is kostenbesparing niet waar ik steeds aan blijf denken.

Het is controle.

Elke regel code die ik via deze stack genereer, blijft op mijn eigen machine. Elk project dat ik analyseer, elk bestand dat ik lees, elke opdracht die ik uitvoer — niets daarvan raakt een externe server. Voor klantwerk met NDA’s, voor propriëtaire codebases, voor alles waarbij gevoelige data komt kijken, is dat geen handige extra. Dat is een compliance-eis die door architectuur wordt opgelost in plaats van door juridische contracten.

De snelheid was het tweede dat me verraste. Zonder netwerkvertraging — geen retourtje naar een datacenter, geen wachtrij achter verzoeken van andere gebruikers — worden de responstijden volledig bepaald door mijn eigen hardware. Tijdens piekuren, wanneer cloud-API’s vertragen, blijft mijn lokale setup even snel. Om 2 uur ’s nachts, als ik in een codeflow zit en prompts erdoorheen jaag, is er geen rate limit die me afremt.

En de rekensom voor schaalbaarheid is omgekeerd. Bij cloud-API’s betekent meer gebruik: meer kosten. Bij lokale inferentie zijn de kosten vast — je bezit de hardware al. Of je nu 10 of 10.000 queries doet, je elektriciteitsrekening verandert nauwelijks. Voor agentische workflows die tientallen tool-calls per taak aan elkaar schakelen, maakt dit architecturen haalbaar die via cloud-billing absurd duur zouden zijn.

Google die Gemma 4 uitbrengt onder Apache 2.0 — de meest permissieve open-sourcelicentie die er is — haalt het laatste juridische obstakel weg. Geen maandelijkse actieve gebruikerslimieten zoals bij Meta’s Llama-licentie. Geen handhaving van een acceptable-use policy. Volledige commerciële vrijheid. Je kunt hier producten op bouwen, ze uitleveren aan klanten, en je bent niemand een licentievergoeding of gebruiksrapport verschuldigd.

De toekomst van AI-ondersteunde ontwikkeling is niet kiezen tussen cloud en lokaal. Het is beide draaien — simpele taken routeren naar je lokale Gemma 4-instantie voor snelheid en privacy, complexe redeneringen opschalen naar Claude Opus of GPT wanneer je de grensverleggende capaciteit nodig hebt. Deze setup ís die hybride toekomst, vandaag al beschikbaar, nu al werkend.

Eén commando om het model te downloaden. Drie omgevingsvariabelen om te verbinden. Twintig minuten vanaf het lezen van deze zin tot het draaien van een gratis AI-coding-agent op je eigen hardware.

De enige vraag die overblijft is: wat ga jij ermee bouwen?

Veelgestelde Vragen

Werkt Gemma 4 met alle Claude Code-functies via Ollama?

Bestanden lezen, bestanden bewerken, bash-uitvoering en tool-aanroepen werken allemaal correct vanaf april 2026. Prompt-caching en tool_choice (gedwongen toolselectie) worden niet ondersteund via Ollama’s compatibiliteitslaag. Zie de trade-offs sectie hierboven voor een volledige vergelijking van de mogelijkheden.

Welke Gemma 4-model is het beste voor Claude Code?

Het 26B MoE-model biedt de beste balans tussen snelheid en kwaliteit op de meeste hardware. Per inference-call worden slechts 3,88 miljard parameters geactiveerd, terwijl de outputkwaliteit dicht in de buurt komt van de 31B dense-variant. Je hebt minimaal 16 GB RAM nodig en moet een contextvenster van 65K tokens configureren.

Hoe snel draait Gemma 4 lokaal vergeleken met Claude in de cloud?

Op een MacBook Pro M4 Pro met 48 GB geheugen genereert het 26B-model ongeveer 51 tokens per seconde. Een RTX 4090 haalt met het 31B-model circa 41 tokens per seconde. Cloud Claude is doorgaans sneller qua ruwe doorvoersnelheid, maar lokale inference elimineert netwerkvertraging — de responstijd voor de eerste token is vaak vergelijkbaar.

Kan ik Gemma 4 draaien op een MacBook Air of budgetlaptop?

Het E4B-model (4 miljard parameters) draait op machines met 8 GB RAM en kan eenvoudige coderingstaken aan. Voor serieuze Claude Code-workflows wil je het 26B-model met minimaal 16 GB RAM. Het E2B-model draait op vrijwel alles, maar is te beperkt voor zinvol agentisch coderen.

Is deze setup echt gratis zonder verborgen kosten?

Gemma 4 is Apache 2.0 gelicentieerd — gratis voor elk gebruik, ook commercieel. Ollama is open source. Claude Code CLI is gratis te installeren. De enige kosten zijn je hardware en elektriciteit. Geen API-sleutels, geen abonnementen, geen gebruikstracking, geen data die je machine verlaat.

Laten We Samenwerken

Wil je AI-systemen bouwen, workflows automatiseren of je technische infrastructuur opschalen? Ik help je graag verder.

• Fiverr (maatwerk & integraties): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (enterprise-oplossingen): ramlit.com
• ColorPark (design & branding): colorpark.io
• xCyberSecurity (beveiligingsdiensten): xcybersecurity.io