Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Code Interpreter: Spouštění kódu v API

Lekce 10 z 20 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Code Interpreter: Spouštění kódu v API
  2. Povolení Code Interpreter
  3. Inspekce provedeného kódu
  4. Poskytnutí souborů jako vstup
  5. Získání vygenerovaných souborů
  6. Kontejner a prostředí
  7. Řetězení více provedení
  8. Kombinace s dalšími nástroji
  9. Vzor: Kompletní analytický pipeline
  10. Klíčové poznatky

Aktualizováno 2. listopadu 2026 na základě oficiální příručky Code Interpreter a SDK openai: nástroj vyžaduje parametr container (chybějící ve všech předchozích příkladech, které by jinak selhaly), vygenerované soubory se objevují v anotacích typu container_file_citation a stahují se přes Containers API (nikoli přes client.files.content) a výstupy volání se nazývají outputs (nikoli results). Části vstupního textu používají typ input_text. Soubory připojené ke zprávě se nahrávají s účelem user_data, což OpenAI doporučuje pro vstupy modelu (File inputs). Zdroje: Code Interpreter · File inputs.

Code Interpreter: Spouštění kódu v API

Jazykový model předpovídá text; neprovádí výpočty. Když ho požádáš o druhou odmocninu z 1764, vyprodukuje nejpravděpodobnější výsledek na základě svého tréninku – často správný, někdy chybný, bez možnosti rozlišit rozdíl. Code Interpreter tuto nejistotu odstraňuje tím, že modelu poskytne interpret Pythonu: napíše výpočet, provede ho a vrátí získaný výsledek, nikoli hádanku.

Posun je hlubší, než se zdá. Model vidí výstup svého vlastního kódu, včetně chyb, takže se může opravit a zkusit to znovu. U datového souboru, jehož přesnou strukturu nikdo nezná, tento cyklus porazí jakoukoli předem napsanou instrukci.

Povolení Code Interpreter

Povolíš ho přidáním nástroje do pole tools – nic není třeba instalovat, žádné prostředí provisionovat. Model se sám rozhodne, kdy kód napsat: na faktické otázky odpovídá přímo, ale u výpočtů nebo manipulace s daty přepne na provádění.

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)

Model napíše kód v Pythonu, provede jej v izolovaném prostředí (sandbox) a integruje výsledky do své odpovědi.

Inspekce provedeného kódu

Zvykni si tento kód číst, alespoň během vývoje. Je to jediný způsob, jak rozlišit dobrý výsledek od toho, který je správný jen náhodou: průměr vypočítaný při tichém ignorování chybějících hodnot je numericky správný, ale analyticky falešný. Odpověď ti to neřekne; kód ano.

Odpověď obsahuje vygenerovaný kód a jeho výsledky:

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"],  # pro získání vytvořených logů a obrázků
)

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)

Poskytnutí souborů jako vstup

Nástroj přináší plnou hodnotu při práci se soubory. Soubor nahraješ, odkážeš na něj ve volání a model jej skutečně otevře – čte skutečné sloupce, skutečné typy a skutečné odlehlé hodnoty, místo aby uvažoval o popisu, který jsi mu mohl poskytnout.

# Nahrání souboru
with open("sales_2025.csv", "rb") as f:
    file_obj = client.files.create(file=f, purpose="user_data")

# Použití Code Interpreter se souborem
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)

Získání vygenerovaných souborů

Funguje i opačný směr: kód vytvoří vyčištěný CSV, graf nebo sešit Excelu a tyto soubory jsou ti vráceny. Zůstávají v kontejneru a odpovědní zpráva je cituje ve svých anotacích typu container_file_citation, včetně ID kontejneru, ID souboru a názvu souboru. Poté je stáhneš přes Containers API. Dvě malé funkce, znovu použité v pozdějších lekcích, zapouzdřují tento tok:

def generated_files(response):
    """Soubory vytvořené Code Interpreter, citované v anotacích zpráv."""
    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):
    """Stáhne soubor z kontejneru a vrátí jeho místní cestu."""
    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

Soubory poskytnuté jako vstup (input_file) jsou automaticky zkopírovány do kontejneru: nemusíš nic dalšího nahrávat.

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"}}]
)

# Získání vygenerovaných souborů
for ann in generated_files(response):
    print(f"Generated file: {ann.filename}")
    download(client, ann, ann.filename)

Kontejner a prostředí

Znalost pravidel kontejneru šetří čas při ladění toho, co nemůže fungovat. Podle dokumentace OpenAI:

  • jedná se o plně izolovaný virtuální stroj (sandbox), kde model spouští Python;
  • nástroj vyžaduje parametr container: {"type": "auto"} vytvoří kontejner (nebo znovu použije jeden z předchozího volání přítomného v kontextu), zatímco ID získané přes client.containers.create(...) vynutí použití konkrétního kontejneru;
  • paměť se nastavuje pomocí memory_limit: 1g (výchozí), 4g, 16g nebo 64g, přičemž vyšší úrovně jsou účtovány podle sazeb pro integrované nástroje;
  • kontejner vyprší po 20 minutách nečinnosti; jeho data jsou poté ztracena, takže si stáhni všechny soubory, které chceš zachovat, dokud je aktivní.

Nespoléhej na přístup k síti z kódu: poskytni data jako vstup nebo deleguj vyhledávání na nástroj Web Search.

# Příklad: model může přímo použít pandas
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"}}]
)

Řetězení více provedení

Postupná provedení sdílejí stejnou relaci: proměnné, DataFrame a importy z prvního bloku zůstávají dostupné v dalším, přesně jako v notebooku. Model to přirozeně využívá – načte, prozkoumá a poté zpracovává – což umožňuje vícekrokovou analýzu bez nutnosti znovu načítat vše v každé fázi.

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"}}]
)

# Model provede 4 bloky kódu sekvenčně
# Každý blok má přístup k proměnným z předchozích

Kombinace s dalšími nástroji

Nejužitečnější kombinace páruje zdroj dat se schopností jej zpracovat: File Search najde příslušný úsek ve tvých dokumentech, Web Search přinese tržní data a Code Interpreter porovná obojí v tabulce nebo grafu. Žádný z těchto nástrojů nedokáže vykonat práci těch ostatních.

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"}}
    ]
)

Vzor: Kompletní analytický pipeline

Poslední příklad řetězí vše výše uvedeného do realistického případu: vstupní soubor, vícekroková analýza a výstupní deliverables. Zaměř se zejména na formát promptu – číslovaný, explicitní ohledně očekávaného výstupu – protože ten, mnohem více než doprovodný kód v Pythonu, určuje kvalitu výsledku.

def analyze_data(file_path: str, questions: list[str]) -> dict:
    """Pipeline pro analýzu dat s Code Interpreter."""
    # Nahrání
    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

# Použití
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?"
])

Klíčové poznatky

  • Code Interpreter spouští Python v izolovaném kontejneru; parametr container je povinný ({"type": "auto"} nebo ID)
  • Soubory poskytnuté jako input_file jsou automaticky zkopírovány do kontejneru
  • Vygenerované soubory jsou citovány jako container_file_citation a stahují se přes client.containers.files.content.retrieve
  • Kontejner vyprší po 20 minutách nečinnosti: stáhni si vše, co chceš zachovat
  • Kombinuj s Web Search a File Search pro obohacenou analýzu