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

Volání paralelní a sekvenční

Lekce 3 z 20 Vývojář
Na této stránce
  1. Volání paralelní a sekvenční
  2. Paralelní volání
  3. Zakázání paralelních volání
  4. Sekvenční volání pomocí smyčky
  5. Praktický příklad: Zpracovatelský pipeline
  6. Hybridní vzor: Nejprve paralelně, pak sekvenčně
  7. Klíčové poznatky

Volání paralelní a sekvenční

Model umí v jedné odpovědi vygenerovat více volání funkcí najednou. Dělá to automaticky pokaždé, když rozpozná nezávislé potřeby. Není to jen kosmetická optimalizace: tři dvousekundová volání spuštěná společně trvají celkem dvě sekundy, zatímco řazená za sebou by zabrala šest.

Skutečným těžištěm této lekce není to, jak paralelizovat – to zvládá model sám – ale jak rozpoznat případy, kdy to dělat nemáš. Dvě volání jsou nezávislá, pokud pořadí jejich provedení neovlivní výsledek. Jakmile jedna operace čte data, která jiná zapisuje, nebo když parametr musí vzejít z předchozího volání, stává se paralelismus těžko reprodukovatelnou chybou.

Paralelní volání

Nic není třeba povolovat: toto je výchozí chování. Dotaz týkající se tří měst vygeneruje tři položky function_call v téže odpovědi; ty je pak provedeš. Všimni si, že model uvažuje o významu funkcí na základě tvých popisů – právě popisy řídí toto rozhodnutí, stejně jako téměř vše ostatní v tomto kurzu.

from openai import OpenAI
import json
import asyncio

client = OpenAI()

tools = [
    {
        "type": "function",
        "name": "get_meteo",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {
                "ville": {"type": "string"}
            },
            "required": ["ville"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "get_taux_change",
        "description": "Get exchange rate between two currencies",
        "parameters": {
            "type": "object",
            "properties": {
                "source": {"type": "string"},
                "cible": {"type": "string"}
            },
            "required": ["source", "cible"],
            "additionalProperties": False
        },
        "strict": True
    }
]

response = client.responses.create(
    model="gpt-5.6-terra",
    input="What's the weather in Paris and Berlin, "
          "and what is the EUR/USD exchange rate?",
    tools=tools
)

# The model emits 3 calls in parallel
appels = [item for item in response.output if item.type == "function_call"]
print(f"Nombre d'appels : {len(appels)}")
# => Nombre d'appels : 3

Provedení paralelních volání na straně klienta

Přijmout tři volání najednou je k ničemu, pokud je tvůj kód provádí jedno po druhém: na straně klienta tím ztratíš veškerý zisk. asyncio.gather je minimum; pro produkční prostředí přidej dvě bezpečnostní opatření – limit souběžnosti, abys neotevřel padesát současných připojení ke službě, která jich podporuje jen deset, a zpracování chyb pro každé volání zvlášť, aby izolovaný výpadek nesrazil ostatní výsledky.

async def executer_fonction(name: str, arguments: str) -> dict:
    args = json.loads(arguments)
    if name == "get_meteo":
        return await api_meteo(args["ville"])
    elif name == "get_taux_change":
        return await api_change(args["source"], args["cible"])

async def traiter_appels_paralleles(appels):
    taches = [
        executer_fonction(appel.name, appel.arguments)
        for appel in appels
    ]
    resultats = await asyncio.gather(*taches)

    return [
        {
            "type": "function_call_output",
            "call_id": appel.call_id,
            "output": json.dumps(resultat)
        }
        for appel, resultat in zip(appels, resultats)
    ]

# Execute
resultats = asyncio.run(traiter_appels_paralleles(appels))

# Send back to the model
response_finale = client.responses.create(
    model="gpt-5.6-terra",
    input=response.output + resultats,
    tools=tools
)
print(response_finale.output_text)

Zakázání paralelních volání

Nastavení parallel_tool_calls=False donutí model generovat v každé odpovědi pouze jedno volání. Toto nastavení používej uvážlivě: vyměňuješ latenci za bezpečnost. Vyhraď si ho pro funkce, které zapisují data, něco upravují nebo spouštějí vnější akce.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Process these three orders",
    tools=tools,
    parallel_tool_calls=False  # One call per response
)

