Comment utiliser l'API Mistral Large 4

Mistral Large 4 a été mis en ligne sur l'API Mistral le 6 octobre 2026, trois semaines avant la publication de ses poids ouverts. Si vous souhaitez essayer dès maintenant le modèle "Le Chonk" de 1 000 milliards de paramètres, l'API est le seul moyen d'y accéder, et c'est aussi le moyen le moins cher actuellement : Mistral le propose à **0,68 $ par million de jetons d'entrée et 2,09 $ par million de jetons de sortie** pendant l'aperçu public, soit la moitié du prix catalogue de 1,36 $ / 4,18 $.

Ce guide vous permet de passer de zéro à un premier appel fonctionnel en cinq minutes environ, puis il aborde les points qui posent problème : les blocs de raisonnement, l'entrée d'images, l'appel de fonctions, la sortie JSON et le coût. Chaque requête peut être enregistrée et rejouée dans Apidog afin que vous puissiez comparer Large 4 avec le modèle que vous utilisez actuellement.

Nouveau pour le modèle lui-même ? Lisez d'abord Mistral est de retour : Le Chonk bat GPT-6 Astra et Claude en cybersécurité pour les benchmarks et ce qui se cache derrière le titre cyber.

Ce dont vous avez besoin

Étape 1 : Obtenir une clé API

1. Connectez-vous à Mistral Studio (anciennement La Plateforme).
2. Ouvrez **Clés API** et créez une nouvelle clé. Donnez-lui un nom qui indique où elle sera utilisée, par exemple local-dev ou ci-staging.
3. Copiez-la une seule fois. Le Studio ne la montrera plus.
4. Exportez-la dans votre shell :

export MISTRAL_API_KEY="your-key-here"

Gardez la clé en dehors du contrôle de version. Si vous l'intégrez à plusieurs outils, notre guide sur les bonnes pratiques de gestion des clés API couvre la rotation et la portée.

Étape 2 : Effectuer votre premier appel

La vérification la plus rapide est un simple appel curl :

curl https://api.mistral.ai/v1/chat/completions \
  -H "Authorization: Bearer $MISTRAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-large-4",
    "messages": [
      {"role": "user", "content": "Give me three edge cases to test on a pagination API."}
    ]
  }'

Une réponse réussie renvoie choices[0].message.content avec la réponse et un bloc usage contenant prompt_tokens, completion_tokens et total_tokens. Si vous obtenez un 401, la clé est incorrecte ou non exportée. Un 404 sur le modèle signifie généralement une faute de frappe dans l'ID du modèle.

Le même appel en Python

import os
from mistralai import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

response = client.chat.complete(
    model="mistral-large-4",
    messages=[
        {"role": "user", "content": "Give me three edge cases to test on a pagination API."}
    ],
)

print(response.choices[0].message.content)

Et en TypeScript

import { Mistral } from "@mistralai/mistralai";

const client = new Mistral({ apiKey: process.env.MISTRAL_API_KEY });

const response = await client.chat.complete({
  model: "mistral-large-4",
  messages: [
    { role: "user", content: "Give me three edge cases to test on a pagination API." },
  ],
});

console.log(response.choices[0].message.content);

Étape 3 : L'enregistrer dans Apidog

Taper des commandes curl devient fastidieux dès que vous commencez à comparer les modèles. Dans Apidog :

1. Créez une nouvelle requête HTTP : POST https://api.mistral.ai/v1/chat/completions.
2. Ajoutez une variable d'environnement MISTRAL_API_KEY et définissez l'en-tête Authorization: Bearer {{MISTRAL_API_KEY}}.
3. Collez le corps JSON de l'étape 2 et cliquez sur **Envoyer**.
4. Dupliquez la requête, changez model pour le modèle que vous utilisez actuellement (par exemple mistral-medium-3-5), et exécutez les deux.

