Python a OpenAI: používame nové Responses API

V tomto článku sa však zameriame výhradne na OpenAI a jeho modely. Pre spúšťanie príkadov je potrebné sa zaregistrovať na portáli platform.openai.com a zakúpiť si kredit. Kredit za 5 dolárov nám na naše testovacie potreby bohato postačí. (Nemýliť si to s chat.openai.com, čo je ChatGPT AI asistent, ktorý používa OpenAI modely, ale neposkytuje priamy prístup k API.) Kredit si zakúpime v nastaveniach, sekcii Billing.

Po zakúpení kreditu je potrebné získať API kľúč, ktorý nám umožní autentifikovať sa pri volaní OpenAI API. Kľúč nájdeme v sekcii API Keys. Tento kľúč je citlivý údaj, ktorý by sme nikdy nemali zdieľať alebo vystavovať v kóde, ktorý bude verejne dostupný (napríklad na GitHub). Preto ho budeme ukladať ako environmentálnu premennú.

export OPENAI_API_KEY=sk-proj-J0RxBN3U...

Premenná prostredia sa typicky na Linuxových systémoch nastavuje v súbore ~/.bashrc alebo ~/.zshrc.

Ak si svoju premennú nazveme OPENAI_API_KEY, nemusíme ju potom v kóde explicitne uvádzať – OpenAI Python knižnica ju automaticky načíta z prostredia.

from openai import OpenAI

client = OpenAI()

Vo všetkých príkladoch sa predpokladá práve takéto nastavenie.

$ uv init
$ uv add openai

Potrebujeme si potom nainštalovať samotnú OpenAI knižnicu. Na manažment závislostí odporúčam použiť nástroj uv, obzvlášť na Unixových systémoch.

$ uv run python main.py

Príklady potom spúšťame pomocou uv run python.

Responses API

OpenAI Responses API je nové rozhranie, ktoré rozširuje možnosti Chat Completions API a prináša zabudované nástroje pre agentické aplikácie. Kľúčové výhody zahŕňajú:

• Natívne nástroje – zabudované funkcie ako vyhľadávanie na webe, interpret kódu, práca s dokumentmi
• Agentické správanie – model automaticky využíva nástroje podľa potreby
• Lepšia výkonnosť – o 3% lepšie výsledky na SWE-bench benchmarku
• Nižšie náklady – o 40–80% lepšie využitie cache
• Stateful kontext – jednoduchšie udržiavanie konverzácie cez  previous_response_id
• Reasoning módy – podpora pre GPT-5 reasoning modely s rôznymi úrovňami úsilia
• Multimodálne vstupy – natívna podpora pre text a obrázky

Tu je prehľad kľúčových rozdielov medzi Chat Completions a Responses API:

Okrem nových schopností sa líši aj štruktúra API. V Chat Completions sme používali messages, v Responses používame input (môže byť reťazec alebo pole správ) a voliteľný instructions. Odpoveď vráti objekt Response s id  namiesto choices poľa. Pre štruktúrované výstupy používame text_format namiesto response_format.

Z uvedeného vyplýva, že pre nové aplikácie je rozhodne odporúčané používať nové Responses API, pokiaľ to samozrejme váš model podporuje.

Základné použitie

Začnime jednoduchým príkladom generovania textu. Responses API má veľmi intuitívne rozhranie – použijeme metódu client.responses.create() a ako parameter input zadáme jednoduchý prompt.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
  model="gpt-5-mini",
  input="Write a haiku about the changing seasons.",
)

print(response.output_text)

V tomto príklade používame pomocný atribút output_text, ktorý priamo vráti vygenerovaný text. Responses API je navrhnuté tak, aby bolo jednoduché na použitie pre základné úlohy, no ponúka aj pokročilé možnosti pre komplexnejšie scenáre.

$ uv run python haiku.py
Bud unfolds to sun
Leaves blaze, then drift in cold winds —
Silence seeds the snow

Pole správ pre input umožňuje zachovať konverzačný kontext.

from openai import OpenAI

client = OpenAI()

prompt = "What is the capital of France? In one sentence."

# 1. Start the conversation history
messages = [
    {
        "type": "message",
        "role": "user",
        "content": [{"type": "input_text", "text": prompt}]
    }
]

