Ollama num_predict instellen voor output limieten
Beperk het aantal tokens in Ollama met num_predict. Ontdek waar u deze parameter instelt, welke prioriteit geldt en hoe u done_reason gebruikt om de stop-status te controleren.
Wat num_predict doet in Ollama
num_predict is de optie in Ollama die het aantal tokens beperkt dat een model in één antwoord mag genereren. Het telt alleen de output-tokens, dus de prompt wordt hier niet in meegerekend. Wanneer het model de limiet bereikt, stopt de generatie direct, soms midden in een woord, en wordt het antwoord geretourneerd met done_reason ingesteld op length.
Dat is de volledige functionaliteit. De complexiteit zit in het feit dat Ollama drie afzonderlijke plaatsen biedt om de waarde in te stellen, waarbij de instelling die het dichtst bij het verzoek staat voorrang krijgt. Vrijwel elk rapport waarin wordt beweerd dat "num_predict niets doet", is het gevolg van de ene laag die stilletjes een andere overschrijft.
num_predict is niet num_ctx
Deze twee opties worden vaker verward dan elk ander paar in Ollama, en deze verwarring kost veel tijd bij het debuggen.
num_ctx bepaalt hoeveel het model kan lezen. Dit is de grootte van het contextvenster, dat de prompt en alles wat tot nu toe is gegenereerd bevat. Het verhogen hiervan kost geheugen, omdat de key/value-cache die het model voor deze tokens bijhoudt, meegroeit met het venster. Het bepalen van de grootte van num_ctx voor uw hardware is een aparte taak met eigen faalmodi.
num_predict bepaalt hoeveel het model zal schrijven. Dit is een stopregel, geen reservering. Het verhogen hiervan kost tijd in plaats van RAM, en er wordt vooraf niets gereserveerd.
Ze komen op één punt samen. Gegenereerde tokens belanden in het contextvenster zodra ze worden geproduceerd. In Ollama v0.40.11 staat context shift standaard aan voor de meeste modellen, waardoor bij een vol venster oudere tokens worden verwijderd en de generatie doorgaat. Als shift uit staat, omdat het verzoek "shift": false meestuurt of het model shifting niet ondersteunt, kan een antwoord ook stoppen omdat het venster vol is in plaats van omdat uw limiet is bereikt. Ollama rapporteert in beide gevallen length, dus het getal dat ze onderscheidt is eval_count, wat verderop wordt behandeld.
Instellen met een Modelfile
Een Modelfile verwerkt de waarde in een model dat u aanmaakt. Schrijf het bestand:
FROM qwen3:8b
PARAMETER num_ctx 8192
PARAMETER num_predict 512Bouw het vervolgens en lees terug wat u heeft gebouwd:
ollama create qwen3-capped -f Modelfile
ollama show --parameters qwen3-cappedollama show --parameters print één regel per opgeslagen parameter met de bijbehorende waarde. Als num_predict ontbreekt in die uitvoer, bevat het model geen ingebouwde limiet en is de standaardwaarde van Ollama van toepassing. ollama show --modelfile qwen3-capped print de volledige definitie; dit is tevens de snelste manier om de parameters te kopiëren waarmee een bestaand model wordt geleverd. Het op deze manier aanmaken van een gelimiteerd model kost vrijwel geen extra schijfruimte, omdat het nieuwe item de weight blobs hergebruikt die het basismodel al heeft gedownload in plaats van ze te kopiëren. Het is nuttig om te weten waar Ollama deze blobs bewaart voordat de root-schijf van een VPS volloopt.
Dit is de juiste laag voor een waarde die elke aanroeper moet overerven. Het is de verkeerde laag als u verwacht dat de waarde definitief is, want dat is deze niet.
Stel dit per verzoek in via het options-object
Elk generation-endpoint accepteert een options-object, en num_predict wordt hierbinnen geplaatst:
curl http://localhost:11434/api/generate -d '{
"model": "qwen3:8b",
"prompt": "Explain what a reverse proxy does.",
"stream": false,
"options": { "num_predict": 128 }
}'/api/chat gebruikt dezelfde options-sleutel met dezelfde betekenis. Een waarde die hier wordt ingesteld, is uitsluitend van toepassing op die specifieke aanroep. Dit is de laag die uw tools gebruiken: een chat-interface, een script, een SDK-wrapper of een coding agent. Ze versturen allemaal een options-object, ongeacht of ze hiervoor een invoerveld aan u tonen.
Instellen voor één sessie met de /set parameter
Binnen ollama run stelt de interactieve sessie opties in voor de rest van die sessie:
>>> /set parameter num_predict 256
>>> /show parameters/show parameters toont wat de sessie met uw volgende bericht zal versturen; dit is de snelste manier om te bevestigen dat een wijziging is doorgevoerd. De waarde blijft behouden totdat u /bye typt. Om de instellingen te bewaren, schrijft /save qwen3-capped de huidige sessie, inclusief parameters, weg als een nieuw model. Niets wat u hier /set bereikt een andere client.
Welke instelling heeft voorrang en waarom uw instelling genegeerd lijkt te worden
De volgorde is kort. Opties die met het verzoek worden meegestuurd, hebben voorrang op alles. Een PARAMETER num_predict-regel in de Modelfile van het model is de fallback die wordt gebruikt wanneer het verzoek geen waarde bevat. Als beide ontbreken, geldt de ingebouwde standaardwaarde van Ollama.
/set parameter is geen derde regel. De interactieve sessie is een API-client, dus wat u daar instelt, wordt verzonden als de options van dat verzoek. Dit is precies de reden waarom het de Modelfile voor de sessie overschrijft.
Dit verklaart het volgende probleem. U voegt PARAMETER num_predict 512 toe, bouwt het model opnieuw op, en antwoorden bevatten nog steeds duizenden tokens. Uw instelling is aanwezig en ollama show --parameters bewijst dit. Deze wordt bij elk verzoek overschreven, omdat de client zijn eigen options-object verstuurt met een eigen getal; vaak een getal dat u maanden geleden in een instellingenscherm hebt ingevoerd en bent vergeten. ollama show leest het opgeslagen model. Het kan u niet tonen wat er via HTTP binnenkomt.
Bewijs de serverzijde met één commando. Verstuur een verzoek dat een lang antwoord genereert, dwing de limiet omlaag en lees twee velden uit:
curl -s http://localhost:11434/api/generate -d '{
"model": "qwen3-capped",
"prompt": "Describe the Linux boot process in detail.",
"stream": false,
"options": { "num_predict": 32 }
}' | jq '.done_reason, .eval_count'Een gedetailleerd antwoord gaat ver voorbij de 32 tokens, dus verwacht "length" en 32. Installeer eerst jq met sudo apt install -y jq als dit ontbreekt. De 32 is niet gegarandeerd, omdat eval_count slechts het aantal output-tokens is dat de server daadwerkelijk heeft gegenereerd. Als het model vroegtijdig stopt, krijgt u "stop" en een lager aantal; de oplossing is dan een prompt die om meer vraagt. Wanneer u wel "length" en 32 krijgt, heeft de waarde van het verzoek zelf gewonnen van de 512 die in qwen3-capped is opgeslagen. Dit toont aan dat de server opties per verzoek respecteert. Het vertelt u echter niet wat uw applicatie verstuurt, dus verplaatst de zoektocht zich naar de client. Voor het eigen verslag van de server over een verzoek, start u deze opnieuw met OLLAMA_DEBUG=1 in de omgeving en monitort u journalctl -u ollama -f terwijl uw applicatie ermee communiceert.
Negatieve waarden en de getallen die u niet moet kopiëren
num_predict accepteert ook negatieve waarden; dit zijn sentinels in plaats van aantallen. Eén negatieve waarde betekent "geen limiet, blijf genereren". Een andere waarde betekende voorheen "vul de resterende context". Sinds oktober 2026 geeft de Ollama Modelfile-referentie -1 als standaardwaarde voor oneindige generatie, en eerdere versies van dezelfde tabel vermeldden ook -2 voor het vullen van de context.
Beschouw dit alles als versieafhankelijk, aangezien de implementatie is gewijzigd. De referentie documenteerde lange tijd 128 als standaardwaarde voordat het item werd gecorrigeerd naar -1, waardoor veel handleidingen nog steeds het oude getal herhalen. Ook het gedrag is veranderd. Ollama v0.40.11, de huidige release op 25 oktober 2026, geeft GGUF-modellen door aan een upstream llama-server-proces dat een eindig budget vereist. Daarom vervangt het elke negatieve waarde, en elke limiet boven tien keer num_ctx, door tien keer num_ctx. "Oneindig" betekent daarom 81.920 tokens voor het bovenstaande qwen3-capped-model, en -2 gedraagt zich niet langer anders dan -1. Lees de Modelfile parameter reference voor de versie die u daadwerkelijk draait en bevestig het gedrag vervolgens met de eval_count-controle hierboven. Een waarde die u op uw eigen systeem heeft geverifieerd, is betrouwbaarder dan een waarde die u ergens leest, inclusief dit bericht.
Waarom outputlengte de voornaamste kostenpost is op een VPS zonder GPU
Ollama is gratis te draaien op een machine die u beheert, waardoor lokale generatie nooit wordt afgerekend en een lang antwoord enkel tijd kost. Generatie kent twee fasen met sterk uiteenlopende snelheden. Prompt-tokens worden in batches verwerkt, vele tegelijk. Output-tokens worden één voor één geproduceerd, waarbij elke token een volledige doorloop van de gebruikte gewichten vereist. Op een VPS zonder GPU wordt die doorloop beperkt door de geheugenbandbreedte, waardoor één gegenereerde token veel meer kost dan één prompt-token. Omdat die doorloop elk gewicht moet lezen dat de token gebruikt (alle gewichten in een dense model, of enkel de actieve experts in een mixture-of-experts model zoals Nemotron 3.5 Lightning, dat ongeveer 3B van zijn 30B parameters per token activeert), bepaalt het aantal bytes per gewicht de bovengrens van uw token-snelheid. Dit is de reden waarom een q4-build sneller decodeert dan hetzelfde model in q8 of fp16.
Vraag om een antwoord zonder streaming en de cijfers worden direct zichtbaar:
"prompt_eval_count": 11,
"prompt_eval_duration": 13074791,
"eval_count": 18,
"eval_duration": 52479709De tijdsduur is uitgedrukt in nanoseconden. In dat blok, wat het voorbeeldantwoord is zoals gepubliceerd in de Ollama API-documentatie per oktober 2026 en geen meting van een specifieke server, kostten 11 prompt-tokens ongeveer 0,013 seconden, terwijl 18 output-tokens ongeveer 0,052 seconden in beslag namen. Dat is grofweg 1,2 milliseconden per prompt-token tegenover 2,9 milliseconden per output-token. Zelfs bij een antwoord van één regel kostte elke gegenereerde token dus meer dan twee keer zoveel als elke gelezen token, en bij een lang antwoord is het de output-fase die de klok vult. Uw eigen generatiesnelheid is eval_count gedeeld door eval_duration omgerekend naar seconden, en het meten van tokens per seconde op uw eigen hardware is de moeite waard om eenmaal uit te voeren voordat u andere zaken optimaliseert. Die snelheid hangt evenzeer af van het model als van de machine. Als lange antwoorden de werkelijke kostenpost zijn, wint een model dat is gebouwd voor snelle decodering, zoals Nemotron 3.5 Lightning op een VPS, de tijd terug die een lage limiet anders zou moeten beschermen.
De rekensom doet de rest. Bij 8 tokens per seconde houdt een antwoord van 2.000 tokens de machine meer dan vier minuten bezet, en het model heeft geen idee dat u slechts om een alinea vroeg. Een redenerend model besteedt een deel van dat budget aan denken voordat het een woord schrijft waar u om vroeg, en dat denkproces wordt token voor token gegenereerd, net als al het andere. Daarom is de redeneerinspanning waar u om vraagt een andere factor in dezelfde rekening. Sommige modellen raken ook in een lus en herhalen een zin totdat iets ze stopt. Zonder limiet houdt dat ene verzoek een core bezet totdat deze tien keer num_ctx tokens bereikt, omdat context-verschuiving voorkomt dat een volledig venster het proces beëindigt. num_predict is de instelling die dit begrenst, wat het meest relevant is op een kleine zelfgehoste Ollama VPS waar één lang verzoek de volledige machine in beslag neemt.
Afgekapte output is meestal de limiet, niet een defect model
De symptomen lijken op een modelstoring. Een antwoord dat halverwege een zin stopt. JSON die niet geparseerd kan worden omdat de afsluitende accolade ontbreekt. De reflex is om het model of de kwantisatie de schuld te geven. Lees eerst de respons.
done_reason beantwoordt de vraag direct. stop betekent dat de generatie eindigde vóór enige limiet, ofwel omdat het model het end-of-sequence token uitstuurde, of omdat de output overeenkwam met een van de strings in uw stop optie, die het antwoord beëindigt waar de match valt. length betekent dat de generatie werd afgebroken omdat er geen ruimte meer was. Wanneer u length ziet, vergelijk dan eval_count met uw limiet: een exacte match betekent dat num_predict het stopte, en een kleiner getal betekent dat het contextvenster eerst vol raakte, wat alleen kan gebeuren als context shift is uitgeschakeld.
Wanneer u streamt, komen die velden aan in het laatste fragment, het fragment dat "done": true bevat. Veel clientbibliotheken negeren dat fragment en geven uw code alleen de tekst, wat de reden is dat dezelfde afkapping onverklaarbaar lijkt binnen een applicatie en overduidelijk is onder curl. Als een bibliotheek het verbergt, stuur dan één verzoek met curl om erachter te komen wat de server werkelijk zei.
Eén punt nog om een verspilde middag te voorkomen. Het verhogen van num_predict zorgt er niet voor dat een model meer schrijft. Het verwijdert alleen een plafond. Als een antwoord eindigt op 200 tokens met done_reason van stop, dan heeft het model besloten dat het klaar was of kwam een van uw stop strings overeen, en een hogere limiet verandert niets. Korte antwoorden met stop zijn een probleem met de prompt of de stop-string. Korte antwoorden met length zijn een probleem met de limiet.
Een waarde kiezen
- Laat de limiet voor interactieve chats onbeperkt en druk op Ctrl+C om een uit de hand gelopen antwoord te stoppen. U kijkt immers zelf mee op het scherm.
- Stel voor gescripte taken altijd een limiet in. Een onbeperkte generatie binnen een lus is de reden dat een batchtaak die tien minuten zou moeten duren, de volgende ochtend nog steeds draait.
- Stel voor gestructureerde output de limiet in boven het grootste geldige document dat u verwacht. Behandel
done_reasonvanlengthvervolgens als een harde fout en probeer het opnieuw, in plaats van de incomplete output te parsen. - Voor een coding agent hoort de waarde in de configuratie van de agent zelf thuis, omdat de agent bij elk verzoek zijn eigen opties meestuurt. Een coding agent naar Ollama laten wijzen beschrijft waar deze instellingen zich bevinden.
De limiet telt tokens, geen woorden of tekens, dus schat deze niet. Genereer één representatief antwoord zonder limiet, lees eval_count af en stel de limiet ruim daarboven in. Modelfamilies tokeniseren op verschillende manieren; een waarde die past bij een Llama-model kan hetzelfde antwoord van een Qwen 3-model op dezelfde VPS afkappen.
FAQ
Wat is het verschil tussen num_ctx en num_predict in Ollama?
num_ctx is de grootte van het contextvenster; dit bepaalt hoeveel de het model kan lezen: de prompt plus alles wat tot nu toe is gegenereerd. Dit kost geheugen, omdat de key/value-cache hiermee groeit. num_predict bepaalt hoeveel tokens het model in één antwoord mag schrijven. Dit kost tijd in plaats van geheugen, en er wordt vooraf niets gereserveerd. Gegenereerde tokens tellen mee voor beide limieten; als context-shifting is uitgeschakeld, kan een antwoord door beide limieten voortijdig worden afgebroken.
Waarom lijkt mijn instelling voor num_predict te worden genegeerd?
Omdat een waarde die met het verzoek wordt meegestuurd, een waarde overschrijft die in het model is opgeslagen. Plaats PARAMETER num_predict 512 in een Modelfile en stuur dat model vervolgens aan vanuit een chat-frontend of een coding agent; de client stuurt dan zijn eigen options-object waarvan het getal voorrang krijgt. ollama show --parameters toont nog steeds uw waarde, omdat dit het opgeslagen model leest en niet kan zien wat er via HTTP binnenkomt. Stuur één verzoek met curl via "options": {"num_predict": 32} en een prompt die een lang antwoord vereist, en lees vervolgens done_reason en eval_count. Een length met een eval_count van 32 toont aan dat de waarde van het verzoek de opgeslagen waarde heeft overschreven. Dit bevestigt dat de server zelf correct functioneert en verplaatst de zoektocht naar uw applicatie. Een stop met een lager aantal betekent alleen dat het model eerder klaar was; probeer het opnieuw met een prompt die om meer vraagt.
Hoe kan ik zien of mijn uitvoer is afgebroken door num_predict?
Stuur het verzoek met "stream": false en lees done_reason. Een waarde van stop betekent dat het model uit zichzelf klaar was of dat een van uw stop-strings het heeft beëindigd. Een waarde van length betekent dat de ruimte op was. Vergelijk vervolgens eval_count met uw limiet: als ze exact overeenkomen, heeft num_predict het proces gestopt, en als eval_count kleiner is, is het contextvenster als eerste volgelopen. Bij streaming komen beide velden aan in het laatste fragment met "done": true, wat veel client-bibliotheken weggooien voordat uw code het ziet.
Wat is de standaardwaarde van num_predict?
Lees dit af van uw eigen installatie in plaats van uit een artikel. Sinds oktober 2026 geeft de Ollama Modelfile-referentie de standaardwaarde aan als -1, wat betekent dat de generatie niet is begrensd. Dat item werd gecorrigeerd na een lange periode waarin 128 werd gedocumenteerd. In Ollama v0.40.11 stopt die open-ended standaardwaarde, net als elke negatieve waarde, in feite bij tien keer num_ctx. Negatieve waarden zijn sentinels in plaats van aantallen, en oudere versies van dezelfde tabel vermeldden ook -2 voor het opvullen van de resterende context. Controleer de Modelfile parameter reference voor uw versie en bevestig dit vervolgens met ollama show --parameters en één curl-verzoek.
Zorgt het verhogen van num_predict ervoor dat het model langere antwoorden schrijft?
Nee. Het verwijdert alleen een plafond. Als een antwoord eindigt met done_reason van stop, heeft het model besloten dat het klaar was of kwam een van uw stop-strings overeen; een hogere limiet verandert dan niets. De lengte is in dat geval een kwestie van prompting: vraag om een specifieke structuur, een aantal secties of een bepaald detailniveau. Verhoog num_predict alleen wanneer done_reason terugkomt als length.