Keskustelutila ja istunnonhallinta
Tällä sivulla
Keskustelutila ja istunnonhallinta
Responses API tukee keskustelutilaa natiivisti, mikä yksinkertaistaa kontekstin ylläpitoa vuorovaikutuksen eri vaiheissa huomattavasti. Sinun ei enää tarvitse rakentaa historiaa uudelleen jokaista pyyntöä varten: palvelin hoitaa tämän puolestasi, ja sinun tarvitsee vain välittää tunniste.
Ketjutus previous_response_id:n avulla
Mekanismi tiivistyy yhteen kenttään. Jokaisella vastauksella on id; välitä se seuraavassa kutsussa parametrina previous_response_id, jolloin mallilla on pääsy kaikkeen aiempaan tietoon. Alla olevassa vaihdossa kolmas kysymys – “Miten ne lasketaan yhteen?” – ei olisi järkevä erillisenä: ketjutuksen ansiosta malli tietää, että puhumme murtoluvuista ja että käyttäjä on aloittelija.
from openai import OpenAI
client = OpenAI()
# Ensimmäinen vuorovaikutus
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}")
# Toinen vuorovaikutus — konteksti säilyy automaattisesti
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}")
# Kolmas vuorovaikutus — koko keskustelu on käytettävissä
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}")
# Malli tietää, että olemme puhuneet murtoluvuista alusta asti
Tarkastele eroa edelliseen lähestymistapaan verrattuna. Chat Completions -rajapinnassa keskustelu eli listassa, jota ylläpidit itse ja lähetit kokonaisena jokaisella vuorolla, mikä kasvatti kustannuksia vuorovaikutuksen pidentyessä.
# VANHA — sinun piti hallita kaikkea itse
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?"},
]
# Lähetetään kokonaisena jokaisessa kutsussa = kasvavat kustannukset
Sama vuorovaikutus pelkistyy nyt yhteen viittaukseen:
# UUSI — yksi ID riittää
r = client.responses.create(
model="gpt-5.6-terra",
input="How do I add them?",
previous_response_id="previous_response_id"
)
# Palvelin hallitsee historiaa puolestasi
Useiden keskustelujen suorittaminen
Heti kun sovelluksesi palvelee useita käyttäjiä, kysymys kuuluu: kuka tunniste kuuluu kenellekin? Vastaus on kartoitustaulukko käyttäjän ja hänen keskustelunsa viimeisimmän response.id:n välillä. Alla oleva hallintaluokka kapseloi tämän logiikan: se lisää previous_response_id:n vain, jos istunto on jo olemassa, ja tallentaa sitten uuden tunnisteen. Alice ja Bob voivat näin ollen keskustella rinnakkain ilman, että heidän kontekstinsa sekoittuvat, ja “uusi istunto” tarkoittaa yksinkertaisesti nykyisen tunnisteen unohtamista.
class SessionManager:
"""Keskusteluistunnon hallinta."""
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:
"""Lähettää viestin käyttäjän istunnossa."""
kwargs = {
"model": "gpt-5.6-terra",
"input": message,
}
# Lisää ohjeet, jos annettu
if instructions:
kwargs["instructions"] = instructions
# Ketjuta edelliseen vastaukseen, jos se on olemassa
if user_id in self.sessions:
kwargs["previous_response_id"] = self.sessions[user_id]
response = client.responses.create(**kwargs)
# Tallenna ID seuraavaa vuoroa varten
self.sessions[user_id] = response.id
return response.output_text
def new_session(self, user_id: str):
"""Aloittaa uuden keskustelun käyttäjälle."""
if user_id in self.sessions:
del self.sessions[user_id]
# Käyttö
manager = SessionManager()
# Käyttäjä Alice
print(manager.send_message("alice", "Hello, tell me about Python."))
print(manager.send_message("alice", "What are its advantages?"))
# Käyttäjä Bob (riippumaton keskustelu)
print(manager.send_message("bob", "Hello, tell me about Rust."))
# Alice jatkaa keskusteluaan Pythonista
print(manager.send_message("alice", "How do I get started?"))
Milloin ottaa historia hallintaan
Automaattisella ketjutuksella on rajansa: et voi muuttaa sitä, mitä on jo sanottu. Jos sovelluksesi tarvitsee tiivistää menneitä vuoroja, poistaa henkilökohtaista dataa sisältävän viestin tai syöttää uudelleen muotoiltua kontekstia, siirry strukturoituun syötteeseen ja hallitse listaa itse. Menetät yksinkertaisuuden, mutta saat täyden hallinnan – ja kyvyn seurata tokenien määrän kasvua vuoro vuorolta.
def manual_conversation():
"""Keskustelu manuaalisella historianhallinnalla."""
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" (Kumulatiiviset tokenit: {response.usage.input_tokens})")
# manual_conversation()
Selviytyminen uudelleenkäynnistyksestä
Muistissa oleva sanakirja katoaa ensimmäisessä uudelleenkäyttöönotossa, vieden mukanaan kaikki aktiiviset keskustelut. Tuotantoympäristössä tunnisteet on pysyväistettävä – alla oleva JSON-tiedosto havainnollistaa periaatetta, jonka voit mukauttaa omaan tietokantaasi tai Redisiin. Huomaa, että tallennamme myös aikaleiman ja tokenien käytön; nämä kaksi tietoa ovat käytössä vanhenemisen ja kustannusten seurannassa.
import json
from datetime import datetime
class PersistentSessionManager:
"""Pysyvät istunnot varmuuskopiolla."""
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
Lopuksi toteuta vanheneminen. Ilman siivousta istuntotaulukkosi vain kasvaa, ja kolmen viikon kuluttua palaava käyttäjä jatkaisi keskustelua, jota hän ei enää muista. Kaksikymmentäneljä tuntia on kohtuullinen lähtökohta, jota voit säätää käyttötarkoituksesi mukaan.
from datetime import datetime, timedelta
def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
"""Poistaa vanhentuneet istunnot."""
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} vanhentunutta istuntoa poistettu")
return active
Yhteenvetona näistä valinnoista: käytä previous_response_id:tä yksinkertaisiin keskusteluihin – se on tehokkain tapa; siirry strukturoituun syötteeseen, kun tarvitset mahdollisuuden muokata historiaa; tallenna response.id luotettavasti tietokantaan äläkä muistiin; siivoa käyttämättömät istunnot; ja seuraa kumulatiivisia tokeneita, tai laskutus tavoittaa sinut.
Keskeiset asiat
previous_response_idketjuttaa vastaukset automaattisesti lähettämättä historiaa uudelleen- Jokaisella vastauksella on ainutlaatuinen
id, jota voidaan käyttää ketjutukseen - Hallitse useita istuntoja
user_id -> response_id-sanakirjalla - Strukturoitu syöte (viestilista) tarjoaa enemmän hallintaa historiaan
- Toteuta istunnon pysyvyys ja vanheneminen tuotantoympäristössä