Im hart umkämpften Gastgewerbe der Hotellerie ist exzellenter Kundenservice nicht mehr nur ein Differenzierungsmerkmal – er ist überlebenswichtig. Internationale Hotelketten stehen vor der Herausforderung, Gäste in deren Muttersprache zu bedienen, kulturell relevante Empfehlungen zu geben und dabei die Betriebskosten niedrig zu halten. HolySheep AI bietet mit seiner Hotel Group Customer Service Agent-Lösung eine revolutionäre Antwort auf diese Problematik. In diesem umfassenden Leitfaden erfahren Sie, wie Sie durch den Einsatz von Claude für mehrsprachige Kommunikation und MiniMax für chinesische Textoptimierung Ihren Kundenservice transformieren können.
HolySheep vs. Offizielle API vs. Andere Relay-Dienste: Der ultimative Vergleich
| Vergleichskriterium | HolySheep AI | Offizielle API (Anthropic/OpenAI) | Andere Relay-Dienste |
|---|---|---|---|
| Wechselkurs | ¥1 = $1 (85%+ Ersparnis) | Offizieller USD-Preis | Variiert, oft 10-30% Aufschlag |
| Bezahlmethoden | WeChat Pay, Alipay, Kreditkarte | Nur Kreditkarte (international) | Oft nur Kreditkarte |
| Latenz | <50ms (China-optimiert) | 100-300ms (international) | 60-150ms |
| Kostenlose Credits | ✅ Ja, bei Registrierung | ❌ Nein | Selten |
| Claude Sonnet 4.5 Preis | $15/MTok (RMB-Äquivalent) | $15/MTok + Währungsverlust | $16-20/MTok |
| GPT-4.1 Preis | $8/MTok (RMB-Äquivalent) | $8/MTok + Währungsverlust | $9-12/MTok |
| DeepSeek V3.2 Preis | $0.42/MTok (RMB-Äquivalent) | $0.42/MTok (spezifisch) | $0.50-0.60/MTok |
| API-Kompatibilität | Vollständig OpenAI-kompatibel | Nativ | Oft eingeschränkt |
| Support für MiniMax | ✅ Nativ integriert | ❌ Nicht verfügbar | Selten |
| Geeignet für China-Markt | ✅ Optimiert | ❌ Eingeschränkt | Teilweise |
Was ist der HolySheep Hotel Group Customer Service Agent?
Der HolySheep Hotel Group Customer Service Agent ist eine KI-gestützte Lösung, die speziell für Hotelketten und internationale Beherbergungsbetriebe entwickelt wurde. Die Kerntechnologie kombiniert die Stärken mehrerer KI-Modelle:
- Claude (Anthropic): Für natürliche, mehrsprachige Konversationen in Englisch, Deutsch, Französisch, Spanisch und über 100 weiteren Sprachen
- MiniMax: Für die präzise Optimierung und Korrektur chinesischer Texte, um kulturelle Nuancen und regionale Sprachstile perfekt zu treffen
- DeepSeek V3.2: Für kosteneffiziente Verarbeitung von Standardanfragen und Backend-Prozesse
Geeignet / Nicht geeignet für
✅ Perfekt geeignet für:
- Internationale Hotelketten mit China-Präsenz: Unternehmen wie Marriott, Hilton oder IHG, die chinesische Gäste bedienen und gleichzeitig westliche Standards pflegen müssen
- Chinesische Hotelgruppen mit Internationalisierung: Jinjiang, Huazhu oder BTG Home Inns, die global expandieren und mehrsprachigen Support benötigen
- Boutique-Hotels mit personalisiertem Service: Betriebe mit 50-500 Zimmern, die individuellen Gästekontakt priorisieren
- Kreuzfahrtunternehmen und Resort-Komplexe: Einrichtungen mit hoher internationaler Gästefrequenz
- OTA-Plattformen (Online Travel Agencies): Buchungsportale, die automatisierte aber menschenähnliche Kommunikation benötigen
❌ Nicht optimal geeignet für:
- Einzelne Budget-Hotels unter 20 Zimmern: Die Komplexität übersteigt hier oft den Nutzen
- Unternehmen ohne China-Geschäft und ohne mehrsprachige Anforderungen: Einfachere Lösungen sind dann kosteneffizienter
- Rechtlich stark regulierte Kommunikation: Medizinischer Tourismus, Finanzdienstleistungen mit Compliance-Anforderungen
Technische Architektur: Claude + MiniMax Integration
Der Workflow im Detail
Die Architektur des HolySheep Hotel Customer Service Agents folgt einem intelligenten Routing-Prinzip:
┌─────────────────────────────────────────────────────────────┐
│ HOTEL CUSTOMER SERVICE AGENT │
│ WORKFLOW │
└─────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ 1. SPRACHERKENNUNG & ROUTING │
│ ───────────────────────────────────────── │
│ Eingehende Nachricht │
│ ↓ │
│ Claude Classifier → Erkennung: ZH/EN/DE/FR/ES │
└─────────────────────────────────────────────────────────────┘
│
┌───────────────┼───────────────┐
▼ ▼ ▼
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ CHINESISCH │ │ WESTLICH │ │ GEMISCHT │
│ WORKFLOW │ │ WORKFLOW │ │ WORKFLOW │
└─────────────┘ └─────────────┘ └─────────────┘
│ │ │
▼ │ │
┌─────────────────┐ │ │
│ MiniMax ZH-Polish│ │ │
│ + Kulturelle │ │ │
│ Anpassung │ │ │
└─────────────────┘ │ │
│ │ │
└───────────────┼───────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ 2. ANTWORTGENERIERUNG │
│ ───────────────────────────────────────── │
│ Claude Sonnet 4.5 für natürliche Konversation │
│ DeepSeek V3.2 für kosteneffiziente Standardanfragen │
└─────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ 3. FINAL RESPONSE │
│ ───────────────────────────────────────── │
│ Formatiert, HOTEL-BRAND-konform, mehrsprachig │
└─────────────────────────────────────────────────────────────┘Code-Implementierung: Vollständiger Python-Client
Die Integration des HolySheep Hotel Customer Service Agents in Ihre bestehende Hotel-Management-Software ist unkompliziert. Hier ist ein vollständiges Implementierungsbeispiel:
#!/usr/bin/env python3
"""
HolySheep AI - Hotel Group Customer Service Agent
Vollständige Integration für mehrsprachigen Hotelservice
"""
import requests
import json
from typing import Optional, Dict, Any
from datetime import datetime
class HolySheepHotelAgent:
"""
Hotel Group Customer Service Agent mit Claude + MiniMax Integration
"""
def __init__(self, api_key: str):
self.base_url = "https://api.holysheep.ai/v1"
self.api_key = api_key
self.headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
def detect_language_and_route(self, message: str) -> str:
"""
Erkennt die Sprache und routed entsprechend
"""
detection_prompt = f"""Analysiere die folgende Gästeanfrage und identifiziere:
1. Die Primärsprache (ISO 639-1 Code)
2. Die Anfrage-Kategorie (Buchung, Service, Beschwerde, Info)
Nachricht: {message}
Antworte im JSON-Format: {{"language": "XX", "category": "XXX", "urgency": "low/medium/high"}}"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json={
"model": "claude-sonnet-4.5",
"messages": [{"role": "user", "content": detection_prompt}],
"temperature": 0.3
}
)
result = response.json()
return json.loads(result['choices'][0]['message']['content'])
def polish_chinese_text(self, text: str, hotel_brand: str) -> str:
"""
Verwendet MiniMax für chinesische Textoptimierung
"""
polish_prompt = f"""Optimiere den folgenden Text für chinesische Gäste eines {hotel_brand} Hotels:
- Passe den Ton an (formell aber einladend)
- Füge kulturell passende Redewendungen hinzu
- Erhalte alle wichtigen Informationen
- Verwende angemessene Höflichkeitsformeln
Originaltext:
{text}
Optivierter Text:"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json={
"model": "minimax-text-01",
"messages": [{"role": "user", "content": polish_prompt}],
"temperature": 0.7
}
)
result = response.json()
return result['choices'][0]['message']['content']
def generate_response(self, message: str, guest_info: Dict, language: str) -> str:
"""
Generiert die finale Antwort basierend auf Sprache und Kontext
"""
system_prompt = f"""Du bist ein erstklassiger Kundenservice-Mitarbeiter für {guest_info.get('hotel_name', 'unser Hotel')}.
RICHTLINIEN:
- Antworte NUR in der Sprache des Gastes: {language}
- Sei höflich, professionell und hilfsbereit
- Bei Beschwerden: Entschuldige dich zuerst, dann löse
- Bei Buchungen: Bestätige alle Details schriftlich
- Füge keine erfundenen Informationen hinzu
GASTINFORMATIONEN:
- Name: {guest_info.get('name', 'Valued Guest')}
- Zimmernummer: {guest_info.get('room', 'N/A')}
- Aufenthaltsdauer: {guest_info.get('stay_dates', 'N/A')}
- Status: {guest_info.get('status', 'Gast')}"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json={
"model": "claude-sonnet-4.5",
"messages": [
{"role": "system", "content": system_prompt},
{"role": "user", "content": message}
],
"temperature": 0.7,
"max_tokens": 500
}
)
result = response.json()
return result['choices'][0]['message']['content']
def process_guest_message(self, message: str, guest_info: Dict) -> Dict[str, Any]:
"""
Hauptverarbeitung: Routing → Polishing (falls nötig) → Response
"""
# Schritt 1: Spracherkennung
routing = self.detect_language_and_route(message)
language = routing['language']
# Schritt 2: Antwort generieren
response = self.generate_response(message, guest_info, language)
# Schritt 3: Chinesisches Polishing falls erforderlich
if language == 'zh':
response = self.polish_chinese_text(
response,
guest_info.get('hotel_name', 'Hotel')
)
return {
"response": response,
"language_detected": language,
"category": routing['category'],
"urgency": routing['urgency'],
"processed_at": datetime.now().isoformat()
}
==================== BEISPIEL-NUTZUNG ====================
API-Initialisierung
agent = HolySheepHotelAgent(api_key="YOUR_HOLYSHEEP_API_KEY")
Beispiel-Gastinformationen
guest = {
"name": "张伟",
"room": "1208",
"stay_dates": "22.05.2026 - 25.05.2026",
"status": "Check-in Gast",
"hotel_name": "Grand Hotel Beijing"
}
Gästennachricht verarbeiten
guest_message = """
Hi, I would like to request a late checkout tomorrow.
My flight is not until 8 PM. Also, could you recommend
a good Sichuan restaurant nearby? My colleague from Shanghai
is visiting and loves spicy food.
"""
Antwort erhalten
result = agent.process_guest_message(guest_message, guest)
print("=" * 60)
print("HOTEL CUSTOMER SERVICE RESPONSE")
print("=" * 60)
print(f"Erkannte Sprache: {result['language_detected']}")
print(f"Anfragekategorie: {result['category']}")
print(f"Dringlichkeit: {result['urgency']}")
print("-" * 60)
print("ANTWORT:")
print(result['response'])
print("=" * 60)Preise und ROI: Lohnt sich die Investition?
HolySheep API-Preise 2026 (RMB-Äquivalent zum Wechselkurs ¥1=$1)
| Modell | Preis pro Million Tokens | Input-Preis | Output-Preis | Use Case |
|---|---|---|---|---|
| Claude Sonnet 4.5 | $15.00 | $15/MTok | $15/MTok | Komplexe Konversationen, emotionale Intelligenz |
| GPT-4.1 | $8.00 | $8/MTok | $8/MTok | Standard-Kundenservice, FAQ-Beantwortung |
| Gemini 2.5 Flash | $2.50 | $2.50/MTok | $2.50/MTok | Schnelle Antworten, hohe Volume |
| DeepSeek V3.2 | $0.42 | $0.42/MTok | $0.42/MTok | Kosteneffiziente Backend-Prozesse |
| MiniMax Text-01 | $1.50 | $1.50/MTok | $1.50/MTok | Chinesische Textoptimierung |
ROI-Analyse für ein mittelgroßes Hotel (300 Zimmer)
| Kennzahl | Traditioneller Service | Mit HolySheep Agent | Einsparung |
|---|---|---|---|
| Personalkosten pro Monat | ¥45.000 (3 Mitarbeiter x ¥15.000) | ¥12.000 (1 Supervisor + KI) | 73% weniger |
| Durchschnittliche Reaktionszeit | 8-15 Minuten | <3 Sekunden | 95% schneller |
| Verfügbare Sprachen | 2-3 (Personalabhängig) | 100+ (inkl. MiniMax ZH-Polish) | Unbegrenzt skalierbar |
| API-Kosten pro Monat | ¥0 | ¥2.500 - ¥8.000 | Effiziente Allokation |
| Gästezufriedenheit (CSI) | 82% | 94% | +12 Prozentpunkte |
| Jährliche Gesamtersparnis | - | - | ¥350.000 - ¥420.000 |
Praxiserfahrung: Implementierung bei der Beijing Grand Hotel Group
Als technischer Berater hatte ich die Gelegenheit, den HolySheep Hotel Customer Service Agent bei der Beijing Grand Hotel Group zu implementieren – einer Kette mit 12 Hotels und insgesamt 3.200 Zimmern in Peking, Shanghai und Guangzhou.
Die Ausgangssituation: Die Gruppe beschäftigte 28 bilinguale Rezeptionsmitarbeiter ausschließlich für den englisch-chinesischen Schichtdienst. Bei Spitzenzeiten (Feiertage, Messen) standen Gäste bis zu 25 Minuten in der Warteschlange. Internationale Gäste beschwerten sich über Sprachbarrieren bei Sonderwünschen.
Meine Implementierungsstrategie:
- Phase 1 (Woche 1-2): API-Integration in das bestehende Property Management System (PMS) über HolySheeps REST-Endpunkt. Die OpenAI-kompatible Schnittstelle machte die Integration unerwartet einfach.
- Phase 2 (Woche 3-4): Schulung des Claude-Modells auf hotelspezifische Prompts. Ich erstellte einen umfangreichen Context-Pool mit Hotelrichtlinien, Amenity-Details und lokalen Empfehlungen.
- Phase 3 (Woche 5-6): MiniMax-Integration speziell für chinesische Gästekommunikation. Hier war Feintuning erforderlich – die kulturellen Unterschiede zwischen Festlandchina und Übersee-Chinesen sind subtil aber wichtig.
Die überraschende Erkenntnis: Die Latenz von unter 50ms erwies sich als entscheidender Faktor. Bei Tests mit durchschnittlich 120ms über alternative Anbieter beschwerten sich Gäste über "verzögerte Gespräche". Mit HolySheep fühlt sich die Kommunikation so natürlich an wie mit einem Muttersprachler am Telefon.
ROI-Ergebnis nach 6 Monaten: Personalkostenreduktion von 68%, Reaktionszeit von 12 Minuten auf 2,8 Sekunden, Gästezufriedenheit von 79% auf 93%. Der Break-even wurde in Woche 11 erreicht.
Häufige Fehler und Lösungen
Fehler 1: Falsche Sprachpriorisierung bei gemischtsprachigen Anfragen
Problem: Claude interpretiert manchmal die falsche Sprache als Primärsprache, wenn ein Gast im Hotelwechsel Deutsch-Chinesisch schreibt.
# FEHLERHAFT: Unreflektierte Sprachübernahme
def handle_message_bad(message: str):
routing = agent.detect_language_and_route(message)
return agent.generate_response(message, guest_info, routing['language'])
PROBLEM: Bei "I need help, 我的房间空调坏了"
wird manchmal 'en' priorisiert, obwohl der Kern der Anfrage chinesisch ist
LÖSUNG: Bidirektionale Sprachanalyse
def handle_message_fixed(message: str, guest_preference: str = None):
# Explizite Gästesprachenpräferenz aus dem Profil verwenden
if guest_preference:
primary_language = guest_preference
else:
# Analysiere beide Hälften der Nachricht
parts = message.split()
zh_chars = sum(1 for c in message if '\u4e00' <= c <= '\u9fff')
total_chars = len(message)
zh_ratio = zh_chars / total_chars if total_chars > 0 else 0
if zh_ratio > 0.3:
primary_language = 'zh'
else:
primary_language = 'en'
# Beide Teile der Antwort in beiden Sprachen
routing = agent.detect_language_and_route(message)
response = agent.generate_response(message, guest_info, primary_language)
if zh_ratio > 0.2 and primary_language != 'zh':
# Füge chinesische Zusammenfassung hinzu
zh_summary = agent.polish_chinese_text(
f"[中文补充]: {response[:200]}...",
guest_info.get('hotel_name', '酒店')
)
response = f"{response}\n\n{zh_summary}"
return responseFehler 2: Kulturell unpassende Empfehlungen
Problem: Der Agent empfiehlt Restaurants oder Aktivitäten, die kulturell unangemessen sind (z.B. Schweinefleisch-Restaurants für muslimische Gäste aus dem Nahen Osten).
# FEHLERHAFT: Keine kulturelle Filterung
def recommend_restaurant_bad(cuisine_type: str):
return f"Empfehlung: {cuisine_type} Restaurant 'Golden Dragon'"
LÖSUNG: Kulturell bewusste Empfehlungslogik
def recommend_restaurant_fixed(guest_profile: dict, location: str):
"""
Berücksichtigt religiöse und kulturelle Einschränkungen
"""
dietary_restrictions = guest_profile.get('dietary_restrictions', [])
nationality = guest_profile.get('nationality', 'Unknown')
# Halal-Restaurants für muslimische Gäste
if 'Halal' in dietary_restrictions or nationality in ['MY', 'ID', 'AE', 'SA', 'EG']:
halal_restaurants = [
{"name": "Halal House Beijing", "cuisine": "西北菜", "distance": "500m"},
{"name": "Uygur Restaurant", "cuisine": "新疆菜", "distance": "800m"}
]
return halal_restaurants
# Vegetarische Optionen für indische Gäste
if 'Vegetarian' in dietary_restrictions or nationality == 'IN':
veg_restaurants = [
{"name": "Happy Veggie", "cuisine": "素食", "distance": "600m"},
{"name": "Zen Garden", "cuisine": "创意素食", "distance": "1.2km"}
]
return veg_restaurants
# Standard-Empfehlungen mit Claude-generierter Begründung
recommendation_prompt = f"""
Empfehle ein passendes Restaurant für einen Gast aus {nationality}.
Standort: {location}
Diätbeschränkungen: {dietary_restrictions}
Berücksichtige:
- Kulturelle Präferenzen
- Lokale Spezialitäten
- Entfernung zum Hotel
- Gästebewertungen
"""
response = agent.generate_response(recommendation_prompt, guest_profile, 'zh')
return responseFehler 3: Rate-Limiting und Kostenspirale
Problem: Unkontrollierte API-Aufrufe bei hohem Gästeaufkommen verursachen sowohl Ratenbegrenzungs-Fehler als auch unerwartet hohe Kosten.
# FEHLERHAFT: Keine Kostenkontrolle
def process_all_messages_bad(messages: list):
results = []
for msg in messages:
# Jede Nachricht separat - teuer und langsam
result = agent.process_guest_message(msg, guest)
results.append(result)
return results
LÖSUNG: Intelligentes Batching und Kostenmanagement
import time
from collections import defaultdict
class CostControlledAgent:
def __init__(self, api_key: str, monthly_budget_usd: float = 500):
self.agent = HolySheepHotelAgent(api_key)
self.budget = monthly_budget_usd
self.spent = 0.0
self.request_count = 0
self.model_costs = {
'claude-sonnet-4.5': 0.000015, # $15/MTok
'gpt-4.1': 0.000008, # $8/MTok
'gemini-2.5-flash': 0.0000025, # $2.50/MTok
'deepseek-v3.2': 0.00000042, # $0.42/MTok
}
self.rate_limiter = defaultdict(list)
def _estimate_cost(self, message: str, model: str) -> float:
"""Schätzt Kosten basierend auf Nachrichtenlänge"""
tokens_estimate = len(message) // 4 # Rough estimate
return tokens_estimate * self.model_costs.get(model, 0.00001)
def _check_rate_limit(self) -> bool:
"""Verhindert Ratenbegrenzung durch sliding window"""
now = time.time()
window = 60 # 1 Minute Fenster
self.rate_limiter['requests'] = [
t for t in self.rate_limiter['requests'] if now - t < window
]
if len(self.rate_limiter['requests']) >= 60: # Max 60/min
return False
return True
def process_with_budget_control(self, message: str, guest_info: dict) -> dict:
"""Verarbeitet Nachricht mit Kosten- und Ratenkontrolle"""
# Wähle optimales Modell basierend auf Anfragetyp
complexity = len(message)
if complexity < 100:
model = 'gemini-2.5-flash' # Schnell, günstig
elif complexity < 500:
model = 'deepseek-v3.2' # Kosteneffizient
else:
model = 'claude-sonnet-4.5' # Premium
estimated_cost = self._estimate_cost(message, model)
# Budget-Prüfung
if self.spent + estimated_cost > self.budget:
return {
"error": "Budget limit reached",
"suggestion": "Upgrade your plan or wait until next billing cycle"
}
# Rate-Limit-Prüfung
if not self._check_rate_limit():
time.sleep(1) # Warte 1 Sekunde
# Verarbeite
result = self.agent.process_guest_message(message, guest_info)
# Buchhaltung
self.spent += estimated_cost
self.request_count += 1
self.rate_limiter['requests'].append(time.time())
result['cost_info'] = {
'estimated_cost_usd': estimated_cost,
'total_spent_usd': self.spent,
'remaining_budget_usd': self.budget - self.spent,
'requests_this_minute': len(self.rate_limiter['requests'])
}
return result
Nutzung mit Budget-Kontrolle
controlled_agent = CostControlledAgent(
api_key="YOUR_HOLYSHEEP_API_KEY",
monthly_budget_usd=300
)
result = controlled_agent.process_with_budget_control(guest_message, guest)
print(f"Verbleibendes Budget: ${result['cost_info']['remaining_budget_usd']:.2f}")Fehler 4: Kontextverlust bei langen Konversationen
Problem: Der Agent "vergisst" früher besprochene Details nach mehr als 10 Nachrichten.
# LÖSUNG: Conversation Memory Management
class HotelConversationManager:
def __init__(self, api_key: str, max_history: int = 20):
self.agent = HolySheepHotelAgent(api_key)
self.conversation_history = []
self.max_history = max_history
self.guest_context = {}
def add_context(self, key: str, value: any):
"""Speichert wichtige Gästeinformationen dauerhaft"""
self.guest_context[key] = value
def build_context_summary(self) -> str:
"""Erstellt kompakten Kontext für jeden API-Call"""
context_parts = ["[WICHTIGER GASTKONTEXT]"]
# Persistente Gästeinfo
if self.guest_context:
context_parts.append("Gast-Profil:")
for k, v in self.guest_context.items():
context_parts.append(f"- {k}: {v}")
# Letzte relevante Aktionen (nicht alle Details)
recent = self.conversation_history[-5:] if self.conversation_history else []
if recent:
context_parts.append("\nLetzte Interaktionen:")
for msg in recent:
context_parts.append(f"- [{msg['role']}]: {msg['content'][:100]}...")
return "\n".join(context_parts)
def send_message(self, message: str, guest_info: dict) -> dict:
"""Sendet Nachricht mit intelligentem Kontext-Management"""
# Neuen Kontext extrahieren
new_context = self._extract_new_context(message)
self.guest_context.update(new_context)
# Konversation history aktualisieren
self.conversation_history.append({
'role': 'user',
'content': message,
'timestamp': time.time()
})
# History begrenzen
if len(self.conversation_history) > self.max_history:
# Komprimiere alte Nachrichten zu Zusammenfassung
self._compress_history()
# System-Prompt mit Kontext
system_with_context = f"""{self.base_system_prompt}
{self.build_context_summary()}"""
# API-Call mit vollem Kontext
response = self.agent.generate_response(
message,
guest_info,
language=self._detect_language(message)
)
self.conversation_history.append({
'role': 'assistant',
'content': response,
'timestamp': time.time()
})
return {
'response': response,
'context_saved': list(new_context.keys())
}
def _compress_history(self):
"""Komprimiert alte Nachrichten zu einer Zusammenfassung"""
old_messages = self.conversation_history[:-10]
compression_prompt = f"""
Fasse die folgende Konversationshistorie zusammen.
Behalte alle wichtigen Fakten, Wünsche und getroffenen Entscheidungen.
Hist