Code Interpreter : exécuter du code via l'API
Op deze pagina
Mis à jour le 2 novembre 2026 sur la base du guide officiel Code Interpreter et du 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. Demandez-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 fournissant au modèle un interpréteur Python : il écrit le calcul, l’exécute et renvoie un résultat obtenu, et 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
Vous l’activez 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 (sandbox) et intègre les résultats à sa réponse.
Inspecter le code exécuté
Prenez 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 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="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. Vous téléversez le fichier, vous le référencez 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 vous auriez pu fournir.
# 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 vous 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. Vous les téléchargez 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 vous fournissez en entrée (input_file) sont automatiquement copiés dans le conteneur : vous n’avez rien d’autre à téléverser.
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 vous fait gagner du temps lors du débogage de ce qui ne peut pas fonctionner. Selon la documentation d’OpenAI :
- il s’agit d’une machine virtuelle entièrement isolée (sandbox) 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 niveaux 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échargez tous les fichiers que vous souhaitez conserver tant qu’il est actif.
Ne comptez pas sur un accès réseau depuis le code : fournissez les données en entrée ou déléguez 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 en tire naturellement parti — 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 vos 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
L’exemple final 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. Concentrez-vous particulièrement sur le format de l’instruction — numérotée, explicite sur le résultat attendu — 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?"
])
Belangrijkste punten
- 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 sous forme de
container_file_citationet téléchargés viaclient.containers.files.content.retrieve - Un conteneur expire après 20 minutes d’inactivité : téléchargez ce que vous souhaitez conserver
- Combinez avec Web Search et File Search pour une analyse enrichie