Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Volania paralelné a sekvenčné

Lekcia 3 z 20 Vývojár
Na tejto strane
  1. Volania paralelné a sekvenčné
  2. Paralelné volania
  3. Zakázanie paralelných volaní
  4. Sekvenčné volania pomocou slučky
  5. Praktický príklad: Spracovateľský pipeline
  6. Hybridný vzor: Najprv paralelne, potom sekvenčne
  7. Kľúčové poznatky

Volania paralelné a sekvenčné

Model dokáže v jednej odpovedi vygenerovať viacero volaní funkcií. Robí to automaticky vždy, keď identifikuje nezávislé potreby. Nie je to len kozmetická optimalizácia: tri dvojssekundové volania spustené súčasne trvajú dokopy dve sekundy, no ak ich spustíš za sebou postupne, zaberie to šesť sekúnd.

Skutočným cieľom tejto lekcie nie je to, ako paralelizovať – to zvláda model sám – ale ako rozpoznať prípady, keď by si to robiť nemal. Dve volania sú nezávislé vtedy, keď poradie ich vykonania neovplyvní výsledok. Akonáhle jedna operácia číta údaje, ktoré druhá zapisuje, alebo ak parameter musí pochádzať z predchádzajúceho volania, stáva sa paralelizmus chybou, ktorú ťažko reprodukuješ.

Paralelné volania

Nič netreba povoľovať: toto je predvolené správanie. Dopyt týkajúci sa troch miest vygeneruje tri položky function_call v tej istej odpovedi; ty ich následne vykonáš. Všimni si, že model uvažuje o význame funkcií na základe tvojich popisov – práve popisy riadia toto rozhodnutie, rovnako ako takmer všetko v tomto kurze.

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

Vykonávanie paralelných volaní na strane klienta

Prijatie troch volaní naraz je zbytočné, ak ich tvoj kód vykonáva jedno po druhom: stratíš tak celý zisk na strane klienta. asyncio.gather je minimum; pre produkčné prostredie pridaj dve opatrenia – limit súbežnosti, aby si neotvoril päťdesiat simultánnych spojení so službou, ktorá podporuje len desať, a ošetrenie chýb pre každé volanie zvlášť, aby izolovaný výpadok nezničil 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ázanie paralelných volaní

Nastavenie parallel_tool_calls=False prinúti model vygenerovať v jednej odpovedi iba jedno volanie. Toto nastavenie používaj zámerne: vymieňaš latenciu za bezpečnosť. Vyhradzuj ho pre funkcie, ktoré zapisujú údaje, niečo modifikujú alebo spúšťajú externé akcie.

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

Prípady použitia pre zakázanie paralelizmu:

  • Operácie, ktoré sa musia vykonať v konkrétnom poradí
  • Funkcie s vedľajšími účinkami, ktoré sa navzájom rušia
  • Situácie, keď výsledok jedného volania podmieňuje ďalšie

Sekvenčné volania pomocou slučky

Sekvenčné vykonávanie nie je riadené parametrom: vyplýva priamo zo slučky. Vykonáš volanie, pošleš späť výsledok a model sa na základe novo získaných informácií rozhodne pre ďalší krok. Presne to odlišuje dynamický reťazec od rigidného plánu – ak krok 2 odhalí, že krok 3 je zbytočný, model ho nezavolá.

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ý príklad: Spracovateľský pipeline

Typický prípad, kde je sekvenčné vykonávanie povinné, pretože každý krok spotrebúva to, čo vyprodukoval predchádzajúci:

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: Najprv paralelne, potom sekvenčne

V praxi väčšina reálnych pracovných postupov nasleduje tento zmiešaný vzor: fáza zberu dát, kde môže všetko bežať súčasne, po ktorej nasleduje fáza spracovania, ktorá rešpektuje závislosti. Nemusíš kódovať nič špeciálne – je to prirodzený dôsledok slučky za predpokladu, že tvoje popisy jasne 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í prirodzene: model automaticky paralelizuje volania, keď sú nezávislé, a následne ich spája sekvenčne, keď sa objaví závislosť.

Kľúčové poznatky

  • Model automaticky paralelizuje nezávislé volania
  • Na vykonávanie paralelných volaní na strane klienta použi asyncio.gather
  • Zakáž paralelizmus pomocou parallel_tool_calls=False, keď záleží na poradí
  • Implementuj slučku pre viacstupňové pracovné postupy
  • Popisy funkcií usmerňujú model pri identifikácii závislostí medzi krokmi