OpenAI Responses API Tutorial: 14 spustitelných příkladů pro Python vývojáře

OpenAI Responses API Tutorial: 14 spustitelných příkladů pro Python vývojáře

Tutoriál k OpenAI Responses API, který skutečně potřebujete: 14 spustitelných příkladů v Pythonu pokrývajících vestavěné nástroje, streaming, volání funkcí, MCP a migraci z Chat Completions ve 3 krocích. Responses API bylo spuštěno 11. března 2025 jako sjednocený primitiv OpenAI pro aplikace stylu agentů a od dubna 2026 je doporučeným výchozím bodem pro každý nový projekt OpenAI. Všechny níže uvedené příklady jsme otestovali proti nejnovějšímu Python SDK openai>=1.50 v dubnu 2026 — každý blok kódu funguje tak, jak je.

Klíčové poznatky

• Responses API (spuštěno 11. března 2025) sjednocuje Chat Completions, Assistants a vestavěné nástroje do jednoho stavového primitivu.
• Podporuje web_search, file_search, code_interpreter, computer_use, image_generation a vzdálené MCP servery přímo out of the box.
• Migrace z Chat Completions zabere 3 kroky: změna endpointu, přejmenování messages → input, aktualizace schémat nástrojů.
• Pro lehký stav použijte previous_response_id (s store: true); pro spolehlivé vícekolové konverzace Conversations API.

Co je OpenAI Responses API?

OpenAI Responses API je sjednocený primitiv spuštěný v březnu 2025, který kombinuje jednoduchost Chat Completions s využitím nástrojů z Assistants API. Podporuje textový a obrazový vstup, vestavěné nástroje (webové vyhledávání, vyhledávání v souborech, interpret kódu, ovládání počítače, generování obrázků), volání funkcí, strukturované výstupy, streaming a stavové konverzace prostřednictvím previous_response_id.

Proč tedy OpenAI vydalo třetí API, když Chat Completions již fungovalo? Protože agentní smyčka, kdy model zavolá nástroj, získá výsledek a rozhodne o dalším kroku, bylo nad chat.completions obtížné budovat. Nakonec jste přenášeli výsledky nástrojů zpět a forth v polích messages, řešili ID vláken s Assistants API nebo si vytvářeli vlastní stav. Responses API považuje tuto smyčku za prvotřídní koncept.

Pokud v roce 2026 začínáte nový projekt OpenAI, Responses API je výchozí volbou, zatímco Chat Completions je legacy primitiv, od kterého migrujete. Velké výjimky: realtime audio (použijte Realtime API) a čistá embeddings (použijte Embeddings API). Pro vše ostatní, chatboty, agenty, RAG pipeline, extraktory strukturovaných dat, je Responses tím, kam vás odkazuje dokumentace OpenAI a příspěvek k oznámení OpenAI.

Pokud orchestrujete více modelů nebo chcete vrstvu vyšší úrovně, obvykle spojíte Responses API s OpenAI Agents SDK. Kompromisy jsme popsali v našem srovnání OpenAI Agents SDK, stručně: Responses je primitiv, Agents SDK je framework.

Jak se Responses API liší od Chat Completions?

Responses API je nadmnožinou Chat Completions: každá funkce Chat Completions funguje v Responses, plus vestavěné nástroje, stavovost a agentní smyčka. OpenAI doporučuje Responses pro všechny nové projekty. Chat Completions zůstává podporován, ale již není výchozím primitivem pro agenty.

Zde je srovnání side-by-side, čerpáno z dokumentace platformy OpenAI:

Každá funkce Chat Completions funguje v Responses; opačně to neplatí. Rozhodovací pravidlo je krátké: pokud potřebujete vestavěné nástroje, stavovost nebo začínáte od nuly, použijte Responses. Pokud máte stabilní pipeline Chat Completions, která nepoužívá nástroje a vaše brána ještě nepodporuje Responses, migrace není urgentní, jen nestavte nové agenty na starém API.

Nastavení a vaše první volání Responses API

Chcete-li provést své první volání Responses API, nainstalujte OpenAI Python SDK verze 1.50 nebo novější, nastavte proměnnou prostředí OPENAI_API_KEY a zavolejte client.responses.create() s parametry model a input. Celý příklad hello-world zabere méně než 60 sekund.

Krok 1 — Instalace SDK:

pip install --upgrade "openai>=1.50"

