Einführung

Ausführen Ministral-3 auf vLLM ist überraschend leistungsstark. Das Modell ist schnell, kreativ und in der Lage, auch unter hoher Belastung qualitativ hochwertige Antworten zu liefern.

Sobald Sie jedoch von einfachen Chat-Eingabeaufforderungen zu strukturierte Ausgaben, Automatisierung oder programmatische NutzungDinge werden schnell kompliziert.

Während der Entwicklung von KI-gesteuertes Jeopardy-Spiel mit 12 gleichzeitigen Spielern und hunderten Modellaufrufenwir sind auf mehrere praktische Probleme gestoßen:

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

Dieser Leitfaden fasst zusammen praktische Erkenntnisse bei der Lösung dieser Problemesowie konkrete Muster, die Sie in Ihren eigenen Projekten wiederverwenden können.

Das reale Szenario

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

• Der Die Host-KI generiert Kategorien und Hinweise
• Mehrere KI-Teilnehmer beantworten gleichzeitig
• Ein weiteres KI-Richter bewertet die Korrektheit
• Die Ergebnisse werden über mehrere Runden hinweg verfolgt

Ein einzelner Spieldurchlauf kann leicht 800 API-API-Aufrufe überschreiten. 800 API-Aufrufe.

Diese Umgebung wurden Randfälle aufgedeckt, die in einfachen Demos selten auftreten – was sie zu einem idealen Testumfeld macht, um zu verstehen, wie Ministral wird unter realen Produktionsbedingungen ausgeführt..

1. Bereitstellung von Mini-Servern auf VLLM

Ministral-Modelle Verwenden Sie nicht die Standard-Tokenizer-Konfiguration von HuggingFace..

Dies bedeutet, dass der Startbefehl explizit aktiviert werden muss. Mistral-Tokenizerformat.

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

Wenn Ihre Anwendung darauf angewiesen ist Funktionsaufruf, fügen Sie die Tool-Flags hinzu:

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

Wichtige Einschränkung

Im Gegensatz zu einigen anderen Modellen Ministral unterstützt dies nicht chat_template_kwargs.

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 explizite Umschaltung des "Denkmodus" (wie bei Modellen wie Qwen oder DeepSeek) sind einfach nicht verfügbar.

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

2. Temperatur: Der wichtigste Parameter

Der offizielle vLLM-Dokumentation verwendet durchgängig den folgenden Wert mit Ministral-3:

temperature = 0.15

Auf den ersten Blick scheint dies extrem niedrig. Es stellt sich jedoch heraus, dass es sich als kritisch erweist. entscheidend für strukturierte Aufgaben.

Was passiert bei höheren Temperaturen?

Unter Verwendung der OpenAI-Standardeinstellung:

temperature: 0.7

das Modell wird übertrieben kreativ bei 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"
    }
  ]
}

Obwohl technisch gültiges JSON, ist es nicht das, was das Schema verlangt.

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

Bei niedriger Temperatur wird das Modell 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: Verwenden temperature: 0.15 als Ihre Standardeinstellung für Ministral-3.

3. Saubere JSON-Antworten erhalten

Produzieren maschinenlesbares JSON von LLMs ist schwieriger als es klingt.

Ministral interpretiert Schemafelder dazu tendenziell. semantisch statt strukturell, was zu tief 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.'
  };
}