Rozmowy wieloturkowe w Pythonie
Na tej stronie
Pamięć, która tak naprawdę nie jest pamięcią
W przeciwieństwie do wyszukiwarki, model językowy podąża za wątkiem rozmowy: bierze pod uwagę to, co zostało powiedziane wcześniej, i buduje swoje odpowiedzi na podstawie tego zgromadzonego kontekstu. Nazywa się to rozmową wieloturkową (multi-turn), dzięki czemu możliwe są pytania eliptyczne, takie jak „a z argumentami?“.
Technicznie rzecz biorąc, model niczego nie pamięta. Żaden stan nie jest zachowywany na serwerze między wywołaniami. Z każdym żądaniem musisz ponownie wysłać całą historię, którą model odczytuje od początku do końca przed udzieleniem odpowiedzi. Mechanizm ten wyjaśnia dwie kwestie, do których wrócimy później: to Ty ponosisz pełną odpowiedzialność za zarządzanie pamięcią, a każdy tur rozmowy kosztuje więcej niż poprzedni.
Trzy role strukturyzujące historię
Każda wiadomość w historii posiada rolę, która informuje model, kto mówi. Rola system definiuje ogólne zachowanie: umieszczona jako pierwsza, wpływa na każdą kolejną odpowiedź.
{"role": "system", "content": "You are an expert assistant in French cuisine. Always respond in French using precise culinary terms."}
Rola user przenosi wiadomości użytkownika – czyli zadane pytanie lub wysłaną instrukcję:
{"role": "user", "content": "How do I make perfect puff pastry?"}
Na koniec rola assistant zawiera wcześniejsze odpowiedzi modelu. Są to wiadomości, które wstrzykujesz z powrotem do historii, aby zachować spójność. Zapomnienie o nich jest równoznaczne z wymazaniem pamięci rozmowy przy każdym turze.
{"role": "assistant", "content": "To make perfect puff pastry, start by..."}
Pełna rozmowa, tur po turze
Poniższy kod stosuje tę zasadę: funkcja dodaje pytanie do historii, wywołuje model, a następnie zapisuje odpowiedź we właściwym miejscu przed jej zwróceniem.
import os
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
historique = [
{
"role": "system",
"content": "You are a teaching assistant specialized in Python programming. Respond concisely and include code examples."
}
]
def poser_question(question: str) -> str:
"""Sends a question and updates the history."""
historique.append({"role": "user", "content": question})
response = client.chat.complete(
model="mistral-small-latest",
messages=historique,
)
reponse_texte = response.choices[0].message.content
historique.append({"role": "assistant", "content": reponse_texte})
return reponse_texte
# Turn 1
print("Q: What is a decorator in Python?")
r1 = poser_question("What is a decorator in Python?")
print(f"R: {r1}\n")
# Turn 2 — the model knows the context
print("Q: Can you show me a concrete example?")
r2 = poser_question("Can you show me a concrete example?")
print(f"R: {r2}\n")
# Turn 3 — implicit reference to previous turns
print("Q: How do I use it with arguments?")
r3 = poser_question("How do I use it with arguments?")
print(f"R: {r3}\n")
W trzecim turze pytanie ani razu nie wspomina słowa „dekorator“. Model nadal rozumie, że „użyć tego“ odnosi się do tej koncepcji, ponieważ ponownie czyta całą wymianę zdań. Usuń linię dodającą odpowiedź do historii i uruchom kod ponownie: model zapyta, o czym mówisz. To najszybszy dowód na to, że ciągłość nie pochodzi od modelu, ale z Twojego kodu.
Zapobieganie wygórowanym kosztom historii
Każdy model ma ograniczone okno kontekstowe, mierzone w tokenach. W miarę wzrostu historii każde żądanie staje się droższe, ponieważ wszystko jest przesyłane ponownie. Rozmowa licząca trzydzieści turów efektywnie rozlicza swój początek trzydzieści razy.
Najprostszym obejściem jest obcięcie historii, zachowując wiadomość systemową i ostatnie N wymian:
MAX_MESSAGES = 20
def ajouter_message(historique, role, content):
historique.append({"role": role, "content": content})
# Keep the system message + the last N messages
if len(historique) > MAX_MESSAGES + 1: # +1 for the system message
system_msg = historique[0]
historique = [system_msg] + historique[-(MAX_MESSAGES):]
return historique
Podejście to jest tanie, ale brutalne: to, co użytkownik określił w drugim turze, znika na zawsze. Gdy rozmowa jest długa, a starszy kontekst ma znaczenie – na przykład podczas wywiadu dotyczącego zbierania wymagań – lepiej go podsumować, niż wyrzucać:
def resumer_historique(client, historique):
"""Summarizes old messages to free up context."""
texte_complet = "\n".join(
f"{m['role']}: {m['content']}"
for m in historique[1:-4] # Exclude system and the last 4 messages
)
resume = client.chat.complete(
model="mistral-small-latest",
messages=[
{"role": "user", "content": f"Summarize this conversation in 3-4 sentences:\n{texte_complet}"}
]
)
return [
historique[0], # System message
{"role": "assistant", "content": f"[Conversation Summary] {resume.choices[0].message.content}"},
] + historique[-4:] # The last 4 messages
Idea polega na skompresowaniu odległej przeszłości do kilku zdań, przy jednoczesnym zachowaniu ostatnich czterech wiadomości w nienaruszonym stanie, ponieważ niosą one bezpośredni kontekst. Podsumowanie zużywa jedno dodatkowe wywołanie, ale z nawiązką zwraca się w kolejnych turach.
Tworzenie wiadomości systemowej
Wiadomość systemowa to najpotężniejsze i najczęściej niedoceniane narzędzie w tej lekcji. Wielu poprzestaje na ogólnikowym „Jesteś pomocnym asystentem“, co nic nie wnosi. Dobra wiadomość systemowa stawia weryfikowalne ograniczenia:
system_prompt = """You are a Corsen AI technical assistant.
Rules:
- Respond in French with a professional tone
- Provide code examples when relevant
- If you are unsure, say so rather than making things up
- Limit your responses to 200 words unless asked otherwise
Context: The user is working on a Python 3.12 project with FastAPI."""
Każda linijka tutaj przynosi mierzalny efekt: limit długości kontroluje koszty, zachęta do przyznawania się do niepewności redukuje halucynacje, a wspomnienie o stosie technologicznym unika generycznych, niezwiązanych z tematem odpowiedzi. Ma być zwięzła, precyzyjna i jednoznaczna – tyle wystarczy.
Kluczowe wnioski
- Cała historia jest wysyłana ponownie z każdym żądaniem – model niczego nie „pamięta“
- Trzy role (
system,user,assistant) strukturyzują rozmowę - Wiadomość
systemdefiniuje ogólne zachowanie – zawsze umieszczaj ją jako pierwszą - Zarządzaj rozmiarem kontekstu poprzez obcinanie lub podsumowywanie starych wiadomości
- Im dłuższa historia, tym każde żądanie kosztuje więcej tokenów