Krok 2 — Nastavení API klíče:

export OPENAI_API_KEY="sk-proj-..."

(Ve Windows PowerShell: $env:OPENAI_API_KEY = "sk-proj-...". Nikdy tento klíč nekomitujte do gitu, pro lokální vývoj použijte soubor .env plus python-dotenv.)

Krok 3 — Volání hello-world:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Say hello in exactly 5 words.",
)

print(response.output_text)

Spusťte to a získáte zpět pozdrav o 5 slovech. Pomocná funkce output_text spojí všechny textové chunky do jednoho řetězce, což je šikovné, když vám nezáleží na strukturovaném výstupu.

Krok 4 — Inspekce objektu odpovědi:

print("ID:        ", response.id)
print("Status:    ", response.status)
print("Model:     ", response.model)
print("Output:    ", response.output)            # list of output items
print("First text:", response.output[0].content[0].text)
print("Usage:     ", response.usage)             # input_tokens, output_tokens

Pole response.output je věc, kterou si musíte zapamatovat. Je to seznam typovaných položek: text, volání nástrojů, výsledky nástrojů, shrnutí uvažování. Budete jím neustále iterovat, jakmile začnete používat vestavěné nástroje.

Jak streamovat odpovědi pomocí Responses API?

Streaming s Responses API využívá Server-Sent Events. Předejte stream=True do client.responses.create() a iterujte přes výsledný proud událostí. Každá událost má pole type, response.output_text.delta pro tokenové chunky a response.completed pro finální payload. SDK 1.50+ vystavuje typovaný proud událostí.

Pokud renderujete tokeny do UI, budete iterovat události response.output_text.delta a ignorovat vše ostatní.

from openai import OpenAI

client = OpenAI()

with client.responses.stream(
    model="gpt-5",
    input="Write a haiku about Python decorators.",
) as stream:
    for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)
        elif event.type == "response.error":
            print(f"\n[error] {event.error}")
            break
        elif event.type == "response.completed":
            print("\n[done]")

    final = stream.get_final_response()
    print(f"\nTokens: {final.usage.output_tokens}")

Několik úskalí, na která jsme narazili při testování: kontextový manažer streamu automaticky zpracovává čištění připojení, takže ho nezavírejte ručně. Pokud chcete async, vyměňte OpenAI() za AsyncOpenAI() a použijte async with plus async for, stejné názvy událostí, stejný tvar.

Vestavěné nástroje: Web Search, File Search, Code Interpreter, Computer Use, Image Generation

Responses API dodává pět vestavěných nástrojů: web_search pro live vyhledávání na internetu, file_search pro retrieval z vector store, code_interpreter pro sandboxované provádění Pythonu, computer_use pro automatizaci prohlížeče/desktopu a image_generation pro inline generování obrázků. Povolte kterýkoli z nich přidáním {"type": "<tool_name>"} do pole tools.

Zde je matice, kterou máme připnutou vedle editoru:

Když jsme benchmarkovali web_search v naší pipeline, latence přidala 1,5–3 s při prvním volání, ale pro opakování byla cachována, počítejte s tím v UI. Příklad webového vyhledávání v OpenAI Cookbook je nejčistší referencí, pokud chcete jít do hloubky.

Web Search

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    tools=[{"type": "web_search"}],
    input="What did OpenAI announce at DevDay 2025? Cite your sources.",
)

print(response.output_text)

# Inspect the web_search_call items in response.output for raw search hits
for item in response.output:
    if item.type == "web_search_call":
        print(f"[searched] {item.query}")

File Search

Vyhledávání souborů je dvoukrokový tanec: vytvořte vector store, nahrajte své soubory a poté odkazujte na ID store v poli tools.

from openai import OpenAI

client = OpenAI()

# 1. Create a vector store + upload a file
store = client.vector_stores.create(name="company-handbook")
client.vector_stores.files.upload_and_poll(
    vector_store_id=store.id,
    file=open("handbook.pdf", "rb"),
)

# 2. Use it in a Responses call
response = client.responses.create(
    model="gpt-5",
    input="What's our PTO policy?",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [store.id],
    }],
)
print(response.output_text)

Code Interpreter

Potřebujete, aby model spustil Python na CSV a něco vykreslil? code_interpreter to udělá v sandboxovaném kontejneru.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Read sales.csv and plot monthly revenue as a bar chart. Return a summary.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
)
print(response.output_text)

