Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Gespreksstatus en sessiebeheer

Les 11 van 22 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Gespreksstatus en sessiebeheer
  2. Koppelen met previous_response_id
  3. Meerdere gesprekken voeren
  4. Wanneer u de geschiedenis zelf moet beheren
  5. Een herstart overleven
  6. Belangrijkste punten

Gespreksstatus en sessiebeheer

De Responses API ondersteunt gespreksstatus native, wat het behouden van context tussen opeenvolgende beurten drastisch vereenvoudigt. U hoeft de geschiedenis niet langer voor elk verzoek opnieuw op te bouwen: de server regelt dit voor u en u geeft slechts een identificatiecode door.

Koppelen met previous_response_id

Het mechanisme komt neer op één enkel veld. Elk antwoord heeft een id; geef deze door in previous_response_id bij de volgende aanroep, en het model heeft toegang tot alles wat eraan voorafging. In de onderstaande uitwisseling zou de derde vraag—“Hoe tel ik ze op?”—op zichzelf geen zin hebben: dankzij de koppeling weet het model dat we het over breuken hebben en dat de gebruiker een beginner is.

from openai import OpenAI
client = OpenAI()

# Eerste uitwisseling
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}")

# Tweede uitwisseling — context blijft automatisch behouden
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}")

# Derde uitwisseling — het hele gesprek is toegankelijk
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}")
# Het model weet dat we vanaf het begin over breuken praten

Beschouw het verschil met de vorige aanpak. Bij Chat Completions leefde het gesprek in een lijst die u zelf beheerde en bij elke beurt volledig opnieuw verzond, waarbij de kosten toenamen naarmate de uitwisseling langer werd.

# OUD — u moest alles zelf beheren
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?"},
]
# Bij elke oproep volledig verzonden = stijgende kosten

Dezelfde uitwisseling reduceert nu tot een enkele referentie:

# NIEUW — een enkele ID volstaat
r = client.responses.create(
    model="gpt-5.6-terra",
    input="How do I add them?",
    previous_response_id="previous_response_id"
)
# De server beheert de geschiedenis voor u

Meerdere gesprekken voeren

Zodra uw applicatie meerdere gebruikers bedient, rijst de vraag: welke identificatiecode behoort tot wie? Het antwoord is een mapping-tabel tussen de gebruiker en de meest recente response.id voor hun gesprek. De onderstaande manager kapselt deze logica in: hij voegt previous_response_id alleen toe als er al een sessie bestaat, en slaat vervolgens de nieuwe identificatiecode op. Alice en Bob kunnen zo parallel converseren zonder dat hun contexten vermengen, en een “nieuwe sessie” betekent simpelweg het vergeten van de huidige identificatiecode.

class SessionManager:
    """Beheerder voor conversatiesessies."""

    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:
        """Verstuurt een bericht in de sessie van de gebruiker."""
        kwargs = {
            "model": "gpt-5.6-terra",
            "input": message,
        }

        # Instructies toevoegen indien opgegeven
        if instructions:
            kwargs["instructions"] = instructions

        # Koppelen met het vorige antwoord indien aanwezig
        if user_id in self.sessions:
            kwargs["previous_response_id"] = self.sessions[user_id]

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

        # De ID opslaan voor de volgende beurt
        self.sessions[user_id] = response.id

        return response.output_text

    def new_session(self, user_id: str):
        """Start een nieuw gesprek voor de gebruiker."""
        if user_id in self.sessions:
            del self.sessions[user_id]

# Gebruik
manager = SessionManager()

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

# Gebruiker Bob (onafhankelijk gesprek)
print(manager.send_message("bob", "Hello, tell me about Rust."))

# Alice zet haar gesprek over Python voort
print(manager.send_message("alice", "How do I get started?"))

Wanneer u de geschiedenis zelf moet beheren

Automatische koppeling heeft een limiet: u kunt niet wijzigen wat er al gezegd is. Als uw applicatie eerdere beurten moet samenvatten, een bericht met persoonsgegevens moet verwijderen, of een geherformuleerde context opnieuw moet injecteren, schakelt u over op gestructureerde input en beheert u de lijst zelf. U verliest aan eenvoud, maar wint volledige controle—en de mogelijkheid om token-inflatie beurt na beurt te volgen.

def manual_conversation():
    """Gesprek met handmatig geschiedenisbeheer."""
    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"  (Cumulatieve tokens: {response.usage.input_tokens})")

# manual_conversation()

Een herstart overleven

Een dictionary in het geheugen verdwijnt bij de eerste herimplementatie, samen met alle actieve gesprekken. In productie moet u de identificatiecodes persistent opslaan; het onderstaande JSON-bestand illustreert het principe, dat u kunt aanpassen aan uw database of Redis. Merk op dat we ook de tijdstempel en het tokengebruik registreren, twee gegevens die respectievelijk worden gebruikt voor verloop en kostentracking.

import json
from datetime import datetime

class PersistentSessionManager:
    """Persistente sessies met back-up."""

    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

Implementeer tot slot een verloopmechanisme. Zonder opschoning groeit uw sessietabel alleen maar, en een gebruiker die drie weken later terugkeert, zou een gesprek hervatten dat hij zich niet meer herinnert. Vierentwintig uur is een redelijk uitgangspunt, aanpasbaar op basis van uw use case.

from datetime import datetime, timedelta

def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
    """Verwijdert verlopen sessies."""
    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} verlopen sessie(s) verwijderd")

    return active

Om deze keuzes samen te vatten: gebruik previous_response_id voor eenvoudige gesprekken—dit is het meest efficiënt; schakel over op gestructureerde input wanneer u de geschiedenis moet wijzigen; sla response.id betrouwbaar op, bij voorkeur in een database en niet in het geheugen; ruim inactieve sessies op; en bewaak de cumulatieve tokens, anders loopt u tegen onverwachte kosten aan.

Belangrijkste punten

  • previous_response_id koppelt antwoorden automatisch zonder de geschiedenis opnieuw te verzenden
  • Elk antwoord heeft een unieke id die gebruikt kan worden voor koppeling
  • Beheer meerdere sessies met een user_id -> response_id-dictionary
  • Gestructureerde input (berichtenlijst) biedt meer controle over de geschiedenis
  • Implementeer sessie-persistentie en verloop in productieomgevingen