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

Funktiochamkut rinnakkain

Oppitunti 8 / 14 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Milloin malli tarvitsee useita tietopalasia samanaikaisesti
  2. Useita kutsuja sisältävän vastauksen lukeminen
  3. Kunkin tuloksen palauttaminen alkuperäiseen kutsuun
  4. Siirtyminen näennäisestä rinnakkaisuudesta todelliseen rinnakkaisuuteen
  5. Hallinnan palauttaminen parametrilla parallel_tool_calls
  6. Mitä rinnakkaisuus todella muuttaa
  7. Keskeiset asiat

Milloin malli tarvitsee useita tietopalasia samanaikaisesti

Tähän asti jokainen keskustelukierros on tuottanut vain yhden funktiokutsun. Monet todellisen maailman kysymykset eivät mahdu tähän muottiin. Kuvittele käyttäjä, joka kysyy: “Mikä on maksun T1001 tila ja päivämäärä?” Malli tarvitsee kaksi tietopalasta, jotka sijaitsevat kahdessa eri funktiossa: retrieve_payment_status ja retrieve_payment_date. Se voisi pyytää niitä yksi kerrallaan odottaen vastaustasi välissä. Tässä tapauksessa se kuitenkin toteaa, ettei kumpikaan riipu toisesta, joten se generoi useita tool_calls-kohteita yhdessä vastauksessa. Saat koko työmäärän kerralla, ja sinä päätät, miten suoritat sen.

Useita kutsuja sisältävän vastauksen lukeminen

Käytännön seuraamus on yksinkertainen: message.tool_calls ei ole enää yhden alkion lista. Sinun on iteröitävä sen yli sen sijaan, että napaisit tool_calls[0]:n, mikä on yleinen refleksi opeteltaessa funktiokutsuja yhden funktion esimerkeistä.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

message = response.choices[0].message

# Useita tool_calls-kohteita samassa vastauksessa
for tc in message.tool_calls:
    print(f"Function: {tc.function.name}")
    print(f"Arguments: {tc.function.arguments}")
    print(f"ID: {tc.id}")
    print("---")

# Mahdollinen tuloste:
# Function: retrieve_payment_status
# Arguments: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Function: retrieve_payment_date
# Arguments: {"transaction_id": "T1001"}
# ID: call_def456

Huomaa, että molemmat kutsut käyttävät samaa argumenttia, T1001, mutta niillä on eri tunnisteet: call_abc123 ja call_def456. Nämä tunnisteet ovat ainoa tapa, jolla malli tietää, mikä tulos vastaa mitäkin pyyntöä.

Kunkin tuloksen palauttaminen alkuperäiseen kutsuun

Sääntö on ehdoton: sinun on suoritettava jokainen funktio ja palautettava jokainen tulos erillisessä tool-viestissä, jossa on vastaava tool_call_id. Jos unohdat tai vaihdat tunnisteet, malli saattaa liittää päivämäärän tilakenttään tai kieltäytyä vastaamasta.

message = response.choices[0].message
messages.append(message)

# Suorita kaikki pyydetyt funktiot
for tool_call in message.tool_calls:
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

    # Suorita funktio
    result = available_functions[function_name](**function_params)

    # Lisää tulos oikealla tool_call_id:llä
    messages.append({
        "role": "tool",
        "name": function_name,
        "content": result,
        "tool_call_id": tool_call.id
    })

# Lähetä kaikki tulokset takaisin mallille
final_response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

print(final_response.choices[0].message.content)
# → "Maksu T1001 suoritettiin 15. maaliskuuta 2026, ja sen tila on: maksettu."

Malli ompelee sitten nämä kaksi fragmenttia yhdeksi lauseeksi, ikään kuin tieto olisi peräisin yhdestä lähteestä. Tämä on täsmälleen se vaikutus, jonka haluat käyttäjän näkökulmasta.

Siirtyminen näennäisestä rinnakkaisuudesta todelliseen rinnakkaisuuteen

