Lokale AI: Waarom Ik Modellen op Mijn Eigen Computer Draai

Op een gegeven moment begon het te irriteren. Niet AI als technologie, maar het feit dat elke vraag, elk stukje code, elke ruwe gedachte die ik intypte werd verstuurd naar servers die ik niet beheer, van bedrijven die ik niet volledig vertrouw.

Dat leidde me naar lokale AI. En ik ben er niet meer van weggegaan.

Hieronder leg ik uit waarom ik steeds vaker modellen draai op mijn eigen machine, hoe je dat aanpakt, en wanneer het de moeite waard is (en wanneer niet).

Het privacy-argument is sterker dan je denkt

De cloudversies van Claude, ChatGPT en anderen zijn prima bruikbaar voor de meeste vragen. Maar er zijn situaties waarin je echt niet wilt dat je input op een externe server belandt:

• Code van een klant met gevoelige bedrijfslogica
• Persoonlijke aantekeningen en dagboekfragmenten
• Contracten of juridische documenten
• Ideeën in een vroeg stadium die je nog niet wilt "delen"

De terms of service van de grote AI-aanbieders zijn lang en vaag. Ze zeggen dat ze je data niet gebruiken voor het trainen van commerciële modellen, maar wie controleert dat? Met een lokaal model is het antwoord simpel: de data verlaat je machine niet.

Als je iets niet aan een willekeurige collega zou laten lezen, stuur het dan niet naar een cloud-API.

Dat klinkt streng, maar het werkt als een handig mentaal model. Gevoelige context? Lokaal. Publieke of anonieme vragen? Cloud is prima.

De kwaliteitskloof is kleiner dan iedereen denkt

Moderne lokale modellen zijn verrassend goed. Twee jaar geleden stelde je een vraag aan een lokaal model en je merkte meteen het verschil: een generieke, haperende, soms onzinnige respons. Dat beeld is achterhaald.

De verbetering zit in twee ontwikkelingen.

De modellen zelf zijn veel beter geworden. Llama 3, Mistral, Qwen, Gemma: dit zijn serieuze modellen van grote labs die hun gewichten publiek beschikbaar stellen. Ze zijn niet goed "voor een lokaal model", ze zijn gewoon goed.

Kwantisatie maakt grote modellen haalbaar. Dit is de techniek die het mogelijk maakt om grote modellen op bescheiden hardware te draaien. Een model met 7 miljard parameters vraagt normaal gesproken tientallen gigabytes aan GPU-geheugen. Met 4-bit kwantisatie past hetzelfde model in 4 tot 5 GB. Je verliest iets aan precisie, maar in de praktijk merk je er nauwelijks iets van bij teksttaken.

Op een MacBook Pro met een M3-chip en 36 GB unified memory draaien modellen tot 32 miljard parameters soepel, volledig lokaal, volledig offline, op bruikbare snelheden.

Hoe je begint: twee tools die je moet kennen

Er zijn twee tools die de instap makkelijk maken. Je hoeft geen modelgewichten handmatig te downloaden of commando's te begrijpen om te starten.

Ollama

Ollama is de tool waarmee het meeste werk gedaan wordt. Het is een command-line applicatie die modellen downloadt, beheert en via een lokale API aanbiedt. Installeren op macOS gaat zo:

brew install ollama

Daarna start je de server:

ollama serve

En je haalt een model op, in dit geval Llama 3.2:

ollama pull llama3.2

Praten met het model kan direct in de terminal:

ollama run llama3.2

De kracht van Ollama zit in de API. Het biedt een OpenAI-compatibele REST API op http://localhost:11434. Dat betekent dat elk stuk software dat werkt met de OpenAI API, zonder aanpassingen kan praten met je lokale model.

LM Studio

Als je liever een grafische interface hebt, is LM Studio de betere keuze. Je kunt er modellen in zoeken (het integreert met Hugging Face), ze downloaden, en er direct mee chatten vanuit de interface.

LM Studio heeft ook een ingebouwde lokale server, handig als je tijdelijk een lokaal eindpunt wilt. De interface toont ook live hoe snel een model tokens genereert en hoeveel geheugen het gebruikt, wat helpt om te begrijpen wat je machine aankan.

Welke modellen werken goed lokaal?

Op basis van dagelijks gebruik zijn dit de huidige favorieten.

Voor algemeen gebruik en schrijven:

• Llama 3.2 (3B of 8B) -- Snel, compact, verrassend capabel. Goed voor snelle vragen.
• Mistral 7B -- Uitstekende verhouding tussen grootte en kwaliteit. Sterk in redeneren en instructies opvolgen.
• Qwen2.5 14B -- Go-to voor complexere taken. Meertalig sterk, inclusief Nederlands.

Voor code:

• Qwen2.5-Coder 7B -- Specifiek getraind op code. Begrijpt context goed en haalt zelden onzin uit.
• DeepSeek-Coder-V2 Lite -- Sterk in meerdere talen. Heeft een langere context window.

Voor grotere taken met meer context:

• Llama 3.1 70B (als je hardware het toelaat) -- Dichtbij frontier-kwaliteit, maar vraagt flink wat RAM.

Wanneer lokaal beter is dan de cloud

Eerlijk gezegd: de beste frontier-modellen, Claude Opus, GPT-4o, Gemini Ultra, zijn nog steeds beter dan wat je lokaal kunt draaien. Zeker voor complexe redenering, lange context en subtiele taaltaken.

Maar "beter" is niet altijd het enige criterium.

Lokaal wint op:

• Privacy -- Geen data die je machine verlaat.
• Kosten bij volume -- Als je honderden of duizenden verzoeken per dag doet, lopen API-kosten snel op. Een lokaal model kost na de installatie niets.
• Offline gebruik -- In een vliegtuig of als je internet traag is. Lokaal werkt altijd.
• Latentie voor korte taken -- Een klein lokaal model dat direct op je chip draait, reageert soms sneller dan een API-call naar een overbelaste server.
• Experimenteren zonder meter die loopt -- Wil je testen hoe een model reageert op duizend variaties van een prompt? Doe het lokaal.

Cloud wint op:

• Complexe redenering en diepgaande analyse
• Zeer lange contextvensters (meerdere boeken tegelijk)
• Multimodaliteit (foto's, audio, video)
• Snelheid bij grote modellen

Een werkbare vuistregel: begin lokaal, en switch naar cloud zodra de kwaliteit echt niet voldoet voor de taak.

Een praktisch voorbeeld: lokale codereview

Voor projecten waarbij je de code niet wilt uploaden naar externe servers is een snelle codereview of "leg dit stukje code uit" precies het soort taak waarbij lokaal goed werkt.

Met Ollama en de OpenAI-compatibele API kun je in je editor een extensie instellen die praat met je lokale model. In VS Code werkt dit via de Continue-extensie:

{
  "models": [
    {
      "title": "Lokaal: Qwen2.5-Coder",
      "provider": "ollama",
      "model": "qwen2.5-coder:7b"
    }
  ]
}

Hiermee heb je een volwaardige AI-coding-assistent in je editor die volledig offline werkt en geen enkele regel code naar buiten stuurt. Voor een freelancer of iemand die met gevoelige codebases werkt, is dat een stuk rustiger.

De beperkingen eerlijk benoemen

Lokale AI is geen perfecte vervanging voor alles. Een paar beperkingen die je dagelijks tegenkomt:

• Snelheid bij grote modellen: Een 32B model op een MacBook genereert zo'n 15 tot 20 tokens per seconde. Dat voelt traag als je gewend bent aan cloud-snelheden.
• Contextvenster: Veel lokale modellen hebben een beperkter contextvenster dan frontier-cloudmodellen.
• Setup kost tijd: Het installeren en finetunen van de juiste instellingen vraagt een middagje. Niet voor iedereen weggelegd.
• Hardware-afhankelijkheid: Zonder een recente chip (Apple Silicon of een NVIDIA GPU) ben je beperkt tot kleinere modellen.

Tot slot

Een hybride setup werkt goed: lokale modellen voor het merendeel van de dagelijkse taken, cloud voor de momenten waarop je echt de scherpste kant van frontier-AI nodig hebt. Die verdeling is vanzelf gegroeid, niet op basis van ideologie, maar op basis van wat simpelweg werkt.

Wat opvalt is hoe snel dit landschap beweegt. Modellen die zes maanden geleden als "lokaal maar beperkt" werden beschouwd, zijn nu capabel genoeg voor het grootste deel van een gewone werkdag. De richting is duidelijk: lokale AI wordt krachtiger, toegankelijker, en steeds moeilijker te negeren voor iedereen die waarde hecht aan privacy en controle.

Als je er nog nooit mee hebt geëxperimenteerd, is Ollama de beste plek om te beginnen. Download het, haal een model op, en probeer het een week lang voor je normale vragen. De kans is groot dat je verrast wordt.