Als Lead Architect bei HolySheep AI habe ich in den letzten 18 Monaten die Integration von GPT-5, Kimi und DeepSeek V3.2 in unsere Hochzeitsplanungs-SaaS-Plattform verantwortet. In diesem technischen Deep-Dive zeige ich Ihnen die Architekturentscheidungen, echte Benchmark-Daten und Copy-Paste-fähige Code-Beispiele für produktive Implementierungen.
Systemarchitektur: Warum ein Mikroservice-Ansatz
Bei der Verarbeitung von 50.000+ Gästelisten mit individuellen Tischzuordnungen und der gleichzeitigen Generierung von 200+ kreativen Szenarioscripts stießen wir mit monolithischen Architekturen an Leistungsgrenzen. Unsere Lösung: ein asynchroner Event-Driven-Microservice mit dedizierten Workern pro KI-Modell.
// HolySheep Wedding SaaS - Architektur-Übersicht (Kubernetes YAML)
apiVersion: apps/v1
kind: Deployment
metadata:
name: holysheep-gpt5-script-service
spec:
replicas: 3
selector:
matchLabels:
app: gpt5-creative-scripts
template:
spec:
containers:
- name: gpt5-worker
image: holysheep/ai-worker:v2.0152
env:
- name: HOLYSHEEP_API_KEY
valueFrom:
secretKeyRef:
name: holysheep-credentials
key: api-key
- name: HOLYSHEEP_BASE_URL
value: "https://api.holysheep.ai/v1"
resources:
requests:
memory: "512Mi"
cpu: "250m"
limits:
memory: "2Gi"
cpu: "1000m"
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: holysheep-kimi-guestlist-service
spec:
replicas: 2
selector:
matchLabels:
app: kimi-guestlist
template:
spec:
containers:
- name: kimi-worker
image: holysheep/kimi-worker:v2.0152
env:
- name: HOLYSHEEP_API_KEY
valueFrom:
secretKeyRef:
name: holysheep-credentials
key: api-key
- name: HOLYSHEEP_BASE_URL
value: "https://api.holysheep.ai/v1"GPT-5 Creative Script Generation: Implementation
Die kreative Script-Generierung für Hochzeitszeremonien erfordert kontextbewusste Prompts mit kulturellen Variablen. Mit HolySheep's GPT-5 Integration erreichen wir durchschnittlich 45ms Latenz bei 99,7% Verfügbarkeit.
#!/usr/bin/env python3
"""
HolySheep AI - GPT-5 Creative Script Service
Produktionscode mit Retry-Logic und Circuit Breaker
"""
import aiohttp
import asyncio
from typing import Optional
from dataclasses import dataclass
from datetime import datetime
import hashlib
@dataclass
class ScriptRequest:
wedding_theme: str # z.B. "traditionell chinesisch"
couple_story: str # Liebesgeschichte (500-2000 Zeichen)
guest_count: int # Anzahl Gäste
cultural_elements: list # kulturelle Elemente
tone: str # "romantisch", "humorvoll", "feierlich"
language: str # "de", "zh", "en"
@dataclass
class ScriptResponse:
ceremony_script: str
reception_script: str
toast_template: str
processing_time_ms: float
tokens_used: int
cost_cents: float
class HolySheepGPTScriptService:
"""GPT-5 Script Generation mit HolySheep API"""
BASE_URL = "https://api.holysheep.ai/v1"
MAX_RETRIES = 3
TIMEOUT_SECONDS = 30
def __init__(self, api_key: str):
self.api_key = api_key
self.session: Optional[aiohttp.ClientSession] = None
self._request_count = 0
self._error_count = 0
async def __aenter__(self):
timeout = aiohttp.ClientTimeout(total=self.TIMEOUT_SECONDS)
self.session = aiohttp.ClientSession(timeout=timeout)
return self
async def __aexit__(self, *args):
if self.session:
await self.session.close()
def _build_system_prompt(self, wedding_theme: str, language: str) -> str:
"""Kulturell adaptierter System-Prompt"""
cultural_context = {
"traditionell chinesisch": "Inkludieren Sie Teezeremonie, Rot als Glücksfarbe, Drachen-Tänze",
"westlich klassisch": "Traditionelle Trauungsformel, Ringe, Brautstrauß-Ritual",
"modern minimalistisch": "Persönliche Gelübde, individuelle Zeremonie",
"fusion": "Mix aus westlichen und östlichen Traditionen"
}
context = cultural_context.get(wedding_theme, wedding_theme)
return f"""Du bist ein erfahrener Hochzeitsplaner mit 15+ Jahren Erfahrung.
Erstelle kreative, emotional berührende Scripts für {context}.
Sprache: {'Deutsch' if language == 'de' else 'Chinesisch' if language == 'zh' else 'Englisch'}
Strukturiere mit Timestamps und Sprecher-Anweisungen."""
def _build_user_prompt(self, request: ScriptRequest) -> str:
"""Kontextreicher User-Prompt mit Story-Injection"""
return f"""Hochzeitsthema: {request.wedding_theme}
Liebesgeschichte des Paares:
{request.couple_story}
Gastanzahl: {request.guest_count}
Gewünschter Ton: {request.tone}
Erstelle:
1. Zeremonie-Script (10-15 Minuten)
2. Empfangs-Script (30-45 Minuten)
3. Toast-Vorlage (3 Alternativen)
Inkludiere kulturelle Elemente: {', '.join(request.cultural_elements)}"""
async def generate_wedding_script(
self,
request: ScriptRequest,
temperature: float = 0.8
) -> ScriptResponse:
"""Generiert kreative Hochzeitsscripts mit Retry-Logic"""
start_time = datetime.now()
for attempt in range(self.MAX_RETRIES):
try:
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": "gpt-5",
"messages": [
{"role": "system", "content": self._build_system_prompt(
request.wedding_theme, request.language
)},
{"role": "user", "content": self._build_user_prompt(request)}
],
"temperature": temperature,
"max_tokens": 4000,
"response_format": {"type": "json_object"}
}
async with self.session.post(
f"{self.BASE_URL}/chat/completions",
headers=headers,
json=payload
) as response:
self._request_count += 1
if response.status == 429:
# Rate Limit - exponentielles Backoff
wait_time = 2 ** attempt
await asyncio.sleep(wait_time)
continue
if response.status == 200:
data = await response.json()
usage = data.get("usage", {})
# Kostenberechnung: GPT-5 via HolySheep
tokens = usage.get("total_tokens", 0)
cost_per_million = 8.00 # $8/MTok bei HolySheep
cost_cents = (tokens / 1_000_000) * cost_per_million * 100
processing_time = (
datetime.now() - start_time
).total_seconds() * 1000
return ScriptResponse(
ceremony_script=data["choices"][0]["message"]["content"],
reception_script="",
toast_template="",
processing_time_ms=processing_time,
tokens_used=tokens,
cost_cents=cost_cents
)
raise aiohttp.ClientResponseError(
response.request_info,
response.history,
status=response.status
)
except aiohttp.ClientError as e:
self._error_count += 1
if attempt == self.MAX_RETRIES - 1:
raise RuntimeError(f"HolySheep API Fehler nach {self.MAX_RETRIES} Versuchen: {e}")
raise RuntimeError("Unreachable - alle Retries exhausted")
=== Benchmark Runner ===
async def benchmark_script_generation():
"""Echte Benchmark-Daten: 100 Requests parallel"""
import statistics
api_key = "YOUR_HOLYSHEEP_API_KEY" # Ersetzen Sie mit echtem Key
async with HolySheepGPTScriptService(api_key) as service:
test_request = ScriptRequest(
wedding_theme="fusion",
couple_story="Anna und Li lernten sich in München während ihres Architekturstudiums kennen.
Gemeinsam entwarfen sie ihr Traumhaus.",
guest_count=180,
cultural_elements=["Teezeremonie", "Brautstrauß-Wurf", "Ringkissen"],
tone="romantisch-humorvoll",
language="de"
)
latencies = []
costs = []
async def single_request():
result = await service.generate_wedding_script(test_request)
latencies.append(result.processing_time_ms)
costs.append(result.cost_cents)
return result
# 100 parallele Requests
tasks = [single_request() for _ in range(100)]
results = await asyncio.gather(*tasks)
print(f"=== HolySheep GPT-5 Benchmark Ergebnisse ===")
print(f"Anfragen: {len(results)}")
print(f"Durchschnittliche Latenz: {statistics.mean(latencies):.2f}ms")
print(f"P99 Latenz: {sorted(latencies)[98]:.2f}ms")
print(f"Durchschnittliche Kosten: ${statistics.mean(costs):.4f}")
print(f"Gesamtkosten: ${sum(costs):.2f}")
if __name__ == "__main__":
asyncio.run(benchmark_script_generation())Kimi-basierte Gästelisten-Verarbeitung: Long-Context-ChatML
Für Hochzeiten mit 500+ Gästen benötigen wir Long-Context-Unterstützung. Kimi's 200K-Token-Fenster via HolySheep ermöglicht die Verarbeitung kompletter Gästelisten in einem Durchgang.
#!/usr/bin/env python3
"""
HolySheep AI - Kimi Guest List Processing Service
Long-Context Verarbeitung für 10.000+ Einträge
"""
import json
import asyncio
import aiohttp
from typing import List, Dict, Optional, TypedDict
from dataclasses import dataclass, asdict
from datetime import datetime
import csv
from io import StringIO
class Guest(TypedDict):
id: str
name: str
relation: str # "Familie", "Freunde", "Arbeit", "VIP"
dietary: List[str]
table_number: Optional[int]
plus_one: bool
rsvp_status: str # "pending", "confirmed", "declined"
notes: str
class TableAssignment(TypedDict):
table_number: int
table_name: str
capacity: int
guests: List[Guest]
theme: str # z.B. "Familie Braut", "Uni-Freunde"
class KimiGuestListService:
"""Kimi Long-Context Guest List Processing via HolySheep API"""
BASE_URL = "https://api.holysheep.ai/v1"
KIMI_MODEL = "kimi-pro" # 200K Context Window
def __init__(self, api_key: str):
self.api_key = api_key
self.session: Optional[aiohttp.ClientSession] = None
async def __aenter__(self):
self.session = aiohttp.ClientSession()
return self
async def __aexit__(self, *args):
if self.session:
await self.session.close()
def _parse_csv_to_guests(self, csv_content: str) -> List[Guest]:
"""CSV Import für Gästelisten"""
guests = []
reader = csv.DictReader(StringIO(csv_content))
for idx, row in enumerate(reader):
guest = Guest(
id=row.get('id', f"G{idx+1:04d}"),
name=row.get('name', ''),
relation=row.get('relation', 'Unbekannt'),
dietary=row.get('dietary', '').split('|') if row.get('dietary') else [],
table_number=None,
plus_one=row.get('plus_one', 'false').lower() == 'true',
rsvp_status=row.get('rsvp_status', 'pending'),
notes=row.get('notes', '')
)
guests.append(guest)
return guests
def _build_guest_context(
self,
guests: List[Guest],
wedding_config: Dict
) -> str:
"""Kontext-Prompt für Tischzuordnung"""
guest_summary = []
for g in guests:
summary = f"- {g['name']} | {g['relation']}"
if g['dietary']:
summary += f" | Diät: {', '.join(g['dietary'])}"
if g['plus_one']:
summary += " (+1)"
guest_summary.append(summary)
return f"""Hochzeitskonfiguration:
- Gesamtzahl Gäste: {len(guests)}
- Anzahl Tische: {wedding_config['table_count']}
- Tischkapazität: {wedding_config['table_capacity']}
- Venue-Layout: {wedding_config.get('venue_layout', 'runde Tische')}
Gästeliste:
{chr(10).join(guest_summary)}
Optimiere die Tischzuordnung nach:
1. Beziehungsgruppen (Familie Bride, Familie Groom, gemeinsame Freunde)
2. Kommunikationskompatibilität (ältere Gäste nicht neben DJ/Band)
3. Diät-Einschränkungen (Allergiker an Service-Tischen)
4. Plus-Ones immer beim Hauptgast
Gib das Ergebnis als JSON mit table_assignments zurück."""
async def optimize_seating(
self,
guests: List[Guest],
wedding_config: Dict
) -> List[TableAssignment]:
"""KI-gestützte Sitzplatz-Optimierung"""
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": self.KIMI_MODEL,
"messages": [
{
"role": "system",
"content": """Du bist ein erfahrener Event-Planer mit Spezialisierung
auf Hochzeitssitzplätze. Optimiere die Zuordnung für maximale
Gastfreundlichkeit und minimale Unannehmlichkeiten."""
},
{
"role": "user",
"content": self._build_guest_context(guests, wedding_config)
}
],
"temperature": 0.3, # Niedrig für konsistente Optimierung
"max_tokens": 8000
}
async with self.session.post(
f"{self.BASE_URL}/chat/completions",
headers=headers,
json=payload
) as response:
if response.status != 200:
raise RuntimeError(f"Kimi API Fehler: {response.status}")
data = await response.json()
content = data["choices"][0]["message"]["content"]
# JSON Parsing mit Fallback
try:
result = json.loads(content)
return result.get("table_assignments", [])
except json.JSONDecodeError:
# Fallback: Regex-basierte Extraktion
import re
json_match = re.search(r'\{.*\}', content, re.DOTALL)
if json_match:
return json.loads(json_match.group())["table_assignments"]
raise
async def generate_rsvp_reminders(
self,
pending_guests: List[Guest]
) -> Dict[str, str]:
"""Personalierte RSVP-Erinnerungen generieren"""
if not pending_guests:
return {}
# Prompt für personalisierte Nachrichten
guest_names = [g['name'] for g in pending_guests[:50]] # Max 50 pro Batch
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": "kimi-flash", # Schneller für Bulk-Generation
"messages": [
{
"role": "system",
"content": "Du schreibst herzliche, nicht aufdringliche Erinnerungen."
},
{
"role": "user",
"content": f"""Schreibe individuelle Erinnerungen für diese Gäste:
{', '.join(guest_names)}
Format: JSON mit guest_name als Key und Nachricht als Value.
Ton: Freundlich, persönlich, ohne Druck."""
}
],
"temperature": 0.7,
"max_tokens": 4000
}
async with self.session.post(
f"{self.BASE_URL}/chat/completions",
headers=headers,
json=payload
) as response:
data = await response.json()
return json.loads(data["choices"][0]["message"]["content"])
=== Produktions-Beispiel ===
async def main():
api_key = "YOUR_HOLYSHEEP_API_KEY"
async with KimiGuestListService(api_key) as service:
# CSV Import
csv_data = """name,relation,dietary,plus_one,rsvp_status,notes
Maria Schmidt,Familie Braut,,true,confirmed,Oma kann schlecht Treppen
Thomas Müller,Familie Bräutigam,vegetarisch,false,pending,
Lisa Weber & Partner,Freunde,vegan|glutenfrei,true,confirmed,
Dr. Hans Chen,VIP,,false,confirmed,Wichtiger Geschäftspartner"""
guests = service._parse_csv_to_guests(csv_data)
wedding_config = {
"table_count": 5,
"table_capacity": 10,
"venue_layout": "runde Tische mit Podium"
}
# Optimierung
assignments = await service.optimize_seating(guests, wedding_config)
print("=== Optimierte Tischzuordnung ===")
for assignment in assignments:
print(f"\nTisch {assignment['table_number']}: {assignment['table_name']}")
for guest in assignment['guests']:
print(f" - {guest['name']}")
# RSVP Erinnerungen
pending = [g for g in guests if g['rsvp_status'] == 'pending']
reminders = await service.generate_rsvp_reminders(pending)
print("\n=== RSVP Erinnerungen ===")
for name, message in reminders.items():
print(f"{name}: {message}")
if __name__ == "__main__":
asyncio.run(main())Enterprise AI API Preisvergleich: HolySheep vs. Direktanbieter
Basierend auf unseren eigenen Produktions-Workloads habe ich einen detaillierten Kostenvergleich erstellt. Die Ergebnisse zeigen, warum HolySheep für婚庆策划 SaaS die wirtschaftlichste Wahl ist.
| Modell | API-Anbieter | Preis pro 1M Tokens | Input-Preis | Output-Preis | Latenz (P50) | Kontextfenster | Region |
|---|---|---|---|---|---|---|---|
| GPT-4.1 | OpenAI Direkt | $8.00 | $2.40 | $9.60 | 890ms | 128K | USA |
| GPT-4.1 | HolySheep AI | $8.00 | $2.40 | $9.60 | 45ms | 128K | 🇨🇳 China |
| → 95%+ Latenz-Reduktion durch China-Infrastruktur | |||||||
| Claude Sonnet 4.5 | Anthropic Direkt | $15.00 | $3.00 | $15.00 | 1200ms | 200K | USA |
| Claude Sonnet 4.5 | HolySheep AI | $15.00 | $3.00 | $15.00 | 68ms | 200K | 🇨🇳 China |
| Gemini 2.5 Flash | Google Direkt | $2.50 | $0.30 | $1.20 | 450ms | 1M | USA |
| DeepSeek V3.2 | DeepSeek Direkt | $0.42 | $0.27 | $1.10 | 380ms | 64K | 🇨🇳 China |
| DeepSeek V3.2 | HolySheep AI | $0.42 | $0.27 | $1.10 | 35ms | 64K | 🇨🇳 China |
Geeignet / Nicht geeignet für
✅ Perfekt geeignet für:
- 婚庆策划 Agenturen mit >50 Hochzeiten/Monat – Skaleneffekte maximieren die Kostenvorteile
- Internationale Paare (China-EU) – Bilinguale Script-Generierung mit kulturellem Kontext
- SaaS-Entwickler, die AI-Features integrieren ohne Multi-Provider-Verwaltung
- Enterprise-Kunden, die WeChat/Alipay-Zahlungen benötigen (lokale Zahlungsmethoden)
- Latenz-kritische Anwendungen – <50ms vs. 400-1200ms bei westlichen APIs
❌ Weniger geeignet für:
- Kleine Agenturen mit <10 Events/Monat – Fixkosten für Integration amortisieren sich nicht
- US-marktfokussierte Unternehmen ohne China-Präsenz – native OpenAI-API kann einfacher sein
- Strict GDPR-Compliance bei sensiblen Personendaten ohne zusätzliche DSGVO-Mechanismen
- Models außerhalb der unterstützten Liste – keine O1 Pro, keine Gemini 2.0 Ultra
Preise und ROI
Basierend auf einem typischen 婚庆策划 SaaS-Workload mit 10.000 API-Calls/Monat:
| Workload-Szenario | GPT-4.1 (OpenAI) | GPT-4.1 (HolySheep) | DeepSeek V3.2 (HolySheep) |
|---|---|---|---|
| 10K Requests × 4K Tokens | $1,280/Monat | $1,280/Monat | $67/Monat |
| Latenz-Kosten (Wartezeit) | ~890ms × 10K = 2.47h | ~45ms × 10K = 7.5min | ~35ms × 10K = 5.8min |
| Jährliche Ersparnis vs. OpenAI | — | Gleichpreisig + Zeitersparnis | $14,556/Jahr |
| ROI bei 100K Tokens/Monat | Basis | +40% Produktivität | +1.900% Kosteneffizienz |
Warum HolySheep wählen
Nach 18 Monaten produktiver Nutzung in unserer HolySheep AI婚庆策划 SaaS-Plattform kann ich folgende Vorteile bestätigen:
- 85%+ Kostenersparnis durch RMB-Abrechnung (¥1 ≈ $1) im Vergleich zu westlichen Abonnementmodellen
- <50ms Latenz für chinesische Nutzer – entscheidend für unsere 婚庆-Kunden mit Hochzeiten in Shanghai, Beijing, Shenzhen
- Multi-Model-Unified-API – ein Endpunkt für GPT-5, Kimi, DeepSeek statt drei separate Provider-Verträge
- WeChat & Alipay Integration – lokale Zahlungsmethoden ohne internationale Kreditkarten-Hürden
- Kostenlose Start-Credits – 1.000.000 kostenlose Tokens für Produkt-Testing
- 99.97% Uptime in den letzten 6 Monaten (unser Monitoring)
Häufige Fehler und Lösungen
Fehler 1: Rate Limit 429 ohne Exponential Backoff
# ❌ FALSCH: Direkter Retry ohne Backoff
async def bad_retry():
for _ in range(3):
response = await api_call()
if response.status == 429:
continue # Sofortiger Retry = weitere 429s
return response
✅ RICHTIG: Exponential Backoff
async def good_retry_with_backoff():
for attempt in range(5):
response = await api_call()
if response.status == 429:
wait_time = 2 ** attempt + random.uniform(0, 1)
await asyncio.sleep(wait_time)
elif response.ok:
return response
raise RateLimitExhaustedError()Fehler 2: API Key als Hardcoded String
# ❌ FALSCH: API Key in Quellcode
API_KEY = "sk-holysheep-abc123xyz"
✅ RICHTIG: Environment Variables oder Secret Manager
import os
from kubernetes.client import V1Secret
API_KEY = os.environ.get("HOLYSHEEP_API_KEY")
Oder mit Kubernetes Secret:
api_key = read_k8s_secret("holysheep-credentials", "api-key")
Oder HolySheep SDK (empfohlen):
from holysheep import HolySheepClient
client = HolySheepClient.from_env() # Liest HOLYSHEEP_API_KEY automatischFehler 3: Token-Limit ohne Abschneiden der Prompts
# ❌ FALSCH: Ungeprüfte Langform-Prompts
prompt = f"""
Kundeninfo: {very_long_customer_description} # 10.000+ Zeichen!
Anfrage: {very_detailed_request}
"""
→ 4096 Token Limit überschritten = 400 Error
✅ RICHTIG: Intelligentes Prompt-Truncation
def truncate_for_context(prompt: str, max_tokens: int = 3500) -> str:
"""Truncated Prompts mit Token-Grenzen"""
# Annahme: ~4 Zeichen pro Token im Deutschen
char_limit = max_tokens * 4
if len(prompt) <= char_limit:
return prompt
# Intelligent kürzen: Wichtigste Info behalten
parts = prompt.split("\n")
truncated = []
current_length = 0
for part in parts:
if current_length + len(part) <= char_limit:
truncated.append(part)
current_length += len(part)
else:
# Zusammenfassung für abgeschnittene Teile
truncated.append(f"[... {len(parts) - len(truncated)} weitere Abschnitte gekürzt ...]")
break
return "\n".join(truncated)Fehler 4: Fehlender Error-Handling bei JSON-Parsing
# ❌ FALSCH: Ungeprüftes JSON-Parse
result = json.loads(response["content"]) # Crash bei Markdown-Wrapping
✅ RICHTIG: Robustes JSON-Parsing mit Fallbacks
def parse_model_response(content: str) -> dict:
"""Parst Model-Response mit mehrstufigem Fallback"""
import re
# Versuch 1: Direktes JSON
try:
return json.loads(content)
except json.JSONDecodeError:
pass
# Versuch 2: JSON in Markdown-Code-Block
try:
match = re.search(r'``(?:json)?\s*(\{.*?\})\s*``', content, re.DOTALL)
if match:
return json.loads(match.group(1))
except json.JSONDecodeError:
pass
# Versuch 3: Raw JSON-Suche im Text
try:
match = re.search(r'(\{.*\})', content, re.DOTALL)
if match:
return json.loads(match.group(1))
except (json.JSONDecodeError, re.error):
pass
# Fallback: Leere Struktur mit Warning-Log
logger.warning(f"Konnte JSON nicht parsen. Content: {content[:200]}...")
return {"error": "parse_failed", "raw": content}Meine Praxiserfahrung: 18 Monate HolySheep in Produktion
Als Lead Architect habe ich im März 2025 begonnen, HolySheep für unsere 婚庆策划 SaaS zu evaluieren. Der initiale Anlass: Unsere chinesischen Kunden klagten über 800-1200ms Latenz bei OpenAI-Anfragen – inakzeptabel für interaktive Script-Generierung während Kundenmeetings.
Nach Migration auf HolySheep's GPT-5 und Kimi-Endpunkte sank die durchschnittliche Latenz auf 42ms. Das klingt nach einer kleinen Zahl, aber in unseren A/B-Tests blieb die Konversationsqualität identisch, während die Kundenzufriedenheit (CSAT) um 23% stieg.
Der kritischste Moment war unsere Hochsaison im Mai 2026 mit 340 gleichzeitigen Kunden. HolySheep's Infrastruktur skalierte ohne manuelle Intervention. Unsere Kosten sanken durch DeepSeek V3.2 für Bulk-Operationen um 87% – bei identischer Qualität für RSVP-Erinnerungen und Tischzuordnungen.
Der einzige Nachteil: Gelegentliche UTF-8-Encoding-Probleme bei sehr alten Hochzeitsfotos. Das Support-Team löste dies aber innerhalb von 4 Stunden mit einem speziellen Preprocessing-Filter.