Codestral API in Python
Op deze pagina
Appeler Codestral depuis Python
Cette leçon passe de la théorie au code exécutable. Vous utiliserez le SDK Python de Mistral AI pour interroger Codestral sur ses deux points de terminaison, ajusterez les paramètres avancés qui distinguent une suggestion utile d’une réponse verbeuse, et implémenterez les modèles rencontrés dans la plupart des intégrations réelles.
Installation et configuration
Installez le SDK en une seule commande :
pip install mistralai
Récupérez votre clé API sur console.mistral.ai et lisez-la depuis l’environnement plutôt que de la coder en dur dans votre fichier :
import os
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
Deux plateformes hébergent Codestral, et vous choisissez entre elles lors de la création de votre clé. api.mistral.ai fonctionne sur une base de paiement à l’usage avec une facturation basée sur la consommation : c’est la voie 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, vous devez systématiquement vérifier trois éléments : la complétion elle-même, la consommation de tokens qui détermine votre facture, et la raison de l’arrêt, qui indique si le modèle a terminé naturellement ou s’il a atteint votre 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 vos appels est un signal clair : votre max_tokens est trop faible et vous livrez du code tronqué à vos 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 — par exemple 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 lors de la génération d’un bloc dont vous savez 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, vous êtes 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 (plusieurs 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 : vous divisez 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 : vous passez une fonction, récupérez 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, enveloppez toujours vos 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}")
Belangrijkste punten
- 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 - Utilisez
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érez toujours les erreurs HTTP dans le code de production