LLM-Kosten senken: Strategien zur Token-Optimierung

Senken Sie die Kosten für LLMs um 80 % durch intelligente Token-Optimierung

Inhaltsverzeichnis

Die Optimierung von Tokens ist die entscheidende Fähigkeit, die kosteneffiziente LLM-Anwendungen von budgetintensiven Experimenten unterscheidet.

Da API-Kosten linear mit der Token-Nutzung skalieren, können das Verständnis und die Implementierung von Optimierungsstrategien die Ausgaben um 60–80 % senken, während die Qualität erhalten bleibt.

Selbst gehostete Agenten-Schleifen verursachen einen zweiten Kostenblock durch verschwendete Completion-Tokens, wenn das Sampling zu „heiß“ ist; Inferenzparameter für Agenten bei Qwen und Gemma sammelt Standardwerte, die Retries eindämmen, ohne das Reasoning zu behindern.

smart architecture

Verständnis der Token-Ökonomie

Bevor Sie optimieren, müssen Sie verstehen, wie Tokens und Preisgestaltung bei verschiedenen LLM-Anbietern funktionieren.

Token-Grundlagen

Tokens sind die grundlegenden Verarbeitungseinheiten von LLMs – sie entsprechen in etwa 4 Zeichen oder 0,75 Wörtern im Englischen. Der String „Hello, world!“ enthält ungefähr 4 Tokens. Verschiedene Modelle verwenden verschiedene Tokenizer (GPT verwendet tiktoken, Claude nutzt eigene), daher variieren die Token-Anzahlen leicht zwischen Anbietern.

Vergleich der Preismodelle

OpenAI-Preise (Stand 2025):

  • GPT-4 Turbo: $0,01 Input / $0,03 Output pro 1K Tokens
  • GPT-3.5 Turbo: $0,0005 Input / $0,0015 Output pro 1K Tokens
  • GPT-4o: $0,005 Input / $0,015 Output pro 1K Tokens

Anthropic-Preise:

  • Claude 3 Opus: $0,015 Input / $0,075 Output pro 1K Tokens
  • Claude 3 Sonnet: $0,003 Input / $0,015 Output pro 1K Tokens
  • Claude 3 Haiku: $0,00025 Input / $0,00125 Output pro 1K Tokens

Für einen umfassenden Vergleich von Cloud-LLM-Anbietern einschließlich detaillierter Preise, Funktionen und Anwendungsfälle, sehen Sie sich unseren dedizierten Leitfaden an.

Wichtige Erkenntnis: Output-Tokens kosten 2–5-mal so viel wie Input-Tokens. Die Begrenzung der Output-Länge hat einen überproportional großen Einfluss auf die Kosten.

Prompt-Engineering für Effizienz

Effektives Prompt-Engineering reduziert den Token-Verbrauch drastisch, ohne die Qualität zu beeinträchtigen.

1. Redundanzen eliminieren

Schlechtes Beispiel (127 Tokens):

You are a helpful assistant. Please help me with the following task.
I would like you to analyze the following text and provide me with
a summary. Here is the text I would like you to summarize:
[text]
Please provide a concise summary of the main points.

Optimiert (38 Tokens):

Summarize the key points:
[text]

Ersparnis: 70 % weniger Tokens, identische Output-Qualität.

2. Strukturierte Formate verwenden

JSON und strukturierte Outputs reduzieren die Token-Verschwendung durch ausschweifende natürliche Sprache.

Statt:

Please extract the person's name, age, and occupation from this text
and format your response clearly.

Verwenden Sie:

Extract to JSON: {name, age, occupation}
Text: [input]

3. Optimierung von Few-Shot-Learning

Few-Shot-Beispiele sind leistungsstark, aber teuer. Optimieren Sie sie durch:

  • Verwenden Sie die minimal notwendige Anzahl von Beispielen (1–3 reichen meist aus)
  • Halten Sie Beispiele prägnant – entfernen Sie unnötige Wörter
  • Nutzen Sie gemeinsame Präfixe – reduzieren Sie wiederholte Anweisungen
# Optimierter Few-Shot-Prompt
prompt = """Classify sentiment (pos/neg):
Text: "Great product!" -> pos
Text: "Disappointed" -> neg
Text: "{user_input}" ->"""

Für weitere Python-Optimierungsmuster und Syntax-Shortcuts sehen Sie sich unsere Python-Cheatsheet an.

