Състояние на разговора и управление на сесиите
На тази страница
Състояние на разговора и управление на сесиите
API за отговори (Responses API) поддържа състоянието на разговора нативно, което драстично опростява поддържането на контекст между отделните реплики. Вече не е необходимо да реконструирате историята за всяка заявка: сървърът се грижи за това вместо Вас, а Вие просто предавате идентификатор.
Верижно свързване чрез previous_response_id
Механизмът се свежда до едно единствено поле. Всеки отговор притежава id; предайте го в previous_response_id при следващото извикване и моделът ще има достъп до всичко, казано дотогава. В обмена по-долу третият въпрос – „Как да ги събера?“ – няма смисъл сам по себе си: верижното свързване позволява на модела да разбере, че става въпрос за дроби и че потребителят е начинаещ.
from openai import OpenAI
client = OpenAI()
# Първи обмен
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}")
# Втори обмен — контекстът се запазва автоматично
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}")
# Трети обмен — целият разговор е достъпен
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}")
# Моделът знае, че от самото начало говорим за дроби
Обърнете внимание на разликата спрямо предишния подход. При Chat Completions разговорът съществуваше в списък, който Вие поддържахте сами и изпращахте изцяло при всяка реплика, като разходите нарастваха с удължаването на обмена.
# СТАРО — трябваше да управлявате всичко сами
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?"},
]
# Изпращане изцяло при всяко извикване = нарастващи разходи
Същият обмен сега се свежда до една единствена препратка:
# НОВО — достатъчен е един ID
r = client.responses.create(
model="gpt-5.6-terra",
input="How do I add them?",
previous_response_id="previous_response_id"
)
# Сървърът управлява историята вместо Вас
Стартиране на множество разговори
Веднага щом Вашето приложение обслужва множество потребители, възниква въпросът: кой идентификатор на кого принадлежи? Отговорът е таблица за съпоставка между потребителя и най-новия response.id за неговия разговор. Мениджърът по-долу обединява тази логика: той добавя previous_response_id само ако сесията вече съществува, след което запазва новия идентификатор. Така Алис и Боб могат да водят разговори паралелно, без контекстите им да се смесват, а „нова сесия“ просто означава забравяне на текущия идентификатор.
class SessionManager:
"""Мениджър на сесиите за разговор."""
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:
"""Изпраща съобщение в сесията на потребителя."""
kwargs = {
"model": "gpt-5.6-terra",
"input": message,
}
# Добавяне на инструкции, ако са предоставени
if instructions:
kwargs["instructions"] = instructions
# Верижно свързване с предишния отговор, ако съществува
if user_id in self.sessions:
kwargs["previous_response_id"] = self.sessions[user_id]
response = client.responses.create(**kwargs)
# Запазване на ID за следващата реплика
self.sessions[user_id] = response.id
return response.output_text
def new_session(self, user_id: str):
"""Започва нов разговор за потребителя."""
if user_id in self.sessions:
del self.sessions[user_id]
# Употреба
manager = SessionManager()
# Потребител Алис
print(manager.send_message("alice", "Hello, tell me about Python."))
print(manager.send_message("alice", "What are its advantages?"))
# Потребител Боб (независим разговор)
print(manager.send_message("bob", "Hello, tell me about Rust."))
# Алис продължава разговора си за Python
print(manager.send_message("alice", "How do I get started?"))
Кога да поемете контрол над историята
Автоматичното верижно свързване има ограничение: не можете да променяте вече казаното. Ако Вашето приложение трябва да обобщава предишни реплики, да изтрива съобщение, съдържащо лични данни, или да reinjectира реформулиран контекст, преминете към структуриран вход и управлявайте списъка сами. Губите простотата, но печелите пълен контрол – както и възможността да проследявате инфлацията на токени реплика след реплика.
def manual_conversation():
"""Разговор с ръчно управление на историята."""
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()
Оцеляване след рестарт
Речникът в паметта изчезва при първото повторно внедряване, отнасяйки със себе си всички активни разговори. В производствена среда запазвайте идентификаторите – JSON файлът по-долу илюстрира принципа, който можете да адаптирате към Вашата база данни или Redis. Обърнете внимание, че записваме и времевия печат, и използването на токени – две информации, използвани съответно за изтичане на срока и проследяване на разходите.
import json
from datetime import datetime
class PersistentSessionManager:
"""Устойчиви сесии с резервно копие."""
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
Накрая, внедрете изтичане на срока. Без почистване таблицата Ви със сесии само ще расте, а потребител, върнал се след три седмици, ще възобнови разговор, който вече не помни. Двадесет и четири часа е разумна отправна точка, която може да се коригира според Вашия случай на употреба.
from datetime import datetime, timedelta
def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
"""Премахва изтеклите сесии."""
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
За да обобщим тези избори: използвайте previous_response_id за прости разговори – това е най-ефективно; преминете към структуриран вход, когато трябва да променяте историята; съхранявайте response.id надеждно, в база данни, а не в паметта; почиствайте неактивните сесии; и следете кумулативните токени, иначе фактурирането ще Ви настигне.
Ключови изводи
previous_response_idверижно свързва отговорите автоматично, без повторно изпращане на историята- Всеки отговор има уникален
id, използваем за верижно свързване - Управлявайте множество сесии с речник
user_id -> response_id - Структурираният вход (списък със съобщения) предлага по-голям контрол над историята
- Внедрете устойчивост на сесиите и изтичане на срока в производствена среда