Mistral API : guide complet pour l’utiliser dans ses projets (2026)

ParÉquipe IA Pratique

Mistral AI, la startup française, a rapidement imposé ses modèles comme une alternative sérieuse aux géants américains. Mais au-delà de l’interface web, c’est via l’API que Mistral déploie tout son potentiel : des modèles accessibles, des tarifs compétitifs, et une documentation claire.

Ce guide pratique vous explique comment utiliser la Mistral API dans vos projets, des modèles disponibles aux exemples de code concrets.

Pourquoi utiliser la Mistral API ?

Plusieurs raisons poussent les développeurs vers Mistral plutôt que vers OpenAI ou Anthropic :

  • Tarifs compétitifs : souvent 5 à 10x moins cher que GPT-4o pour des performances proches
  • Open source : certains modèles (Mistral 7B, Mixtral) peuvent tourner en local via Ollama
  • Données en Europe : infrastructure hébergée en UE, point important pour la conformité RGPD
  • API compatible OpenAI : la migration depuis l’API OpenAI est simple
  • Modèles spécialisés : Codestral pour le code, des modèles d’embedding, etc.

Si vous cherchez à faire tourner des LLM en local sans cloud, consultez aussi notre guide sur Ollama. Pour une comparaison Mistral vs ChatGPT, voir notre article dédié.

Créer son compte et obtenir une clé API

L’accès à la Mistral API se fait via la console La Plateforme (console.mistral.ai).

Étapes :

  1. Créer un compte sur console.mistral.ai
  2. Ajouter un moyen de paiement (carte bancaire)
  3. Aller dans API Keys → créer une nouvelle clé
  4. Copier la clé (elle ne s’affiche qu’une fois)

Il n’y a pas d’abonnement mensuel obligatoire : vous payez uniquement ce que vous consommez (modèle pay-as-you-go). Un crédit initial de test est parfois proposé pour les nouveaux comptes.

Stocker la clé de façon sécurisée :

# Dans votre fichier .env
MISTRAL_API_KEY=votre_clé_ici

# Ne jamais commiter ce fichier dans Git
echo ".env" >> .gitignore

Les modèles disponibles

Mistral propose plusieurs modèles avec des compromis différents entre performance et coût :

Modèle Usage recommandé Contexte Prix input (1M tokens)
mistral-large-latest Tâches complexes, raisonnement 128K ~2€
mistral-small-latest Tâches courantes, équilibre coût/perf 32K ~0,20€
mistral-nemo Modèle léger, très économique 128K ~0,10€
codestral-latest Génération et complétion de code 256K ~0,20€
mistral-embed Embeddings (RAG, recherche sémantique) 8K ~0,10€
pixtral-large Multimodal (texte + images) 128K ~2€

Les tarifs sont indicatifs et peuvent évoluer. Consultez la page de pricing officielle de Mistral pour les valeurs à jour.

Conseil pratique : Pour la plupart des applications, mistral-small-latest offre le meilleur compromis. Réservez mistral-large-latest pour les tâches qui nécessitent vraiment plus de raisonnement.

Installation et premier appel API

Installation du SDK Python

pip install mistralai

Premier appel basique

import os
from mistralai import Mistral

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

response = client.chat.complete(
    model="mistral-small-latest",
    messages=[
        {"role": "user", "content": "Explique le concept de RAG en 3 phrases."}
    ]
)

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

Avec un système de prompts

response = client.chat.complete(
    model="mistral-small-latest",
    messages=[
        {
            "role": "system",
            "content": "Tu es un assistant technique spécialisé en Python. Réponds en français, de façon concise."
        },
        {
            "role": "user",
            "content": "Comment lire un fichier CSV avec pandas ?"
        }
    ]
)

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

Streaming des réponses

Pour les interfaces utilisateur, le streaming évite d’attendre toute la réponse avant de l’afficher :

with client.chat.stream(
    model="mistral-small-latest",
    messages=[{"role": "user", "content": "Écris un poème sur l'IA"}]
) as stream:
    for text in stream.get_text_stream():
        print(text, end="", flush=True)

Utiliser Codestral pour la génération de code

Codestral est le modèle de Mistral spécialisé pour le code. Il supporte des contextes longs (256K tokens), ce qui le rend pratique pour analyser de grandes bases de code :

