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

Code Interpreter : executer du code dans l’API

Code Interpreter permet au modele d’ecrire et d’executer du code Python dans un environnement sandboxe directement depuis la Responses API. Le modele peut ainsi effectuer des calculs, analyser des donnees, generer des fichiers et produire des visualisations.

Activer Code Interpreter

L’activation se fait en ajoutant l’outil dans le tableau tools :

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.3",
    input="Calcule la suite de Fibonacci jusqu'au 20e terme",
    tools=[{"type": "code_interpreter"}]
)

print(response.output_text)

Le modele ecrit le code Python, l’execute dans un sandbox, et integre les resultats dans sa reponse.

Examiner le code execute

La reponse contient le code genere et ses resultats :

response = client.responses.create(
    model="gpt-5.3",
    input="Quelle est la racine carree de 1764 et verifie en elevant au carre",
    tools=[{"type": "code_interpreter"}]
)

for item in response.output:
    if item.type == "code_interpreter_call":
        print("--- Code execute ---")
        print(item.code)
        print("--- Resultats ---")
        for result in item.results:
            print(result)

Fournir des fichiers en entree

Code Interpreter peut travailler avec des fichiers que vous uploadez :

# Upload du fichier
with open("ventes_2025.csv", "rb") as f:
    fichier = client.files.create(file=f, purpose="assistants")

# Utiliser Code Interpreter avec le fichier
response = client.responses.create(
    model="gpt-5.3",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Analyse ce fichier de ventes. "
                 "Donne-moi le total par categorie et le mois le plus performant."},
                {"type": "input_file", "file_id": fichier.id}
            ]
        }
    ],
    tools=[{"type": "code_interpreter"}]
)

print(response.output_text)

Recuperer les fichiers generes

Code Interpreter peut generer des fichiers en sortie :

response = client.responses.create(
    model="gpt-5.3",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Cree un graphique des ventes par mois "
                 "et exporte les donnees nettoyees en CSV."},
                {"type": "input_file", "file_id": fichier.id}
            ]
        }
    ],
    tools=[{"type": "code_interpreter"}]
)

# Recuperer les fichiers generes
for item in response.output:
    if item.type == "code_interpreter_call":
        for result in item.results:
            if hasattr(result, "files"):
                for f in result.files:
                    print(f"Fichier genere : {f.name} ({f.mime_type})")
                    # Telecharger le fichier
                    contenu = client.files.content(f.file_id)
                    with open(f.name, "wb") as out:
                        out.write(contenu.read())

Container et environnement

Le code s’execute dans un container isole avec :

• Python 3.11+ avec les bibliotheques courantes pre-installees
• pandas, numpy, matplotlib, seaborn pour l’analyse de donnees
• Pillow pour le traitement d’images
• sympy pour le calcul symbolique
• Pas d’acces reseau : le container est completement isole

# Exemple : le modele peut utiliser pandas directement
response = client.responses.create(
    model="gpt-5.3",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "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"}]
)

Enchainer plusieurs executions

Le modele peut executer plusieurs blocs de code dans un meme appel, chaque bloc beneficiant du contexte des precedents :

response = client.responses.create(
    model="gpt-5.3",
    input="1. Genere 1000 points aleatoires selon une distribution normale. "
          "2. Calcule la moyenne et l'ecart-type. "
          "3. Cree un histogramme. "
          "4. Effectue un test de normalite de Shapiro-Wilk.",
    tools=[{"type": "code_interpreter"}]
)

# Le modele execute 4 blocs de code sequentiellement
# Chaque bloc a acces aux variables des precedents

Combiner avec d’autres outils

Code Interpreter fonctionne avec File Search et Web Search :

response = client.responses.create(
    model="gpt-5.3",
    input="Cherche sur le web les donnees du PIB francais des 10 dernieres annees, "
          "puis cree un graphique de la tendance avec une regression lineaire.",
    tools=[
        {"type": "web_search_preview"},
        {"type": "code_interpreter"}
    ]
)

Pattern : pipeline d’analyse complete

def analyser_donnees(fichier_path: str, questions: list[str]) -> dict:
    """Pipeline d'analyse de donnees avec Code Interpreter."""
    # Upload
    with open(fichier_path, "rb") as f:
        fichier = client.files.create(file=f, purpose="assistants")

    resultats = {}

    for question in questions:
        response = client.responses.create(
            model="gpt-5.3",
            input=[
                {
                    "role": "user",
                    "content": [
                        {"type": "text", "text": question},
                        {"type": "input_file", "file_id": fichier.id}
                    ]
                }
            ],
            tools=[{"type": "code_interpreter"}],
            instructions="Ecris du code Python propre et commente. "
                        "Affiche les resultats intermediaires."
        )

        resultats[question] = response.output_text

    return resultats

# Utilisation
resultats = analyser_donnees("ventes.csv", [
    "Donne les statistiques descriptives de chaque colonne numerique",
    "Quels sont les 5 produits les plus vendus ?",
    "Y a-t-il une saisonnalite dans les ventes ?"
])

Points cles a retenir

• Code Interpreter execute du Python dans un sandbox isole
• Uploadez des fichiers via input_file pour les analyser
• Recuperez les fichiers generes dans les resultats
• Le container inclut pandas, numpy, matplotlib et plus
• Combinez avec Web Search et File Search pour des analyses enrichies