Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Code Interpreter : exécuter du code via l'API

Les 10 van 20 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Code Interpreter : exécuter du code via l’API
  2. Activer Code Interpreter
  3. Inspecter le code exécuté
  4. Fournir des fichiers en entrée
  5. Récupérer les fichiers générés
  6. Conteneur et environnement
  7. Enchaîner plusieurs exécutions
  8. Combiner avec d’autres outils
  9. Modèle : pipeline d’analyse complet
  10. Belangrijkste punten

Mis à jour le 2 novembre 2026 sur la base du guide officiel Code Interpreter et du SDK openai : l’outil requiert un paramètre container (absent de tous les exemples précédents, qui auraient échoué), les fichiers générés apparaissent dans les annotations container_file_citation et se téléchargent via l’API Containers (et non client.files.content), et les sorties d’appel se nomment outputs (et non results). Les parties de texte en entrée utilisent le type input_text. Les fichiers joints à un message sont téléversés avec l’objectif user_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 via client.containers.create(...) force l’utilisation d’un conteneur spécifique ;
  • la mémoire est définie avec memory_limit : 1g (par défaut), 4g, 16g ou 64g, 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 container est obligatoire ({"type": "auto"} ou un ID)
  • Les fichiers fournis en tant que input_file sont automatiquement copiés dans le conteneur
  • Les fichiers générés sont cités sous forme de container_file_citation et téléchargés via client.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