Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Stav konverzácie a správa relácií

Lekcia 11 z 22 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Stav konverzácie a správa relácií
  2. Reťazenie pomocou previous_response_id
  3. Spúšťanie viacerých konverzácií
  4. Kedy prevziať kontrolu nad históriou
  5. Prežitie reštartu
  6. Kľúčové poznatky

Stav konverzácie a správa relácií

API Responses natívne podporuje stav konverzácie, čo výrazne zjednodušuje udržiavanie kontextu medzi jednotlivými odpoveďami. Už nemusíš pre každú požiadavku znovu zostavovať históriu: server to vybaví za teba a ty mu len odovzdáš identifikátor.

Reťazenie pomocou previous_response_id

Mechanizmus sa redukuje na jediné pole. Každá odpoveď má svoje id; odovzdaj ho v poli previous_response_id pri ďalšom volaní a model bude mať prístup ku všetkému, čo predchádzalo. Vo výmene nižšie tretia otázka – „Ako ich sčítam?“ – by sama o sebe nedávala zmysel: vďaka reťazeniu model vie, že hovoríme o zlomkoch a že používateľ je začiatočník.

from openai import OpenAI
client = OpenAI()

# Prvá výmena
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ýmena — kontext sa zachováva automaticky
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}")

# Tretia výmena — celá konverzácia je dostupná
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 vie, že od začiatku hovoríme o zlomkoch

Pozri sa na rozdiel oproti predchádzajúcemu prístupu. Pri Chat Completions žila konverzácia v zozname, ktorý si musel spravovať sám a pri každom kroku ho odosielať celý, pričom náklady rástli s dĺžkou výmeny.

# STARÉ — všetko si musel spravovať 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?"},
]
# Odoslané celé pri každom volaní = rastúce náklady

Tá istá výmena sa teraz redukuje na jedinú referenciu:

# NOVÉ — stačí jedno ID
r = client.responses.create(
    model="gpt-5.6-terra",
    input="How do I add them?",
    previous_response_id="previous_response_id"
)
# Server spravuje históriu za teba

Spúšťanie viacerých konverzácií

Akonáhle tvoja aplikácia obsluhuje viacerých používateľov, vzniká otázka: ktorý identifikátor patrí komu? Odpoveďou je mapovacia tabuľka medzi používateľom a najnovším response.id pre jeho konverzáciu. Nižšie uvedený správca zapuzdruje túto logiku: pridá previous_response_id len vtedy, ak relácia už existuje, a následne uloží nový identifikátor. Alice a Bob tak môžu viesť paralelné konverzácie bez miešania kontextov a „nová relácia“ jednoducho znamená zabudnutie aktuálneho identifikátora.

class SessionManager:
    """Správca relácií konverzácie."""

    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:
        """Odošle správu v relácii používateľa."""
        kwargs = {
            "model": "gpt-5.6-terra",
            "input": message,
        }

        # Pridaj inštrukcie, ak sú poskytnuté
        if instructions:
            kwargs["instructions"] = instructions

        # Reťaz s predchádzajúcou odpoveďou, ak existuje
        if user_id in self.sessions:
            kwargs["previous_response_id"] = self.sessions[user_id]

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

        # Ulož ID pre ďalší krok
        self.sessions[user_id] = response.id

        return response.output_text

    def new_session(self, user_id: str):
        """Spustí novú konverzáciu pre používateľa."""
        if user_id in self.sessions:
            del self.sessions[user_id]

# Použitie
manager = SessionManager()

# Používateľ Alice
print(manager.send_message("alice", "Hello, tell me about Python."))
print(manager.send_message("alice", "What are its advantages?"))

# Používateľ Bob (nezávislá konverzácia)
print(manager.send_message("bob", "Hello, tell me about Rust."))

# Alice pokračuje v konverzácii o Pythone
print(manager.send_message("alice", "How do I get started?"))

Kedy prevziať kontrolu nad históriou

Automatické reťazenie má svoje limity: nemôžeš meniť to, čo už bolo povedané. Ak tvoja aplikácia potrebuje zhrnúť predchádzajúce kroky, vymazať správu obsahujúcu osobné údaje alebo znovu vložiť preformulovaný kontext, prepnite sa na štruktúrovaný vstup a spravuj zoznam sám. Stratíš síce jednoduchosť, ale získaš plnú kontrolu – a schopnosť sledovať nafukovanie tokenov krok za krokom.

def manual_conversation():
    """Konverzácia s manuálnou správou histórie."""
    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"  (Kumulatívne tokeny: {response.usage.input_tokens})")

# manual_conversation()

Prežitie reštartu

Slovník v pamäti zmizne pri prvom opätovnom nasadení a vezme so sebou všetky aktívne konverzácie. V produkčnom prostredí persistuj identifikátory – nižšie uvedený súbor JSON ilustruje princíp, ktorý môžeš prispôsobiť svojej databáze alebo Redisu. Všimni si, že zaznamenávame aj časovú pečiatku a využitie tokenov, dve informácie používané respectively na vypršanie platnosti a sledovanie nákladov.

import json
from datetime import datetime

class PersistentSessionManager:
    """Perzistentné relácie so zálohovaní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

Nakoniec implementuj vypršanie platnosti. Bez čistenia tvoja tabuľka relácií len rastie a používateľ, ktorý sa vráti o tri týždne, by obnovil konverzáciu, na ktorú si už nepamätá. Dvadsaťštyri hodín je rozumný východiskový bod, upraviteľný podľa tvojho prípadu použitia.

from datetime import datetime, timedelta

def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
    """Odstráni expirované relácie."""
    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) relácia(í) odstránená(ých)")

    return active

Ak zhrnieme tieto voľby: používaj previous_response_id pre jednoduché konverzácie – je to najefektívnejšie; prepnite sa na štruktúrovaný vstup, keď potrebuješ upravovať históriu; ukladaj response.id spoľahlivo, radšej do databázy než do pamäte; čistí neaktívne relácie; a monitoruj kumulatívne tokeny, inak ťa dobehne fakturácia.

Kľúčové poznatky

  • previous_response_id automaticky reťazí odpovede bez opätovného odoslania histórie
  • Každá odpoveď má jedinečné id použiteľné na reťazenie
  • Spravuj viacero relácií pomocou slovníka user_id -> response_id
  • Štruktúrovaný vstup (zoznam správ) ponúka väčšiu kontrolu nad históriou
  • V produkčnom prostredí implementuj perzistenciu relácií a ich vypršanie platnosti