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

Konwersacje trwałe

Lekcja 5 z 18 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Stan utrzymujący się między wymianami
  2. Rozpoczynanie konwersacji
  3. Kontynuowanie konwersacji
  4. Mechanizm niezmienności
  5. Odczytywanie historii konwersacji
  6. Zarządzanie przechowywaniem
  7. Wzorzec konwersacji wieloturowej
  8. Kluczowe wnioski

Lekcja zaktualizowana 3 listopada 2026 w oparciu o SDK mistralai w wersji 3.7.0: historię konwersacji (jej entries) pobierasz za pomocą client.beta.conversations.get_history; metoda retrieve nie istnieje, a get zwraca wyłącznie metadane konwersacji. Źródło: client-python.

Stan utrzymujący się między wymianami

Jedną z głównych zalet interfejsu API Agents w porównaniu z Chat Completions jest trwałość konwersacji. Nie musisz już ręcznie zarządzać historią wiadomości – Mistral robi to po stronie serwera. Konkretnie: lista słowników, którą wcześniej akumulowałeś w zmiennej, skracałeś przy przepełnieniu kontekstu i odbudowywałeś przy każdym restarcie procesu, znika z Twojego kodu. Musisz śledzić tylko jedną rzecz: identyfikator. Ten identyfikator podlega zasadzie, na której potykają się wszyscy przy swoim pierwszym projekcie.

Rozpoczynanie konwersacji

Metoda conversations.start() tworzy nową konwersację i wysyła pierwszą wiadomość. Poniższy przykład tworzy również agenta, który będzie ją obsługiwał, a następnie przekazuje mu kontekst projektu, do którego możesz odwoływać się przez wiele tur rozmowy.

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

# Utwórz agenta
agent = client.beta.agents.create(
    model="mistral-medium-latest",
    name="Asystent projektu",
    description="Asystent do zarządzania projektami.",
    instructions="Pomagasz organizować i śledzić projekty. Bądź uporządkowany."
)

# Rozpocznij konwersację
response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="Rozpoczynam nowy projekt redesignu naszej strony internetowej. Budżet: 50 000 €, termin: wrzesień 2026."
)

print(f"ID konwersacji: {response.conversation_id}")

Zwrócone conversation_id to Twój klucz do kontynuowania tej rozmowy później. Przechowuj je tam, gdzie Twoja aplikacja będzie mogła je odzyskać: w sesji użytkownika, bazie danych lub zgłoszeniu wsparcia, którego dotyczy rozmowa.

Kontynuowanie konwersacji

Aby dodać wiadomość do istniejącej konwersacji, przekaż conversation_id do metody conversations.append(). Podążaj za wątkiem w tym przykładzie: drugie pytanie nie powtarza budżetu ani terminu, a trzecie prosi o harmonogram bez przypominania agentowi, że chodzi o redesign strony. Mimo to agent posiada cały ten kontekst.

# Pierwsza wymiana
response1 = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="Rozpoczynam projekt redesignu strony. Budżet 50 000 €."
)

# Druga wymiana – agent pamięta kontekst
response2 = client.beta.conversations.append(
    conversation_id=response1.conversation_id,
    inputs="Jakie są prioritety kroków?"
)

# Trzecia wymiana – nadal w tym samym kontekście
response3 = client.beta.conversations.append(
    conversation_id=response2.conversation_id,
    inputs="Sporządź harmonogram na pierwsze 3 miesiące."
)

Przyjrzyj się uważnie, który identyfikator zasila każde wywołanie: response2 startuje z ID z response1, a response3 z ID z response2. To nie jest dziwactwo; to główny mechanizm działania tego API.

Mechanizm niezmienności

Każde wywołanie conversations.append() zwraca nowe conversation_id. Stare pozostaje dostępne do odczytu, ale do kolejnego dopisania musisz użyć najnowsze ID.

# Każde append zwraca nowe ID
id_1 = response1.conversation_id  # "conv-aaa"
id_2 = response2.conversation_id  # "conv-bbb"
id_3 = response3.conversation_id  # "conv-ccc"