# Turn 1: Ask about France
response = client.responses.create(
    model="gpt-5-mini",
    input=messages
)

fr_reply = response.output_text

print(f"AI: {fr_reply}")

messages.append({
    "type": "message",
    "role": "assistant",
    "content": [{"type": "output_text", "text": fr_reply}]
})

# Turn 2: Follow-up (Notice we don't mention "capital" or "France" again)
messages.append({
    "type": "message",
    "role": "user",
    "content": [{"type": "input_text", "text": "And of Slovakia?"}]
})

# Send the WHOLE list (3 messages total now)
response_2 = client.responses.create(
    model="gpt-5-mini",
    input=messages
)

svk_reply = response_2.output_text

print(f"AI: {svk_reply}")

V tomto príklade vytvárame pole messages, ktoré obsahuje celú konverzačnú históriu vrátane otázok a odpovedí. Každý ťah pridávame do tejto histórie, takže model má kontext pre následné otázky. Toto je veľmi užitočné pre udržiavanie stavových konverzácií, kde model „pamätá“ predchádzajúce interakcie bez potreby opakovania informácií v každom requeste.

Reasoning mód

Responses API podporuje nové GPT-5 reasoning modely, ktoré sú optimalizované na riešenie komplexných problémov. Pomocou parametra reasoning môžeme nastaviť úroveň úsilia, ktorú má model vynaložiť na uvažovanie:

from openai import OpenAI

client = OpenAI()

prompt = """
Write a bash script that takes a matrix represented as a string with
format '[1,2],[3,4],[5,6]' and prints the transpose in the same format.
"""

response = client.responses.create(
    model="gpt-5",
    reasoning={"effort": "medium"},
    input=[
        {
            "role": "user",
            "content": prompt
        }
    ]
)

print(response.output_text)

Parameter effort môže mať hodnoty low, medium alebo high. Vyššia úroveň znamená viac času stráveného uvažovaním, čo vedie k lepším výsledkom pri komplexných úlohách, ako je programovanie, matematika alebo logické riešenie problémov. To samozrejme vedie k väčšej spotrebe tokenov a vyššej latencii, takže je dobré experimentovať s rôznymi úrovňami podľa potreby.

Súkromie a ukladanie dát

OpenAI štandardne ukladá konverzácie pre zlepšovanie služby, no pre organizácie s prísnejšími požiadavkami na súkromie existuje parameter store.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
  model="gpt-5-mini",
  input="Write a haiku about the changing seasons.",
  store=False,
)

print(response.output_text)

Pri nastavení store=False OpenAI neukladá žiadne dáta z requestu ani odpovede. Toto je v súlade s Zero Data Retention (ZDR) politikou, ktorá je požadovaná v niektorých odvetviach alebo jurisdikciách.

Na našom OpenAI dashboarde v záložke Logs môžeme vidieť uloženú komunikáciu s modelom, ktorá nemala vypnutý parameter store.

Pre reasoning modely existuje aj možnosť šifrovaného uvažovania, kde uvažovanie modelu je zašifrované a dešifrované len v pamäti, nikdy nie na disku. Toto sa aktivuje parametrom:

response = client.responses.create(
    model="gpt-5",
    reasoning={"effort": "medium", "encrypted": True},
    store=False,
    include=["reasoning.encrypted_content"],
    input="Sensitive calculation task..."
)

V sektore zdravotníctva sú údaje pacientov chránené prísnymi predpismi (ako GDPR v EÚ alebo HIPAA v USA). Šifrované spracovanie dát umožňuje využívať pokročilú AI bez toho, aby poskytovateľ AI videl citlivé medicínske diagnózy v procese „premýšľania“ modelu.

Prístup k týmto voľbám je však dostupný len pre organizácie, ktoré sú v programe ZDR a bežný užívatelia ho nemajú k dispozícii.

Systémové inštrukcie: Architektúra správania modelu

Systémové inštrukcie predstavujú základný stavebný kameň pre definovanie logiky a identity umelej inteligencie. Správne pochopenie rozdielu medzi parametrom instructions a správou s rolou system je kľúčové pre stabilitu a efektivitu vyvíjaných aplikácií.

