Sejħiet Paralleli
F'din il-paġna
Għodod Multipli f’Risposta Waħda
Waħda mill-aktar karatteristiċi qawwija tas-sejħiet tal-funzjonijiet ta’ Grok hija l-kapaċità li tirritorna sejħiet tal-għodod multipli f’risposta waħda. Minflok ma tagħmel vjaġġ ‘l hemm u ‘l hawn għal kull funzjoni, il-mudell jidentifika l-informazzjoni kollha li jeħtieġ u jiġġenera kull sejħa b’mod parallel.
Il-Parametru parallel_tool_calls
Is-sejħiet paralleli huma attivi b’mod default. Il-parametru parallel_tool_calls jikkontrolla dan l-imġiba:
# Attiv b'mod default (m'hemmx bżonn tispeċifika)
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=True # Dan huwa d-default
)
Meta utent jistaqsi, “X’inhu t-temp f’Pariġi u Ljon?”, il-mudell jirritorna żewġ tool_calls fl-istess risposta:
{
"tool_calls": [
{
"id": "call_001",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Paris\"}"
}
},
{
"id": "call_002",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Lyon\"}"
}
}
]
}
Kif Timmaniġġja Sejħiet Paralleli
Il-kodiċi tiegħek irid jimmaniġġja array ta’ tool_calls, mhux wieħed biss:
import json
import asyncio
message = response.choices[0].message
if message.tool_calls:
# Eżegwixxi l-funzjonijiet kollha
tool_results = []
for tool_call in message.tool_calls:
args = json.loads(tool_call.function.arguments)
result = execute_function(tool_call.function.name, args)
tool_results.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": json.dumps(result)
})
# Ibghat IR-RIZULTATI KOLLHA lura lill-mudell
messages = [
{"role": "user", "content": "What's the weather in Paris and Lyon?"},
message,
*tool_results # Ir-riżultati kollha
]
final = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools
)
Punt kritiku: trid tirritorna r-riżultati kollha tal-għodod, mhux biss l-ewwel wieħed. Kull riżultat huwa marbut mal-tool_call_id korrispondenti tiegħu.
Eżekuzzjoni Verament Paralleli fuq il-Klijent
Il-mudell jirritorna s-sejħiet b’mod parallel, iżda l-kodiċi tiegħek irid jeżegwixxihom b’mod parallel. F’Python, uża asyncio jew concurrent.futures:
import concurrent.futures
def execute_parallel(tool_calls):
results = []
with concurrent.futures.ThreadPoolExecutor() as executor:
futures = {}
for tc in tool_calls:
args = json.loads(tc.function.arguments)
future = executor.submit(execute_function, tc.function.name, args)
futures[future] = tc.id
for future in concurrent.futures.as_completed(futures):
call_id = futures[future]
result = future.result()
results.append({
"role": "tool",
"tool_call_id": call_id,
"content": json.dumps(result)
})
return results
L-eżekuzzjoni parallela tnaqqas b’mod sinifikanti l-latency totali. Jekk kull sejħa API tieħu 200ms, żewġ sejħiet sekwenzjali = 400ms, iżda żewġ sejħiet paralleli = ~200ms.
Id-diżattivazzjoni tas-Sejħiet Paralleli
F’xi każijiet, tkun trid sejħiet sekwenzjali:
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=False
)
Iddiżattiva l-parallelità kull meta l-indipendenza tas-sejħiet ma tkunx garantita. L-aktar każ ovvju huwa d-dipendenza tad-data: jekk ir-riżultat ta’ għodda waħda jidħol fl-argumenti tal-għodda li jmiss—bħall-iftix ta’ ID ta’ klijent qabel ma tirritorna l-ordnijiet tiegħu—it-tħaddim tagħhom b’mod parallel se jikkawża żball fl-aħjar każ, u fl-agħar każ jipproduċi riżultat ħażin mingħajr ma jintwera. Il-loġika tan-negozju timponi l-istess restrizzjoni: il-ħolqien ta’ utent qabel ma tingħatah rwol mhuwiex negozjabbli, u biss il-modalità sekwenzjali tiggarantixxi dan. Żewġ raġunijiet oħra prattiċi jikkompletaw il-ħarsa ġenerali: API esterna soġġetta għal limiti ta’ talbiet konkorrenti ma tittrattax tajjeb żieda f’daqqa ta’ sejħiet paralleli, u waqt l-iżvilupp, il-modalità sekwenzjali tagħmel it-traċċar tas-sejħiet infinitament aktar leġibbli—sejħa waħda, riżultat wieħed, log wieħed, f’ordni.
Sejħiet Paralleli b’Għodod Differenti
Il-mudell jista’ jsejjaħ ukoll għodod differenti b’mod parallel:
# Talba: "Ibbukja mejda u għidli x'inhu t-temp il-lejla"
# Il-mudell jirritorna:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")
Dan huwa partikolarment utli għal assistenti versatili li jeħtieġu jiġbru informazzjoni minn sorsi differenti.
Immaniġġjar tal-Iżbalji fil-Parallel
Meta sejħa waħda tfalli iżda oħrajn jirnexxu, xorta waħda rritorna r-riżultati kollha. Il-mudell jimmaniġġja l-iżbalji individwali:
results = []
for tc in message.tool_calls:
try:
result = execute_function(tc.function.name, args)
results.append({
"role": "tool",
"tool_call_id": tc.id,
"content": json.dumps(result)
})
except Exception as e:
results.append({
"role": "tool",
"tool_call_id": tc.id,
"content": json.dumps({"error": str(e)})
})
Punti Ewlenin
- Is-sejħiet paralleli huma attivati b’mod default (
parallel_tool_calls: true) - Il-mudell jirritorna
tool_callsmultipli f’risposta waħda - Trid tirritorna r-riżultati kollha, kull wieħed marbut mal-
tool_call_idtiegħu - Implimenta eżekuzzjoni paralleli fuq in-naħa tal-klijent biex tnaqqas il-latency
- Iddiżattiva l-parallelità meta jkun hemm dipendenzi bejn is-sejħiet
- Immaniġġja l-iżbalji individwalment—timblukkax kollox għal falliment wieħed