response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {
            "role": "user",
            "content": """Voici une fonction Python. Optimise-la et explique les changements :

def trouver_doublons(liste):
    doublons = []
    for i in range(len(liste)):
        for j in range(i + 1, len(liste)):
            if liste[i] == liste[j] and liste[i] not in doublons:
                doublons.append(liste[i])
    return doublons"""
        }
    ]
)

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

Embeddings et recherche sémantique

Les embeddings permettent de convertir du texte en vecteurs numériques pour la recherche sémantique (RAG, clustering, etc.) :

texts = [
    "L'intelligence artificielle transforme les entreprises",
    "Les LLM sont des modèles de langage entraînés sur de grandes quantités de données",
    "Le rugby est un sport collectif populaire en France"
]

embeddings_response = client.embeddings.create(
    model="mistral-embed",
    inputs=texts
)

# Récupérer les vecteurs
vectors = [e.embedding for e in embeddings_response.data]
print(f"Dimension des embeddings : {len(vectors[0])}")  # 1024 dimensions

Gérer les erreurs et les limites de taux

En production, il faut gérer les cas d’erreur proprement :

import time
from mistralai import Mistral
from mistralai.models import SDKError

def appel_avec_retry(client, messages, model="mistral-small-latest", max_retries=3):
    for tentative in range(max_retries):
        try:
            response = client.chat.complete(
                model=model,
                messages=messages
            )
            return response.choices[0].message.content
        except SDKError as e:
            if e.status_code == 429:  # Rate limit
                wait_time = 2 ** tentative  # Backoff exponentiel
                print(f"Rate limit atteint. Attente {wait_time}s...")
                time.sleep(wait_time)
            else:
                raise e
    raise Exception("Nombre maximum de tentatives atteint")

Compatibilité avec l’API OpenAI

Si vous avez déjà du code utilisant le SDK OpenAI, la migration est simple. Mistral propose un endpoint compatible :

from openai import OpenAI

# Utiliser le client OpenAI avec l'endpoint Mistral
client = OpenAI(
    api_key=os.environ["MISTRAL_API_KEY"],
    base_url="https://api.mistral.ai/v1"
)

response = client.chat.completions.create(
    model="mistral-small-latest",
    messages=[{"role": "user", "content": "Bonjour !"}]
)

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

Cette compatibilité permet de tester Mistral sans réécrire toute votre base de code.

Exemple concret : un assistant de résumé de documents

Un cas d’usage pratique qui illustre plusieurs fonctionnalités :

import os
from mistralai import Mistral

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

def resumer_document(texte: str, longueur: str = "courte") -> str:
    """
    Résume un document avec Mistral.
    longueur: "courte" (3-5 phrases) ou "detaillee" (paragraphe complet)
    """
    instructions = {
        "courte": "Résume ce texte en 3 à 5 phrases, en gardant les points essentiels.",
        "detaillee": "Fais un résumé détaillé de ce texte en un paragraphe structuré."
    }
    
    response = client.chat.complete(
        model="mistral-small-latest",
        messages=[
            {"role": "system", "content": "Tu es un assistant spécialisé dans la synthèse de documents. Réponds uniquement en français."},
            {"role": "user", "content": f"{instructions[longueur]}\n\nTexte :\n{texte}"}
        ],
        temperature=0.3  # Réponses plus déterministes pour les résumés
    )
    
    return response.choices[0].message.content

# Usage
with open("mon_document.txt", "r") as f:
    contenu = f.read()

print(resumer_document(contenu, longueur="courte"))

Bonnes pratiques

  • Choisir le bon modèle : commencez par mistral-small et montez en gamme seulement si nécessaire
  • Temperature : 0 à 0.3 pour les tâches factuelles, 0.7 à 1.0 pour la créativité
  • Monitorer les coûts : la console Mistral affiche votre consommation en temps réel
  • Tester en local d’abord : utilisez les modèles Mistral open source via Ollama pour développer sans frais
  • Stocker les conversations : conservez l’historique des messages pour les applications conversationnelles

Conclusion

La Mistral API est une option sérieuse pour les développeurs qui cherchent un bon rapport qualité-prix, une infrastructure européenne, et des modèles performants sur un large éventail de tâches.

La compatibilité OpenAI facilite la migration, et les modèles spécialisés (Codestral, Pixtral) couvrent des besoins spécifiques. Pour des projets qui nécessitent de la conformité RGPD ou une maîtrise des coûts à grande échelle, c’est une piste à explorer sérieusement.

Les modèles open source de Mistral restent aussi disponibles pour un déploiement 100% local si vous ne souhaitez pas dépendre d’une API cloud.

Publications similaires

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *