Portfolio/blog-posts/04-ai-cost-optimization.md

# Cost Optimization für AI-Agenten: Von $100 auf $10 pro 1000 Anfragen

**Meta-Description:** Reduzieren Sie Ihre AI-API-Kosten um bis zu 90%. Praktische Strategien für Prompt Caching, Model Routing, Batch Processing und intelligentes Token-Management.

**Keywords:** AI Cost Optimization, Prompt Caching, Token Optimization, LLM Kosten, API Kosten reduzieren, Claude Caching, OpenAI Batch API

---

## Einführung

AI-Inference-Kosten machen mittlerweile **55% der Cloud-Ausgaben** für KI-Infrastruktur aus – insgesamt $37,5 Milliarden Anfang 2026. Erstmals übertreffen sie damit die Trainingskosten.

Die gute Nachricht: LLM-Inference-Preise fallen jährlich um den Faktor **50x** im Median. Die noch bessere Nachricht: Mit den richtigen Optimierungsstrategien können Sie Ihre Kosten zusätzlich um **90%** senken.

In diesem Artikel zeige ich Ihnen die bewährtesten Techniken aus meinen Produktionsprojekten.

---

## Die Kosten-Hierarchie verstehen

### Aktuelle API-Preise (Stand 2026)

| Provider | Modell | Input/1M Tokens | Output/1M Tokens |
|----------|--------|-----------------|------------------|
| **Anthropic** | Claude Haiku 4.5 | $1.00 | $5.00 |
| **Anthropic** | Claude Sonnet 4.5 | $3.00 | $15.00 |
| **Anthropic** | Claude Opus 4.5 | $5.00 | $25.00 |
| **OpenAI** | GPT-4o | $2.50 | $10.00 |
| **OpenAI** | o1 | $15.00 | $60.00 |
| **DeepSeek** | R1 | $0.55 | $2.19 |
| **DeepSeek** | V3 | $0.27 | $1.10 |

### Wo das Geld wirklich verloren geht

```
┌──────────────────────────────────────────────┐
│         Typische Kostenverteilung            │
│                                              │
│  [████████████████████          ] 60%        │
│  Redundante System Prompts                   │
│                                              │
│  [████████████                  ] 25%        │
│  Unnötig große Modelle                       │
│                                              │
│  [████                          ] 10%        │
│  Unoptimierte Outputs                        │
│                                              │
│  [██                            ] 5%         │
│  Tatsächlich notwendige Tokens               │
└──────────────────────────────────────────────┘
```

---

## Strategie 1: Prompt Caching (90% Ersparnis)

### Wie es funktioniert

Prompt Caching speichert häufig verwendete Prompt-Präfixe (System Prompts, Instruktionen, Beispiele) und lädt sie bei nachfolgenden Requests aus dem Cache statt sie neu zu verarbeiten.

**Ersparnisse:**
- **Anthropic:** 90% günstiger für gecachte Tokens
- **OpenAI:** 50% günstiger für gecachte Tokens

### Implementierung bei Anthropic (Claude)

```typescript
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

// Statischer Content am Anfang = wird gecacht
const systemPrompt = `Du bist ein Experte für Produktbewertung.

## Deine Aufgaben:
1. Analysiere Produkt-Listings
2. Bewerte das Reselling-Potential
3. Identifiziere Risikofaktoren

## Bewertungskriterien:
- Marktwert: Aktueller Durchschnittspreis
- Zustand: Neu, Gebraucht, Defekt
- Nachfrage: Hoch, Mittel, Niedrig
- Risiko: Fälschungsgefahr, Garantie, etc.

## Output-Format:
{
  "marktwert": number,
  "potential": 1-10,
  "risiken": string[],
  "empfehlung": "kaufen" | "verhandeln" | "skip"
}
`;

// Mit Cache-Control Header
async function analyzeProduct(productDescription: string) {
  const response = await client.messages.create({
    model: "claude-3-haiku-20240307",
    max_tokens: 500,
    system: [
      {
        type: "text",
        text: systemPrompt,
        cache_control: { type: "ephemeral" } // Aktiviert Caching
      }
    ],
    messages: [
      {
        role: "user",
        content: productDescription // Variabel - nicht gecacht
      }
    ]
  });

  return response;
}
```

