Paralleelsed ja järjestikused väljakutsed
Sellel lehel
Paralleelsed ja järjestikused väljakutsed
Mudel võib ühes vastuses teha mitu funktsioonikutset, tehes seda automaatselt iga kord, kui ta tuvastab sõltumatuid vajadusi. See pole pelgalt kosmeetiline optimeerimine: kolm kahe sekundiga kestvat väljakutset, mis käivitatakse koos, võtavad kokku kaks sekundit, kuid järjestikku aheldatuna kuus sekundit.
Selle tunni tegelik fookus ei ole selles, kuidas paralleelsust rakendada – mudel haldab seda ise –, vaid selles, kuidas tuvastada juhtumeid, kus seda teha ei tohi. Kaks väljakutset on sõltumatud, kui täitmise järjekord tulemust ei mõjuta. Niipea kui üks operatsioon loeb seda, mida teine kirjutab, või kui parameeter peab tulema eelmisest väljakutsest, muutub paralleelsus raskesti reprodutseeritavaks veaks.
Paralleelsed väljakutsed
Midagi ei vaja lubamist: see on vaikimisi käitumine. Päring kolme linna kohta toodab samas vastuses kolm function_call elementi; sina täidad need. Pane tähele, et mudel arutleb funktsioonide tähenduse üle sinu kirjelduste põhjal – kirjeldused juhivad otsust, nagu peaaegu kõiges selles kursuses.
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
Paralleelsete väljakutsete täitmine kliendi poolel
Kolme väljakutse korraga vastuvõtmine on kasutu, kui sinu kood täidab need üksteise järel: kaotad kogu võidu kliendi poolel. asyncio.gather on miinimum; lisa tootmiskeskkonnaks kaks ettevaatusabinõu – samaaegsuse piirang, et mitte avada viiskümmend samaaegset ühendust teenusega, mis toetab vaid kümmet, ja iga väljakutse veahaldus, et üksik tõrge ei tooks kaasa teiste tulemuste nurjumist.
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)
Paralleelsete väljakutsete keelamine
parallel_tool_calls=False sunnib mudelit väljastama ainult ühe väljakutse ühes vastuses. Kasuta seda sätet teadlikult: see vahetab latentsuse ohutuse vastu. Reserveeri see funktsioonidele, mis kirjutavad, muudavad või käivitavad midagi välist.
response = client.responses.create(
model="gpt-5.6-terra",
input="Process these three orders",
tools=tools,
parallel_tool_calls=False # One call per response
)
Juhtumid paralleelsuse keelamiseks:
- Toimingud, mis peavad toimuma kindlas järjekorras
- Funktsioonid kõrvalmõjudega, mis segavad üksteist
- Kui ühe väljakutse tulemus määrab järgmise tingimused
Järjestikused väljakutsed tsükliga
Järjestikust täitmist ei juhi parameeter: see tuleneb tsüklist. Sa täidad väljakutse, saadad tulemuse tagasi ja mudel otsustab järgmise sammu selle põhjal, mida ta just õppis. See ongi see, mis eristab dünaamilist ahelat jäigast plaanist – kui 2. samm näitab, et 3. samm on tarbetu, ei kutsu mudel seda.
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"
Läbitöötatud näide: töötlemistorustik
Tüüpiline juhtum, kus järjestikune täitmine on kohustuslik, sest iga samm tarbib eelmise toodangut:
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
)
Hübriidmuster: paralleelne, seejärel järjestikune
Praktikas järgib enamik reaalseid töövooge seda segamustrit: kogumisfaas, kus kõik saab käivituda samaaegselt, millele jäneb töötlemisfaas, mis austab sõltuvusi. Sa ei pea selleks midagi erilist kodeerima – see on tsükli loomulik tagajärg, eeldusel et sinu kirjeldused teevad sõltuvused selgeks.
# 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
See muster tundub loomulik: mudel paralleelistab automaatselt, kui väljakutsed on sõltumatud, ja aheldab seejärel järjestikku, kui ilmneb sõltuvus.
Peamised punktid
- Mudel paralleelistab automaatselt sõltumatud väljakutsed
- Kasuta
asyncio.gatherparalleelsete väljakutsete täitmiseks kliendi poolel - Keela kasutades
parallel_tool_calls=False, kui järjekord on oluline - Rakenda tsükkel mitmeastmeliste töövoogude jaoks
- Funktsioonide kirjeldused juhivad mudelit sammudevaheliste sõltuvuste osas