Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Stav konverzace a správa relací

Lekce 11 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Stav konverzace a správa relací
  2. Řetězení pomocí previous_response_id
  3. Provozování více konverzací
  4. Kdy převzít kontrolu nad historií
  5. Přežití restartu
  6. Klíčové poznatky

Stav konverzace a správa relací

API Responses nativně podporuje stav konverzace, což drasticky zjednodušuje udržování kontextu mezi jednotlivými výměnami. Už nemusíš pro každý požadavek znovu sestavovat historii: server to zařídí za tebe a ty pouze předáš identifikátor.

Řetězení pomocí previous_response_id

Celý mechanismus se redukuje na jediné pole. Každá odpověď má své id; při dalším volání ho předáš v parametru previous_response_id a model získá přístup ke všemu, co bylo řečeno dříve. Ve výměně níže třetí otázka – „Jak je sečtu?“ – by sama o sobě nedávala smysl: řetězení zajistí, že model ví, že mluvím o zlomcích a že uživatel je začátečník.

from openai import OpenAI
client = OpenAI()

# První výměna
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}")

# Druhá výměna — kontext je automaticky zachován
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}")

# Třetí výměna — celá konverzace je přístupná
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 ví, že od začátku mluvíme o zlomcích

Podívej se na rozdíl oproti předchozímu přístupu. U Chat Completions žila konverzace v seznamu, který jsi musel udržovat sám a při každém kroku ho posílat celý, přičemž s délkou výměny rostly náklady.

# STARÝ PŘÍSTUP — vše jsi musel spravovat sám
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?"},
]
# Posíláno celé při každém volání = rostoucí náklady

Stejná výměna se nyní redukuje na jediný odkaz:

# NOVÝ PŘÍSTUP — stačí jediné ID
r = client.responses.create(
    model="gpt-5.6-terra",
    input="How do I add them?",
    previous_response_id="previous_response_id"
)
# Server spravuje historii za tebe

Provozování více konverzací

Jakmile tvoje aplikace obsluhuje více uživatelů, vyvstává otázka: který identifikátor patří komu? Odpovědí je mapovací tabulka mezi uživatelem a nejnovějším response.id jeho konverzace. Následující správce tuto logiku zapouzdřuje: přidá previous_response_id pouze tehdy, pokud relace již existuje, a poté uloží nový identifikátor. Alice a Bob tak mohou konverzovat paralelně, aniž by se jim mísily kontexty, a „nová relace“ jednoduše znamená zapomenutí aktuálního identifikátoru.

class SessionManager:
    """Správce relací konverzace."""

    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:
        """Odešle zprávu v rámci relace uživatele."""
        kwargs = {
            "model": "gpt-5.6-terra",
            "input": message,
        }

        # Přidání instrukcí, pokud jsou poskytnuty
        if instructions:
            kwargs["instructions"] = instructions

        # Řetězení s předchozí odpovědí, pokud existuje
        if user_id in self.sessions:
            kwargs["previous_response_id"] = self.sessions[user_id]

        response = client.responses.create(**kwargs)

        # Uložení ID pro další krok
        self.sessions[user_id] = response.id

        return response.output_text

    def new_session(self, user_id: str):
        """Spustí novou konverzaci pro uživatele."""
        if user_id in self.sessions:
            del self.sessions[user_id]

# Použití
manager = SessionManager()

# Uživatel Alice
print(manager.send_message("alice", "Hello, tell me about Python."))
print(manager.send_message("alice", "What are its advantages?"))

# Uživatel Bob (nezávislá konverzace)
print(manager.send_message("bob", "Hello, tell me about Rust."))

# Alice pokračuje ve své konverzaci o Pythonu
print(manager.send_message("alice", "How do I get started?"))

Kdy převzít kontrolu nad historií

Automatické řetězení má svůj limit: nemůžeš měnit to, co již bylo řečeno. Pokud tvoje aplikace potřebuje shrnout předchozí kroky, smazat zprávu obsahující osobní údaje nebo znovu vložit přeformulovaný kontext, přepni se na strukturovaný vstup a seznam spravuj sám. Ztratíš na jednoduchosti, ale získáš plnou kontrolu – a schopnost sledovat nafukování tokenů krok za krokem.

def manual_conversation():
    """Konverzace s ruční správou historie."""
    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"  (Kumulativní tokeny: {response.usage.input_tokens})")

# manual_conversation()

Přežití restartu

Slovník v paměti zmizí při prvním redeployování a vezme s sebou všechny aktivní konverzace. V produkčním prostředí musíš identifikátory perzistentně ukládat – následující JSON soubor ilustruje princip, který můžeš přizpůsobit své databázi nebo Redisu. Všimni si, že zaznamenáváme také časové razítko a využití tokenů, dvě informace používané rispetive pro vypršení platnosti a sledování nákladů.

import json
from datetime import datetime

class PersistentSessionManager:
    """Perzistentní relace se zálohováním."""

    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

Nakonec implementuj vypršení platnosti. Bez čištění bude tvoje tabulka relací pouze růst a uživatel, který se vrátí za tři týdny, by obnovil konverzaci, na kterou si už nepamatuje. Dvacet čtyři hodin je rozumný výchozí bod, který lze upravit podle tvého případu použití.

from datetime import datetime, timedelta

def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
    """Odstraní expirované relace."""
    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} expirovaná(ých) relace(í) odstraněna")

    return active

Shrňme si tato rozhodnutí: pro jednoduché konverzace použij previous_response_id – je to nejefektivnější; přepni se na strukturovaný vstup, když potřebuješ upravovat historii; ukládej response.id spolehlivě, raději do databáze než do paměti; čistě neaktivní relace; a sleduj kumulativní tokeny, jinak tě doženou faktury.

Klíčové poznatky

  • previous_response_id automaticky řetězí odpovědi bez opětovného posílání historie
  • Každá odpověď má unikátní id použitelné pro řetězení
  • Spravuj více relací pomocí slovníku user_id -> response_id
  • Strukturovaný vstup (seznam zpráv) nabízí větší kontrolu nad historií
  • V produkčním prostředí implementuj perzistenci relací a jejich vypršení platnosti