Datenworkflows mit Code Interpreter

Lektion aktualisiert am 2. November 2026 basierend auf der OpenAI-Dokumentation: Das Code Interpreter-Tool erfordert einen container-Parameter (in allen Beispielen hinzugefügt), Textteile der Eingabe sind vom Typ input_text, und die Websuche verwendet das web_search-Tool (web_search_preview ist nun ein veraltetes Tool ohne Domänenfilter). Generierte Dateien werden mit den Funktionen fichiers_generes und telecharger aus Lektion 10 abgerufen. An Dateien angehängte Dateien werden mit dem Zweck user_data hochgeladen, was OpenAI für Modell-Eingaben empfiehlt (Dateieingaben). Quellen: Code Interpreter · Websuche.

Datenworkflows mit Code Interpreter

In vorherigen Lektionen wurden einzelne Aufgaben nacheinander behandelt. In der Realität verketten sie sich: Sie importieren, bereinigen, berechnen, visualisieren und exportieren. Es ist die Kette – nicht jeder isolierte Schritt – die Zeit verbraucht, wenn sie manuell durchgeführt wird.

Die folgenden vier Workflows sind reale Anwendungsfälle, die absichtlich variiert sind: periodische Berichterstattung, Verhaltensanalyse über die Zeit, Segmentierung und Prognose. Lesen Sie sie weniger wegen des Codes und mehr wegen der Prompt-Struktur – nummeriert, explizit bezüglich der erwarteten Ergebnisse und präzise bezüglich des Formats. Diese Struktur verwandelt eine vage Anfrage in einen umsetzbaren Bericht, den Sie direkt auf Ihre eigenen Daten anwenden können.

Workflow 1: Automatisierter Finanzbericht

Periodische Berichterstattung ist der beste Kandidat für Automatisierung aus einem einfachen Grund: Die Dateien ändern sich, aber die Berichtsstruktur bleibt gleich. Sobald Sie den Prompt für einen Monat geschrieben und validiert haben, funktioniert er für die nächsten elf Monate. Beachten Sie die finale Anweisung, die eine Excel-Export pro Abschnitt anfordert. Dies macht das Ergebnis direkt teilbar, anstatt Sie mit Text zu belassen, der neu formatiert werden muss.

from openai import OpenAI

client = OpenAI()

# Quelldateien hochladen
files = {}
for name in ["revenus_2025.xlsx", "depenses_2025.xlsx", "budget_previsionnel.xlsx"]:
    with open(name, "rb") as f:
        file_obj = client.files.create(file=f, purpose="user_data")
        files[name] = file_obj.id

content = [
    {"type": "input_text", "text": (
        "Erstellen Sie einen vollständigen Finanzbericht aus diesen 3 Dateien: "
        "1. ZUSAMMENFASSUNG: Gesamteinnahmen, Bruttomarge, Nettogewinn "
        "2. MONATLICHE ANALYSE: Monatliche Entwicklung mit Variationen "
        "3. BUDGETABWEICHUNGEN: Vergleich Ist vs. Prognose, signifikante Abweichungen "
        "4. DIAGRAMME: "
        "   - Entwicklung von Einnahmen und Ausgaben (doppelte Achse) "
        "   - Wasserfall-Diagramm der Budgetabweichungen "
        "   - Aufschlüsselung der Ausgaben nach Kategorie "
        "5. EXPORT: Excel-Datei mit einem Tab pro Abschnitt"
    )}
]
for fid in files.values():
    content.append({"type": "input_file", "file_id": fid})

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{"role": "user", "content": content}],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions=(
        "Erstellen Sie einen professionellen Bericht. "
        "Zeichnen Sie Zahlen mit Tausendertrennzeichen. "
        "Verwenden Sie das europäische Format (Komma als Dezimaltrennzeichen). "
        "Kommentieren Sie jede signifikante Abweichung (> 5%)."
    )
)

# Alle generierten Dateien abrufen
for ann in fichiers_generes(response):
    telecharger(client, ann, f"sortie_{ann.filename}")
    print(f"Generiert: {ann.filename}")

Workflow 2: Kohortenanalyse

