Die Herausforderung: Vom Playground zur Produktion

Der Sprung von ersten ChatGPT-Experimenten zu einem produktiven LLM-System ist größer als viele erwarten. Bei innFactory haben wir zahlreiche LLM-Integrationen für Kunden umgesetzt und dabei bewährte Patterns identifiziert.

1. Prompt Engineering für Produktion

System Prompts richtig strukturieren

Ein produktiver System Prompt sollte enthalten:

[Rolle & Kontext]
Du bist ein Kundenservice-Assistent für [Unternehmen]. 

[Aufgabe]
Beantworte Kundenanfragen basierend auf der Wissensbasis.

[Einschränkungen]
- Antworte nur auf Deutsch
- Erfinde keine Informationen
- Verweise bei Unsicherheit an den Support

[Format]
- Nutze kurze Absätze
- Verwende Aufzählungen für Listen
- Maximal 200 Wörter

Few-Shot Examples

Für konsistente Ausgaben:

{
  "examples": [
    {
      "input": "Wie kann ich mein Passwort ändern?",
      "output": "Sie können Ihr Passwort in den Kontoeinstellungen ändern: 1. Klicken Sie auf 'Profil'..."
    }
  ]
}

2. Robustes Error Handling

LLM-APIs sind nicht immer zuverlässig. Implementieren Sie:

Retry-Logik mit Exponential Backoff

import time
from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=2, max=10)
)
def call_llm(prompt: str) -> str:
    return openai.chat.completions.create(...)

Fallback-Strategien

Primary: GPT-4 Turbo
  ↓ (bei Fehler)
Fallback 1: GPT-3.5 Turbo
  ↓ (bei Fehler)
Fallback 2: Vordefinierte Antwort + Eskalation

Timeout-Management

API-Timeout: 30-60 Sekunden
User-facing Timeout: 10-15 Sekunden
Streaming für lange Antworten nutzen

3. Kostenoptimierung

LLM-Kosten können schnell eskalieren. Unsere Strategien:

Token-Management

# Prompt-Länge begrenzen
def truncate_context(context: str, max_tokens: int = 3000) -> str:
    encoder = tiktoken.encoding_for_model("gpt-4")
    tokens = encoder.encode(context)
    if len(tokens) > max_tokens:
        return encoder.decode(tokens[:max_tokens])
    return context

Caching

Query → Hash → Cache Lookup
          ↓ (Miss)
       LLM Call → Cache Store → Response

Bei innFactory setzen wir Redis oder DynamoDB für semantisches Caching ein - gleiche Fragen werden nur einmal beantwortet.

Modell-Routing

Nicht jede Anfrage braucht GPT-4:

Anfragetyp	Empfohlenes Modell	Kosten
Einfache FAQ	GPT-3.5 Turbo	€€
Komplexe Analyse	GPT-4 Turbo	€€€€
Klassifikation	Fine-tuned GPT-3.5	€

4. Security & Compliance

Prompt Injection Prevention

def sanitize_user_input(text: str) -> str:
    # Bekannte Injection-Patterns entfernen
    patterns = [
        r"ignore.*instructions",
        r"disregard.*above",
        r"system:.*"
    ]
    for pattern in patterns:
        text = re.sub(pattern, "", text, flags=re.IGNORECASE)
    return text

PII-Handling

Für DSGVO-Compliance:

Input-Filterung: PII vor dem API-Call maskieren
Output-Filterung: Unerwünschte Daten in Antworten erkennen
Logging: Keine personenbezogenen Daten in Logs

Audit Trail

{
  "timestamp": "2025-01-15T10:30:00Z",
  "user_id": "user_123",
  "model": "gpt-4-turbo",
  "prompt_hash": "abc123...",
  "tokens_used": 1500,
  "response_hash": "def456..."
}

5. Monitoring & Observability

Wichtige Metriken

Latenz: P50, P95, P99 der Antwortzeiten
Token-Verbrauch: Pro Request und aggregiert
Fehlerrate: Nach Fehlertyp (Rate Limit, Timeout, etc.)
Qualität: User-Feedback, Thumbs up/down

Alerting

alerts:
  - name: LLM Error Rate High
    condition: error_rate > 5%
    window: 5 minutes
    
  - name: Cost Spike
    condition: daily_cost > 1.5 * avg_daily_cost
    
  - name: Latency Degradation
    condition: p95_latency > 10s

6. Architektur-Patterns

Async Processing

Für nicht-interaktive Anwendungen:

User Request → Queue (SQS/RabbitMQ) → Worker → LLM → Result Store
     ↓
  Immediate Response: "Ihre Anfrage wird bearbeitet"

Streaming für UX

async def stream_response(prompt: str):
    stream = await openai.chat.completions.create(
        model="gpt-4-turbo",
        messages=[{"role": "user", "content": prompt}],
        stream=True
    )
    async for chunk in stream:
        yield chunk.choices[0].delta.content

Fazit

Eine erfolgreiche LLM-Integration erfordert mehr als nur API-Calls. Planen Sie von Anfang an:

Robuste Fehlerbehandlung
Kostenmonitoring und -kontrolle
Security-Maßnahmen
Qualitätsmessung

Bei innFactory unterstützen wir Sie bei der gesamten Journey - vom Proof of Concept bis zum skalierbaren Produktivsystem.

Ihr LLM-Projekt steht an? Sprechen Sie mit uns über Ihre Anforderungen.