Code Interpreter: Spouštění kódu v API
Na této stránce
Aktualizováno 2. listopadu 2026 na základě oficiální příručky Code Interpreter a SDK
openai: nástroj vyžaduje parametrcontainer(chybějící ve všech předchozích příkladech, které by jinak selhaly), vygenerované soubory se objevují v anotacích typucontainer_file_citationa stahují se přes Containers API (nikoli přesclient.files.content) a výstupy volání se nazývajíoutputs(nikoliresults). Části vstupního textu používají typinput_text. Soubory připojené ke zprávě se nahrávají s účelemuser_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řesclient.containers.create(...)vynutí použití konkrétního kontejneru; - paměť se nastavuje pomocí
memory_limit:1g(výchozí),4g,16gnebo64g, 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
containerje povinný ({"type": "auto"}nebo ID) - Soubory poskytnuté jako
input_filejsou automaticky zkopírovány do kontejneru - Vygenerované soubory jsou citovány jako
container_file_citationa stahují se přesclient.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