Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Code Interpreter: Kód futtatása az API-ban

10. lecke 20 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Code Interpreter: Kód futtatása az API-ban
  2. A Code Interpreter engedélyezése
  3. A végrehajtott kód vizsgálata
  4. Fájlok biztosítása bemenetként
  5. A generált fájlok lekérése
  6. Konténer és környezet
  7. Több végrehajtás láncolása
  8. Kombinálás más eszközökkel
  9. Minta: Teljes elemzési folyamat
  10. Főbb megállapítások

Frissítve: 2026. november 2. a hivatalos Code Interpreter útmutató és az openai SDK alapján: az eszköz megköveteli a container paramétert (ami minden korábbi példából hiányzott, így azok sikertelenek lettek volna), a generált fájlok a container_file_citation annotációkban jelennek meg, és a Containers API-n keresztül tölthetők le (nem a client.files.content segítségével), a hívások kimenete pedig outputs néven szerepel (nem resultsként). A bemeneti szövegrészek típusa input_text. Az üzenethez csatolt fájlokat user_data céllal kell feltölteni, amit az OpenAI ajánl a modellbemenetekhez (File inputs). Források: Code Interpreter · File inputs.

Code Interpreter: Kód futtatása az API-ban

A nyelvi modell szöveget jósol meg; nem számol. Ha megkéred a 1764 négyzetgyökére, a tanítási adatai alapján a legvalószínűbb eredményt adja meg – ami gyakran helyes, de néha téves, és nincs módod eldönteni, melyik melyik. A Code Interpreter megszünteti ezt a bizonytalanságot azáltal, hogy egy Python értelmezőt biztosít a modell számára: az megírja a számítást, végrehajtja, és egy kapott eredményt ad vissza, nem pedig egy tippet.

A váltás mélyebb, mint elsőre tűnik. A modell látja a saját kódja kimenetét, beleértve a hibákat is, így képes kijavítani magát és újra próbálkozni. Egy olyan adatfájlnál, ahol senki sem ismeri a pontos szerkezetet, ez a ciklus felülmúl bármilyen előre megírt utasítást.

A Code Interpreter engedélyezése

Úgy engedélyezed, hogy hozzáadod az eszközt a tools tömbhöz – nincs szükség telepítésre, sem környezet előkészítésére. A modell dönti el, mikor írjon kódot: a ténykérdésekre közvetlenül válaszol, de számítások vagy adatmanipuláció esetén végrehajtásra vált.

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)

A modell megírja a Python kódot, végrehajtja egy homokozóban (sandbox), és integrálja az eredményeket a válaszába.

A végrehajtott kód vizsgálata

Szoktasd rá magad, hogy elolvasod ezt a kódot, legalábbis fejlesztés közben. Ez az egyetlen módja annak, hogy megkülönböztesd a jó eredményt attól, ami csak véletlenül helyes: egy átlag, amelyet a hiányzó értékek csendes figyelmen kívül hagyásával számítanak ki, numerikusan helyes lehet, de analitikailag hamis. A válasz ezt nem árulja el; a kód igen.

A válasz tartalmazza a generált kódot és annak eredményeit:

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"],  # a naplók és képek fogadásához
)

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)

Fájlok biztosítása bemenetként

Az eszköz akkor nyújtja a teljes értékét, amikor fájlokkal dolgozik. Feltöltöd a fájlt, hivatkozol rá a hívásban, és a modell ténylegesen megnyitja azt – elolvassa a valós oszlopokat, valós típusokat és valós kiugró értékeket, ahelyett, hogy egy általad esetleg megadott leírás alapján következtetne.

# A fájl feltöltése
with open("sales_2025.csv", "rb") as f:
    file_obj = client.files.create(file=f, purpose="user_data")

# A Code Interpreter használata a fájllal
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)

A generált fájlok lekérése

A fordított út is működik: a kód előállít egy tisztított CSV-t, egy diagramot vagy egy Excel-munkafüzetet, és ezeket a fájlokat visszakapod. Ezek a konténerben maradnak, és a válaszüzenet container_file_citation típusú annotációkban hivatkozik rájuk, beleértve a konténer azonosítóját, a fájl azonosítóját és a fájlnevét. Ezután a Containers API-n keresztül töltöd le őket. Két kis függvény, amelyet a későbbi leckékben újra felhasználunk, kapszulázza ezt a folyamatot:

