Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Stanje pogovora in upravljanje sej

Lekcija 11 od 22 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Stanje pogovora in upravljanje sej
  2. Povezovanje s parametrom previous_response_id
  3. Vzporedno vodenje več pogovorov
  4. Kdaj prevzeti nadzor nad zgodovino
  5. Preživetje ponovnega zagona
  6. Ključne ugotovitve

Stanje pogovora in upravljanje sej

API Responses samodejno podpira stanje pogovora, kar drastično poenostavi ohranjanje konteksta med zaporednimi odzivi. Zgodovine ni treba več rekonstruirati za vsako zahtevo posebej: strežnik to opravi namesto vas, vi pa posredujete le identifikator.

Povezovanje s parametrom previous_response_id

Mehanizem se skrči na eno samo polje. Vsak odziv ima id; tega posredujete v parametru previous_response_id ob naslednjem klicu in model dobi dostop do vsega, kar je bilo povedano prej. V spodnji izmenjavi tretje vprašanje – „Kako jih seštejem?” – samostojno nima smisla: povezovanje modelu pove, da govorimo o ulomkih in da je uporabnik začetnik.

from openai import OpenAI
client = OpenAI()

# Prva izmenjava
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 izmenjava — kontekst se samodejno ohrani
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}")

# Tretja izmenjava — celoten pogovor je dostopen
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 ve, da smo od začetka govorili o ulomkih

Razmisli o razliki glede na prejšnji pristop. Pri Chat Completions je pogovor živel v seznamu, ki ste ga vzdrževali sami in ga pri vsakem koraku znova pošiljali v celoti, zaradi česar so stroški z daljšanjem izmenjave rasli.

# STARO — vse ste morali upravljati sami
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?"},
]
# Poslano v celoti ob vsakem klicu = naraščajoči stroški

Ista izmenjava se zdaj zreducira na eno samo referenco:

# NOVO — dovolj je en sam ID
r = client.responses.create(
    model="gpt-5.6-terra",
    input="How do I add them?",
    previous_response_id="previous_response_id"
)
# Strežnik namesto vas upravlja zgodovino

Vzporedno vodenje več pogovorov

Takoj ko vaša aplikacija streže več uporabnikov, se pojavi vprašanje: kateri identifikator pripada komu? Odgovor je preslikovalna tabela med uporabnikom in najnovejšim response.id za njegov pogovor. Spodnji upravitelj encapsulira to logiko: previous_response_id doda le, če seja že obstaja, nato pa shrani novi identifikator. Alenka in Borut lahko tako vzporedno konverzirata, ne da bi se njuna konteksta mešala, „nova seja” pa preprosto pomeni pozabo trenutnega identifikatorja.

class SessionManager:
    """Upravitelj sej pogovorov."""

    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:
        """Pošlje sporočilo v uporabnikovi seji."""
        kwargs = {
            "model": "gpt-5.6-terra",
            "input": message,
        }

        # Dodaj navodila, če so podana
        if instructions:
            kwargs["instructions"] = instructions

        # Poveži s prejšnjim odzivom, če obstaja
        if user_id in self.sessions:
            kwargs["previous_response_id"] = self.sessions[user_id]

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

        # Shrani ID za naslednji korak
        self.sessions[user_id] = response.id

        return response.output_text

    def new_session(self, user_id: str):
        """Začne nov pogovor za uporabnika."""
        if user_id in self.sessions:
            del self.sessions[user_id]

# Uporaba
manager = SessionManager()

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

# Uporabnik Borut (neodvisen pogovor)
print(manager.send_message("bob", "Hello, tell me about Rust."))

# Alenka nadaljuje pogovor o Pythonu
print(manager.send_message("alice", "How do I get started?"))

Kdaj prevzeti nadzor nad zgodovino

Samodejno povezovanje ima mejo: ne morete spreminjati tega, kar je bilo že povedano. Če vaša aplikacija potrebuje povzemanje preteklih korakov, brisanje sporočila z osebnimi podatki ali ponovno vbrizganje preoblikovanega konteksta, preklopite na strukturiran vnos in seznam upravljajte sami. Izgubite preprostost, a pridobite popoln nadzor – in možnost sledenja napihovanju števila žetonov iz koraka v korak.

def manual_conversation():
    """Pogovor z ročnim upravljanjem zgodovine."""
    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 žetoni: {response.usage.input_tokens})")

# manual_conversation()

Preživetje ponovnega zagona

Slovar v pomnilniku ob prvi ponovni namestitvi izgine, z njim pa vse aktivne pogovore. V produkcijskem okolju identifikatorje trajno shranite – spodnja datoteka JSON ponazarja princip, ki ga lahko prilagodite svoji bazi podatkov ali Redisu. Upoštevajte, da beležimo tudi časovni žig in porabo žetonov; dve informaciji, ki ju uporabimo za potek veljavnosti oziroma sledenje stroškom.

import json
from datetime import datetime

class PersistentSessionManager:
    """Trajne seje z varnostno kopijo."""

    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

Nazadnje implementirajte potek veljavnosti. Brez čiščenja tabela sej le raste, uporabnik, ki se vrne čez tri tedne, pa bi nadaljeval pogovor, katerega se ne spominja več. Dvainštirideset ur je razumna izhodiščna vrednost, ki jo prilagodite svojemu primeru uporabe.

from datetime import datetime, timedelta

def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
    """Odstrani potekle seje."""
    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} potekla(-ih) seja(-e) odstranjena(-ih)")

    return active

Če povzamemo te izbire: za preproste pogovore uporabite previous_response_id – to je najbolj učinkovito; preklopite na strukturiran vnos, ko potrebujete spreminjanje zgodovine; response.id zanesljivo shranite v bazo podatkov, ne v pomnilnik; počistite neaktivne seje; in spremljajte kumulativne žetone, sicer vas bodo dohiteli stroški.

Ključne ugotovitve

  • previous_response_id samodejno poveže odzive brez ponovnega pošiljanja zgodovine
  • Vsak odziv ima edinstven id, uporaben za povezovanje
  • Več sej upravljajte s slovarjem user_id -> response_id
  • Strukturiran vnos (seznam sporočil) omogoča večji nadzor nad zgodovino
  • V produkcijskem okolju implementirajte trajnost sej in potek veljavnosti