Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Konverzácia s viacerými kolami

Lekcia 7 z 14 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Viac než jednotlivé volania
  2. Princíp: Udržiavanie histórie
  3. Kompletná slučka konverzácie
  4. Príklad konverzácie s viacerými kolami
  5. Reťazenie sekvenčných volaní
  6. Správa veľkosti histórie
  7. Kľúčové poznatky

Viac než jednotlivé volania

V reálnej aplikácii sa používatelia neopýtajú na jednu otázku a potom neodídu. Spájajú požiadavky, vracajú sa k predchádzajúcim témam a púšťajú náznaky ako „čo táto?“, ktoré samotná veta nedokáže vyriešiť. Volanie funkcií musí fungovať v kontexte konverzácie s viacerými kolami, kde model môže volať funkcie v každom kroku dialógu, pričom nikdy nestratí prehľad o tom, čo bolo predtým.

Princíp: Udržiavanie histórie

Kľúč sa dá zhrnúť do jednej vety: uchovávaj všetky správy v zozname, ktorý sa s každou výmenou rozrastá. Model si medzi volaniami API nič nepamätá; jediný kontext, ktorý má, je to, čo mu pošleš späť. Práve táto úplná história mu umožňuje pochopiť implicitné odkazy.

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"

# História konverzácie
messages = [
    {
        "role": "system",
        "content": "You are a payment tracking assistant. "
                   "Respond in concise English."
    }
]

Kompletná slučka konverzácie

Nižšie uvedený kód funguje v dvoch fázach. process_tool_calls vykoná všetky volania požadované modelom a reštartuje konverzáciu s výsledkami; chat spracuje celé kolo od vstupu používateľa až po finálny text.

def process_tool_calls(response, messages, available_functions, tools):
    """Spracuje tool_calls a vráti konečnú odpoveď."""
    message = response.choices[0].message
    messages.append(message)

    # Vykonanie každého 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
        })

    # Opätovné volanie modelu s výsledkami
    return client.chat.complete(
        model=model, messages=messages, tools=tools
    )


def chat(user_input: str, messages: list, tools: list,
         available_functions: dict) -> str:
    """Spracuje kompletné kolo konverzácie."""
    messages.append({"role": "user", "content": user_input})

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

    message = response.choices[0].message

    # Cyklus pokračuje, kým model chce volať funkcie
    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 skončil – odpovedá textom
    messages.append(message)
    return message.content

Slučka while je kľúčovým prvkom. Po získaní výsledku funkcie môže model pokojne požadovať ďalší: slučka pokračuje, kým produkuje tool_calls, a zastaví sa až vtedy, keď konečne vráti text. Jednoduché if by vybavilo prvé volanie a následne by vrátilo prázdnu odpoveď v každom prípade, keď boli potrebné dve volania.

Príklad konverzácie s viacerými kolami

Pozrime sa, ako táto slučka vyzerá naprieč štyrmi prepojenými kolami.

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

# Kolo 2 — nadväzujúca otázka
reponse = chat("When was it made?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 was made on March 15, 2026."

# Kolo 3 — nová transakcia
reponse = chat("Compare with payment T1003.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1003 is pending, unlike T1001 which is paid."

# Kolo 4 — otázka bez funkcie
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."

Druhé kolo si zaslúži podrobnejšiu pozornosť. Veta „Kedy bola uskutočnená?“ neobsahuje žiadny identifikátor; práve história umožňuje modelu pochopiť, že sa stále odkazuje na T1001, a zavolať retrieve_payment_date so správnym argumentom. Odstráň správy z prvého kola a táto veta sa stane nevyriešiteľnou. V treťom kole sa model môže rozhodnúť zavolať viacero funkcií – stav a dátum pre T1003 –, aby zostavil porovnanie s výsledkami už získanými pre T1001. Štvrté kolo nespustí žiadne volania: model vie aj kedy sa zdržať.

Reťazenie sekvenčných volaní

Niektoré požiadavky vyžadujú, aby model počkal na jeden výsledok, než zistí, čo sa má opýtať ďalej. Slučka while vo funkcii chat() tento prípad zvláda bez jediného riadku kódu navyše.

# Používateľ požiada o niečo, čo si vyžaduje 2 sekvenčné volania
reponse = chat(
    "Show me the status and date of payment T1002.",
    messages, tools, available_functions
)
# Model môže:
# 1. Zavolať retrieve_payment_status(T1002)
# 2. Prijať výsledok
# 3. Zavolať retrieve_payment_date(T1002)
# 4. Prijať výsledok
# 5. Sformulovať konečnú odpoveď s oboma informáciami

Z pohľadu histórie správ vyzerá sekvenčný tok takto:

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

Spočítaj kroky asistenta: tri, čo znamená tri požiadavky fakturované API. To sú náklady sekvenčného vykonávania a dôvod, prečo sa nasledujúca lekcia zameriava na paralelné volania.

Správa veľkosti histórie

V produkcii sa dlhotrvajúca konverzácia stáva nákladnou: každé kolo posiela späť celú sadu predchádzajúcich správ a účet za tokeny rastie kvadraticky. Jednoduchou stratégiou je ponechať si iba systémovú správu a najnovšie výmeny.

def trim_messages(messages: list, max_messages: int = 20) -> list:
    """Ponechá systémovú správu a posledných N správ."""
    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

Pred zapojením tejto funkcie si daj pozor na jednu vec: nikdy neorež tool_call bez jeho zodpovedajúcej správy tool. Ak by orezanie dopadlo medzi ne, API dostane nevybavenú požiadavku na volanie a query zamietne. Uprav bod orezania tak, aby si zachoval kompletné páry, namiesto slepého počítania správ.

Kľúčové poznatky

  • Udržiavaj úplnú históriu správ, aby model chápal kontext
  • Použi slučku while na spracovanie sekvenčných volaní funkcií
  • Model chápe implicitné odkazy („tento“, „predchádzajúci“) vďaka kontextu
  • V produkcii obmedz veľkosť histórie, pričom zachovaj páry tool_call/tool nedotknuté
  • Funkcia chat() uvedená tu je opakovateľný vzor pre akúkoľvek aplikáciu využívajúcu volanie funkcií