Kontejner přetrvává mezi voláními ve stejné relaci, což je užitečné, když chcete, aby model pokračoval v iteraci nad dataframe.

Computer Use

V dubnu 2026 stále v preview. Model dostane virtuální prohlížeč/desktop a kliká kolem, aby dokončil úkoly. Přeskočte to, pokud nemáte specifický use case automatizace prohlížeče, který svět Playwright/Selenium již nedokáže vyřešit.

Image Generation

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Generate a diagram showing a CI/CD pipeline with build, test, and deploy stages.",
    tools=[{"type": "image_generation"}],
)

# Image bytes live in image_generation_call items
for item in response.output:
    if item.type == "image_generation_call":
        with open("pipeline.png", "wb") as f:
            f.write(item.result)

Volání funkcí s vlastními nástroji

Volání funkcí v Responses API umožňuje modelu vyvolat vaše vlastní Python funkce. Definujte každou funkci jako JSON schéma v poli tools, proveďte volání, zkontrolujte response.output na položky function_call, spusťte funkci a předejte výsledek zpět prostřednictvím function_call_output.

Responses API mění volání funkcí ze 4-krokového tance na jediný round-trip, když necháte agentní smyčku, aby to zařídila za vás. Zde je kompletní příklad převodu měny:

import json
from openai import OpenAI

client = OpenAI()

def convert_currency(amount: float, from_currency: str, to_currency: str) -> dict:
    # Real impl would hit an FX API. Stubbed for the example.
    rate = 1.08 if (from_currency, to_currency) == ("USD", "EUR") else 1.0
    return {"amount": amount * rate, "currency": to_currency}

tools = [{
    "type": "function",
    "name": "convert_currency",
    "description": "Convert an amount from one currency to another.",
    "parameters": {
        "type": "object",
        "properties": {
            "amount": {"type": "number"},
            "from_currency": {"type": "string"},
            "to_currency": {"type": "string"},
        },
        "required": ["amount", "from_currency", "to_currency"],
    },
}]

# Turn 1: model decides to call our function
first = client.responses.create(
    model="gpt-5",
    input="How much is 250 USD in EUR?",
    tools=tools,
)

# Find the function_call item, run it, send the result back
for item in first.output:
    if item.type == "function_call" and item.name == "convert_currency":
        args = json.loads(item.arguments)
        result = convert_currency(**args)

        second = client.responses.create(
            model="gpt-5",
            previous_response_id=first.id,
            input=[{
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(result),
            }],
            tools=tools,
        )
        print(second.output_text)

To je celá smyčka. Pokud jste s tímto vzorem noví, náš příspěvek základy volání funkcí prochází koncepčním modelem a udržujeme souhrn knihoven pro volání funkcí, pokud nechcete ručně tvořit schémata. Parametr tool_choice (nastaven na "auto", "required" nebo konkrétní název nástroje) je vaší pákou pro vynucení nebo zakázání volání nástroje, když potřebujete determinismus.

Strukturované výstupy (JSON Schema a Pydantic)

Strukturované výstupy zaručují, že model vrátí JSON odpovídající vašemu schématu. Předejte parametr response_format={"type": "json_schema", "json_schema": {...}} nebo, s Python SDK, mu přímo předejte Pydantic model prostřednictvím client.responses.parse(). Model je omezen v době dekódování, nejen promptem.

from openai import OpenAI
from pydantic import BaseModel

client = OpenAI()

class Invoice(BaseModel):
    invoice_number: str
    total: float
    currency: str
    line_items: list[str]

response = client.responses.parse(
    model="gpt-5",
    input="Extract: Invoice #INV-2024-001 for $1,250.00 USD. Items: hosting, support, SSL cert.",
    text_format=Invoice,
)

invoice: Invoice = response.output_parsed
print(invoice.invoice_number, invoice.total, invoice.line_items)

Cesta přes Pydantic je ta, kterou chcete v 95 % případů, type-safe, méně boilerplate a vaše IDE doplňuje výsledek. Raw JSON schéma použijte pouze tehdy, když potřebujete sdílení schémat napříč jazyky nebo když je schéma generováno dynamicky. Do hloubky se zabýváme kompromisy v naší příručce strukturované výstupy a JSON schema a našem primeru Pydantic pro type-safe schémata.

Správa stavu: previous_response_id, Conversations API a store=true

