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

Rozmowy wieloturkowe w Pythonie

Lekcja 7 z 14 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Pamięć, która tak naprawdę nie jest pamięcią
  2. Trzy role strukturyzujące historię
  3. Pełna rozmowa, tur po turze
  4. Zapobieganie wygórowanym kosztom historii
  5. Tworzenie wiadomości systemowej
  6. Kluczowe wnioski

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ść system definiuje 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