Inleiding

Uitvoeren Ministral-3 op vLLM is verrassend krachtig. Het model is snel, creatief en in staat om hoogwaardige antwoorden te produceren, zelfs onder zware belasting.

Maar zodra je overgaat van eenvoudige chatprompts naar gestructureerde output, automatisering of programmatisch gebruikdingen snel ingewikkeld worden.

Tijdens de ontwikkeling van een AI-gestuurd Jeopardy-spel met 12 gelijktijdige spelers en honderden modeloproepen, we kwamen verschillende praktische problemen tegen:

• Markdown verschijnt in platte tekst-antwoorden
• JSON-uitvoer wordt diep genest
• Tokenlimieten worden overschreden
• Kleine verschillen in opmaak veroorzaken problemen in de downstream logic

Deze handleiding vat samen praktische lessen geleerd tijdens het oplossen van deze problemensamen met concrete patronen die je in je eigen projecten kunt hergebruiken.

Het Real-World Scenario

Ons benchmarkproject simuleert een volledig Jeopardy-spel waarin:

• De De host AI genereert categorieën en aanwijzingen
• Meerdere AI-deelnemers beantwoorden tegelijkertijd
• Nog een AI-rechter beoordeelt de correctheid
• Scores worden bijgehouden over de rondes

Een enkele spelronde kan gemakkelijk 800 API-aanroepen overschrijden 800 API-oproepen.

Deze omgeving bracht randgevallen aan het licht die zelden voorkomen in eenvoudige demo's — waardoor het een geweldige testomgeving is om te begrijpen hoe Ministral presteert onder echte productiebelastingen.

1. Ministral-3 serveren op vLLM

Ministral-modellen Gebruik niet de standaard HuggingFace tokenizer configuratie.

Dit betekent dat het opstartcommando expliciet de Mistral tokenizer-formaat.

vllm serve mistralai/Ministral-3-14B-Instruct-2512 \
  --tokenizer_mode mistral \
  --config_format mistral \
  --load_format mistral

Als uw applicatie hiervan afhankelijk is functie aanroepen, voeg de tool-vlaggen toe:

--enable-auto-tool-choice
--tool-call-parser mistral

Belangrijke beperking

In tegenstelling tot sommige andere modellen, Ministral ondersteunt dit niet chat_template_kwargs.

Als u een verzoek als dit verzendt:

{
  "chat_template_kwargs": {
    "enable_thinking": false
  }
}

vLLM retourneert:

HTTP 400: chat_template is not supported for Mistral tokenizers

Dat betekent functies zoals expliciete "denkmodus" schakeling (gebruikt met modellen zoals Qwen of DeepSeek) zijn eenvoudigweg niet beschikbaar.

Gelukkig is dit zelden nodig omdat Ministral standaard al beknopte uitvoer produceert.

2. Temperatuur: De belangrijkste parameter

De officiële vLLM documentatie gebruikt consequent de volgende waarde met Ministral-3:

temperature = 0.15

Op het eerste gezicht lijkt dit erg laag. Echter, blijkt dit toch het geval te zijn. cruciaal voor gestructureerde taken.

Wat gebeurt er bij hogere temperaturen

Met de standaardinstellingen van OpenAI:

temperature: 0.7

het model wordt overdreven creatief met structuur.

Een eenvoudige vraag zoals:

{ "expertise": "2-3 topics they know best" }

kan zoiets retourneren:

{
  "expertise": [
    {
      "category": "Gourmet Pizza Alchemy",
      "detail": "Can transform random ingredients into Michelin-star pizza"
    },
    {
      "category": "Sumo Wrestling Physics",
      "detail": "Understands body mechanics and center-of-gravity combat"
    }
  ]
}

Technisch gezien geldige JSON, maar het is niet wat het schema vroeg.

Het resultaat:

• JSON wordt groter dan verwacht
• max_tokens limieten worden overschreden
• Reacties worden afgekapt
• Het parsen mislukt

