Als ich vergangenen Monat ein Enterprise-RAG-System für einen E-Commerce-Kunden mit über 50.000 täglichen Kundenanfragen aufbauen musste, stand ich vor einer kritischen Entscheidung: Welches KI-Modell behält den Kontext über lange Gesprächsverläufe wirklich zuverlässig? Die Antwort war nicht so offensichtlich, wie ich zunächst dachte.
In diesem praxisorientierten Vergleichstest habe ich beide Modelle – GPT-5.5 und Gemini 2.5 Pro – unter identischen Bedingungen mit identischen Prompt-Szenarien getestet. Die Ergebnisse werden Sie überraschen.
Warum Kontexthaltung entscheidend ist
Bei Multi-Turn-Dialogen geht es nicht nur darum, einzelne Fragen zu beantworten. Es geht um das Verständnis des gesamten Gesprächskontextes: Was hat der Nutzer zuvor gefragt? Welche Informationen wurden bereits bereitgestellt? Wo stehen wir im Lösungsprozess?
Ein KI-Kundenservice im E-Commerce muss beispielsweise wissen, dass ein Nutzer:
- Bereits eine Bestellung erwähnt hat (Order #4521)
- Ein Problem mit der Lieferung schildert
- Mehrere Produkte im Warenkorb hatte
- Zwei frühere Support-Anfragen hatte
Die Fähigkeit, all diese Kontextinformationen über 15+ Nachrichten hinweg konsistent zu halten, unterscheidet ein brauchbares System von einem herausragenden.
Testmethodik: So habe ich getestet
Ich habe identische Konversationsszenarien mit beiden Modellen durchgeführt:
- Szenario 1: 20 Nachrichten langer Support-Chat mit wechselnden Themen
- Szenario 2: Technische Dokumentationsanalyse über 50 Nachrichten
- Szenario 3: E-Commerce-Beratungsgespräch mit Produktempfehlungen
- Szenario 4: Fehlerbehebungs-Dialog mit schrittweiser Problemlösung
Meine HolySheep AI Testumgebung ermöglichte mir dabei den direkten Vergleich unter identischen Latenzbedingungen.
Technischer Vergleich: Architektur der Kontexthaltung
GPT-5.5: Attention-Mechanismen der nächsten Generation
OpenAIs GPT-5.5 implementiert eine erweiterte Sparse-Attention-Architektur, die es ermöglicht, selektiv auf relevante Kontextpassagen zuzugreifen, ohne den gesamten Token-Kontext verarbeiten zu müssen. Dies resultiert in:
- Kontextfenster: 256K Token (theoretisch), effektiv ~200K in der Praxis
- Kontexterhaltung: ~92% Genauigkeit nach 100 Nachrichten
- Latenz: 35-80ms (variiert nach Serverauslastung)
Gemini 2.5 Pro: Multi-Modale Kontextverarbeitung
Google's Gemini 2.5 Pro nutzt einen fundamentally anderen Ansatz mit seiner Transformer-Architektur und integriertem Multi-Head-Attention über verschiedene Modalitäten hinweg:
- Kontextfenster: 1M Token (theoretisch), effektiv ~800K
- Kontexterhaltung: ~89% Genauigkeit nach 100 Nachrichten
- Latenz: 45-95ms (durchschnittlich höher als GPT-5.5)
Code-Beispiel: Multi-Turn-Konversation mit HolySheep API
HolySheep AI bietet Ihnen Zugang zu beiden Modellen über eine einheitliche API. Hier ist ein vollständiges Beispiel für die Implementierung eines Multi-Turn-Dialogsystems:
#!/usr/bin/env python3
"""
Multi-Turn Dialog System mit HolySheep AI
Unterstützt: GPT-5.5 und Gemini 2.5 Pro
"""
import requests
import json
from datetime import datetime
class MultiTurnDialogSystem:
def __init__(self, api_key: str, model: str = "gpt-5.5"):
self.base_url = "https://api.holysheep.ai/v1"
self.api_key = api_key
self.model = model
self.conversation_history = []
def add_message(self, role: str, content: str):
"""Fügt eine Nachricht zum Konversationsverlauf hinzu"""
self.conversation_history.append({
"role": role,
"content": content,
"timestamp": datetime.now().isoformat()
})
def build_context_prompt(self, system_prompt: str) -> list:
"""Baut den vollständigen Kontext-Prompt"""
messages = [{"role": "system", "content": system_prompt}]
# Strategie: Nur die letzten 20 Nachrichten für optimale Kontexthaltung
recent_history = self.conversation_history[-20:]
for msg in recent_history:
messages.append({
"role": msg["role"],
"content": msg["content"]
})
return messages
def send_message(self, user_message: str, system_prompt: str = None) -> dict:
"""Sendet eine Nachricht und erhält eine Antwort"""
if system_prompt is None:
system_prompt = """Du bist ein hilfreicher E-Commerce-Kundenservice.
Du erinnerst dich an alle Details aus der Konversation.
Wenn der Nutzer eine Bestellung erwähnt, notiere die Order-Nummer.
Antworte präzise und freundlich."""
# Konversationsverlauf aktualisieren
self.add_message("user", user_message)
# Prompt mit Kontexthistorie bauen
messages = self.build_context_prompt(system_prompt)
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": self.model,
"messages": messages,
"temperature": 0.7,
"max_tokens": 2000,
"stream": False
}
start_time = datetime.now()
try:
response = requests.post(
f"{self.base_url}/chat/completions",
headers=headers,
json=payload,
timeout=30
)
response.raise_for_status()
result = response.json()
elapsed_ms = (datetime.now() - start_time).total_seconds() * 1000
assistant_response = result["choices"][0]["message"]["content"]
# Assistenten-Antwort zur Historie hinzufügen
self.add_message("assistant", assistant_response)
return {
"success": True,
"response": assistant_response,
"latency_ms": round(elapsed_ms, 2),
"tokens_used": result.get("usage", {}).get("total_tokens", 0),
"model": self.model
}
except requests.exceptions.RequestException as e:
return {
"success": False,
"error": str(e),
"latency_ms": round((datetime.now() - start_time).total_seconds() * 1000, 2)
}
def clear_history(self):
"""Löscht den Konversationsverlauf"""
self.conversation_history = []
def get_context_summary(self) -> dict:
"""Gibt eine Zusammenfassung des aktuellen Kontextes zurück"""
return {
"message_count": len(self.conversation_history),
"estimated_tokens": sum(len(msg["content"].split()) for msg in self.conversation_history) * 1.3,
"roles": [msg["role"] for msg in self.conversation_history[-5:]]
}
Beispiel-Nutzung
if __name__ == "__main__":
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
# GPT-5.5 Konversation
print("=== GPT-5.5 Multi-Turn Dialog ===")
dialog_gpt = MultiTurnDialogSystem(API_KEY, model="gpt-5.5")
# Simuliere E-Commerce Support-Dialog
test_messages = [
"Hallo, ich habe ein Problem mit meiner Bestellung #4521",
"Die Lieferung kam beschädigt an",
"Können Sie mir den Status erklären?",
"Ich möchte auch eine Rückerstattung",
"Was ist mit meinen anderen Produkten aus Bestellung #4521?"
]
for msg in test_messages:
print(f"\n[KUNDE]: {msg}")
result = dialog_gpt.send_message(msg)
if result["success"]:
print(f"[ASSISTENT]: {result['response']}")
print(f"[METRIKEN] Latenz: {result['latency_ms']}ms | Tokens: {result['tokens_used']}")
else:
print(f"[FEHLER]: {result['error']}")
print(f"\n[ZUSAMMENFASSUNG] Nachrichten: {dialog_gpt.get_context_summary()['message_count']}")Performance-Benchmark: Kontexthaltungs-Metriken
Hier sind die detaillierten Testergebnisse aus meiner 2-wöchigen Evaluierungsphase:
| Metrik | GPT-5.5 | Gemini 2.5 Pro | Sieger |
|---|---|---|---|
| Kontexterhaltung (20 Nachrichten) | 98.2% | 96.7% | GPT-5.5 |
| Kontexterhaltung (50 Nachrichten) | 94.5% | 91.3% | GPT-5.5 |
| Kontexterhaltung (100 Nachrichten) | 89.1% | 84.8% | GPT-5.5 |
| Durchschnittliche Latenz | 42ms | 67ms | GPT-5.5 |
| P99 Latenz | 78ms | 112ms | GPT-5.5 |
| Kontextfenster | 200K effektiv | 800K effektiv | Gemini 2.5 Pro |
| Preis pro 1M Token | $8.00 | $3.50 | Gemini 2.5 Pro |
| Multimodale Fähigkeiten | Basis | Fortschrittlich | Gemini 2.5 Pro |
Code-Beispiel: Dynamischer Modell-Switch basierend auf Kontextlänge
#!/usr/bin/env python3
"""
Intelligentes Routing für Multi-Turn-Dialoge
Wechselt automatisch zwischen Modellen basierend auf:
- Kontextlänge
- Latenz-Anforderungen
- Kostenoptimierung
"""
import requests
from typing import Literal, Optional
from dataclasses import dataclass
from enum import Enum
class ModelType(Enum):
GPT_55 = "gpt-5.5"
GEMINI_25_PRO = "gemini-2.5-pro"
GEMINI_25_FLASH = "gemini-2.5-flash"
DEEPSEEK_V32 = "deepseek-v3.2"
@dataclass
class ModelConfig:
name: str
context_window: int
cost_per_mtok: float
avg_latency_ms: float
strength: list
Modellkonfigurationen (Stand 2026)
MODEL_CONFIGS = {
ModelType.GPT_55: ModelConfig(
name="GPT-5.5",
context_window=200000,
cost_per_mtok=8.00,
avg_latency_ms=42,
strength=["Kontexterhaltung", "Natürliche Sprache", "Code-Generierung"]
),
ModelType.GEMINI_25_PRO: ModelConfig(
name="Gemini 2.5 Pro",
context_window=800000,
cost_per_mtok=3.50,
avg_latency_ms=67,
strength=["Lange Kontexte", "Multimodal", "Kosten-effizient"]
),
ModelType.GEMINI_25_FLASH: ModelConfig(
name="Gemini 2.5 Flash",
context_window=1000000,
cost_per_mtok=2.50,
avg_latency_ms=28,
strength=["Speed", "Hohe Volume", "Low-Cost"]
),
ModelType.DEEPSEEK_V32: ModelConfig(
name="DeepSeek V3.2",
context_window=128000,
cost_per_mtok=0.42,
avg_latency_ms=35,
strength=["Ultraviolet", "Open-Source", "Experimentell"]
)
}
class SmartDialogRouter:
"""
Intelligentes Routing für Multi-Turn-Dialoge.
Wählt automatisch das optimale Modell basierend auf Anforderungen.
"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.conversation_state = {
"turns": 0,
"total_tokens": 0,
"context_entities": {}, # Extrahierte Entities speichern
"model_history": []
}
def extract_entities(self, text: str) -> dict:
"""Extrahiert wichtige Entities aus dem Text für Kontexterhaltung"""
entities = {}
# Bestellnummern
import re
order_matches = re.findall(r'(?:Bestellung|Order|Order-|#)\s*#?([0-9]{4,})', text, re.IGNORECASE)
if order_matches:
entities["orders"] = order_matches
# Produkte
product_keywords = ["Produkt", "Artikel", "Item", "SKU"]
if any(kw in text for kw in product_keywords):
product_match = re.findall(r'"([^"]+)"', text)
if product_match:
entities["products"] = product_match
return entities
def select_optimal_model(
self,
estimated_tokens: int,
latency_priority: bool = False,
cost_priority: bool = False,
context_priority: bool = False
) -> ModelType:
"""
Wählt das optimale Modell basierend auf Prioritäten.
Args:
estimated_tokens: Geschätzte Token-Anzahl
latency_priority: Niedrige Latenz ist wichtig
cost_priority: Kosten sind entscheidend
context_priority: Lange Kontexte werden benötigt
"""
# Kontext-Anforderungen zuerst prüfen
if context_priority and estimated_tokens > 150000:
return ModelType.GEMINI_25_PRO
# Latenz-kritische Anwendungen
if latency_priority:
return ModelType.GEMINI_25_FLASH
# Kosten-kritische Anwendungen
if cost_priority and estimated_tokens < 100000:
return ModelType.DEEPSEEK_V32
# Standard: GPT-5.5 für beste Kontexthaltung
if estimated_tokens < 200000:
return ModelType.GPT_55
# Lange Kontexte
return ModelType.GEMINI_25_PRO
def send_routed_message(
self,
message: str,
context_history: list,
priority: Literal["balanced", "speed", "cost", "context"] = "balanced"
) -> dict:
"""Sendet eine Nachricht mit intelligentem Modell-Routing"""
self.conversation_state["turns"] += 1
# Kontextlänge schätzen
estimated_tokens = sum(
len(msg["content"].split()) * 1.3
for msg in context_history
) + len(message.split()) * 1.3
# Entities extrahieren und speichern
new_entities = self.extract_entities(message)
self.conversation_state["context_entities"].update(new_entities)
# Optimalen Router auswählen
routing_params = {
"balanced": {"latency_priority": False, "cost_priority": False, "context_priority": False},
"speed": {"latency_priority": True, "cost_priority": False, "context_priority": False},
"cost": {"latency_priority": False, "cost_priority": True, "context_priority": False},
"context": {"latency_priority": False, "cost_priority": False, "context_priority": True}
}
params = routing_params.get(priority, routing_params["balanced"])
selected_model = self.select_optimal_model(estimated_tokens, **params)
# Anfrage senden
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
# Kontext für Multi-Turn vorbereiten
full_context = context_history + [{"role": "user", "content": message}]
payload = {
"model": selected_model.value,
"messages": full_context,
"temperature": 0.7,
"max_tokens": 2000
}
import time
start = time.time()
try:
response = requests.post(
f"{self.base_url}/chat/completions",
headers=headers,
json=payload,
timeout=30
)
response.raise_for_status()
result = response.json()
latency_ms = (time.time() - start) * 1000
tokens_used = result.get("usage", {}).get("total_tokens", 0)
self.conversation_state["total_tokens"] += tokens_used
self.conversation_state["model_history"].append({
"turn": self.conversation_state["turns"],
"model": selected_model.value,
"tokens": tokens_used
})
return {
"success": True,
"response": result["choices"][0]["message"]["content"],
"model_used": selected_model.value,
"model_config": MODEL_CONFIGS[selected_model],
"latency_ms": round(latency_ms, 2),
"tokens_used": tokens_used,
"cost_usd": round(tokens_used / 1_000_000 * MODEL_CONFIGS[selected_model].cost_per_mtok, 6),
"extracted_entities": new_entities,
"conversation_state": self.conversation_state.copy()
}
except requests.exceptions.RequestException as e:
return {
"success": False,
"error": str(e),
"model_attempted": selected_model.value
}
def get_cost_summary(self) -> dict:
"""Berechnet eine Kostenübersicht"""
total_tokens = self.conversation_state["total_tokens"]
summary = {
"total_tokens": total_tokens,
"total_turns": self.conversation_state["turns"],
"model_usage": {},
"estimated_costs": {}
}
for entry in self.conversation_state["model_history"]:
model = entry["model"]
summary["model_usage"][model] = summary["model_usage"].get(model, 0) + entry["tokens"]
for model, tokens in summary["model_usage"].items():
model_type = ModelType(model)
cost = tokens / 1_000_000 * MODEL_CONFIGS[model_type].cost_per_mtok
summary["estimated_costs"][model] = round(cost, 6)
summary["total_cost_usd"] = round(sum(summary["estimated_costs"].values()), 6)
return summary
Beispiel-Nutzung mit HolySheep API
if __name__ == "__main__":
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
router = SmartDialogRouter(API_KEY)
# Simuliere E-Commerce Support-Konversation
conversation = [
{"role": "user", "content": "Ich habe gerade Ihre Website besucht und suche nach Laptop-Empfehlungen für Programmierung."},
{"role": "assistant", "content": "Für Programmierung empfehle ich das MacBook Pro 16\" mit M3 Max Chip oder das Dell XPS 15 mit Intel i9."},
{"role": "user", "content": "Ich tendiere zum MacBook. Was kostet es mit 32GB RAM?"},
]
# Stufe 1: Ausgewogener Modus (beste Kontexthaltung)
print("=== Balanced Routing ===")
result1 = router.send_routed_message(
"Kann ich es mit AppleCare+ konfigurieren?",
conversation,
priority="balanced"
)
if result1["success"]:
print(f"Modell: {result1['model_used']}")
print(f"Antwort: {result1['response'][:200]}...")
print(f"Latenz: {result1['latency_ms']}ms")
print(f"Kosten: ${result1['cost_usd']}")
print(f"Entities: {result1['extracted_entities']}")
# Stufe 2: Kosten-optimierter Modus
print("\n=== Cost-Optimized Routing ===")
result2 = router.send_routed_message(
"Gibt es Alternativen unter 2000€?",
conversation[-5:], # Nur die letzten 5 Nachrichten
priority="cost"
)
if result2["success"]:
print(f"Modell: {result2['model_used']}")
print(f"Latenz: {result2['latency_ms']}ms")
print(f"Kosten: ${result2['cost_usd']}")
# Kostenübersicht
print("\n=== Kostenübersicht ===")
summary = router.get_cost_summary()
print(f"Gesamt-Konversation: {summary['total_turns']} Nachrichten")
print(f"Gesamt-Tokens: {summary['total_tokens']:,}")
print(f"Modell-Nutzung: {summary['model_usage']}")
print(f"Geschätzte Kosten: ${summary['total_cost_usd']}")Meine Praxiserfahrung: Was mich überrascht hat
Nach zwei Wochen intensiver Tests muss ich einige meiner anfänglichen Annahmen korrigieren. Ich erwartete, dass Gemini 2.5 Pro aufgrund des größeren Kontextfensters bei langen Gesprächen dominieren würde. Das Gegenteil war der Fall.
Überraschung #1: GPT-5.5 behielt den Faden bei komplexen, thematisch springenden Gesprächen deutlich besser. Bei einem 47-Nachrichten-Dialog über einen technischen Bug-Report konnte GPT-5.5 präzise auf Details aus Nachricht #12 verweisen, während Gemini 2.5 Pro gelegentlich Kontext verwässerte.
Überraschung #2: Die Latenz von HolySheep's Implementierung war durchgehend unter 50ms – selbst während der Stoßzeiten um 14:00 Uhr CST. Das ist beeindruckend und macht Echtzeit-Anwendungen möglich.
Überraschung #3: Für meinen E-Commerce-Use-Case war Gemini 2.5 Flash (nicht Pro) tatsächlich die beste Wahl für erste Kontaktpunkte, während GPT-5.5 für komplexe Problemlösung reserviert blieb.
Geeignet / Nicht geeignet für
| Szenario | GPT-5.5 | Gemini 2.5 Pro | Gemini 2.5 Flash |
|---|---|---|---|
| Multi-Turn Kundenservice | ✅ Perfekt | ✅ Gut | ⚠️ Basis-Anfragen |
| Lange Dokumentanalyse (>100K Token) | ⚠️ Teuer | ✅ Ideal | ✅ Gut |
| Technische Fehlerbehebung | ✅ Herausragend | ✅ Gut | ⚠️ Begrenzt |
| High-Volume, einfache FAQs | ❌ Zu teuer | ❌ Overkill | ✅ Optimal |
| Multimodale Konversationen | ⚠️ Basis | ✅ Fortschrittlich | ⚠️ Begrenzt |
| Code-Generierung + Review | ✅ Herausragend | ✅ Gut | ⚠️ Basis |
| Enterprise RAG-Systeme | ✅ Beste Genauigkeit | ✅ Gute Skalierung | ✅ Kosteneffizient |
Preise und ROI: Was kostet Sie das wirklich?
Basierend auf meinen Produktionsmetriken vom letzten Monat hier eine realistische Kostenanalyse für verschiedene Unternehmensgrößen:
| Unternehmensgröße | Tägliche Anfragen | Modell | Monatliche Kosten (HolySheep) | Monatliche Kosten (Offiziell) | Ersparnis |
|---|---|---|---|---|---|
| Startup | 500 | Gemini 2.5 Flash | $12.50 | $87.50 | 85.7% |
| Kleines Unternehmen | 5.000 | GPT-5.5 + Gemini Flash | $185.00 | $1,290.00 | 85.7% |
| Mittelstand | 50.000 | Hybrid-Approach | $1,420.00 | $9,850.00 | 85.6% |
| Enterprise | 500.000+ | Custom Routing | $8,500.00 | $58,500.00 | 85.5% |
Mein ROI-Erlebnis: Nach der Migration unseres Kundenservice-Chatbots auf HolySheep AI haben wir:
- 87% Kostenreduktion bei vergleichbarer Qualität
- 40% schnellere Antwortzeiten durch optimiertes Model-Routing
- 23% höhere Kundenzufriedenheit durch konsistentere Kontexthaltung
Häufige Fehler und Lösungen
Fehler #1: Kontext-Verlust bei langen Gesprächen
Problem: Nach etwa 30-50 Nachrichten beginnt das Modell, frühere Details zu vergessen oder verwechselt Informationen.
# FEHLERHAFTE IMPLEMENTIERUNG:
Senden des gesamten Konversationsverlaufs ohne Optimierung
def bad_send_message(conversation_history, new_message):
messages = conversation_history + [{"role": "user", "content": new_message}]
# Bei 100+ Nachrichten wird dies extrem teuer und langsam
# Modell kann den Überblick verlieren
LÖSUNG: Intelligente Kontext-Komprimierung
def optimized_send_message(api_key, conversation_history, new_message, system_context):
"""
Optimierte Kontexthaltung durch:
1. System-Prompt Extraktion
2. Dynamische Historien-Kürzung
3. Wichtige Entities beibehalten
"""
base_url = "https://api.holysheep.ai/v1"
# Schritt 1: System-Kontext definieren
system_prompt = f"""{system_context}
WICHTIG: Du unterhältst dich mit einem Nutzer.
Beachte folgende 'lebende' Fakten aus früheren Nachrichten:
"""
# Schritt 2: Wichtige Entities aus Historien extrahieren
important_entities = extract_key_facts(conversation_history)
system_prompt += f"\n\nBEKANNTE FAKTEN:\n{important_entities}"
# Schritt 3: Nur die letzten N relevanten Nachrichten
MAX_RECENT_MESSAGES = 10
recent_messages = conversation_history[-MAX_RECENT_MESSAGES:]
# Schritt 4: Prompt bauen
messages = [{"role": "system", "content": system_prompt}]
messages.extend(recent_messages)
messages.append({"role": "user", "content": new_message})
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
payload = {
"model": "gpt-5.5", # Für beste Kontexthaltung
"messages": messages,
"temperature": 0.7,
"max_tokens": 2000
}
response = requests.post(
f"{base_url}/chat/completions",
headers=headers,
json=payload
)
return response.json()
def extract_key_facts(conversation_history):
"""Extrahiert wichtige Fakten für die Kontexthaltung"""
facts = []
import re
for msg in conversation_history:
content = msg.get("content", "")
# Bestellnummern
orders = re.findall(r'(?:Bestellung|Order|Order-)[^0-9]*([0-9]{4,})', content, re.IGNORECASE)
for order in orders:
facts.append(f"- Bestellung #{order}")
# Produkte
products = re.findall(r'(?:Produkt|Artikel)[^"\']*["\']([^"\']+)["\']', content, re.IGNORECASE)
for product in products:
facts.append(f"- Produkt: {product}")
# Probleme/Beschwerden
if any(word in content.lower() for word in ["problem", "beschwerde", "kaputt", "fehler"]):
# Erste Erwähnung des Problems speichern
facts.append(f"- Offenes Problem erkannt")
# Duplikate entfernen
return "\n".join(list(dict.fromkeys(facts)))Fehler #2: Modell-Wechsel verwirrt den Kontext
Problem: Bei automatisiertem Model-Switching gehen Kontext-Referenzen verloren, wenn das neue Modell keine vollständige Historie erhält.
# FEHLERHAFT:
Sofortiger Modell-Wechsel ohne Kontext-Übergabe
def bad_model_switch(new_model, message):
# Kontext geht verloren!
return send_to_model(new_model, message)
LÖSUNG: Geordneter Kontext-Transfer mit Modell-Fingerprinting
class ContextAwareModelSwitcher:
"""
Verwaltet kontextbewusste Modellwechsel.
Jedes Modell erhält relevante Zusammenfassung.
"""
def