def generated_files(response):
    """A Code Interpreter által létrehozott fájlok, hivatkozva az üzenet annotációiban."""
    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):
    """Letölt egy fájlt a konténerből, és visszaadja a helyi elérési útját."""
    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

A bemenetként megadott fájlok (input_file) automatikusan másolódnak a konténerbe: nem kell mást feltöltened.

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"}}]
)

# A generált fájlok lekérése
for ann in generated_files(response):
    print(f"Generated file: {ann.filename}")
    download(client, ann, ann.filename)

Konténer és környezet

A konténer szabályainak ismerete időt takarít meg annak debuggolásában, ami nem működhet. Az OpenAI dokumentációja szerint:

  • ez egy teljesen izolált virtuális gép (homokozó), ahol a modell Python kódot futtat;
  • az eszköz megköveteli a container paramétert: a {"type": "auto"} létrehoz egy konténert (vagy újrahasznál egy korábbi hívásból származót, ha az a kontextusban jelen van), míg a client.containers.create(...) segítségével kapott azonosító egy konkrét konténert kényszerít ki;
  • a memóriát a memory_limit állítja be: 1g (alapértelmezett), 4g, 16g vagy 64g, ahol a magasabb szinteket integrált eszközárakkal számlázzák;
  • egy konténer 20 perc inaktivitás után lejár; az adatai ezután elvesznek, ezért töltsd le az összes megőrizni kívánt fájlt, amíg aktív.

Ne számíts hálózati hozzáférésre a kódból: biztosítsd az adatokat bemenetként, vagy delegáld a kutatást a Web Search eszközre.

# Példa: a modell közvetlenül használhatja a pandas könyvtárat
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"}}]
)

Több végrehajtás láncolása

A egymást követő végrehajtások ugyanazt a munkamenetet osztják meg: az első blokkból származó változók, DataFrame-ek és importálások elérhetők maradnak a következőben, pontosan úgy, mint egy jegyzetfüzetben. A modell ezt természetesen kihasználja – betölt, ellenőriz, majd feldolgoz –, lehetővé téve a több lépéses elemzést anélkül, hogy minden szakaszban újra kellene tölteni mindent.

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"}}]
)

# A modell 4 kódblokkot hajt végre sorrendben
# Minden blokk hozzáfér az előzőek változóihoz

Kombinálás más eszközökkel

A leghasznosabb kombináció egy adatforrást párosít a feldolgozás képességével: a File Search megtalálja a releváns részt a dokumentumaidban, a Web Search piacai adatokat hoz be, a Code Interpreter pedig táblázatban vagy diagramon összehasonlítja a kettőt. Egyik eszköz sem képes a másik feladatát ellátni.

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"}}
    ]
)

Minta: Teljes elemzési folyamat

A végső példa mindent összeláncol a fentiekből egy valós esetbe: egy bemeneti fájl, több lépéses elemzés és kimeneti deliverables. Különösen a prompt formátumára figyelj – számozott, explicit a várt kimenetről –, mert ez, sokkal inkább mint a kísérő Python kód, meghatározza az eredmény minőségét.

def analyze_data(file_path: str, questions: list[str]) -> dict:
    """Adatelemzési folyamat Code Interpreterrel."""
    # Feltöltés
    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

# Használat
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?"
])

Főbb megállapítások

  • A Code Interpreter Pythont futtat egy izolált konténerben; a container paraméter kötelező ({"type": "auto"} vagy egy azonosító)
  • Az input_file-ként megadott fájlok automatikusan másolódnak a konténerbe
  • A generált fájlok container_file_citation-ként vannak hivatkozva, és a client.containers.files.content.retrieve segítségével tölthetők le
  • Egy konténer 20 perc inaktivitás után lejár: töltsd le, amit meg szeretnél őrizni
  • Kombináld a Web Search és a File Search eszközökkel a gazdagított elemzés érdekében