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

Monivaiheinen keskustelu

Oppitunti 7 / 14 Päivitetty 2. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Yhden kutsun tuolla puolen
  2. Periaate: Historian ylläpito
  3. Täydellinen keskustelusilmukka
  4. Monivaiheisen keskustelun esimerkki
  5. Peräkkäisten kutsujen ketjuttaminen
  6. Historian koon hallinta
  7. Keskeiset asiat

Yhden kutsun tuolla puolen

Todellisissa sovelluksissa käyttäjät eivät esitä yhtä kysymystä ja katoa. He ketjuttavat pyyntöjä, palaavat aiempiin aiheisiin ja heittävät vihjeitä kuten “entä tämä?”, joita pelkkä lause ei pysty ratkaisemaan. Funktiokutsujen on toimittava tässä monivaiheisen keskustelun kontekstissa, jossa malli voi kutsua funktioita vuoropuhelun jokaisessa vaiheessa menettämättä koskaan näkyvistään sitä, mitä aiemmin on tapahtunut.

Periaate: Historian ylläpito

Avainasemassa on yksi lause: pidä kaikki viestit listassa, joka kasvaa jokaisen vuorovaikutuksen myötä. Mallilla ei ole omaa muistia API-kutsujen välillä; ainoa konteksti, joka sillä on, on se, mitä lähetät sille takaisin. Tämä täydellinen historia mahdollistaa implisiittisten viittausten ymmärtämisen.

import os
import json
from mistralai.client import Mistral
from functools import partial

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"

# Keskusteluhistoria
messages = [
    {
        "role": "system",
        "content": "Olet maksujen seuranta-avustaja. "
                   "Vastaa ytimekkäästi englanniksi."
    }
]

Täydellinen keskustelusilmukka

Alla oleva koodi toimii kahdessa vaiheessa. process_tool_calls suorittaa kaikki mallin pyytämät kutsut ja aloittaa keskustelun uudelleen tulosten kanssa; chat hoitaa koko vuoron käyttäjän syötteestä lopulliseen tekstiin.

def process_tool_calls(response, messages, available_functions, tools):
    """Käsittelee tool_callsit ja palauttaa lopullisen vastauksen."""
    message = response.choices[0].message
    messages.append(message)

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

        if function_name in available_functions:
            result = available_functions[function_name](**function_params)
        else:
            result = json.dumps({"error": f"Tuntematon funktio {function_name}"})

        messages.append({
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        })

    # Kutsu mallia uudelleen tulosten kanssa
    return client.chat.complete(
        model=model, messages=messages, tools=tools
    )


def chat(user_input: str, messages: list, tools: list,
         available_functions: dict) -> str:
    """Käsittelee täydellisen keskusteluvuoron."""
    messages.append({"role": "user", "content": user_input})

    response = client.chat.complete(
        model=model, messages=messages, tools=tools
    )

    message = response.choices[0].message

    # Toista niin kauan kuin malli haluaa kutsua funktioita
    while message.tool_calls and len(message.tool_calls) > 0:
        response = process_tool_calls(
            response, messages, available_functions, tools
        )
        message = response.choices[0].message

    # Malli on valmis – se vastaa tekstillä
    messages.append(message)
    return message.content

while-silmukka on kriittinen osa. Funktiotuloksen vastaanottamisen jälkeen malli saattaa hyvin pyytää toistakin: silmukka jatkuu niin kauan kuin se tuottaa tool_calls-kutsuja ja pysähtyy vasta, kun se viimein palauttaa tekstiä. Pelkkä if-lause käsittelisi ensimmäisen kutsun ja palauttaisi sitten tyhjän vastauksen kaikissa tapauksissa, joissa tarvittaisiin kahta kutsua.

Monivaiheisen keskustelun esimerkki

Katsotaan, miltä tämä silmukka näyttää neljän ketjutetun vuoron yli.

# Vuoro 1
reponse = chat("Mikä on maksun T1001 tila?",
               messages, tools, available_functions)
print(f"Avustaja : {reponse}")
# → "Maksun T1001 tila: maksettu."

# Vuoro 2 — jatkokysymys
reponse = chat("Milloin se tehtiin?",
               messages, tools, available_functions)
print(f"Avustaja : {reponse}")
# → "Maksu T1001 tehtiin 15. maaliskuuta 2026."

# Vuoro 3 — uusi tapahtuma
reponse = chat("Vertaa maksuun T1003.",
               messages, tools, available_functions)