Waarom 0.15 werkt beter

Bij lage temperatuur wordt het model structureel gedisciplineerd.

temperature: 0.15

Voordelen:

• JSON volgt schema's nauwkeurig
• tokengebruik wordt voorspelbaar
• geneste structuren verdwijnen bijna volledig
• antwoorden blijven binnen de tokenlimieten

Zelfs creatieve tekstgeneratie blijft sterk — het model stopt simpelweg met het improviseren met structuur.

Aanbeveling: Gebruik temperature: 0.15 als uw standaardwaarde voor Ministral-3.

3. Schone JSON-antwoorden verkrijgen

Produceren machine-leesbare JSON van LLM's is lastiger dan het klinkt.

Ministral interpreteert schema-velden vaak semantisch semantisch in plaats van structureel, wat resulteert in een diep geneste uitvoer.

Return JSON with these fields.

{ "expertise": "2-3 topics they know best" }

{
  "expertise": [
    {
      "category": "Ancient Roman Engineering",
      "detail": "Knows aqueduct systems in surprising detail"
    },
    {
      "category": "Pizza Dough Chemistry",
      "detail": "Obsessed with yeast fermentation dynamics"
    }
  ]
}

Respond with ONLY valid JSON.
No markdown, no explanation, no text before or after the JSON.
Keep values as short plain strings — never use nested objects or arrays.

Every value MUST be a short plain string — NO arrays, NO nested objects.

function extractJSON(raw, shape) {
  var text = raw.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, '').trim();
  if (shape === 'array') {
    var m = text.match(/\[[\s\S]*\]/);
    if (m) text = m[0];
  } else {
    var m = text.match(/\{[\s\S]*\}/);
    if (m) text = m[0];
  }
  return text;
}

var stack = [];
var inStr = false, esc = false;

for (var i = 0; i < text.length; i++) {
  var ch = text[i];

  if (esc) { esc = false; continue; }
  if (ch === '\\') { esc = true; continue; }
  if (ch === '"') { inStr = !inStr; continue; }
  if (inStr) continue;

  if (ch === '{') stack.push('}');
  else if (ch === '[') stack.push(']');
  else if (ch === '}' || ch === ']') stack.pop();
}

text = text.replace(/,\s*$/, '');

while (stack.length > 0)
  text += stack.pop();

if (Array.isArray(value)) {
  flat = value.map(function(item) {
    if (typeof item === 'string') return item;
    if (typeof item === 'object') return Object.values(item).join(' — ');
    return String(item);
  }).join(', ');
}

2–3 retry attempts

verdict.toUpperCase().startsWith('CORRECT')

**CORRECT**

function stripMarkdown(text) {
  if (!text) return text;

  var s = text.replace(/\*\*([^*]+)\*\*/g, '$1');
  s = s.replace(/__([^_]+)__/g, '$1');
  s = s.replace(/\*([^*]+)\*/g, '$1');
  s = s.replace(/^#{1,6}\s+/gm, '');
  s = s.replace(/`([^`]+)`/g, '$1');
  s = s.replace(/^```[a-z]*\s*$/gm, '');

  return s.trim();
}

function buildModelProfile(modelName) {
  var lower = modelName.toLowerCase();
  var isMistral = lower.includes('mistral') || lower.includes('ministral');

  return {
    family: isMistral ? 'Mistral' : 'Generic',

    jsonSystemInstruction: isMistral
      ? 'Respond with ONLY valid JSON. No markdown. Keep values as short plain strings.'
      : 'You output only valid JSON. No markdown fences, no explanation.',

    jsonSchemaHint: isMistral
      ? ' Every value MUST be a short plain string — NO arrays, NO nested objects.'
      : '',

    jsonTemperature: isMistral ? 0.15 : 0.7,
    defaultTemperature: isMistral ? 0.15 : 0.7,

    plainTextInstruction: ' Do not use markdown formatting.'
  };
}