### Best Practices für Caching

```typescript
// ✅ Gut: Statischer Content am Anfang
const prompt = `
[SYSTEM INSTRUCTIONS - 2000 Tokens - GECACHT]
[FEW-SHOT EXAMPLES - 1000 Tokens - GECACHT]
[USER QUERY - 100 Tokens - NICHT GECACHT]
`;

// ❌ Schlecht: Variabler Content am Anfang
const prompt = `
[USER QUERY - 100 Tokens]
[SYSTEM INSTRUCTIONS - 2000 Tokens]
[EXAMPLES - 1000 Tokens]
`;
```

### Cache-Retention verstehen

| Policy | Retention | Use Case |
|--------|-----------|----------|
| **In-Memory** | 5-10 Min (max 1h) | Standard-Requests |
| **Extended** | Bis zu 24h | Batch-Processing |

**Kosten-Rechnung:**
```
Ohne Caching: 50.000 Docs × 3.000 Tokens × $3/1M = $450/Monat
Mit Caching:  50.000 Docs × 3.000 Tokens × $0.30/1M = $45/Monat

Ersparnis: $405/Monat (90%)
```

---

## Strategie 2: Intelligentes Model Routing (60% Ersparnis)

### Das Konzept

Nicht jede Anfrage braucht das stärkste Modell. Routen Sie einfache Tasks zu günstigen Modellen und komplexe zu leistungsfähigen.

```typescript
interface RouteDecision {
  model: "haiku" | "sonnet" | "opus";
  reason: string;
}

function routeRequest(task: Task): RouteDecision {
  // Klassifikation
  if (task.type === "classification" || task.type === "extraction") {
    return { model: "haiku", reason: "Einfache, strukturierte Aufgabe" };
  }

  if (task.type === "summarization" || task.type === "analysis") {
    return { model: "sonnet", reason: "Moderate Komplexität" };
  }

  if (task.type === "reasoning" || task.type === "creative") {
    return { model: "opus", reason: "Komplexes Reasoning erforderlich" };
  }

  // Fallback auf Sonnet (bestes Preis-Leistungs-Verhältnis)
  return { model: "sonnet", reason: "Default" };
}
```

### Praktisches Routing-System

```typescript
class ModelRouter {
  private taskClassifier: TaskClassifier;

  async route(input: string, context: Context): Promise<string> {
    // 1. Schnelle Klassifikation mit Haiku
    const classification = await this.classifyTask(input);

    // 2. Route basierend auf Komplexität
    const model = this.selectModel(classification);

    // 3. Ausführen
    return await this.execute(input, model, context);
  }

  private selectModel(classification: Classification): Model {
    const complexityScore = classification.complexity; // 0-1

    if (complexityScore < 0.3) {
      return "claude-3-haiku"; // $1 input
    } else if (complexityScore < 0.7) {
      return "claude-3-sonnet"; // $3 input
    } else {
      return "claude-3-opus"; // $5 input
    }
  }

  // Klassifikation ist selbst günstig (Haiku)
  private async classifyTask(input: string): Promise<Classification> {
    const response = await haiku.classify(input);
    return response;
  }
}
```

### Routing-Regeln aus der Praxis

| Task | Empfohlenes Modell | Grund |
|------|-------------------|-------|
| Spam-Klassifikation | Haiku | Binäre Entscheidung |
| Sentiment-Analyse | Haiku | Einfache Extraktion |
| E-Mail-Zusammenfassung | Sonnet | Moderate Komplexität |
| Code-Review | Sonnet | Gutes Reasoning |
| Komplexe Recherche | Opus | Multi-Step-Reasoning |
| Kreatives Schreiben | Opus/Sonnet | Je nach Qualitätsanspruch |

---

## Strategie 3: Batch Processing (50% Ersparnis)

### OpenAI Batch API

OpenAI bietet **50% Rabatt** für Batch-Requests mit höherer Latenz-Toleranz:

```typescript
import OpenAI from "openai";

const openai = new OpenAI();

// Batch-File erstellen
const batchInput = products.map((product, index) => ({
  custom_id: `product-${index}`,
  method: "POST",
  url: "/v1/chat/completions",
  body: {
    model: "gpt-4o",
    messages: [
      { role: "system", content: systemPrompt },
      { role: "user", content: product.description }
    ],
    max_tokens: 500
  }
}));

// Als JSONL-File speichern und hochladen
const file = await openai.files.create({
  file: fs.createReadStream("batch_input.jsonl"),
  purpose: "batch"
});

// Batch starten
const batch = await openai.batches.create({
  input_file_id: file.id,
  endpoint: "/v1/chat/completions",
  completion_window: "24h" // Für 50% Rabatt
});

// Später: Ergebnisse abrufen
const results = await openai.batches.retrieve(batch.id);
```

### Wann Batch Processing nutzen?

✅ **Geeignet für:**
- Nächtliche Report-Generierung
- Bulk-Datenverarbeitung
- Content-Migration
- Historische Datenanalyse

❌ **Nicht geeignet für:**
- Real-Time Chat
- Benutzer-facing Features
- Zeitkritische Entscheidungen

---

## Strategie 4: Prompt Engineering für Token-Effizienz

### Konkrete Techniken

#### 1. Präzise Instruktionen

```typescript
// ❌ Schlecht: Vage und lang (150 Tokens)
const badPrompt = `
Ich möchte, dass du dir das Produkt anschaust und mir sagst,
was du darüber denkst. Bitte gib mir eine ausführliche Analyse
mit allen Details, die du finden kannst. Es wäre toll, wenn du
auch den Preis bewerten könntest und mir sagst, ob ich es
kaufen sollte oder nicht.
`;

// ✅ Gut: Präzise und kurz (50 Tokens)
const goodPrompt = `
Analysiere das Produkt:
- Marktwert (€)
- Zustand (1-10)
- Kaufempfehlung (ja/nein)

Output: JSON
`;
```

**Ersparnis: 67% weniger Input-Tokens**

#### 2. Strukturierte Outputs erzwingen

```typescript
// JSON-Mode aktivieren (weniger verbose)
const response = await openai.chat.completions.create({
  model: "gpt-4o",
  response_format: { type: "json_object" },
  messages: [
    {
      role: "system",
      content: "Antworte nur mit validem JSON im Schema: {preis: number, empfehlung: boolean}"
    },
    { role: "user", content: productDescription }
  ]
});

// Output: {"preis": 450, "empfehlung": true}
// Statt: "Nach meiner Analyse empfehle ich... Der Preis liegt bei..."
```

#### 3. Few-Shot-Beispiele optimieren

```typescript
// ❌ Schlecht: Vollständige Beispiele
const examples = `
Beispiel 1:
Input: iPhone 14 Pro, 256GB, wie neu, 600€
Output: Das iPhone 14 Pro ist ein Premium-Gerät von Apple...
[200 Tokens Output]

Beispiel 2:
...
`;

// ✅ Gut: Minimale Beispiele
const examples = `
In: iPhone 14 Pro 256GB wie neu 600€
Out: {"wert":650,"potential":7,"kaufen":true}

In: PS5 defekt 150€
Out: {"wert":100,"potential":3,"kaufen":false}
`;
```

---

## Strategie 5: RAG für Context-Reduktion (70% Ersparnis)

### Das Problem

Lange Kontexte = viele Tokens = hohe Kosten.

```typescript
// ❌ Schlecht: Gesamten Dokumentenkorpus übergeben
const response = await llm.generate({
  system: "Du bist ein Experte.",
  context: entireDatabase, // 100.000 Tokens!
  question: userQuery
});
```

### Die Lösung: Retrieval-Augmented Generation

```typescript
import { VectorStore } from "@/lib/vectors";

class RAGPipeline {
  private vectorStore: VectorStore;

  async answer(query: string): Promise<string> {
    // 1. Relevante Chunks abrufen (nur ~2000 Tokens)
    const relevantChunks = await this.vectorStore.search(query, {
      limit: 5,
      minScore: 0.7
    });

    // 2. Kompakten Context erstellen
    const context = relevantChunks
      .map(chunk => chunk.content)
      .join("\n\n");

    // 3. Mit reduziertem Context generieren
    const response = await llm.generate({
      system: "Beantworte basierend auf dem Kontext.",
      context, // Nur 2000 statt 100.000 Tokens
      question: query
    });

    return response;
  }
}
```

