Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Samtaler over flere omgange

Lektion 7 af 14 Opdateret 2. november 2026 Udvikler
På denne side
  1. Ud over enkelte kald
  2. Princippet: Vedligehold historik
  3. Komplet samtaleløkke
  4. Eksempel på samtale over flere omgange
  5. Kædning af sekventielle kald
  6. Håndtering af historikstørrelse
  7. Vigtige pointer

Ud over enkelte kald

I en rigtig applikation stiller brugere ikke blot ét spørgsmål og forsvinder. De kæder anmodninger sammen, vender tilbage til tidligere emner og kommer med antydninger som „hvad med denne her?”, som sætningen alene ikke kan løse. Funktionskald skal fungere i denne kontekst med samtaler over flere omgange, hvor modellen kan kalde funktioner ved hvert skridt i dialogen uden nogensinde at miste overblikket over, hvad der skete før.

Princippet: Vedligehold historik

Nøglen kan opsummeres i én sætning: Gem alle beskeder i en liste, der vokser med hver udveksling. Modellen har ingen egen hukommelse mellem API-kald; den eneste kontekst, den har, er det, du sender tilbage. Det er denne fuldstændige historik, der gør det muligt for den at forstå implicitte referencer.

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"

# Samtalehistorik
messages = [
    {
        "role": "system",
        "content": "Du er en assistent til sporing af betalinger. "
                   "Svar på koncist engelsk."
    }
]

Komplet samtaleløkke

Koden nedenfor fungerer i to trin. process_tool_calls udfører alle kald, som modellen anmoder om, og genstarter samtalen med resultaterne; chat håndterer en hel omgang, fra brugerens input til det endelige svar.

def process_tool_calls(response, messages, available_functions, tools):
    """Behandler tool_calls og returnerer det endelige svar."""
    message = response.choices[0].message
    messages.append(message)

    # Udfør hvert 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"Ukendt funktion {function_name}"})

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

    # Kald modellen igen med resultaterne
    return client.chat.complete(
        model=model, messages=messages, tools=tools
    )


def chat(user_input: str, messages: list, tools: list,
         available_functions: dict) -> str:
    """Håndterer en komplet samtaleomgang."""
    messages.append({"role": "user", "content": user_input})

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

    message = response.choices[0].message

    # Fortsæt løkken, så længe modellen ønsker at kalde funktioner
    while message.tool_calls and len(message.tool_calls) > 0:
        response = process_tool_calls(
            response, messages, available_functions, tools
        )
        message = response.choices[0].message

    # Modellen er færdig – den svarer med tekst
    messages.append(message)
    return message.content

while-løkken er det afgørende element. Efter at have modtaget et funktionsresultat kan modellen sagtens anmode om endnu et: løkken fortsætter, så længe den producerer tool_calls, og stopper først, når den endelig returnerer tekst. Et simpelt if ville kun håndtere det første kald og derefter returnere et tomt svar i alle tilfælde, hvor to kald var nødvendige.

Eksempel på samtale over flere omgange

Lad os se på, hvordan denne løkke ser ud over fire kædede omgange.

# Omgang 1
reponse = chat("Hvad er status for betaling T1001?",
               messages, tools, available_functions)
print(f"Assistent : {reponse}")
# → "Status for betaling T1001: betalt."

# Omgang 2 – opfølgningsspørgsmål
reponse = chat("Hvornår blev den foretaget?",
               messages, tools, available_functions)
print(f"Assistent : {reponse}")
# → "Betaling T1001 blev foretaget den 15. marts 2026."

# Omgang 3 – ny transaktion
reponse = chat("Sammenlign med betaling T1003.",
               messages, tools, available_functions)
print(f"Assistent : {reponse}")
# → "Betaling T1003 afventer, i modsætning til T1001, som er betalt."

# Omgang 4 – spørgsmål uden funktion
reponse = chat("Tak, det var alt for i dag.",
               messages, tools, available_functions)
print(f"Assistent : {reponse}")
# → "Det var så lidt! Du er velkommen til at spørge, hvis du har andre spørgsmål."

Omgang 2 er den, du skal se nærmere på. „Hvornår blev den foretaget?” indeholder ingen identifikator; det er historikken, der gør det muligt for modellen at forstå, at dette stadig refererer til T1001, og at kalde retrieve_payment_date med det korrekte argument. Fjern beskederne fra omgang 1, og denne sætning bliver uløselig. I omgang 3 kan modellen beslutte at kalde flere funktioner – status og dato for T1003 – for at opbygge sammenligningen med resultater, der allerede er opnået for T1001. Omgang 4 udløser slet ingen kald: modellen ved også, hvornår den skal holde igen.

Kædning af sekventielle kald

Nogle anmodninger kræver, at modellen venter på ét resultat, før den ved, hvad den skal spørge om næste gang. while-løkken i chat() håndterer dette tilfælde uden en eneste ekstra kode linje.

# Brugeren spørger om noget, der kræver 2 sekventielle kald
reponse = chat(
    "Vis mig status og dato for betaling T1002.",
    messages, tools, available_functions
)
# Modellen kan:
# 1. Kalde retrieve_payment_status(T1002)
# 2. Modtage resultatet
# 3. Kalde retrieve_payment_date(T1002)
# 4. Modtage resultatet
# 5. Formulere det endelige svar med begge oplysninger

Set ud fra beskedhistorikken ser det sekventielle flow sådan ud:

user → assistant(tool_call_1) → tool(result_1) → assistant(tool_call_2) → tool(result_2) → assistant(response)

Tæl assistent-omgangene: tre, hvilket betyder tre anmodninger, der faktureres til API’et. Det er prisen for sekventiel eksekvering, og grunden til at næste lektion fokuserer på parallelle kald.

Håndtering af historikstørrelse

I produktion bliver en langvarig samtale dyr: hver omgang sender hele sættet af tidligere beskeder tilbage, og token-regningen vokser kvadratisk. En simpel strategi er kun at beholde systembeskeden og de seneste udvekslinger.

def trim_messages(messages: list, max_messages: int = 20) -> list:
    """Beholder systembeskeden og de sidste N beskeder."""
    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

Én forholdsregel, før du kobler denne funktion på: Klip aldrig et tool_call uden den tilhørende tool-besked. Hvis afkortningen lander mellem de to, modtager API’et en ubesvaret kaldanmodning og afviser forespørgslen. Justér skæringspunktet, så du bevarer komplette par, i stedet for blindt at tælle beskeder.

Vigtige pointer

  • Vedligehold en fuldstændig historik over beskeder, så modellen forstår konteksten
  • Brug en while-løkke til at håndtere sekventielle funktionskald
  • Modellen forstår implicitte referencer („den der”, „den forrige”) takket være konteksten
  • I produktion skal du begrænse historikstørrelsen, mens du bevarer tool_call/tool-par intakte
  • Funktionen chat(), der vises her, er et genanvendeligt mønster til enhver applikation med funktionskald