Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Stanje razgovora i upravljanje sesijama

Lekcija 11 od 22 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Stanje razgovora i upravljanje sesijama
  2. Lančanje pomoću previous_response_id
  3. Pokretanje više razgovora
  4. Kada preuzeti kontrolu nad poviješću
  5. Preživljavanje ponovnog pokretanja
  6. Ključne točke

Stanje razgovora i upravljanje sesijama

Responses API izvorno podržava stanje razgovora, što drastično pojednostavljuje održavanje konteksta kroz više uzastopnih poruka. Više ne moraš rekonstruirati povijest za svaki zahtjev: server to radi umjesto tebe, a ti samo prosljeđuješ identifikator.

Lančanje pomoću previous_response_id

Mehanizam se svodi na jedno polje. Svaki odgovor ima id; proslijedi ga u previous_response_id pri sljedećem pozivu i model će imati pristup svemu što je prethodilo. U razmjeni ispod, treće pitanje – „Kako ih zbrajam?“ – nema smisla izolirano: lančanje omogućuje modelu da zna da govorimo o razlomcima i da je korisnik početnik.

from openai import OpenAI
client = OpenAI()

# Prva razmjena
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 razmjena — kontekst je automatski očuvan
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}")

# Treća razmjena — cijeli razgovor je dostupan
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 zna da od početka govorimo o razlomcima

Razmisli o razlici u odnosu na prethodni pristup. Kod Chat Completions razgovor je živio u popisu koji si sam održavao i slao u cijelosti pri svakom koraku, pri čemu su troškovi rasli kako se razmjena produljivala.

# STARO — morao si sve upravljati sam
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?"},
]
# Slanje u cijelosti pri svakom pozivu = rastući troškovi

Ista se razmjena sada svodi na jednu referencu:

# NOVO — dovoljan je jedan ID
r = client.responses.create(
    model="gpt-5.6-terra",
    input="How do I add them?",
    previous_response_id="previous_response_id"
)
# Server upravlja poviješću umjesto tebe

Pokretanje više razgovora

Čim tvoja aplikacija opslužuje više korisnika, postavlja se pitanje: koji identifikator pripada kome? Odgovor je tablica mapiranja između korisnika i najnovijeg response.id za njegov razgovor. Upravitelj u nastavku encapsulira tu logiku: dodaje previous_response_id samo ako sesija već postoji, a zatim pohranjuje novi identifikator. Alice i Bob tako mogu razgovarati paralelno bez miješanja konteksta, a „nova sesija“ jednostavno znači zaboravljanje trenutnog identifikatora.

class SessionManager:
    """Upravitelj sesijama razgovora."""

    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:
        """Šalje poruku u korisnikovoj sesiji."""
        kwargs = {
            "model": "gpt-5.6-terra",
            "input": message,
        }

        # Dodaj upute ako su navedene
        if instructions:
            kwargs["instructions"] = instructions

        # Lančaj s prethodnim odgovorom ako postoji
        if user_id in self.sessions:
            kwargs["previous_response_id"] = self.sessions[user_id]

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

        # Spremi ID za sljedeći korak
        self.sessions[user_id] = response.id

        return response.output_text

    def new_session(self, user_id: str):
        """Pokreće novi razgovor za korisnika."""
        if user_id in self.sessions:
            del self.sessions[user_id]

# Upotreba
manager = SessionManager()

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

# Korisnik Bob (nezavisan razgovor)
print(manager.send_message("bob", "Hello, tell me about Rust."))

# Alice nastavlja svoj razgovor o Pythonu
print(manager.send_message("alice", "How do I get started?"))

Kada preuzeti kontrolu nad poviješću

Automatsko lančanje ima granicu: ne možeš modificirati ono što je već rečeno. Ako tvoja aplikacija treba sažeti prošle korake, izbrisati poruku koja sadrži osobne podatke ili ponovno ubaciti reformulirani kontekst, prijeđi na strukturirani unos i sam upravljaj popisom. Gubiš na jednostavnosti, ali dobivaš potpunu kontrolu – i mogućnost praćenja napuhavanja tokena iz koraka u korak.

def manual_conversation():
    """Razgovor s ručnim upravljanjem poviješću."""
    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 tokeni: {response.usage.input_tokens})")

# manual_conversation()

Preživljavanje ponovnog pokretanja

Rječnik u memoriji nestaje pri prvom ponovnom raspoređivanju, povlačeći sa sobom sve aktivne razgovore. U proizvodnji trajno pohrani identifikatore – donji JSON datoteka ilustrira princip, koji možeš prilagoditi svojoj bazi podataka ili Redisu. Imaj na umu da također bilježimo vremensku oznaku i potrošnju tokena, dva podatka koja se koriste za istek i praćenje troškova.

import json
from datetime import datetime

class PersistentSessionManager:
    """Trajne sesije s sigurnosnom kopijom."""

    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

Konačno, implementiraj istek. Bez čišćenja, tvoja tablica sesija samo raste, a korisnik koji se vrati nakon tri tjedna nastavio bi razgovor kojeg se više ne sjeća. Dvadeset četiri sata razuman je početni okvir, prilagodiv ovisno o tvom slučaju upotrebe.

from datetime import datetime, timedelta

def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
    """Uklanja istečene sesije."""
    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} istekla(-e) sesija(-e) uklonjeno")

    return active

Da sumiramo ove izbore: koristi previous_response_id za jednostavne razgovore – to je najučinkovitije; prijeđi na strukturirani unos kada trebaš modificirati povijest; pouzdano pohrani response.id, u bazi podataka umjesto u memoriji; očisti neaktivne sesije; i prati kumulativne tokene, inače će te naplatiti stići.

Ključne točke

  • previous_response_id automatski lanča odgovore bez ponovnog slanja povijesti
  • Svaki odgovor ima jedinstveni id koji se može koristiti za lančanje
  • Upravljaj više sesija s rječnikom user_id -> response_id
  • Strukturirani unos (popis poruka) nudi veću kontrolu nad poviješću
  • Implementiraj trajnost sesija i istek u proizvodnji