Introducción

Ejecutar Ministral-3 en vLLM resulta sorprendentemente potente. El modelo es rápido, creativo y capaz de generar respuestas de alta calidad incluso bajo cargas de trabajo intensivas.

Pero una vez que pasas de simples indicaciones en formato chat a salidas estructuradas, automatización o uso programático, las cosas se complican rápidamente.

Durante el desarrollo de un juego de Jeopardy impulsado por IA con 12 jugadores simultáneos y cientos de llamadas al modelo, nos encontramos con varios problemas prácticos:

• Aparecen marcas de Markdown en las respuestas de texto plano
• salidas en formato JSON volviéndose profundamente anidadas
• Se superan los límites de tokens
• Pequeñas diferencias de formato que rompen la lógica posterior

Esta guía resume las lecciones prácticas aprendidas al resolver estos problemas, junto con patrones concretos que puedes reutilizar en tus propios proyectos.

El Escenario del Mundo Real

Nuestro proyecto de referencia simula un juego completo de Jeopardy! donde:

• El AI anfitrión genera categorías y pistas
• Varios participantes de IA responden simultáneamente
• Otro juez de IA evalúa la precisión
• Los puntajes se registran durante las rondas

Una sola ejecución del juego puede superar fácilmente 800 llamadas de API.

Este entorno expuso casos límite que rara vez aparecen en demostraciones simples — convirtiéndolo en una excelente cama de pruebas para entender cómo Ministral se comporta bajo cargas reales de producción.

1. Ejecutando Ministral-3 en vLLM

Los modelos Ministral no utilizan la configuración estándar del tokenizador de HuggingFace

Esto significa que el comando de inicio debe habilitar explícitamente el formato del tokenizador de Mistral.

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

Si su aplicación depende de llamadas a funciones, agregue las banderas de herramientas:

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

Limitación importante

A diferencia de otros modelos, Ministral no admite chat_template_kwargs

Si envías una solicitud como esta:

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

vLLM devuelve:

HTTP 400: chat_template is not supported for Mistral tokenizers

Eso significa que funciones como el ajuste explícito del modo "pensamiento" (utilizado en modelos como Qwen o DeepSeek) simplemente no están disponibles

Afortunadamente, esto rara vez es necesario porque Ministral ya genera salidas concisas por defecto.

2. Temperatura: El parámetro más importante

La documentación oficial de vLLM utiliza consistentemente el siguiente valor con Ministral-3:

temperature = 0.15

A primera vista esto parece extremadamente bajo. Sin embargo, resulta ser crítico para tareas estructuradas.

¿Qué ocurre con temperaturas más altas?

Usando el valor predeterminado estilo OpenAI:

temperature: 0.7

el modelo se vuelve demasiado creativo con la estructura

Una solicitud sencilla como:

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

podría devolver algo como:

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

Aunque es JSON técnicamente válido, no cumple con lo que el esquema solicitó.

El resultado:

• El JSON resulta más grande de lo esperado
• max_tokens se superan los límites
• Las respuestas quedan truncadas
• Fallo al analizar

¿Por qué 0.15 funciona mejor

A baja temperatura el modelo se vuelve estructuralmente disciplinado.

temperature: 0.15

Ventajas:

• El JSON sigue esquemas con precisión
• el uso de tokens se vuelve predecible
• las estructuras anidadas casi desaparecen
• las respuestas se mantienen dentro de los límites de tokens

Incluso la generación creativa de texto sigue siendo sólida; el modelo simplemente deja de improvisar en la estructura.

Recomendación: Usa temperatura: 0.15 como valor predeterminado para Ministral-3.

3. Obtener Respuestas en JSON Limpio

Generar JSON legible por máquina desde modelos de lenguaje es más difícil de lo que parece.

Ministral tiende a interpretar los campos del esquema de manera semántica en lugar de estructuralmente, lo que genera salidas profundamente anidadas.

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