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

Caching ερωτημάτων: Επαναχρησιμοποίηση υπολογισμών

Μάθημα 3 / 20 Ενημερώθηκε 28 Ιουλίου 2026 Προχωρημένος
Σε αυτήν τη σελίδα
  1. Τι είναι το caching ερωτημάτων;
  2. Πώς λειτουργεί
  3. Δομή για μεγιστοποίηση της μνήμης cache
  4. Βασικά σημεία

Τι είναι το caching ερωτημάτων;

Όταν στέλνετε επανειλημμένα το ίδιο πρόθεμα ερωτήματος—μια μακρά οδηγία συστήματος, λεπτομερείς εντολές ή ένα έγγραφο αναφοράς—η OpenAI μπορεί να αποθηκεύσει αυτόματα αυτό το πρόθεμα στη μνήμη cache. Οι επόμενες κλήσεις που μοιράζονται αυτό το πρόθεμα επωφελούνται από μειωμένο χρόνο μέχρι το πρώτο token (TTFT) και χαμηλότερο κόστος για τα tokens εισόδου. Με άλλα λόγια, η εργασία επεξεργασίας του σταθερού πλαισίου δεν επαναλαμβάνεται για κάθε αίτημα.

Το caching ερωτημάτων είναι αυτόματο από το 2025: δεν χρειάζεται να ενεργοποιήσετε τίποτα. Η OpenAI εντοπίζει πανομοιότυπα προθέματα και τα αποθηκεύει στη μνήμη cache. Επομένως, το πλεονέκτημά σας δεν έγκειται στην ενεργοποίηση ή απενεργοποίησή του, αλλά στη διαμόρφωση των ερωτημάτων σας ώστε ο μηχανισμός να μπορεί να εφαρμοστεί. Πρόκειται για θέμα δομής και όχι διαμόρφωσης, και εδώ είναι που οι περισσότερες ομάδες χάνουν χρήματα.

Πώς λειτουργεί

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

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

import openai

client = openai.OpenAI()

# ✅ Καλή δομή: σταθερά στοιχεία πρώτα
SYSTEM_PROMPT = """Είστε νομικός βοηθός ειδικευμένος στο γαλλικό
δίκαιο συμβάσεων. Αναλύετε συμβατικές ρήτρες σύμφωνα με τον
Αστικό Κώδικα και τη recent νομολογία. Πάντα απαντάτε
δομώντας την ανάλυσή σας: 1) Ταυτοποίηση ρήτρας,
2) Νομική ανάλυση, 3) Πιθανοί κίνδυνοι, 4) Συστάσεις.

Εδώ είναι η σύμβαση αναφοράς προς ανάλυση:
[Εισαγάγετε εδώ ένα έγγραφο 2.000+ tokens που δεν αλλάζει μεταξύ κλήσεων]
"""

def analyze_clause(clause: str) -> str:
    """Κάθε κλήση επαναχρησιμοποιεί τη μνήμη cache της οδηγίας συστήματος."""
    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=SYSTEM_PROMPT,  # Σταθερό πρόθεμα = αποθηκευμένο στη μνήμη cache
        input=f"Αναλύστε αυτή τη ρήτρα: {clause}",  # Μεταβλητό μέρος
    )
    return response.output_text

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

Επαλήθευση της μνήμης cache

Μια βελτιστοποίηση που δεν μετράτε είναι μια βελτιστοποίηση που απλώς νομίζετε ότι έχετε. Το API επιστρέφει πληροφορίες σχετικά με τη χρήση της μνήμης cache στην απόκριση:

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions=SYSTEM_PROMPT,
    input="Αναλύστε τη ρήτρα μη ανταγωνισμού.",
)

# Έλεγχος χρήσης μνήμης cache
usage = response.usage
print(f"Tokens εισόδου: {usage.input_tokens}")
print(f"Tokens εισόδου (στη μνήμη cache): {usage.input_tokens_details.cached_tokens}")
print(f"Tokens εξόδου: {usage.output_tokens}")

# Αν cached_tokens > 0: χρησιμοποιήθηκε η μνήμη cache
cache_ratio = usage.input_tokens_details.cached_tokens / usage.input_tokens
print(f"Λόγος μνήμης cache: {cache_ratio:.1%}")

Καταγράψτε αυτόν τον λόγο στην παραγωγή αντί να τον ελέγξετε μία φορά κατά την ανάπτυξη. Μια ξαφνική πτώση στον ρυθμό της μνήμης cache είναι το πιο αξιόπιστο σύμπτωμα μιας ακούσιας αλλαγής στη δομή του ερωτήματος και θα το δείτε πριν σας το πει ο μηνιαίος λογαριασμός.

Δομή για μεγιστοποίηση της μνήμης cache

Η πρώτη προσέγγιση είναι να εμπλουτίσετε σκόπιμα την οδηγία συστήματος. Αυτό φαίνεται αντιδιαισθητικό όταν προσπαθείτε να μειώσετε τα tokens, αλλά ευθυγραμμίζεται με τον κανόνα του ορίου: μια οδηγία συστήματος 900 tokens δεν θα αποθηκευτεί ποτέ στη μνήμη cache, ενώ η ίδια οδηγία εμπλουτισμένη με παραδείγματα few-shot και ένα έγγραφο αναφοράς ξεπερνά το όριο και μεταβαίνει στον μειωμένο συντελεστή για το αποθηκευμένο τμήμα.

# Εμπλουτίστε την οδηγία συστήματος για μεγιστοποίηση της μνήμης cache
ENRICHED_PROMPT = """
[Λεπτομερείς οδηγίες - 500+ tokens]
[Παραδείγματα Few-shot - 500+ tokens]
[Έγγραφο αναφοράς - 1.000+ tokens]
---
Σύνολο > 1.024 tokens = επιλέξιμο για cache
"""

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

def conversation_with_cache(history: list[dict], new_message: str):
    """Το αυξανόμενο ιστορικό μεγιστοποιεί αυτόματα τη μνήμη cache."""
    history.append({"role": "user", "content": new_message})

    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=SYSTEM_PROMPT,
        input=history,
    )

    history.append({
        "role": "assistant",
        "content": response.output_text,
    })
    return response.output_text

Τέλος, δεδομένου ότι η διάρκεια ζωής της μνήμης cache μετριέται σε λεπτά, η ομαδοποίηση αιτημάτων που μοιράζονται ένα πρόθεμα γίνεται απόφαση προγραμματισμού. Η επεξεργασία σαράντα ρητρών από μια σύμβαση διαδοχικά διατηρεί τη μνήμη cache ενεργή («hot»)· η κατανομή τους καθ’ όλη τη διάρκεια της ημέρας με παρεμβολή άλλων αρχείων την αφήνει να λήξει μεταξύ των κλήσεων.

import asyncio

async def batch_with_cache(clauses: list[str]) -> list[str]:
    """Στέλνει αιτήματα γρήγορα για να αξιοποιήσει τη μνήμη cache."""
    results = []
    for clause in clauses:
        result = analyze_clause(clause)
        results.append(result)
    return results

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

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

  • Το caching ερωτημάτων είναι αυτόματο με την OpenAI—τοποθετήστε τα σταθερά στοιχεία στην αρχή του ερωτήματος
  • Ελάχιστο όριο: 1.024 πανομοιότυπα tokens στο πρόθεμα
  • Κέρδος: ~50% στα αποθηκευμένα tokens εισόδου + μειωμένο TTFT
  • Ελέγξτε το usage.input_tokens_details.cached_tokens για να επιβεβαιώσετε το caching