Volání paralelní a sekvenční
Na této stránce
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