**Kostenvergleich:**
```
Ohne RAG: 100.000 Tokens × $3/1M = $0.30 pro Anfrage
Mit RAG:    2.000 Tokens × $3/1M = $0.006 pro Anfrage

Ersparnis: 98% pro Anfrage
```

---

## Strategie 6: Response Streaming & Early Termination

### Kosten sparen durch frühes Abbrechen

```typescript
async function streamWithEarlyStop(prompt: string): Promise<string> {
  const stream = await anthropic.messages.create({
    model: "claude-3-sonnet",
    max_tokens: 1000,
    stream: true,
    messages: [{ role: "user", content: prompt }]
  });

  let fullResponse = "";
  let jsonComplete = false;

  for await (const event of stream) {
    if (event.type === "content_block_delta") {
      fullResponse += event.delta.text;

      // Prüfe ob JSON vollständig
      if (isValidJson(fullResponse)) {
        jsonComplete = true;
        break; // Früh abbrechen = Tokens sparen
      }
    }
  }

  return fullResponse;
}
```

---

## Gesamtübersicht: Kombinierte Ersparnis

| Strategie | Ersparnis | Aufwand |
|-----------|-----------|---------|
| Prompt Caching | 90% | Niedrig |
| Model Routing | 60% | Mittel |
| Batch Processing | 50% | Niedrig |
| Prompt Optimization | 30-50% | Mittel |
| RAG | 70-98% | Hoch |
| Early Termination | 10-30% | Niedrig |

### Realistische Gesamt-Ersparnis

```
Ausgangskosten:           $1000/Monat

Nach Prompt Caching:      $100/Monat  (-90%)
Nach Model Routing:       $40/Monat   (-60%)
Nach Prompt Optimization: $25/Monat   (-37%)

Gesamtersparnis: 97.5%
```

---

## Monitoring: Kosten im Blick behalten

```typescript
class CostTracker {
  private costs: Map<string, number> = new Map();

  trackRequest(
    model: string,
    inputTokens: number,
    outputTokens: number
  ) {
    const pricing = this.getPricing(model);
    const cost =
      (inputTokens * pricing.input) / 1_000_000 +
      (outputTokens * pricing.output) / 1_000_000;

    const current = this.costs.get(model) || 0;
    this.costs.set(model, current + cost);

    // Alert bei Überschreitung
    if (this.getDailyCost() > DAILY_BUDGET) {
      this.alertOps("Budget exceeded!");
    }

    return cost;
  }

  getDailyCost(): number {
    return Array.from(this.costs.values()).reduce((a, b) => a + b, 0);
  }
}
```

---

## Fazit

AI-Kosten sind kein unvermeidbares Übel. Mit den richtigen Strategien können Sie:

1. **Prompt Caching** für repetitive Workflows aktivieren
2. **Model Routing** für Task-basierte Modellauswahl implementieren
3. **Batch Processing** für nicht-zeitkritische Aufgaben nutzen
4. **Prompt Engineering** für Token-Effizienz optimieren
5. **RAG** für kontextintensive Anwendungen einsetzen

Der Schlüssel liegt in der **Kombination** dieser Strategien. Starten Sie mit Prompt Caching (schnellster ROI) und fügen Sie schrittweise weitere Optimierungen hinzu.

---

## Bildprompts für diesen Artikel

**Bild 1 – Hero Image:**
"Descending bar chart made of golden coins transforming into efficient AI circuits, business infographic style, clean white background"

**Bild 2 – Caching Visualization:**
"Piggy bank with neural network patterns, surrounded by floating dollar signs and code snippets, modern 3D illustration"

**Bild 3 – Dashboard:**
"Dashboard showing cost metrics with green downward trend arrows, professional business analytics visualization"

---

## Quellen

- [Anthropic: Prompt Caching Guide](https://www.aifreeapi.com/en/posts/claude-api-prompt-caching-guide)
- [OpenAI: Prompt Caching](https://platform.openai.com/docs/guides/prompt-caching)
- [Finout: OpenAI Pricing 2026](https://www.finout.io/blog/openai-pricing-in-2026)
- [Index.dev: 7 Best Platforms to Cut AI Costs](https://www.index.dev/blog/cut-ai-costs-platforms)
- [ngrok: Prompt Caching Deep Dive](https://ngrok.com/blog/prompt-caching/)