Code Interpreter: Codeausführung in der API

Aktualisiert am 2. November 2026 basierend auf dem offiziellen Code Interpreter-Leitfaden und dem openai SDK: Das Tool erfordert einen container-Parameter (in allen vorherigen Beispielen fehlend, was zu Fehlern geführt hätte), generierte Dateien erscheinen in container_file_citation-Anmerkungen und werden über die Containers-API heruntergeladen (nicht client.files.content), und Aufrufausgaben werden als outputs bezeichnet (nicht results). Eingabetext-Teile verwenden den Typ input_text. Dateien, die einer Nachricht angehängt werden, werden mit dem Zweck user_data hochgeladen, was OpenAI für Modell-Eingaben empfiehlt (Dateieingaben). Quellen: Code Interpreter · Dateieingaben.

Ein Sprachmodell sagt Text voraus; es berechnet nicht. Wenn Sie es nach der Quadratwurzel von 1764 fragen, liefert es das wahrscheinlichste Ergebnis basierend auf seinem Training – oft korrekt, manchmal falsch, ohne dass man den Unterschied erkennen kann. Der Code Interpreter beseitigt diese Unsicherheit, indem er dem Modell einen Python-Interpreter zur Verfügung stellt: Es schreibt die Berechnung, führt sie aus und liefert ein erlangtes Ergebnis, keine Vermutung.

Die Verschiebung ist tiefer, als sie auf den ersten Blick erscheint. Das Modell sieht die Ausgabe seines eigenen Codes, einschließlich Fehler, sodass es sich selbst korrigieren und erneut versuchen kann. Bei einer Datendatei, bei der niemand die genaue Struktur kennt, schlägt dieser Kreislauf jede vorab geschriebene Anweisung.

Code Interpreter aktivieren

Sie aktivieren ihn, indem Sie das Tool dem tools-Array hinzufügen – nichts zu installieren, keine Umgebung bereitzustellen. Das Modell entscheidet, wann es Code schreibt: Es beantwortet faktische Fragen direkt, wechselt aber zur Ausführung für Berechnungen oder Datenmanipulation.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Berechnen Sie die Fibonacci-Folge bis zum 20. Term",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

print(response.output_text)

Das Modell schreibt den Python-Code, führt ihn in einer Sandbox aus und integriert die Ergebnisse in seine Antwort.

Ausgeführten Code inspizieren

Machen Sie sich zur Gewohnheit, diesen Code zu lesen, zumindest während der Entwicklung. Es ist der einzige Weg, um ein gutes Ergebnis von einem Ergebnis zu unterscheiden, das zufällig richtig ist: Ein Durchschnitt, der fehlende Werte stumm ignoriert, ist numerisch korrekt, aber analytisch falsch. Die Antwort wird Ihnen das nicht sagen; der Code wird es.

Die Antwort enthält den generierten Code und seine Ergebnisse:

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Was ist die Quadratwurzel von 1764? Überprüfen Sie dies, indem Sie das Ergebnis quadrieren.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    include=["code_interpreter_call.outputs"],  # um generierte Protokolle und Bilder zu erhalten
)

for item in response.output:
    if item.type == "code_interpreter_call":
        print("--- Ausgeführter Code ---")
        print(item.code)
        print("--- Ausgaben ---")
        for output in item.outputs or []:
            print(output.logs if output.type == "logs" else output.url)

Dateien als Eingabe bereitstellen

Das Tool liefert seinen vollen Wert, wenn es mit Dateien arbeitet. Sie laden hoch, verweisen die Datei im Aufruf und das Modell öffnet sie tatsächlich – es liest die echten Spalten, echten Typen und echten Ausreißer, anstatt über eine Beschreibung zu schlussfolgern, die Sie möglicherweise bereitgestellt haben.

# Datei hochladen
with open("sales_2025.csv", "rb") as f:
    file_obj = client.files.create(file=f, purpose="user_data")

# Code Interpreter mit der Datei verwenden
response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Analysieren Sie diese Verkaufsdatei. "
                 "Geben Sie mir die Summe nach Kategorie und den am besten performenden Monat."},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }
    ],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

print(response.output_text)

Generierte Dateien abrufen

Der umgekehrte Weg funktioniert ebenfalls: Der Code erzeugt eine bereinigte CSV-Datei, ein Diagramm oder eine Excel-Datei, und diese Dateien werden Ihnen zurückgegeben. Sie bleiben im Container, und die Antwortnachricht zitiert sie in ihren Anmerkungen vom Typ container_file_citation, einschließlich der Container-ID, der Datei-ID und des Dateinamens. Sie laden sie dann über die Containers-API herunter. Zwei kleine Funktionen, die in späteren Lektionen wiederverwendet werden, kapseln diesen Fluss:

def generated_files(response):
    """Von Code Interpreter erstellte Dateien, die in Nachrichten-Anmerkungen zitiert werden."""
    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):
    """Lädt eine Datei aus dem Container herunter und gibt den lokalen Pfad zurück."""
    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

