Introduction

Exécuter Ministral-3 sur vLLM est surprenantement puissant. Le modèle est rapide, créatif et capable de produire des réponses de haute qualité, même sous forte charge.

Mais dès que l’on passe des invites de discussion simples à des sorties structurées, automatisation ou utilisation programmatique, les choses deviennent rapidement complexes.

Développement d'un jeu de type Jeopardy piloté par IA avec 12 joueurs simultanés et des centaines d'appels au modèle

• 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 les leçons pratiques tirées de la résolution de ces problèmes, ainsi que des modèles concrets réutilisables dans vos propres projets.

Le scénario du monde réel

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

• L’IA animatrice génère les catégories et indices
• Plusieurs participants IA répondent simultanément
• Un autre juge IA évalue la justesse
• 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 les démonstrations simples — en faisant un excellent banc d'essai pour comprendre comment Ministral se comporte sous de réelles charges de travail en production.

1. Servir Ministral-3 sur vLLM

Les modèles Ministral n’utilisent pas la configuration de tokeniseur standard de HuggingFace.

Cela signifie que la commande de lancement doit explicitement activer le format de tokeniseur Mistral.

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

Si votre application repose sur l'appel de fonctions, ajoutez les drapeaux d'outil suivants :

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

Limitation importante

Contrairement à d'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 comme le basculement en mode de réflexion explicite (utilisé avec des modèles tels que Qwen ou DeepSeek) sont simplement indisponibles

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

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

temperature = 0.15

À première vue, cette valeur semble extrêmement faible. Pourtant, elle s'avère être critique 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

trop créatif au niveau de 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"
    }
  ]
}

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

structurellement rigoureux

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 : Utilisez temperature : 0,15 comme valeur par défaut pour Ministral-3.

3. Obtenir des réponses JSON propres

Générer un JSON lisible par machine à partir des modèles de langage est plus difficile qu'il n'y paraît.

Ministral tend à interpréter les champs de schéma de manière sémantique plutôt que structurale, ce qui conduit à des sorties profondément imbriquées.

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