Mistral Medium 3.5 (128B denso, 256K)

Despliega Mistral Medium 3.5 en Clore.ai: 128B denso, contexto de 256K, razonamiento de modo dual lanzado en abril de 2026. Configuración de producción vLLM/SGLang en 4× H100 o 2× H200.

Estado (abril de 2026): Mistral Medium 3.5 se lanzó el 29 de abril de 2026 por Mistral AI como sucesor de Mistral Medium 3. Los pesos están en huggingface.co/mistralai/Mistral-Medium-3.5 bajo la Licencia de Investigación de Mistral (MRL) para investigación; la Licencia Comercial de Mistral es necesaria para uso en producción más allá de la evaluación. vLLM (≥ 0.8.x) y SGLang ofrecen soporte desde el día 0.

Mistral Medium 3.5 es un transformador denso de 128B con una ventana de contexto de 256K tokens y un interruptor nativo de razonamiento que alterna entre respuestas rápidas "instant" y trazas más largas de "cadena de pensamiento" "deep" en el mismo checkpoint. El lanzamiento consolida tres líneas de Mistral que antes estaban separadas — Medium 3 (instrucción general), Codestral (código) y la vista previa de razonamiento de Mistral — en un único modelo conmutables, que es el cambio principal para los equipos de ingeniería que estaban manejando múltiples pesos.

Para los usuarios de Clore.ai, la implicación práctica es el dimensionamiento. Un modelo denso de 128B en FP8 pesa aproximadamente 128 GB antes de la caché KV, así que no no cabe en una sola GPU de 80 GB a plena precisión — necesitas 4× H100 80 GB (FP8) o 2× H200 141 GB para servirlo correctamente vía vLLM. En el mercado eso se sitúa alrededor de bare metal para la configuración 4× H100 o ~4,16 $/h para 2× H200, que es el punto óptimo para la mayoría de los equipos. Los despliegues de una sola H100 solo funcionan con una cuantización Q4 GGUF agresiva (~70 tok/s vía llama.cpp), y el contexto de 256 K es lo primero que desaparece cuando comprimes.

Características clave

128B parámetros densos — sin trucos de enrutamiento MoE, perfil predecible de VRAM y latencia, más fácil de afinar que los modelos dispersos
ventana de contexto de 256K — análisis de bases de código completas, RAG de documentos largos, bucles de agentes de múltiples turnos sin truncamiento
Razonamiento en doble modo — alternar reasoning_mode=instant para una latencia de ~chat o reasoning_mode=deep para mostrar una <think> traza antes de la respuesta
Instrucción + código + razonamiento unificados — un solo conjunto de pesos reemplaza Medium 3 + Codestral + la vista previa de razonamiento
Llamadas a funciones y salidas estructuradas — cumplimiento nativo de esquemas JSON, formato de llamada a herramientas compatible con OpenAI
Pesos abiertos — MRL para investigación, licencia comercial disponible; los pesos se quedan en tu máquina y nunca hacen ida y vuelta a una API del proveedor
Soporte desde el día 0 para vLLM y SGLang — rutas FP8 listas para producción, paralelismo de tensores, prefill fragmentado, batching continuo

Modos de razonamiento

Medium 3.5 es el primer modelo de Mistral que ofrece un único checkpoint para respuestas "rápidas" y "pensadas". El interruptor se controla en tiempo de solicitud, no en tiempo de carga, así que un solo proceso vLLM maneja ambos modos para el mismo llamante.

Modo

Cuándo usar

TTFT típico

Forma de salida

instant (predeterminado)

Chat, autocompletado, clasificación, llamadas a funciones donde importa la latencia

50–250 ms

Solo respuesta

deep

Revisión de código, planificación de varios pasos, matemáticas, depuración difícil, paso de planificación de agentes

1–6 s antes del primer token de respuesta

<think>...</think> traza, luego respuesta final

En deep modo el modelo emite un tramo de razonamiento oculto (encapsulado en <think>...</think> por la plantilla de chat) antes de la respuesta visible. Esto cuesta desde unos pocos cientos hasta unos pocos miles de tokens extra por turno, así que no lo habilites para cada solicitud — resérvalo para tareas en las que, de otro modo, indicarías a un modelo más pequeño "piensa paso a paso". Un patrón razonable es mantener instant como predeterminado y solo escalar a deep para pasos de planificación de llamadas a herramientas o síntesis de la respuesta final.

Muestreo sugerido por el proveedor. Mistral recomienda temperature=0.15 para instant y temperature=0.7 con top_p=0.95 para deep modo. El muestreo con temperatura cero tiende a truncar prematuramente las trazas de razonamiento.