Použijte previous_response_id pro lehký vícekolový kontext, Conversations API pro spolehlivé session s thready nebo posílejte plnou historii zpráv pro plnou kontrolu na straně klienta. previous_response_id vyžaduje store: true a přetrvává pouze pro cachované odpovědi; fallbackněte na plnou historii, pokud je ID neřešitelné.

Zde je dvoukolový příklad používající previous_response_id:

from openai import OpenAI

client = OpenAI()

# Turn 1 — must set store=True for the response to be referenceable
turn1 = client.responses.create(
    model="gpt-5",
    input="My name is Mert and I'm building a weather agent.",
    store=True,
)

# Turn 2 — reference turn 1 by ID; the model "remembers" the name
turn2 = client.responses.create(
    model="gpt-5",
    previous_response_id=turn1.id,
    input="What was my name again?",
    store=True,
)

print(turn2.output_text)  # "Your name is Mert..."

Pokud zapomenete store: true, vaše previous_response_id se nepřeloží na nic a model začíná každý krok studený. Spálili jsme hodinu laděním tohoto problému, API nechybuje, jen vás tiše amnezicky ignoruje. Výchozí retence je 30 dní; pokud potřebujete déle, přejděte na Conversations API, které vám dává explicitní kontrolu životního cyklu threadů.

Kdy byste měli upgradovat na Conversations API? Když máte více uživatelů v jedné appce, když thready přežívají jednu session nebo když chcete server-side editaci/větvení zpráv. Pro rychlý chatbot je previous_response_id zcela dostačující.

Jak migrovat z Chat Completions na Responses API

Migrace z Chat Completions na Responses API zabere tři kroky: změňte /v1/chat/completions na /v1/responses, nahraďte messages za input a nahraďte schémata tools novým formátem. Volání funkcí a multimodální vstupy vyžadují mírně odlišné zacházení. OpenAI dodává oficiální migration pack na GitHubu.

Krok 1 — Záměna endpointu:

# Before (Chat Completions)
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "Hello"}],
)
text = response.choices[0].message.content

# After (Responses)
response = client.responses.create(
    model="gpt-5",
    input="Hello",
)
text = response.output_text

Krok 2 — Přejmenování messages → input:

# Before
client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Summarize this PDF."},
    ],
)

# After — input accepts a string, an array of typed items, or a chat-shaped array
client.responses.create(
    model="gpt-5",
    instructions="You are a helpful assistant.",   # system → instructions
    input="Summarize this PDF.",
)

Krok 3 — Aktualizace schémat nástrojů:

# Before (Chat Completions tool format)
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather",
        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
    },
}]

# After (Responses tool format — flatter, no nested "function" key)
tools = [{
    "type": "function",
    "name": "get_weather",
    "description": "Get current weather",
    "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
}]

To je vše. Postupně přepínejte traffic s feature flagem, nechte svou cestu kódu Chat Completions běžet za stejným rozhraním týden nebo dva, logujte oba tvary odpovědí side-by-side a přepněte na 100 % až po ověření parity. Migration pack v repozitáři openai-cookbook má úplnější adapter pattern, pokud chcete referenci.

Jak používat MCP a vzdálené MCP servery s Responses API

Responses API podporuje vzdálené MCP (Model Context Protocol) servery jako typ nástroje. Přidejte položku jako {"type": "mcp", "server_url": "https://mcp.example.com", "server_label": "..."} do pole tools. Model objeví katalog nástrojů MCP serveru a zavolá je jako vestavěné nástroje.

Pokud jste se MCP nikdy nedotkli, zde je 30sekundový pitch: je to otevřený protokol, který umožňuje jakékoli službě vystavit své API jako katalog nástrojů, které může model volat. Shopify, Stripe, GitHub a rostoucí seznam vendorů provozuje veřejné MCP endpointy. Naše deep-dive Model Context Protocol (MCP) pokrývá samotný protokol.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Find me the top-ranking competitor for 'openai responses api tutorial' and summarize their content gaps.",
    tools=[{
        "type": "mcp",
        "server_url": "https://mcp.semrush.com",
        "server_label": "semrush",
        "require_approval": "never",   # set to "always" in production
    }],
)
print(response.output_text)

