Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Pogovor z več krogi

Lekcija 7 od 14 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Onkraj enojnih klicev
  2. Načelo: Ohranjanje zgodovine
  3. Popolna zanka pogovora
  4. Primer pogovora z več krogi
  5. Povezovanje zaporednih klicev
  6. Upravljanje velikosti zgodovine
  7. Ključne ugotovitve

Onkraj enojnih klicev

V realnih aplikacijah uporabniki ne postavijo enega vprašanja in nato izginejo. Povezujejo zahteve, se vračajo k prejšnjim temam in namigujejo s stavki, kot je “kaj pa ta?”, ki jih sam stavek ne more razrešiti. Klicanje funkcij mora delovati v kontekstu pogovora z več krogi, kjer lahko model kliče funkcije ob vsakem koraku dialoga, ne da bi kdaj izgubil sled tem, kar je bilo prej.

Načelo: Ohranjanje zgodovine

Ključ se skriva v enem stavku: vsa sporočila hrani v seznamu, ki z vsako izmenjavo raste. Model med klici API-ja nima lastnega spomina; edini kontekst, ki ga ima, je tisto, kar mu pošlješ nazaj. Prav ta popolna zgodovina mu omogoča razumevanje implicitnih sklicev.

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"

# Zgodovina pogovora
messages = [
    {
        "role": "system",
        "content": "You are a payment tracking assistant. "
                   "Respond in concise English."
    }
]

Popolna zanka pogovora

Spodnja koda deluje v dveh fazah. process_tool_calls izvede vse klice, ki jih zahteva model, in ponovno zažene pogovor z rezultati; chat pa obravnava celoten krog, od uporabnikovega vnosa do končnega besedila.

def process_tool_calls(response, messages, available_functions, tools):
    """Obdela tool_calls in vrne končni odgovor."""
    message = response.choices[0].message
    messages.append(message)

    # Izvedi vsak 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
        })

    # Ponovno pokliči model z rezultati
    return client.chat.complete(
        model=model, messages=messages, tools=tools
    )


def chat(user_input: str, messages: list, tools: list,
         available_functions: dict) -> str:
    """Obdela celoten krog pogovora."""
    messages.append({"role": "user", "content": user_input})

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

    message = response.choices[0].message

    # Ponavljaj, dokler model želi klicati funkcije
    while message.tool_calls and len(message.tool_calls) > 0:
        response = process_tool_calls(
            response, messages, available_functions, tools
        )
        message = response.choices[0].message

    # Model je končal – odgovori z besedilom
    messages.append(message)
    return message.content

Zanka while je ključni del. Ko model prejme rezultat funkcije, lahko zahteva še enega: zanka se nadaljuje, dokler model proizvaja tool_calls, in se ustavi šele, ko končno vrne besedilo. Preprost if bi obdelal prvi klic, nato pa bi v primeru, ko sta potrebna dva klica, vrnil prazen odgovor.

Primer pogovora z več krogi

Oglejmo si, kako ta zanka deluje skozi štiri zaporedne kroge.

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

# Krog 2 – nadaljevalno vprašanje
reponse = chat("When was it made?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 was made on March 15, 2026."

# Krog 3 – nova transakcija
reponse = chat("Compare with payment T1003.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1003 is pending, unlike T1001 which is paid."

# Krog 4 – vprašanje brez funkcije
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."

Krog 2 je tisti, ki si ga moraš natančneje ogledati. “When was it made?” ne vsebuje identifikatorja; zgodovina je tista, ki modelu omogoči razumeti, da se to še vedno nanaša na T1001, in poklicati retrieve_payment_date s pravilnim argumentom. Če iz zgodovine odstraniš sporočila iz 1. kroga, ta stavek postane nerešljiv. V 3. krogu se model lahko odloči za klic več funkcij – status in datum za T1003 –, da zgradi primerjavo z rezultati, že pridobljenimi za T1001. 4. krog ne sproži nobenega klica: model ve tudi, kdaj se mora vzdržati.

Povezovanje zaporednih klicev

Nekatere zahteve od modela zahtevajo, da počaka na en rezultat, preden ve, kaj naj vpraša naprej. Zanka while v funkciji chat() ta primer obdela brez ene same dodatne vrstice kode.

# Uporabnik zahteva nekaj, kar potrebuje 2 zaporedna klica
reponse = chat(
    "Show me the status and date of payment T1002.",
    messages, tools, available_functions
)
# Model lahko:
# 1. Pokliče retrieve_payment_status(T1002)
# 2. Prejme rezultat
# 3. Pokliče retrieve_payment_date(T1002)
# 4. Prejme rezultat
# 5. Oblikuje končni odgovor z obema informacijama

Če pogledamo zgodovino sporočil, zaporedni tok izgleda takole:

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

Preštej obrate asistenta: trije, kar pomeni tri zahteve, zaračunane API-ju. To je cena zaporednega izvajanja in razlog, zakaj se naslednja lekcija osredotoča na vzporedne klice.

Upravljanje velikosti zgodovine

V proizvodnem okolju dolg pogovor postane drag: vsak krog pošlje nazaj celoten niz prejšnjih sporočil, račun za žetone pa raste kvadratno. Preprosta strategija je, da obdržiš le sistemsko sporočilo in najnovejše izmenjave.

def trim_messages(messages: list, max_messages: int = 20) -> list:
    """Ohrani sistemsko sporočilo in zadnjih N sporočil."""
    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

Preden to funkcijo vključiš, bodi previden: nikoli ne prereži tool_call brez pripadajočega sporočila tool. Če se obrezovanje zgodi med njima, API prejme neodgovorjeno zahtevo za klic in zavrne poizvedbo. Točko reza prilagodi tako, da ohraniš celotne pare, namesto da bi slepo štel sporočila.

Ključne ugotovitve

  • Ohrani popolno zgodovino sporočil, da model razume kontekst
  • Uporabi zanko while za obravnavo zaporednih klicev funkcij
  • Model razume implicitne sklice („ta”, „prejšnji”) zahvaljujoč kontekstu
  • V proizvodnem okolju omeji velikost zgodovine, hkrati pa ohrani pare tool_call/tool nedotaknjene
  • Funkcija chat(), prikazana tukaj, je vzorec, ki ga lahko ponovno uporabiš v kateri koli aplikaciji za klicanje funkcij