Code Interpreter: Käivita koodi API-s
Sellel lehel
Uuendatud 2. novembril 2026 ametliku Code Interpreteri juhendi ja
openaiSDK põhjal: tööriist nõuab parameetritcontainer(puudus kõigist varasematest näidetest, mis oleksid seetõttu nurjunud), genereeritud failid ilmuvad annotatsioonidesse tüübigacontainer_file_citationja need laaditakse alla Containers API kaudu (mitteclient.files.content), ning väljakutsete tulemused kannavad nimeoutputs(mitteresults). Sisendteksti osad kasutavad tüüpiinput_text. Sõnumile lisatud failid laaditakse üles eesmärgigauser_data, mida OpenAI soovitab mudeli sisendite jaoks (File inputs). Allikad: Code Interpreter · File inputs.
Code Interpreter: Käivita koodi API-s
Keelemudel ennustab teksti; see ei arvuta. Küsi temalt arvu 1764 ruutjuurt ja ta toodab oma treeningu põhjal kõige tõenäolisema tulemuse – sageli õige, mõnikord vale, ilma võimaluseta neid eristada. Code Interpreter kõrvaldab selle määramatuse, andes mudelile Pythoni interpretaatori: ta kirjutab arvutuse, käivitab selle ja tagab saadud tulemuse, mitte aimduse.
Muutus on sügavam, kui esmapilgul paistab. Mudel näeb oma koodi väljundit, sealhulgas vigu, nii et ta saab ennast parandada ja uuesti proovida. Andmefaili puhul, mille täpset struktuuri keegi ei tea, lööb see tsükkel iga eelnevalt kirjutatud juhise.
Luba Code Interpreter
Sa lubad selle, lisades tööriista massiivi tools – midagi pole vaja installida ega keskkonda ette valmistada. Mudel otsustab ise, millal koodi kirjutada: ta vastab faktilistele küsimustele otse, kuid lülitub arvutuste või andmete manipuleerimise korral täitmisele.
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)
Mudel kirjutab Pythoni koodi, käivitab selle liivakastis ja integreerib tulemused oma vastusesse.
Kontrolli käivitatud koodi
Harjuta end vähemalt arenduse faasis seda koodi lugema. See on ainus viis eristada head tulemust sellisest, mis on juhuslikult õige: keskmine, mis on arvutatud, ignoreerides vaikselt puuduvaid väärtusi, on numbriliselt õige, kuid analüütiliselt vale. Vastus seda ei ütle; kood ütleb.
Vastus sisaldab genereeritud koodi ja selle tulemusi:
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"], # to receive produced logs and images
)
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)
Esita faile sisendina
Tööriist annab oma täieliku väärtuse just failidega töötamisel. Sa laadid faili üles, viidad sellele väljakutses ja mudel avab selle tegelikult – ta loeb reaalsed veerud, reaalsed tüübid ja reaalsed hälbed, selle asemel et arutleda kirjelduse üle, mida sa oleksid võinud anda.
# Upload the file
with open("sales_2025.csv", "rb") as f:
file_obj = client.files.create(file=f, purpose="user_data")
# Use Code Interpreter with the file
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)
Hangi genereeritud failid
Pöördtee toimib samuti: kood toodab puhastatud CSV-faili, diagrammi või Exceli töövihiku ja need failid tagastatakse sulle. Need jäävad konteinerisse ja vastussõnum viitab neile oma annotatsioonides tüübiga container_file_citation, kaasates konteineri ID, faili ID ja failinime. Seejärel laadid need alla Containers API kaudu. Kaks väikest funktsiooni, mida kasutatakse hilisemates tundides, kapseldavad selle voogu:
def generated_files(response):
"""Files created by Code Interpreter, cited in message annotations."""
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):
"""Downloads a file from the container and returns its local path."""
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
Sisendina esitatud failid (input_file) kopeeritakse automaatselt konteinerisse: sa ei pea midagi muud üles laadima.
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"}}]
)
# Retrieve generated files
for ann in generated_files(response):
print(f"Generated file: {ann.filename}")
download(client, ann, ann.filename)
Konteiner ja keskkond
Konteineri reeglite tundmine säästab aega veaotsingul selle üle, mis ei saa toimida. OpenAI dokumentatsiooni kohaselt:
- see on täielikult isoleeritud virtuaalmasin (liivakast), kus mudel käivitab Pythoni;
- tööriist nõuab parameetrit
container:{"type": "auto"}loob konteineri (või kasutab uuesti kontekstis olevat eelmisest väljakutsest pärit konteinerit), samas kui ID, mis on saadudclient.containers.create(...)kaudu, sunnib kasutama kindlat konteinerit; - mälu määratakse parameetriga
memory_limit:1g(vaikimisi),4g,16gvõi64g, kus kõrgemaid tasemeid arveldatakse integreeritud tööriistade hindade järgi; - konteiner aegub pärast 20-minutilist tegevusetust; selle andmed lähevad seejärel kaduma, seega laadi alla kõik failid, mida soovid säilitada, kuni see on aktiivne.
Ära looda koodist võrguühendusele: esita andmed sisendina või delegeeri uurimistöö Web Searchi tööriistale.
# Example: the model can use pandas directly
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"}}]
)
Ahelda mitu täitmist
Järjestikused täitmised jagavad sama sessiooni: muutujad, DataFrame’id ja impordid esimesest plokist jäävad järgmisesse kättesaadavaks, täpselt nagu märkmikus. Mudel kasutab seda loomulikult – ta laeb, kontrollib ja seejärel töötleb –, muutes mitmeastmelise analüüsi võimalikuks ilma kõike igas etapis uuesti laadimata.
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"}}]
)
# The model executes 4 code blocks sequentially
# Each block has access to variables from previous ones
Kombineeri teiste tööriistadega
Kasulikuim kombinatsioon ühendab andmeallika võimekusega seda töödelda: File Search leiab asjakohase lõigu sinu dokumentidest, Web Search toob turuandmed ja Code Interpreter võrdleb neid kahest tabelis või diagrammis. Ükski neist tööriistadest ei saa teiste tööd teha.
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"}}
]
)
Muster: täielik analüüsitorustik
Viimane näide ühendab kõik eelneva realistlikuks juhtumiks: sisendfail, mitmeastmeline analüüs ja väljundfailid. Pööra erilist tähelepanu vihje (prompt) formaadile – nummerdatud, selge oodatava väljundi osas –, sest just see, palju rohkem kui kaasnev Pythoni kood, määrab tulemuse kvaliteedi.
def analyze_data(file_path: str, questions: list[str]) -> dict:
"""Data analysis pipeline with Code Interpreter."""
# Upload
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
# Usage
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?"
])
Peamised punktid
- Code Interpreter käivitab Pythoni isoleeritud konteineris; parameeter
containeron kohustuslik ({"type": "auto"}või ID) - Sisendina
input_fileesitatud failid kopeeritakse automaatselt konteinerisse - Genereeritud failidele viidatakse kui
container_file_citationja need laaditakse allaclient.containers.files.content.retrievekaudu - Konteiner aegub pärast 20-minutilist tegevusetust: laadi alla see, mida soovid säilitada
- Kombineeri Web Searchi ja File Searchiga rikastatud analüüsi jaoks