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

Παραγωγή: Κλιμάκωση και Παρακολούθηση

Μάθημα 18 / 18 Ενημερώθηκε 3 Νοεμβρίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Παραγωγή: Κλιμάκωση και Παρακολούθηση
  2. Αρχιτεκτονική Παραγωγής
  3. Διαχείριση Ταυτόχρονων Συνεδριών
  4. Δομημένη Καταγραφή (Logging)
  5. Μετρικές Prometheus
  6. Διαχείριση Κόστους
  7. Διαχείριση Σφαλμάτων σε Παραγωγή
  8. Βασικά σημεία
  9. Δοκιμάστε τις γνώσεις σας

Ενημερώθηκε στις 2 Νοεμβρίου 2026 — Μοντέλα ήχου. Αρκετά μοντέλα σε αυτό το μάθημα έχουν καταργηθεί: τα tts-1, tts-1-hd και gpt-4o-mini-tts θα σταματήσουν να λειτουργούν στις 6 Ιανουαρίου 2027 (αντικατάσταση: gpt-realtime-2.1-mini, το οποίο ο οδηγός OpenAI TTS αναφέρει ότι δεν υποστηρίζεται από το /v1/audio/speech: η μετάβαση στη σύνθεση ομιλίας πρέπει να γίνει μέσω του Realtime API)· τα gpt-realtime, gpt-4o-realtime και τα παλαιότερα μοντέλα ήχου στις 20 Ιανουαρίου 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5)· τα whisper-1, gpt-4o-transcribe και το /v1/audio/translations στις 26 Φεβρουαρίου 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Για αμφίδρομη φωνητική επικοινωνία (full-duplex), το GPT-Live 1 είναι διαθέσιμο στο API από τις 10 Σεπτεμβρίου 2026.

Ενημερώθηκε στις 3 Νοεμβρίου 2026. Η διαχείριση κόστους χωρούσε προηγουμένως σε μία πρόταση· πλέον αντικατοπτρίζει το μοντέλο χρέωσης που περιγράφει η OpenAI (χρέωση ανά απόκριση, επιστροφή συνομιλίας σε κάθε γύρο, μέτρηση του ήχου σε tokens, αυτόματη caching, ξεχωριστή χρέωση για μεταγραφή) και την περικοπή μέσω του retention_ratio, του οποίου η μορφή επαληθεύτηκε έναντι των τύπων SDK openai έκδοσης 3.42.1. Πηγή: Βελτιστοποίηση κόστους.

Παραγωγή: Κλιμάκωση και Παρακολούθηση

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

Αρχιτεκτονική Παραγωγής

Σε περιβάλλον παραγωγής, ο φωνητικός πράκτορας λειτουργεί πίσω από έναν εξισορροπητή φορτίου και ένα pool εργαζομένων (workers):

1

Εξισορροπητής Φορτίου (nginx / HAProxy)

Κατανέμει τις εισερχόμενες συνδέσεις WebSocket στους εργαζόμενους. Υποστηρίζει sticky sessions για διατήρηση συγγένειας.

2

Εργαζόμενοι (FastAPI + uvicorn)

Κάθε εργαζόμενος διαχειρίζεται πολλαπλές ταυτόχρονες συνεδρίες Realtime χάρη στο asyncio.

3

Βάση Δεδομένων (PostgreSQL)

Αποθηκεύει καταγραφές συνομιλιών, μετρικές και ρυθμίσεις του πράκτορα.

4

Παρακολούθηση (Prometheus + Grafana)

Συλλέγει μετρικές σε πραγματικό χρόνο: λανθάνουσα κατάσταση, αριθμός συνεδριών, σφάλματα, κόστος.

Διαχείριση Ταυτόχρονων Συνεδριών

Κάθε σύνδεση WebSocket διατηρεί μια συνεδρία Realtime API. Ο αριθμός των ταυτόχρονων συνεδριών περιορίζεται από τα όρια ρυθμού (rate limits) της OpenAI και τη χωρητικότητα των εργαζομένων σας:

