Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Konverzace s více obraty

Lekce 7 z 14 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Za hranicí jednoho volání
  2. Princip: Udržování historie
  3. Kompletní smyčka konverzace
  4. Příklad konverzace s více obraty
  5. Řetězení sekvenčních volání
  6. Správa velikosti historie
  7. Klíčové poznatky

Za hranicí jednoho volání

V reálné aplikaci se uživatelé nezeptají jednou a pak zmizí. Řetězí požadavky, vracejí se k předchozím tématům a používají náznaky typu „co třeba tenhle?“, které samotná věta nedokáže vyřešit. Volání funkcí musí fungovat v kontextu této konverzace s více obraty, kde model může volat funkce v každém kroku dialogu, aniž by kdy ztratil přehled o tom, co bylo předtím.

Princip: Udržování historie

Klíč se vejde do jedné věty: udržuj všechny zprávy v seznamu, který se s každou výměnou rozrůstá. Model nemá mezi voláními API žádnou vlastní paměť; jediný kontext, který má, je to, co mu pošleš zpět. Právě tato úplná historie mu umožňuje chápat 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"

# Historie konverzace
messages = [
    {
        "role": "system",
        "content": "Jsi asistent pro sledování plateb. "
                   "Odpovídej stručně v angličtině."
    }
]

Kompletní smyčka konverzace

Níže uvedený kód funguje ve dvou fázích. process_tool_calls provede všechna volání požadovaná modelem a restartuje konverzaci s výsledky; chat zpracuje celý obrat, od vstupu uživatele až po finální text.

def process_tool_calls(response, messages, available_functions, tools):
    """Zpracuje tool_calls a vrátí konečnou odpověď."""
    message = response.choices[0].message
    messages.append(message)

    # Provedení 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"Neznámá funkce {function_name}"})

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

    # Opětovné volání modelu s výsledky
    return client.chat.complete(
        model=model, messages=messages, tools=tools
    )


def chat(user_input: str, messages: list, tools: list,
         available_functions: dict) -> str:
    """Zpracuje kompletní obrat konverzace."""
    messages.append({"role": "user", "content": user_input})

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

    message = response.choices[0].message

    # Smyčka dokud model chce volat funkce
    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 – odpovídá textem
    messages.append(message)
    return message.content

Smyčka while je tím kritickým prvkem. Po obdržení výsledku funkce může model klidně požádat o další: smyčka pokračuje, dokud produkuje tool_calls, a zastaví se až tehdy, když konečně vrátí text. Prosté if by zpracovalo první volání a následně by vrátilo prázdnou odpověď v jakémkoli případě, kdy by byla potřeba dvě volání.

Příklad konverzace s více obraty

Podívejme se, jak tato smyčka vypadá napříč čtyřmi řetězenými obraty.

# Obrat 1
reponse = chat("Jaký je stav platby T1001?",
               messages, tools, available_functions)
print(f"Asistent : {reponse}")
# → "Stav platby T1001: zaplaceno."

# Obrat 2 — navazující otázka
reponse = chat("Kdy byla provedena?",
               messages, tools, available_functions)
print(f"Asistent : {reponse}")
# → "Platba T1001 byla provedena 15. března 2026."

# Obrat 3 — nová transakce
reponse = chat("Porovnej s platbou T1003.",
               messages, tools, available_functions)
print(f"Asistent : {reponse}")
# → "Platba T1003 čeká na vyřízení, na rozdíl od T1001, která je zaplacena."

# Obrat 4 — otázka bez funkce
reponse = chat("Díky, to je pro dnešek vše.",
               messages, tools, available_functions)
print(f"Asistent : {reponse}")
# → "Není zač! Neváhej se zeptat, pokud budeš mít další otázky."

Obrat 2 je ten, na který se musíš podívat pozorně. „Kdy byla provedena?“ neobsahuje žádný identifikátor; právě historie umožňuje modelu pochopit, že se stále odkazuje na T1001, a zavolat retrieve_payment_date se správným argumentem. Odstraň zprávy z Obratu 1 a tato věta se stane neřešitelnou. V Obratu 3 se model může rozhodnout zavolat více funkcí – stav a datum pro T1003 – aby vytvořil srovnání s výsledky již získanými pro T1001. Obrat 4 nespustí žádná volání: model také ví, kdy se má zdržet.

Řetězení sekvenčních volání

Některé požadavky vyžadují, aby model počkal na jeden výsledek, než zjistí, na co se má zeptat dál. Smyčka while v chat() tento případ zvládne bez jediného řádku kódu navíc.

# Uživatel požádá o něco, co vyžaduje 2 sekvenční volání
reponse = chat(
    "Ukaž mi stav a datum platby T1002.",
    messages, tools, available_functions
)
# Model může:
# 1. Zavolat retrieve_payment_status(T1002)
# 2. Obdržet výsledek
# 3. Zavolat retrieve_payment_date(T1002)
# 4. Obdržet výsledek
# 5. Formulovat konečnou odpověď s oběma informacemi

Pohledem na historii zpráv vypadá sekvenční tok takto:

uživatel → asistent(tool_call_1) → nástroj(result_1) → asistent(tool_call_2) → nástroj(result_2) → asistent(odpověď)

Spočítej obraty asistenta: tři, což znamená tři požadavky fakturované API. To je cena sekvenčního provádění a důvod, proč se další lekce zaměří na paralelní volání.

Správa velikosti historie

V produkčním prostředí se dlouhotrvající konverzace stává drahou: každý obrat posílá zpět celou sadu předchozích zpráv a účet za tokeny roste kvadraticky. Jednoduchou strategií je ponechat pouze systémovou zprávu a nejnovější výměny.

def trim_messages(messages: list, max_messages: int = 20) -> list:
    """Ponechá systémovou zprávu a posledních N zprá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

Jedna opatrnost před zapojením této funkce: nikdy neusekni tool_call bez jeho odpovídající zprávy tool. Pokud oříznutí dopadne mezi ně, API obdrží nezodpovězený požadavek na volání a dotaz zamítne. Uprav bod oříznutí tak, aby zachoval kompletní páry, místo abys slepě počítal zprávy.

Klíčové poznatky

  • Udržuj úplnou historii zpráv, aby model chápal kontext
  • Používej smyčku while pro zpracování sekvenčních volání funkcí
  • Model chápe implicitní odkazy („tenhle“, „předchozí“) díky kontextu
  • V produkci omez velikost historie, přičemž zachovej páry tool_call/tool nedotčené
  • Funkce chat() zde ukázaná je znovu použitelným vzorem pro jakoukoli aplikaci využívající volání funkcí