Systémové inštrukcie fungujú ako nadradený operačný manuál. Určujú osobnosť modelu, jeho tón, formát výstupu a striktné obmedzenia. Zatiaľ čo používateľský vstup definuje konkrétnu úlohu, systémové inštrukcie definujú spôsob, akým bude táto úloha vykonaná. Premieňajú generický model na špecializovaný nástroj – napríklad na analytika schopného spracovávať zložité finančné výkazy alebo na asistenta pre plánovanie rozpočtu.

V novom rozhraní Responses API existujú dve cesty, ako tieto inštrukcie modelu odovzdať. Každá má svoje špecifiká z hľadiska architektúry kódu a vplyvu na model.

Odporúčania pre implementáciu:

• Priorita pre moderné modely: Pre modely ako GPT-5 a GPT-5-mini je preferovanou voľbou parameter instructions. Modelu to jasne signalizuje, že ide o fixné pravidlá, ktoré nesmú byť ovplyvnené neskoršími manipuláciami v používateľskom čate.
• Súkromie a čistota dát: Využitie samostatného parametra umožňuje čistejšie oddelenie aplikačnej logiky od používateľských dát. Ak je nastavený parameter store=False, inštrukcie sú spracované ako dočasné riadiace dáta, čo zvyšuje bezpečnosť citlivých firemných promptov.
• Konzistencia v dlhých konverzáciách: V prípade vývoja komplexných aplikácií, kde zoznam správ ( input) neustále narastá, parameter instructions zabezpečuje, že model nezabudne na svoje pôvodné zadanie. Na rozdiel od správy v histórii, ktorú môže model pri vyčerpaní kontextového okna začať ignorovať, top-level inštrukcie zostávajú ukotvené v každom kroku generovania.

from openai import OpenAI

client = OpenAI()

# Inštrukcie definujú expertný tón a zameranie na logistiku
instructions = """
Si profesionálny itinerár-manažér a cestovný poradca.
Tvojou úlohou je vytvárať logicky nadväzujúce plány ciest,
ktoré optimalizujú čas, náklady a zážitky pre celú rodinu.
"""

# Vstup s konkrétnymi preferenciami a obmedzeniami
prompt = """
Naplánuj 10-dňový okruh po Islande v máji pre 4 osoby.
Máme rozpočet 6 000 €, chceme vidieť vodopády, ale vyhnúť sa
najväčším davom. Máme prenajaté auto 4x4. Navrhni mestá na
ubytovanie a denný rozpis aktivít.
"""

# Konfigurácia s využitím instructions, hlbšieho uvažovania a súkromia
response = client.responses.create(
  model="gpt-5",
  instructions=instructions,
  input=prompt,
  reasoning={"effort": "high"}, # Model musí prepočítať vzdialenosti a kapacity v danom mesiaci
  store=False                   # Vaše osobné plány a rozpočet sa neukladajú do histórie
)

print(response.output_text)

V tomto príklade využívame parameter instructions na definovanie identity a úlohy modelu. Model je nastavený ako „profesionálny itinerár‑manažér a cestovný poradca“, čo mu poskytuje jasný rámec pre generovanie odpovede. Vstup obsahuje konkrétne požiadavky a obmedzenia, ktoré model musí zohľadniť pri plánovaní cesty.

Výstup modelu bude detailný itinerár s odporúčaniami na ubytovanie, denné aktivity a logistiku, ktorý zohľadňuje vaše preferencie a obmedzenia, a zároveň je optimalizovaný pre efektívne využitie času a rozpočtu.

V druhom príklade využívame systémové inštrukcie v rámci správy s rolou system. Príklad klasifikuje položky do kategórií veľkosti.

from openai import OpenAI

client = OpenAI()

# The items to classify
items = ["elephant", "mouse", "dog", "snail", "giraffe", "ant"]
prompt = f"Classify the following items as [large, medium, small, tiny]:\n {', '.join(items)}"

system_instruction = """
You are a helpful assistant that classifies items strictly
into the categories provided.
"""


response = client.responses.create(
  model="gpt-5-mini",
  input=[
    {
      "role": "system",
      "content": [
        {
          "type": "input_text",
          "text": system_instruction
        }
      ],
    },
    {
      "role": "user",
      "content": [
        {
          "type": "input_text",
          "text": prompt
        }
      ],
    }
  ],
)

