Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Konversationstillstånd och sessionshantering

Lektion 11 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Konversationstillstånd och sessionshantering
  2. Kedjekoppling med previous_response_id
  3. Hantera flera konversationer
  4. När du behöver ta kontroll över historiken
  5. Överleva en omstart
  6. Viktiga punkter

Konversationstillstånd och sessionshantering

Responses API har inbyggt stöd för konversationstillstånd, vilket förenklar hanteringen av kontext mellan olika inlägg avsevärt. Du behöver inte längre återskapa historiken för varje begäran: servern sköter detta åt dig, och du behöver bara skicka med en identifierare.

Kedjekoppling med previous_response_id

Mekanismen kokar ner till ett enda fält. Varje svar har ett id; skicka detta i previous_response_id vid nästa anrop, så har modellen tillgång till allt som sagts tidigare. I utbytet nedan ger den tredje frågan – “Hur lägger jag ihop dem?” – ingen mening isolerat sett: kedjekopplingen låter modellen förstå att vi pratar om bråk och att användaren är nybörjare.

from openai import OpenAI
client = OpenAI()

# Första utbytet
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}")

# Andra utbytet — kontexten bevaras automatiskt
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 utbytet — hela konversationen är tillgänglig
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 vet att vi har pratat om bråk från början

Tänk på skillnaden jämfört med det tidigare tillvägagångssättet. Med Chat Completions levde konversationen i en lista som du underhöll själv och skickade i sin helhet vid varje inlägg, vilket innebar att kostnaderna ökade i takt med att utbytet blev längre.

# GAMMALT — du var tvungen att hantera allt själv
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?"},
]
# Skickas i sin helhet vid varje anrop = stigande kostnader

Samma utbyte reduceras nu till en enda referens:

# NYTT — ett enda ID räcker
r = client.responses.create(
    model="gpt-5.6-terra",
    input="How do I add them?",
    previous_response_id="previous_response_id"
)
# Servern hanterar historiken åt dig

Hantera flera konversationer

Så snart din applikation betjänar flera användare uppstår frågan: vilken identifierare tillhör vem? Svaret är en mappningstabell mellan användaren och det senaste response.id för deras konversation. Hanteraren nedan kapslar in denna logik: den lägger till previous_response_id endast om en session redan existerar, och lagrar sedan den nya identifieraren. Alice och Bob kan därmed föra parallella konversationer utan att deras kontext blandas, och “ny session” innebär helt enkelt att man glömmer den aktuella identifieraren.

class SessionManager:
    """Hanterare för konversationssessioner."""

    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:
        """Skickar ett meddelande i användarens session."""
        kwargs = {
            "model": "gpt-5.6-terra",
            "input": message,
        }

        # Lägg till instruktioner om de anges
        if instructions:
            kwargs["instructions"] = instructions

        # Kedjekoppla med föregående svar om det finns
        if user_id in self.sessions:
            kwargs["previous_response_id"] = self.sessions[user_id]

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

        # Spara ID:t för nästa inlägg
        self.sessions[user_id] = response.id

        return response.output_text

    def new_session(self, user_id: str):
        """Startar en ny konversation för användaren."""
        if user_id in self.sessions:
            del self.sessions[user_id]

# Användning
manager = SessionManager()

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

# Användare Bob (oberoende konversation)
print(manager.send_message("bob", "Hello, tell me about Rust."))

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

När du behöver ta kontroll över historiken

Automatisk kedjekoppling har en begränsning: du kan inte modifiera det som redan har sagts. Om din applikation behöver sammanfatta tidigare inlägg, radera ett meddelande som innehåller personuppgifter, eller injicera en omformulerad kontext på nytt, bör du byta till strukturerad inmatning och hantera listan själv. Du förlorar enkelheten, men får full kontroll – och möjligheten att spåra tokeninflation inlägg för inlägg.

def manual_conversation():
    """Konversation med manuell hantering av 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"  (Kumulativa tokens: {response.usage.input_tokens})")

# manual_conversation()

Överleva en omstart

En ordbok i minnet försvinner vid första omdistributionen, vilket tar med sig alla aktiva konversationer. I produktion måste du beständiggöra identifierarna – JSON-filen nedan illustrerar principen, som du kan anpassa till din databas eller Redis. Observera att vi även registrerar tidsstämpeln och tokenanvändningen, två uppgifter som används för utgångsdatum och kostnadsuppföljning.

import json
from datetime import datetime

class PersistentSessionManager:
    """Beständiga sessioner med säkerhetskopiering."""

    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

Implementera slutligen utgångsdatum. Utan rensning växer din sessionstabell bara, och en användare som återvänder efter tre veckor skulle återuppta en konversation de inte längre minns. Tjugofyra timmar är en rimlig utgångspunkt, justerbart beroende på ditt användningsområde.

from datetime import datetime, timedelta

def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
    """Tar bort utgångna sessioner."""
    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} utgången(a) session(er) borttagen(a)")

    return active

Sammanfattningsvis gäller följande för dessa val: använd previous_response_id för enkla konversationer – det är mest effektivt; byt till strukturerad inmatning när du behöver modifiera historiken; lagra response.id pålitligt, helst i en databas snarare än i minnet; rensa inaktiva sessioner; och övervaka kumulativa tokens, annars hinner faktureringen ikapp dig.

Viktiga punkter

  • previous_response_id kedjekopplar svar automatiskt utan att skicka om historiken
  • Varje svar har ett unikt id som kan användas för kedjekoppling
  • Hantera flera sessioner med en ordbok user_id -> response_id
  • Strukturerad inmatning (meddelandelista) ger mer kontroll över historiken
  • Implementera beständighet och utgångsdatum för sessioner i produktion