import asyncio
from dataclasses import dataclass

@dataclass
class SessionManager:
    """Διαχειρίζεται ταυτόχρονες συνεδρίες Realtime API."""
    max_sessions: int = 50
    active_sessions: dict = None
    semaphore: asyncio.Semaphore = None

    def __post_init__(self):
        self.active_sessions = {}
        self.semaphore = asyncio.Semaphore(self.max_sessions)

    async def create_session(self, session_id: str, config: dict):
        """Δημιουργεί μια νέα συνεδρία με έλεγχο ταυτοχρονισμού."""
        async with self.semaphore:
            if session_id in self.active_sessions:
                raise ValueError(f"Session {session_id} already active")

            self.active_sessions[session_id] = {
                "created_at": asyncio.get_event_loop().time(),
                "config": config,
                "status": "active"
            }
            return session_id

    async def close_session(self, session_id: str):
        """Κλείνει σωστά μια συνεδρία."""
        if session_id in self.active_sessions:
            del self.active_sessions[session_id]

    @property
    def active_count(self) -> int:
        return len(self.active_sessions)

    @property
    def available_slots(self) -> int:
        return self.max_sessions - self.active_count

session_manager = SessionManager(max_sessions=50)

Δομημένη Καταγραφή (Logging)

Καταγράφετε κάθε αλληλεπίδραση για αποσφαλμάτωση και συμμόρφωση:

import logging
import json
from datetime import datetime

class ConversationLogger:
    """Δομημένος καταγραφέας για φωνητικές συνομιλίες."""

    def __init__(self, session_id: str):
        self.session_id = session_id
        self.logger = logging.getLogger(f"voice.{session_id}")
        self.events = []

    def log_event(self, event_type: str, data: dict = None):
        entry = {
            "timestamp": datetime.utcnow().isoformat(),
            "session_id": self.session_id,
            "event_type": event_type,
            "data": data or {}
        }
        self.events.append(entry)
        self.logger.info(json.dumps(entry))

    def log_transcription(self, role: str, text: str):
        self.log_event("transcription", {
            "role": role,
            "text": text
        })

    def log_function_call(self, name: str, args: dict, result: dict, duration_ms: float):
        self.log_event("function_call", {
            "name": name,
            "arguments": args,
            "result": result,
            "duration_ms": round(duration_ms)
        })

    def log_error(self, error_type: str, message: str):
        self.log_event("error", {
            "type": error_type,
            "message": message
        })

    async def save_to_db(self, db_pool):
        """Επιμένει το πλήρες αρχείο καταγραφής στη βάση δεδομένων."""
        async with db_pool.acquire() as conn:
            await conn.execute(
                "INSERT INTO conversation_logs (session_id, events, created_at) "
                "VALUES ($1, $2, NOW())",
                self.session_id, json.dumps(self.events)
            )

Μετρικές Prometheus

Εκθέστε μετρικές για παρακολούθηση σε πραγματικό χρόνο:

from prometheus_client import Counter, Histogram, Gauge, start_http_server

# Βασικές μετρικές
sessions_active = Gauge(
    "voice_sessions_active",
    "Number of active voice sessions"
)

session_duration = Histogram(
    "voice_session_duration_seconds",
    "Duration of voice sessions",
    buckets=[30, 60, 120, 300, 600, 1800]
)

response_latency = Histogram(
    "voice_response_latency_ms",
    "Response latency (end of speech → first audio)",
    buckets=[200, 400, 600, 800, 1000, 1500, 2000, 3000]
)

errors_total = Counter(
    "voice_errors_total",
    "Total number of errors",
    ["error_type"]
)

tokens_used = Counter(
    "voice_tokens_total",
    "Tokens consumed",
    ["type"]  # input_audio, output_audio, input_text, output_text
)

# Εκκίνηση του διακομιστή μετρικών
start_http_server(9090)

Διαχείριση Κόστους