print(response.output_text)

V tomto prípade sú systémové inštrukcie súčasťou konverzačnej histórie. Model dostáva inštrukcie ako prvú správu, ale v závislosti od dĺžky a komplexnosti konverzácie môže začať ignorovať tieto inštrukcie, ak sa dostaneme k limitu kontextového okna. Preto je tento prístup menej spoľahlivý pre dlhé alebo komplexné interakcie, kde je kritické, aby model dodržiaval pevné pravidlá.

Štruktúrované výstupy

Jednou z najužitočnejších funkcií je schopnosť generovať štruktúrované výstupy v JSON formáte. Responses API podporuje dva prístupy: použitie Pydantic modelov alebo manuálnu definíciu JSON schémy.

Pydantic modely

Najelegantnejším spôsobom je využitie Pydantic modelov. Použijeme metódu responses.parse() a parameter text_format, ktorý automaticky validuje a parsuje odpoveď do Pydantic objektu:

from openai import OpenAI
from pydantic import BaseModel
from typing import List

client = OpenAI()

text = """
Extract information about people mentioned in the following text. For each
person, provide their name, age, and city of residence in a structured JSON
format. John Doe is a software engineer living in New York. He is 30 years old
and enjoys hiking and photography. Jane Smith is a graphic designer based in San
Francisco. She is 28 years old and loves painting and traveling.
"""

class Person(BaseModel):
    name: str
    age: int
    city: str

class PeopleExtraction(BaseModel):
    people: List[Person]

response = client.responses.parse(
    model="gpt-5-mini",
    input=[{"role": "user", "content": text}],
    text_format=PeopleExtraction,
)

print("Extracted info:", response.output_parsed)

print("\nPeople found:")
for person in response.output_parsed.people:
    print(f"- {person.name}, {person.age} years old, from {person.city}")

Výhodou tohto prístupu je typová bezpečnosť – dostávame priamo Python objekt s validovanými typmi. Vlastnosť output_parsed nám vráti inštanciu triedy PeopleExtraction, s ktorou môžeme ďalej pracovať ako s bežným Python objektom.

$ uv run python extract_data_resp_pydantic.py
Extracted info: people=[Person(name='John Doe', age=30, city='New York'),
    Person(name='Jane Smith', age=28, city='San Francisco')]

People found:
- John Doe, 30 years old, from New York
- Jane Smith, 28 years old, from San Francisco

Použitie JSON schémy

Alternatívne môžeme použiť manuálnu definíciu JSON schémy. Tento prístup dáva väčšiu kontrolu nad štruktúrou, no vyžaduje viac kódu:

from openai import OpenAI
import json

client = OpenAI()

text = """
Extract information about people mentioned in the following text. For each
person, provide their name, age, and city of residence in a structured JSON
format. John Doe is a software engineer living in New York. He is 30 years old
and enjoys hiking and photography. Jane Smith is a graphic designer based in San
Francisco. She is 28 years old and loves painting and traveling."""

format_schema = {
    "type": "json_schema",
    "name": "people_extraction",
    "strict": True,
    "schema": {
        "type": "object",
        "properties": {
            "people": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "name": {"type": "string"},
                        "age": {"type": "integer"},
                        "city": {"type": "string"}
                    },
                    "required": ["name", "age", "city"],
                    "additionalProperties": False
                }
            }
        },
        "required": ["people"],
        "additionalProperties": False
    }
}

response = client.responses.create(
    model="gpt-5-mini",
    input=[{"role": "user", "content": text}],
    text={
        "format": format_schema
    }
)

data = json.loads(response.output_text)
print("Extracted info:", data)

if "people" in data:
    print("\nPeople found:")
    for person in data["people"]:
        print(f"- {person['name']}, {person['age']} years old, from {person['city']}")

Pri použití JSON schémy si všimnite parameter text namiesto text_format. Odpoveď dostávame cez output_text a sami ju parsujeme pomocou json.loads(). Parameter strict: True zabezpečuje prísnu validáciu podľa schémy.

Natívne nástroje

