Stanje pogovora in upravljanje sej
Na tej strani
Stanje pogovora in upravljanje sej
API Responses samodejno podpira stanje pogovora, kar drastično poenostavi ohranjanje konteksta med zaporednimi odzivi. Zgodovine ni treba več rekonstruirati za vsako zahtevo posebej: strežnik to opravi namesto vas, vi pa posredujete le identifikator.
Povezovanje s parametrom previous_response_id
Mehanizem se skrči na eno samo polje. Vsak odziv ima id; tega posredujete v parametru previous_response_id ob naslednjem klicu in model dobi dostop do vsega, kar je bilo povedano prej. V spodnji izmenjavi tretje vprašanje – „Kako jih seštejem?” – samostojno nima smisla: povezovanje modelu pove, da govorimo o ulomkih in da je uporabnik začetnik.
from openai import OpenAI
client = OpenAI()
# Prva izmenjava
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 izmenjava — kontekst se samodejno ohrani
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}")
# Tretja izmenjava — celoten pogovor je dostopen
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 ve, da smo od začetka govorili o ulomkih
Razmisli o razliki glede na prejšnji pristop. Pri Chat Completions je pogovor živel v seznamu, ki ste ga vzdrževali sami in ga pri vsakem koraku znova pošiljali v celoti, zaradi česar so stroški z daljšanjem izmenjave rasli.
# STARO — vse ste morali upravljati sami
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?"},
]
# Poslano v celoti ob vsakem klicu = naraščajoči stroški
Ista izmenjava se zdaj zreducira na eno samo referenco:
# NOVO — dovolj je en sam ID
r = client.responses.create(
model="gpt-5.6-terra",
input="How do I add them?",
previous_response_id="previous_response_id"
)
# Strežnik namesto vas upravlja zgodovino
Vzporedno vodenje več pogovorov
Takoj ko vaša aplikacija streže več uporabnikov, se pojavi vprašanje: kateri identifikator pripada komu? Odgovor je preslikovalna tabela med uporabnikom in najnovejšim response.id za njegov pogovor. Spodnji upravitelj encapsulira to logiko: previous_response_id doda le, če seja že obstaja, nato pa shrani novi identifikator. Alenka in Borut lahko tako vzporedno konverzirata, ne da bi se njuna konteksta mešala, „nova seja” pa preprosto pomeni pozabo trenutnega identifikatorja.
class SessionManager:
"""Upravitelj sej pogovorov."""
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:
"""Pošlje sporočilo v uporabnikovi seji."""
kwargs = {
"model": "gpt-5.6-terra",
"input": message,
}
# Dodaj navodila, če so podana
if instructions:
kwargs["instructions"] = instructions
# Poveži s prejšnjim odzivom, če obstaja
if user_id in self.sessions:
kwargs["previous_response_id"] = self.sessions[user_id]
response = client.responses.create(**kwargs)
# Shrani ID za naslednji korak
self.sessions[user_id] = response.id
return response.output_text
def new_session(self, user_id: str):
"""Začne nov pogovor za uporabnika."""
if user_id in self.sessions:
del self.sessions[user_id]
# Uporaba
manager = SessionManager()
# Uporabnica Alenka
print(manager.send_message("alice", "Hello, tell me about Python."))
print(manager.send_message("alice", "What are its advantages?"))
# Uporabnik Borut (neodvisen pogovor)
print(manager.send_message("bob", "Hello, tell me about Rust."))
# Alenka nadaljuje pogovor o Pythonu
print(manager.send_message("alice", "How do I get started?"))
Kdaj prevzeti nadzor nad zgodovino
Samodejno povezovanje ima mejo: ne morete spreminjati tega, kar je bilo že povedano. Če vaša aplikacija potrebuje povzemanje preteklih korakov, brisanje sporočila z osebnimi podatki ali ponovno vbrizganje preoblikovanega konteksta, preklopite na strukturiran vnos in seznam upravljajte sami. Izgubite preprostost, a pridobite popoln nadzor – in možnost sledenja napihovanju števila žetonov iz koraka v korak.
def manual_conversation():
"""Pogovor z ročnim upravljanjem zgodovine."""
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" (Kumulativni žetoni: {response.usage.input_tokens})")
# manual_conversation()
Preživetje ponovnega zagona
Slovar v pomnilniku ob prvi ponovni namestitvi izgine, z njim pa vse aktivne pogovore. V produkcijskem okolju identifikatorje trajno shranite – spodnja datoteka JSON ponazarja princip, ki ga lahko prilagodite svoji bazi podatkov ali Redisu. Upoštevajte, da beležimo tudi časovni žig in porabo žetonov; dve informaciji, ki ju uporabimo za potek veljavnosti oziroma sledenje stroškom.
import json
from datetime import datetime
class PersistentSessionManager:
"""Trajne seje z varnostno kopijo."""
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
Nazadnje implementirajte potek veljavnosti. Brez čiščenja tabela sej le raste, uporabnik, ki se vrne čez tri tedne, pa bi nadaljeval pogovor, katerega se ne spominja več. Dvainštirideset ur je razumna izhodiščna vrednost, ki jo prilagodite svojemu primeru uporabe.
from datetime import datetime, timedelta
def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
"""Odstrani potekle seje."""
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} potekla(-ih) seja(-e) odstranjena(-ih)")
return active
Če povzamemo te izbire: za preproste pogovore uporabite previous_response_id – to je najbolj učinkovito; preklopite na strukturiran vnos, ko potrebujete spreminjanje zgodovine; response.id zanesljivo shranite v bazo podatkov, ne v pomnilnik; počistite neaktivne seje; in spremljajte kumulativne žetone, sicer vas bodo dohiteli stroški.
Ključne ugotovitve
previous_response_idsamodejno poveže odzive brez ponovnega pošiljanja zgodovine- Vsak odziv ima edinstven
id, uporaben za povezovanje - Več sej upravljajte s slovarjem
user_id -> response_id - Strukturiran vnos (seznam sporočil) omogoča večji nadzor nad zgodovino
- V produkcijskem okolju implementirajte trajnost sej in potek veljavnosti