Βελτιστοποίηση Κόστους σε Κλίμακα
Σε αυτήν τη σελίδα
Το Κόστος ως Μηχανικός Περιορισμός
Ένα κακώς βελτιστοποιημένο prompt που κοστίζει 0,002 $ ανά κλήση είναι αμελητέο κατά την ανάπτυξη. Σε ένα εκατομμύριο κλήσεις, κοστίζει 2.000 $—και θα συνεχίσει να σας κοστίζει τόσο κάθε μήνα μέχρι κάποιος να το ξαναγράψει. Αυτή η αλλαγή κλίμακας μετατρέπει το κόστος σε μηχανικό περιορισμό: δεν το λύνετε διαπραγματευόμενοι ένα συμβόλαιο, το λύνετε αλλάζοντας κώδικα.
Η ορατότητα είναι η προϋπόθεση για κάθε βελτιστοποίηση. Ένας μηνιαίος λογαριασμός σας λέει πόσα ξοδέψατε, όχι πού. Γι’ αυτό το μάθημα ξεκινά με την οργανομέτρηση πριν καλύψει τους μοχλούς μείωσης.
Γνωρίζοντας Πού Πάνε τα Χρήματα
Τέσσερα στοιχεία καθορίζουν το κόστος μιας κλήσης και δεν συμπεριφέρονται όλα με τον ίδιο τρόπο. Τα tokens εισόδου, τα οποία συγκεντρώνουν το prompt συστήματος, το ιστορικό συνομιλίας και το μήνυμα του χρήστη, αυξάνονται με τη διάρκεια της συνεδρίας. Τα tokens εξόδου—η παραγόμενη απάντηση—χρεώνονται σημαντικά υψηλότερα από την είσοδο. Τα cached tokens εισόδου λαμβάνουν περίπου 50% έκπτωση επί του τιμολογίου εισόδου, καθιστώντας την παρακολούθησή τους απαραίτητη για την κατανόηση οποιουδήποτε λογαριασμού. Τέλος, το ίδιο το μοντέλο: το GPT-5.6 Luna είναι πολύ φθηνότερο από το GPT-5.6 Sol, και αυτός ο παράγοντας κυριαρχεί έναντι όλων των άλλων.
Η παρακολούθηση σημαίνει μετατροπή κάθε αντικειμένου usage που επιστρέφεται από το API σε χρηματικό ποσό, εφαρμογή του σωστού τιμολογίου και απομόνωση του cached μέρους.
import openai
from dataclasses import dataclass, field
client = openai.OpenAI()
# Rates per million tokens (July 2026) — cached_input is indicative (~50% of input),
# adjust according to the official pricing grid
RATES = {
"gpt-5.6-luna": {"input": 0.20, "output": 1.20, "cached_input": 0.02},
"gpt-5.6-terra": {"input": 2.00, "output": 12.00, "cached_input": 0.20},
"gpt-5.6-sol": {"input": 5.00, "output": 30.00, "cached_input": 0.50},
}
@dataclass
class CostTracker:
"""Tracks costs in real time."""
calls: list[dict] = field(default_factory=list)
def record(self, model: str, usage: dict) -> float:
input_tokens = usage.input_tokens
cached_tokens = getattr(
usage.input_tokens_details, "cached_tokens", 0
)
output_tokens = usage.output_tokens
uncached_input_tokens = input_tokens - cached_tokens
rate = RATES.get(model, RATES["gpt-5.6-terra"])
cost = (
(uncached_input_tokens / 1_000_000) * rate["input"]
+ (cached_tokens / 1_000_000) * rate["cached_input"]
+ (output_tokens / 1_000_000) * rate["output"]
)
self.calls.append({
"model": model,
"input_tokens": input_tokens,
"cached_tokens": cached_tokens,
"output_tokens": output_tokens,
"cost": cost,
})
return cost
@property
def total_cost(self) -> float:
return sum(a["cost"] for a in self.calls)
def report(self) -> str:
if not self.calls:
return "No calls recorded."
return (
f"Calls: {len(self.calls)} | "
f"Total cost: ${self.total_cost:.4f} | "
f"Average cost: ${self.total_cost / len(self.calls):.6f}"
)
tracker = CostTracker()
Ο πίνακας RATES απαιτεί συνεχή προσοχή: γίνεται ξεπερασμένος μόλις αλλάξει ο επίσημος τιμοκατάλογος. Αντιμετωπίστε τον ως δεδομένα διαμόρφωσης που πρέπει να επαληθεύετε, όχι ως σταθερά προγράμματος, και κάντε το μέσο κόστος ανά κλήση μια μετρική που ελέγχετε εβδομαδιαίως.
Τέσσερις Μοχλοί Μείωσης
Ο πρώτος μοχλός, και μακράν ο πιο αποδοτικός, είναι η αποφυγή πληρωμής για ένα μοντέλο υψηλής απόδοσης όταν η εργασία δεν το απαιτεί. Η ρητή δρομολόγηση βάσει πολυπλοκότητας αποτρέπει την προεπιλεγμένη ολίσθηση όπου όλη η κίνηση καταλήγει στο ακριβότερο μοντέλο απλώς και μόνο επειδή εμφανίστηκε στο πρώτο αντιγραμμένο παράδειγμα.
async def economic_router(prompt: str, complexity: str) -> str:
"""Routes to the cheapest capable model."""
if complexity == "simple":
model = "gpt-5.6-luna"
elif complexity == "medium":
model = "gpt-5.6-terra"
else:
model = "gpt-5.6-sol"
response = client.responses.create(model=model, input=prompt)
tracker.record(model, response.usage)
return response.output_text
Ο δεύτερος μοχλός πηγαίνει πιο μακριά όταν η πολυπλοκότητα δεν είναι γνωστή εκ των προτέρων. Αντί να ταξινομείτε το αίτημα, η καταρράκτης δοκιμάζει πρώτα το φθηνότερο μοντέλο και κλιμακώνεται μόνο εάν η απάντηση αποτύχει σε έναν έλεγχο ποιότητας. Ο έλεγχος που χρησιμοποιείται εδώ είναι σκόπιμα rudimentary—ένα ελάχιστο μήκος και η απουσία παραδοχής άγνοιας—και αυτό είναι το σημείο που θα χρειαστεί να βελτιώσετε: μια καταρράκτης που κλιμακώνεται πολύ συχνά γίνεται πιο ακριβή από μια άμεση κλήση στο σωστό μοντέλο.
async def model_cascade(prompt: str) -> str:
"""Tries the cheapest model first."""
models = ["gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol"]
for model in models:
response = client.responses.create(
model=model,
input=prompt,
max_output_tokens=500,
)
tracker.record(model, response.usage)
# Check quality (simple heuristic)
text = response.output_text
if len(text) > 50 and "i don't know" not in text.lower():
return text
return text # Last result even if imperfect
Ο τρίτος μοχλός στοχεύει στα tokens εισόδου, τα οποία αυξάνονται σιωπηλά σε οποιαδήποτε εφαρμογή συνομιλίας: κατά την εικοστή στροφή, πληρώνετε εκ νέου για τις προηγούμενες δεκαεννέα με κάθε μήνυμα. Η συμπίεση του ιστορικού διατηρώντας το πρώτο μήνυμα (που κρατά το πλαίσιο) και το τελευταίο (που κρατά την ερώτηση), και στη συνέχεια γεμίζοντας τον υπόλοιπο προϋπολογισμό με τις πιο πρόσφατες ανταλλαγές, διατηρεί την απαραίτητη συνοχή σε ένα κλάσμα του κόστους.
def compress_history(
messages: list[dict],
max_tokens: int = 4000,
) -> list[dict]:
"""Keeps the most recent messages within budget."""
# Always keep the first (context) and last (question)
if len(messages) <= 2:
return messages
first = messages[0]
last = messages[-1]
middle = messages[1:-1]
# Estimate tokens (approximation: 1 token ≈ 4 characters)
fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
middle_budget = max_tokens - fixed_tokens
# Keep the most recent messages
result = []
tokens_used = 0
for msg in reversed(middle):
msg_tokens = len(msg["content"]) // 4
if tokens_used + msg_tokens > middle_budget:
break
result.insert(0, msg)
tokens_used += msg_tokens
return [first] + result + [last]
Ο τέταρτος μοχλός δεν απαιτεί αλγοριθμική δεξιοτεχνία, μόνο πειθαρχία: το Batch API προσφέρει μείωση 50% και απλώς χρειάζεται να εντοπίσετε τι μπορεί να περιμένει. Αφήστε την ίδια την εργασία να φέρει την επείγουσα φύση της από τη δημιουργία της, αντί να την εξάγετε εκ των υστέρων—αυτός είναι ο μόνος τρόπος για να αποτρέψετε τα πάντα από το να καταλήγουν στην ουρά πραγματικού χρόνου.
def classify_urgency(tasks: list[dict]) -> dict:
"""Separates tasks into real-time vs batch."""
real_time = []
batch = []
for task in tasks:
if task.get("urgency") == "immediate":
real_time.append(task)
else:
batch.append(task)
return {
"real_time": real_time,
"batch": batch,
"estimated_savings": len(batch) * 0.001, # Example
}
Λήψη Προειδοποίησης Πριν τον Λογαριασμό
Όλες αυτές οι βελτιστοποιήσεις μπορούν να ακυρωθούν από μια και μόνο δυστυχής ανάπτυξη: ένας βρόχος επανάληψης χωρίς όριο, ένα τριπλασιασμένο prompt συστήματος, ένα μοντέλο που αλλάζει κατά λάθος. Μια ειδοποίηση κόστους είναι το δίχτυ ασφαλείας που σας προειδοποιεί μέσα σε ώρες και όχι στο τέλος του μήνα. Σημειώστε το ενδιάμεσο όριο στο 80%: μετατρέπει έναν βίαιο συναγερμό σε ένα πρώιμο σήμα, δίνοντάς σας χρόνο να δράσετε πριν υπερβείτε το όριο.
class CostAlert:
"""Triggers alerts when costs exceed a threshold."""
def __init__(self, daily_threshold: float = 50.0):
self.threshold = daily_threshold
self.tracker = CostTracker()
def check(self) -> str | None:
if self.tracker.total_cost > self.threshold:
return (
f"ALERT: daily cost ${self.tracker.total_cost:.2f} "
f"exceeds threshold of ${self.threshold:.2f}"
)
if self.tracker.total_cost > self.threshold * 0.8:
return (
f"WARNING: cost at {self.tracker.total_cost / self.threshold:.0%} "
f"of daily threshold"
)
return None
Βασικά σημεία
- Παρακολουθείτε τα κόστη σας σε πραγματικό χρόνο χρησιμοποιώντας το
response.usage - Δρομολογείτε προς το φθηνότερο μοντέλο ικανό για την εργασία
- Χρησιμοποιείτε το Batch API (-50%) για οτιδήποτε δεν απαιτεί επεξεργασία σε πραγματικό χρόνο
- Μειώνετε τα tokens εισόδου συμπιέζοντας το ιστορικό
- Ρυθμίζετε ειδοποιήσεις κόστους για να αποφύγετε εκπλήξεις