Strategien für Context-Caching

Context-Caching ist die wirksamste Optimierung für Anwendungen mit wiederkehrenden statischen Inhalten.

Wie Context-Caching funktioniert

Anbieter wie OpenAI und Anthropic cachen Prompt-Präfixe, die in mehreren Anfragen auftreten. Gecachte Teile kosten 50–90 % weniger als reguläre Tokens.

Anforderungen:

  • Mindestens cachebare Inhalte: 1024 Tokens (OpenAI) oder 2048 Tokens (Anthropic)
  • Cache-TTL: 5–60 Minuten, abhängig vom Anbieter
  • Der Inhalt muss identisch sein und am Prompt-Anfang erscheinen

Implementierungsbeispiel

from openai import OpenAI

client = OpenAI()

# Systemnachricht wird über Anfragen hinweg gecacht
SYSTEM_PROMPT = """You are a customer service AI for TechCorp.
Company policies:
[Large policy document - 2000 tokens]
"""

# Dies wird automatisch gecacht
response = client.chat.completions.create(
    model="gpt-4-turbo",
    messages=[
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": "How do I return an item?"}
    ]
)

# Nachfolgende Aufrufe innerhalb der Cache-TTL nutzen den gecachten System-Prompt
# Sie zahlen nur für die User-Nachricht + Output

Praktische Auswirkung: Anwendungen mit Wissensdatenbanken oder ausführlichen Anweisungen sehen eine Kostensenkung von 60–80 %.

Strategie zur Modellauswahl

Die Verwendung des richtigen Modells für jede Aufgabe ist entscheidend für die Kostenoptimierung.

Die Modell-Hierarchie

  1. GPT-4 / Claude Opus – Komplexe Reasoning-Aufgaben, kreative Aufgaben, kritische Genauigkeit
  2. GPT-4o / Claude Sonnet – Ausgewogene Leistung/Kosten, Allzweck-Einsatz
  3. GPT-3.5 / Claude Haiku – Einfache Aufgaben, Klassifizierung, Extraktion
  4. Fine-tuned kleinere Modelle – Spezialisierte, repetitive Aufgaben

Routing-Muster

def route_request(task_complexity, user_query):
    """Route to appropriate model based on complexity"""
    
    # Einfache Klassifizierung - Haiku verwenden
    if task_complexity == "simple":
        return call_llm("claude-3-haiku", user_query)
    
    # Moderat - Sonnet verwenden
    elif task_complexity == "moderate":
        return call_llm("claude-3-sonnet", user_query)
    
    # Komplexes Reasoning - Opus verwenden
    else:
        return call_llm("claude-3-opus", user_query)

Fallstudie: Ein Customer-Service-Chatbot, der 80 % der Anfragen an GPT-3.5 und 20 % an GPT-4 weiterleitete, reduzierte die Kosten um 75 % im Vergleich zur ausschließlichen Verwendung von GPT-4.

Batch-Verarbeitung

Für nicht zeitkritische Workloads bietet die Batch-Verarbeitung 50 % Rabatt bei den meisten Anbietern.

OpenAI Batch API

from openai import OpenAI
client = OpenAI()

# Batch-Datei erstellen
batch_requests = [
    {"custom_id": f"request-{i}", 
     "method": "POST",
     "url": "/v1/chat/completions",
     "body": {
         "model": "gpt-3.5-turbo",
         "messages": [{"role": "user", "content": query}]
     }}
    for i, query in enumerate(queries)
]

