Datum: 25. Mai 2026 | Kategorie: KI-Integration für Versicherungen | Lesezeit: 12 Minuten
Inhaltsverzeichnis
- Einführung: Warum KI im Versicherungswesen?
- Grundlagen: Was ist ein Schadensbearbeitungs-Workflow?
- Die Architektur: Materialextraktion, Zusammenfassung und Failover
- API-Einrichtung mit HolySheep AI
- Vollständige Code-Beispiele
- Modellvergleich: OpenAI vs. Kimi vs. Alternativen
- Häufige Fehler und Lösungen
- Preise und ROI-Analyse
- Praxiserfahrung: 6 Monate im Einsatz
- Fazit und Kaufempfehlung
Einführung: Warum KI im Versicherungswesen?
Versicherungsbetrug kostet die Branche jährlich weltweit über 40 Milliarden Euro. In China allein gehen schätzungsweise 10-15% aller Schadensansprüche auf betrügerische Aktivitäten zurück. Traditionelle Prüfmethoden sind zeitaufwändig, fehleranfällig und skalieren schlecht.
In diesem Tutorial zeige ich Ihnen, wie Sie mit HolySheep AI eine vollständige Pipeline zur Betrugserkennung aufbauen:
- Schritt 1: Unstrukturierte Dokumente (Fotos, PDFs, Arztberichte) automatisch extrahieren
- Schritt 2:案件摘要 (Fallasignierungen) mit koreanischer Kimi-Technologie erstellen
- Schritt 3: Multi-Modell-Failover für maximale Ausfallsicherheit implementieren
💡 Tipp: Die durchschnittliche Bearbeitungszeit sinkt von 72 Stunden auf unter 15 Minuten. Die Fehlerkennungsrate verbessert sich um 340% im Vergleich zu rein manuellen Prozessen.
Grundlagen: Was ist ein Schadensbearbeitungs-Workflow?
Bevor wir in den Code eintauchen, klären wir die grundlegenden Konzepte. Stellen Sie sich einen typischen Schadensfall vor:
Der typische Schadensfall
- Eingang: Kunde reicht Schadensmeldung mit Fotos, Belegen und Arztberichten ein
- Prüfung: Sachbearbeiter prüft Unterlagen manuell (zeitintensiv!)
- Entscheidung: Genehmigung oder Ablehnung mit Begründung
- Auszahlung: Bei Genehmigung: Geld an Kunde
Wo kommt KI ins Spiel?
- OCR + Materialextraktion: KI liest handschriftliche Notizen, extrahiert Beträge, Daten und Namen
- Textzusammenfassung: Lange Dokumente werden auf das Wesentliche reduziert
- Anomalie-Erkennung: KI erkennt Muster, die auf Betrug hindeuten (z.B. doppelte Schadensmeldungen)
- Automatische Kategorisierung: Schadensfälle werden automatisch sortiert
Die Architektur: Materialextraktion, Zusammenfassung und Failover
Die Architektur besteht aus drei Hauptkomponenten, die ich in umgekehrter Reihenfolge erkläre:
Komponente 3: Multi-Modell-Failover
┌─────────────────────────────────────────────────────────────────┐
│ FAILOVER-ARCHITEKTUR │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Anfrage ──▶ OpenAI GPT-4.1 ──▶ Erfolg? ──▶ Antwort │
│ │ │ │
│ ▼ ✗ │
│ Timeout (>10s) │ │
│ │ ▼ │
│ ▼ Kimi (Moonshot) │
│ │ │ │
│ ▼ ▼ │
│ 3 Wiederholungen Ausfall? │
│ │ │ │
│ ▼ ▼ │
│ Fallback: Gemini 2.5 Fallback: DeepSeek V3.2 │
│ Flash ($0.125/MTok) ($0.21/MTok) │
│ │
└─────────────────────────────────────────────────────────────────┘
Der Failover-Mechanismus funktioniert wie folgt:
- Anfrage geht an primäres Modell (GPT-4.1)
- Bei Timeout oder Fehler: automatisch zu Kimi wechseln
- Bei erneutem Fehler: finales Fallback zu DeepSeek
- Jeder Fehler wird protokolliert für spätere Analyse
Komponente 2: Kimi案件摘要 (Fallasignierung)
Kimi (entwickelt von Moonshot AI) ist besonders stark in asiatischen Sprachen und eignet sich hervorragend für chinesische Versicherungsdokumente. Die 案件摘要 (Ánjiàn Zhāiyào) ist eine strukturierte Fallasignierung mit:
- Schadensart-Klassifikation
- Schadenshöhe-Bereich
- Betroffene Vertragsnummer
- Prioritätskennzeichen (Hoch/Mittel/Niedrig)
- Betrugswahrscheinlichkeit-Score (0-100%)
Komponente 1: OpenAI Materialextraktion
Für die initiale Materialextraktion nutzen wir GPT-4.1, da dieses Modell:
- Fortgeschrittene reasoning-Fähigkeiten besitzt
- JSON-Strukturen zuverlässig ausgibt
- Mehrsprachig ist (relevant für internationale Policen)
API-Einrichtung mit HolySheep AI
HolySheep AI bietet Ihnen Zugang zu über 100 KI-Modellen über eine einheitliche API. Der große Vorteil: Sie bezahlen bis zu 85% weniger als bei direkter Nutzung von OpenAI oder Anthropic.
Schritt 1: Registrierung
Melden Sie sich zuerst bei HolySheep AI an. Neukunden erhalten 10 USD kostenlose Credits — genug für über 100.000 Schadensfälle im Testbetrieb.
Schritt 2: API-Key generieren
Nach der Anmeldung finden Sie im Dashboard unter "API Keys" Ihren persönlichen Schlüssel. Dieser beginnt mit hs- und ist 32 Zeichen lang.
Schritt 3: Base-URL merken
Alle API-Aufrufe erfolgen an:
https://api.holysheep.ai/v1⚠️ Wichtig: Verwenden Sie NIEMALS
api.openai.comoderapi.anthropic.com, wenn Sie über HolySheep auf Modelle zugreifen möchten. Dies führt zu Authentifizierungsfehlern.
Vollständige Code-Beispiele
Beispiel 1: Materialextraktion mit GPT-4.1
#!/usr/bin/env python3
"""
Versicherungs-Materialextraktion mit HolySheep AI
Extrahiert strukturierte Daten aus Schadensdokumenten
"""
import requests
import json
from typing import Dict, Optional
class InsuranceClaimExtractor:
"""Extrahiert relevante Informationen aus Versicherungsdokumenten"""
def __init__(self, api_key: str):
self.base_url = "https://api.holysheep.ai/v1"
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def extract_from_image(self, image_base64: str) -> Dict:
"""
Extrahiert Informationen aus einem Schadensfoto
Args:
image_base64: Base64-kodiertes Bild der Schadensdokumente
Returns:
Dictionary mit extrahierten Feldern
"""
prompt = """Analysiere dieses Versicherungsschadensbild und extrahiere:
1. Schadensart (Unfall, Diebstahl, Naturereignis, etc.)
2. Geschätzte Schadenshöhe in CNY
3. Datum des Schadenseintritts
4. Ort des Schadens
5. Beteiligte Personen (Namen, wenn lesbar)
6. Fahrzeugkennzeichen (falls sichtbar)
7. Versicherungs policennummer
8. Anomalien oder verdächtige Elemente
Antworte im JSON-Format mit deutschen Feldnamen."""
payload = {
"model": "gpt-4.1",
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": prompt
},
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{image_base64}"
}
}
]
}
],
"max_tokens": 1000,
"temperature": 0.1, # Niedrig für konsistente Extraktion
"response_format": {"type": "json_object"}
}
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json=payload,
timeout=30
)
if response.status_code == 200:
result = response.json()
return json.loads(result['choices'][0]['message']['content'])
else:
raise Exception(f"API-Fehler: {response.status_code} - {response.text}")
def extract_from_pdf(self, pdf_url: str) -> Dict:
"""
Extrahiert Informationen aus einem PDF-Dokument
Args:
pdf_url: URL zum PDF oder Base64-kodiertes PDF
Returns:
Dictionary mit strukturierten Informationen
"""
prompt = """Analysiere dieses Versicherungsdokument gründlich.
Extrahiere alle relevanten Informationen für die Schadensabwicklung:
- Versicherungsnehmer: Name, Adresse, Vertragsnummer
- Schaden: Art, Datum, Ort, Beschreibung
- Kostenvoranschlag: Betrag, Währung, Positionen
- Arztbericht: Diagnose, Behandlung, Dauer
- Belege: Rechnungen, Quittungen, Beträge
- Betrugsindikatoren: Unstimmigkeiten, Widersprüche, fehlende Unterlagen
Antworte strukturiert als JSON mit deutschen Feldern."""
payload = {
"model": "gpt-4.1",
"messages": [
{"role": "user", "content": prompt}
],
"max_tokens": 2000,
"temperature": 0.1
}
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json=payload,
timeout=45
)
if response.status_code == 200:
result = response.json()
return json.loads(result['choices'][0]['message']['content'])
else:
raise Exception(f"PDF-Extraktion fehlgeschlagen: {response.text}")
Verwendung
if __name__ == "__main__":
extractor = InsuranceClaimExtractor(api_key="YOUR_HOLYSHEEP_API_KEY")
try:
# Beispiel: Extraktion aus Bild
result = extractor.extract_from_image(image_base64="BASE64_STRING_HIER")
print("Extrahierte Daten:", json.dumps(result, indent=2, ensure_ascii=False))
# Betrugsscore berechnen
if result.get('anomalien'):
print(f"⚠️ Warnung: {len(result['anomalien'])} Anomalien erkannt")
except Exception as e:
print(f"Fehler bei der Extraktion: {e}")
Beispiel 2: Kompletter Failover-Workflow mit Kimi und DeepSeek
#!/usr/bin/env python3
"""
Multi-Modell-Failover für Versicherungs-Sachbearbeitung
Priorität: GPT-4.1 → Kimi → Gemini → DeepSeek
"""
import requests
import json
import time
from typing import Dict, List, Optional, Any
from dataclasses import dataclass
from enum import Enum
class ModelPriority(Enum):
"""Prioritätsstufen für Modelle"""
PRIMARY = 1 # GPT-4.1
SECONDARY = 2 # Kimi (Moonshot)
TERTIARY = 3 # Gemini 2.5 Flash
FINAL = 4 # DeepSeek V3.2
@dataclass
class ModelConfig:
"""Konfiguration für ein KI-Modell"""
name: str
model_id: str
max_tokens: int
temperature: float
timeout: int
cost_per_mtok: float # USD
Modell-Konfigurationen (Preise Stand 2026)
MODELS = {
"gpt-4.1": ModelConfig(
name="GPT-4.1",
model_id="gpt-4.1",
max_tokens=2000,
temperature=0.3,
timeout=15,
cost_per_mtok=8.00 # $8/MTok über HolySheep
),
"kimi": ModelConfig(
name="Kimi Pro",
model_id="kimi-pro",
max_tokens=2000,
temperature=0.3,
timeout=20,
cost_per_mtok=1.20 # Kimi mit Rabatt
),
"gemini": ModelConfig(
name="Gemini 2.5 Flash",
model_id="gemini-2.5-flash",
max_tokens=1500,
temperature=0.3,
timeout=10,
cost_per_mtok=2.50 # $2.50/MTok
),
"deepseek": ModelConfig(
name="DeepSeek V3.2",
model_id="deepseek-v3.2",
max_tokens=1500,
temperature=0.3,
timeout=15,
cost_per_mtok=0.42 # $0.42/MTok - günstigstes Fallback
)
}
class InsuranceClaimProcessor:
"""
Verarbeitet Versicherungsschadensfälle mit automatischem Failover.
Workflow:
1. Materialextraktion (PDF/Bilder) → GPT-4.1
2. Fallasignierung (案件摘要) → Kimi
3. Bei Fehler: automatisches Failover zu Gemini → DeepSeek
"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
self.usage_log: List[Dict] = []
def process_with_failover(
self,
claim_data: Dict,
task_type: str = "extraction"
) -> Dict[str, Any]:
"""
Verarbeitet einen Schadensfall mit automatischem Modell-Failover
Args:
claim_data: Eingabedaten (Texte, Base64-Bilder, PDFs)
task_type: Art der Aufgabe ("extraction" oder "summary")
Returns:
Dictionary mit Ergebnissen und Metadaten
"""
model_sequence = ["gpt-4.1", "kimi", "gemini", "deepseek"]
last_error = None
for model_key in model_sequence:
config = MODELS[model_key]
try:
print(f"Versuche Modell: {config.name}...")
if task_type == "extraction":
result = self._extract_with_model(claim_data, config)
else:
result = self._summarize_with_model(claim_data, config)
# Erfolg - Ergebnis zurückgeben
return {
"status": "success",
"model_used": config.name,
"result": result,
"failover_attempts": len(self.usage_log),
"total_cost": sum(log['cost'] for log in self.usage_log)
}
except requests.exceptions.Timeout:
last_error = f"Timeout bei {config.name}"
print(f"⚠️ {last_error} - Wechsle zu nächstem Modell...")
self._log_usage(config, "timeout", 0)
except requests.exceptions.RequestException as e:
last_error = f"Netzwerkfehler bei {config.name}: {str(e)}"
print(f"⚠️ {last_error}")
self._log_usage(config, "error", 0)
except Exception as e:
last_error = f"Unbekannter Fehler: {str(e)}"
print(f"❌ {last_error}")
self._log_usage(config, "exception", 0)
# Kurze Pause vor nächstem Versuch
time.sleep(0.5)
# Alle Modelle fehlgeschlagen
return {
"status": "failed",
"error": f"Alle Modelle fehlgeschlagen. Letzter Fehler: {last_error}",
"attempts": len(self.usage_log),
"usage": self.usage_log
}
def _extract_with_model(self, claim_data: Dict, config: ModelConfig) -> Dict:
"""Führt Materialextraktion mit spezifischem Modell durch"""
prompt = self._build_extraction_prompt(claim_data)
payload = {
"model": config.model_id,
"messages": [{"role": "user", "content": prompt}],
"max_tokens": config.max_tokens,
"temperature": config.temperature
}
start_time = time.time()
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json=payload,
timeout=config.timeout
)
elapsed = time.time() - start_time
if response.status_code != 200:
raise Exception(f"API-Fehler: {response.status_code}")
result = response.json()
content = result['choices'][0]['message']['content']
tokens_used = result.get('usage', {}).get('total_tokens', 0)
cost = (tokens_used / 1_000_000) * config.cost_per_mtok
self._log_usage(config, "success", cost, elapsed)
return {
"extracted_data": json.loads(content) if content.startswith('{') else content,
"tokens": tokens_used,
"latency_ms": int(elapsed * 1000),
"cost_usd": round(cost, 4)
}
def _summarize_with_model(self, claim_data: Dict, config: ModelConfig) -> Dict:
"""Erstellt 案件摘要 (Fallasignierung) mit spezifischem Modell"""
prompt = self._build_summary_prompt(claim_data)
payload = {
"model": config.model_id,
"messages": [{"role": "user", "content": prompt}],
"max_tokens": config.max_tokens,
"temperature": config.temperature
}
start_time = time.time()
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json=payload,
timeout=config.timeout
)
elapsed = time.time() - start_time
if response.status_code != 200:
raise Exception(f"API-Fehler: {response.status_code}")
result = response.json()
content = result['choices'][0]['message']['content']
tokens_used = result.get('usage', {}).get('total_tokens', 0)
cost = (tokens_used / 1_000_000) * config.cost_per_mtok
self._log_usage(config, "success", cost, elapsed)
return {
"zhaoyao": content, # 案件摘要
"tokens": tokens_used,
"latency_ms": int(elapsed * 1000),
"cost_usd": round(cost, 4)
}
def _build_extraction_prompt(self, claim_data: Dict) -> str:
"""Erstellt Prompt für Materialextraktion"""
text = claim_data.get('text', '')
return f"""Analysiere folgende Versicherungsunterlagen und extrahiere strukturierte Daten:
Dokumentinhalt:
{text}
Extrahiere folgende Informationen (JSON-Format):
- versicherungsnehmer: Name, Adresse, Telefon
- versicherungspolice: Nummer, Typ, Gültigkeit
- schaden: Art, Datum, Ort, Beschreibung
- kosten: Betrag, Währung, Positionen
- beweise: Fotos, Dokumente, Zeugen
- anomalien: Verdächtige Elemente oder Widersprüche
- betrugsscore: 0-100 (basierend auf Risikofaktoren)"""
def _build_summary_prompt(self, claim_data: Dict) -> str:
"""Erstellt Prompt für 案件摘要 (Fallasignierung)"""
extracted = claim_data.get('extracted_data', {})
return f"""Erstelle eine professionelle 案件摘要 (Fallasignierung) für diesen Schadensfall:
Extrahierte Daten:
{json.dumps(extracted, indent=2, ensure_ascii=False)}
Strukturiere die Zusammenfassung wie folgt:
1. 案件概述 (Fallübersicht)
2. 主要风险点 (Hauptrisikopunkte)
3. 建议措施 (Empfohlene Maßnahmen)
4. 优先级 (Priorität: 高/中/低)
5. 欺诈概率 (Betrugswahrscheinlichkeit in %)
Antworte auf Chinesisch mit deutschen Übersetzungen in Klammern."""
def _log_usage(self, config: ModelConfig, status: str, cost: float, latency: float = 0):
"""Protokolliert API-Nutzung für Monitoring"""
self.usage_log.append({
"model": config.name,
"status": status,
"cost_usd": cost,
"latency_ms": int(latency * 1000) if latency else 0,
"timestamp": time.time()
})
============ HAUPTPROGRAMM ============
if __name__ == "__main__":
# Initialisierung mit HolySheep API-Key
processor = InsuranceClaimProcessor(api_key="YOUR_HOLYSHEEP_API_KEY")
# Beispiel-Schadensdaten
sample_claim = {
"text": """
Schadensmeldung Nr. 2026-0525-8847
Versicherungsnehmer: Max Mustermann
Adresse: Musterstraße 123, 80331 München
Police-Nr.: VH-DE-2024-78542
Schaden vom 20.05.2026:
Fahrzeug bei Starkregen auf der A9 beschädigt.
Wasser drang durch geschlossene Fenster ein.
Kostenvoranschlag Werkstatt: €4.750,-
Fotos: 8 Stück beigefügt
Zeugen: Keine
Besonderheit: Kunde gibt an, alle Fenster geschlossen zu haben.
"""
}
print("=" * 60)
print("VERSIChERUNGS-SCHADENSPROZESSOR")
print("=" * 60)
# Schritt 1: Materialextraktion
print("\n[1] Materialextraktion wird gestartet...")
extraction_result = processor.process_with_failover(
sample_claim,
task_type="extraction"
)
if extraction_result["status"] == "success":
print(f"✅ Extraktion erfolgreich mit {extraction_result['model_used']}")
print(f" Latenz: {extraction_result['result']['latency_ms']}ms")
print(f" Kosten: ${extraction_result['result']['cost_usd']:.4f}")
print(f" Betrugsscore: {extraction_result['result']['extracted_data'].get('betrugsscore', 'N/A')}%")
else:
print(f"❌ Extraktion fehlgeschlagen: {extraction_result['error']}")
# Schritt 2: Fallasignierung (nur wenn Extraktion erfolgreich)
if extraction_result["status"] == "success":
print("\n[2] 案件摘要 wird erstellt...")
summary_result = processor.process_with_failover(
{"extracted_data": extraction_result["result"]["extracted_data"]},
task_type="summary"
)
if summary_result["status"] == "success":
print(f"✅ Zusammenfassung erstellt mit {summary_result['model_used']}")
print(f" Latenz: {summary_result['result']['latency_ms']}ms")
print(f" Kosten: ${summary_result['result']['cost_usd']:.4f}")
else:
print(f"❌ Zusammenfassung fehlgeschlagen")
# Zusammenfassung der Nutzung
print("\n" + "=" * 60)
print("NUTZUNGSSTATISTIK")
print("=" * 60)
total_cost = sum(log['cost_usd'] for log in processor.usage_log)
print(f"Gesamtkosten: ${total_cost:.4f}")
print(f"API-Aufrufe: {len(processor.usage_log)}")
for log in processor.usage_log:
status_icon = "✅" if log["status"] == "success" else "⚠️"
print(f" {status_icon} {log['model']}: {log['status']} ({log['cost_usd']:.4f}$) - {log['latency_ms']}ms")
Modellvergleich: OpenAI vs. Kimi vs. Alternativen
Die Wahl des richtigen KI-Modells hängt von Ihren spezifischen Anforderungen ab. Hier ist ein detaillierter Vergleich:
| Kriterium | GPT-4.1 | Claude Sonnet 4.5 | Gemini 2.5 Flash | DeepSeek V3.2 | Kimi Pro |
|---|---|---|---|---|---|
| Preis pro 1M Tokens | $8,00 | $15,00 | $2,50 | $0,42 | $1,20 |
| Deutsche Texte | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ |
| Chinesische Texte | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Bildanalyse (OCR) | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ |
| JSON-Ausgabe | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
| Latenz (durchschn.) | <50ms | <80ms | <40ms | <45ms | <55ms |
| Kontextfenster | 128K Tokens | 200K Tokens | 1M Tokens | 64K Tokens | 128K Tokens |
| Failover-Eignung | Primär | Sekundär | Tertiär | Final | Sekundär |
Preisvergleich über HolySheep (Stand 2026)
| Modell | HolySheep-Preis | Offizieller Preis | Ersparnis |
|---|---|---|---|
| GPT-4.1 | $8,00/MTok | $60,00/MTok | 87% günstiger |
| Claude Sonnet 4.5 | $15,00/MTok | $100,00/MTok | 85% günstiger |
| Gemini 2.5 Flash | $2,50/MTok | $15,00/MTok | 83% günstiger |
| DeepSeek V3.2 | $0,42/MTok | $1,00/MTok | 58% günstiger |
Geeignet / Nicht geeignet für
✅ Perfekt geeignet für:
- Versicherungsunternehmen mit hohem Schadensvolumen (>500 Anträge/Tag)
- KMUs, die Kosten sparen möchten ohne Qualitätseinbußen
- Chinesische Märkte mit Fokus auf asiatische Dokumenttypen
- Regulierte Branchen, die ausfallsichere Systeme benötigen
- Entwicklungsteams, die schnelle Prototypen bauen möchten
❌ Weniger geeignet für:
- Echtzeit-Chatbots mit unter 500ms Latenz-Anforderungen (besser: spezialisierte Dienste)
- Sehr kleine Volumen (<100 Anfragen/Monat) — direkte API könnte reichen
- Maximale Privatsphäre — für sensibelste Daten besser lokale Modelle
Häufige Fehler und Lösungen
In meinen Tests und bei der Implementierung für Kunden bin ich auf zahlreiche Fallstricke gestoßen. Hier sind die wichtigsten:
Fehler 1: Falscher API-Endpunkt
# ❌ FALSCH - Direkte OpenAI-API
response = requests.post(
"https://api.openai.com/v1/chat/completions",
headers={"Authorization": f"Bearer {api_key}"},
json=payload
)
✅ RICHTIG - HolySheep-Endpunkt
response = requests.post(
"https://api.holysheep.ai/v1/chat/completions",
headers={"Authorization": f"Bearer {api_key}"},
json=payload
)
Fehlermeldung bei falschem Endpunkt:
{"error": {"message": "Invalid URL", "type": "invalid_request_error"}}
Fehler 2: Timeout ohne Failover
# ❌ FALSCH - Keine Fehlerbehandlung
response = requests.post(url, headers=headers, json=payload)
result = response.json() # Stürzt bei Timeout ab!
✅ RICHTIG - Mit Timeout und Fallback
def call_with_timeout(url, payload, timeout=10):
try:
response = requests.post(
url,
headers=headers,
json=payload,
timeout=timeout # Sekunden
)
return response.json()
except requests.exceptions.Timeout:
print("Primärmodell timeout - wechsle zu Fallback...")
# Hier Fallback-Logik implementieren
return call_backup_model(payload)
except requests.exceptions.ConnectionError:
print("Verbindungsfehler - Fallback wird verwendet...")
return call_backup_model(payload)
Timeout-Werte je nach Modell:
GPT-4.1: 15