Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Rinnakkaiset kutsut

Oppitunti 6 / 14 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Useita työkaluja yhdessä vastauksessa
  2. parallel_tool_calls-parametri
  3. Rinnakkaisten kutsujen käsittely
  4. Todellinen rinnakkainen suoritus asiakaspuolella
  5. Rinnakkaisuuden poistaminen käytöstä
  6. Eri työkalujen rinnakkaiset kutsut
  7. Virheenkäsittely rinnakkaisessa suorituksessa
  8. Keskeiset asiat

Useita työkaluja yhdessä vastauksessa

Yksi Grok-funktiokutsujen tehokkaimmista ominaisuuksista on kyky palauttaa useita työkalukutsuja yhdessä vastauksessa. Malli tunnistaa kaiken tarvitsemansa tiedon ja generoi kaikki kutsut rinnakkain sen sijaan, että jokaiselle funktiolle tehtäisiin erillinen edestakainen viestintäkierros.

parallel_tool_calls-parametri

Rinnakkaiset kutsut ovat oletusarvoisesti käytössä. parallel_tool_calls-parametri ohjaa tätä toimintaa:

# Käytössä oletuksena (määrittelyä ei tarvita)
response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Tämä on oletusarvo
)

Kun käyttäjä kysyy: “Mikä sää on Pariisissa ja Lyonissa?”, malli palauttaa kaksi tool_calls-kohdetta samassa vastauksessa:

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

Rinnakkaisten kutsujen käsittely

Koodisi tulee käsitellä tool_calls-taulukkoa, ei vain yhtä kohdetta:

import json
import asyncio

message = response.choices[0].message

if message.tool_calls:
    # Suorita kaikki funktiot
    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)
        })

    # Lähetä KAIKKI tulokset takaisin mallille
    messages = [
        {"role": "user", "content": "Mikä sää on Pariisissa ja Lyonissa?"},
        message,
        *tool_results  # Kaikki tulokset
    ]

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

Kriittinen kohta: sinun on palautettava kaikki työkalutulokset, ei vain ensimmäistä. Jokainen tulos on linkitetty vastaavaan tool_call_id:hen.

Todellinen rinnakkainen suoritus asiakaspuolella

Malli palauttaa kutsut rinnakkain, mutta koodisi täytyy suorittaa ne rinnakkain. Käytä Pythonissa asyncio:ta tai concurrent.futures:ia:

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

Rinnakkainen suoritus lyhentää merkittävästi kokonaisviivettä. Jos jokainen API-kutsu kestää 200 ms, kaksi peräkkäistä kutsua vie 400 ms, mutta kaksi rinnakkaista kutsua vain noin 200 ms.

Rinnakkaisuuden poistaminen käytöstä

Joissakin tilanteissa haluat peräkkäisiä kutsuja:

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

Poista rinnakkaisuus käytöstä aina, kun kutsujen riippumattomuutta ei voida taata. Ilmeisin tapaus on datariippuvuus: jos yhden työkalun tulos syötetään seuraavan työkalun argumentteihin – esimerkiksi asiakastunnuksen hakeminen ennen tilausten noutamista – rinnakkainen suoritus aiheuttaa pahimmillaan virheen tai parhaimmillaan hiljaisesti virheellisen tuloksen. Liiketoimintalogiikan järjestys asettaa saman rajoituksen: käyttäjän luominen ennen roolin määrittämistä on ehdoton vaatimus, ja vain peräkkäinen tila takaa tämän. Kaksi käytännön syytä täydentävät kuvaa: ulkoinen API, jossa on samanaikaisten pyyntöjen rajoituksia, ei kestä rinnakkaisten kutsujen ryöppyä, ja kehitysvaiheessa peräkkäinen tila tekee kutsujen seuraamisesta huomattavasti selkeämpää – yksi kutsu, yksi tulos, yksi lokimerkintä järjestyksessä.

Eri työkalujen rinnakkaiset kutsut

Malli voi kutsua myös eri työkaluja rinnakkain:

# Pyyntö: "Varaa pöytä ja kerro tämän illan sää"
# Malli palauttaa:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")

Tämä on erityisen hyödyllistä monipuolisille avustajille, joiden on kerättävä tietoa eri lähteistä.

Virheenkäsittely rinnakkaisessa suorituksessa

Vaikka yksi kutsu epäonnistuisi ja muut onnistuisivat, palauta silti kaikki tulokset. Malli käsittelee yksittäiset virheet:

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

Keskeiset asiat

  • Rinnakkaiset kutsut ovat oletusarvoisesti käytössä (parallel_tool_calls: true)
  • Malli palauttaa useita tool_calls-kohteita yhdessä vastauksessa
  • Sinun on palautettava kaikki tulokset, joista jokainen on linkitetty omaan tool_call_id:hensä
  • Toteuta asiakaspuolen rinnakkainen suoritus viiveen vähentämiseksi
  • Poista rinnakkaisuus käytöstä, kun kutsujen välillä on riippuvuuksia
  • Käsittele virheet yksittäin – älä estä kaikkea yhden epäonnistumisen vuoksi