Les Modèles Magistral

Une famille dédiée au raisonnement

Les modèles Magistral de Mistral AI ne sont pas des modèles génériques auxquels on ajoute du raisonnement. Ce sont des modèles conçus dès le départ pour raisonner. Chaque token généré par un Magistral passe par un processus de réflexion structuré, sans qu’il soit nécessaire d’activer quoi que ce soit.

Les deux modèles disponibles

magistral-small-latest

• Positionnement : version compacte optimisée pour le rapport performance/coût
• Forces : recherche, raisonnement efficace, tâches nécessitant une réflexion structurée
• Cas d’usage : prototypage rapide, applications à fort volume, raisonnement sur des problèmes de complexité modérée
• Alias actuel : -latest pointe vers la version -2509

magistral-medium-latest

• Positionnement : modèle plus puissant, équilibre entre performance et coût
• Forces : raisonnement approfondi, problèmes complexes multi-étapes, analyse détaillée
• Cas d’usage : tâches critiques, debugging avancé, démonstrations mathématiques, architecture logicielle
• Alias actuel : -latest pointe vers la version -2509

Choix entre les deux

from mistralai import Mistral

client = Mistral(api_key="VOTRE_CLE_API")

# Pour les tâches courantes nécessitant du raisonnement
response_small = client.chat.complete(
    model="magistral-small-latest",
    messages=[{"role": "user", "content": "Résous 2x + 5 = 17"}]
)

# Pour les problèmes complexes nécessitant une réflexion profonde
response_medium = client.chat.complete(
    model="magistral-medium-latest",
    messages=[{"role": "user", "content": "Démontrez le théorème fondamental de l'algèbre par l'approche topologique."}]
)

Versions et évolution

Les modèles Magistral ont connu plusieurs versions, et la méthode de génération des traces de raisonnement a évolué :

Versions récentes (-2509 / -2507)

Les versions récentes utilisent des control tokens tokenisés pour délimiter les traces de raisonnement. Cela signifie que la séparation entre réflexion et réponse est gérée au niveau des tokens du modèle, pas par des tags textuels.

# Les versions récentes retournent des chunks structurés
response = client.chat.complete(
    model="magistral-medium-latest",  # pointe vers -2509
    messages=[{"role": "user", "content": "Votre question..."}]
)

# content est un tableau de chunks
for chunk in response.choices[0].message.content:
    print(f"Type: {chunk.type}")

Version ancienne (-2506)

La version -2506 utilisait des tags XML sous forme de strings pour délimiter le raisonnement :

<think>
Voici mon raisonnement étape par étape...
1. D'abord, j'analyse le problème...
2. Ensuite, je considère les options...
</think>

Voici ma réponse finale structurée.

Cette approche est désormais obsolète. Si vous migrez depuis -2506, vous devez adapter votre parsing.

Migration de -2506 vers -2509

Si votre code parse les tags <think>, voici comment migrer :

# ANCIEN code pour -2506
def parse_old_response(text):
    """Parse les tags <think> de l'ancienne version."""
    if "<think>" in text:
        thinking = text.split("<think>")[1].split("</think>")[0]
        answer = text.split("</think>")[1].strip()
        return thinking, answer
    return None, text

# NOUVEAU code pour -2509
def parse_new_response(response):
    """Parse les chunks structurés de la nouvelle version."""
    thinking = None
    answer = ""
    for chunk in response.choices[0].message.content:
        if chunk.type == "thinking":
            # Accès aux sous-éléments du thinking
            thinking_parts = chunk.thinking
            thinking = " ".join(part.text for part in thinking_parts)
        elif chunk.type == "text":
            answer = chunk.text
    return thinking, answer

Structure de réponse Magistral

La structure de réponse des modèles Magistral est légèrement différente de celle du raisonnement ajustable :

{
  "content": [
    {
      "type": "thinking",
      "thinking": [
        {"type": "text", "text": "Étape 1 : J'analyse le problème..."},
        {"type": "text", "text": "Étape 2 : Je considère les cas..."}
      ]
    },
    {
      "type": "text",
      "text": "Voici ma réponse finale..."
    }
  ]
}

Notez la différence : dans Magistral, le chunk thinking contient un sous-tableau thinking avec des éléments de type text. Dans le raisonnement ajustable (Small), le chunk thinking contient directement un champ text.

Spécifier une version précise

Pour garantir la stabilité de votre application en production, vous pouvez spécifier une version exacte :

# Version précise pour la production
response = client.chat.complete(
    model="magistral-medium-2509",  # version fixe
    messages=[{"role": "user", "content": "..."}]
)

# Version -latest pour le développement (suit les mises à jour)
response = client.chat.complete(
    model="magistral-medium-latest",  # pointe vers la dernière version
    messages=[{"role": "user", "content": "..."}]
)

En production, privilégiez toujours une version fixe pour éviter les surprises lors des mises à jour.

Points clés à retenir

• Deux modèles : magistral-small-latest (efficace) et magistral-medium-latest (puissant)
• -latest pointe actuellement vers la version -2509
• Les versions récentes (-2509/-2507) utilisent des control tokens, pas des tags <think>
• La structure de réponse Magistral a un sous-tableau thinking dans le chunk thinking
• En production, spécifiez une version fixe pour la stabilité
• Migrez le parsing si vous venez de la version -2506