Zelf hosten
Een model op je eigen hardware draaien is de enige manier om zeker te weten dat je data die hardware niet verlaat. Het is ook meer werk dan de meesten verwachten, en het eerlijke antwoord is voor velen dat ze het niet nodig hebben. Deze pagina behandelt beide kanten.
Waarom zelf hosten
Je data gaat nergens heen
Dit is de enige reden op de lijst die categorisch waar is in plaats van een kwestie van gradatie. Elk ander argument voor zelf hosten heeft een cloudalternatief; dit niet.
Geen model wordt onder je vandaan uitgefaseerd
Onderschat, en steeds vaker het sterkste praktische argument. OpenAI belooft minstens zes maanden aankondiging voor algemeen beschikbare modellen en soms maar twee weken voor previews. Een bestand op je eigen schijf wordt nooit uitgefaseerd. Heb je een set prompts gevalideerd tegen een specifiek model, dan telt dat.
Geen kosten per token bij volume
Echt waar, maar reken het eerlijk door. Een videokaart verdient zichzelf alleen terug bij een aanhoudende werklast — de API-prijzen van kleine modellen zijn laag genoeg dat incidenteel gebruik het nooit terugverdient, en de stroom is ook niet gratis.
Offline, en geen lock-in
Beide echt, beide meestal ondergeschikt aan de twee hierboven. Het noemen waard als je werkt op een plek zonder betrouwbare verbinding, of afgeschermd door beleid.
Wanneer juist niet
Het kwaliteitsverschil zit niet waar je denkt
De open modellen die echt kunnen tippen aan de frontier zijn enorm — honderden miljarden tot biljoenen parameters. Die draai je niet op een werkstation. Het verschil dat voor jou telt is dat tussen de frontier en wat in jouw geheugen past, en dat verschil is nog steeds groot.
Mixture-of-experts bespaart je geen geheugen
Een veelgemaakt en duur misverstand. Google zegt het onomwonden over zijn eigen 26B-model met 4B actief: alle 26 miljard parameters moeten alsnog worden geladen, dus het geheugengebruik is vergelijkbaar met een dense model van dat formaat. Sparse modellen zijn snel, niet klein.
Jij wordt de beheerafdeling
Runtimes brengen voortdurend updates uit. Jij bent nu degene die bijwerkt, en degene die ontdekt dat een wijziging in het chatsjabloon je uitvoer vorige dinsdag stilletjes verslechterde.
De meesten overschatten hun privacybehoefte
Een bruikbare toets: als de data prima in Microsoft 365 of Google Workspace kan staan, kan die waarschijnlijk ook prima naar een API-eindpunt in de EU onder een verwerkersovereenkomst. De echte gevallen zijn smaller — stukken onder verschoningsrecht, gezondheidsgegevens, broncode onder NDA, data die je contractueel niet aan subverwerkers mag tonen.
De juiste keuze als
Vertrouwelijke of bijzondere persoonsgegevens. Hoog aanhoudend volume. Offline of afgeschermd werk. Een model dat je moet bevriezen voor reproduceerbaarheid. Of je hebt de hardware al.
De verkeerde keuze als
Je wilt frontier-kwaliteit. De werklast is incidenteel. Niemand wil het beheer op zich nemen. Of "privacy" is een gevoel en geen vastgelegde eis.
De middenweg
Er is een middenweg die mensen vergeten: een beheerd eindpunt in een EU-regio onder een verwerkersovereenkomst geeft je het grootste deel van het complianceverhaal zonder enige beheerlast.
Runtimes
Controleer of lokaal echt lokaal is
Controleer of "lokaal" echt lokaal is. Ollama biedt inmiddels een cloudmodus waarin een commando dat er precies zo uitziet als een lokaal commando het model gewoon op andermans servers draait. Is jouw reden om zelf te hosten dat data je infrastructuur niet mag verlaten, controleer dan in welke modus je zit voordat je iets vertrouwelijks verstuurt.
| Runtime | Licentie | API | Past bij | Belangrijkste beperking |
|---|---|---|---|---|
| Ollama | MIT | localhost:11434/v1 | De snelste route van niets naar een werkend model. | Het verbergt alles achter standaardinstellingen — contextgrootte, sjabloon, sampling — en dat maakt het juist een slechte keuze voor werk waarin promptkwaliteit telt, tot je die hebt aangepast. |
| llama.cpp | MIT | instelbaar | Controle, en ongebruikelijke hardware — het draait op vrijwel alles, ook op machines zonder GPU. | Je krijgt elke instelling voor je kiezen, en de standaardwaarden zijn niet die van de modelmaker. |
| vLLM | Apache 2.0 | localhost:8000 | Meerdere mensen tegelijk bedienen. De winst zit in gelijktijdigheid, niet in snelheid voor één gebruiker. | Het wil een echte GPU en echt beheer. Bij één gebruiker is het voordeel ten opzichte van Ollama verwaarloosbaar en de kosten niet. |
| LM Studio | gratis voor zakelijk gebruik; licentie van de app niet vermeld | localhost:1234/v1 | Mensen die liever klikken dan typen. Een grafische app met een opdrachtregeltool voor als je die ontgroeit. | De licentie van de desktopapplicatie staat niet in de documentatie, dus ga er niet van uit dat die open source is. |
| Jan | Apache 2.0 | localhost:1337 | Het licentieschone alternatief voor LM Studio, gebouwd op llama.cpp en volledig offline. | Kleinere gemeenschap dan Ollama of LM Studio, dus minder antwoorden als er iets misgaat. |
Hardware
De vuistregel
Gewichten kosten ruwweg 2 GB per miljard parameters bij 16 bits, 1 GB bij 8 bits en 0,5 GB bij 4 bits. Tel daar 20–50% bij op voor de key-value cache, meer als je lange context wilt. Dus: deel je VRAM in gigabytes door twee en dat is ongeveer het grootste model in miljarden parameters dat je op 4 bits kunt draaien.
| Precisie | VRAM per miljard params | Een 8B-model | Een 27B-model |
|---|---|---|---|
| 16 bits (zoals getraind) | 2 × B | 16 GB | 54 GB |
| 8 bits | 1 × B | 8 GB | 27 GB |
| 4 bits | 0.5 × B | 4 GB | 14 GB |
Een moderne laptop
16–32 GB geheugen draait modellen van 2B–8B op 4 bits. Echt bruikbaar voor samenvatten, extractie en concepten schrijven. Apple Silicon presteert hier bovengemiddeld omdat het geheugen wordt gedeeld met de grafische processor.
Eén videokaart van 24 GB
De optimale plek. Modellen tot ruwweg 30B op 4 bits passen met ruimte voor context. Hier gebeurt het meeste serieuze zelf hosten.
Een werkstation
32 GB op één kaart, of twee kaarten van 24 GB. Grotere modellen op betere quantisatie. Let op: een high-end kaart kan ruim 500 watt trekken en wil een voeding van 1000 watt — geluid, warmte en stroom worden allemaal echte overwegingen.
Een kleine server
Eén of meer versnellers van 80 GB. Hier begint vLLM zijn complexiteit terug te verdienen, omdat je nu gelijktijdige gebruikers bedient in plaats van jezelf.
Wat quantisatie eigenlijk is
De gewichten van een model zijn miljarden getallen, tijdens training elk opgeslagen in 16 bits. Quantisatie schrijft ze met minder bits — 8, 5 of 4 — zodat het bestand krimpt en er meer in snel geheugen past. Het is verliesgevend, net als een JPEG. Tot ongeveer 4 bits is het verlies bij gewoon werk meestal onzichtbaar; daaronder wordt het merkbaar, eerst in samenhang over langere tekst en in gestructureerde uitvoer.
- Kies een quantisation-aware versie als de leverancier die levert. Google meldt dat het kwaliteitsverlies bij 4 bits daarmee ongeveer halveert ten opzichte van achteraf quantiseren.
- Agressieve quantisatie breekt tool-aanroepen eerder dan lopende tekst. Produceert je model ineens misvormde functieaanroepen, verdenk dan eerst de quantisatie en niet de prompt.
Lokale modellen prompten
Bij een frontier-API vangt het platform je fouten op. Lokaal doet niets dat — en de fouten zijn stil. Er komt geen foutmelding; de uitvoer wordt alleen ongemerkt slechter. Dit zijn de vijf waar mensen op stuklopen.
Het chatsjabloon
Een chatmodel is nog steeds een voorspeller van het volgende token: de rollen die je stuurt worden platgeslagen tot één tekst met stuurtokens die specifiek zijn voor dat model. Twee modellen die uit dezelfde basis zijn gefinetuned kunnen totaal verschillende opmaak gebruiken, en Hugging Face stelt onomwonden dat met verkeerde stuurtokens de prestaties drastisch slechter zijn. Drie manieren waarop het misgaat: een ontbrekende generatieprompt, waardoor het model je bericht voortzet in plaats van beantwoordt; dubbele speciale tokens doordat je zelf een tekst samenstelt die ze al bevatte; en een stille terugval op een generiek sjabloon als de runtime het model niet herkent.
Wat je doet
Gebruik het OpenAI-compatibele chateindpunt en geef een berichtenreeks mee. Bouw de ruwe tekst nooit met de hand. Moet het toch, controleer dan in de startlog van de runtime welk sjabloon die daadwerkelijk koos.
Systeemberichten zijn niet universeel
De instructie-getunede Gemma-modellen ondersteunen alleen de rollen user en model — er is helemaal geen systeemrol, en Google adviseert instructies op systeemniveau in de eerste gebruikersbeurt te zetten. Aan de andere kant gebruiken de open modellen van OpenAI een formaat dat wat jij een systeemprompt noemt over twee rollen verdeelt met een strikte voorrangsvolgorde, en OpenAI stelt dat ze zonder dat formaat niet goed werken. Een systeemprompt die op het ene open model werkt, wordt op het andere stilletjes genegeerd.
Wat je doet
Lees op de model card welke rolconventie geldt voordat je een prompt overzet. Toets of je systeeminstructie echt effect had in plaats van het aan te nemen.
Chain of thought, opnieuw bekeken
Hier verschillen lokale modellen echt van het advies elders op deze site. OpenAI zegt dat zijn redeneermodellen vragen om stap voor stap te denken onnodig is en zelfs kan hinderen. Maar het oorspronkelijke onderzoek uit 2022 vond dat chain-of-thought pas helpt vanaf ongeveer 100B parameters, en dat kleinere modellen vloeiende maar onlogische redeneringen produceren — precies de fout die je op een laptopmodel ziet. Het antwoord in 2026 is drieledig, niet tweeledig.
Wat je doet
Frontier-redeneermodel: vraag niet om stap voor stap, dat is overbodig. Klein open model met ingebouwde denkmodus: gebruik die modus, plak er geen chain-of-thought bovenop. Klein open model zonder denkmodus: expliciet stap voor stap helpt nog steeds — maar toets het op je eigen taak, want een vloeiende maar foute redenering is de kenmerkende fout.
Het contextvenster dat je echt krijgt
Een model dat 262.144 tokens adverteert kan op jouw machine op 4.096 draaien, omdat de runtime de context afstemt op beschikbaar geheugen in plaats van op wat het model aankan. Het begin van je gesprek wordt dan stilzwijgend afgekapt — precies de ervaring waardoor mensen concluderen dat lokale modellen dom zijn. Nog twee valkuilen: een uitgebreid contextvenster is een ruil en geen gratis upgrade, en leveranciers merken op dat prestaties op kortere teksten kunnen verslechteren als uitbreiding aanstaat. En de aandacht is ongelijk verdeeld over lange invoer, dus het midden krijgt er minder van dan de randen.
Wat je doet
Controleer waar je feitelijk op draait en verhoog het bewust. Zet vervolgens je instructie en je belangrijkste document aan de randen van een lange prompt, niet ergens in het midden.
Sampling-standaarden zijn niet die van de leverancier
Bij een gehoste API raak je sampling zelden aan. Lokaal kiest de runtime standaardwaarden — vaak een temperatuur van 0,8 — die niet zijn wat de makers van het model aanraden, en dat verschil verslechtert de uitvoer ongemerkt. Aanbevolen instellingen verschillen niet alleen per leverancier maar ook tussen de denk- en niet-denkmodus van hetzelfde model, en ze zijn tussen generaties van dezelfde familie veranderd. Er is geen universeel goede standaard. Eén tegenintuïtieve waarschuwing is het opvolgen waard: Qwen stelt in hoofdletters dat je geen greedy decoding moet gebruiken, omdat dat leidt tot verslechtering en eindeloze herhaling. Veel mensen zetten uit gewoonte de temperatuur op nul voor voorspelbaarheid; bij een redeneermodel werkt dat juist averechts.
Wat je doet
Open de model card en neem de aanbevolen temperatuur, top-p en top-k over. De uitzondering is gestructureerde extractie tegen een schema, waar een temperatuur van nul wél wordt aangeraden.
Schone gestructureerde uitvoer krijgen
Lokale modellen kletsen. De oplossing is niet erop aandringen in de prompt maar het decoderen beperken, wat lokaal beter wordt ondersteund dan bij de meeste gehoste API’s: llama.cpp kan uitvoer dwingen te voldoen aan een grammatica of een JSON-schema, en Ollama accepteert rechtstreeks een schema. Er is één kanttekening die vrijwel iedereen mist, en beide projecten benoemen die: het schema beperkt alleen het uitvoerformaat — het model ziet het schema nooit, dus je moet de verwachte structuur nog steeds in de prompt beschrijven.
Wat je doet
Schema én prompt, niet schema in plaats van prompt. Zet de temperatuur in dit ene geval op nul.
AVG en de AI-verordening
Zelf hosten verandert je juridische positie op manieren die makkelijk in beide richtingen worden overdreven. Dit is oriëntatie, geen juridisch advies — zie de disclaimer op de juridische pagina, en win echt advies in bij alles wat gevolgen heeft.
Waar zelf hosten echt bij helpt
- De verwerkersrelatie verdwijnt. Andermans API gebruiken maakt hen verwerker, met een overeenkomst en een keten van subverwerkers daarachter. Het model zelf draaien haalt die keten helemaal weg.
- Vragen over internationale doorgifte vervallen als de hardware in de EU staat.
- Beveiligingsmaatregelen worden makkelijker aantoonbaar, omdat je encryptie, pseudonimisering en tests zelf beheert in plaats van andermans verklaringen te erven.
Wat het niet oplost
- Je blijft verwerkingsverantwoordelijke. Grondslag, doelbinding, dataminimalisatie, transparantie en rechten van betrokkenen blijven ongewijzigd. De hardware zelf draaien verandert wie verwerkt, niet of de verwerking rechtmatig is.
- Een gegevensbeschermingseffectbeoordeling kan nog steeds verplicht zijn, en moet vóór de verwerking plaatsvinden, niet erna.
- Het model zelf kan persoonsgegevens bevatten. De European Data Protection Board behandelt anonimiteit van een model als iets dat je per geval beoordeelt, niet aanneemt. Een model met open gewichten downloaden importeert geen schone compliancegeschiedenis.
- Je infrastructuur is nu jouw beveiligingsprobleem. Een modelserver zonder authenticatie die aan het internet hangt, is slechter dan een gerenommeerde API.
Waar het je positie onder de AI-verordening verandert
Onder de AI-verordening telt het onderscheid tussen een deployer, die een systeem onder eigen verantwoordelijkheid gebruikt, en een provider, die er een ontwikkelt en in gebruik neemt — inclusief, in de woorden van de verordening zelf, voor eigen gebruik. Die formulering maakt dat een eigen systeem bouwen rond een zelfgehost model dichter bij de providerrol ligt dan andermans API aanroepen, waar je doorgaans duidelijk deployer bent. Beschouw dit als een reëel risico op rolwisseling en niet als een zekerheid; veel hangt ervan af of je überhaupt een systeem ontwikkelt of er alleen een bedient, en dat is een juridisch oordeel. Twee verplichtingen gelden hoe dan ook al: de plicht tot AI-geletterdheid voor providers én deployers, en de transparantieregels die sinds 2 augustus 2026 van kracht zijn. Let er ook op dat de verordening in juli 2026 is gewijzigd, waarbij verschillende termijnen zijn verschoven — controleer actuele data in plaats van een oudere samenvatting.
In Nederland
In Nederland coördineert de Autoriteit Persoonsgegevens het toezicht op algoritmes, naast de Rijksinspectie Digitale Infrastructuur in een centrale rol voor AI-toezicht, met een testomgeving in oprichting waarin organisaties systemen kunnen beproeven onder begeleiding van de toezichthouder.
Aan de slag
Wees eerlijk over het waarom
Schrijf één zin die benoemt welke data niet weg mag. Lukt dat niet, stop dan hier en gebruik een API in een EU-regio onder een verwerkersovereenkomst — dat scheelt je de hardware en het onderhoud.
Bepaal je plafond voordat je iets downloadt
Zoek je VRAM op, of het gedeelde geheugen op een Mac. Deel door twee: dat is ruwweg het grootste model in miljarden parameters dat je op 4 bits kunt draaien, vóór context. 8 GB brengt je rond 7–8B; 24 GB rond 27–31B gequantiseerd.
Installeer precies één ding
Ollama als je in een terminal leeft. LM Studio als je liever klikt. Vergelijk geen vijf runtimes voordat je één model hebt gedraaid.
Herstel de twee standaarden die de uitvoer stil verpesten
Dit is de stap die elke andere gids overslaat. Verhoog de contextlengte bewust in plaats van te accepteren wat de runtime gokte. Open daarna de model card en neem de aanbevolen sampling-instellingen over in plaats van die van de runtime.
Richt er een echte client op
Elke runtime hier spreekt een OpenAI-compatibele interface, dus één basis-URL wijzigen in een bestaand script is meestal de hele integratie. Hier ontdek je ook welke functies ontbreken.
Test je prompts opnieuw, en neem niets als gegeven aan
Lees op de model card welke conventie voor systeemberichten geldt. Gebruik een schema én beschrijf de structuur in de prompt. Vergelijk daarna met de API die je gebruikte, op je eigen echte taken, voordat je je ergens aan vastlegt.
Bronnen en onderbouwing
- 1Chat templatesHugging Face (Transformers docs)Bron voor de faalmodi van chatsjablonen, inclusief de generatieprompt en dubbele speciale tokens.
- 2Optimizing LLMs for speed and memoryHugging Face (Transformers docs)Bron voor de VRAM-vuistregel en de omvang van de key-value cache.
- 3Gemma prompt structureGoogleBevestigt dat Gemma alleen de rollen user en model ondersteunt, zonder systeemrol.
- 4Gemma model overviewGoogleBron voor het geheugenpunt over mixture-of-experts en de geheugencijfers per variant.
- 5Reasoning best practicesOpenAIStelt dat een redeneermodel vragen stap voor stap te denken onnodig is en kan hinderen.
- 6Chain-of-Thought Prompting Elicits Reasoning in Large Language ModelsWei et al., 2022 (arXiv)De bevinding dat chain-of-thought pas op grote schaal helpt, en dat kleine modellen vloeiende maar onlogische redeneringen produceren.
- 7Lost in the Middle: How Language Models Use Long ContextsLiu et al., 2023 (arXiv)De bevinding over ongelijke aandacht, waarom instructies aan de randen van een lange prompt horen.
- 8Structured outputsOllamaBron voor schema-beperkte uitvoer en het advies de structuur ook in de prompt te beschrijven.
- 9Context lengthOllamaBron voor het feit dat context wordt bepaald door beschikbaar geheugen in plaats van door het model.
- 10Ollama CloudOllamaDe cloudmodus waardoor een lokaal ogend commando op servers elders draait.
- 11GBNF grammarsllama.cppGrammatica- en JSON-schema-gestuurd decoderen, en de opmerking dat het model het schema nooit ziet.
- 12Model deprecationsOpenAIDe aankondigingstermijnen achter het argument dat een lokaal model nooit onder je vandaan verdwijnt.
- 13Article 3: DefinitionsEU Artificial Intelligence ActDefinities van provider en deployer, inclusief in gebruik nemen voor eigen gebruik.
- 14Article 4: AI literacyEU Artificial Intelligence ActDe geletterdheidsplicht die zowel voor deployers als providers geldt.
- 15Opinion 28/2024 on AI models and GDPREuropean Data Protection BoardAnonimiteit van een model wordt per geval beoordeeld, niet aangenomen.