Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Konversation över flera omgångar

Lektion 7 av 14 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Utöver enskilda anrop
  2. Principen: Behåll historiken
  3. Kompletterande konversationsloop
  4. Exempel på konversation över flera omgångar
  5. Länkning av sekventiella anrop
  6. Hantering av historikstorlek
  7. Viktiga punkter

Utöver enskilda anrop

I en verklig applikation ställer användaren inte bara en fråga och försvinner sedan. De länkar samman förfrågningar, återvänder till tidigare ämnen och slänger ur sig ledtrådar som “vad gäller den här?” som meningen i sig inte kan lösa. Funktionsanrop måste fungera inom denna kontext av konversation över flera omgångar, där modellen kan anropa funktioner vid varje steg i dialogen utan att någonsin tappa tråden på vad som hände tidigare.

Principen: Behåll historiken

Nyckeln kan sammanfattas i en mening: behåll alla meddelanden i en lista som växer för varje utbyte. Modellen har inget eget minne mellan API-anrop; den enda kontext den har är det du skickar tillbaka. Det är denna kompletta historik som gör att den kan förstå implicita referenser.

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"

# Konversationshistorik
messages = [
    {
        "role": "system",
        "content": "Du är en assistent för betalningsövervakning. "
                   "Svara på koncis engelska."
    }
]

Kompletterande konversationsloop

Koden nedan fungerar i två steg. process_tool_calls exekverar alla anrop som modellen begär och startar om konversationen med resultaten; chat hanterar en hel omgång, från användarens inmatning till det slutgiltiga svaret.

def process_tool_calls(response, messages, available_functions, tools):
    """Bearbetar tool_calls och returnerar det slutgiltiga svaret."""
    message = response.choices[0].message
    messages.append(message)

    # Exekvera varje 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"Unknown function {function_name}"})

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

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


def chat(user_input: str, messages: list, tools: list,
         available_functions: dict) -> str:
    """Hanterar en komplett konversationsomgång."""
    messages.append({"role": "user", "content": user_input})

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

    message = response.choices[0].message

    # Loopa så länge modellen vill anropa 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 är klar – den svarar med text
    messages.append(message)
    return message.content

while-loopen är den kritiska delen. Efter att ha fått ett funktionsresultat kan modellen mycket väl begära ytterligare ett: loopen fortsätter så länge den producerar tool_calls och stoppar först när den slutligen returnerar text. En enkel if-sats skulle hantera det första anropet och sedan returnera ett tomt svar i alla fall där två anrop behövdes.

Exempel på konversation över flera omgångar

Låt oss se hur denna loop ser ut över fyra sammankopplade omgångar.

# Omgång 1
reponse = chat("What is the status of payment T1001?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 status: paid."

# Omgång 2 — uppföljningsfråga
reponse = chat("When was it made?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 was made on March 15, 2026."

# Omgång 3 — ny transaktion
reponse = chat("Compare with payment T1003.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1003 is pending, unlike T1001 which is paid."

# Omgång 4 — fråga utan funktion
reponse = chat("Thanks, that's all for today.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "You're welcome! Feel free to ask if you have other questions."

Omgång 2 är den som kräver noggrann granskning. “When was it made?” innehåller ingen identifierare; det är historiken som gör att modellen förstår att detta fortfarande refererar till T1001 och att den ska anropa retrieve_payment_date med rätt argument. Tar du bort meddelandena från omgång 1 blir denna mening olöslig. I omgång 3 kan modellen besluta sig för att anropa flera funktioner – status och datum för T1003 – för att bygga jämförelsen med resultat som redan erhållits för T1001. Omgång 4 utlöser inga anrop alls: modellen vet också när den ska hålla tillbaka.

Länkning av sekventiella anrop

Vissa förfrågningar kräver att modellen väntar på ett resultat innan den vet vad den ska fråga efter härnäst. while-loopen i chat() hanterar detta fall utan en enda extra kodrad.

# Användaren ber om något som kräver 2 sekventiella anrop
reponse = chat(
    "Show me the status and date of payment T1002.",
    messages, tools, available_functions
)
# Modellen kan:
# 1. Anropa retrieve_payment_status(T1002)
# 2. Ta emot resultatet
# 3. Anropa retrieve_payment_date(T1002)
# 4. Ta emot resultatet
# 5. Formulera det slutgiltiga svaret med båda informationsbitarna

Sett från meddelandehistoriken ser det sekventiella flödet ut så här:

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

Räkna assistentens omgångar: tre, vilket betyder tre förfrågningar som debiteras av API:t. Det är kostnaden för sekventiell exekvering, och anledningen till att nästa lektion fokuserar på parallella anrop.

Hantering av historikstorlek

I produktion blir en långvarig konversation dyr: varje omgång skickar tillbaka hela uppsättningen av tidigare meddelanden, och token-kostnaden växer kvadratiskt. En enkel strategi är att bara behålla systemmeddelandet och de senaste utbytena.

def trim_messages(messages: list, max_messages: int = 20) -> list:
    """Behåller systemmeddelandet och de senaste N meddelandena."""
    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

En försiktighetsåtgärd innan du kopplar in denna funktion: klipp aldrig av ett tool_call utan dess motsvarande tool-meddelande. Om trunkeringen hamnar mellan de två får API:t en obesvarad anropsförfrågan och avvisar frågan. Justera skärningspunkten för att bevara kompletta par snarare än att räkna meddelanden blindt.

Viktiga punkter

  • Behåll en komplett historik av meddelanden så att modellen förstår kontexten
  • Använd en while-loop för att hantera sekventiella funktionsanrop
  • Modellen förstår implicita referenser (“den där”, “den föregående”) tack vare kontexten
  • I produktion, begränsa historikstorleken samtidigt som du behåller tool_call/tool-par intakta
  • Funktionen chat() som visas här är ett återanvändbart mönster för alla applikationer med funktionsanrop