Izsaukumi paralēli un secīgi
Šajā lapā
Izsaukumi paralēli un secīgi
Modelis vienā atbildē var ģenerēt vairākus funkciju izsaukumus, to darot automātiski, tiklīdz tas identificē neatkarīgas vajadzības. Tas nav tikai kosmētisks uzlabojums: trīs divu sekunžu ilgi izsaukumi, kas veikti vienlaicīgi, kopā aizņem divas sekundes, bet virknēti secīgi tie prasīs sešas sekundes.
Šīs nodarbības galvenais fokuss nav tas, kā veikt paralēlizpildi – modeli to paveic pats –, bet gan kā atpazīt gadījumus, kad to nevajadzētu darīt. Divi izsaukumi ir neatkarīgi, ja izpildes secība neietekmē rezultātu. Tiklīdz viena operācija nolasīja datus, ko otra raksta, vai ja parametrs ir jāiegūst no iepriekšējā izsaukuma, paralēlisms kļūst par grūti reproducējamu kļūdu.
Paralēlie izsaukumi
Nekas nav jāaktivizē: tā ir noklusējuma uzvedība. Vaicājums par trim pilsētām ģenerēs trīs function_call vienumus vienā atbildē; tev tie jāizpilda. Ņem vērā, ka modelis spriež par funkciju nozīmi, balstoties uz taviem aprakstiem – apraksti virza lēmumu pieņemšanu, tāpat kā gandrīz visā šajā kursā.
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
Paralēlo izsaukumu izpilde klienta pusē
Trīs izsaukumu saņemšana vienlaikus ir bezjēdzīga, ja tavs kods tos izpilda vienu pēc otra: tu zaudē visu ieguvumu klienta pusē. asyncio.gather ir minimums; ražošanas videi pievieno divus piesardzības pasākumus – vienlaicīguma ierobežojumu, lai neatvērtu piecdesmit savienojumus vienlaicīgi ar servisu, kas atbalsta tikai desmit, un kļūdu apstrādi katram izsaukumam atsevišķi, lai izolēta kļūda neiznīcinātu pārējos rezultātus.
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)
Paralēlo izsaukumu atspējošana
parallel_tool_calls=False piespiež modeli ģenerēt tikai vienu izsaukumu vienā atbildē. Izmanto šo iestatījumu apzināti: tas upurē latentumu drošības labā. Rezervē to funkcijām, kas raksta datus, veic izmaiņas vai aktivizē kaut ko ārējā vidē.
response = client.responses.create(
model="gpt-5.6-terra",
input="Process these three orders",
tools=tools,
parallel_tool_calls=False # One call per response
)
Gadījumi, kad paralēlisms ir jāatspējo:
- Operācijas, kas jāizpilda noteiktā secībā
- Funkcijas ar blakusparādībām, kas traucē cita citai
- Situācijas, kad viena izsaukuma rezultāts nosaka nākamo soli
Secīgi izsaukumi, izmantojot ciklu
Secīga izpilde netiek kontrolēta ar parametru: tā izriet no cikla. Tu izpildi izsaukumu, nosūti atpakaļ rezultātu, un modelis, balstoties uz tikko iegūto informāciju, lemj par nākamo soli. Tieši tas atšķir dinamisku ķēdi no stingra plāna – ja 2. solis atklāj, ka 3. solis nav nepieciešams, modelis to neizsauks.
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"
Praktisks piemērs: apstrādes konveijers
Tipisks gadījums, kur secīga izpilde ir obligāta, jo katrs solis patērē iepriekšējā solī iegūto:
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
)
Hibrīda modelis: vispirms paralēli, tad secīgi
Praksē lielākā daļa reālu darba plūsmu seko šim jauktajam modelim: datu vākšanas fāze, kur viss var notikt vienlaicīgi, kam seko apstrādes fāze, kas ievēro atkarības. Tev nav jākodē nekas īpašs – tas ir dabiskais cikla rezultāts, ja tavi apraksti skaidri norāda uz atkarībām.
# 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 modelis šķiet dabisks: modelis automātiski veic paralēlizpildi, kad izsaukumi ir neatkarīgi, un pāriet uz secīgu ķēdi, tiklīdz parādās atkarība.
Galvenās atziņas
- Modelis automātiski veic neatkarīgu izsaukumu paralēlizpildi
- Izmanto
asyncio.gather, lai klienta pusē izpildītu paralēlos izsaukumus - Atspējo ar
parallel_tool_calls=False, ja secībai ir nozīme - Ievies ciklu daudzsoļu darba plūsmām
- Funkciju apraksti norāda modelim uz atkarībām starp soļiem