Ir al contenido principal
Español— Elegir un idioma
Menú

Migración desde Magistral

Lección 8 de 12 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. ¿En qué punto está tu código?
  2. Tabla de correspondencia
  3. Qué cambia en el código
  4. Validación de la migración
  5. Aprovechar la migración
  6. Puntos clave

Lección reescrita el 2 de noviembre de 2026. Esta lección describía originalmente el razonamiento «siempre activo» de Magistral. Dado que todos los modelos Magistral se retiraron el 31 de julio de 2026, ahora cubre la migración a reasoning_effort. Fuentes: Models — deprecated and removed models · Reasoning · Native reasoning (deprecated).

¿En qué punto está tu código?

Las últimas versiones de Magistral, Small 1.2 y Medium 1.2 (-2509), se marcaron como obsoletas en la primavera de 2026 y se retiraron el 31 de julio de 2026; las versiones 1.0 y 1.1 ya se habían retirado el 30 de noviembre de 2025. Cualquier código que siga llamando a magistral-small-latest, magistral-medium-latest o a un identificador con fecha de esa familia está apuntando a un modelo que ya no existe. La migración ya no es algo que debas planificar, es algo que debes hacer ahora.

Tabla de correspondencia

Estabas usandoSustituto designado por MistralLo que recomendamos hoy
Magistral Small (1.0, 1.1, 1.2)Mistral Small 4mistral-small-2603 con reasoning_effort="high"
Magistral Medium (1.0, 1.1, 1.2)Mistral Medium 3.5Small 4 si la calidad es suficiente; si no, mistral-large-4-0 con reasoning_effort="high"

¿Por qué no seguir al pie de la letra el sustituto designado por Mistral para Magistral Medium? Porque Mistral Medium 3.5 está él mismo obsoleto desde el 31 de octubre de 2026, con su retirada programada para el 30 de abril de 2027, y Large 4 como su sucesor. Migrar a él significa comprometerte a una segunda migración dentro de seis meses. Large 4 está en vista previa pública: si ese nivel de madurez no encaja en tu entorno de producción, Medium 3.5 sigue siendo un posible paso intermedio, siempre que programes ahora el siguiente cambio.

Qué cambia en el código

Magistral razonaba siempre; los modelos actuales solo razonan cuando se lo pides. El equivalente natural de «siempre activo» es, por tanto, reasoning_effort="high".

# Antes: Magistral (retirado)
response = client.chat.complete(
    model="magistral-medium-latest",
    messages=[
        {"role": "system", "content": "You are a rigorous analyst."},
        {"role": "user", "content": question},
    ],
    prompt_mode=None,   # desactivaba el prompt de sistema por defecto de Magistral
)

# Después: Mistral Large 4 con razonamiento explícito
response = client.chat.complete(
    model="mistral-large-4-0",
    messages=[
        {"role": "system", "content": "You are a rigorous analyst."},
        {"role": "user", "content": question},
    ],
    reasoning_effort="high",
)

Cuatro puntos que debes abordar en el proceso:

  1. Identificadores de modelo: busca magistral en tu código, archivos de configuración y variables de entorno.
  2. prompt_mode: la documentación de razonamiento ya no lo menciona; elimínalo de tus llamadas.
  3. Prompts de sistema: borra la plantilla de razonamiento específica de Magistral (el fragmento thinking colocado en el mensaje de sistema) y conserva solo las instrucciones de método y formato (lección 6).
  4. Lectura de respuestas: la estructura de Magistral 25.07 y 25.09 (ThinkChunk seguido de TextChunk) coincide con la de los modelos actuales, por lo que tu código de lectura sigue siendo válido. Solo tienes que añadir el manejo del caso de cadena simple, que devuelven Small 4 y Medium 3.5 cuando reasoning_effort="none". Si tu código provenía de Magistral 25.06 y buscaba etiquetas <think> en el texto, sustitúyelo por la función separer de la lección 3.

Validación de la migración

No cambies a ciegas. Vuelve a ejecutar una muestra de tus casos reales, junto con sus respuestas de referencia, y compara tres métricas: calidad (precisión, cumplimiento del formato), tokens consumidos (usage.completion_tokens) y latencia. Un script sencillo basta para ello:

import time

def comparer(client, cas, configs):
    """cas: lista de (pregunta, verificador); configs: lista de (modelo, nivel)."""
    for model, niveau in configs:
        justes = tokens = 0
        debut = time.perf_counter()
        for question, verifier in cas:
            r = client.chat.complete(
                model=model,
                messages=[{"role": "user", "content": question}],
                reasoning_effort=niveau,
            )
            _, reponse = separer(r.choices[0].message.content)
            justes += bool(verifier(reponse))
            tokens += r.usage.completion_tokens
        duree = time.perf_counter() - debut
        print(f"{model} ({niveau}) : {justes}/{len(cas)} correctos, {tokens} tokens, {duree:.0f} s")

comparer(client, mes_cas, [
    ("mistral-small-2603", "high"),
    ("mistral-large-4-0", "medium"),
    ("mistral-large-4-0", "high"),
])

La función verifier depende de tu dominio: comparación con un valor esperado, presencia de elementos requeridos o validación JSON. Esto es lo que convierte una impresión en una decisión.

Aprovechar la migración

Ya que vas a tocar todas las llamadas al modelo, aprovecha la oportunidad para fijar identificadores con fecha en producción (mistral-small-2603 en lugar de mistral-small-latest) y para centralizar la elección del modelo y del nivel de razonamiento en una única configuración. La próxima obsolescencia —y la habrá— será entonces un cambio de una sola línea.

Puntos clave

  • Magistral se retiró el 31 de julio de 2026: cualquier llamada restante apunta a un modelo no disponible
  • Magistral Small → Small 4; Magistral Medium → Small 4 o Large 4 en lugar de Medium 3.5, que está él mismo obsoleto
  • «Siempre activo» se traduce como reasoning_effort="high"
  • Elimina prompt_mode y la plantilla de razonamiento de los prompts de sistema
  • Valida con tus casos reales (calidad, tokens, latencia) y luego fija los identificadores con fecha