Apeluri de funcții în paralel
Pe această pagină
Când modelul are nevoie de mai multe informații simultan
Până acum, fiecare intervenție în conversație a generat un singur apel de funcție. Multe întrebări din lumea reală nu se încadrează în acest tipar. Să luăm exemplul unui utilizator care întreabă: „Care este starea și data plății T1001?“. Modelul are nevoie de două informații care se află în două funcții distincte: retrieve_payment_status și retrieve_payment_date. Ar putea solicita aceste informații una câte una, așteptând răspunsul dumneavoastră între ele. Totuși, în acest caz, modelul determină că niciuna nu depinde de cealaltă, așa că generează mai multe tool_calls într-un singur răspuns. Primești întreaga sarcină de lucru dintr-o dată, iar dumneata decizi cum să o execuți.
Citirea unui răspuns cu mai multe apeluri
Implicația practică este simplă: message.tool_calls nu mai este o listă cu un singur element. Trebuie să iterezi asupra ei, în loc să accesezi direct tool_calls[0], un reflex comun când înveți apelarea de funcții din exemple care implică o singură funcție.
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
message = response.choices[0].message
# Multiple tool_calls in the same response
for tc in message.tool_calls:
print(f"Function: {tc.function.name}")
print(f"Arguments: {tc.function.arguments}")
print(f"ID: {tc.id}")
print("---")
# Possible output:
# Function: retrieve_payment_status
# Arguments: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Function: retrieve_payment_date
# Arguments: {"transaction_id": "T1001"}
# ID: call_def456
Rețineți că ambele apeluri folosesc același argument, T1001, dar au ID-uri diferite: call_abc123 și call_def456. Aceste ID-uri sunt singurul mod prin care modelul știe cărui rezultat îi corespunde fiecare cerere.
Returnarea fiecărui rezultat către apelul său original
Regula este strictă: trebuie să executați fiecare funcție și să returnați fiecare rezultat într-un mesaj tool separat, care conține tool_call_id corespunzător. Dacă uitați sau schimbați un ID, modelul ar putea atribui data câmpului de stare sau ar putea refuza să răspundă.
message = response.choices[0].message
messages.append(message)
# Execute all requested functions
for tool_call in message.tool_calls:
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# Execute the function
result = available_functions[function_name](**function_params)
# Add the result with the correct tool_call_id
messages.append({
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
})
# Send all results back to the model
final_response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
print(final_response.choices[0].message.content)
# → "Payment T1001 was made on March 15, 2026, and its status is: paid."
Modelul asamblează apoi cele două fragmente într-o singură propoziție, ca și cum informația ar proveni dintr-o singură sursă. Acesta este exact efectul dorit din perspectiva utilizatorului.
Trecerea de la paralelism aparent la paralelism real
O nuanță scapă adesea cititorilor la prima lectură: în bucla for de mai sus, funcțiile se execută una după alta. Modelul și-a solicitat apelurile în paralel, dar codul dumneavoastră rămâne secvențial. Atâta timp cât funcțiile dumneavoastră citesc un DataFrame din memorie, acest lucru nu contează. Totuși, odată ce acestea interoghează un API extern sau o bază de date, două apeluri de câte 300 ms devin 600 ms de latență percepută, iar beneficiul paralelismului dispare. Dacă funcțiile dumneavoastră sunt asincrone, asyncio.gather le lansează simultan și așteaptă întregul lot.
import asyncio
import json
async def execute_tools_parallel(tool_calls, available_functions):
"""Executes tool_calls in parallel and returns the results."""
async def execute_one(tool_call):
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# If your functions are async:
result = await available_functions[function_name](**function_params)
return {
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
}
# Execute all functions in parallel
tasks = [execute_one(tc) for tc in tool_calls]
return await asyncio.gather(*tasks)
Majoritatea bazelor de cod existente expun funcții sincrone pe care nu veți dori să le rescrieți ca async doar pentru acest motiv. Un pool de thread-uri produce același efect fără a atinge logica de afaceri.
from concurrent.futures import ThreadPoolExecutor
def execute_tools_threaded(tool_calls, available_functions):
"""Executes tool_calls using a thread pool."""
def execute_one(tool_call):
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
result = available_functions[function_name](**function_params)
return {
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
}
with ThreadPoolExecutor(max_workers=5) as executor:
results = list(executor.map(execute_one, tool_calls))
return results
Recâștigarea controlului cu parallel_tool_calls
Paralelismul nu este întotdeauna de dorit. Parametrul parallel_tool_calls vă permite să îl permiteți sau să îl interziceți. Când este setat la True (valoarea implicită), modelul decide dacă să își grupeze apelurile. Când este setat la False, acesta poate produce un singur tool_call per răspuns.
# Allow parallel calls (default)
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools,
parallel_tool_calls=True # Model decides
)
# Force sequential calls
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools,
parallel_tool_calls=False # Only one tool_call per response
)
Trei situații justifică setarea acestei valori la False. Prima este atunci când ordinea de execuție contează: facturarea înainte de verificarea stocului produce un rezultat diferit față de invers. A doua implică dependențe de date, unde rezultatul unei funcții este necesar pentru a o apela pe următoarea – de exemplu, găsirea unui contact pentru a obține ID-ul acestuia înainte de a-i modifica înregistrarea. A treia se referă pur și simplu la nevoia unui control mai fin asupra fluxului, de obicei în timpul depanării, când doriți să observați fiecare apel izolat înainte de a deschide complet robinetul.
Ce schimbă cu adevărat paralelismul
Câștigul nu ține doar de thread-uri; privește în primul rând numărul de dus-întorsuri către API, care domină latența totală.
# Sequential (2 API calls to the model)
user → assistant(fc.1) → tool(r.1) → assistant(fc.2) → tool(r.2) → assistant(response)
# Parallel (only 1 additional API call)
user → assistant(fc.1, fc.2) → tool(r.1), tool(r.2) → assistant(response)
În modelul secvențial, modelul trebuie să completeze două cicluri complete de raționament înainte de răspunsul final. În modelul paralel, o singură cerere preia toate tool_calls, iar doar o cerere suplimentară este necesară pentru răspuns. Pentru o întrebare care implică două sau trei funcții, acest lucru economisește adesea utilizatorului câteva secunde.
Puncte cheie
- Modelul poate genera mai multe
tool_callsîntr-un singur răspuns - Fiecare rezultat trebuie returnat cu
tool_call_idcorect - Pentru funcțiile de rețea, utilizați
asynciosauThreadPoolExecutorpentru o execuție cu adevărat paralelă - Parametrul
parallel_tool_callscontrolează acest comportament (Trueîn mod implicit) - Modelul paralel reduce cererile către API și îmbunătățește latența