# Batch einreichen (50 % Rabatt, 24-Stunden-Verarbeitung)
batch = client.batches.create(
    input_file_id=upload_batch_file(batch_requests),
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

Anwendungsfälle:

  • Datenlabeling und Annotation
  • Content-Generierung für Blogs/SEO
  • Berichterstellung
  • Batch-Übersetzungen
  • Synthetische Dataset-Generierung

Techniken zur Output-Kontrolle

Da Output-Tokens 2–5-mal so viel kosten, ist die Kontrolle der Output-Länge entscheidend.

1. Max-Tokens festlegen

response = client.chat.completions.create(
    model="gpt-4",
    messages=messages,
    max_tokens=150  # Harte Grenze verhindert Kostenexplosion
)

2. Stop-Sequenzen verwenden

response = client.chat.completions.create(
    model="gpt-4",
    messages=messages,
    stop=["END", "\n\n\n"]  # Stoppen bei Markern
)

3. Prägnante Formate anfordern

Fügen Sie Anweisungen wie diese hinzu:

  • „Answer in under 50 words“ (Antworte in unter 50 Wörtern)
  • „Provide bullet points only“ (Nutze nur Aufzählungspunkte)
  • „Return JSON only, no explanation“ (Gib nur JSON zurück, keine Erklärung)

Streaming für bessere UX

Während Streaming die Kosten nicht reduziert, verbessert es die wahrgenommene Leistung und ermöglicht eine frühzeitige Beendigung.

stream = client.chat.completions.create(
    model="gpt-4",
    messages=messages,
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        token = chunk.choices[0].delta.content
        print(token, end="")
        
        # Early termination if response goes off-track
        if undesired_pattern(token):
            break

RAG-Optimierung

Retrieval-Augmented Generation (RAG) fügt Kontext hinzu, aber nicht optimiertes RAG verschwendet Tokens.

Effizientes RAG-Muster

def optimized_rag(query, vector_db):
    # 1. Relevante Chunks abrufen
    chunks = vector_db.search(query, top_k=3)  # Nicht zu viele
    
    # 2. Chunks komprimieren - Redundanzen entfernen
    compressed = compress_chunks(chunks)  # Custom compression
    
    # 3. Auf Token-Limit kürzen
    context = truncate_to_tokens(compressed, max_tokens=2000)
    
    # 4. Strukturierter Prompt
    prompt = f"Context:\n{context}\n\nQ: {query}\nA:"
    
    return call_llm(prompt)

Optimierungstechniken:

  • Verwenden Sie semantisches Chunking (nicht feste Größe)
  • Entfernen Sie Markdown-Formatierung aus abgerufenen Chunks
  • Implementieren Sie Re-Ranking, um den relevantesten Content zu erhalten
  • Erwägen Sie Chunk-Zusammenfassungen für große Dokumente

Response-Caching

Cachen Sie identische oder ähnliche Anfragen, um API-Aufrufe vollständig zu vermeiden.

Implementierung mit Redis

import redis
import hashlib
import json

redis_client = redis.Redis()

def cached_llm_call(prompt, model="gpt-4", ttl=3600):
    # Cache-Key aus Prompt + Modell erstellen
    cache_key = hashlib.md5(
        f"{model}:{prompt}".encode()
    ).hexdigest()
    
    # Cache prüfen
    cached = redis_client.get(cache_key)
    if cached:
        return json.loads(cached)
    
    # LLM aufrufen
    response = call_llm(model, prompt)
    
    # Ergebnis cachen
    redis_client.setex(
        cache_key, 
        ttl, 
        json.dumps(response)
    )
    
    return response

Semantisches Caching: Verwenden Sie für ähnliche (nicht identische) Abfragen Vektor-Embeddings, um gecachte Responses zu finden.

Monitoring und Analytik

Verfolgen Sie die Token-Nutzung, um Optimierungspotenziale zu identifizieren.

Wesentliche Metriken

class TokenTracker:
    def __init__(self):
        self.metrics = {
            'total_tokens': 0,
            'input_tokens': 0,
            'output_tokens': 0,
            'cost': 0.0,
            'requests': 0
        }
    
    def track_request(self, response, model):
        usage = response.usage
        self.metrics['input_tokens'] += usage.prompt_tokens
        self.metrics['output_tokens'] += usage.completion_tokens
        self.metrics['total_tokens'] += usage.total_tokens
        self.metrics['cost'] += calculate_cost(usage, model)
        self.metrics['requests'] += 1
    
    def report(self):
        return {
            'avg_tokens_per_request': 
                self.metrics['total_tokens'] / self.metrics['requests'],
            'total_cost': self.metrics['cost'],
            'input_output_ratio': 
                self.metrics['input_tokens'] / self.metrics['output_tokens']
        }

Kostenwarnungen

Richten Sie Warnungen ein, wenn die Nutzung Schwellenwerte überschreitet:

def check_cost_threshold(daily_cost, threshold=100):
    if daily_cost > threshold:
        send_alert(f"Daily cost ${daily_cost} exceeded ${threshold}")

Fortgeschrittene Techniken

1. Prompt-Kompressionsmodelle

Verwenden Sie dedizierte Modelle zur Komprimierung von Prompts:

  • LongLLMLingua
  • AutoCompressors
  • Gelernte Kompressionstokens

Diese können Kompressionsraten von 10x erreichen und dabei 90 %+ der Task-Leistung beibehalten.

2. Spekulatives Decoding

Führen Sie ein kleines Modell parallel zu einem großen Modell aus, um Tokens vorherzusagen und so Aufrufe des großen Modells zu reduzieren. Typischerweise 2–3x Beschleunigung und Kostensenkung bei ähnlicher Qualität.

3. Quantisierung

Für selbst gehostete Modelle reduziert Quantisierung (4-Bit, 8-Bit) Speicher und Rechenleistung:

  • 4-Bit: ~75 % Speicherreduzierung, minimaler Qualitätsverlust
  • 8-Bit: ~50 % Speicherreduzierung, vernachlässigbarer Qualitätsverlust

Wenn Sie LLMs lokal ausführen, bietet Ollama eine exzellente Plattform zum Bereitstellen quantisierter Modelle mit minimaler Konfiguration. Für die Hardwareauswahl und Leistungsbenchmarks zeigt unser Vergleich NVIDIA DGX Spark vs. Mac Studio vs. RTX-4080 die reale Leistung über verschiedene Hardwarekonfigurationen hinweg beim Ausführen großer quantisierter Modelle.

Kostenoptimierungs-Checkliste

  • Profilieren Sie die aktuelle Token-Nutzung und Kosten pro Endpoint
  • Überprüfen Sie Prompts auf Redundanzen – entfernen Sie unnötige Wörter
  • Implementieren Sie Context-Caching für statische Inhalte > 1K Tokens
  • Richten Sie Model-Routing ein (klein für einfache, groß für komplexe Aufgaben)
  • Fügen Sie max_tokens-Grenzen zu allen Anfragen hinzu
  • Implementieren Sie Response-Caching für identische Abfragen
  • Verwenden Sie die Batch-API für nicht dringende Workloads
  • Aktivieren Sie Streaming für eine bessere UX
  • Optimieren Sie RAG: weniger Chunks, besseres Ranking
  • Monitor mit Token-Tracking und Kostenwarnungen
  • Erwägen Sie Fine-Tuning für repetitive Aufgaben
  • Bewerten Sie kleinere Modelle (Haiku, GPT-3.5) für Klassifizierungsaufgaben

Fallstudie aus der Praxis

Szenario: Customer-Support-Chatbot, 100K Anfragen/Monat

Vor der Optimierung:

  • Modell: GPT-4 für alle Anfragen
  • Durchschnittliche Input-Tokens: 800
  • Durchschnittliche Output-Tokens: 300
  • Kosten: 100K × (800 × 0,00003 + 300 × 0,00006) = $4.200/Monat

Nach der Optimierung:

  • Model-Routing: 80 % GPT-3.5, 20 % GPT-4
  • Context-Caching: 70 % der Prompts gecacht
  • Prompt-Kompression: 40 % Reduktion
  • Response-Caching: 15 % Cache-Hit-Rate

Ergebnisse:

  • 85 % der Anfragen vermieden GPT-4
  • 70 % profitieren vom Context-Cache-Rabatt
  • 40 % weniger Input-Tokens
  • Effektive Kosten: $780/Monat
  • Ersparnis: 81 % ($3.420/Monat)

Fazit

Token-Optimierung verwandelt die LLM-Ökonomie von prohibitiv teuer in nachhaltig skalierbar. Durch die Implementierung von Prompt-Kompression, Context-Caching, intelligenter Modellauswahl und Response-Caching erreichen die meisten Anwendungen eine Kostensenkung von 60–80 %, ohne die Qualität zu beeinträchtigen.

Beginnen Sie mit den Quick Wins: Überprüfen Sie Ihre Prompts, aktivieren Sie Context-Caching und leiten Sie einfache Aufgaben an kleinere Modelle weiter. Monitorieren Sie Ihre Token-Nutzung konsequent – was gemessen wird, wird optimiert. Der Unterschied zwischen einer kosteneffizienten LLM-Anwendung und einer teuren liegt nicht in der Technologie – es liegt in der Optimierungsstrategie.

Verwandte Artikel

Abonnieren

Neue Beiträge zu Systemen, Infrastruktur und KI-Engineering.