Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Samtalestatus og sessionshåndtering

Lektion 11 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Samtalestatus og sessionshåndtering
  2. Kædning med previous_response_id
  3. Kørsel af flere samtaler
  4. Hvornår du skal tage kontrol over historikken
  5. Overlevelse efter genstart
  6. Vigtige pointer

Samtalestatus og sessionshåndtering

Responses API understøtter samtalestatus nativt, hvilket forenkler vedligeholdelsen af kontekst på tværs af tur drastisk. Du behøver ikke længere at genopbygge historikken for hver anmodning: serveren håndterer det for dig, og du skal blot sende en identifikator.

Kædning med previous_response_id

Mekanismen koges ned til et enkelt felt. Hvert svar har et id; send det i previous_response_id ved næste kald, så har modellen adgang til alt, der er sket før. I udvekslingen nedenfor giver det tredje spørgsmål – „Hvordan lægger jeg dem sammen?” – ingen mening isoleret set: kædning fortæller modellen, at vi taler om brøker, og at brugeren er nybegynder.

from openai import OpenAI
client = OpenAI()

# Første udveksling
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}")

# Anden udveksling — konteksten bevares automatisk
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}")

# Tredje udveksling — hele samtalen er tilgængelig
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}")
# Modellen ved, at vi har talt om brøker fra starten

Overvej forskellen fra den tidligere tilgang. Med Chat Completions levede samtalen i en liste, som du selv vedligeholdt og sendte fuldt ud ved hver tur, hvor omkostningerne steg, efterhånden som udvekslingen blev længere.

# GAMMELT — du skulle styre alt selv
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?"},
]
# Sendes fuldt ud ved hvert kald = stigende omkostninger

Den samme udveksling reduceres nu til en enkelt reference:

# NYT — et enkelt ID er nok
r = client.responses.create(
    model="gpt-5.6-terra",
    input="How do I add them?",
    previous_response_id="previous_response_id"
)
# Serveren styrer historikken for dig

Kørsel af flere samtaler

Så snart din applikation betjener flere brugere, bliver spørgsmålet: hvilken identifikator hører til hvem? Svaret er en mapping-tabel mellem brugeren og det seneste response.id for deres samtale. Manageren nedenfor kapsler denne logik ind: den tilføjer kun previous_response_id, hvis der allerede findes en session, og gemmer derefter den nye identifikator. Alice og Bob kan dermed føre samtaler parallelt uden at deres kontekster blandes, og „ny session” betyder blot at glemme den aktuelle identifikator.

class SessionManager:
    """Sessionshåndtering for samtaler."""

    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:
        """Sender en besked i brugerens session."""
        kwargs = {
            "model": "gpt-5.6-terra",
            "input": message,
        }

        # Tilføj instrukser hvis angivet
        if instructions:
            kwargs["instructions"] = instructions

        # Kæd med det forrige svar hvis det eksisterer
        if user_id in self.sessions:
            kwargs["previous_response_id"] = self.sessions[user_id]

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

        # Gem ID'et til næste tur
        self.sessions[user_id] = response.id

        return response.output_text

    def new_session(self, user_id: str):
        """Starter en ny samtale for brugeren."""
        if user_id in self.sessions:
            del self.sessions[user_id]

# Brug
manager = SessionManager()

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

# Bruger Bob (uafhængig samtale)
print(manager.send_message("bob", "Hello, tell me about Rust."))

# Alice fortsætter sin samtale om Python
print(manager.send_message("alice", "How do I get started?"))

Hvornår du skal tage kontrol over historikken

Automatisk kædning har en begrænsning: du kan ikke ændre det, der allerede er sagt. Hvis din applikation skal opsummere tidligere tur, slette en besked med personlige data eller genindsætte en omformuleret kontekst, skal du skifte til struktureret input og selv administrere listen. Du mister enkelheden, men får fuld kontrol – og evnen til at spore token-inflation tur for tur.

def manual_conversation():
    """Samtale med manuel håndtering af historik."""
    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"  (Kumulative tokens: {response.usage.input_tokens})")

# manual_conversation()

Overlevelse efter genstart

Et ordbogsobjekt i hukommelsen forsvinder ved første genudrulning og tager alle aktive samtaler med sig. I produktion skal du persistere identifikatorerne – JSON-filen nedenfor illustrerer princippet, som du kan tilpasse til din database eller Redis. Bemærk, at vi også registrerer tidsstemplet og token-forbruget, to oplysninger der bruges henholdsvis til udløb og omkostningssporing.

import json
from datetime import datetime

class PersistentSessionManager:
    """Persistente sessions med backup."""

    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

Implementér til sidst udløb. Uden oprydning vokser din sessionstabel kun, og en bruger, der vender tilbage efter tre uger, vil genoptage en samtale, de ikke længere kan huske. 24 timer er et rimeligt udgangspunkt, der kan justeres efter dit use case.

from datetime import datetime, timedelta

def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
    """Fjerner udløbne sessions."""
    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} udløbet(ne) session(er) fjernet")

    return active

For at opsummere disse valg: brug previous_response_id til simple samtaler – det er mest effektivt; skift til struktureret input, når du skal ændre historikken; gem response.id pålideligt, helst i en database frem for i hukommelsen; ryd op i inaktive sessions; og overvåg kumulative tokens, ellers vil faktureringen indhente dig.

Vigtige pointer

  • previous_response_id kæder svar automatisk uden at gensende historik
  • Hvert svar har et unikt id, der kan bruges til kædning
  • Håndtér flere sessions med en ordbog user_id -> response_id
  • Struktureret input (beskedliste) giver mere kontrol over historikken
  • Implementér sessionspersistens og udløb i produktion