Przejdź do głównej treści
Polski— Wybierz język
Menu

Code Interpreter: Uruchamianie kodu w API

Lekcja 10 z 20 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Code Interpreter: Uruchamianie kodu w API
  2. Włączanie Code Interpreter
  3. Inspekcja wykonanego kodu
  4. Dostarczanie plików jako dane wejściowe
  5. Pobieranie wygenerowanych plików
  6. Kontener i środowisko
  7. Łańcuchowe wykonywanie wielu operacji
  8. Łączenie z innymi narzędziami
  9. Wzorzec: Pełny potok analityczny
  10. Kluczowe wnioski

Zaktualizowano 2 listopada 2026 na podstawie oficjalnego przewodnika po Code Interpreter oraz SDK openai: narzędzie wymaga parametru container (brakującego we wszystkich poprzednich przykładach, co powodowałoby błędy), wygenerowane pliki pojawiają się w adnotacjach typu container_file_citation i są pobierane przez Containers API (a nie przez client.files.content), a wyniki wywołań noszą nazwę outputs (a nie results). Części tekstowe wejścia używają typu input_text. Pliki dołączone do wiadomości są przesyłane z przeznaczeniem user_data, co OpenAI rekomenduje dla danych wejściowych modelu (File inputs). Źródła: Code Interpreter · File inputs.

Code Interpreter: Uruchamianie kodu w API

Model językowy przewiduje tekst; nie wykonuje obliczeń. Poproś go o pierwiastek kwadratowy z 1764, a zwróci najbardziej prawdopodobny wynik na podstawie swojego treningu – często poprawny, czasem błędny, bez możliwości rozróżnienia tych przypadków. Code Interpreter usuwa tę niepewność, dostarczając modelowi interpreter Pythona: pisze on kod obliczeniowy, wykonuje go i zwraca uzyskany wynik, a nie domysł.

Zmiana ta jest głębsza, niż się wydaje. Model widzi wynik działania własnego kodu, w tym błędy, dzięki czemu może się skorygować i spróbować ponownie. W przypadku pliku z danymi, którego dokładna struktura nie jest znana, taka pętla sprawdza się lepiej niż jakakolwiek wcześniej napisana instrukcja.

Włączanie Code Interpreter

Włączasz go, dodając narzędzie do tablicy tools – niczego nie instalujesz, żadnego środowiska nie musisz konfigurować. Model sam decyduje, kiedy napisać kod: na pytania faktograficzne odpowiada bezpośrednio, ale przełącza się na wykonanie kodu w przypadku obliczeń lub manipulacji danymi.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Oblicz ciąg Fibonacciego do 20. wyrazu",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

print(response.output_text)

Model pisze kod w Pythonie, wykonuje go w piaskownicy i integruje wyniki ze swoją odpowiedzią.

Inspekcja wykonanego kodu

Wyrób sobie nawyk czytania tego kodu, przynajmniej podczas rozwoju. To jedyny sposób, by odróżnić dobry wynik od takiego, który jest poprawny przez przypadek: średnia obliczona przy cichym ignorowaniu brakujących wartości jest numerycznie poprawna, ale analitycznie fałszywa. Odpowiedź Ci tego nie powie; kod już tak.

Odpowiedź zawiera wygenerowany kod i jego wyniki:

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Jaki jest pierwiastek kwadratowy z 1764? Zweryfikuj, podnosząc wynik do kwadratu.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    include=["code_interpreter_call.outputs"],  # aby otrzymać wygenerowane logi i obrazy
)

for item in response.output:
    if item.type == "code_interpreter_call":
        print("--- Wykonany kod ---")
        print(item.code)
        print("--- Wyniki ---")
        for output in item.outputs or []:
            print(output.logs if output.type == "logs" else output.url)

Dostarczanie plików jako dane wejściowe

Narzędzie ujawnia pełnię swoich możliwości podczas pracy z plikami. Przesyłasz plik, odwołujesz się do niego w wywołaniu, a model faktycznie go otwiera – odczytuje rzeczywiste kolumny, rzeczywiste typy i rzeczywiste wartości odstające, zamiast rozumować na podstawie opisu, który mogłeś dostarczyć.

# Przesyłanie pliku
with open("sales_2025.csv", "rb") as f:
    file_obj = client.files.create(file=f, purpose="user_data")

# Użycie Code Interpreter z plikiem
response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Przeanalizuj ten plik sprzedażowy. "
                 "Podaj sumę według kategorii i najlepszy miesiąc."},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }
    ],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

print(response.output_text)

Pobieranie wygenerowanych plików

Działa to również w drugą stronę: kod produkuje oczyszczony plik CSV, wykres lub skoroszyt Excela, a te pliki są Ci zwracane. Pozostają one w kontenerze, a wiadomość odpowiedzi cytuję je w swoich adnotacjach typu container_file_citation, zawierających ID kontenera, ID pliku i nazwę pliku. Następnie pobierasz je przez Containers API. Dwie małe funkcje, wykorzystywane w kolejnych lekcjach, encapsulują ten przepływ:

def generated_files(response):
    """Pliki utworzone przez Code Interpreter, cytowane w adnotacjach wiadomości."""
    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):
    """Pobiera plik z kontenera i zwraca jego lokalną ścieżkę."""
    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

Pliki dostarczone jako dane wejściowe (input_file) są automatycznie kopiowane do kontenera: nie musisz przesyłać niczego dodatkowego.

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Stwórz wykres sprzedaży według miesięcy "
                 "i eksportuj oczyszczone dane jako CSV."},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }
    ],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

# Pobieranie wygenerowanych plików
for ann in generated_files(response):
    print(f"Wygenerowany plik: {ann.filename}")
    download(client, ann, ann.filename)

Kontener i środowisko

Znajomość zasad działania kontenera oszczędza czas na debugowaniu rzeczy, które nie mogą zadziałać. Zgodnie z dokumentacją OpenAI:

  • jest to w pełni izolowana maszyna wirtualna (piaskownica), w której model wykonuje Pythona;
  • narzędzie wymaga parametru container: {"type": "auto"} tworzy kontener (lub ponownie używa istniejącego z poprzedniego wywołania obecnego w kontekście), podczas gdy ID uzyskane przez client.containers.create(...) wymusza użycie konkretnego kontenera;
  • pamięć jest ustawiana przez memory_limit: 1g (domyślnie), 4g, 16g lub 64g, przy czym wyższe poziomy są rozliczane według stawek za zintegrowane narzędzia;
  • kontener wygasa po 20 minutach bezczynności; jego dane są wtedy tracone, więc pobierz wszelkie pliki, które chcesz zachować, dopóki jest aktywny.

Nie licz na dostęp do sieci z poziomu kodu: dostarcz dane jako wejście lub deleguj badania do narzędzia Web Search.

# Przykład: model może używać pandas bezpośrednio
response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Wczytaj ten CSV za pomocą pandas, "
                 "oblicz statystyki opisowe i zidentyfikuj wartości odstające."},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }
    ],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

Łańcuchowe wykonywanie wielu operacji

Kolejne wykonania dzielą tę samą sesję: zmienne, DataFrame i importy z pierwszego bloku pozostają dostępne w następnym, dokładnie tak jak w notatniku. Model wykorzystuje to w naturalny sposób – ładuje, inspekcjonuje, a następnie przetwarza – co umożliwia wieloetapową analizę bez konieczności ponownego ładowania wszystkiego na każdym etapie.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="1. Wygeneruj 1000 losowych punktów z rozkładu normalnego. "
          "2. Oblicz średnią i odchylenie standardowe. "
          "3. Stwórz histogram. "
          "4. Przeprowadź test normalności Shapiro-Wilka.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

# Model wykonuje 4 bloki kodu sekwencyjnie
# Każdy blok ma dostęp do zmiennych z poprzednich

Łączenie z innymi narzędziami

Najbardziej użyteczna kombinacja łączy źródło danych ze zdolnością do jego przetwarzania: File Search znajduje odpowiedni fragment w Twoich dokumentach, Web Search dostarcza danych rynkowych, a Code Interpreter porównuje oba zestawy w tabeli lub na wykresie. Żadne z tych narzędzi nie może wykonywać zadań pozostałych.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Wyszukaj w sieci dane o PKB Francji z ostatnich 10 lat, "
          "następnie stwórz wykres trendu z regresją liniową.",
    tools=[
        {"type": "web_search"},
        {"type": "code_interpreter", "container": {"type": "auto"}}
    ]
)

Wzorzec: Pełny potok analityczny

Ostatni przykład łączy wszystko powyższe w realistyczny przypadek: plik wejściowy, wieloetapowa analiza i produkty wyjściowe. Skup się szczególnie na formacie promptu – numerowanym, z wyraźnym określeniem oczekiwanego wyniku – ponieważ to on, znacznie bardziej niż towarzyszący mu kod Pythona, decyduje o jakości rezultatu.

def analyze_data(file_path: str, questions: list[str]) -> dict:
    """Potok analizy danych z Code Interpreter."""
    # Przesyłanie
    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="Pisz czysty, komentowany kod w Pythonie. "
                        "Wyświetlaj wyniki pośrednie."
        )

        results[question] = response.output_text

    return results

# Użycie
results = analyze_data("sales.csv", [
    "Podaj statystyki opisowe dla każdej kolumny numerycznej",
    "Jakie są 5 najlepiej sprzedających się produktów?",
    "Czy w sprzedaży występuje sezonowość?"
])

Kluczowe wnioski

  • Code Interpreter uruchamia Pythona w izolowanym kontenerze; parametr container jest wymagany ({"type": "auto"} lub ID)
  • Pliki dostarczone jako input_file są automatycznie kopiowane do kontenera
  • Wygenerowane pliki są cytowane jako container_file_citation i pobierane przez client.containers.files.content.retrieve
  • Kontener wygasa po 20 minutach bezczynności: pobierz to, co chcesz zachować
  • Łącz z Web Search i File Search, aby wzbogacić analizę