Vous avez maintenant deux requêtes enregistrées avec le même prompt. Apidog affiche le corps de la réponse, le statut, le temps d'exécution et la taille pour chacune, afin que vous puissiez comparer la qualité de la réponse, la latence et le nombre de jetons usage sans écrire de script. Ajoutez une assertion post-réponse selon laquelle choices[0].message.content n'est pas vide et vous avez un test de validation rapide que vous pouvez réexécuter chaque fois que Mistral met à jour l'aperçu.

Étape 4 : Activer et désactiver le raisonnement

Large 4 est un modèle hybride : le même modèle gère les réponses rapides et le raisonnement étape par étape. Vous le contrôlez avec un seul paramètre, reasoning_effort :

curl https://api.mistral.ai/v1/chat/completions \
  -H "Authorization: Bearer $MISTRAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-large-4",
    "messages": [
      {"role": "user", "content": "Our API returns 200 with an empty body under load. List likely causes in order of probability."}
    ],
    "reasoning_effort": "high"
  }'

**C'est la partie qui casse les analyseurs.** Avec `reasoning_effort: "high"`, `message.content` n'est plus une chaîne de caractères. Il devient une liste de blocs :

• un bloc `thinking` contenant la trace de raisonnement, et
• un bloc `text` contenant la réponse finale.

Ainsi, `response.choices[0].message.content` affichera une liste, et non votre réponse. Extrayez explicitement le bloc de texte :

response = client.chat.complete(
    model="mistral-large-4",
    messages=[{"role": "user", "content": "Why would a 200 response have an empty body?"}],
    reasoning_effort="high",
)

content = response.choices[0].message.content
if isinstance(content, str):
    answer = content
else:
    answer = "".join(c.text for c in content if c.type == "text")

print(answer)

Les jetons de réflexion sont facturés comme des jetons de sortie, donc `"high"` coûte plus cher par requête. Par défaut, utilisez `"none"` et ne passez à `"high"` que pour les appels qui en ont besoin.

Étape 5 : Envoyer une image

Large 4 est nativement multimodal, avec un encodeur de vision de 1,6 milliard de paramètres. Transmettez les images comme des parties de contenu à côté de votre texte :

curl https://api.mistral.ai/v1/chat/completions \
  -H "Authorization: Bearer $MISTRAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-large-4",
    "messages": [
      {
        "role": "user",
        "content": [
          {"type": "text", "text": "This is a screenshot of our API error dashboard. Which endpoint is failing most and what is the error code?"},
          {"type": "image_url", "image_url": "https://example.com/dashboard.png"}
        ]
      }
    ]
  }'

Pour les fichiers locaux, envoyez plutôt une URL de données base64 : "image_url": "data:image/png;base64,<encoded>". Mistral indique que Large 4 obtient 42 % au benchmark de mise à la terre visuelle Dense 200, juste devant les 41 % de GPT-6 Astra, donc les captures d'écran de tableaux de bord, de graphiques et d'états d'interface utilisateur sont une utilisation pertinente.

Étape 6 : Appel de fonction

L'appel de fonction est l'endroit où les benchmarks d'agent de Large 4 (59,9 % sur AutomationBench) deviennent utiles. Vous décrivez les outils, le modèle décide quand les appeler, et votre code exécute l'appel.

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_order_status",
            "description": "Look up the status of an order by its ID.",
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {"type": "string", "description": "The order ID, e.g. ORD-1042"}
                },
                "required": ["order_id"],
            },
        },
    }
]

messages = [{"role": "user", "content": "Where is order ORD-1042?"}]

response = client.chat.complete(
    model="mistral-large-4",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.function.name, tool_call.function.arguments)

Exécutez vous-même la fonction, puis renvoyez le résultat avec l'`tool_call_id` correspondant :

import json

result = {"order_id": "ORD-1042", "status": "shipped", "eta": "2026-10-09"}

messages.append(response.choices[0].message)
messages.append({
    "role": "tool",
    "name": "get_order_status",
    "content": json.dumps(result),
    "tool_call_id": tool_call.id,
})