Elige tu despliegue

Tres configuraciones realistas en el mercado de Clore.ai. Elige primero por presupuesto de VRAM y luego por rendimiento.

Configuración

Precisión

VRAM total

Contexto (práctico)

Rendimiento

Nivel recomendado de Clore

Notas

1× H100 80 GB

Q4 GGUF (llama.cpp)

80 GB

32K–64K

~50–70 tok/s

GPU única, evaluación/desarrollo

Cuantización agresiva; se pierde algo de calidad en código largo

4× H100 80 GB

FP8 (vLLM)

320 GB

256K completo

~80–140 tok/s

Punto óptimo para producción

TP=4, mejor tok/$ para tráfico sostenido

2× H200 141 GB

FP8 o BF16

282 GB

256K completo

~90–130 tok/s

Alto contexto, menos GPUs que gestionar

Topología más simple, margen para la caché KV en 256K

Elección predeterminada: 4× H100 80 GB FP8 vía vLLM. Obtienes el contexto completo de 256K, ~100 tok/s sostenidos, API compatible con OpenAI y escalado limpio de paralelismo de tensores — por aproximadamente el coste diario de un solo asiento de uso intensivo de Claude Opus.

Requisitos del servidor

Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai. Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como bare metal bajo pedido. Consulta Precios y disponibilidad de GPU antes de dimensionar un despliegue.

Componente

Mínimo (Q4 una sola GPU)

Recomendado (FP8, 4× H100)

Alto contexto (2× H200)

VRAM de GPU

80 GB (1× H100)

4× 80 GB = 320 GB

2× 141 GB = 282 GB

RAM del sistema

128 GB

256 GB

Disco (NVMe)

200 GB

400 GB

Red

1 Gbps+ para descarga desde HF

1 Gbps+

CUDA

12.8+

Controlador

≥ 555

Tiempo de arranque

3–6 min (descarga en frío)

6–12 min (descarga en frío, 4 fragmentos)

5–10 min

El primer arranque en frío está dominado por la descarga de HuggingFace — los pesos FP8 son aproximadamente 128 GB, BF16 más cerca de 256 GB. Monta un volumen persistente en /root/.cache/huggingface para que solo pagues ese coste de ancho de banda una vez por servidor.

Despliegue rápido en CLORE.AI

La ruta más rápida es la imagen oficial vllm/vllm-openai con el paralelismo de tensores ajustado al número de tus GPUs. El ejemplo de abajo asume una instancia 4× H100.

Imagen Docker:

vllm/vllm-openai:latest

Puertos:

22/tcp
8000/http

Comando de arranque (4× H100, FP8):

vllm serve mistralai/Mistral-Medium-3.5-FP8 \\
    --tensor-parallel-size 4 \\
    --max-model-len 65536 \
    --gpu-memory-utilization 0.90 \\
    --enable-chunked-prefill \\
    --enable-auto-tool-choice \\
    --tool-call-parser mistral \\
    --reasoning-parser mistral \\
    --tokenizer-mode mistral \\
    --config-format mistral \\
    --load-format mistral \\
    --served-model-name mistral-medium-3.5 \\
    --host 0.0.0.0 \\
    --port 8000

Alternativa — 2× H200 BF16:

vllm serve mistralai/Mistral-Medium-3.5 \\
    --tensor-parallel-size 2 \\
    --max-model-len 131072 \\
    --gpu-memory-utilization 0.92 \\
    --enable-chunked-prefill \\
    --enable-auto-tool-choice \\
    --tool-call-parser mistral \\
    --reasoning-parser mistral \\
    --tokenizer-mode mistral \\
    --config-format mistral \\
    --load-format mistral \\
    --served-model-name mistral-medium-3.5 \\
    --host 0.0.0.0 \\
    --port 8000

Empieza con --max-model-len 65536 incluso en hardware que podría admitir más. La memoria de la caché KV crece linealmente con el contexto, y la mayoría de las cargas de trabajo nunca alcanzan 256K. Sube el valor una vez que hayas confirmado la mezcla de solicitudes.

Alternativa SGLang (a menudo más rápido en Hopper para prefill largos):

python3 -m sglang.launch_server \\
    --model-path mistralai/Mistral-Medium-3.5-FP8 \\
    --tp-size 4 \\
    --tool-call-parser mistral \\
    --reasoning-parser mistral \\
    --mem-fraction-static 0.88 \\
    --context-length 65536 \\
    --served-model-name mistral-medium-3.5 \\
    --host 0.0.0.0 \\
    --port 8000

