Volania paralelné a sekvenčné
Na tejto strane
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