Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

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

Paskaita 10 iš 20 Atnaujinta 2026 m. lapkričio 2 d. Kūrėjas
Šiame puslapyje
  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. Svarbiausi punktai

Mise à jour du 2 novembre 2026 basée sur le guide officiel Code Interpreter et le 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. 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 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 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 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 comme 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écharge ce que tu veux conserver
  • Combine avec Web Search et File Search pour une analyse enrichie