Ejemplos de uso

Después del despliegue, encuentra tu http_pub URL en Mis pedidos en Clore.ai (por ejemplo abc123.clorecloud.net). Reemplaza localhost:8000 con https://YOUR_HTTP_PUB_URL en los ejemplos de abajo al llamar desde fuera del servidor.

1. Chat — Modo Instantáneo (predeterminado)

Respuesta de baja latencia, sin traza de razonamiento visible. Bueno para interfaces de chat, autocompletado, clasificación.

curl http://localhost:8000/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "mistral-medium-3.5",
    "messages": [
      {"role": "system", "content": "Eres un ingeniero backend senior."},
      {"role": "user", "content": "Escribe un middleware HTTP en Go que limite la tasa por clave de API con un token bucket."}
    ],
    "temperature": 0.15,
    "max_tokens": 1024,
    "extra_body": {"reasoning_mode": "instant"}
  }'

2. Chat — Modo Profundo (alternancia de razonamiento)

Habilita la <think> traza antes de la respuesta final. Úsalo para depuración difícil, planificación, matemáticas.

curl http://localhost:8000/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "mistral-medium-3.5",
    "messages": [
      {"role": "user", "content": "Un usuario informa que nuestro webhook de pagos se dispara dos veces para el 1% de los pedidos. Explica en orden de probabilidad las causas raíz más probables y propone un plan de diagnóstico."}
    ],
    "temperature": 0.7,
    "top_p": 0.95,
    "max_tokens": 4096,
    "extra_body": {"reasoning_mode": "deep"}
  }'

La respuesta incluirá un reasoning_content campo (vLLM analiza el <think>...</think> tramo fuera del mensaje visible) junto con content. Elimina o muestra la traza según tu producto.

3. Python — Cliente compatible con OpenAI

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="no necesario"
)

# Modo instantáneo — chat
response = client.chat.completions.create(
    model="mistral-medium-3.5",
    messages=[
        {"role": "system", "content": "Eres un asistente de programación útil."},
        {"role": "user", "content": "Refactoriza esta función de Python para mejorar la legibilidad."}
    ],
    temperature=0.15,
    max_tokens=1024,
    extra_body={"reasoning_mode": "instant"}
)
print(response.choices[0].message.content)

# Modo profundo — paso de planificación
plan = client.chat.completions.create(
    model="mistral-medium-3.5",
    messages=[
        {"role": "user", "content": "Planifica una migración de MongoDB a PostgreSQL para una tabla de pedidos de 2 TB con cero tiempo de inactividad."}
    ],
    temperature=0.7,
    max_tokens=4096,
    extra_body={"reasoning_mode": "deep"}
)

msg = plan.choices[0].message
print("PENSANDO:\n", getattr(msg, "reasoning_content", ""))
print("\nRESPUESTA:\n", msg.content)

4. Salidas estructuradas — Esquema JSON

Medium 3.5 admite decodificación guiada por esquema JSON mediante response_format. Útil cuando el consumidor final es un analizador, no una persona.

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="x")

schema = {
    "type": "object",
    "properties": {
        "severity": {"type": "string", "enum": ["low", "medium", "high", "critical"]},
        "categories": {
            "type": "array",
            "items": {"type": "string", "enum": ["auth", "payments", "db", "ui", "infra"]}
        },
        "summary": {"type": "string", "maxLength": 240},
        "next_action": {"type": "string"}
    },
    "required": ["severity", "categories", "summary", "next_action"],
    "additionalProperties": False
}

response = client.chat.completions.create(
    model="mistral-medium-3.5",
    messages=[
        {"role": "system", "content": "Clasifica el informe de error entrante. Devuelve JSON estricto."},
        {"role": "user", "content": "El inicio de sesión falla para los usuarios con apóstrofos en su correo, devolviendo 500 desde /webapi/login."}
    ],
    temperature=0.0,
    response_format={
        "type": "json_schema",
        "json_schema": {"name": "triage", "schema": schema, "strict": True}
    },
    extra_body={"reasoning_mode": "instant"}
)

import json
print(json.loads(response.choices[0].message.content))

5. Llamadas a funciones

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="x")

tools = [{
    "type": "function",
    "function": {
        "name": "search_orders",
        "description": "Busca en la base de datos de pedidos por ID de usuario y rango de fechas opcional",
        "parameters": {
            "type": "object",
            "properties": {
                "user_id": {"type": "string"},
                "start_date": {"type": "string", "format": "date"},
                "end_date": {"type": "string", "format": "date"}
            },
            "required": ["user_id"]
        }
    }
}]

