Code Interpreter: Uruchamianie kodu w API
Na tej stronie
Zaktualizowano 2 listopada 2026 na podstawie oficjalnego przewodnika po Code Interpreter oraz SDK
openai: narzędzie wymaga parametrucontainer(brakującego we wszystkich poprzednich przykładach, co powodowałoby błędy), wygenerowane pliki pojawiają się w adnotacjach typucontainer_file_citationi są pobierane przez Containers API (a nie przezclient.files.content), a wyniki wywołań noszą nazwęoutputs(a nieresults). Części tekstowe wejścia używają typuinput_text. Pliki dołączone do wiadomości są przesyłane z przeznaczeniemuser_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 przezclient.containers.create(...)wymusza użycie konkretnego kontenera; - pamięć jest ustawiana przez
memory_limit:1g(domyślnie),4g,16glub64g, 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
containerjest wymagany ({"type": "auto"}lub ID) - Pliki dostarczone jako
input_filesą automatycznie kopiowane do kontenera - Wygenerowane pliki są cytowane jako
container_file_citationi pobierane przezclient.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ę