Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Code Interpreter: Kør kode i API'en

Lektion 10 af 20 Opdateret 2. november 2026 Udvikler
På denne side
  1. Code Interpreter: Kør kode i API’en
  2. Aktiver Code Interpreter
  3. Inspicer den udførte kode
  4. Lever filer som input
  5. Hent genererede filer
  6. Container og miljø
  7. Kæd flere eksekveringer
  8. Kombiner med andre værktøjer
  9. Mønster: Fuld analysepipeline
  10. Vigtige pointer

Opdateret 2. november 2026 baseret på den officielle Code Interpreter-guide og openai SDK: Værktøjet kræver en container-parameter (mangler i alle tidligere eksempler, hvilket ville have fået dem til at fejle), genererede filer vises i container_file_citation-annotationer og downloades via Containers API (ikke client.files.content), og kald-output hedder outputs (ikke results). Input-tekstdele bruger typen input_text. Filer, der er vedhæftet en besked, uploades med formålet user_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 via client.containers.create(...) tvinger brugen af en specifik container;
  • hukommelsen indstilles med memory_limit: 1g (standard), 4g, 16g eller 64g, 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 container er påkrævet ({"type": "auto"} eller et ID)
  • Filer leveret som input_file kopieres automatisk ind i containeren
  • Genererede filer citeres som container_file_citation og downloades via client.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