Samtalestatus og sessionshåndtering
På denne side
Samtalestatus og sessionshåndtering
Responses API understøtter samtalestatus nativt, hvilket forenkler vedligeholdelsen af kontekst på tværs af tur drastisk. Du behøver ikke længere at genopbygge historikken for hver anmodning: serveren håndterer det for dig, og du skal blot sende en identifikator.
Kædning med previous_response_id
Mekanismen koges ned til et enkelt felt. Hvert svar har et id; send det i previous_response_id ved næste kald, så har modellen adgang til alt, der er sket før. I udvekslingen nedenfor giver det tredje spørgsmål – „Hvordan lægger jeg dem sammen?” – ingen mening isoleret set: kædning fortæller modellen, at vi taler om brøker, og at brugeren er nybegynder.
from openai import OpenAI
client = OpenAI()
# Første udveksling
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}")
# Anden udveksling — konteksten bevares automatisk
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}")
# Tredje udveksling — hele samtalen er tilgængelig
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}")
# Modellen ved, at vi har talt om brøker fra starten
Overvej forskellen fra den tidligere tilgang. Med Chat Completions levede samtalen i en liste, som du selv vedligeholdt og sendte fuldt ud ved hver tur, hvor omkostningerne steg, efterhånden som udvekslingen blev længere.
# GAMMELT — du skulle styre alt selv
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?"},
]
# Sendes fuldt ud ved hvert kald = stigende omkostninger
Den samme udveksling reduceres nu til en enkelt reference:
# NYT — et enkelt ID er nok
r = client.responses.create(
model="gpt-5.6-terra",
input="How do I add them?",
previous_response_id="previous_response_id"
)
# Serveren styrer historikken for dig
Kørsel af flere samtaler
Så snart din applikation betjener flere brugere, bliver spørgsmålet: hvilken identifikator hører til hvem? Svaret er en mapping-tabel mellem brugeren og det seneste response.id for deres samtale. Manageren nedenfor kapsler denne logik ind: den tilføjer kun previous_response_id, hvis der allerede findes en session, og gemmer derefter den nye identifikator. Alice og Bob kan dermed føre samtaler parallelt uden at deres kontekster blandes, og „ny session” betyder blot at glemme den aktuelle identifikator.
class SessionManager:
"""Sessionshåndtering for samtaler."""
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:
"""Sender en besked i brugerens session."""
kwargs = {
"model": "gpt-5.6-terra",
"input": message,
}
# Tilføj instrukser hvis angivet
if instructions:
kwargs["instructions"] = instructions
# Kæd med det forrige svar hvis det eksisterer
if user_id in self.sessions:
kwargs["previous_response_id"] = self.sessions[user_id]
response = client.responses.create(**kwargs)
# Gem ID'et til næste tur
self.sessions[user_id] = response.id
return response.output_text
def new_session(self, user_id: str):
"""Starter en ny samtale for brugeren."""
if user_id in self.sessions:
del self.sessions[user_id]
# Brug
manager = SessionManager()
# Bruger Alice
print(manager.send_message("alice", "Hello, tell me about Python."))
print(manager.send_message("alice", "What are its advantages?"))
# Bruger Bob (uafhængig samtale)
print(manager.send_message("bob", "Hello, tell me about Rust."))
# Alice fortsætter sin samtale om Python
print(manager.send_message("alice", "How do I get started?"))
Hvornår du skal tage kontrol over historikken
Automatisk kædning har en begrænsning: du kan ikke ændre det, der allerede er sagt. Hvis din applikation skal opsummere tidligere tur, slette en besked med personlige data eller genindsætte en omformuleret kontekst, skal du skifte til struktureret input og selv administrere listen. Du mister enkelheden, men får fuld kontrol – og evnen til at spore token-inflation tur for tur.
def manual_conversation():
"""Samtale med manuel håndtering af historik."""
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" (Kumulative tokens: {response.usage.input_tokens})")
# manual_conversation()
Overlevelse efter genstart
Et ordbogsobjekt i hukommelsen forsvinder ved første genudrulning og tager alle aktive samtaler med sig. I produktion skal du persistere identifikatorerne – JSON-filen nedenfor illustrerer princippet, som du kan tilpasse til din database eller Redis. Bemærk, at vi også registrerer tidsstemplet og token-forbruget, to oplysninger der bruges henholdsvis til udløb og omkostningssporing.
import json
from datetime import datetime
class PersistentSessionManager:
"""Persistente sessions med backup."""
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
Implementér til sidst udløb. Uden oprydning vokser din sessionstabel kun, og en bruger, der vender tilbage efter tre uger, vil genoptage en samtale, de ikke længere kan huske. 24 timer er et rimeligt udgangspunkt, der kan justeres efter dit use case.
from datetime import datetime, timedelta
def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
"""Fjerner udløbne sessions."""
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} udløbet(ne) session(er) fjernet")
return active
For at opsummere disse valg: brug previous_response_id til simple samtaler – det er mest effektivt; skift til struktureret input, når du skal ændre historikken; gem response.id pålideligt, helst i en database frem for i hukommelsen; ryd op i inaktive sessions; og overvåg kumulative tokens, ellers vil faktureringen indhente dig.
Vigtige pointer
previous_response_idkæder svar automatisk uden at gensende historik- Hvert svar har et unikt
id, der kan bruges til kædning - Håndtér flere sessions med en ordbog
user_id -> response_id - Struktureret input (beskedliste) giver mere kontrol over historikken
- Implementér sessionspersistens og udløb i produktion