Eine Kohortenanalyse verfolgt Gruppen, die zum gleichen Eintrittsdatum gebildet wurden, über die Zeit. Wenige Teams führen diese Berechnung regelmäßig durch, da die Einrichtung mühsam ist. Genau deshalb lohnt es sich, dies zu delegieren: Die Logik ist standardisiert; nur die Daten ändern sich.

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

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Führen Sie eine Kohortenanalyse an diesen Benutzerdaten durch: "
                "1. Definieren Sie Kohorten nach Anmeldemonat "
                "2. Berechnen Sie die Bindungsrate pro Kohorte (Monat 1, 2, ..., 12) "
                "3. Erstellen Sie ein Bindungs-Wärmebild "
                "4. Identifizieren Sie die Kohorte mit der besten Bindung "
                "5. Schätzen Sie den LTV pro Kohorte "
                "6. Exportieren Sie die Bindungstabelle als CSV"
            )},
            {"type": "input_file", "file_id": file_obj.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions=(
        "Zeigen Sie den Code Schritt für Schritt. "
        "Zeigen Sie Zwischenergebnisse. "
        "Verwenden Sie für das Wärmebild eine grüne Palette (dunkel = gut, hell = niedrig). "
        "Annotieren Sie jede Zelle mit dem Prozentsatz."
    )
)

Workflow 3: Bewertung und Segmentierung

Hier beschreibt das Modell nicht nur die Daten; es erstellt eine Bewertung und bildet Gruppen. Dies erfordert eine Vorsichtsmaßnahme: Fordern Sie immer die Methode zusätzlich zum Ergebnis an. Ein Segment wie „Risikokunden” ohne die Kriterien, die es erzeugt haben, ist unbrauchbar: Niemand kann es hinterfragen, reproduzieren oder korrigieren.

def segmenter_clients(file_path: str) -> dict:
    """Segmentiert Kunden unter Verwendung von RFM und Clustering."""
    with open(file_path, "rb") as f:
        file_obj = client.files.create(file=f, purpose="user_data")

    response = client.responses.create(
        model="gpt-5.6-terra",
        input=[{
            "role": "user",
            "content": [
                {"type": "input_text", "text": (
                    "Führen Sie eine RFM-Kunden-Segmentierung durch: "
                    "1. Berechnen Sie Recency, Frequency, Monetary für jeden Kunden "
                    "2. Weisen Sie jedem Kunden eine RFM-Bewertung von 1 bis 5 pro Dimension zu "
                    "3. Erstellen Sie Segmente: Champions, Loyal, At Risk, Lost "
                    "4. Wenden Sie K-Means an (k=4 bis 8, wählen Sie das beste k mit dem Ellbogen-Verfahren) "
                    "5. Visualisieren Sie Segmente in 2D (PCA oder t-SNE) "
                    "6. Profilieren Sie jedes Segment: Größe, durchschnittliche Einnahmen, Frequenz "
                    "7. Export: CSV mit Segment pro Kunde + PDF-ähnlicher Bericht"
                )},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }],
        tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
        instructions=(
            "Verwenden Sie sklearn für Clustering. "
            "Normalisieren Sie Variablen vor dem Clustering. "
            "Zeigen Sie das Ellbogen-Diagramm an, um die Wahl von k zu rechtfertigen. "
            "Erstellen Sie ein Radar-Diagramm pro Segment."
        )
    )

    output_files = []
    for ann in fichiers_generes(response):
        telecharger(client, ann, ann.filename)
        output_files.append(ann.filename)

    return {
        "analysis": response.output_text,
        "files": output_files
    }

Workflow 4: Prognose und Trends

Die Prognose ist der Workflow, bei dem Vorsicht am wichtigsten ist. Der Container kann eine Regression oder eine saisonale Zerlegung durchführen, und er wird dies tun, auch wenn Ihre Daten dafür nicht geeignet sind – zwanzig Datenpunkte reichen aus, um eine perfekt präsentierte Kurve zu erzeugen, die völlig bedeutungslos ist. Fordern Sie das Konfidenzintervall und die Modellannahmen an: Dies unterscheidet eine Projektion von einer Extrapolation.

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Basierend auf diesen monatlichen Verkaufsdaten: "
                "1. Zerlegen Sie die Zeitreihe (Trend, Saisonalität, Restwert) "
                "2. Wenden Sie exponentielle Glättung (Holt-Winters) an "
                "3. Prognostizieren Sie die nächsten 6 Monate mit einem 95%-Konfidenzintervall "
                "4. Vergleichen Sie mit einer einfachen linearen Regression "
                "5. Generieren Sie ein Diagramm mit Historie und Prognosen "
                "6. Berechnen Sie Fehlermetriken (MAE, RMSE, MAPE)"
            )},
            {"type": "input_file", "file_id": file_obj.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions=(
        "Verwenden Sie statsmodels für Zerlegung und Prognose. "
        "Färben Sie das Konfidenzintervall in transparentem Blau. "
        "Markieren Sie die Trennung zwischen Historie und Prognosen deutlich."
    )
)