response = client.chat.completions.create(
    model="mistral-medium-3.5",
    messages=[{"role": "user", "content": "Encuentra todos los pedidos del usuario u_4821 en abril de 2026."}],
    tools=tools,
    tool_choice="auto",
    temperature=0.1
)

for call in response.choices[0].message.tool_calls or []:
    print(call.function.name, call.function.arguments)

Consejos de rendimiento

Prefiere el checkpoint FP8 en Hopper. Mistral-Medium-3.5-FP8 es la compilación FP8 proporcionada por el proveedor y es aproximadamente 2× más ligera que BF16 con una pérdida de calidad despreciable en hardware de clase Hopper. Es el valor predeterminado adecuado tanto para 4× H100 como para 2× H200.
Paralelismo de tensores = número de GPUs. Para 4× H100 usa --tensor-parallel-size 4; para 2× H200 usa --tensor-parallel-size 2. El paralelismo de canalización en un solo nodo normalmente perjudica el rendimiento para un modelo denso de 128B.
Limita max-model-len a lo que realmente usas. La caché KV a 256K es enorme — una sola secuencia en contexto completo puede consumir 30–50 GB. Establece --max-model-len 65536 (o 32768) a menos que tengas una necesidad verificada de más, y súbelo solo después de perfilar.
Habilita el prefill fragmentado. --enable-chunked-prefill mantiene fluyendo los tokens de decodificación mientras los prompts grandes aún se están procesando. Para prompts de 100K+ esto marca la diferencia entre "responsivo" y "agotado por tiempo".
Cacha los pesos. Monta un volumen de Docker en /root/.cache/huggingface y reutilízalo entre reinicios. Volver a descargar 128 GB en cada arranque en frío es la causa más común de "vLLM parece tardar mucho en iniciar".
Cuantización de la caché KV para margen adicional. En 4× H100 puedes exprimir más sesiones concurrentes con --kv-cache-dtype fp8. El proveedor informa una calidad casi sin pérdida; verifícalo en tu conjunto de evaluación antes de activarlo en producción.
No uses deep modo para cada solicitud. Las trazas de razonamiento cuestan tokens reales y latencia real. Enruta por tipo de tarea: clasificación, autocompletado y generación de argumentos de herramientas permanecen en instant; los pasos de planificación y verificación pasan a deep.
La decodificación especulativa ayuda. vLLM y SGLang ambos admiten decodificación especulativa con modelo borrador (por ejemplo, con un borrador Ministral 3B). En completaciones largas de código esto normalmente aporta un aumento de rendimiento de 1.3–1.7× sin coste de calidad.

Pruebas comparativas

Números publicados por el proveedor — verifícalos de forma independiente. La tabla de abajo procede del anuncio de Mistral AI del 29 de abril de 2026. Las reproducciones independientes de terceros (LMSys, EQ-Bench, la tabla de clasificación de SWE-Bench) aún están llegando. Tómalo como orientativo, no como autoritativo.

Benchmark

Mistral Medium 3.5 (proveedor)

Puntos de referencia (citados por el proveedor)

MMLU-Pro

~78%

Llama 4 Maverick ~76%, GPT-5.4 ~81%

HumanEval

~92%

Codestral 25.01 ~88%, GLM-5.1 ~94%

LiveCodeBench (abr 2026)

~68%

GLM-5.1 ~72%, Llama 4 Maverick ~64%

AIME 2025 (modo profundo)

~62%

GPT-5.4 ~73%, GLM-5.1 ~58%

GPQA Diamond (modo profundo)

~59%

Claude Opus 4.6 ~63%, GLM-5.1 ~57%

Recuerdo de contexto largo (128K)

~95%

Llama 4 Maverick ~93%

El posicionamiento al que apunta Mistral: aproximadamente nivel de Llama 4 Maverick / GLM-5.1 en tareas generales, brecha de código más estrecha, alternancia de razonamiento distintiva. No se presenta como un competidor de GPT-5.4 / Claude Opus 4.6.

Solución de problemas

Problema

Solución

CUDA sin memoria en carga (4× H100)

Probablemente estás cargando BF16 por error. Usa el checkpoint FP8 (Mistral-Medium-3.5-FP8) o baja a --max-model-len 32768.

CUDA sin memoria a mitad de solicitud con contexto de 256K

La caché KV explotó. Reduce --max-model-len, habilita --kv-cache-dtype fp8, o limita --max-num-seqs (prueba 8).

El modo profundo produce reasoning_content

Confirma --reasoning-parser mistral está establecido en vLLM y que temperature ≥ 0.5. El muestreo con temperatura cero trunca la traza.

