Code Interpreter: Kør kode i API'en
På denne side
Opdateret 2. november 2026 baseret på den officielle Code Interpreter-guide og
openaiSDK: Værktøjet kræver encontainer-parameter (mangler i alle tidligere eksempler, hvilket ville have fået dem til at fejle), genererede filer vises icontainer_file_citation-annotationer og downloades via Containers API (ikkeclient.files.content), og kald-output hedderoutputs(ikkeresults). Input-tekstdele bruger typeninput_text. Filer, der er vedhæftet en besked, uploades med formåletuser_data, hvilket OpenAI anbefaler til model-input (File inputs). Kilder: Code Interpreter · File inputs.
Code Interpreter: Kør kode i API’en
En sprogmodel forudsiger tekst; den regner ikke. Spørg den om kvadratroden af 1764, og den vil producere det mest sandsynlige resultat baseret på sin træning – ofte korrekt, nogle gange forkert, uden mulighed for at skelne mellem de to. Code Interpreter fjerner denne usikkerhed ved at give modellen en Python-fortolker: den skriver beregningen, udfører den og returnerer et opnået resultat, ikke et gæt.
Skiftet er dybere, end det umiddelbart ser ud. Modellen ser outputtet fra sin egen kode, inklusive fejl, så den kan rette sig selv og prøve igen. På en datafil, hvor ingen kender den nøjagtige struktur, slår denne løkke enhver forhåndsdefineret instruktion.
Aktiver Code Interpreter
Du aktiverer det ved at tilføje værktøjet til tools-arrayet – intet at installere, intet miljø at klargøre. Modellen beslutter selv, hvornår den skal skrive kode: den svarer direkte på faktuelle spørgsmål, men skifter til eksekvering ved beregninger eller datamanipulation.
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)
Modellen skriver Python-koden, udfører den i en sandbox og integrerer resultaterne i sit svar.
Inspicer den udførte kode
Væn dig til at læse denne kode, i hvert fald under udvikling. Det er den eneste måde at skelne et godt resultat fra et, der kun er rigtigt ved et tilfælde: et gennemsnit beregnet, mens manglende værdier stille ignoreres, er numerisk korrekt, men analytisk falsk. Svaret fortæller dig ikke dette; det gør koden.
Svaret indeholder den genererede kode og dens resultater:
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)
Lever filer som input
Værktøjet leverer sin fulde værdi, når det arbejder med filer. Du uploader, refererer til filen i kaldet, og modellen åbner den faktisk – den læser de rigtige kolonner, rigtige typer og rigtige udsving i stedet for at ræsonnere ud fra en beskrivelse, du måske har leveret.
# 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)
Hent genererede filer
Den omvendte vej fungerer også: koden producerer en renset CSV, et diagram eller en Excel-arbejdsbog, og disse filer returneres til dig. De forbliver i containeren, og svarbeskeden citerer dem i sine annotationer af typen container_file_citation, inklusive container-ID, fil-ID og filnavn. Du downloader dem derefter via Containers API. To små funktioner, genbrugt i senere lektioner, kapsler dette flow ind:
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
Filer, du leverer som input (input_file), kopieres automatisk ind i containeren: du behøver ikke uploade noget andet.
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 og miljø
At kende reglerne for containeren sparer tid på at fejlsøge det, der ikke kan fungere. Ifølge OpenAIs dokumentation:
- det er en fuldstændig isoleret virtuel maskine (sandbox), hvor modellen udfører Python;
- værktøjet kræver en
container-parameter:{"type": "auto"}opretter en container (eller genbruger en fra et tidligere kald, der findes i konteksten), mens et ID opnået viaclient.containers.create(...)tvinger brugen af en specifik container; - hukommelsen indstilles med
memory_limit:1g(standard),4g,16geller64g, hvor højere niveauer faktureres til satser for integrerede værktøjer; - en container udløber efter 20 minutters inaktivitet; dens data går derefter tabt, så download alle filer, du vil beholde, mens den er aktiv.
Regn ikke med netværksadgang fra koden: lever data som input, eller deleger research til Web Search-værktøjet.
# 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"}}]
)
Kæd flere eksekveringer
Efterfølgende eksekveringer deler den samme session: variabler, DataFrames og imports fra den første blok forbliver tilgængelige i den næste, præcis som i en notesbog. Modellen udnytter dette naturligt – den indlæser, inspicerer og behandler derefter – hvilket gør flertrinsanalyse mulig uden at genindlæse alt på hvert trin.
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
Kombiner med andre værktøjer
Den mest nyttige kombination parret en datakilde med evnen til at behandle den: File Search finder det relevante afsnit i dine dokumenter, Web Search henter markedsdata, og Code Interpreter sammenligner de to i en tabel eller et diagram. Intet af disse værktøjer kan udføre de andres opgaver.
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"}}
]
)
Mønster: Fuld analysepipeline
Det sidste eksempel kæder alt ovenstående sammen i et realistisk tilfælde: en inputfil, flertrinsanalyse og output-leverancer. Fokuser især på prompt-formatet – nummereret, eksplicit omkring det forventede output – for det er dette, langt mere end den medfølgende Python-kode, der bestemmer resultatets kvalitet.
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?"
])
Vigtige pointer
- Code Interpreter kører Python i en isoleret container; parameteren
containerer påkrævet ({"type": "auto"}eller et ID) - Filer leveret som
input_filekopieres automatisk ind i containeren - Genererede filer citeres som
container_file_citationog downloades viaclient.containers.files.content.retrieve - En container udløber efter 20 minutters inaktivitet: download det, du vil beholde
- Kombiner med Web Search og File Search for beriget analyse