Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Κατάσταση συνομιλίας και διαχείριση συνεδριών

Μάθημα 11 / 22 Ενημερώθηκε 29 Ιουλίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Κατάσταση συνομιλίας και διαχείριση συνεδριών
  2. Αλυσιδωτή σύνδεση με το previous_response_id
  3. Εκτέλεση πολλαπλών συνομιλιών
  4. Πότε να αναλάβετε τον έλεγχο του ιστορικού
  5. Επιβίωση μετά από επανεκκίνηση
  6. Βασικά σημεία

Κατάσταση συνομιλίας και διαχείριση συνεδριών

Το Responses API υποστηρίζει εγγενώς την κατάσταση της συνομιλίας, απλοποιώντας δραστικά τη διατήρηση του συμφραζομένου μεταξύ των εναλλαγών. Δεν χρειάζεται πλέον να ανακατασκευάζετε το ιστορικό για κάθε αίτημα: ο διακομιστής το αναλαμβάνει για εσάς και εσείς περνάτε απλώς ένα αναγνωριστικό.

Αλυσιδωτή σύνδεση με το previous_response_id

Ο μηχανισμός ανάγεται σε ένα μόνο πεδίο. Κάθε απόκριση διαθέτει ένα id· περάστε το στο previous_response_id κατά την επόμενη κλήση και το μοντέλο θα έχει πρόσβαση σε ό,τι προηγήθηκε. Στην παρακάτω ανταλλαγή, η τρίτη ερώτηση—«Πώς τα προσθέτω;»—δεν έχει νόημα μεμονωμένα: η αλυσιδωτή σύνδεση επιτρέπει στο μοντέλο να γνωρίζει ότι μιλάμε για κλάσματα και ότι ο χρήστης είναι αρχάριος.

from openai import OpenAI
client = OpenAI()

# First exchange
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}")

# Second exchange — context is preserved automatically
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}")

# Third exchange — the entire conversation is accessible
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}")
# The model knows we've been talking about fractions from the start

Σκεφτείτε τη διαφορά από την προηγούμενη προσέγγιση. Με το Chat Completions, η συνομιλία ζούσε σε μια λίστα που διαχειριζόσασταν εσείς και την ξαναστέλνατε ολόκληρη σε κάθε εναλλαγή, με το κόστος να αυξάνεται καθώς η ανταλλαγή μεγάλωνε.

# OLD — you had to manage everything yourself
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?"},
]
# Sent in full on every call = rising costs

Η ίδια ανταλλαγή τώρα ανάγεται σε μια απλή αναφορά:

# NEW — a single ID is enough
r = client.responses.create(
    model="gpt-5.6-terra",
    input="How do I add them?",
    previous_response_id="previous_response_id"
)
# The server manages the history for you

Εκτέλεση πολλαπλών συνομιλιών

Μόλις η εφαρμογή σας εξυπηρετεί πολλούς χρήστες, το ερώτημα γίνεται: ποιο αναγνωριστικό ανήκει σε ποιον; Η απάντηση είναι ένας πίνακας αντιστοίχισης μεταξύ του χρήστη και του τελευταίου response.id για τη συνομιλία του. Ο διαχειριστής που ακολουθεί ενσωματώνει αυτή τη λογική: προσθέτει το previous_response_id μόνο αν υπάρχει ήδη μια συνεδρία και στη συνέχεια αποθηκεύει το νέο αναγνωριστικό. Έτσι, η Alice και ο Bob μπορούν να συνομιλούν παράλληλα χωρίς να αναμειγνύονται τα συμφραζόμενά τους, ενώ «νέα συνεδρία» σημαίνει απλώς να ξεχνάτε το τρέχον αναγνωριστικό.

class SessionManager:
    """Conversation session manager."""

    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:
        """Sends a message in the user's session."""
        kwargs = {
            "model": "gpt-5.6-terra",
            "input": message,
        }

        # Add instructions if provided
        if instructions:
            kwargs["instructions"] = instructions

        # Chain with the previous response if it exists
        if user_id in self.sessions:
            kwargs["previous_response_id"] = self.sessions[user_id]

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

        # Save the ID for the next turn
        self.sessions[user_id] = response.id

        return response.output_text

    def new_session(self, user_id: str):
        """Starts a new conversation for the user."""
        if user_id in self.sessions:
            del self.sessions[user_id]

