Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Architektura volání funkcí v Responses API

Lekce 1 z 20 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Architektura volání funkcí v Responses API
  2. Základní princip
  3. Anatomie odpovědi
  4. Kompletní smyčka
  5. Klíčové rozdíly oproti Chat Completions
  6. Kdy model zavolá funkci?
  7. Klíčové poznatky

Aktualizováno 2. listopadu 2026 na základě dokumentace OpenAI: nástroj Code Interpreter nyní vyžaduje parametr container (přidán do všech příkladů), textové části vstupu používají typ input_text a webové vyhledávání využívá nástroj web_search (web_search_preview je nyní zastaralý nástroj bez filtrů domén). Vygenerované soubory se získávají pomocí funkcí fichiers_generes a telecharger z Lekce 10. Zdroje: Code Interpreter · Web search.

Architektura volání funkcí v Responses API

Volání funkcí je klíčový mechanismus, který umožňuje modelům OpenAI komunikovat s vnějším světem. V Responses API byl tento mechanismus přepracován tak, aby byl robustnější, předvídatelnější a nativně integrovaný se vestavěnými nástroji, jako jsou Webové vyhledávání a Code Interpreter.

Základní princip

Model nikdy nic neprovádí přímo. Vysílá strukturované záměry, které tvůj kód zachytí a provede. Může to znít jako technické omezení, ale ve skutečnosti jde o designové rozhodnutí, které umožňuje vše ostatní.

Zvaž alternativu. Pokud by model akce prováděl sám, musel bys mu předat přihlašovací údaje k databázi, API klíče a práva k zápisu – a neměl bys žádný bod, kde bys cokoli ověřil. Díky oddělení prochází každý záměr tvým kódem: validuješ argumenty, vynucuješ obchodní pravidla a v případě potřeby akci odmítneš. Model navrhuje, tvůj kód rozhoduje a právě tato hranice ti umožňuje nasadit volání funkcí do produkce bez ztráty kontroly.

from openai import OpenAI

client = OpenAI()

# Deklarace vlastního nástroje
tools = [{
    "type": "function",
    "name": "rechercher_client",
    "description": "Search for a client in the CRM by name or email",
    "parameters": {
        "type": "object",
        "properties": {
            "terme": {
                "type": "string",
                "description": "Client name, email, or ID"
            },
            "champ": {
                "type": "string",
                "enum": ["nom", "email", "id"],
                "description": "Field to search in"
            }
        },
        "required": ["terme"]
    }
}]

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Find the client Jean Dupont",
    tools=tools
)

Anatomie odpovědi

Odpověď neobsahuje buď text, nebo volání nástrojů: output je heterogenní seznam, který může obsahovat obojí. Zvyk, který si musíš vypěstovat od prvního řádku kódu, je iterovat přes tento seznam, místo abys četl pouze output[0]. Model, který před voláním funkce vysvětlí své uvažování, přesně tento případ produkuje, a kód, který čte pouze první prvek, se rozbije ve chvíli, kdy začne přidávat komentáře.

for item in response.output:
    if item.type == "function_call":
        print(f"Call ID  : {item.call_id}")
        print(f"Function : {item.name}")
        print(f"Args     : {item.arguments}")

call_id je zásadní: propojuje volání s jeho výsledkem, když odešleš odpověď zpět modelu. U jediného volání si toho sotva všimneš; u tří paralelních volání je to jediná věc, která ti zabrání připsat počasí v Lyonu k požadavku týkajícímu se Marseille. Výsledek vždy vrať s call_id, které jsi obdržel, nikdy s ID, které si rekonstruuješ na své straně.

Kompletní smyčka

Tento čtyřkrokový cyklus je neměnný: platí pro jednu funkci i pro dvacet, pro jednoduché volání i pro agenta řetězícího deset nástrojů. Veškerá složitost, se kterou se později setkáš – paralelismus, chyby, záložní řešení – spočívá v instrumentaci této smyčky, nikdy v její náhradě.

import json

# 1. První volání s deklarovanými nástroji
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What is the balance for client [email protected]?",
    tools=tools
)

# 2. Detekce a provedení volání funkcí
resultats = []
for item in response.output:
    if item.type == "function_call":
        if item.name == "rechercher_client":
            args = json.loads(item.arguments)
            resultat = votre_crm.rechercher(args["terme"])
            resultats.append({
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(resultat)
            })

# 3. Odeslání výsledků zpět modelu
response_finale = client.responses.create(
    model="gpt-5.6-terra",
    input=response.output + resultats,
    tools=tools
)

# 4. Model formuluje svou přirozenou odpověď
print(response_finale.output_text)

Klíčové rozdíly oproti Chat Completions

Responses API přináší několik architektonických vylepšení.

Nativní zpracování vestavěných nástrojů

Vestavěné nástroje se deklarují přesně jako tvé funkce, ale provádějí se na straně OpenAI. Praktickým důsledkem je příjemná skutečnost: pro ně nemusíš psát žádnou smyčku. Model zavolá funkci, získá výsledek a pokračuje, vše v jediném kole. Výše popsaná smyčka se týká pouze tvých funkcí – těch, které běží na tvém stroji.

# Mix vestavěných a vlastních nástrojů
tools = [
    {"type": "web_search"},
    {"type": "code_interpreter", "container": {"type": "auto"}},
    {
        "type": "function",
        "name": "ma_fonction",
        "description": "My custom function",
        "parameters": {"type": "object", "properties": {}}
    }
]

Stabilní identifikátory volání

Každé volání funkce obdrží jedinečné call_id, které ti umožní přesně vysledovat, který výsledek odpovídá kterému volání, a to i při paralelních voláních.

Zjednodušený tok

Není třeba ručně spravovat role assistant a tool ve zprávách. Pole input přímo přijímá zřetězení předchozích výstupů s výsledky funkcí.

Kdy model zavolá funkci?

Model se rozhodne zavolat funkci, když uživatelův požadavek vyžaduje informace, které nemá, když popis funkce odpovídá identifikované potřebě a když lze požadované parametry odvodit z kontextu.

Musí být tedy současně splněny tři podmínky, což je užitečné pro ladění: když se funkce nezavolá, přestože by měla, příčina je téměř vždy v té druhé – v popisu, který nepokrývá způsob, jakým uživatel svůj požadavek formuloval. Parametr tool_choice ti umožňuje vynutit chování, když popis nestačí:

# Nechat rozhodnutí na modelu
tool_choice = "auto"

# Vynutit volání konkrétní funkce
tool_choice = {"type": "function", "name": "rechercher_client"}

# Zakázat všechna volání funkcí
tool_choice = "none"

# Vyžadovat alespoň jedno volání bez určení kterého
tool_choice = "required"

Klíčové poznatky

  • Volání funkcí je protokol záměrů, nikoli protokol provádění
  • Smyčka volání-provedení-návrat je základním vzorem
  • Vestavěné a vlastní nástroje koexistují ve stejném poli tools
  • call_id zajišťuje sledovatelnost pro každé volání
  • tool_choice ti umožňuje jemně řídit chování modelu