Kvietimai lygiagrečiai ir nuosekliai
Šiame puslapyje
Kvietimai lygiagrečiai ir nuosekliai
Modelis viename atsakyme gali pateikti kelis funkcijų kvietimus ir tai daro automatiškai, kai nustato nepriklausomus poreikius. Tai ne tik kosmetinis optimizavimas: trys dviejų sekundžių trukmės kvietimai, įvykdyti kartu, užtrunka iš viso dvi sekundes, o vykdomi nuosekliai grandine – šešias.
Šios pamokos esmė ne tai, kaip lygiagretinti – modelis tai tvarko pats – o kaip atpažinti atvejus, kada to daryti negalima. Du kvietimai yra nepriklausomi, kai vykdymo eiliškumas neturi įtakos rezultatui. Kai tik viena operacija skaito tai, ką rašo kita, arba parametras turi būti gautas iš ankstesnio kvietimo, lygiagretumas tampa sunkiai atkuriamu klaidos šaltiniu.
Lygiagretūs kvietimai
Nieko nereikia įjungti: tai yra numatytoji elgsena. Užklausa apie tris miestus tame pačiame atsakyme sugeneruos tris function_call elementus; tau tereikia juos įvykdyti. Atkreipk dėmesį, kad modelis samprotauja apie funkcijų prasmę remdamasis tavo pateiktais aprašymais – būtent aprašymai lemia sprendimą, kaip ir beveik visur šiame kurse.
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
Lygiagrečių kvietimų vykdymas kliento pusėje
Gauti tris kvietimus vienu metu yra beprasmiška, jei tavo kodas juos vykdo vieną po kito: taip prarandi visą naudą kliento pusėje. asyncio.gather yra minimumas; gamybinei aplinkai pridėk dvi atsargumo priemones – lygiagretumo ribą, kad neatidarytum penkiasdešimties simultaninių ryšių su tarnyba, palaikančia tik dešimt, ir kiekvieno kvietimo klaidų apdorojimą, kad pavienis gedimas nenugriautų kitų rezultatų.
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)
Lygiagrečių kvietimų išjungimas
parallel_tool_calls=False priverčia modelį kiekviename atsakyme pateikti tik vieną kvietimą. Naudok šį nustatymą sąmoningai: tai mainai tarp delsos ir saugumo. Palik jį funkcijoms, kurios rašo, modifikuoja arba suaktyvina ką nors išorėje.
response = client.responses.create(
model="gpt-5.6-terra",
input="Process these three orders",
tools=tools,
parallel_tool_calls=False # One call per response
)
Atvejai, kada verta išjungti lygiagretumą:
- Operacijos, kurios turi būti vykdomos griežta eilės tvarka
- Funkcijos su šalutiniais poveikiais, kurie trukdo viena kitai
- Kai vieno kvietimo rezultatas lemia kitą
Nuoseklūs kvietimai naudojant ciklą
Nuoseklus vykdymas valdomas ne parametru: jis išplaukia iš ciklo. Įvykdai kvietimą, grąžini rezultatą, o modelis, remdamasis tuo, ką ką tik sužinojo, nusprendžia, ką daryti toliau. Būtent tai skiria dinaminę grandinę nuo standaus plano – jei antras žingsnis atskleidžia, kad trečias nereikalingas, modelis jo nekvies.
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"
Pavyzdys: apdorojimo grandinė
Tipinis atvejis, kai nuoseklus vykdymas yra privalomas, nes kiekvienas žingsnis sunaudoja tai, ką sukūrė ankstesnis:
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
)
Hibridinis šablonas: pirma lygiagrečiai, paskui nuosekliai
Praktiškai dauguma realių darbo eigų laikosi šio mišraus šablono: duomenų rinkimo fazė, kai viskas gali vykti simultaniškai, o po jos – apdorojimo fazė, gerbianti priklausomybes. Tau nereikia rašyti jokio specialaus kodo – tai natūrali ciklo pasekmė, jei tavo aprašymuose aiškiai įvardytos priklausomybės.
# 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
Šis šablonas atrodo natūralus: modelis automatiškai lygiagretina kvietimus, kai jie nepriklausomi, o atsiradus priklausomybei – juos grandina nuosekliai.
Svarbiausi punktai
- Modelis automatiškai lygiagretina nepriklausomus kvietimus
- Lygiagrečiams kvietimams kliento pusėje vykdyti naudok
asyncio.gather - Išjunk naudodamas
parallel_tool_calls=False, kai svarbi eiliškumas - Daugiažingsnėms darbo eigoms įgyvendink ciklą
- Funkcijų aprašymai nukreipia modelį dėl priklausomybių tarp žingsnių