Responses API prináša veľkú zmenu v podobe vstavaných nástrojov (tools), ktoré model môže využívať automaticky. Nemusíme už implementovať vlastné API volania – stačí pridať nástroj do poľa tools a model ho použije, keď to bude potrebné. Použitie nástrojov sa tak mimoriadne zjednodušuje.

Dostupné nástroje zahŕňajú:

Vyhľadávanie na webe

Najjednoduchší príklad použitia natívneho nástroja je web_search. Model automaticky vyhľadá aktuálne informácie a odpovie na základe nájdených výsledkov. Tomuto sa v anglickej terminológii hovorí grounding.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5-mini",
    tools=[{"type": "web_search"}],
    input="Who are the last three Slovak presidents, including the present one?"
)

print(response.output_text)

Model automaticky identifikuje, že potrebuje aktuálne informácie, spustí vyhľadávanie a odpovie na základe nájdených dát. Nemusíme implementovať logiku pre volanie vyhľadávacieho API – všetko sa deje automaticky v rámci agentického správania.

$ uv run python web_search.py
The last three presidents of Slovakia (including the current one):

- Peter Pellegrini — incumbent president; took office 15 June 2024.
([en.wikipedia.org](https://en.wikipedia.org/wiki/Peter_Pellegrini?utm_source=openai))
- Zuzana Čaputová — served 15 June 2019 – 15 June 2024.
([en.wikipedia.org](https://en.wikipedia.org/wiki/Zuzana_%C4%8Caputov%C3%A1?utm_source=openai))
- Andrej Kiska — served 15 June 2014 – 15 June 2019.
([en.wikipedia.org](https://en.wikipedia.org/wiki/Andrej_Kiska?utm_source=openai))

Would you like short bios or links to sources for any of them?

Model poskytne aktuálnu odpoveď spolu s linkami na zdroje.

$ uv run python web_search_no_tool.py
As of my last update (June 2024), the most recent three Slovak presidents are:

- Zuzana Čaputová — incumbent (in office since 15 June 2019)
- Andrej Kiska — 15 June 2014 to 15 June 2019
- Ivan Gašparovič — 15 June 2004 to 15 June 2014

If you need the current holder as of today (Feb 2026), I can look it up—I don't
have browsing access in this session, so I can't confirm any changes after June
2024 unless you want me to fetch fresh information.

Ak nepoužijeme nástroj, model sa spolieha na svoje trénované dáta, ktoré sú v našom prípade zastarané. Model však na to inteligentne poukazuje.

Analýza dát s Code Interpreter

Ďalším výkonným nástrojom je code_interpreter, ktorý umožňuje modelu spúšťať Python kód v izolovanom prostredí. To je užitočné pre matematické výpočty, analýzu dát alebo spracovanie súborov.

Ešte predtým, než sa pustíme do analýzy dát, povedzme si pár slov o využítí LLM pre matematícké výpočty.

Veľké jazykové modely predstavujú vynikajúci nástroj na prácu s matematikou, no ich využitie má svoje limity. Fungujú skôr ako jazykoví experti na matematiku než ako samotné kalkulačky. Excelujú vo vysvetľovaní zložitých konceptov, riešení slovných úloh a generovaní cvičných príkladov.

Hlavným úskalím však zostáva fakt, že LLM sú pravdepodobnostné generátory textu, nie deterministické stroje. Nemajú v sebe zabudovaný logický obvod kalkulačky; namiesto výpočtu sa snažia odhadnúť nasledujúci najpravdepodobnejší „token“. To vedie k tzv. matematickým halucináciám, kedy model sebavedomo predloží nesprávny výsledok. Hoci nové uvažujúce modely vďaka internému reťazcu myšlienok tieto nedostatky zmierňujú, stále nie sú stopercentne spoľahlivé pri čistej aritmetike.

V súčasnosti sa ako najvhodnejší prístup k matematike ukazuje hybridný model. LLM sa použije na pochopenie zadania, navrhnutie postupu alebo brainstorming. Na samotné výpočty, kde záleží na každej cifre, je však vždy potrebné použiť špecializované nástroje ako Wolfram Alpha, Python alebo vedeckú kalkulačku.

Najprv si ukážme jednoduchú analýzu CSV súboru bez použitia code interpreter – model dostane dáta a má ich analyzovať priamo.

id,first_name,last_name,email,occupation,salary,created_at
1,Jana,Nováková,jana.novakova@gmail.com,Software Engineer,3200.0,2026-01-01
2,Peter,Kováč,peter.kovac@example.com,Data Analyst,2800.0,2026-01-02
3,Lucia,Horváthová,lucia.horvathova@example.com,Project Manager,3500.0,2026-01-03
4,Martin,Tóth,martin.toth@example.com,UX Designer,3000.0,2026-01-04
5,Simona,Varga,simona.varga@example.com,QA Engineer,2700.0,2026-01-05
6,Marek,Polák,marek.polak@example.com,DevOps Engineer,3400.0,2026-01-06
7,Zuzana,Bartošová,zuzana.bartosova@example.com,HR Specialist,2500.0,2026-01-07
8,Tomáš,Urban,tomas.urban@example.com,Business Analyst,2900.0,2026-01-08
9,Barbora,Králová,barbora.kralova@simplemail.com,Marketing Manager,3300.0,2026-01-09
10,Jozef,Šimek,jozef.simek@example.com,System Administrator,3100.0,2026-01-10
11,Michaela,Dudová,michaela.dudova@example.com,Content Writer,2200.0,2026-01-11
12,Richard,Bielik,richard.bielik@example.com,Product Owner,3600.0,2026-01-12
13,Katarína,Farkašová,katarina.farkasova@gmail.com,Accountant,2600.0,2026-01-13
14,Andrej,Gregor,andrej.gregor@example.com,Network Engineer,3200.0,2026-01-14
15,Veronika,Kučerová,veronika.kucerova@gmail.com,Graphic Designer,2400.0,2026-01-15
16,Patrik,Holub,patrik.holub@gmail.com,Mobile Developer,3300.0,2026-01-16
17,Eva,Švecová,eva.svecova@example.com,Recruiter,2300.0,2026-01-17
18,Roman,Marek,roman.marek@simplemail.com,Database Administrator,3400.0,2026-01-18
19,Monika,Blažeková,monika.blazekova@example.com,Scrum Master,3100.0,2026-01-19
20,Filip,Klein,filip.klein@example.com,Web Developer,3000.0,2026-01-20

V súbore máme dvadsať záznamov o používateľoch. Našou úlohou je zistiť minimum, maximum, sumu a priemer platov.

from openai import OpenAI
from pydantic import BaseModel

client = OpenAI()

class SalaryReport(BaseModel):
    minimum: float
    maximum: float
    sum: float
    average: float

file_name = "users.csv"

with open(file_name, "r", encoding="utf-8") as file:
    data = file.read()

    prompt = f"""Generate a report containing minimum, maximum, sum, and average of salaries
    from the CSV data provided. Please provide the results in JSON format.\n\nData:\n{data}"""

    response = client.responses.parse(
        model="gpt-5-mini",
        input=[{"role": "user", "content": prompt}],
        text_format=SalaryReport,
        store=False,
    )

    report = response.output_parsed
    print(report.model_dump_json(indent=2))

Dáta načítame priamo z CSV súboru a vložíme ich do promptu.

$ uv run python data_analysis_direct.py
{
  "minimum": 2200.0,
  "maximum": 3600.0,
  "sum": 59500.0,
  "average": 2975.0
}

Výsledky sú správne. Avšak nikdy si nemôžeme byť úplne istí.

Teraz to porovnajme s použitím code_interpreter.

from openai import OpenAI
from pydantic import BaseModel

client = OpenAI()

file_name = "users.csv"

class SalaryReport(BaseModel):
    minimum: float
    maximum: float
    sum: float
    average: float

with open(file_name, "r", encoding="utf-8") as file:
    data = file.read()

    prompt = f"""Generate a report containing minimum, maximum, sum, and average of salaries
    from the CSV data provided. Write and run Python tool to analyze the data.
    Please provide the results in JSON format.\n\nData:\n{data}"""

    response = client.responses.parse(
        model="gpt-5-mini",
        input=[{"role": "user", "content": prompt}],
        tools=[
            {
                "type": "code_interpreter",
                "container": {"type": "auto", "memory_limit": "1g"},
            }
        ],
        text_format=SalaryReport,
        store=False,
    )

    report = response.output_parsed
    print(report.model_dump_json(indent=2))

Pri použití nástroja code_interpreter model napíše Python skript, spustí ho v izolovanom kontajneri, a vráti presné výsledky. Parameter container umožňuje konfiguráciu prostredia, vrátane limitov pamäte. Na našom účte na portáli OpenAI si môžeme pozrieť na dashboarde v sekcii Usage vytvorenie nového kontajnera.

Vďaka nástroju code_interpreter je spúšťanie Python kódu triviálnou záležitosťou.

Multimodálne vstupy

Responses API natívne podporuje prácu s obrázkami. Môžeme kombinovať textové a obrázkové vstupy v jednom requeste pomocou typov input_text a input_image:

import base64
from openai import OpenAI

client = OpenAI()

def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

image_path = "sid.jpg"
base64_image = encode_image(image_path)

response = client.responses.create(
    model="gpt-5-mini",
    input=[
        {
            "role": "user",
            "content": [
                { "type": "input_text", "text": "Who in this image?" },
                {
                    "type": "input_image",
                    "image_url": f"data:image/jpeg;base64,{base64_image}",
                },
            ],
        }
    ],
)

print(response.output_text)

Obrázok musíme najprv zakódovať do formátu Base64. Parameter content môže obsahovať pole rôznych typov vstupov, čo umožňuje flexibilnú kompozíciu multimodálnych požiadaviek. Model GPT-5-mini aj GPT-5 podporujú vision capabilities pre analýzu a popis obrázkov.

$ uv run python describe_image.py
That's Sid the Sloth, the goofy ground sloth character from the Ice Age animated
movies (voiced by John Leguizamo).

Tvorba obrázkov

Pre generovanie obrázkov pomocou najnovších modelov platia prísne pravidlá. Je potrebné sa verifikovať a odovzdať osobné informácie. Je to kvôli tomu, aby sa zabránilo tvorbe sexuálne explicitného obsahu alebo deepfake obsahu.

import openai
import os

client = openai.OpenAI()

prompt = "A serene landscape with mountains, a river, and a clear sky at sunset."

# 1. Create a Response using image_generation tool
response = client.responses.create(
    model="gpt-4o-mini", # Model that supports image_generation tool
    input=prompt,
    tools=[{"type": "image_generation"}]
)

# 2. Extract the image from the output items
# The Responses API returns a list of items (text, tool calls, or media)
for item in response.output:
    if item.type == "image":
        image_id = item.image.id
        print(f"Generated Image ID: {image_id}")

        # 3. Download the file using the Files API
        # In the modern stack, images are often stored as internal File objects
        image_file = client.files.content(image_id)

        with open("serene_landscape.png", "wb") as f:
            f.write(image_file.content)

        print("Image saved as serene_landscape.png")

Osobne som sa kvôli tejto verifikácii a požiadavke na osobné údaje rozhodol tento nástroj zatiaľ nevyužívať.

Prístup k starších modelom zostal zachovaný.

import openai
import requests

client = openai.OpenAI()

prompt = 'A monk writing a book in a monastery library, detailed, realistic'

response = client.images.generate(
    model="dall-e-3",
    prompt=prompt,
    size="1024x1024",
    quality="standard",
    n=1, # number of images to generate
)

image_url = response.data[0].url
print(f"Generated image: {image_url}")

# Download and save the image
image_data = requests.get(image_url).content
with open("monk_writing.png", "wb") as f:
    f.write(image_data)

print("Image saved as monk_writing.png")

Tento príklad využíva staršie API a starší model DALL-E 3, ktorý nevyžaduje verifikáciu. Obrázok sa generuje a následne sťahuje cez URL. Tento prístup je stále funkčný.

Všetky príklady z článku a mnohé ďalšie sú dostupné na GitHub repozitári github.com/janbodnar/Python-AI-Skolenie.

V nasledujúcich pokračovaniach tohto seriálu sa pozrieme na ďalšie možnosti, ako je práca s MCP, agentmi, audiom, súbormi, kontajnermi, shellmi a ďalšími nástrojmi, ktoré sú k dispozícii v rámci Responses API.