# Usage
manager = SessionManager()

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

# User Bob (independent conversation)
print(manager.send_message("bob", "Hello, tell me about Rust."))

# Alice continues her conversation about Python
print(manager.send_message("alice", "How do I get started?"))

Πότε να αναλάβετε τον έλεγχο του ιστορικού

Η αυτόματη αλυσιδωτή σύνδεση έχει ένα όριο: δεν μπορείτε να τροποποιήσετε ό,τι έχει ήδη ειπωθεί. Αν η εφαρμογή σας χρειάζεται να συνοψίσει προηγούμενες εναλλαγές, να διαγράψει ένα μήνυμα που περιέχει προσωπικά δεδομένα ή να επανεισάγει ένα αναδιατυπωμένο συμφραζόμενο, μεταβείτε σε δομημένη είσοδο και διαχειριστείτε εσείς τη λίστα. Χάνετε την απλότητα, αλλά κερδίζετε πλήρη έλεγχο—και τη δυνατότητα παρακολούθησης του πληθωρισμού των tokens εναλλαγή με εναλλαγή.

def manual_conversation():
    """Conversation with manual history management."""
    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"  (Cumulative tokens: {response.usage.input_tokens})")

# manual_conversation()

Επιβίωση μετά από επανεκκίνηση

Ένα λεξικό στη μνήμη εξαφανίζεται με την πρώτη επαναδιάταξη, παρασύροντας μαζί του όλες τις ενεργές συνομιλίες. Σε περιβάλλον παραγωγής, επιμείνετε στα αναγνωριστικά· το παρακάτω αρχείο JSON απεικονίζει την αρχή, την οποία μπορείτε να προσαρμόσετε στη βάση δεδομένων ή στο Redis σας. Σημειώστε ότι καταγράφουμε επίσης τη χρονική σήμανση και τη χρήση tokens, δύο πληροφορίες που χρησιμοποιούνται για τη λήξη και την παρακολούθηση του κόστους, αντίστοιχα.

import json
from datetime import datetime

class PersistentSessionManager:
    """Persistent sessions with 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

Τέλος, υλοποιήστε τη λήξη. Χωρίς εκκαθάριση, ο πίνακας συνεδριών σας μόνο μεγαλώνει, και ένας χρήστης που επιστρέφει μετά από τρεις εβδομάδες θα συνέχιζε μια συνομιλία που δεν θυμάται πια. Οι είκοσι τέσσερις ώρες είναι μια λογική αφετηρία, προσαρμόσιμη ανάλογα με τη χρήση σας.

from datetime import datetime, timedelta

def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
    """Removes expired 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} expired session(s) removed")

    return active

Για να συνοψίσουμε αυτές τις επιλογές: χρησιμοποιήστε το previous_response_id για απλές συνομιλίες—είναι ο πιο αποδοτικός τρόπος· μεταβείτε σε δομημένη είσοδο όταν χρειάζεται να τροποποιήσετε το ιστορικό· αποθηκεύστε αξιόπιστα το response.id, σε βάση δεδομένων και όχι στη μνήμη· εκκαθαρίστε τις ανενεργές συνεδρίες· και παρακολουθήστε τα αθροιστικά tokens, διαφορετικά η χρέωση θα σας προλάβει.

Βασικά σημεία

  • Το previous_response_id συνδέει αυτόματα τις αποκρίσεις χωρίς επαναποστολή του ιστορικού
  • Κάθε απόκριση διαθέτει ένα μοναδικό id κατάλληλο για αλυσιδωτή σύνδεση
  • Διαχειριστείτε πολλαπλές συνεδρίες με ένα λεξικό user_id -> response_id
  • Η δομημένη είσοδος (λίστα μηνυμάτων) προσφέρει μεγαλύτερο έλεγχο στο ιστορικό
  • Υλοποιήστε επιμονή και λήξη συνεδριών σε περιβάλλον παραγωγής