API Codestral en Python
På denna sida
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
mistralaiexposeclient.fim.complete()pour le FIM etclient.chat.complete()pour le chat - Les paramètres
promptetsuffixsont spécifiques au point de terminaison FIM - Utilise
temperature=0pour l’auto-complétion,0.2-0.7pour la génération créative stoplimite la génération à un bloc de code cohérentmin_tokensetmax_tokenscontrôlent la longueur de la sortie- Gère toujours les erreurs HTTP dans le code de production