Σύμφωνα με τον οδηγό Cost optimization της OpenAI, μια συνεδρία συνομιλίας Realtime χρεώνεται ανά απόκριση, σε tokens εισόδου και εξόδου για κείμενο, ήχο και εικόνες. Τρεις μηχανισμοί καθορίζουν το μεγαλύτερο μέρος του λογαριασμού:

  • Ολόκληρη η συνομιλία επιστρέφεται στο μοντέλο με κάθε απόκριση: οι μεταγενέστεροι γύροι κοστίζουν περισσότερο από τους προηγούμενους.
  • Ο ήχος μετριέται σε tokens: 1 token ανά 100 ms ήχου χρήστη, 1 token ανά 50 ms ήχου βοηθού.
  • Η caching prompt εφαρμόζεται αυτόματα: εφόσον η αρχή της συνομιλίας δεν αλλάζει, χρεώνεται με τον μειωμένο ρυθμό cached token. Η τροποποίηση ή διαγραφή ενός παλαιότερου στοιχείου «σπάει» την cache από εκείνο το σημείο και μετά.

Η μεταγραφή εισόδου, εάν είναι ενεργοποιημένη, χρεώνεται ξεχωριστά με τον ρυθμό του δικού της μοντέλου: το gpt-transcribe χρεώνεται ανά διάρκεια, η οποία διαβάζεται από το συμβάν conversation.item.input_audio_transcription.completed. Η κατανάλωση για κάθε απόκριση εμφανίζεται στο response.done, κάτω από το response.usage (total_tokens, input_tokens, output_tokens, συν την ανάλυση για κείμενο, ήχο, εικόνα και cache).

Για να περιορίσετε το μέγεθος του context—και συνεπώς το κόστος των μεταγενέστερων γύρων—η συνεδρία δέχεται έναν κανόνα περικοπής: πέρα από το όριο, τα παλαιότερα μηνύματα απορρίπτονται. Με το retention_ratio ορισμένο κάτω από 1, ο διακομιστής αφαιρεί ελαφρώς περισσότερα από τα απαραίτητα, κάτι που αραιώνει τις περικοπές και διατηρεί την cache:

await ws.send(json.dumps({
    "type": "session.update",
    "session": {
        "type": "realtime",
        "truncation": {
            "type": "retention_ratio",
            "retention_ratio": 0.8,
            "token_limits": {"post_instructions": 8000},
        },
    },
}))

Η αντιστάθμιση: ένας πράκτορας που διατηρεί λιγότερο context ξεχνάει γρηγορότερα. Συμπληρώστε το αυτό με όρια συνεδρίας στον κώδικά σας:

class CostController:
    """Ελέγχει το κόστος για μια συνεδρία Realtime."""

    def __init__(self, max_duration_s: int = 600, max_tokens: int = 50000):
        self.max_duration_s = max_duration_s
        self.max_tokens = max_tokens
        self.total_tokens = 0
        self.start_time = None

    def start(self):
        self.start_time = asyncio.get_event_loop().time()

    def update_tokens(self, usage: dict):
        self.total_tokens += usage.get("total_tokens", 0)

    @property
    def elapsed_seconds(self) -> float:
        if not self.start_time:
            return 0
        return asyncio.get_event_loop().time() - self.start_time

    @property
    def should_terminate(self) -> bool:
        if self.elapsed_seconds > self.max_duration_s:
            return True
        if self.total_tokens > self.max_tokens:
            return True
        return False

    @property
    def warning_message(self) -> str:
        remaining = self.max_duration_s - self.elapsed_seconds
        if remaining < 60:
            return f"This session will end in {int(remaining)} seconds."
        return ""

Διαχείριση Σφαλμάτων σε Παραγωγή

