Izsaukumu paralēla izpilde
Šajā lapā
Kad modelim vienlaikus nepieciešama vairāka informācija
Līdz šim katra sarunas kārtas rezultātā tika veikts tikai viens funkcijas izsaukums. Daudzi reāli jautājumi tomēr neietilpst šajā shēmā. Iedomājies lietotāju, kurš jautā: “Kāds ir maksājuma T1001 statuss un datums?” Modelim ir nepieciešami divi informācijas gabali, kas atrodas divās dažādās funkcijās: retrieve_payment_status un retrieve_payment_date. Tas varētu pieprasīt tos vienu pēc otra, gaidot tavu atbildi starpā. Tomēr šeit tas secina, ka neviens no tiem nav atkarīgs no otra, tāpēc tas ģenerē vairākus tool_calls vienā atbildē. Tu saņem visu darba slodzi uzreiz, un tu lemj, kā to izpildīt.
Atbildes ar vairākiem izsaukumiem nolasīšana
Praktiskā nozīme ir vienkārša: message.tool_calls vairs nav saraksts ar vienu elementu. Tev ir jāveic iterācija pār to, nevis jāpaņem tool_calls[0], kas ir bieži sastopams reflekss, apgūstot funkciju izsaukumus no piemēriem ar vienu funkciju.
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
message = response.choices[0].message
# Vairāki tool_calls vienā atbildē
for tc in message.tool_calls:
print(f"Function: {tc.function.name}")
print(f"Arguments: {tc.function.arguments}")
print(f"ID: {tc.id}")
print("---")
# Iespējamā izvade:
# Function: retrieve_payment_status
# Arguments: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Function: retrieve_payment_date
# Arguments: {"transaction_id": "T1001"}
# ID: call_def456
Ņem vērā, ka abi izsaukumi izmanto vienu un to pašu argumentu T1001, bet tiem ir dažādi ID: call_abc123 un call_def456. Šie ID ir vienīgais veids, kā modelis zina, kurš rezultāts atbilst kuram pieprasījumam.
Katra rezultāta atgriešana sākotnējam izsaukumam
Noteikums ir stingrs: tev ir jāizpilda katra funkcija un jāatgriež katrs rezultāts atsevišķā tool ziņojumā, kas satur atbilstošo tool_call_id. Ja aizmirsīsi vai samainīsi ID, modelis varētu piedēvēt datumu statusa laukam vai atteikties atbildēt.
message = response.choices[0].message
messages.append(message)
# Izpildi visas pieprasītās funkcijas
for tool_call in message.tool_calls:
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# Izpildi funkciju
result = available_functions[function_name](**function_params)
# Pievieno rezultātu ar pareizo tool_call_id
messages.append({
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
})
# Nosūti visus rezultātus atpakaļ modelim
final_response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
print(final_response.choices[0].message.content)
# → "Maksājums T1001 tika veikts 2026. gada 15. martā, un tā statuss ir: apmaksāts."
Modelis pēc tam savieno abus fragmentus vienā teikumā, it kā informācija būtu nākusi no viena avota. Tieši tādu efektu tu vēlies panākt no lietotāja perspektīvas.
Pāreja no šķietamas paralēlisma uz īstu paralēlismu
Viena nianse bieži paliek nepamanīta pirmajā lasījumā: iepriekšējā for ciklā funkcijas tiek izpildītas viena pēc otras. Modelis pieprasīja savus izsaukumus paralēli, bet tavs kods paliek secīgs. Kamēr tavas funkcijas lasa atmiņā esošu DataFrame, tam nav nozīmes. Tomēr, tiklīdz tās veic vaicājumus ārējai API vai datubāzei, divi 300 ms ilgi izsaukumi pārvēršas 600 ms uztvertajā latentumā, un paralēlisma priekšrocība izzūd. Ja tavas funkcijas ir asinhronas, asyncio.gather palaiž tās kopā un gaida visu pakotni.
import asyncio
import json
async def execute_tools_parallel(tool_calls, available_functions):
"""Izpilda tool_calls paralēli un atgriež rezultātus."""
async def execute_one(tool_call):
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# Ja tavas funkcijas ir asinhronas:
result = await available_functions[function_name](**function_params)
return {
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
}
# Izpildi visas funkcijas paralēli
tasks = [execute_one(tc) for tc in tool_calls]
return await asyncio.gather(*tasks)
Lielākā daļa esošo kodu bāzu eksponē sinhronas funkcijas, kuras nevēlēsies pārrakstīt kā async tikai šī iemesla dēļ. Diegu baseins (thread pool) rada tādu pašu efektu, nepieskaroties tavai biznesa loģikai.
from concurrent.futures import ThreadPoolExecutor
def execute_tools_threaded(tool_calls, available_functions):
"""Izpilda tool_calls, izmantojot diegu baseinu."""
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
Kontroles atgūšana ar parallel_tool_calls
Paralēlisms ne vienmēr ir vēlams. Parametrs parallel_tool_calls ļauj to atļaut vai aizliegt. Ja tas ir iestatīts uz True (noklusējuma vērtība), modelis pats lemj, vai grupēt savus izsaukumus. Ja tas ir iestatīts uz False, tas var ģenerēt tikai vienu tool_call katrā atbildē.
# Atļaut paralēlus izsaukumus (noklusējums)
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools,
parallel_tool_calls=True # Modelis lemj
)
# Piespiest secīgus izsaukumus
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools,
parallel_tool_calls=False # Tikai viens tool_call katrā atbildē
)
Ir trīs situācijas, kas attaisno šī parametra iestatīšanu uz False. Pirmā ir tad, kad izpildes secībai ir nozīme: rēķina izrakstīšana pirms krājumu pārbaudes dod citu rezultātu nekā otrādi. Otrā situācija ir saistīta ar datu atkarībām, kur vienas funkcijas rezultāts ir nepieciešams nākamās izsaukšanai – piemēram, kontakta atrašana, lai iegūtu tā ID, pirms tiek modificēts tā ieraksts. Trešā vienkārši attiecas uz nepieciešamību pēc smalkākas plūsmas kontroles, parasti atkļūdošanas laikā, kad vēlies novērot katru izsaukumu izolēti, pirms atver slūžas.
Ko paralēlisms patiesībā maina
Ieguvums nav tikai diegos; tas galvenokārt attiecas uz API aprites ciklu (round trips) skaitu, kas dominē kopējā latentumā.
# Secīgi (2 API izsaukumi uz modeli)
lietotājs → asistents(fc.1) → rīks(r.1) → asistents(fc.2) → rīks(r.2) → asistents(atbilde)
# Paralēli (tikai 1 papildu API izsaukums)
lietotājs → asistents(fc.1, fc.2) → rīks(r.1), rīks(r.2) → asistents(atbilde)
Secīgajā模式中 modelim ir jāpabeidz divi pilni spriešanas cikli pirms galīgās atbildes. Paralēlajā模式中 viens pieprasījums iegūst visus tool_calls, un atbildei ir nepieciešams tikai viens papildu pieprasījums. Jautājumiem, kas ietver divas vai trīs funkcijas, tas parasti ietaupa lietotājam vairākas sekundes.
Galvenās atziņas
- Modelis var ģenerēt vairākus
tool_callsvienā atbildē - Katrs rezultāts ir jāatgriež ar pareizo
tool_call_id - Tīkla funkcijām izmanto
asynciovaiThreadPoolExecutorpatiesai paralēlai izpildei - Parametrs
parallel_tool_callskontrolē šo uzvedību (pēc noklusējumaTrue) - Paralēlais raksts samazina API pieprasījumu skaitu un uzlabo latentumu