Code Interpreter : exécuter du code via l'API
Šiame puslapyje
Mise à jour du 2 novembre 2026 basée sur le guide officiel Code Interpreter et le SDK
openai: l’outil requiert un paramètrecontainer(absent de tous les exemples précédents, qui auraient échoué), les fichiers générés apparaissent dans les annotationscontainer_file_citationet se téléchargent via l’API Containers (et nonclient.files.content), et les sorties d’appel se nommentoutputs(et nonresults). Les parties de texte en entrée utilisent le typeinput_text. Les fichiers joints à un message sont téléversés avec l’objectifuser_data, ce qu’OpenAI recommande pour les entrées du modèle (File inputs). Sources : Code Interpreter · File inputs.
Code Interpreter : exécuter du code via l’API
Un modèle de langage prédit du texte ; il ne calcule pas. Demande-lui la racine carrée de 1764, et il produira le résultat le plus probable selon son entraînement — souvent correct, parfois faux, sans moyen de faire la différence. Code Interpreter lève cette incertitude en offrant au modèle un interpréteur Python : il écrit le calcul, l’exécute et renvoie un résultat obtenu, non une supposition.
Le changement est plus profond qu’il n’y paraît. Le modèle voit la sortie de son propre code, y compris les erreurs, ce qui lui permet de se corriger et de réessayer. Sur un fichier de données dont personne ne connaît la structure exacte, cette boucle surpasse toute instruction préécrite.
Activer Code Interpreter
Tu l’actives en ajoutant l’outil au tableau tools — rien à installer, aucun environnement à provisionner. Le modèle décide quand écrire du code : il répond directement aux questions factuelles, mais bascule vers l’exécution pour les calculs ou la manipulation de données.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Calculate the Fibonacci sequence up to the 20th term",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
print(response.output_text)
Le modèle écrit le code Python, l’exécute dans un bac à sable et intègre les résultats à sa réponse.
Inspecter le code exécuté
Prends l’habitude de lire ce code, au moins durant le développement. C’est le seul moyen de distinguer un bon résultat d’un résultat juste par hasard : une moyenne calculée en ignorant silencieusement des valeurs manquantes est numériquement correcte mais analytiquement fausse. La réponse ne te 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="What is the square root of 1764? Verify by squaring the result.",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
include=["code_interpreter_call.outputs"], # to receive produced logs and images
)
for item in response.output:
if item.type == "code_interpreter_call":
print("--- Executed Code ---")
print(item.code)
print("--- Outputs ---")
for output in item.outputs or []:
print(output.logs if output.type == "logs" else output.url)
Fournir des fichiers en entrée
L’outil déploie toute sa valeur lorsqu’il travaille avec des fichiers. Tu téléverses le fichier, tu le références dans l’appel, et le modèle l’ouvre réellement — il lit les vraies colonnes, les vrais types et les vraies valeurs aberrantes, au lieu de raisonner sur une description que tu aurais fournie.
# Upload the file
with open("sales_2025.csv", "rb") as f:
file_obj = client.files.create(file=f, purpose="user_data")
# Use Code Interpreter with the file
response = client.responses.create(
model="gpt-5.6-terra",
input=[
{
"role": "user",
"content": [
{"type": "input_text", "text": "Analyze this sales file. "
"Give me the total by category and the best-performing month."},
{"type": "input_file", "file_id": file_obj.id}
]
}
],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
print(response.output_text)
Récupérer les fichiers générés
Le chemin inverse fonctionne aussi : le code produit un CSV nettoyé, un graphique ou un classeur Excel, et ces fichiers te sont renvoyés. Ils restent dans le conteneur, et le message de réponse les cite dans ses annotations de type container_file_citation, incluant l’ID du conteneur, l’ID du fichier et le nom de fichier. Tu les télécharges ensuite via l’API Containers. Deux petites fonctions, réutilisées dans les leçons suivantes, encapsulent ce flux :
def generated_files(response):
"""Files created by Code Interpreter, cited in message annotations."""
for item in response.output:
if item.type == "message":
for part in item.content:
for ann in getattr(part, "annotations", None) or []:
if ann.type == "container_file_citation":
yield ann
def download(client, ann, path):
"""Downloads a file from the container and returns its local path."""
content = client.containers.files.content.retrieve(ann.file_id, container_id=ann.container_id)
with open(path, "wb") as out:
out.write(content.read())
return path
Les fichiers que tu fournis en entrée (input_file) sont automatiquement copiés dans le conteneur : tu n’as besoin de rien téléverser d’autre.
response = client.responses.create(
model="gpt-5.6-terra",
input=[
{
"role": "user",
"content": [
{"type": "input_text", "text": "Create a chart of sales by month "
"and export the cleaned data as a CSV."},
{"type": "input_file", "file_id": file_obj.id}
]
}
],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# Retrieve generated files
for ann in generated_files(response):
print(f"Generated file: {ann.filename}")
download(client, ann, ann.filename)
Conteneur et environnement
Connaître les règles du conteneur te fait gagner du temps pour déboguer ce qui ne peut pas fonctionner. Selon la documentation d’OpenAI :
- c’est une machine virtuelle entièrement isolée (bac à sable) où le modèle exécute Python ;
- l’outil requiert un paramètre
container:{"type": "auto"}crée un conteneur (ou en réutilise un issu d’un appel précédent présent dans le contexte), tandis qu’un ID obtenu viaclient.containers.create(...)force l’utilisation d’un conteneur spécifique ; - la mémoire est définie avec
memory_limit:1g(par défaut),4g,16gou64g, les paliers supérieurs étant facturés aux tarifs des outils intégrés ; - un conteneur expire après 20 minutes d’inactivité ; ses données sont alors perdues, donc télécharge tous les fichiers que tu souhaites conserver tant qu’il est actif.
Ne compte pas sur un accès réseau depuis le code : fournis les données en entrée, ou délègue la recherche à l’outil Web Search.
# Example: the model can use pandas directly
response = client.responses.create(
model="gpt-5.6-terra",
input=[
{
"role": "user",
"content": [
{"type": "input_text", "text": "Load this CSV with pandas, "
"calculate descriptive statistics, and identify outliers."},
{"type": "input_file", "file_id": file_obj.id}
]
}
],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
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 — rendant possible une analyse en plusieurs étapes sans tout recharger à chaque phase.
response = client.responses.create(
model="gpt-5.6-terra",
input="1. Generate 1000 random points from a normal distribution. "
"2. Calculate the mean and standard deviation. "
"3. Create a histogram. "
"4. Perform a Shapiro-Wilk normality test.",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# The model executes 4 code blocks sequentially
# Each block has access to variables from previous ones
Combiner avec d’autres outils
La combinaison la plus utile associe une source de données à la capacité de la traiter : File Search trouve le passage pertinent dans tes documents, Web Search apporte des données de marché, et Code Interpreter compare les deux dans un tableau ou un graphique. Aucun de ces outils ne peut faire le travail des autres.
response = client.responses.create(
model="gpt-5.6-terra",
input="Search the web for French GDP data from the last 10 years, "
"then create a trend chart with a linear regression.",
tools=[
{"type": "web_search"},
{"type": "code_interpreter", "container": {"type": "auto"}}
]
)
Modèle : pipeline d’analyse complet
Le dernier exemple enchaîne tout ce qui précède dans un cas réaliste : un fichier d’entrée, une analyse en plusieurs étapes et des livrables en sortie. Concentre-toi particulièrement sur le format de l’instruction — numérotée, explicite sur la sortie attendue — car c’est cela, bien plus que le code Python accompagnant, qui détermine la qualité du résultat.
def analyze_data(file_path: str, questions: list[str]) -> dict:
"""Data analysis pipeline with Code Interpreter."""
# Upload
with open(file_path, "rb") as f:
file_obj = client.files.create(file=f, purpose="user_data")
results = {}
for question in questions:
response = client.responses.create(
model="gpt-5.6-terra",
input=[
{
"role": "user",
"content": [
{"type": "input_text", "text": question},
{"type": "input_file", "file_id": file_obj.id}
]
}
],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
instructions="Write clean, commented Python code. "
"Display intermediate results."
)
results[question] = response.output_text
return results
# Usage
results = analyze_data("sales.csv", [
"Give descriptive statistics for each numeric column",
"What are the top 5 best-selling products?",
"Is there seasonality in sales?"
])
Svarbiausi punktai
- Code Interpreter exécute Python dans un conteneur isolé ; le paramètre
containerest obligatoire ({"type": "auto"}ou un ID) - Les fichiers fournis en tant que
input_filesont automatiquement copiés dans le conteneur - Les fichiers générés sont cités comme
container_file_citationet téléchargés viaclient.containers.files.content.retrieve - Un conteneur expire après 20 minutes d’inactivité : télécharge ce que tu veux conserver
- Combine avec Web Search et File Search pour une analyse enrichie