async def production_event_loop(ws, logger, cost_ctrl):
    """Εύρωστος βρόχος γεγονότων για παραγωγή."""
    cost_ctrl.start()

    try:
        async for raw in ws:
            event = json.loads(raw)
            t = event["type"]

            # Έλεγχος ορίων κόστους
            if cost_ctrl.should_terminate:
                logger.log_event("session_limit_reached")
                await ws.send(json.dumps({
                    "type": "conversation.item.create",
                    "item": {
                        "type": "message",
                        "role": "user",
                        "content": [{"type": "input_text",
                                     "text": "The session is approaching its duration limit."}]
                    }
                }))
                break

            if t == "response.done":
                usage = event["response"].get("usage", {})
                cost_ctrl.update_tokens(usage)
                tokens_used.labels(type="total").inc(usage.get("total_tokens", 0))

            elif t == "error":
                error = event["error"]
                logger.log_error(error["type"], error["message"])
                errors_total.labels(error_type=error["type"]).inc()

                if error["type"] == "rate_limit_error":
                    await asyncio.sleep(1)

    except websockets.exceptions.ConnectionClosed as e:
        logger.log_error("connection_closed", str(e))
    except Exception as e:
        logger.log_error("unexpected", str(e))
    finally:
        session_duration.observe(cost_ctrl.elapsed_seconds)
        sessions_active.dec()

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

  • Η αρχιτεκτονική παραγωγής διαχωρίζει τον εξισορροπητή φορτίου, τους εργαζόμενους asyncio, τη βάση δεδομένων και την παρακολούθηση
  • Ένας SessionManager με semaphore ελέγχει τον αριθμό των ταυτόχρονων συνεδριών
  • Η δομημένη καταγραφή JSON επιτρέπει την αποσφαλμάτωση και τη συμμόρφωση (καταγραφή συνομιλιών)
  • Οι μετρικές Prometheus (TTFA, διάρκεια, tokens, σφάλματα) είναι απαραίτητες για τις καθημερινές λειτουργίες
  • Ο CostController περιορίζει τη διάρκεια της συνεδρίας και τα tokens για την αποφυγή υπέρβασης του προϋπολογισμού

Δοκιμάστε τις γνώσεις σας

Πέντε ερωτήσεις που καλύπτουν ολόκληρη την αλυσίδα φωνής, από το WebSocket έως την ανάπτυξη σε παραγωγή.

1. Γιατί το Realtime API χρησιμοποιεί WebSocket αντί για αιτήματα HTTP;

Απάντηση: Επειδή μια μόνιμη, αμφίδρομη σύνδεση σας επιτρέπει να μεταδίδετε ήχο μικροφώνου και να λαμβάνετε απαντήσεις συνεχώς, χωρίς να πληρώνετε το γενικό κόστος δημιουργίας ενός αιτήματος για κάθε ανταλλαγή. Αυτή είναι η προϋπόθεση για συνομιλία χαμηλής λανθάνουσας κατάστασης.

2. Τι πρέπει να στείλετε αμέσως μετά το `session.created` και γιατί;

Απάντηση: Το session.update, αμέσως: εδώ είναι όπου διαμορφώνετε τη φωνή, τις οδηγίες, τα εργαλεία και τη μορφή ήχου. Μέχρι να σταλεί αυτό το μήνυμα, η συνεδρία εκτελείται με τις προεπιλεγμένες τιμές.

3. Γιατί είναι απαραίτητος ένας διακομιστής μεσολάβησης (proxy) σε παραγωγή;

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

4. Ποιος είναι ο σκοπός της παραμέτρου `prompt` στο API μεταγραφής;

Απάντηση: Να κατευθύνει την αναγνώριση προς το αναμενόμενο λεξιλόγιο: κύρια ονόματα, μάρκες, ορολογία τομέα. Οι όροι που αναφέρετε εκεί μεταγράφονται με πολύ μεγαλύτερη ακρίβεια.

5. Ποιος είναι ο κύριος μοχλός για την αντιληπτή λανθάνουσα κατάσταση σε έναν φωνητικό πράκτορα;

Απάντηση: Η ροή end-to-end: αναπαραγωγή ήχου μόλις φτάσουν τα πρώτα τμήματα αντί να περιμένετε την πλήρη απόκριση, και διαχείριση διακοπών ώστε ο χρήστης να μπορεί να παρέμβει ανά πάσα στιγμή.