Паралелни извиквания на функции
На тази страница
- Когато моделът се нуждае от няколко части информация едновременно
- Четене на отговор с множество извиквания
- Връщане на всеки резултат към оригиналното му извикване
- Преминаване от привидна към реална паралелност
- Възвръщане на контрола чрез parallel_tool_calls
- Какво всъщност променя паралелизмът
- Ключови изводи
Когато моделът се нуждае от няколко части информация едновременно
Досега всяка стъпка в разговора водеше до едно единствено извикване на функция. Много реални въпроси обаче не се вписват в този шаблон. Помислете за потребител, който пита: „Какъв е статусът и датата на плащане T1001?“. Моделът се нуждае от две части информация, които се намират в две различни функции: retrieve_payment_status и retrieve_payment_date. Той би могъл да ги поиска една след друга, изчаквайки Вашия отговор между тях. В този случай обаче той определя, че нито едната зависи от другата, затова генерира няколко tool_calls в един единствен отговор. Вие получавате цялата работна натовареност наведнъж и Вие решавате как да я изпълните.
Четене на отговор с множество извиквания
Практическото следствие е просто: message.tool_calls вече не е списък с един елемент. Трябва да го обходите чрез цикъл, вместо да грабвате tool_calls[0], което е често срещан рефлекс при изучаване на извикването на функции чрез примери с една функция.
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
Обърнете внимание, че и двете извиквания използват един и същ аргумент, T1001, но имат различни ID: call_abc123 и call_def456. Тези ID са единственият начин моделът да разбере кой резултат на кое заявка съответства.
Връщане на всеки резултат към оригиналното му извикване
Правилото е строго: трябва да изпълните всяка функция и да върнете всеки резултат в отделно съобщение от тип tool, носещо съответния tool_call_id. Ако пропуснете или размените някое ID, моделът може да припише датата към полето за статус или да откаже да отговори.
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."
След това моделът събира двата фрагмента в едно изречение, сякаш информацията идва от един източник. Това е точно ефектът, който искате от гледна точка на потребителя.
Преминаване от привидна към реална паралелност
Един нюанс често убягва на читателите при първо четене: в горния цикъл for функциите се изпълняват една след друга. Моделът е поискал своите извиквания паралелно, но Вашият код остава последователен. Докато Вашите функции четат DataFrame в паметта, това няма значение. Щом обаче те правят заявка към външен API или база данни, две извиквания от по 300 ms се превръщат в 600 ms възприемана латентност и ползата от паралелизма изчезва. Ако Вашите функции са асинхронни, asyncio.gather ги стартира едновременно и изчаква цялата партида.
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)
Повечето съществуващи кодови бази излагат синхронни функции, които няма да искате да препишете като async само заради това. Пул от нишки (thread pool) произвежда същия ефект, без да пипате бизнес логиката си.
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
Възвръщане на контрола чрез parallel_tool_calls
Паралелизмът не винаги е желателен. Параметърът parallel_tool_calls Ви позволява да го разрешите или забраните. Когато е зададен на True (стойност по подразбиране), моделът решава дали да групира своите извиквания. Когато е зададен на False, той може да произведе само едно tool_call на отговор.
# 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
)
Три ситуации оправдават задаването на тази стойност на False. Първата е, когато редът на изпълнение има значение: фактурирането преди проверка на наличностите дава различен резултат от обратното. Втората включва зависимости от данни, където резултатът от една функция е необходим, за да се извика следващата – например намиране на контакт, за да се получи неговото ID, преди да се модифицира записът му. Третата просто се отнася до нуждата от по-фин контрол върху потока, обикновено по време на отстраняване на грешки, когато искате да наблюдавате всяко извикване в изолация, преди да отворите шлюзовете.
Какво всъщност променя паралелизмът
Ползата не е просто в нишките; тя се отнася преди всичко до броя на往返 (round trips) към API, които доминират общата латентност.
# 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)
При последователния шаблон моделът трябва да завърши два пълни цикъла на разсъждение преди крайния отговор. При паралелния шаблон една единствена заявка извлича всички tool_calls и е необходима само една допълнителна заявка за отговора. За въпрос, включващ две или три функции, това обикновено спестява на потребителя няколко секунди.
Ключови изводи
- Моделът може да генерира няколко
tool_callsв един единствен отговор - Всеки резултат трябва да бъде върнат с правилния
tool_call_id - За мрежови функции използвайте
asyncioилиThreadPoolExecutorза истинско паралелно изпълнение - Параметърът
parallel_tool_callsконтролира това поведение (Trueпо подразбиране) - Паралелният шаблон намалява броя на API заявките и подобрява латентността