Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Izsaukumi paralēli

Nodarbība 6 no 14 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Vairāki rīki vienā atbildē
  2. Parametrs parallel_tool_calls
  3. Paralēlo izsaukumu apstrāde
  4. Patiesa paralēla izpilde klientā
  5. Paralēlo izsaukumu atslēgšana
  6. Paralēli izsaukumi ar dažādiem rīkiem
  7. Kļūdu apstrāde paralēlā režīmā
  8. Galvenās atziņas

Vairāki rīki vienā atbildē

Viena no Grok funkciju izsaukšanas spēcīgākajām īpašībām ir iespēja vienā atbildē atgriezt vairākus rīku izsaukumus. Tā vietā, lai veiktu atsevišķu apriti katrai funkcijai, modelis identificē visu nepieciešamo informāciju un ģenerē visus izsaukumus paralēli.

Parametrs parallel_tool_calls

Paralēlie izsaukumi ir ieslēgti pēc noklusējuma. Parametrs parallel_tool_calls kontrolē šo uzvedību:

# Ieslēgts pēc noklusējuma (nav jānorāda)
response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Šis ir noklusējums
)

Kad lietotājs jautā: „Kāds laiks ir Parīzē un Lionā?”, modelis vienā atbildē atgriež divus tool_calls:

{
  "tool_calls": [
    {
      "id": "call_001",
      "function": {
        "name": "get_weather",
        "arguments": "{\"city\": \"Paris\"}"
      }
    },
    {
      "id": "call_002",
      "function": {
        "name": "get_weather",
        "arguments": "{\"city\": \"Lyon\"}"
      }
    }
  ]
}

Paralēlo izsaukumu apstrāde

Tavam kodam ir jāapstrādā tool_calls masīvs, nevis tikai viens elements:

import json
import asyncio

message = response.choices[0].message

if message.tool_calls:
    # Izpildi visas funkcijas
    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)
        })

    # Nosūti VISUS rezultātus atpakaļ modelim
    messages = [
        {"role": "user", "content": "What's the weather in Paris and Lyon?"},
        message,
        *tool_results  # Visi rezultāti
    ]

    final = client.chat.completions.create(
        model="grok-4.5",
        messages=messages,
        tools=tools
    )

Kritiski svarīgi: tev ir jāatgriež visi rīku rezultāti, ne tikai pirmais. Katrs rezultāts ir saistīts ar savu atbilstošo tool_call_id.

Patiesa paralēla izpilde klientā

Modelis atgriež izsaukumus paralēli, bet tavam kodam tie ir jāizpilda paralēli. Python valodā izmanto asyncio vai 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

Paralēla izpilde ievērojami samazina kopējo latentumu. Ja katrs API izsaukums aizņem 200 ms, tad divi secīgi izsaukumi = 400 ms, bet divi paralēli izsaukumi = ~200 ms.

Paralēlo izsaukumu atslēgšana

Dažos gadījumos tev būs nepieciešami secīgi izsaukumi:

response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False
)

Atslēdz paralēlismu, ja izsaukumu neatkarība nav garantēta. Acīmredzamākais gadījums ir datu atkarība: ja viena rīka rezultāts tiek izmantots nākamā rīka argumentos — piemēram, klienta ID meklēšana pirms pasūtījumu iegūšanas — to izpilde paralēli labākajā gadījumā izraisīs kļūdu, bet sliktākajā radīs klusi nepareizu rezultātu. Biznesa loģikas secība uzliek tādu pašu ierobežojumu: lietotāja izveide pirms tam piešķirtās lomas ir obligāta, un to garantē tikai secīgais režīms. Divi papildu praktiski iemesli papildina kopainu: ārējs API, uz kuru attiecas vienlaicīgu pieprasījumu limiti, netiks galā ar paralēlu izsaukumu plūsmu, un izstrādes laikā secīgais režīms padara izsaukumu izsekošanu bezgalīgi lasāmāku — viens izsaukums, viens rezultāts, viens žurnāla ieraksts secībā.

Paralēli izsaukumi ar dažādiem rīkiem

Modelis var paralēli izsaukt arī dažādus rīkus:

# Pieprasījums: "Rezervē galdu un pastāsti, kāds būs laiks šovakar"
# Modelis atgriež:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")

Tas ir īpaši noderīgi universāliem asistentiem, kuriem jāapkopo informācija no dažādiem avotiem.

Kļūdu apstrāde paralēlā režīmā

Ja viens izsaukums neizdodas, bet pārējie ir veiksmīgi, tomēr atgriez visus rezultātus. Modelis apstrādā individuālas kļūdas:

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)})
        })

Galvenās atziņas

  • Paralēlie izsaukumi ir ieslēgti pēc noklusējuma (parallel_tool_calls: true)
  • Modelis vienā atbildē atgriež vairākus tool_calls
  • Tev ir jāatgriež visi rezultāti, katru saistot ar savu tool_call_id
  • Implementē paralēlu izpildi klientā, lai samazinātu latentumu
  • Atslēdz paralēlismu, ja starp izsaukumiem pastāv atkarības
  • Apstrādā kļūdas individuāli — nebloķē visu procesu vienas kļūdas dēļ