Yksi vivahde jää usein huomaamatta ensimmäisellä lukukerralla: yllä olevassa for-silmukassa funktiot suoritetaan yksi kerrallaan. Malli pyysi kutsunsa rinnakkain, mutta koodisi pysyy sekventiaalisena. Niin kauan kuin funktiosi lukevat muistissa olevaa DataFramea, tällä ei ole väliä. Heti kun ne kuitenkin kysyvät ulkoista API:a tai tietokantaa, kaksi 300 ms:n kutsua muuttuu 600 ms:n havaituksi viiveeksi, ja rinnakkaisuuden hyöty haihtuu. Jos funktiosi ovat asynkronisia, asyncio.gather käynnistää ne yhdessä ja odottaa koko erän valmistumista.

import asyncio
import json

async def execute_tools_parallel(tool_calls, available_functions):
    """Suorittaa tool_calls-kohteet rinnakkain ja palauttaa tulokset."""

    async def execute_one(tool_call):
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)
        # Jos funktiosi ovat asynkronisia:
        result = await available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }

    # Suorita kaikki funktiot rinnakkain
    tasks = [execute_one(tc) for tc in tool_calls]
    return await asyncio.gather(*tasks)

Useimmat olemassa olevat koodikannat tarjoavat synkronisia funktioita, joita et halua kirjoittaa uudelleen async-muotoon pelkästään tämän vuoksi. Säiesovellus (thread pool) tuottaa saman vaikutuksen koskematta liiketoimintalogiikkaasi.

from concurrent.futures import ThreadPoolExecutor

def execute_tools_threaded(tool_calls, available_functions):
    """Suorittaa tool_calls-kohteet säiepoolin avulla."""
    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

Hallinnan palauttaminen parametrilla parallel_tool_calls

Rinnakkaisuus ei ole aina toivottavaa. Parametri parallel_tool_calls antaa sinun sallia tai kieltää sen. Kun se on asetettu arvoon True (oletus), malli päättää, ryhmitteleekö se kutsunsa. Kun se on asetettu arvoon False, se voi tuottaa vain yhden tool_call-kohteen per vastaus.

# Salli rinnakkaiset kutsut (oletus)
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Malli päättää
)

# Pakota sekventiaaliset kutsut
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False  # Vain yksi tool_call per vastaus
)

Kolme tilannetta oikeuttaa asettamaan tämän arvoksi False. Ensimmäinen on, kun suoritusjärjestyksellä on väliä: laskutus ennen varaston tarkistusta tuottaa eri tuloksen kuin päinvastoin. Toinen liittyy datariippuvuuksiin, jossa yhden funktion tulos tarvitaan seuraavan kutsumiseen – esimerkiksi yhteystiedon löytäminen tunnisteen saamiseksi ennen tietueen muokkaamista. Kolmas liittyy yksinkertaisesti tarpeeseen saada hienosyisempää hallintaa vuohon, tyypillisesti vianetsinnän aikana, kun haluat tarkkailla jokaista kutsua erillään ennen kuin avaat tulvat.

Mitä rinnakkaisuus todella muuttaa

Hyöty ei liity pelkästään säikeisiin; se koskee ensisijaisesti API-kierrosten määrää, jotka dominoivat kokonaisviivettä.

# Sekventiaalinen (2 API-kutsua mallille)
user → assistant(fc.1) → tool(r.1) → assistant(fc.2) → tool(r.2) → assistant(response)

# Rinnakkainen (vain 1 ylimääräinen API-kutsu)
user → assistant(fc.1, fc.2) → tool(r.1), tool(r.2) → assistant(response)

Sekventiaalisessa mallissa mallin on suoritettava kaksi täyttä päättelykierrosta ennen lopullista vastausta. Rinnakkaisessa mallissa yksi pyyntö hakee kaikki tool_calls-kohteet, ja vain yksi lisäpyyntö tarvitaan vastausta varten. Kysymyksessä, joka sisältää kaksi tai kolme funktiota, tämä säästää käyttäjältä yleensä useita sekunteja.

Keskeiset asiat

  • Malli voi generoida useita tool_calls-kohteita yhdessä vastauksessa
  • Jokainen tulos on palautettava oikealla tool_call_id:llä
  • Verkkofunktioille käytä asyncio:ta tai ThreadPoolExecutor:ia todelliseen rinnakkaiseen suoritukseen
  • Parametri parallel_tool_calls ohjaa tätä käyttäytymistä (oletusarvo True)
  • Rinnakkainen malli vähentää API-pyyntöjä ja parantaa viivettä