Apeluri paralele
Pe această pagină
Mai multe instrumente într-un singur răspuns
Una dintre cele mai puternice funcționalități ale apelurilor de funcții Grok este capacitatea de a returna mai multe apeluri de instrumente într-un singur răspuns. În loc să efectuați o dus-întors pentru fiecare funcție, modelul identifică toate informațiile necesare și generează fiecare apel în paralel.
Parametrul parallel_tool_calls
Apelurile paralele sunt activate implicit. Parametrul parallel_tool_calls controlează acest comportament:
# Activat implicit (nu este nevoie să specificați)
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=True # Aceasta este valoarea implicită
)
Când un utilizator întreabă: „Ce vreme este la Paris și Lyon?“, modelul returnează două tool_calls în același răspuns:
{
"tool_calls": [
{
"id": "call_001",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Paris\"}"
}
},
{
"id": "call_002",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Lyon\"}"
}
}
]
}
Gestionarea apelurilor paralele
Codul dumneavoastră trebuie să gestioneze un tablou de tool_calls, nu doar unul singur:
import json
import asyncio
message = response.choices[0].message
if message.tool_calls:
# Executați toate funcțiile
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)
})
# Trimiteți TOATE rezultatele înapoi modelului
messages = [
{"role": "user", "content": "What's the weather in Paris and Lyon?"},
message,
*tool_results # Toate rezultatele
]
final = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools
)
Punct critic: trebuie să returnați toate rezultatele instrumentelor, nu doar pe primul. Fiecare rezultat este legat de tool_call_id corespunzător.
Executarea cu adevărat paralelă la nivelul clientului
Modelul returnează apelurile în paralel, dar codul dumneavoastră trebuie să le execute în paralel. În Python, utilizați asyncio sau 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
Executarea paralelă reduce semnificativ latența totală. Dacă fiecare apel API durează 200 ms, două apeluri secvențiale înseamnă 400 ms, dar două apeluri paralele înseamnă aproximativ 200 ms.
Dezactivarea apelurilor paralele
În anumite cazuri, veți dori apeluri secvențiale:
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=False
)
Dezactivați paralelismul ori de câte ori independența apelurilor nu este garantată. Cel mai evident caz este dependența de date: dacă rezultatul unui instrument servește drept argument pentru următorul instrument – de exemplu, căutarea unui ID de client înainte de a prelua comenzile acestuia – executarea lor în paralel va provoca, în cel mai bun caz, o eroare și, în cel mai rău caz, va genera un rezultat incorect fără a semnala nicio problemă. Ordinea logicii de afaceri impune aceeași constrângere: crearea unui utilizator înainte de a-i atribui un rol este obligatorie, iar doar modul secvențial garantează acest lucru. Două motive practice completează imaginea: un API extern supus unor limite de cereri concurente nu va gestiona bine o explozie de apeluri paralele, iar în timpul dezvoltării, modul secvențial face urmărirea apelurilor infinit mai lizibilă – un apel, un rezultat, un jurnal, în ordine.
Apeluri paralele cu instrumente diferite
Modelul poate apela, de asemenea, instrumente diferite în paralel:
# Cerere: „Rezervă o masă și spune-mi vremea pentru diseară“
# Modelul returnează:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")
Acest lucru este deosebit de util pentru asistenții versatili care trebuie să colecteze informații din surse diferite.
Gestionarea erorilor în paralel
Când un apel eșuează, dar altele reușesc, returnați totuși toate rezultatele. Modelul gestionează erorile individuale:
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)})
})
Puncte cheie
- Apelurile paralele sunt activate implicit (
parallel_tool_calls: true) - Modelul returnează mai multe
tool_callsîntr-un singur răspuns - Trebuie să returnați toate rezultatele, fiecare fiind legat de
tool_call_idsău - Implementați executarea paralelă la nivelul clientului pentru a reduce latența
- Dezactivați paralelismul atunci când există dependențe între apeluri
- Gestionați erorile individual – nu blocați totul din cauza unei singure erori