Zacházejte s MCP servery jako s jakýmkoli third-party API. require_approval: "never" je v pořádku pro prototypy; v produkci chcete "always" (nebo allowlist nástrojů), aby kompromitovaný MCP server nemohl tiše exfiltrovat data. Před nasměrováním agenta na server zkontrolujte jeho katalog nástrojů.

Ceny, rate limity a produkční úskalí

Ceny Responses API odpovídají Chat Completions u nákladů na tokeny (prompt + completion), s příplatky za volání u vestavěných nástrojů (web_search, file_search). Rate limity následují vaši existující tier OpenAI. Běžná produkční úskalí zahrnují výchozí hodnoty retence store: true, přechodné 429 při burst traffic a zpoždění funkcí u Azure varianty.

Ceny se mění, vždy ověřte na stránce cen OpenAI v době psaní.

Pro zpracování chyb zabalte volání do try/except openai.RateLimitError a try/except openai.APIStatusError s exponenciálním backoffem přes tenacity:

from openai import OpenAI, RateLimitError, APIStatusError
from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_exponential

client = OpenAI()

@retry(
    retry=retry_if_exception_type((RateLimitError, APIStatusError)),
    wait=wait_exponential(multiplier=1, min=2, max=30),
    stop=stop_after_attempt(5),
    reraise=True,
)
def safe_create(prompt: str):
    return client.responses.create(model="gpt-5", input=prompt)

print(safe_create("Hello").output_text)

Narazili jsme na přechodnou 429 při burstu 20 paralelních requestů v našem staging env, tenacity s exponenciálním backoffem to čistě vyřešil. Error string, který jsme logovali, byl openai.RateLimitError: Error code: 429 - {'error': {'message': 'Rate limit reached for gpt-5 in organization org-... on requests per min (RPM)'}}. Přečtěte si to jednou a pokračujte; retry decorator zařídí zbytek.

Poznámka k Azure variantě: Azure OpenAI vystavuje Responses API, ale za rollouty řízenými Samem Altmanem zpožďuje o 4–8 týdnů. Od dubna 2026 je podpora MCP na Azure pouze v preview, potvrďte proti dokumentaci Azure OpenAI Responses API na Microsoft Learn před nasazením.

Kompatibilita brány: pokud proxyjujete OpenAI přes LiteLLM proxy, podpora Responses API dorazila v roce 2026. Většina ostatních bran dohání. A pro produkční rollouty budete chtít mít zapojenou AI observabilitu a logging před přepnutím trafficu, události Responses API jsou bohatší než Chat Completions a budete chtít každé volání nástroje logovat.

Kdy NEpoužívat Responses API

Vynechejte Responses API pro low-latency realtime audio (použijte Realtime API), generování embeddings (použijte Embeddings API) a workflows fine-tuning. Zůstaňte u Chat Completions, pokud vaše brána/proxy ještě nepodporuje Responses (většina ano přes LiteLLM od roku 2026).

Několik dalších upřímných diskvalifikátorů:

• Realtime voice agenti, Realtime API používá WebSockets a je built pro sub-sekundové střídání. Streaming Responses API je HTTP SSE; pro hlas bude působit pomalu.
• Čisté pipelines embeddings, client.embeddings.create() je levnější, rychlejší a to, co očekává každá integrace vektorové DB.
• Fine-tuning, trénujete a nasazujete fine-tunes přes fine-tuning API; můžete je pak volat přes Responses, ale samotné trénování není workflow Responses.
• Batch API jobs, pokud zpracováváte milion promptů přes noc s 50 % slevou, Batch API stále vítězí cenou.
• Uzamčená semantika Chat Completions, pokud vaše eval použití, observabilita a knihovna promptů všechny předpokládají chat.completions.choices[0].message.content, náklady na migraci jsou reálné. Nemigrujte jen proto, že je to novější.

Pokud je váš stack spokojený s Chat Completions a nestavíte agenty, migrace není zdarma, váš Q2 sprint to možná nepotřebuje. Novější neznamená lepší-pro-vás, Responses API je správný primitiv pro agenty, ne pro každou workload OpenAI.

Často kladené otázky

Co je OpenAI Responses API?

OpenAI Responses API je sjednocený primitiv spuštěný v březnu 2025, který kombinuje jednoduchost Chat Completions s využitím nástrojů z Assistants API. Podporuje textový a obrazový vstup, pět vestavěných nástrojů, volání funkcí, strukturované výstupy, streaming a stavové konverzace prostřednictvím previous_response_id.

