Премини към основното съдържание
Български— Изберете език
Меню

Състояние на разговора и управление на сесиите

Урок 11 от 22 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Състояние на разговора и управление на сесиите
  2. Верижно свързване чрез previous_response_id
  3. Стартиране на множество разговори
  4. Кога да поемете контрол над историята
  5. Оцеляване след рестарт
  6. Ключови изводи

Състояние на разговора и управление на сесиите

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
  • Структурираният вход (списък със съобщения) предлага по-голям контрол над историята
  • Внедрете устойчивост на сесиите и изтичане на срока в производствена среда