Tiempo lento hasta el primer token en modo profundo

Esperado — el modo profundo emite un <think> tramo antes de cualquier salida visible. Haz streaming al cliente con stream=true y muestra un estado de interfaz "pensando…".

403 Prohibido de la descarga desde HuggingFace

Mistral Medium 3.5 está restringido. Acepta la MRL en la tarjeta del modelo y establece HF_TOKEN en el entorno del contenedor.

tokenizer_mode mistral errores

Las tres banderas son necesarias juntas: --tokenizer-mode mistral --config-format mistral --load-format mistral.

Llamadas a herramientas descartadas silenciosamente

Establece ambas --enable-auto-tool-choice y --tool-call-parser mistral. Sin el analizador, vLLM devuelve los argumentos de las herramientas como texto plano.

El rendimiento se desploma después de ~32 sesiones concurrentes

Has alcanzado la expulsión de la caché KV. Reduce --max-model-len, aumenta --gpu-memory-utilization a 0.92, o escala horizontalmente a una segunda réplica.

Error de licencia que bloquea el uso comercial

MRL es solo para investigación. Contacta con ventas de Mistral para la licencia comercial antes de atender a usuarios de pago.

Preguntas frecuentes

P: Mistral Medium 3.5 vs Llama 4 Maverick — ¿cuál debería elegir?

Ambos están en una clase de peso similar (Maverick es MoE con 17B activos y 400B totales; Medium 3.5 es denso de 128B). Elige Medium 3.5 si quieres VRAM/latencia predecibles, el interruptor de razonamiento de doble modo en un solo checkpoint y mejor rendimiento de código. Elige Llama 4 Maverick si necesitas licencia permisiva para uso comercial sin restricciones (Llama 4 tiene licencia comunitaria; Medium 3.5 necesita licencia comercial de Mistral para producción) o si quieres el menor coste de inferencia por token que MoE te ofrece por solicitud.

P: ¿Cómo habilito el modo de razonamiento?

Pasa extra_body={"reasoning_mode": "deep"} en el cliente Python de OpenAI, o incluye "reasoning_mode": "deep" en el nivel superior de tu cuerpo JSON HTTP. El valor predeterminado es "instant". En el lado del servidor, asegúrate de que vLLM se haya iniciado con --reasoning-parser mistral para que el <think> span se analice en el reasoning_content campo en lugar de filtrarse en content.

P: ¿Por qué 4× H100 en lugar de 2× H100?

Los pesos FP8 son ~128 GB antes de la caché KV. 2× H100 de 80 GB te dan 160 GB en total — suficiente para cargar los pesos, pero con casi nada de margen para la caché KV, las activaciones o incluso una ventana de contexto moderada. En la práctica, 2× H100 se queda sin memoria (OOM) inmediatamente al pasar de un contexto de 8K. 4× H100 es el mínimo para una implementación usable compatible con 256K; 2× H200 (282 GB) es la alternativa si prefieres administrar menos GPUs con un costo por GPU ligeramente más alto.

P: ¿Puedo usar Mistral Medium 3.5 comercialmente?

La Licencia de Investigación de Mistral predeterminada (MRL) permite la investigación y la evaluación interna, pero no producción comercial. Para implementaciones orientadas a clientes de pago necesitas la Licencia Comercial de Mistral — contacta con ventas de Mistral. Este es el mismo requisito de acceso que se aplicaba anteriormente a Medium 3 y Codestral. Si una licencia favorable para uso comercial es un requisito indispensable, mira Mistral Small 3.1 (Apache 2.0) o Llama 4 (licencia comunitaria de Llama).

P: ¿Medium 3.5 admite visión o audio?

No. Medium 3.5 es solo de texto. Para Mistral multimodal, usa Mistral Large 3, que incluye un codificador de visión de 2.5B. Para otras opciones multimodales en Clore.ai, consulta Qwen3.5-Omni o Gemma 3.

Guías relacionadas

Mistral Large 3 — modelo fronterizo multimodal MoE de 675B, Apache 2.0, cuando necesites visión y la máxima calidad
Mistral y Mixtral — Mistral 7B más antiguo y Mixtral 8x7B/8x22B para implementaciones de una sola GPU
vLLM — framework de servicio en producción, el backend recomendado para Medium 3.5
Llama 4 — el par de pesos abiertos más cercano a esta escala, alternativa con licencia permisiva

Enlaces externos

AnteriorMistral Large 3 (675B MoE)

SiguienteMiMo-V2-Flash

Última actualización hace 1 mes

¿Te fue útil?