Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

API Codestral en Python

Lektion 3 av 14 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Appeler Codestral depuis Python
  2. Installation et configuration
  3. Appel FIM complet
  4. Appel Chat pour la génération de code
  5. Paramètres avancés
  6. Deux modèles à copier-coller
  7. Gestion des erreurs
  8. Viktiga punkter

Appeler Codestral depuis Python

Cette leçon passe de la théorie au code exécutable. Tu vas utiliser le SDK Python de Mistral AI pour interroger Codestral sur ses deux points de terminaison, ajuster les paramètres avancés qui font la différence entre une suggestion utile et une réponse verbeuse, et implémenter les modèles que l’on retrouve dans la plupart des intégrations réelles.

Installation et configuration

Installe le SDK en une seule commande :

pip install mistralai

Récupère ta clé API sur console.mistral.ai et lis-la depuis l’environnement plutôt que de la coder en dur dans ton fichier :

import os
from mistralai.client import Mistral

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

Deux plateformes hébergent Codestral, et tu choisis entre elles lors de la création de ta clé. api.mistral.ai fonctionne sur une base de paiement à l’usage avec une facturation basée sur la consommation : c’est le chemin standard lorsque Codestral n’est qu’un composant parmi d’autres dans une application. codestral.mistral.ai est un point de terminaison dédié, accessible gratuitement ou via un abonnement, conçu pour une utilisation directe par un développeur au sein de son éditeur.

Appel FIM complet

Voici un appel FIM détaillé incluant tous les paramètres importants :

from mistralai.client import Mistral

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

response = client.fim.complete(
    model="codestral-latest",
    prompt="def calculate_vat(price_excl: float, rate: float = 0.20) -> float:",
    suffix="price = float(input('Price excl. VAT: '))\nprint(f'Price incl. VAT: {calculate_vat(price):.2f} EUR')",
    temperature=0,
    max_tokens=150,
    stop=["\n\n"],
)

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

Analyse de la réponse

L’objet retourné contient plus que le simple texte généré. En production, tu dois systématiquement vérifier trois éléments : la complétion elle-même, la consommation de tokens qui détermine ta facture, et la raison de l’arrêt, qui t’indique si le modèle a terminé naturellement ou s’il a atteint ta limite.

# Accéder à la complétion générée
text = response.choices[0].message.content

# Vérifier le nombre de tokens utilisés
tokens_prompt = response.usage.prompt_tokens
tokens_completion = response.usage.completion_tokens
tokens_total = response.usage.total_tokens

# Vérifier la raison de l'arrêt
reason = response.choices[0].finish_reason  # "stop", "length", etc.

Une finish_reason de "length" sur la moitié de tes appels est un signal clair : ton max_tokens est trop bas et tu livres du code tronqué à tes utilisateurs.

Appel Chat pour la génération de code

Dès qu’il n’y a pas de curseur au milieu d’un fichier — comme pour une génération complète, une explication ou un refactoring — le point de terminaison chat prend le relais. Le message système encadre alors le format de sortie, ce qui évite d’avoir à nettoyer la réponse ensuite :

response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {
            "role": "system",
            "content": "You are an expert Python development assistant. Respond with code only, no explanations."
        },
        {
            "role": "user",
            "content": "Write a Python function that validates an email address using regex."
        }
    ],
    temperature=0.2,
    max_tokens=500,
)

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

Paramètres avancés

La paire min_tokens / max_tokens encadre la longueur de la sortie. Le plancher est utile lorsque tu génères un bloc dont tu sais qu’il ne peut pas être plus court qu’un certain volume, comme une fonction avec sa gestion d’erreurs.

# min_tokens : force une longueur de sortie minimale
# max_tokens : limite la longueur maximale
response = client.fim.complete(
    model="codestral-latest",
    prompt=prompt,
    suffix=suffix,
    min_tokens=20,
    max_tokens=300,
)

Les tokens d’arrêt jouent un rôle différent : ils haltent la génération sur un motif spécifique, maintenant la complétion dans le scope de la fonction actuelle au lieu de laisser le modèle enchaîner sur la suivante.

# Arrêter la génération sur des motifs spécifiques
response = client.fim.complete(
    model="codestral-latest",
    prompt=prompt,
    suffix=suffix,
    stop=["\n\n", "\nclass ", "\ndef "],  # Arrêt avant une nouvelle fonction/classe
)

Enfin, la température régit la variabilité. À 0, la même entrée produit toujours la même sortie, ce que requiert l’auto-complétion. Autour de 0.3, le modèle propose des variantes, ce qui est intéressant lors de l’affichage de plusieurs suggestions. À 0.7, tu es en mode brainstorming de code, utile pour explorer une approche mais inadapté à un flux d’édition.

# temperature=0 : déterministe (auto-complétion)
# temperature=0.3 : légèrement créatif (multiples suggestions)
# temperature=0.7 : créatif (brainstorming de code)

response = client.fim.complete(
    model="codestral-latest",
    prompt=prompt,
    suffix=suffix,
    temperature=0.3,
    top_p=0.95,
)

Deux modèles à copier-coller

Le premier reproduit le comportement d’un IDE : tu scindes le contenu du fichier à la position du curseur, et les deux moitiés deviennent le prompt et le suffixe.

def autocomplete_ide(file_content: str, cursor_position: int) -> str:
    """Simule l'auto-complétion d'un IDE avec Codestral FIM."""
    prompt = file_content[:cursor_position]
    suffix = file_content[cursor_position:]

    response = client.fim.complete(
        model="codestral-latest",
        prompt=prompt,
        suffix=suffix,
        temperature=0,
        max_tokens=100,
        stop=["\n\n", "\ndef ", "\nclass "],
    )

    return response.choices[0].message.content

Le second automatise la documentation pour un projet existant : tu passes une fonction, récupères sa docstring, et l’instruction système impose un format unique afin que le résultat s’insère sans édition supplémentaire.

def generate_docstring(function_code: str) -> str:
    """Génère une docstring pour une fonction Python."""
    response = client.chat.complete(
        model="codestral-latest",
        messages=[
            {
                "role": "system",
                "content": "Generate a Google-style docstring for the following function. Return ONLY the docstring between triple quotes."
            },
            {
                "role": "user",
                "content": function_code
            }
        ],
        temperature=0,
        max_tokens=300,
    )
    return response.choices[0].message.content

Gestion des erreurs

Un appel réseau finira tôt ou tard par échouer, et une extension d’éditeur qui plante sur une erreur de validation est pire qu’une extension sans complétion. Par conséquent, enveloppe toujours tes appels :

from mistralai.client import Mistral
from mistralai.client.errors import HTTPValidationError

try:
    response = client.fim.complete(
        model="codestral-latest",
        prompt=prompt,
        suffix=suffix,
    )
except HTTPValidationError as e:
    print(f"Validation error: {e}")
except Exception as e:
    print(f"Unexpected error: {e}")

Viktiga punkter

  • Le SDK mistralai expose client.fim.complete() pour le FIM et client.chat.complete() pour le chat
  • Les paramètres prompt et suffix sont spécifiques au point de terminaison FIM
  • Utilise temperature=0 pour l’auto-complétion, 0.2-0.7 pour la génération créative
  • stop limite la génération à un bloc de code cohérent
  • min_tokens et max_tokens contrôlent la longueur de la sortie
  • Gère toujours les erreurs HTTP dans le code de production