final = client.chat.complete(model="mistral-large-4", messages=messages, tools=tools)
print(final.choices[0].message.content)

Le schéma d'outil est un simple JSON Schema. Si votre API dispose déjà d'une spécification OpenAPI, vous pouvez reprendre directement le schéma de requête pour chaque opération dans `parameters`. Concevoir d'abord la spécification dans Apidog permet de maintenir les définitions d'outils et l'API réelle synchronisées.

Étape 7 : Obtenir du JSON en retour

Lorsque vous avez besoin d'une sortie lisible par machine, définissez `response_format` :

curl https://api.mistral.ai/v1/chat/completions \
  -H "Authorization: Bearer $MISTRAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-large-4",
    "messages": [
      {"role": "user", "content": "Extract method, path and status code from: GET /v1/users/42 returned 404. Reply in JSON."}
    ],
    "response_format": {"type": "json_object"}
  }'

Mentionnez JSON dans le prompt ainsi que dans `response_format`. Pour des formes strictes, Mistral prend également en charge `{"type": "json_schema", "json_schema": {...}}` avec un schéma complet. Dans Apidog, ajoutez une assertion de schéma JSON sur la réponse afin qu'une forme divergente échoue bruyamment au lieu de casser un service en aval.

Ce que ça coûte

Un exemple concret : un agent qui effectue 10 000 appels par jour, chacun avec 3 000 jetons d'entrée (principalement un prompt système et des outils mis en cache) et 500 jetons de sortie.

• Entrée : 30M de jetons. Si 2 500 des 3 000 sont en cache, cela représente 25M en cache à 0,07 $ et 5M frais à 0,68 $, soit environ **5,15 $/jour**.
• Sortie : 5M de jetons à 2,09 $, soit environ **10,45 $/jour**.
• Total : environ **15,60 $/jour au prix d'aperçu**, soit environ 31 $ au prix catalogue.

La même charge de travail sur GPT-6 Astra (10 $ / 50 $ par million, avant les remises de mise en cache) coûterait plusieurs centaines de dollars par jour. Mistral n'a pas précisé quand la tarification d'aperçu prend fin, alors prévoyez votre budget en fonction du prix catalogue.

Erreurs courantes

FAQ

Mistral Large 4 est-il compatible avec OpenAI ? La forme de la requête est très similaire : model, messages, tools, tool_choice et response_format fonctionnent tous comme vous l'attendez. Utilisez les SDK Mistral ou le HTTP simple pour plus de sécurité. La sortie de raisonnement utilise le format de bloc propre à Mistral.

Quand pourrai-je l'exécuter localement ? Mistral annonce que les poids seront livrés d'ici fin octobre 2026. Avec un total de 1,05 milliard de paramètres, il nécessite un matériel serveur multi-GPU. Notre guide exécuter Mistral 3 localement couvre en attendant les outils pour les modèles plus petits.

L'aperçu est-il suffisamment stable pour la production ? Pas encore. Le modèle est étiqueté "aperçu public" et peut changer avant la publication des poids. Épinglez vos tests, réexécutez-les lorsque Mistral met à jour le modèle, et gardez un modèle de secours configuré.

Puis-je utiliser Large 4 avec mon code Mistral existant ? Oui. Même URL de base, même authentification, même SDK. Changez la chaîne model en mistral-large-4. Si vous venez de Medium 3.5, consultez notre guide API Mistral Medium 3.5 pour les parties qui sont transférables.

Conclusion

En cinq minutes, vous obtenez un appel fonctionnel. L'heure suivante est mieux dépensée à exécuter vos vrais prompts sur Large 4 et votre modèle actuel côte à côte. Enregistrez les deux requêtes dans Apidog, ajoutez des assertions sur le statut et la forme de la réponse, et vous saurez en un jour si Le Chonk mérite une place dans votre pile technologique, tant que le prix d'aperçu est encore à moitié prix.