Code Interpreter : exécuter du code dans l'API
Code Interpreter : exécuter du code dans l’API
Un modèle de langage prédit du texte ; il ne calcule pas. Demandez-lui la racine carrée de 1764 et il produira le résultat le plus probable au vu de son entraînement — souvent juste, parfois faux, sans que rien ne distingue les deux cas. Code Interpreter supprime cette incertitude en donnant au modèle un interpréteur Python : il écrit le calcul, l’exécute et vous rend un résultat obtenu, non deviné.
Le glissement est plus profond qu’il n’y paraît. Le modèle voit la sortie de son propre code, y compris les erreurs, et peut donc corriger et réessayer. Sur un fichier de données dont personne ne connaît la structure exacte, cette boucle vaut mieux que n’importe quelle consigne écrite à l’avance.
Activer Code Interpreter
L’activation se fait en ajoutant l’outil dans le tableau tools — il n’y a rien à installer, ni environnement à provisionner. Le modèle décide seul quand écrire du code : sur une question factuelle il répond directement, sur un calcul ou une manipulation de données il bascule vers l’exécution.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Calcule la suite de Fibonacci jusqu'au 20e terme",
tools=[{"type": "code_interpreter"}]
)
print(response.output_text)Le modèle écrit le code Python, l’exécute dans un sandbox, et intègre les résultats dans sa réponse.
Examiner le code exécuté
Prenez l’habitude de lire ce code, au moins pendant la mise au point. C’est le seul moyen de distinguer un bon résultat d’un résultat juste par chance : une moyenne calculée en ignorant silencieusement les valeurs manquantes est numériquement correcte et analytiquement fausse. La réponse ne vous le dira pas ; le code, si.
La réponse contient le code généré et ses résultats :
response = client.responses.create(
model="gpt-5.6-terra",
input="Quelle est la racine carree de 1764 et verifie en elevant au carre",
tools=[{"type": "code_interpreter"}]
)
for item in response.output:
if item.type == "code_interpreter_call":
print("--- Code execute ---")
print(item.code)
print("--- Resultats ---")
for result in item.results:
print(result)Fournir des fichiers en entrée
C’est avec des fichiers que l’outil prend toute sa valeur. Vous téléversez, vous référencez le fichier dans l’appel, et le modèle l’ouvre pour de bon — il lit les vraies colonnes, les vrais types, les vraies valeurs aberrantes, au lieu de raisonner sur la description que vous en auriez faite.
# Upload du fichier
with open("ventes_2025.csv", "rb") as f:
fichier = client.files.create(file=f, purpose="assistants")
# Utiliser Code Interpreter avec le fichier
response = client.responses.create(
model="gpt-5.6-terra",
input=[
{
"role": "user",
"content": [
{"type": "text", "text": "Analyse ce fichier de ventes. "
"Donne-moi le total par catégorie et le mois le plus performant."},
{"type": "input_file", "file_id": fichier.id}
]
}
],
tools=[{"type": "code_interpreter"}]
)
print(response.output_text)Récupérer les fichiers générés
Le trajet inverse fonctionne aussi : le code produit un CSV nettoyé, un graphique ou un classeur Excel, et ces fichiers vous sont rendus. Ils ne sont pas joints au texte de la réponse mais listés dans les résultats de l’appel d’outil, avec un identifiant qu’il faut ensuite télécharger — l’exemple ci-dessous montre ce parcours, qui surprend au premier essai.
response = client.responses.create(
model="gpt-5.6-terra",
input=[
{
"role": "user",
"content": [
{"type": "text", "text": "Cree un graphique des ventes par mois "
"et exporte les données nettoyees en CSV."},
{"type": "input_file", "file_id": fichier.id}
]
}
],
tools=[{"type": "code_interpreter"}]
)
# Récupérer les fichiers générés
for item in response.output:
if item.type == "code_interpreter_call":
for result in item.results:
if hasattr(result, "files"):
for f in result.files:
print(f"Fichier généré : {f.name} ({f.mime_type})")
# Telecharger le fichier
contenu = client.files.content(f.file_id)
with open(f.name, "wb") as out:
out.write(contenu.read())Container et environnement
Connaître les limites du container évite de perdre du temps à déboguer ce qui ne peut pas fonctionner. La plus structurante est la dernière de la liste : aucun accès réseau. Pas de pip install, pas d’appel d’API, pas de téléchargement depuis une URL. Tout ce dont le code a besoin doit être présent dans le container ou téléversé par vos soins — et si votre traitement suppose d’aller chercher une donnée en ligne, c’est Web Search qui s’en charge, pas le code.
Le code s’exécute donc dans un container isolé qui offre :
- Python 3.11+ avec les bibliothèques courantes pré-installées
- pandas, numpy, matplotlib, seaborn pour l’analyse de données
- Pillow pour le traitement d’images
- sympy pour le calcul symbolique
- Pas d’accès réseau : le container est complètement isolé
# Exemple : le modèle peut utiliser pandas directement
response = client.responses.create(
model="gpt-5.6-terra",
input=[
{
"role": "user",
"content": [
{"type": "text", "text": "Charge ce CSV avec pandas, "
"calcule les statistiques descriptives et identifie les outliers."},
{"type": "input_file", "file_id": fichier.id}
]
}
],
tools=[{"type": "code_interpreter"}]
)Enchaîner plusieurs exécutions
Les exécutions successives partagent la même session : les variables, les DataFrames et les imports du premier bloc restent disponibles dans le suivant, exactement comme dans un notebook. Le modèle exploite cela naturellement — il charge, inspecte, puis traite — et c’est ce qui rend les analyses en plusieurs temps possibles sans tout recharger à chaque étape.
response = client.responses.create(
model="gpt-5.6-terra",
input="1. Génère 1000 points aleatoires selon une distribution normale. "
"2. Calcule la moyenne et l'écart-type. "
"3. Cree un histogramme. "
"4. Effectue un test de normalite de Shapiro-Wilk.",
tools=[{"type": "code_interpreter"}]
)
# Le modèle execute 4 blocs de code séquentiellement
# Chaque bloc a accès aux variables des précédentsCombiner avec d’autres outils
La combinaison la plus utile associe une source de données à la capacité de les traiter : File Search retrouve le passage pertinent dans vos documents, Web Search apporte la donnée de marché, et Code Interpreter met les deux en regard dans un tableau ou un graphique. Aucun de ces outils ne sait faire le travail des autres.
response = client.responses.create(
model="gpt-5.6-terra",
input="Cherche sur le web les données du PIB français des 10 dernières années, "
"puis cree un graphique de la tendance avec une regression lineaire.",
tools=[
{"type": "web_search_preview"},
{"type": "code_interpreter"}
]
)Pattern : pipeline d’analyse complète
L’exemple final enchaîne tout ce qui précède sur un cas réaliste : un fichier en entrée, une analyse en plusieurs étapes, des livrables en sortie. Retenez-en surtout la forme du prompt — numéroté, explicite sur le format attendu — car c’est elle, bien plus que le code Python qui l’accompagne, qui décide de la qualité du résultat.
def analyser_donnees(fichier_path: str, questions: list[str]) -> dict:
"""Pipeline d'analyse de données avec Code Interpreter."""
# Upload
with open(fichier_path, "rb") as f:
fichier = client.files.create(file=f, purpose="assistants")
resultats = {}
for question in questions:
response = client.responses.create(
model="gpt-5.6-terra",
input=[
{
"role": "user",
"content": [
{"type": "text", "text": question},
{"type": "input_file", "file_id": fichier.id}
]
}
],
tools=[{"type": "code_interpreter"}],
instructions="Écris du code Python propre et commente. "
"Affiche les résultats intermédiaires."
)
resultats[question] = response.output_text
return resultats
# Utilisation
resultats = analyser_donnees("ventes.csv", [
"Donne les statistiques descriptives de chaque colonne numérique",
"Quels sont les 5 produits les plus vendus ?",
"Y a-t-il une saisonnalité dans les ventes ?"
])Points clés à retenir
- Code Interpreter exécute du Python dans un sandbox isolé
- Uploadez des fichiers via
input_filepour les analyser - Récupérez les fichiers générés dans les résultats
- Le container inclut pandas, numpy, matplotlib et plus
- Combinez avec Web Search et File Search pour des analyses enrichies