Konversationszustand und Sitzungsverwaltung
Auf dieser Seite
Konversationszustand und Sitzungsverwaltung
Die Responses API unterstützt den Konversationszustand nativ, was die Aufrechterhaltung des Kontextes über mehrere Runden hinweg erheblich vereinfacht. Sie müssen die Historie für jede Anfrage nicht mehr neu rekonstruieren: Der Server übernimmt dies für Sie, und Sie müssen lediglich eine Identifikator übergeben.
Verkettung mit previous_response_id
Der Mechanismus reduziert sich auf ein einziges Feld. Jede Antwort verfügt über eine id; übergeben Sie diese im nächsten Aufruf als previous_response_id, hat das Modell Zugriff auf alles, was zuvor kam. Im folgenden Austausch macht die dritte Frage – „Wie füge ich sie hinzu?” – isoliert keinen Sinn: Die Verkettung ermöglicht es dem Modell, zu wissen, dass über Brüche gesprochen wird und der Nutzer ein Anfänger ist.
from openai import OpenAI
client = OpenAI()
# Erster Austausch
r1 = client.responses.create(
model="gpt-5.6-terra",
instructions="Sie sind ein geduldiger Mathematiklehrer.",
input="Ich möchte über Brüche lernen."
)
print(f"R1: {r1.output_text}")
# Zweiter Austausch — der Kontext wird automatisch erhalten
r2 = client.responses.create(
model="gpt-5.6-terra",
input="Können Sie mir ein konkretes Beispiel geben?",
previous_response_id=r1.id
)
print(f"R2: {r2.output_text}")
# Dritter Austausch — die gesamte Konversation ist zugänglich
r3 = client.responses.create(
model="gpt-5.6-terra",
input="Und wie füge ich sie hinzu?",
previous_response_id=r2.id
)
print(f"R3: {r3.output_text}")
# Das Modell weiß, dass wir von Anfang an über Brüche gesprochen haben
Betrachten Sie den Unterschied zum vorherigen Ansatz. Bei Chat Completions lebte die Konversation in einer Liste, die Sie selbst verwalteten und bei jeder Runde vollständig erneut sandten, wobei die Kosten mit zunehmender Länge des Austauschs stiegen.
# ALT — Sie mussten alles selbst verwalten
history = [
{"role": "system", "content": "Sie sind ein Mathematiklehrer."},
{"role": "user", "content": "Ich möchte über Brüche lernen."},
{"role": "assistant", "content": "Gerne! Brüche..."},
{"role": "user", "content": "Ein konkretes Beispiel?"},
{"role": "assistant", "content": "Nehmen wir eine Pizza..."},
{"role": "user", "content": "Wie füge ich sie hinzu?"},
]
# In jedem Aufruf vollständig gesendet = steigende Kosten
Dieser gleiche Austausch reduziert sich nun auf einen einzigen Verweis:
# NEU — eine einzelne ID reicht aus
r = client.responses.create(
model="gpt-5.6-terra",
input="Wie füge ich sie hinzu?",
previous_response_id="previous_response_id"
)
# Der Server verwaltet die Historie für Sie
Mehrere Konversationen parallel führen
Sobald Ihre Anwendung mehrere Benutzer bedient, stellt sich die Frage: Welcher Identifikator gehört zu wem? Die Antwort ist eine Zuordnungstabelle zwischen dem Benutzer und der neuesten response.id für dessen Konversation. Der untenstehende Manager kapselt diese Logik: Er fügt previous_response_id nur hinzu, wenn eine Sitzung bereits existiert, und speichert dann die neue Identifikator. Alice und Bob können somit parallel konversieren, ohne dass sich ihre Kontexte vermischen, und eine „neue Sitzung” bedeutet einfach, den aktuellen Identifikator zu vergessen.
class SessionManager:
"""Verwalter für Konversationssitzungen."""
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:
"""Sendet eine Nachricht in der Sitzung des Benutzers."""
kwargs = {
"model": "gpt-5.6-terra",
"input": message,
}
# Anweisungen hinzufügen, falls vorhanden
if instructions:
kwargs["instructions"] = instructions
# Mit der vorherigen Antwort verketten, falls diese existiert
if user_id in self.sessions:
kwargs["previous_response_id"] = self.sessions[user_id]
response = client.responses.create(**kwargs)
# Speichern der ID für die nächste Runde
self.sessions[user_id] = response.id
return response.output_text
def new_session(self, user_id: str):
"""Startet eine neue Konversation für den Benutzer."""
if user_id in self.sessions:
del self.sessions[user_id]
# Nutzung
manager = SessionManager()
# Benutzer Alice
print(manager.send_message("alice", "Hallo, erzähl mir von Python."))
print(manager.send_message("alice", "Was sind seine Vorteile?"))
# Benutzer Bob (unabhängige Konversation)
print(manager.send_message("bob", "Hallo, erzähl mir von Rust."))
# Alice setzt ihre Konversation über Python fort
print(manager.send_message("alice", "Wie fange ich an?"))
Wann die Kontrolle über die Historie übernehmen
Automatische Verkettung hat Grenzen: Sie können nicht ändern, was bereits gesagt wurde. Wenn Ihre Anwendung vergangene Runden zusammenfassen, eine Nachricht mit personenbezogenen Daten löschen oder einen reformulierten Kontext erneut einfügen muss, wechseln Sie zu strukturiertem Input und verwalten Sie die Liste selbst. Sie verlieren an Einfachheit, gewinnen aber volle Kontrolle – und die Möglichkeit, die Token-Inflation Runde für Runde zu verfolgen.
def manual_conversation():
"""Konversation mit manueller Historienverwaltung."""
history = []
while True:
user_input = input("Sie: ")
if user_input.lower() == "quit":
break
history.append({"role": "user", "content": user_input})
response = client.responses.create(
model="gpt-5.6-terra",
instructions="Sie sind ein präziser Assistent.",
input=history
)
assistant_msg = response.output_text
history.append({"role": "assistant", "content": assistant_msg})
print(f"Assistent: {assistant_msg}")
print(f" (Kumulative Tokens: {response.usage.input_tokens})")
# manual_conversation()
Überleben eines Neustarts
Ein im Arbeitsspeicher befindliches Wörterbuch verschwindet bei der ersten Neustartung und nimmt alle aktiven Konversationen mit sich. In der Produktion müssen Sie die Identifikatoren persistieren – die untenstehende JSON-Datei illustriert das Prinzip, das Sie an Ihre Datenbank oder Redis anpassen können. Beachten Sie, dass wir auch den Zeitstempel und den Tokenverbrauch erfassen, zwei Informationen, die jeweils für die Ablaufzeit und die Kostenverfolgung genutzt werden.
import json
from datetime import datetime
class PersistentSessionManager:
"""Persistente Sitzungen mit Sicherung."""
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
Implementieren Sie abschließend eine Ablaufzeit. Ohne Bereinigung wächst Ihre Sitzungstabelle nur noch an, und ein Benutzer, der drei Wochen später zurückkehrt, würde eine Konversation fortsetzen, die er sich nicht mehr erinnert. Zweiundzwanzig Stunden sind ein vernünftiger Ausgangspunkt, der je nach Anwendungsfall anpassbar ist.
from datetime import datetime, timedelta
def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
"""Entfernt abgelaufene Sitzungen."""
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} abgelaufene Sitzung(en) entfernt")
return active
Zusammenfassend diese Entscheidungen: Nutzen Sie previous_response_id für einfache Konversationen – dies ist die effizienteste Methode; wechseln Sie zu strukturiertem Input, wenn Sie die Historie ändern müssen; speichern Sie response.id zuverlässig in einer Datenbank und nicht im Arbeitsspeicher; bereinigen Sie inaktive Sitzungen; und überwachen Sie die kumulativen Tokens, sonst wird die Abrechnung Sie einholen.
Wichtige Erkenntnisse
previous_response_idverketten Antworten automatisch, ohne die Historie erneut zu senden- Jede Antwort verfügt über eine eindeutige
id, die für die Verkettung genutzt werden kann - Verwalten Sie mehrere Sitzungen mit einem Wörterbuch
user_id -> response_id - Strukturierte Eingabe (Nachrichtenliste) bietet mehr Kontrolle über die Historie
- Implementieren Sie in der Produktion die Persistenz und Ablaufzeit von Sitzungen