Kdy bylo OpenAI Responses API vydáno?

OpenAI oznámilo Responses API 11. března 2025 spolu s širším oznámením „nové nástroje pro budování agentů“. API je obecně dostupné od spuštění, přičemž Conversations API, podpora MCP a nástroj image_generation byly přidávány v inkrementálních aktualizacích během roku 2025 a začátku roku 2026.

Je OpenAI Responses API stavové?

Ano, volitelně. Předejte previous_response_id plus store: true a model nese kontext mezi voláními bez toho, abyste posílali plnou historii. Pro dlouho žijící thready vám Conversations API dává explicitní správu životního cyklu threadů. Můžete také zůstav stateless a posílat plnou historii každý krok, jako u Chat Completions.

Jaký je rozdíl mezi Responses API a Chat Completions?

Responses API je nadmnožinou Chat Completions. Každá funkce Chat Completions funguje v Responses, plus vestavěné nástroje (web_search, file_search atd.), stavovost přes previous_response_id a agentní smyčka jako prvotřídní koncept. OpenAI doporučuje Responses pro všechny nové projekty od roku 2026.

Je Chat Completions API deprecated?

Ne. Od dubna 2026 není Chat Completions deprecated, zůstává plně podporován. OpenAI doporučuje Responses pro nové projekty a většina tutoriálů ve stylu agentů předpokládá Responses. Chat Completions je nyní legacy primitiv: stabilní, ale již ne tam, kde nové funkce přicházejí jako první.

Které modely OpenAI podporují Responses API?

GPT-5, gpt-5-mini, gpt-4.1 a reasoning modely o-series všechny podporují Responses API. O-series přidává parametr reasoning_effort (low, medium, high) pro workloads s rozšířeným uvažováním. Generování obrázků routuje pod kapotou přes gpt-image-1, když povolíte nástroj image_generation.

Jak migrovat z Chat Completions na Responses API?

Tři kroky: přepněte client.chat.completions.create() na client.responses.create(), nahraďte pole messages za input (a přesuňte systémové prompty do instructions) a zploštěte svá schémata nástrojů (odstraňte vnořený klíč function). Migration pack OpenAI na GitHubu má kompletní příklady adapterů.

Podporuje Responses API streaming?

Ano. Předejte stream=True do client.responses.create() (nebo použijte client.responses.stream() jako kontextový manažer) a iterujte typované Server-Sent Events. Události token-streamu, které budete zpracovávat, jsou response.output_text.delta pro obsah a response.completed pro finální payload. Async streaming funguje přes AsyncOpenAI.

Mohu používat Responses API na Azure?

Ano. Azure OpenAI vystavuje Responses API, ale parita funkcí zpožďuje přímé rollouty OpenAI o 4–8 týdnů. Od dubna 2026 je podpora MCP na Azure v preview. Před nasazením do produkce zkontrolujte Microsoft Learn pro aktuální Azure-specifické zvláštnosti.

Funguje Responses API s MCP servery?

Ano, vzdálené MCP (Model Context Protocol) servery jsou prvotřídní typ nástroje. Přidejte {"type": "mcp", "server_url": "...", "server_label": "..."} do svého pole tools a model objeví a zavolá katalog nástrojů serveru jako jakýkoli vestavěný nástroj. Pro bezpečnost v produkci použijte require_approval: "always".

Závěr

Nyní máte kompletní obraz Responses API: jak se liší od Chat Completions, jak odeslat své první volání, jak zapojit vestavěné nástroje a jak migrovat existující projekt Chat Completions ve třech krocích. Několik poznatků, na které se zaměřit:

• Nejprve stavte, pak optimalizujte. Začněte příkladem hello-world, přidejte vestavěný nástroj, poté vrstvěte stav s previous_response_id.
• Migrujte postupně. Použijte feature flag, logujte oba tvary odpovědí, přepněte na 100 % až po ověření parity.
• Nasaďte MCP integrace. To je hranice roku 2026, většina vendorů závodí ve vystavování MCP endpointů a Responses API je nejčistší způsob, jak je konzumovat.

V Techsy pomáháme týmům nasazovat produkčně grade integrace OpenAI, včetně rolloutů Responses API a migrací z Chat Completions. Získejte bezplatnou konzultaci.

Tým editorů Techsy, production engineerové nasazující integrace OpenAI od roku 2024. Poslední aktualizace: 25. dubna 2026.