Przejdź do głównej treści
Polski— Wybierz język
Menu

Rozmowa wieloturowa

Lekcja 7 z 14 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Poza pojedynczymi wywołaniami
  2. Zasada: Utrzymuj historię
  3. Pełna pętla rozmowy
  4. Przykład rozmowy wieloturowej
  5. Łączenie wywołań sekwencyjnych
  6. Zarządzanie rozmiarem historii
  7. Kluczowe wnioski

Poza pojedynczymi wywołaniami

W rzeczywistej aplikacji użytkownicy nie zadają jednego pytania i nie znikają. Łączą żądania w łańcuchy, wracają do wcześniejszych tematów i rzucają wskazówki typu „a co z tym?“, których samo zdanie nie pozwala rozwiązać. Wywoływanie funkcji musi działać w kontekście rozmowy wieloturowej, gdzie model może wywoływać funkcje na każdym etapie dialogu, nigdy nie tracąc z oczu tego, co wydarzyło się wcześniej.

Zasada: Utrzymuj historię

Klucz sprowadza się do jednego zdania: przechowuj wszystkie wiadomości na liście, która rośnie z każdą wymianą. Model nie posiada własnej pamięci między wywołaniami API; jedynym kontekstem, jaki ma, jest to, co mu wyślesz. To kompletna historia pozwala mu zrozumieć niejawne odniesienia.

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"

# Historia rozmowy
messages = [
    {
        "role": "system",
        "content": "Jesteś asystentem do śledzenia płatności. "
                   "Odpowiadaj w zwięzłym języku angielskim."
    }
]

Pełna pętla rozmowy

Poniższy kod działa w dwóch etapach. process_tool_calls wykonuje wszystkie wywołania zażądane przez model i restartuje rozmowę z wynikami; chat obsługuje pełny tur, od danych wejściowych użytkownika do końcowego tekstu.

def process_tool_calls(response, messages, available_functions, tools):
    """Przetwarza tool_calls i zwraca ostateczną odpowiedź."""
    message = response.choices[0].message
    messages.append(message)

    # Wykonaj każde 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"Nieznana funkcja {function_name}"})

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

    # Wywołaj model ponownie z wynikami
    return client.chat.complete(
        model=model, messages=messages, tools=tools
    )


def chat(user_input: str, messages: list, tools: list,
         available_functions: dict) -> str:
    """Obsługuje pełny tur rozmowy."""
    messages.append({"role": "user", "content": user_input})

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

    message = response.choices[0].message

    # Kontynuuj pętlę, dopóki model chce wywoływać funkcje
    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 skończył – odpowiada tekstem
    messages.append(message)
    return message.content

Pętla while jest kluczowym elementem. Po otrzymaniu wyniku funkcji model może zażądać kolejnego: pętla trwa tak długo, jak długo generowane są tool_calls, i kończy się dopiero, gdy model zwróci tekst. Proste if obsłużyłoby pierwsze wywołanie, a następnie zwróciłoby pustą odpowiedź w każdym przypadku, gdy potrzebne byłyby dwa wywołania.

Przykład rozmowy wieloturowej

Zobaczmy, jak ta pętla wygląda w przypadku czterech połączonych turów.

# Tur 1
reponse = chat("Jaki jest status płatności T1001?",
               messages, tools, available_functions)
print(f"Asystent : {reponse}")
# → "Status płatności T1001: opłacona."

# Tur 2 — pytanie uzupełniające
reponse = chat("Kiedy została dokonana?",
               messages, tools, available_functions)
print(f"Asystent : {reponse}")
# → "Płatność T1001 została dokonana 15 marca 2026 r."

# Tur 3 — nowa transakcja
reponse = chat("Porównaj z płatnością T1003.",
               messages, tools, available_functions)
print(f"Asystent : {reponse}")
# → "Płatność T1003 oczekuje, w przeciwieństwie do T1001, która jest opłacona."

# Tur 4 — pytanie bez funkcji
reponse = chat("Dziękuję, to wszystko na dziś.",
               messages, tools, available_functions)
print(f"Asystent : {reponse}")
# → "Proszę bardzo! Śmiało pytaj, jeśli masz inne pytania."

Tur 2 wymaga szczególnej uwagi. „Kiedy została dokonana?“ nie zawiera identyfikatora; to historia pozwala modelowi zrozumieć, że nadal chodzi o T1001 i wywołać retrieve_payment_date z właściwym argumentem. Usuń wiadomości z Turu 1, a to zdanie stanie się nierozwiązywalne. W Turze 3 model może zdecydować się na wywołanie wielu funkcji — statusu i daty dla T1003 — aby zbudować porównanie z wynikami już uzyskanymi dla T1001. Tur 4 nie uruchamia żadnych wywołań: model wie również, kiedy się wstrzymać.

Łączenie wywołań sekwencyjnych

Niektóre żądania wymagają, aby model poczekał na jeden wynik, zanim będzie wiedział, o co poprosić dalej. Pętla while w funkcji chat() obsługuje ten przypadek bez ani jednej dodatkowej linii kodu.

# Użytkownik prosi o coś wymagającego 2 sekwencyjnych wywołań
reponse = chat(
    "Pokaż mi status i datę płatności T1002.",
    messages, tools, available_functions
)
# Model może:
# 1. Wywołać retrieve_payment_status(T1002)
# 2. Otrzymać wynik
# 3. Wywołać retrieve_payment_date(T1002)
# 4. Otrzymać wynik
# 5. Sformułować ostateczną odpowiedź zawierającą obie informacje

Patrząc na historię wiadomości, przepływ sekwencyjny wygląda następująco:

użytkownik → asystent(tool_call_1) → narzędzie(result_1) → asystent(tool_call_2) → narzędzie(result_2) → asystent(odpowiedź)

Policz tury asystenta: trzy, co oznacza trzy żądania rozliczane przez API. To koszt wykonania sekwencyjnego i powód, dla którego następna lekcja skupia się na wywołaniach równoległych.

Zarządzanie rozmiarem historii

W środowisku produkcyjnym długotrwała rozmowa staje się kosztowna: każdy tur wysyła z powrotem cały zestaw poprzednich wiadomości, a rachunek za tokeny rośnie kwadratowo. Prostą strategią jest utrzymanie tylko wiadomości systemowej i najnowszych wymian.

def trim_messages(messages: list, max_messages: int = 20) -> list:
    """Zachowuje wiadomość systemową i ostatnie N wiadomości."""
    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 uwaga przed podpięciem tej funkcji: nigdy nie ucinaj tool_call bez odpowiadającej mu wiadomości tool. Jeśli przycięcie wypadnie między nimi, API otrzyma żądanie wywołania bez odpowiedzi i odrzuci zapytanie. Dostosuj punkt cięcia tak, aby zachować kompletne pary, zamiast ślepo liczyć wiadomości.

Kluczowe wnioski

  • Utrzymuj kompletną historię wiadomości, aby model rozumiał kontekst
  • Używaj pętli while do obsługi sekwencyjnych wywołań funkcji
  • Dzięki kontekstowi model rozumie niejawne odniesienia („ten“, „poprzedni“)
  • W środowisku produkcyjnym ograniczaj rozmiar historii, zachowując nienaruszone pary tool_call/tool
  • Przedstawiona tutaj funkcja chat() to wzorzec wielokrotnego użytku dla każdej aplikacji wykorzystującej wywoływanie funkcji