Klici vzporedno in zaporedno
Na tej strani
Klici vzporedno in zaporedno
Model lahko v enem samem odgovoru izda več klicev funkcij. To stori samodejno, ko prepozna neodvisne potrebe. To ni le kozmetična optimizacija: trije dvosekundni klici, izvedeni hkrati, trajajo skupaj dve sekundi, medtem ko jih zaporedna izvedba podaljša na šest sekund.
Pravi fokus te lekcije ni v tem, kako vzporediti klice – to model opravi sam –, temveč v tem, kako prepoznati primere, ko tega ne smeš storiti. Dva klica sta neodvisna, kadar vrstni red izvedbe ne vpliva na rezultat. Takoj ko ena operacija prebere podatke, ki jih je zapisala druga, ali pa mora parameter izhajati iz prejšnjega klica, postane vzporednost težko ponovljiva napaka.
Vzporedni klici
Ni treba ničesar omogočati: to je privzeto vedenje. Poizvedba o treh mestih vrne tri elemente function_call v istem odgovoru; ti jih nato izvedeš. Upoštevaj, da model razmišlja o pomenu funkcij na podlagi tvojih opisov – opisi poganjajo odločitve, tako kot skoraj vse v tem tečaju.
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
Izvedba vzporednih klicev na strani odjemalca
Prejem treh klicev hkrati je neuporaben, če jih tvoja koda izvrši enega za drugim: na strani odjemalca izgubiš vso pridobljeno prednost. asyncio.gather je minimum; za produkcijsko okolje dodaj še dva previdnostna ukrepa – omejitev sočasnosti, da ne odpreš petdesetih povezav hkrati do storitve, ki podpira le deset, in obravnavo napak za vsak klic posebej, da ena sama izolirana napaka ne poruši ostalih rezultatov.
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)
Onemogočanje vzporednih klicev
Nastavitev parallel_tool_calls=False prisili model, da v vsakem odgovoru izda le en klic. To nastavitev uporabi namerno: zamenjaš latenco za varnost. Rezerviraj jo za funkcije, ki pišejo, spreminjajo ali sprožijo nekaj zunanjega.
response = client.responses.create(
model="gpt-5.6-terra",
input="Process these three orders",
tools=tools,
parallel_tool_calls=False # One call per response
)
Primeri uporabe za onemogočanje vzporednosti:
- Operacije, ki se morajo izvesti v določenem vrstnem redu
- Funkcije s stranskimi učinki, ki si medsebojno nasprotujejo
- Primeri, ko rezultat enega klica določa naslednjega
Zaporedni klici z zanko
Zaporedne izvedbe ne nadzoruje parameter: ta izhaja iz zanke. Klic izvedeš, pošlješ rezultat nazaj in model se na podlagi pravkar pridobljenih informacij odloči za naslednji korak. To je ravno tisto, kar ločuje dinamično verigo od togega načrta – če drugi korak razkrije, da tretji ni potreben, ga model ne bo poklical.
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"
Delovni primer: cevovod za obdelavo
Tipičen primer, kjer je zaporedna izvedba obvezna, saj vsak korak porabi rezultat prejšnjega:
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
)
Hibridni vzorec: najprej vzporedno, nato zaporedno
V praksi večina realnih delovnih tokov sledi temu mešanemu vzorcu: faza zbiranja, kjer lahko vse teče hkrati, ki ji sledi faza obdelave, ki spoštuje odvisnosti. Za to ni treba kodirati ničesar posebnega – to je naravna posledica zanke, pod pogojem, da tvoji opisi jasno opredelijo odvisnosti.
# 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
Ta vzorec deluje naravno: model samodejno vzporedi klice, ko so neodvisni, in jih nato poveže zaporedno, ko se pojavi odvisnost.
Ključne ugotovitve
- Model samodejno vzporedi neodvisne klice
- Za izvedbo vzporednih klicev na strani odjemalca uporabi
asyncio.gather - Onemogoči vzporednost z
parallel_tool_calls=False, ko je vrstni red pomemben - Za večstopenjske delovne tokove implementiraj zanko
- Opisi funkcij usmerjajo model glede odvisnosti med koraki