Opkald parallelt og sekventielt
På denne side
Opkald parallelt og sekventielt
Modellen kan udstede flere funktionskald i ét enkelt svar og gør det automatisk, når den identificerer uafhængige behov. Dette er ikke blot kosmetisk optimering: Tre opkald på to sekunder, der køres sammen, tager samlet to sekunder, men kædes de sekventielt, tager de seks.
Fokus i denne lektion er ikke hvordan man paralleliserer – det håndterer modellen selv – men hvordan man genkender tilfælde, hvor du ikke bør gøre det. To kald er uafhængige, når eksekveringsrækkefølgen ikke påvirker resultatet. Så snart én operation læser det, en anden skriver, eller en parameter skal komme fra et tidligere kald, bliver parallelisme en svær at reproducere fejl.
Parallelle kald
Intet behøver at blive aktiveret: Dette er standardadfærden. En forespørgsel om tre byer producerer tre function_call-elementer i samme svar; du eksekverer dem. Bemærk, at modellen ræsonnerer ud fra betydningen af funktionerne baseret på dine beskrivelser – beskrivelserne styrer beslutningen, ligesom i næsten alt andet i dette kursus.
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
Eksekver parallelle kald på klientsiden
Det nytter ikke noget at modtage tre kald på én gang, hvis din kode eksekverer dem ét efter ét: Så mister du hele gevinsten på klientsiden. asyncio.gather er minimum; til produktion skal du tilføje to forholdsregler: en grænse for samtidighed, så du ikke åbner halvtreds samtidige forbindelser til en tjeneste, der kun understøtter ti, og fejlhåndtering pr. kald, så en isoleret fejl ikke vælter de andre resultater.
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)
Deaktiver parallelle kald
parallel_tool_calls=False tvinger modellen til kun at udstede ét kald pr. svar. Brug denne indstilling bevidst: Det bytter ventetid ud mod sikkerhed. Reserver det til funktioner, der skriver, ændrer eller udløser noget eksternt.
response = client.responses.create(
model="gpt-5.6-terra",
input="Process these three orders",
tools=tools,
parallel_tool_calls=False # One call per response
)
Anvendelsestilfælde for deaktivering af parallelisme:
- Operationer, der skal eksekveres i en bestemt rækkefølge
- Funktioner med bivirkninger, der forstyrrer hinanden
- Når resultatet af ét kald betinger det næste
Sekventielle kald med en løkke
Sekventiel eksekvering styres ikke af en parameter: Den opstår af løkken. Du eksekverer kaldet, sender resultatet tilbage, og modellen beslutter næste skridt baseret på det, den lige har lært. Det er præcis det, der adskiller en dynamisk kæde fra en stiv plan – hvis trin 2 afslører, at trin 3 er unødvendigt, vil modellen ikke kalde det.
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"
Gennemarbejdet eksempel: Behandlingspipeline
Et typisk tilfælde, hvor sekventiel eksekvering er obligatorisk, fordi hvert trin forbruger det, det foregående har produceret:
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
)
Hybridd mønster: Først parallelt, derefter sekventielt
I praksis følger de fleste virkelige arbejdsgange dette blandede mønster: En indsamlingsfase, hvor alt kan køre samtidigt, efterfulgt af en behandlingsfase, der respekterer afhængigheder. Du behøver ikke kode noget specielt til dette – det er den naturlige konsekvens af løkken, forudsat at dine beskrivelser gør afhængighederne klare.
# 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
Dette mønster føles naturligt: Modellen paralleliserer automatisk, når kald er uafhængige, og kæder derefter sekventielt, når en afhængighed opstår.
Vigtige pointer
- Modellen paralleliserer automatisk uafhængige kald
- Brug
asyncio.gathertil at eksekvere parallelle kald på klientsiden - Deaktiver med
parallel_tool_calls=False, når rækkefølgen betyder noget - Implementer en løkke til arbejdsgange med flere trin
- Funktionsbeskrivelser guider modellen omkring afhængigheder mellem trin