Einführung

Ministral-3 auf vLLM zu betreiben ist überraschend leistungsstark. Das Modell ist schnell, kreativ und liefert selbst unter hoher Auslastung hochwertige Antworten.

Doch sobald man von einfachen Chat-Aufforderungen zu strukturierten Ausgaben, Automatisierung oder programmtechnischer Nutzung übergeht, wird es schnell kompliziert.

Entwicklung eines KI-gesteuerten Jeopardy-Spiels mit 12 gleichzeitigen Spielern und Hunderten von Modellabfragen

• Markdown erscheint in reinen Textantworten
• JSON-Ausgaben werden tief verschachtelt
• Überschreitung der Token-Budgets
• Geringfügige Formatierungsunterschiede führen zu Fehlern in nachgelagerten Logiken

Diese Anleitung fasst die praktischen Erkenntnisse zusammen, die beim Lösen dieser Probleme gewonnen wurden, sowie konkrete Muster, die Sie in eigenen Projekten wiederverwenden können.

Das reale Szenario

Unser Benchmark-Projekt simuliert ein vollständiges Jeopardy-Spiel, bei dem:

• Der Host-AI generiert Kategorien und Hinweise
• Mehrere KI-Spieler antworten gleichzeitig
• Eine weitere KI bewertet die Richtigkeit
• Die Ergebnisse werden über mehrere Runden hinweg verfolgt

Ein einzelner Spielablauf kann leicht über 800 API-Aufrufe hinausgehen.

Diese Umgebung deckte Edge-Cases auf, die in einfachen Demos selten vorkommen – was sie zu einem hervorragenden Testfeld macht, um zu verstehen, wie sich Ministral unter echten Produktionslasten verhält.

1. Bereitstellung von Mini-Servern auf VLLM

Ministral-Modelle verwenden keine Standard-HuggingFace-Tokenizer-Konfiguration.

Das Tokenizer-Format von Mistral muss explizit aktiviert werden.

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

Falls Ihre Anwendung auf Function Calling angewiesen ist, fügen Sie folgende Tool-Flags hinzu:

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

Wichtige Einschränkung

Im Gegensatz zu anderen Modellen unterstützt chat_template_kwargs nicht.

Wenn Sie eine Anfrage wie diese senden:

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

vLLM gibt zurück:

HTTP 400: chat_template is not supported for Mistral tokenizers

Das bedeutet, dass Funktionen wie das explizite Aktivieren/Deaktivieren eines Denkmodus (wie bei Modellen wie Qwen oder DeepSeek verwendet wird) einfach nicht unterstützt werden

Glücklicherweise ist dies selten erforderlich, da Ministral bereits standardmäßig prägnante Ausgaben erzeugt.

2. Temperatur: Der wichtigste Parameter

Die offizielle vLLM-Dokumentation verwendet durchgehend folgenden Wert mit Ministral-3:

temperature = 0.15

Auf den ersten Blick wirkt dieser Wert extrem niedrig. Allerdings erweist er sich als entscheidend für strukturierte Aufgaben.

Was passiert bei höheren Temperaturen?

Unter Verwendung der OpenAI-Standardeinstellung:

temperature: 0.7

zu kreativ mit der Struktur

Eine einfache Anfrage wie:

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

kann beispielsweise Folgendes zurückgeben:

{
  "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"
    }
  ]
}

entspricht nicht dem vom Schema geforderten Format

Das Ergebnis:

• JSON wird unerwartet größer
• max_tokens Grenzen werden überschritten
• Antworten werden abgeschnitten
• Das Parsen schlägt fehl.

Warum 0.15 funktioniert besser

strukturell diszipliniert

temperature: 0.15

Vorteile:

• JSON folgt präzise den Schemas
• Die Token-Nutzung wird vorhersagbar.
• verschachtelte Strukturen verschwinden fast
• Die Antworten bleiben innerhalb der Token-Limits.

Auch die kreative Textgenerierung bleibt stark – das Modell hört einfach auf, mit der Struktur zu improvisieren.

Empfehlung: Nutzen Sie temperature: 0.15 als Standardwert für Ministral-3.

3. Saubere JSON-Antworten erhalten

Maschinelles JSON, das lesbar ist (und korrekt verarbeitet werden kann), aus Sprachmodellen zu generieren, ist schwieriger als es klingt.

Ministral deutet Schemabefelde semantisch statt strukturell, was zu stark verschachtelten Ausgaben führt.

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.'
  };
}