Introduction

Exécution Ministral-3 sur vLLM est étonnamment puissant. Le modèle est rapide, créatif et capable de produire des réponses de haute qualité même sous de lourdes charges de travail.

Mais une fois que vous passez de simples invites de chat à sorties structurées, automatisation ou utilisation programmatiqueles choses se compliquent rapidement.

Au cours du développement d'un Jeu Jeopardy piloté par l'IA avec 12 joueurs simultanés et des centaines d'appels de modèles, nous avons rencontré plusieurs problèmes pratiques :

• Markdown apparaissant dans les réponses en texte brut
• Les sorties JSON devenant profondément imbriquées
• Les limites de jetons sont dépassées
• De légères différences de formatage entraînant des erreurs dans la logique en aval

Ce guide résume leçons pratiques tirées de la résolution de ces problèmes, ainsi que des modèles concrets que vous pouvez réutiliser dans vos propres projets.

Le scénario du monde réel

Notre projet de référence simule un jeu complet de Jeopardy où :

• Le l'IA hôte génère des catégories et des indices
• Multiples Les concurrents IA répondent simultanément
• Un autre L'IA juge de l'exactitude
• Les scores sont suivis tout au long des tours.

Une seule partie peut facilement dépasser 800 appels d'API.

Cet environnement a révélé des cas limites qui apparaissent rarement dans des démonstrations simples, ce qui en fait un excellent banc d'essai pour comprendre comment Ministral se comporte dans des conditions de production réelles.

1. Servir Ministral-3 sur vLLM

Modèles Ministral ne pas utiliser la configuration standard du tokenizer HuggingFace.

Cela signifie que la commande de lancement doit explicitement activer le Format de tokenizer Mistral.

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

Si votre application en dépend appel de fonction, ajoutez les options supplémentaires :

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

Limitation importante

Contrairement à certains autres modèles, Ministral ne prend pas en charge chat_template_kwargs.

Si vous envoyez une requête comme celle-ci :

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

vLLM renvoie :

HTTP 400: chat_template is not supported for Mistral tokenizers

Cela signifie que des fonctionnalités telles que basculement explicite du "mode de réflexion" (utilisés avec des modèles tels que Qwen ou DeepSeek) sont tout simplement non disponible.

Heureusement, ce n'est que rarement nécessaire car Ministral produit déjà des sorties concises par défaut.

2. La température : le paramètre le plus important

Le documentation officielle vLLM utilise systématiquement la valeur suivante avec Ministral-3 :

temperature = 0.15

Au premier abord, cela semble extrêmement bas. Cependant, il s'avère que ce n'est pas le cas. essentiel pour les tâches structurées.

Que se passe-t-il à des températures plus élevées

En utilisant la valeur par défaut de type OpenAI :

temperature: 0.7

le modèle devient trop créatif avec la structure.

Une simple requête comme :

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

peut renvoyer quelque chose comme :

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

Bien que techniquement valide JSON, ce n'est pas le cas. ce n'est pas ce que le schéma demandait.

Le résultat :

• Le JSON devient plus volumineux que prévu.
• max_tokens les limites sont dépassées
• Les réponses sont tronquées
• L'analyse échoue

Pourquoi 0.15 fonctionne mieux

À basse température, le modèle devient discipliné structurellement.

temperature: 0.15

Avantages :

• Le JSON suit précisément les schémas.
• l'utilisation des jetons devient prévisible
• les structures imbriquées disparaissent presque
• les réponses restent dans les limites des tokens

Même la génération de texte créatif reste performante — le modèle cesse simplement d'improviser avec la structure.

Recommandation : Utiliser temperature: 0.15 par défaut pour Ministral-3.

3. Obtenir des réponses JSON propres

La production JSON lisible par une machine provenant des LLM est plus difficile qu'il n'y paraît.

Ministral a tendance à interpréter les champs de schéma sémantiquement plutôt que structurellement, ce qui conduit à une sortie profondément imbriquée.

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