Rozmowa wieloturowa
Na tej stronie
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