Code Interpreter: Executați cod în API
Pe această pagină
Actualizat la 2 noiembrie 2026 pe baza ghidului oficial Code Interpreter și a SDK-ului
openai: instrumentul necesită un parametrucontainer(lipsă din toate exemplele anterioare, care ar fi eșuat), fișierele generate apar în adnotările de tipcontainer_file_citationși sunt descărcate prin API-ul Containers (nu princlient.files.content), iar rezultatele apelurilor sunt denumiteoutputs(nuresults). Părțile de text de intrare folosesc tipulinput_text. Fișierele atașate unui mesaj sunt încărcate cu scopuluser_data, ceea ce OpenAI recomandă pentru intrările modelului (File inputs). Surse: Code Interpreter · File inputs.
Code Interpreter: Executați cod în API
Un model lingvistic prezice text; nu calculează. Dacă îi cereți rădăcina pătrată a lui 1764, va produce rezultatul cel mai probabil bazat pe antrenamentul său – adesea corect, uneori greșit, fără nicio modalitate de a face diferența. Code Interpreter elimină această incertitudine oferind modelului un interpretor Python: acesta scrie calculul, îl execută și returnează un rezultat obținut, nu o ghicitoare.
Schimbarea este mai profundă decât pare. Modelul vede ieșirea propriului său cod, inclusiv erorile, astfel încât se poate corecta și poate reîncerca. Pe un fișier de date unde nimeni nu cunoaște structura exactă, această buclă bate orice instrucțiune pre-scrisă.
Activarea Code Interpreter
Îl activați adăugând instrumentul în tabloul tools – nimic de instalat, niciun mediu de provisionat. Modelul decide când să scrie cod: răspunde direct la întrebările factuale, dar trece la execuție pentru calcule sau manipularea datelor.
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)
Modelul scrie codul Python, îl execută într-un sandbox și integrează rezultatele în răspunsul său.
Inspectarea codului executat
Obișnuiți-vă să citiți acest cod, cel puțin în timpul dezvoltării. Este singura modalitate de a distinge un rezultat bun de unul care este corect din întâmplare: o medie calculată ignorând silențios valorile lipsă este numeric corectă, dar analitic falsă. Răspunsul nu vă va spune acest lucru; codul o va face.
Răspunsul conține codul generat și rezultatele sale:
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)
Furnizarea fișierelor ca intrare
Instrumentul își livrează întreaga valoare atunci când lucrează cu fișiere. Încărcați fișierul, faceți referire la el în apel, iar modelul îl deschide efectiv – citește coloanele reale, tipurile reale și valorile aberante reale, în loc să raționeze despre o descriere pe care ați fi putut-o furniza.
# 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)
Recuperarea fișierelor generate
Calea inversă funcționează, de asemenea: codul produce un CSV curățat, un grafic sau un registru Excel, iar aceste fișiere vă sunt returnate. Ele rămân în container, iar mesajul de răspuns le citează în adnotările sale de tip container_file_citation, incluzând ID-ul containerului, ID-ul fișierului și numele fișierului. Apoi le descărcați prin API-ul Containers. Două funcții mici, reutilizate în lecțiile ulterioare, encapsulează acest flux:
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
Fișierele pe care le furnizați ca intrare (input_file) sunt copiate automat în container: nu trebuie să încărcați nimic altceva.
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)
Container și mediu
Cunoașterea regulilor containerului vă economisește timp depanând ceea ce nu poate funcționa. Conform documentației OpenAI:
- este o mașină virtuală complet izolată (sandbox) în care modelul execută Python;
- instrumentul necesită un parametru
container:{"type": "auto"}creează un container (sau îl reutilizează pe unul dintr-un apel anterior prezent în context), în timp ce un ID obținut princlient.containers.create(...)forțează un container specific; - memoria este setată cu
memory_limit:1g(implicit),4g,16gsau64g, nivelurile superioare fiind facturate la tarifele pentru instrumente integrate; - un container expiră după 20 de minute de inactivitate; datele sale se pierd apoi, așa că descărcați orice fișier pe care doriți să îl păstrați cât timp este activ.
Nu contați pe accesul la rețea din cod: furnizați datele ca intrare sau delegați cercetarea instrumentului Web Search.
# 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"}}]
)
Înlănțuirea mai multor execuții
Execuțiile succesive partajează aceeași sesiune: variabilele, DataFrame-urile și importurile din primul bloc rămân disponibile în următorul, exact ca într-un notebook. Modelul valorifică acest lucru în mod natural – încarcă, inspectează, apoi procesează – făcând posibilă analiza în mai mulți pași fără a reîncărca totul la fiecare etapă.
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
Combinarea cu alte instrumente
Cea mai utilă combinație asociază o sursă de date cu capacitatea de a o procesa: File Search găsește pasajul relevant din documentele dumneavoastră, Web Search aduce date de piață, iar Code Interpreter compară cele două într-un tabel sau grafic. Niciunul dintre aceste instrumente nu poate face treaba celorlalte.
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"}}
]
)
Model: Pipeline complet de analiză
Ultimul exemplu înlănțuiește totul de mai sus într-un caz realist: un fișier de intrare, analiză în mai mulți pași și livrabile de ieșire. Acordați o atenție deosebită formatului promptului – numerotat, explicit privind ieșirea așteptată – deoarece acesta, mult mai mult decât codul Python care îl însoțește, determină calitatea rezultatului.
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?"
])
Puncte cheie
- Code Interpreter rulează Python într-un container izolat; parametrul
containereste obligatoriu ({"type": "auto"}sau un ID) - Fișierele furnizate ca
input_filesunt copiate automat în container - Fișierele generate sunt citate ca
container_file_citationși descărcate princlient.containers.files.content.retrieve - Un container expiră după 20 de minute de inactivitate: descărcați ceea ce doriți să păstrați
- Combinați cu Web Search și File Search pentru o analiză îmbogățită