# Gevormde JSON Outputs Afdwingen bij Lokale LLM's

[Naar de inhoud](#lm-inhoud)Netwerk/NL[EN](/en/)[Hubhub.llmnet.nlModellen vergelijken op taak, taal, kosten en licentie.](https://hub.llmnet.nl/)[Communitycommunity.llmnet.nlPrompttechnieken, patronen en systeemprompts.](https://community.llmnet.nl/)[APIapi.llmnet.nlLLM's robuust in software: rate limits, routing, structured output.](https://api.llmnet.nl/)[Consultancyconsultancy.llmnet.nlAI invoeren in een organisatie, van pilot tot productie.](https://consultancy.llmnet.nl/)[Nieuwsnieuws.llmnet.nlOntwikkelingen in AI, geduid voor Nederland.](https://nieuws.llmnet.nl/)[Benchmarkbenchmark.llmnet.nlZelf meten wat AI-kwaliteit is, voor jouw taken.](https://benchmark.llmnet.nl/)[Vacaturesvacatures.llmnet.nlAI-rollen, salarissen en carrièrepaden in Nederland.](https://vacatures.llmnet.nl/)[Lerenleren.llmnet.nlAI-concepten in gewoon Nederlands, van beginner tot bouwer.](https://leren.llmnet.nl/)[Gidsgids.llmnet.nlAI privé draaien op eigen Mac, pc, NAS of thuisserver.](https://gids.llmnet.nl/)[Directorydirectory.llmnet.nlHet AI-ecosysteem in kaart: tools, modellen, bedrijven.](https://directory.llmnet.nl/)[Radarradar.llmnet.nlSignalen uit X, onderzoek en communities voor indie developers.](https://radar.llmnet.nl/)[llmnet.nl — hoofdsite](https://llmnet.nl/)[](https://x.com/intent/post?url=https%3A%2F%2Fgids.llmnet.nl%2Fstructured-outputs-lokale-llm&text=Gevormde%20JSON%20Outputs%20Afdwingen%20bij%20Lokale%20LLM%27s)[](https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fgids.llmnet.nl%2Fstructured-outputs-lokale-llm)[](https://www.reddit.com/submit?url=https%3A%2F%2Fgids.llmnet.nl%2Fstructured-outputs-lokale-llm&title=Gevormde%20JSON%20Outputs%20Afdwingen%20bij%20Lokale%20LLM%27s)[](#)[](https://x.com/intent/post?url=https%3A%2F%2Fgids.llmnet.nl%2Fstructured-outputs-lokale-llm&text=Gevormde%20JSON%20Outputs%20Afdwingen%20bij%20Lokale%20LLM%27s)[](https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fgids.llmnet.nl%2Fstructured-outputs-lokale-llm)[](https://www.reddit.com/submit?url=https%3A%2F%2Fgids.llmnet.nl%2Fstructured-outputs-lokale-llm&title=Gevormde%20JSON%20Outputs%20Afdwingen%20bij%20Lokale%20LLM%27s)[](#)

 
# Gevormde JSON Outputs Afdwingen bij Lokale LLM's

 Door Ivo Donker — samengesteld met AI-ondersteuning (Claude & Gemini) · Laatst bijgewerkt: 7 augustus 2026

Wanneer je een lokaal model in een eigen toepassing gebruikt, wil je niet terugkrijgen wat het model toevallig oplevert: je wilt een vaste structuur. Deze gids laat zien hoe je bij lokale inference-servers geldige JSON afdwingt, met JSON-schema's en GBNF-grammatica's; gecontroleerd op 2026-08-07.

In het overkoepelende leertraject van deze gids bevindt deze pagina zich in stap 5: beheren en serveren. De logische volgorde in de gids-canon loopt van modellen kiezen, via installeren en lokaal gebruiken, naar koppelen met eigen software en het beheren van de server. Heb je je lokale serveromgeving nog niet fysiek geïnstalleerd, raadpleeg dan eerst de stap hiervoor over [Ollama op macOS installeren](https://gids.llmnet.nl/ollama-macos-installeren) voor de basisinrichting. De API-specificaties, parameters en voorbeelden in dit artikel zijn gebaseerd op de officiële documentatie van Ollama, llama.cpp, vLLM en LM Studio, met als vaste peildatum 2026-08-07.

## Hardware-ondergrens voor afgedwongen JSON-uitvoer

De voorbeelden in dit artikel gaan uit van een basissysteem met minimaal 16 GB werkgeheugen (RAM of unified memory) en een 7B- tot 8B-model dat gekwantiseerd is naar Q4_K_M. Een dergelijk model neemt ongeveer 5 GB geheugenruimte in beslag, waardoor er voldoende werkgeheugen overblijft voor het contextvenster en de overhead van het inference-proces. Wil je enkel snel testen of een JSON-schema werkt binnen je code, dan volstaat een systeem met 8 GB werkgeheugen in combinatie met een 3B- tot 4B-model in Q4-kwantisatie. Raadpleeg het overzicht voor [hardware voor lokale LLM's](https://gids.llmnet.nl/hardware-voor-lokale-llm) om te controleren wat jouw specifieke machine kan verwerken voordat je complexe schema's gaat laden.

Als je twijfelt over welk model het beste presteert bij het volgen van instructies en gestructureerde formats, bekijk dan de gids over een [lokaal model kiezen](https://gids.llmnet.nl/lokaal-model-kiezen) voor een helder overzicht van modelarchitecturen. Voor diepere vergelijkende data over hoe verschillende modelfamilies omgaan met complexe JSON-structuren kun je terecht bij het overzicht voor [modellen selecteren voor gestructureerde output](https://hub.llmnet.nl/modellen-selecteren-voor-gestructureerde-output). Om te begrijpen hoe kwantisatie de precisie en geheugenvoetafdruk beïnvloedt zonder de rekenstappen te herhalen, verwijzen we naar het artikel over [kwantisatie uitgelegd](https://gids.llmnet.nl/kwantisatie-uitgelegd).

## Wat is constrained decoding?

Wanneer een taalmodel tekst genereert, kiest het token voor token op basis van waarschijnlijkheden. Bij normale tekstgeneratie kan elk token uit de woordenschat worden gekozen. Constrained decoding (ook wel guided decoding genoemd) grijpt rechtstreeks in tijdens de sampling-stap van het inference-proces: de inference-server filtert vóór het selecteren van het volgende token alle opties weg die de opgegeven grammatica of het JSON-schema zouden schenden. Hierdoor kan het model fysiek geen karakters produceren die tot een ongeldige JSON-syntaxis leiden. Wil je de exacte theoretische werking van het token-samplingproces inzien, lees dan de achtergronden over [inference uitgelegd](https://leren.llmnet.nl/inference-uitgelegd) op het leerplatform.

## Vier manieren om JSON af te dwingen bij lokale servers

Er bestaan verschillende methoden en protocollen om een lokale server te dwingen uitsluitend JSON uit te sturen. Welke methode je kiest, hangt af van de inference-engine die je gebruikt en de mate van controle die je nodig hebt over de veldtypes.

### 1. Ollama: JSON-modus en JSON-schema's

Ollama biedt twee niveaus van JSON-afdwinging. Met de eenvoudige JSON-modus dwing je de server af om een syntactisch geldige JSON-string te genereren, maar de specifieke sleutels en datatypen liggen niet vast. Sinds eind 2024 ondersteunt Ollama daarnaast het opgeven van een volledig JSON-schema via het format-veld in de API. Hiermee dwing je zowel de syntaxis als de exacte sleutels en datatypen af.

Kies voor Ollama wanneer je snel een eenvoudige REST API wilt aanroepen zonder handmatig grammatica-bestanden te hoeven compileren. De rekenkundige overhead van constrained decoding binnen Ollama is verwaarloosbaar; het filteren van de logits kost nauwelijks extra geheugen. De voornaamste beperking is dat extreem diep geneste schema's bij kleinere modellen soms kunnen leiden tot herhalende patronen als de prompt onvoldoende context biedt.

Het onderstaande cURL-voorbeeld toont hoe je een gestructureerd JSON-schema meestuurt via de Ollama /api/generate endpoint:

curl http://localhost:11434/api/generate -d '{
 "model": "llama3.2",
 "prompt": "Geef de specificaties van een kantoorlaptop.",
 "stream": false,
 "format": {
 "type": "object",
 "properties": {
 "merk": { "type": "string" },
 "ram_gb": { "type": "integer" },
 "is_voorraad": { "type": "boolean" }
 },
 "required": ["merk", "ram_gb", "is_voorraad"]
 }
}'

Als je geavanceerde runtime-parameters of specifieke systeemprompts wilt vastleggen in je Ollama-omgeving, lees dan hoe je de configuratie aanpast in de handleiding over een [Ollama Modelfile aanpassen](https://gids.llmnet.nl/ollama-model-file-aanpassen).

### 2. llama.cpp: GBNF-grammatica's

llama.cpp gebruikt GBNF (GGML BNF), een uitbreiding op de Backus-Naur Form, om de uitvoer op karakter- en tokenniveau te beperken. Via de opdrachtregel-tool llama-cli gebruik je de vlag --grammar-file. Bij de ingebouwde HTTP-server (llama-server) geeft je een GBNF-string mee in het veld grammar van de JSON payload.

GBNF is de meest flexibele en krachtige aanpak voor lokale sturing. Het ondersteunt niet alleen JSON, maar elke vorm van gestructureerde tekst zoals SQL, XML of aangepaste domain-specific languages (DSL's). Het schrijven van handmatige GBNF-grammatica's vereist wel kennis van formele grammatica's. Om van een JSON-schema naar GBNF te komen, levert de llama.cpp-repository het Python-script json-schema-to-grammar.py mee.

Hieronder staat een compact voorbeeld van een GBNF-grammatica die een eenvoudig JSON-object afdwingt met een string-sleutel en een string-waarde:

root ::= "{" ws pair ws "}"
pair ::= string ":" ws value
string ::= "\"" [a-zA-Z0-9_]* "\""
value ::= string | number
number ::= [0-9]+
ws ::= [ \t\n]*

De overhead van GBNF zit in de initiële opbouw van de kwalificatiematrix (de 'state machine') bij het starten van het verzoek. Bij zeer omvangrijke grammatica's kan dit een kleine vertraging (enkele milliseconden) geven op de eerste-token-tijd (Time To First Token of TTFT). De beperking van raw GBNF is dat fouten in de grammatica-definitie ertoe kunnen leiden dat het model in een oneindige gegenereerde lus raakt als er geen duidelijke stop-tokens zijn gedefinieerd.

### 3. vLLM: Guided decoding met xgrammar of outlines

vLLM is ontworpen voor omgevingen waar hoge doorvoer en meervoudige gelijktijdige verzoeken noodzakelijk zijn. Via de OpenAI-compatibele API van vLLM kun je gestructureerde uitvoer afdwingen met de parameters guided_json of guided_grammar. Onder de motorkap maakt vLLM gebruik van krachtige afdwingings-backends zoals Outlines of xGrammar.

Kies voor vLLM als je een productieserver draait op een dedicated GPU waar meerdere applicaties of gebruikers tegelijkertijd JSON-data opvragen. Omdat vLLM de grammatica-state machines efficiënt verwerkt via PagedAttention en parallelle batching, blijft de invloed op de totale doorvoer minimaal. Het nadeel van vLLM is de hogere instapgrens en het vereiste videogeheugen; voor een simpele lokale werkplek met beperkte middelen is het zwaarder dan Ollama of llama.cpp.

Details over het instellen van een productiewaardige omgeving met vLLM vind je in de handleiding over de [vLLM server configureren](https://gids.llmnet.nl/vllm-server-configureren).

### 4. LM Studio: Structured outputs via OpenAI API-indeling

LM Studio biedt een grafische interface gecombineerd met een lokale HTTP-server. De lokale server volgt de OpenAI REST API-specificatie. Je dwingt gestructureerde JSON af door binnen de aanroep naar /v1/chat/completions het veld response_format te vullen met het type json_schema.

LM Studio is een uitstekende keuze voor ontwikkelaars die visueel modellen willen testen en tegelijk een lokale API-endpoint nodig hebben voor hun applicatie. Qua prestaties gebruikt LM Studio een llama.cpp-backend, waardoor de verwerkingssnelheid en overhead vergelijkbaar zijn. De beperking van LM Studio is dat het primair is ontworpen als desktoptoepassing en minder geschikt is voor headless server-implementaties op een Linux-cluster zonder GUI.

Lees de gids over de [LM Studio headless server](https://gids.llmnet.nl/lm-studio-headless-server) als je deze toepassing toch zonder grafische schil wilt inzetten in een geautomatiseerde pipeline.

## Overzicht van de vier verwerkingsmethoden

In de onderstaande tabel staan de belangrijkste kenmerken van de vier inference-opties naast elkaar:

 
 
 Server-engine | 
 Afdwingingsmethode | 
 Primaire API-parameter | 
 Bestandsindeling / Formaat | 
 

 
 
 
 Ollama | 
 JSON-mode & JSON-schema | 
 format | 
 JSON Schema Object | 
 

 
 llama.cpp | 
 GBNF Grammatica | 
 --grammar-file / grammar | 
 .gbnf bestand of string | 
 

 
 vLLM | 
 Outlines / xGrammar | 
 guided_json / guided_grammar | 
 JSON Schema / Pydantic | 
 

 
 LM Studio | 
 OpenAI Structured Outputs | 
 response_format | 
 JSON Schema Object | 
 

 

## JSON-schema's ontwerpen voor lokale modellen

Hoewel een server met constrained decoding garandeert dat de uitvoer voldoet aan de syntaxis van een JSON-schema, hebben lokale modellen met een omvang van 7B tot 8B parameters moeite met te ingewikkelde structuren. Een slecht ontworpen schema leidt ertoe dat het model inhoudelijk hallucinaties gaat vertonen of vastloopt in de logica, ook al blijft de JSON syntactisch correct.

Hanteren de volgende ontwerpregels voor het bouwen van JSON-schema's voor lokaal draaiende LLM's:

 
- Beperk het aantal velden: Houd het schema compact. Richt je op 5 tot maximaal 10 velden per extractiestap. Wil je meer data verzamelen, knip de taak dan op in meerdere opeenvolgende stappen.
 
- Maak verplichte velden expliciet: Vul de required-array in het schema altijd volledig in. Als een veld optioneel is, kan de server twijfelen wanneer het veld moet worden afgesloten, wat extra generatietijd kost.
 
- Gebruik enums voor vaste waarden: Als een veld slechts een beperkt aantal opties mag bevatten (bijvoorbeeld een status als "concept", "definitief", of "gearchiveerd"), geef dit dan expliciet op via een enum. De constrained decoding-engine filtert alle andere woorden direct weg.
 
- Vermijd diepe nesting: Beperk de diepte van JSON-objecten tot maximaal twee niveaus. Diep geneste objecten (zoals een object binnen een array van objecten die weer een array bevatten) vergroten de kans dat het model de context kwijtraakt.

Houd er rekening mee dat een strikt JSON-schema meer rekenkundige sturing vereist dan het simpele format: "json". Bij format: "json" hoeft de engine alleen te controleren of haakjes, komma's en quotes correct sluiten. Bij een JSON-schema moet de engine bij elke stap de interne toestand van het schema bijhouden, wat bij heel grote schema's een lichte toename in CPU-berekeningen geeft tijdens de sampling-fase.

Als de verwerkte documenten erg lang zijn, dien je ook rekening te houden met de beschikbare geheugenruimte van het model. Raadpleeg het artikel over het [context-window optimaliseren bij lokale modellen](https://gids.llmnet.nl/context-window-optimaliseren-lokaal) om te voorkomen dat je schema-instructies buiten het bereik van het model vallen.

## Praktijkvoorbeeld: Nederlandstalige samenvatting

Om te demonstreren hoe een afgedwongen JSON-uitvoer er in de praktijk uitziet, gebruiken we een scenario waarin een Nederlandstalig document geanalyseerd moet worden. De gewenste uitvoer bevat een korte samenvatting, een lijst met kernpunten en een lijst van geciteerde bronnen.

Het onderstaande cURL-verzoek dwingt het lokale model via een JSON-schema om exact deze structuur terug te geven met Nederlandstalige veldnamen:

curl http://localhost:11434/api/generate -d '{
 "model": "llama3.2",
 "prompt": "Analyseer het onderstaande verslag over de energietransitie en vat het samen.\n\nVerslag: De gemeenteraad heeft besloten om in 2027 alle openbare gebouwen te voorzien van zonnepanelen. De totale kosten worden geschat op 1,2 miljoen euro. Dit staat vermeld in het klimaatrapport van mei 2026.",
 "stream": false,
 "format": {
 "type": "object",
 "properties": {
 "samenvatting": {
 "type": "string"
 },
 "kernpunten": {
 "type": "array",
 "items": { "type": "string" }
 },
 "bronnen": {
 "type": "array",
 "items": { "type": "string" }
 }
 },
 "required": ["samenvatting", "kernpunten", "bronnen"]
 }
}'

Na de verwerking geeft de lokale server het volgende JSON-antwoord terug aan jouw applicatie:

{
 "samenvatting": "De gemeenteraad gaat in 2027 alle openbare gebouwen voorzien van zonnepanelen voor een geschat bedrag van 1,2 miljoen euro.",
 "kernpunten": [
 "Alle openbare gebouwen krijgen zonnepanelen in 2027.",
 "De geschatte investering bedraagt 1,2 miljoen euro."
 ],
 "bronnen": [
 "Klimaatrapport mei 2026"
 ]
}

De lokale inference-server garandeert dat het antwoord exact deze syntactische velden bevat. De inhoudelijke juistheid van de tekst in de velden blijft echter afhankelijk van het gekozen model en de kwaliteit van de gegeven prompt. Om de kwaliteit van de gegenereerde Nederlandstalige tekst binnen de velden te verhogen, verwijzen we naar de adviezen voor [beter Nederlands uit lokale modellen krijgen](https://gids.llmnet.nl/beter-nederlands).

## Foutafhandeling en de grenzen van afdwinging

Het is essentieel om het onderscheid te begrippen tussen structuurgarantie en inhoudsgarantie. Constrained decoding biedt een 100% garantie dat de gegenereerde output voldoet aan de grammaticale regels van het opgegeven schema. Het voorkomt dat je parser crasht op ontbrekende haakjes of foute komma's.

Wat constrained decoding niet kan garanderen, is dat het model de juiste gegevens in de juiste velden plaatst. Als je een model zonder afdwinging gebruikt, zie je vaak dat het model extra uitleg rond de JSON typt (zoals "Hier is de gevraagde JSON:"), veldnamen halverwege de tekst aanpast, of ongeldige karakters invoegt. Met constrained decoding worden deze syntactische problemen volledig geëlimineerd.

Toch kunnen er inhoudelijke problemen ontstaan als de prompt niet goed aansluit bij het schema:

 
- Veld-drifting: Het model vult een veld genaamd "datum" met een tekst als "volgende week dinsdag", terwijl de ontvangende applicatie een ISO-indeling (YYYY-MM-DD) verwacht. Dit los je op door een strikter regex-patroon op te nemen in je schema of GBNF-grammatica.
 
- Inhoudelijke hallucinaties: Wanneer een verplicht veld niet in de brontekst voorkomt, kan de server het model dwingen om toch een waarde te genereren. Het model verzint dan een waarde om aan de grammatica te voldoen. Gebruik in je prompt duidelijke instructies wat het model moet invullen bij ontbrekende gegevens (bijvoorbeeld de waarde "onbekend").

In een robuuste ontwikkelomgeving combineer je de lokale afdwinging altijd met een geautomatiseerde validatiestap binnen de applicatielogica. Ontvang je een JSON-antwoord, haal dit dan door een schema-validator. Blijkt een veld inhoudelijk ongeldig, stuur de foutmelding dan terug naar het model in een vervolgverzoek. Voor een overzicht van vergelijkbare patronen aan de cloud-API-zijde kun je de documentatie raadplegen over [structured output via API's](https://api.llmnet.nl/structured-output). Om je eigen gemaakte schema's vooraf te testen op geldigheid, kun je gebruikmaken van de [JSON schema validator tool](https://benchmark.llmnet.nl/tool-json-schema-validator) op het benchmark-platform.

## Privacy en gegevensbeheer

Het grote voordeel van het afdwingen van JSON bij lokale inference-servers is dat het volledige proces plaatsvindt binnen je eigen netwerk of apparaat. De ingevoerde prompts, de verwerkte documenten en de gegenereerde JSON-structuren verlaten op geen enkel moment de lokale machine.

In tegenstelling tot commerciële cloud-API's worden er geen gegevens verzonden naar externe verwerkers, en worden gegevens niet gebruikt voor het her-trainen van modellen. Dit maakt gestructureerde data-extractie met lokale LLM's uitermate geschikt voor het verwerken van privacygevoelige klantdossiers, medische documenten en vertrouwelijke financiële rapportages. Meer informatie over het inrichten van een privacyvriendelijke werkomgeving vind je in het overzicht over [privacyvriendelijke AI-oplossingen](https://gids.llmnet.nl/privacyvriendelijk-ai).

## Stroomverbruik en operationele kosten

Bij het continu laten draaien van een lokale server voor geautomatiseerde JSON-extractie spelen de operationele kosten een rol. Een lokaal systeem op desktop-niveau (zoals een moderne pc met een losse videokaart of een Mac Studio) dat in ruststand staat te wachten op API-verzoeken, verbruikt gemiddeld enkele tientallen watts. Wanneer er actieve inference plaatsvindt en de server constrained decoding-stappen uitvoert, stijgt het stroomverbruik tijdelijk naar de maximale belastingswaarde van de processor en GPU.

Deze energiekosten vormen een vast onderdeel van de totale eigendomskosten van een eigen AI-infrastructuur. Wil je exact berekenen wat de stroomkosten zijn voor jouw specifieke hardware-opstelling, bekijk dan de rekenvoorbeelden in het artikel over het [stroomverbruik van lokale AI](https://gids.llmnet.nl/stroomverbruik-lokale-ai).

## Samenvatting en controle

Het afdwingen van gestructureerde JSON-uitvoer transformeert een lokaal taalmodel van een tekstgenerator tot een betrouwbare bouwsteen voor software-integraties. Door gebruik te maken van JSON-schema's in Ollama, LM Studio en vLLM, of door GBNF-grammatica's in te zetten bij llama.cpp, garandeer je dat elke API-respons zonder parseerfouten verwerkt kan worden.

Belangrijkste stappen voor een geslaagde implementatie:

 
- Kies een geschikte lokale server-engine op basis van jouw vereisten voor doorvoer en beheer.
 
- Ontwerp een compact JSON-schema met minimaal geneste structuren en expliciete verplichte velden.
 
- Geef het schema of het grammatica-bestand mee in de API-aanroep van je lokale server.
 
- Valideer de ontvangen inhoud in de applicatielaag om inhoudelijke hallucinaties af te vangen.

Informatie en API-specificaties gecontroleerd op 2026-08-07.

llmnet.nl - praktische gids voor lokale taalmodellen