Stan konwersacji i zarządzanie sesjami
Na tej stronie
Stan konwersacji i zarządzanie sesjami
Interfejs API Responses natywnie obsługuje stan konwersacji, co drastycznie upraszcza utrzymanie kontekstu między kolejnymi wymianami zdań. Nie musisz już rekonstruować historii dla każdego żądania: serwer robi to za Ciebie, a Ty przekazujesz jedynie identyfikator.
Łączenie za pomocą previous_response_id
Mechanizm sprowadza się do jednego pola. Każda odpowiedź posiada id; przekaż je w polu previous_response_id przy kolejnym wywołaniu, a model uzyska dostęp do wszystkiego, co wydarzyło się wcześniej. W poniższej wymianie trzecie pytanie – „Jak je dodać?“ – nie miałoby sensu w izolacji: łączenie pozwala modelowi zrozumieć, że rozmawiamy o ułamkach i że użytkownik jest początkujący.
from openai import OpenAI
client = OpenAI()
# Pierwsza wymiana
r1 = client.responses.create(
model="gpt-5.6-terra",
instructions="You are a patient math teacher.",
input="I'd like to learn about fractions."
)
print(f"R1: {r1.output_text}")
# Druga wymiana — kontekst jest zachowywany automatycznie
r2 = client.responses.create(
model="gpt-5.6-terra",
input="Can you give me a concrete example?",
previous_response_id=r1.id
)
print(f"R2: {r2.output_text}")
# Trzecia wymiana — cała konwersacja jest dostępna
r3 = client.responses.create(
model="gpt-5.6-terra",
input="And how do I add them?",
previous_response_id=r2.id
)
print(f"R3: {r3.output_text}")
# Model wie, że od początku rozmawiamy o ułamkach
Zwróć uwagę na różnicę w stosunku do poprzedniego podejścia. W przypadku Chat Completions konwersacja żyła w liście, którą zarządzałeś samodzielnie i wysyłałeś w całości przy każdej turze, co powodowało wzrost kosztów wraz z wydłużaniem się rozmowy.
# STARE — musiałeś zarządzać wszystkim samodzielnie
history = [
{"role": "system", "content": "You are a math teacher."},
{"role": "user", "content": "I'd like to learn about fractions."},
{"role": "assistant", "content": "Sure! Fractions..."},
{"role": "user", "content": "A concrete example?"},
{"role": "assistant", "content": "Let's take a pizza..."},
{"role": "user", "content": "How do I add them?"},
]
# Wysyłane w całości przy każdym wywołaniu = rosnące koszty
Ta sama wymiana sprowadza się teraz do pojedynczego odniesienia:
# NOWE — wystarczy pojedynczy identyfikator
r = client.responses.create(
model="gpt-5.6-terra",
input="How do I add them?",
previous_response_id="previous_response_id"
)
# Serwer zarządza historią za Ciebie
Prowadzenie wielu konwersacji
Gdy tylko Twoja aplikacja obsługuje wielu użytkowników, pojawia się pytanie: który identyfikator należy do kogo? Odpowiedzią jest tabela mapująca użytkownika na najnowszy response.id jego konwersacji. Poniższy menedżer encapsuluje tę logikę: dodaje previous_response_id tylko wtedy, gdy sesja już istnieje, a następnie zapisuje nowy identyfikator. Dzięki temu Alicja i Bob mogą prowadzić równoległe rozmowy bez mieszania się ich kontekstów, a „nowa sesja“ oznacza po prostu zapomnienie bieżącego identyfikatora.
class SessionManager:
"""Menedżer sesji konwersacyjnych."""
def __init__(self):
self.sessions: dict[str, str] = {} # user_id -> last_response_id
def send_message(self, user_id: str, message: str,
instructions: str = "") -> str:
"""Wysyła wiadomość w sesji użytkownika."""
kwargs = {
"model": "gpt-5.6-terra",
"input": message,
}
# Dodaj instrukcje, jeśli podano
if instructions:
kwargs["instructions"] = instructions
# Połącz z poprzednią odpowiedzią, jeśli istnieje
if user_id in self.sessions:
kwargs["previous_response_id"] = self.sessions[user_id]
response = client.responses.create(**kwargs)
# Zapisz ID na następną turę
self.sessions[user_id] = response.id
return response.output_text
def new_session(self, user_id: str):
"""Rozpoczyna nową konwersację dla użytkownika."""
if user_id in self.sessions:
del self.sessions[user_id]
# Użycie
manager = SessionManager()
# Użytkownik Alicja
print(manager.send_message("alice", "Hello, tell me about Python."))
print(manager.send_message("alice", "What are its advantages?"))
# Użytkownik Bob (niezależna konwersacja)
print(manager.send_message("bob", "Hello, tell me about Rust."))
# Alicja kontynuuje rozmowę o Pythonie
print(manager.send_message("alice", "How do I get started?"))
Kiedy przejąć kontrolę nad historią
Automatyczne łączenie ma swoje granice: nie możesz zmodyfikować tego, co zostało już powiedziane. Jeśli Twoja aplikacja potrzebuje podsumować przeszłe tury, usunąć wiadomość zawierającą dane osobowe lub ponownie wstrzyknąć sformułowany na nowo kontekst, przełącz się na ustrukturyzowane dane wejściowe i zarządzaj listą samodzielnie. Tracisz na prostocie, ale zyskujesz pełną kontrolę – oraz możliwość śledzenia inflacji tokenów z tury na turę.
def manual_conversation():
"""Konwersacja z ręcznym zarządzaniem historią."""
history = []
while True:
user_input = input("You: ")
if user_input.lower() == "quit":
break
history.append({"role": "user", "content": user_input})
response = client.responses.create(
model="gpt-5.6-terra",
instructions="You are a concise assistant.",
input=history
)
assistant_msg = response.output_text
history.append({"role": "assistant", "content": assistant_msg})
print(f"Assistant: {assistant_msg}")
print(f" (Cumulative tokens: {response.usage.input_tokens})")
# manual_conversation()
Przetrwanie restartu
Słownik przechowywany w pamięci znika przy pierwszym ponownym wdrożeniu, zabierając ze sobą wszystkie aktywne konwersacje. W środowisku produkcyjnym utrwalaj identyfikatory – poniższy plik JSON ilustruje tę zasadę, którą możesz dostosować do swojej bazy danych lub Redis. Zauważ, że rejestrujemy również znacznik czasu i zużycie tokenów – dwie informacje wykorzystywane odpowiednio do wygasania sesji i śledzenia kosztów.
import json
from datetime import datetime
class PersistentSessionManager:
"""Trwałe sesje z kopią zapasową."""
def __init__(self, db_path: str = "sessions.json"):
self.db_path = db_path
self.sessions = self._load()
def _load(self) -> dict:
try:
with open(self.db_path, "r") as f:
return json.load(f)
except FileNotFoundError:
return {}
def _save(self):
with open(self.db_path, "w") as f:
json.dump(self.sessions, f, indent=2)
def send(self, session_id: str, message: str) -> str:
kwargs = {"model": "gpt-5.6-terra", "input": message}
if session_id in self.sessions:
kwargs["previous_response_id"] = self.sessions[session_id]["last_id"]
response = client.responses.create(**kwargs)
self.sessions[session_id] = {
"last_id": response.id,
"updated_at": datetime.now().isoformat(),
"total_tokens": response.usage.total_tokens
}
self._save()
return response.output_text
Na koniec zaimplementuj wygasanie. Bez czyszczenia tabela sesji będzie tylko rosła, a użytkownik wracający po trzech tygodniach wznowiłby rozmowę, której już nie pamięta. Dwadzieścia cztery godziny to rozsądny punkt wyjścia, który można dostosować do przypadku użycia.
from datetime import datetime, timedelta
def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
"""Usuwa wygasłe sesje."""
now = datetime.now()
active = {}
for sid, data in sessions.items():
updated = datetime.fromisoformat(data["updated_at"])
if now - updated < timedelta(hours=max_age_hours):
active[sid] = data
deleted = len(sessions) - len(active)
if deleted > 0:
print(f"{deleted} expired session(s) removed")
return active
Podsumowując te wybory: używaj previous_response_id do prostych konwersacji – to najbardziej wydajne rozwiązanie; przełącz się na ustrukturyzowane dane wejściowe, gdy potrzebujesz modyfikować historię; przechowuj response.id w sposób niezawodny, w bazie danych, a nie w pamięci; czyść nieaktywne sesje; i monitoruj łączną liczbę tokenów, inaczej koszty Cię dogonią.
Kluczowe wnioski
previous_response_idautomatycznie łączy odpowiedzi bez konieczności ponownego wysyłania historii- Każda odpowiedź posiada unikalny
id, który można wykorzystać do łączenia - Zarządzaj wieloma sesjami za pomocą słownika
user_id -> response_id - Ustrukturyzowane dane wejściowe (lista wiadomości) oferują większą kontrolę nad historią
- Wdroż trwałość sesji i ich wygasanie w środowisku produkcyjnym