Κλήσεις Παράλληλες και Ακολουθιακές
Σε αυτήν τη σελίδα
Κλήσεις Παράλληλες και Ακολουθιακές
Το μοντέλο μπορεί να εκδώσει πολλαπλές κλήσεις συναρτήσεων σε μία μόνο απόκριση, κάνοντάς το αυτόματα όποτε εντοπίζει ανεξάρτητες ανάγκες. Αυτό δεν είναι απλώς μια καλλωπιστική βελτιστοποίηση: τρεις κλήσεις των δύο δευτερολέπτων που εκτελούνται ταυτόχρονα διαρκούν συνολικά δύο δευτερόλεπτα, αλλά αν εκτελεστούν ακολουθιακά η μία μετά την άλλη, διαρκούν έξι.
Ο πραγματικός στόχος αυτού του μαθήματος δεν είναι το πώς θα πραγματοποιήσετε παραλληλοποίηση—το μοντέλο το χειρίζεται αυτό—αλλά πώς να αναγνωρίζετε τις περιπτώσεις όπου δεν πρέπει να το κάνετε. Δύο κλήσεις είναι ανεξάρτητες όταν η σειρά εκτέλεσης δεν επηρεάζει το αποτέλεσμα. Μόλις μια λειτουργία διαβάσει κάτι που έγραψε μια άλλη, ή μια παράμετρος πρέπει να προέρχεται από μια προηγούμενη κλήση, ο παραλληλισμός μετατρέπεται σε ένα σφάλμα δύσκολο να αναπαραχθεί.
Παράλληλες Κλήσεις
Δεν απαιτείται καμία ενεργοποίηση: αυτή είναι η προεπιλεγμένη συμπεριφορά. Ένα ερώτημα για τρεις πόλεις παράγει τρία στοιχεία function_call στην ίδια απόκριση· εσείς τα εκτελείτε. Σημειώστε ότι το μοντέλο συλλογίζεται σχετικά με τη σημασία των συναρτήσεων βάσει των περιγραφών σας—οι περιγραφές καθοδηγούν την απόφαση, όπως σχεδόν σε όλα σε αυτό το μάθημα.
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
Εκτέλεση Παράλληλων Κλήσεων στην Πλευρά του Πελάτη
Το να λαμβάνετε τρεις κλήσεις ταυτόχρονα είναι άχρηστο αν ο κώδικάς σας τις εκτελεί τη μία μετά την άλλη: χάνετε όλο το όφελος στην πλευρά του πελάτη. Το asyncio.gather είναι το ελάχιστο απαραίτητο· προσθέστε δύο προφυλάξεις για περιβάλλον παραγωγής: ένα όριο ταυτόχρονων εκτελέσεων, ώστε να μην ανοίγετε πενήντα ταυτόχρονες συνδέσεις σε μια υπηρεσία που υποστηρίζει μόνο δέκα, και χειρισμό σφαλμάτων ανά κλήση, ώστε μια μεμονωμένη αποτυχία να μην καταρρίπτει τα υπόλοιπα αποτελέσματα.
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)
Απενεργοποίηση Παράλληλων Κλήσεων
Η ρύθμιση parallel_tool_calls=False αναγκάζει το μοντέλο να εκπέμπει μόνο μία κλήση ανά απόκριση. Χρησιμοποιήστε αυτή τη ρύθμιση σκόπιμα: ανταλλάσσετε τον χρόνο απόκρισης (latency) με ασφάλεια. Κρατήστε την για συναρτήσεις που γράφουν δεδομένα, τροποποιούν καταστάσεις ή ενεργοποιούν κάτι εξωτερικό.
response = client.responses.create(
model="gpt-5.6-terra",
input="Process these three orders",
tools=tools,
parallel_tool_calls=False # One call per response
)
Περιπτώσεις χρήσης για την απενεργοποίηση του παραλληλισμού:
- Λειτουργίες που πρέπει να εκτελεστούν με συγκεκριμένη σειρά
- Συναρτήσεις με παρενέργειες που αλληλεπιδρούν μεταξύ τους
- Όταν το αποτέλεσμα μιας κλήσης καθορίζει την επόμενη
Ακολουθιακές Κλήσεις με Βρόχο
Η ακολουθιακή εκτέλεση δεν ελέγχεται από μια παράμετρο: προκύπτει από τον βρόχο. Εκτελείτε την κλήση, στέλνετε πίσω το αποτέλεσμα και το μοντέλο αποφασίζει το επόμενο βήμα βάσει αυτού που μόλις έμαθε. Αυτό είναι ακριβώς που distingue μια δυναμική αλυσίδα από ένα άκαμπτο σχέδιο—αν το βήμα 2 αποκαλύψει ότι το βήμα 3 είναι περιττό, το μοντέλο δεν θα το καλέσει.
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"
Πρακτικό Παράδειγμα: Ροή Επεξεργασίας
Μια τυπική περίπτωση όπου η ακολουθιακή εκτέλεση είναι υποχρεωτική, επειδή κάθε βήμα καταναλώνει αυτό που παρήγαγε το προηγούμενο:
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
)
Υβριδικό Πρότυπο: Παράλληλο και Στη συνέχεια Ακολουθιακό
Στην πράξη, οι περισσότερες ροές εργασίας στον πραγματικό κόσμο ακολουθούν αυτό το μικτό πρότυπο: μια φάση συλλογής όπου όλα μπορούν να τρέξουν ταυτόχρονα, ακολουθούμενη από μια φάση επεξεργασίας που σέβεται τις εξαρτήσεις. Δεν χρειάζεται να κωδικοποιήσετε κάτι ιδιαίτερο γι’ αυτό—είναι η φυσική συνέπεια του βρόχου, υπό την προϋπόθεση ότι οι περιγραφές σας καθιστούν σαφείς τις εξαρτήσεις.
# 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
Αυτό το πρότυπο φαίνεται φυσικό: το μοντέλο παραλληλοποιεί αυτόματα όταν οι κλήσεις είναι ανεξάρτητες και στη συνέχεια τις αλυσοδένει ακολουθιακά όταν εμφανίζεται μια εξάρτηση.
Βασικά σημεία
- Το μοντέλο παραλληλοποιεί αυτόματα τις ανεξάρτητες κλήσεις
- Χρησιμοποιήστε το
asyncio.gatherγια να εκτελέσετε παράλληλες κλήσεις στην πλευρά του πελάτη - Απενεργοποιήστε με
parallel_tool_calls=Falseόταν η σειρά έχει σημασία - Υλοποιήστε έναν βρόχο για ροές εργασίας πολλαπλών βημάτων
- Οι περιγραφές των συναρτήσεων καθοδηγούν το μοντέλο σχετικά με τις εξαρτήσεις μεταξύ των βημάτων