Code Interpreter : exécuter du code dans l'API — Outils API : Search, Files et Code Interpreter

Leçon corrigée le 2 novembre 2026 d’après le guide officiel Code Interpreter et le SDK openai : l’outil exige un paramètre container (absent de tous les exemples précédents, qui auraient échoué), les fichiers générés se lisent dans les annotations container_file_citation et se téléchargent par l’API des conteneurs (et non par client.files.content), et les sorties de l’appel s’appellent outputs (pas results). Les parties de texte de l’entrée sont de type input_text. Les fichiers joints au message sont téléversés avec l’usage user_data, celui que recommande OpenAI pour les entrées du modèle (File inputs). Sources : Code Interpreter · File inputs.

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", "container": {"type": "auto"}}]
)

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", "container": {"type": "auto"}}],
    include=["code_interpreter_call.outputs"],  # pour recevoir journaux et images produits
)

for item in response.output:
    if item.type == "code_interpreter_call":
        print("--- Code exécuté ---")
        print(item.code)
        print("--- Sorties ---")
        for sortie in item.outputs or []:
            print(sortie.logs if sortie.type == "logs" else sortie.url)

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="user_data")

# Utiliser Code Interpreter avec le fichier
response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_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", "container": {"type": "auto"}}]
)

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 restent dans le conteneur et le message de réponse les cite dans ses annotations, de type container_file_citation, avec l’identifiant du conteneur, celui du fichier et son nom. On les télécharge ensuite par l’API des conteneurs. Deux petites fonctions, réutilisées dans les leçons suivantes, encapsulent ce parcours :

def fichiers_generes(response):
    """Fichiers créés par Code Interpreter, cités dans les annotations du message."""
    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 telecharger(client, ann, chemin):
    """Télécharge un fichier du conteneur et renvoie son chemin local."""
    contenu = client.containers.files.content.retrieve(ann.file_id, container_id=ann.container_id)
    with open(chemin, "wb") as out:
        out.write(contenu.read())
    return chemin

Les fichiers que vous fournissez en entrée (input_file) sont, eux, copiés automatiquement dans le conteneur : vous n’avez rien à téléverser à part.

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_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", "container": {"type": "auto"}}]
)

# Récupérer les fichiers générés
for ann in fichiers_generes(response):
    print(f"Fichier généré : {ann.filename}")
    telecharger(client, ann, ann.filename)

Container et environnement

Connaître les règles du conteneur évite de perdre du temps à déboguer ce qui ne peut pas fonctionner. D’après la documentation d’OpenAI :

c’est une machine virtuelle entièrement isolée (sandbox) dans laquelle le modèle exécute du Python ;
l’outil exige un paramètre container : {"type": "auto"} crée un conteneur (ou réutilise celui d’un appel précédent présent dans le contexte), un identifiant obtenu par client.containers.create(...) impose un conteneur précis ;
la mémoire se choisit avec memory_limit : 1g (par défaut), 4g, 16g ou 64g, les paliers supérieurs étant facturés au tarif des outils intégrés ;
un conteneur expire après 20 minutes sans utilisation ; ses données sont alors perdues, d’où l’intérêt de télécharger les fichiers utiles 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 confiez la recherche à l’outil Web Search.

# Exemple : le modèle peut utiliser pandas directement
response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_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", "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 — 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", "container": {"type": "auto"}}]
)

# Le modèle execute 4 blocs de code séquentiellement
# Chaque bloc a accès aux variables des précédents

Combiner 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"},
        {"type": "code_interpreter", "container": {"type": "auto"}}
    ]
)

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="user_data")

    resultats = {}

    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": fichier.id}
                    ]
                }
            ],
            tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
            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 conteneur isolé ; le paramètre container est obligatoire ({"type": "auto"} ou un identifiant)
Les fichiers fournis en input_file sont copiés automatiquement dans le conteneur
Les fichiers générés sont cités en container_file_citation et se téléchargent par client.containers.files.content.retrieve
Un conteneur expire après 20 minutes d’inactivité : téléchargez ce que vous voulez garder
Combinez avec Web Search et File Search pour des analyses enrichies