print(f"Avustaja : {reponse}")
# → "Maksu T1003 on vireillä, toisin kuin T1001, joka on maksettu."

# Vuoro 4 — kysymys ilman funktiota
reponse = chat("Kiitos, siinä kaikki tältä päivältä.",
               messages, tools, available_functions)
print(f"Avustaja : {reponse}")
# → "Ole hyvä! Kysy rohkeasti, jos sinulla on muita kysymyksiä."

Vuoro 2 on se, jota kannattaa tarkastella lähemmin. “Milloin se tehtiin?” ei sisällä tunnisteita; historia on se, mikä mahdollistaa mallin ymmärtää, että tämä viittaa edelleen T1001:een ja kutsua retrieve_payment_date oikealla argumentilla. Poista viestit vuorosta 1, ja tämä lause muuttuu ratkaisemattomaksi. Vuorossa 3 malli voi päättää kutsua useita funktioita – tilan ja päivämäärän T1003:lle – rakentaakseen vertailun tuloksiin, jotka on jo saatu T1001:lle. Vuoro 4 ei laukaise lainkaan kutsuja: malli tietää myös, milloin pitää pidättyä.

Peräkkäisten kutsujen ketjuttaminen

Jotkin pyynnöt vaativat mallia odottamaan yhtä tulosta ennen kuin se tietää, mitä seuraavaksi kysyä. chat()-funktion while-silmukka hoitaa tämän tapauksen ilman ainuttakaan ylimääräistä koodiriviä.

# Käyttäjä pyytää jotain, joka vaatii 2 peräkkäistä kutsua
reponse = chat(
    "Näytä minulle maksun T1002 tila ja päivämäärä.",
    messages, tools, available_functions
)
# Malli voi:
# 1. Kutsua retrieve_payment_status(T1002)
# 2. Vastaanottaa tuloksen
# 3. Kutsua retrieve_payment_date(T1002)
# 4. Vastaanottaa tuloksen
# 5. Muotoilla lopullisen vastauksen molempien tietojen kanssa

Viestihistorian näkökulmasta peräkkäinen virta näyttää tältä:

käyttäjä → avustaja(tool_call_1) → työkalu(result_1) → avustaja(tool_call_2) → työkalu(result_2) → avustaja(vastaus)

Laske avustajan vuorot: kolme, mikä tarkoittaa kolmea API:lle laskutettua pyyntöä. Tämä on peräkkäisen suorituksen hinta, ja syy siihen, miksi seuraava oppitunti keskittyy rinnakkaiskutsuihin.

Historian koon hallinta

Tuotantoympäristössä pitkään jatkuva keskustelu tulee kalliiksi: jokainen vuoro lähettää takaisin koko aiempien viestien joukon, ja token-lasku kasvaa neliöllisesti. Yksinkertainen strategia on pitää vain järjestelmäviesti ja viimeisimmät vaihdot.

def trim_messages(messages: list, max_messages: int = 20) -> list:
    """Säilyttää järjestelmäviestin ja viimeiset N viestiä."""
    system_messages = [m for m in messages if hasattr(m, "role")
                       and m.get("role") == "system"
                       or (isinstance(m, dict) and m.get("role") == "system")]

    non_system = [m for m in messages if m not in system_messages]

    if len(non_system) > max_messages:
        non_system = non_system[-max_messages:]

    return system_messages + non_system

Yksi varotoimi ennen tämän funktion kytkemistä: älä koskaan katkaise tool_call-kutsua ilman siihen kuuluvaa tool-viestiä. Jos katkaisu osuu näiden kahden väliin, API vastaanottaa vastaamattoman kutsupyynnön ja hylkää kyselyn. Säädä katkaisukohtaa säilyttääksesi täydelliset parit sen sijaan, että lasket viestejä sokeasti.

Keskeiset asiat

  • Ylläpidä täydellistä historiaa viesteistä, jotta malli ymmärtää kontekstin
  • Käytä while-silmukkaa käsitelläksesi peräkkäisiä funktiokutsuja
  • Malli ymmärtää implisiittiset viittaukset (“tuo”, “edellinen”) kontekstin ansiosta
  • Tuotannossa rajoita historian kokoa pitäen kuitenkin tool_call/tool-parit ehjinä
  • Tässä esitetty chat()-funktio on uudelleenkäytettävä malli mihin tahansa funktiokutsuja hyödyntävään sovellukseen