Orchestrierung eines mehrstufigen Workflows

Ab einer gewissen Größe erreicht ein einzelner Prompt seine Grenzen: Die Analyse driftet ab, eine Zwischenanweisung wird vergessen, und Sie verlieren den Überblick darüber, an welchem Schritt Sie sich befinden. Das Aufbrechen des Prozesses in aufeinanderfolgende Aufrufe, die alle innerhalb desselben Containers arbeiten, in dem Dateien aus dem vorherigen Schritt weiterhin verfügbar bleiben, stellt ein, was Sie verloren haben: eine Checkpoint nach jedem Schritt und die Möglichkeit, von dem fehlerhaften Schritt fortzufahren, anstatt alles neu zu starten.

class WorkflowData:
    def __init__(self):
        self.client = OpenAI()
        # Ein expliziter Container: Generierte Dateien bleiben von einem Schritt zum nächsten verfügbar
        self.container = self.client.containers.create(name="workflow-data")
        self.intermediate_files = []

    def step(self, instruction: str, file_ids: list[str] | None = None) -> str:
        """Führt einen Workflow-Schritt im gemeinsamen Container aus."""
        content = [{"type": "input_text", "text": instruction}]
        for fid in file_ids or []:
            content.append({"type": "input_file", "file_id": fid})

        response = self.client.responses.create(
            model="gpt-5.6-terra",
            input=[{"role": "user", "content": content}],
            tools=[{"type": "code_interpreter", "container": self.container.id}],
        )

        # Generierte Dateien merken, um am Ende herunterzuladen
        self.intermediate_files.extend(fichiers_generes(response))
        return response.output_text

    def download_results(self, output_folder: str):
        """Lädt generierte Dateien herunter, bevor der Container abläuft."""
        import os
        os.makedirs(output_folder, exist_ok=True)
        for ann in self.intermediate_files:
            telecharger(self.client, ann, os.path.join(output_folder, ann.filename))

# Nutzung
wf = WorkflowData()

# Schritt 1: Import und Bereinigung
with open("donnees_brutes.csv", "rb") as f:
    file_obj = client.files.create(file=f, purpose="user_data")

wf.step(
    "Bereinigen Sie diese CSV-Datei: Duplikate entfernen, fehlende Werte behandeln, "
    "Typen normalisieren. Exportieren Sie das Ergebnis.",
    [file_obj.id]
)

# Schritt 2: Analyse
wf.step("Berechnen Sie die wichtigsten KPIs und identifizieren Sie Trends.")

# Schritt 3: Visualisierung
wf.step("Erstellen Sie 4 Schlüsseldiagramme für einen Managementbericht.")

# Schritt 4: Export
wf.step("Fassen Sie alles in einer Excel-Datei mit Tabs und eingebetteten Diagrammen zusammen.")

wf.download_results("./sortie_workflow/")

Wichtige Erkenntnisse

• Zerlegen Sie komplexe Workflows in Schritte mit Dateipassing
• Verwenden Sie detaillierte Anweisungen für jeden Schritt
• Das Modell verarbeitet statistische Analysen und grundlegendes maschinelles Lernen von Haus aus
• Rufen Sie Zwischendateien systematisch ab, um die Nachverfolgbarkeit sicherzustellen
• Kombinieren Sie Datenanalyse und Visualisierung in einem einzigen Aufruf für vollständige Berichte