Dateien, die Sie als Eingabe bereitstellen (input_file), werden automatisch in den Container kopiert: Sie müssen nichts anderes hochladen.

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Erstellen Sie ein Diagramm der Verkäufe nach Monat "
                 "und exportieren Sie die bereinigte Daten als CSV."},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }
    ],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

# Generierte Dateien abrufen
for ann in generated_files(response):
    print(f"Generierte Datei: {ann.filename}")
    download(client, ann, ann.filename)

Container und Umgebung

Das Wissen um die Containerregeln spart Zeit beim Debuggen dessen, was nicht funktioniert. Laut der Dokumentation von OpenAI:

es handelt sich um eine vollständig isolierte virtuelle Maschine (Sandbox), in der das Modell Python ausführt;
das Tool erfordert einen container-Parameter: {"type": "auto"} erstellt einen Container (oder nutzt einen von einem vorherigen Aufruf im Kontext vorhandenen), während eine über client.containers.create(...) erhaltene ID einen spezifischen Container erzwingt;
der Speicher wird mit memory_limit festgelegt: 1g (Standard), 4g, 16g oder 64g, wobei höhere Stufen nach integrierten Tool-Tarifen abgerechnet werden;
ein Container läuft nach 20 Minuten Inaktivität ab; seine Daten gehen dann verloren, also laden Sie alle Dateien herunter, die Sie behalten möchten, solange er aktiv ist.

Zählen Sie nicht auf Netzwerkkzugriff aus dem Code: Geben Sie Daten als Eingabe an oder delegieren Sie die Recherche an das Web Search Tool.

# Beispiel: Das Modell kann pandas direkt verwenden
response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Laden Sie diese CSV-Datei mit pandas, "
                 "berechnen Sie deskriptive Statistiken und identifizieren Sie Ausreißer."},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }
    ],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

Mehrere Ausführungen verketten

Nachehende Ausführungen teilen sich dieselbe Sitzung: Variablen, DataFrames und Imports aus dem ersten Block bleiben im nächsten verfügbar, genau wie in einem Notebook. Das Modell nutzt dies natürlich aus – es lädt, inspiziert und verarbeitet dann – wodurch mehrstufige Analysen möglich werden, ohne alles in jeder Stufe neu zu laden.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="1. Generieren Sie 1000 zufällige Punkte aus einer Normalverteilung. "
          "2. Berechnen Sie den Mittelwert und die Standardabweichung. "
          "3. Erstellen Sie ein Histogramm. "
          "4. Führen Sie einen Shapiro-Wilk-Test auf Normalverteilung durch.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

# Das Modell führt 4 Code-Blöcke sequentiell aus
# Jeder Block hat Zugriff auf Variablen aus vorherigen

Kombination mit anderen Tools

Die nützlichste Kombination paart eine Datenquelle mit der Fähigkeit, diese zu verarbeiten: File Search findet den relevanten Abschnitt in Ihren Dokumenten, Web Search bringt Marktdaten mit, und Code Interpreter vergleicht die beiden in einer Tabelle oder einem Diagramm. Keine dieser Tools kann die Arbeit der anderen übernehmen.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Suchen Sie im Web nach französischen BIP-Daten der letzten 10 Jahre, "
          "und erstellen Sie dann ein Trenddiagramm mit linearer Regression.",
    tools=[
        {"type": "web_search"},
        {"type": "code_interpreter", "container": {"type": "auto"}}
    ]
)

Muster: Vollständiger Analyse-Pipeline

Das letzte Beispiel verketzt alles oben in einen realistischen Fall: Eine Eingabe-Datei, mehrstufige Analyse und Ausgabe-Lieferables. Konzentrieren Sie sich besonders auf das Prompt-Format – nummeriert, explizit bezüglich des erwarteten Outputs – denn dies bestimmt weit mehr als der begleitende Python-Code die Qualität des Ergebnisses.

def analyze_data(file_path: str, questions: list[str]) -> dict:
    """Datenanalyse-Pipeline mit Code Interpreter."""
    # Hochladen
    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="Schreiben Sie sauberen, kommentierten Python-Code. "
                        "Zeigen Sie Zwischenergebnisse an."
        )

        results[question] = response.output_text

    return results

# Verwendung
results = analyze_data("sales.csv", [
    "Geben Sie deskriptive Statistiken für jede numerische Spalte an",
    "Welche sind die 5 am besten verkauften Produkte?",
    "Gibt es eine Saisonalität in den Verkäufen?"
])

Wichtige Erkenntnisse

Code Interpreter führt Python in einem isolierten Container aus; der container-Parameter ist erforderlich ({"type": "auto"} oder eine ID)
Dateien, die als input_file bereitgestellt werden, werden automatisch in den Container kopiert
Generierte Dateien werden als container_file_citation zitiert und werden über client.containers.files.content.retrieve heruntergeladen
Ein Container läuft nach 20 Minuten Inaktivität ab: Laden Sie alles herunter, was Sie behalten möchten
Kombinieren Sie mit Web Search und File Search für eine bereicherte Analyse