Příklady použití, kdy paralelismus vypnout:

  • Operace, které musí proběhnout v přesném pořadí
  • Funkce s vedlejšími účinky, které se navzájem ruší
  • Situace, kdy výsledek jednoho volání podmiňuje další

Sekvenční volání pomocí smyčky

Sekvenční provádění není řízeno parametrem: vyplývá přímo ze smyčky. Provedeš volání, odešleš výsledek zpět a model se na základě právě získaných informací rozhodne pro další krok. Přesně to odlišuje dynamický řetězec od strnulého plánu – pokud krok 2 odhalí, že krok 3 není nutný, model ho neprovede.

def boucle_function_calling(prompt: str, tools: list, max_tours: int = 10):
    """Complete loop for sequential function calling."""
    messages_input = prompt
    tour = 0

    while tour < max_tours:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=messages_input,
            tools=tools,
            parallel_tool_calls=False
        )

        # Check for function calls
        appels = [i for i in response.output if i.type == "function_call"]

        if not appels:
            # Model is done, responding with text
            return response.output_text

        # Execute each call
        resultats = []
        for appel in appels:
            resultat = executer_fonction_sync(appel.name, appel.arguments)
            resultats.append({
                "type": "function_call_output",
                "call_id": appel.call_id,
                "output": json.dumps(resultat)
            })

        # Prepare next turn
        messages_input = response.output + resultats
        tour += 1

    return "Turn limit reached"

Praktický příklad: Zpracovatelský pipeline

Typický případ, kdy je sekvenční provádění nezbytné, protože každý krok spotřebovává výstup toho předchozího:

tools_pipeline = [
    {
        "type": "function",
        "name": "valider_commande",
        "description": "Verify order validity (stock, price, customer)",
        "parameters": {
            "type": "object",
            "properties": {
                "commande_id": {"type": "string"}
            },
            "required": ["commande_id"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "calculer_livraison",
        "description": "Calculate shipping fees and delays. "
                       "Requires a validated order.",
        "parameters": {
            "type": "object",
            "properties": {
                "commande_id": {"type": "string"},
                "mode": {"type": "string", "enum": ["standard", "express"]}
            },
            "required": ["commande_id", "mode"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "confirmer_commande",
        "description": "Confirm the order and trigger payment. "
                       "Requires prior validation and shipping calculation.",
        "parameters": {
            "type": "object",
            "properties": {
                "commande_id": {"type": "string"},
                "livraison_id": {"type": "string"}
            },
            "required": ["commande_id", "livraison_id"],
            "additionalProperties": False
        },
        "strict": True
    }
]

# The model will naturally call in this order:
# 1. valider_commande
# 2. calculer_livraison (using step 1 result)
# 3. confirmer_commande (using results from steps 1 and 2)
resultat = boucle_function_calling(
    "Process order CMD-42567 with express shipping",
    tools_pipeline
)

Hybridní vzor: Nejprve paralelně, pak sekvenčně

V praxi většina reálných pracovních postupů následuje tento smíšený vzor: fáze sběru dat, kde může vše běžet současně, následovaná fází zpracování, která respektuje závislosti. Nemusíš kódovat nic speciálního – je to přirozený důsledek smyčky, za předpokladu, že tvé popisy jasně definují závislosti.

# Turn 1: Parallel data collection
# The model calls get_client AND get_stock in parallel

# Turn 2: Sequential decision based on results
# The model calls valider_commande with collected info

# Turn 3: Final action
# The model calls confirmer_commande

Tento vzor působí přirozeně: model automaticky paralelizuje, když jsou volání nezávislá, a řadí je sekvenčně, jakmile se objeví závislost.

Klíčové poznatky

  • Model automaticky paralelizuje nezávislá volání
  • K provedení paralelních volání na straně klienta použij asyncio.gather
  • Pokud záleží na pořadí, zakaž paralelismus pomocí parallel_tool_calls=False
  • Pro vícekrokové pracovní postupy implementuj smyčku
  • Popisy funkcí vedou model k pochopení závislostí mezi jednotlivými kroky