# Zawsze używaj NAJNOWSZEGO id, aby kontynuować
response4 = client.beta.conversations.append(
    conversation_id=id_3,  # Nie id_1 ani id_2
    inputs="Dodaj kamienie milowe walidacji przez klienta."
)

Klasycznym błędem jest zapisanie początkowego identyfikatora w bazie danych, gdy użytkownik otwiera wątek, a następnie wielokrotne używanie go bez zmian dla każdej wiadomości. Nic się nie wysypuje: API odpowiada normalnie, ale każde pytanie restartuje się z kontekstu pierwszej wymiany, a Twój agent zdaje się mieć amnezję, bez żadnego błędu, który by Cię ostrzegł. Zawsze nadpisuj przechowywany identyfikator tym zwróconym w odpowiedzi.

Odczytywanie historii konwersacji

Historię możesz odczytać w dowolnym momencie, co pomaga zarówno w debugowaniu, jak i wyświetlaniu wątku w Twoim interfejsie.

conversation = client.beta.conversations.get_history(
    conversation_id=response.conversation_id
)

for entry in conversation.entries:
    print(f"[{entry.role}] {entry.type}: {entry.content[:100]}...")

Zarządzanie przechowywaniem

Domyślnie konwersacje są przechowywane w chmurze Mistral. Parametr store=False wyłącza to zachowanie dla wymian, których Twoja wewnętrzna polityka zabrania pozostawiać na serwerze strony trzeciej.

# Konwersacja efemeryczna – nic nie jest zapisywane
response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="Dane poufne do analizy...",
    store=False
)

Kompromis jest zgodny z celem: konwersacja nie jest możliwa do odzyskania po zakończeniu sesji, a dane nie są przechowywane na serwerach Mistral. Tracisz możliwość odtworzenia historii opisanej powyżej, a Twoja aplikacja musi sama zajmować się śledzeniem wymian, jeśli jest to konieczne. Podejmij tę decyzję z góry, a nie jako ostatni moment zaznaczenia opcji.

Wzorzec konwersacji wieloturowej

Poniższy szkielet stosuje wszystko, co powyżej, w pętli interaktywnej. Kluczowym punktem jest zmienna conversation_id, zainicjalizowana jako None: decyduje ona, które wywołanie wykonać – start() przy pierwszej turze, append() subsequently – i jest ona przypisywana na nowo po każdej odpowiedzi, zgodnie z zasadą niezmienności.

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="Trener techniczny",
    description="Trener do spraw decyzji technicznych.",
    instructions="Jesteś starszym trenerem technicznym. Zadawaj pytania, aby zrozumieć kontekst przed udzieleniem porady."
)

# Pętla konwersacji
conversation_id = None

while True:
    user_input = input("Ty: ")
    if user_input.lower() in ["quit", "exit"]:
        break

    if conversation_id is None:
        response = client.beta.conversations.start(
            agent_id=agent.id,
            inputs=user_input
        )
    else:
        response = client.beta.conversations.append(
            conversation_id=conversation_id,
            inputs=user_input
        )

    conversation_id = response.conversation_id

    for entry in response.outputs:
        if hasattr(entry, "content"):
            print(f"Agent: {entry.content}")

Dostosuj go do swojego kontekstu, zastępując input() swoim rzeczywistym źródłem wiadomości – żądaniem HTTP, wiadomością z kolejki, zdarzeniem webhooka – i utrwalając conversation_id tam, gdzie Twoja aplikacja będzie mogła je znaleźć przy następnej turze.

Kluczowe wnioski

  • conversations.start() tworzy nową konwersację z pierwszą wiadomością
  • conversations.append() dodaje wiadomość do istniejącej konwersacji
  • Każde wywołanie append zwraca nowe conversation_id – zawsze używaj najnowszego
  • store=False wyłącza trwałość po stronie Mistral dla danych wrażliwych
  • Agent zachowuje pełny kontekst konwersacji bez konieczności ponownego wysyłania historii