Der Markt für Business Process Outsourcing (BPO) befindet sich 2026 in einer fundamentalen Transformation. Klassische Call-Center-Modelle, die auf statische Skripte und manuelle Qualitätskontrolle setzen, verlieren angesichts KI-gestützter Lösungen dramatisch an Wettbewerbsfähigkeit. Die zentrale Herausforderung für BPO-Dienstleister besteht darin, branchenspezifisches Domänenwissen effizient zu operationalisieren — ohne dabei proprietäre Systeme aufzugeben.
Dieser technische Leitfaden zeigt, wie Sie als BPO-Anbieter HolySheep AI als zentrale Wissensinfrastruktur nutzen: für industriespezifische Agent-Trainings, automatisierte Qualitätsbewertung und、回访摘要 (Rückrufzusammenfassungen) — alles in einer einheitlichen API-Architektur.
Vergleich: HolySheep vs. Offizielle APIs vs. Andere Relay-Dienste
| Kriterium | HolySheep AI | Offizielle APIs (OpenAI/Anthropic) | Andere Relay-Dienste |
|---|---|---|---|
| DeepSeek V3.2 Preis | $0.42/MTok | $0.27/MTok (China-exklusiv) | $0.35–$0.55/MTok |
| GPT-4.1 Preis | $8.00/MTok | $15.00/MTok | $10.00–$18.00/MTok |
| Zahlungsmethoden | 💳 WeChat, Alipay, USD-Karten | 💳 Internationale Karten | Variiert |
| Latenz | <50ms | 80–150ms | 60–120ms |
| Kostenlose Credits | ✅ Ja, bei Registrierung | ❌ Nein | Selten |
| Multi-Modell-Aggregation | ✅ Inklusive | ❌ Einzelmodelle | Teilweise |
| China-Marktzugang | ✅ Optimiert | ⚠️ Eingeschränkt | Variiert |
| Ersparnis vs. Offiziell | Bis 85%+ | Basis | 20–40% |
Architektur-Überblick: BPO-Wissensmanagement mit HolySheep
Die Engineering-Implementierung für BPO-Dienstleister gliedert sich in drei Kernmodule:
- Modul 1: 分行业坐席训练 (Branchen-spezifische Agent-Schulung)
- Modul 2: 质检评分 (Qualitätsprüfung & Bewertung)
- Modul 3: 回访摘要 (Rückrufzusammenfassungen)
Alle Module nutzen eine gemeinsame base_url und konsistente Authentifizierung — vereinfachter Betrieb, reduzierte Komplexität.
Modul 1: 分行业坐席训练 — Branchenspezifische Agent-Schulung
Das Problem
BPO-Agenten im Finanzsektor benötigen andere Wissensbasen als solche im E-Commerce oder Healthcare. Traditionelle Ansätze erfordern separate Trainingssysteme pro Branche — hoher Wartungsaufwand, inkonsistente Qualität.
Die Lösung: Wissenspaket-Management
# Wissenspaket-Definition für verschiedene Branchen
Python SDK für HolySheep AI
import requests
BASE_URL = "https://api.holysheep.ai/v1"
Branchenspezifische Wissenspaket-Konfiguration
BRANCH_WISSEN = {
"finanzdienstleistung": {
"system_prompt": "Sie sind ein Finanzberater für Privatkunden. "
"Geben Sie keine Anlageempfehlungen. "
"Verweisen Sie bei Vertragsänderungen auf offizielle Dokumente.",
"kompetenzen": ["Kontoeröffnung", " Kreditberatung", "Betrugsprävention"],
"kontraindikationen": ["Steuerliche Einzelberatung", "Garantieversprechen"]
},
"e-commerce": {
"system_prompt": "Sie sind ein Kundenservice-Agent eines Online-Shops. "
"Helfen Sie bei Bestellungen, Rücksendungen und Reklamationen.",
"kompetenzen": ["Bestellverfolgung", "Retourenabwicklung", "Rabattcodes"],
"kontraindikationen": ["Preisverhandlungen außerhalb von Aktionen"]
},
"healthcare": {
"system_prompt": "Sie sind ein Patientenservice-Assistent. "
"Geben Sie keine medizinischen Diagnosen. "
"Vermitteln Sie an Fachpersonal bei Symptomfragen.",
"kompetenzen": ["Terminbuchung", "Öffnungszeiten", "Versicherungsfragen"],
"kontraindikationen": ["Diagnosen", "Medikamentenempfehlungen", "Behandlungspläne"]
}
}
def trainiere_agent(branchen_id: str, agent_name: str, api_key: str):
"""
Trainiert einen Agenten mit branchenspezifischem Wissenspaket.
Args:
branchen_id: z.B. 'finanzdienstleistung', 'e-commerce', 'healthcare'
agent_name: Eindeutiger Name für den Agenten
api_key: HolySheep API-Schlüssel
"""
config = BRANCH_WISSEN.get(branchen_id)
if not config:
raise ValueError(f"Unbekannte Branche: {branchen_id}")
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
payload = {
"model": "deepseek-v3.2",
"messages": [
{"role": "system", "content": config["system_prompt"]},
{"role": "user", "content": f"Initialisiere Agent '{agent_name}' mit folgenden "
f"Kompetenzen: {', '.join(config['kompetenzen'])}. "
f"Folgende Themen sind kontraindiziert: {', '.join(config['kontraindikationen'])}"}
],
"temperature": 0.3,
"max_tokens": 500
}
response = requests.post(
f"{BASE_URL}/chat/completions",
headers=headers,
json=payload
)
if response.status_code == 200:
result = response.json()
return {
"agent_id": agent_name,
"branche": branchen_id,
"trainings_status": "abgeschlossen",
"token_verbrauch": result.get("usage", {}).get("total_tokens", 0)
}
else:
raise Exception(f"Training fehlgeschlagen: {response.status_code} - {response.text}")
Beispiel-Aufruf
try:
ergebnis = trainiere_agent(
branchen_id="finanzdienstleistung",
agent_name="berater_premium_001",
api_key="YOUR_HOLYSHEEP_API_KEY"
)
print(f"✅ Agent {ergebnis['agent_id']} erfolgreich trainiert")
print(f" Token-Verbrauch: {ergebnis['token_verbrauch']}")
except Exception as e:
print(f"❌ Fehler: {e}")Batch-Training für mehrere Agenten
# Paralleles Training mehrerer Agenten über verschiedene Branchen
import concurrent.futures
from dataclasses import dataclass
from typing import List, Dict
@dataclass
class AgentConfig:
name: str
branche: str
erfahrungsstufe: str # 'anfänger', 'fortgeschritten', 'experte'
def trainiere_batch_agenten(configs: List[AgentConfig], api_key: str) -> List[Dict]:
"""
Trainiert mehrere Agenten parallel in verschiedenen Branchen.
"""
def _trainiere_einzeln(config):
branchen_prompts = {
"banking": "Professioneller Bankberater mit Fokus auf Privatkunden.",
"versicherung": "Versicherungsberater für Sach- und Lebensversicherungen.",
"telekommunikation": "Kundenservice für Mobilfunk und Festnetz.",
"logistik": "Speditionskundenbetreuung für B2B-Sendungen."
}
erfahrungs_modifikatoren = {
"anfänger": "Erklären Sie alles ausführlich und fragen Sie nach Bedarf nach.",
"fortgeschritten": "Gehen Sie effizient vor, fassen Sie sich zusammen.",
"experte": "Nutzen Sie Fachterminologie, setzen Sie Vertrauen voraus."
}
system_prompt = (f"{branchen_prompts.get(config.branche, '')} "
f"{erfahrungs_modifikatoren.get(config.erfahrungsstufe, '')}")
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
payload = {
"model": "gpt-4.1", # Höhere Qualität für Training
"messages": [
{"role": "system", "content": system_prompt},
{"role": "user", "content": f"Bestätige Initialisierung für Agent: {config.name}"}
],
"temperature": 0.2
}
response = requests.post(
f"{BASE_URL}/chat/completions",
headers=headers,
json=payload
)
return {
"name": config.name,
"status": "erfolgreich" if response.status_code == 200 else "fehlgeschlagen",
"branche": config.branche,
"kosten": berechne_kosten(response.json()) if response.status_code == 200 else 0
}
# Parallelisierung für schnelle Verarbeitung
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
ergebnisse = list(executor.map(lambda c: _trainiere_einzeln(c), configs))
return ergebnisse
def berechne_kosten(response_data: Dict) -> float:
"""Berechnet Kosten basierend auf Token-Verbrauch"""
if "usage" not in response_data:
return 0.0
tokens = response_data["usage"]["total_tokens"]
# HolySheep Preise 2026
preise = {
"gpt-4.1": 8.00,
"deepseek-v3.2": 0.42,
"claude-sonnet-4.5": 15.00,
"gemini-2.5-flash": 2.50
}
modell = response_data.get("model", "deepseek-v3.2")
preis_pro_million = preise.get(modell, 1.00)
return (tokens / 1_000_000) * preis_pro_million
Beispiel-Batch-Training
agent_konfigurationen = [
AgentConfig("banking_junior_01", "banking", "anfänger"),
AgentConfig("banking_senior_01", "banking", "experte"),
AgentConfig("versicherung_norm_01", "versicherung", "fortgeschritten"),
AgentConfig("telko_support_01", "telekommunikation", "anfänger"),
AgentConfig("logistik_b2b_01", "logistik", "fortgeschritten"),
]
batch_ergebnisse = trainiere_batch_agenten(
agent_konfigurationen,
api_key="YOUR_HOLYSHEEP_API_KEY"
)
print("=" * 50)
print("BATCH-TRAINING ZUSAMMENFASSUNG")
print("=" * 50)
for ergebnis in batch_ergebnisse:
status_icon = "✅" if ergebnis["status"] == "erfolgreich" else "❌"
print(f"{status_icon} {ergebnis['name']}: {ergebnis['status']} "
f"(Kosten: ${ergebnis['kosten']:.4f})")
Gesamtkosten = sum(r["kosten"] for r in batch_ergebnisse)
print(f"\n💰 Gesamtkosten Batch-Training: ${Gesamtkosten:.4f}")
print(f"📊 Ersparnis vs. Offizielle API: ~${Gesamtkosten * 3:.2f}")Modul 2: 质检评分 — Automatisierte Gesprächsqualitätsbewertung
Die automatisierte Qualitätsbewertung (QA) ist ein kritischer Use Case für BPO-Dienstleister. Traditionelle manuelle Reviews sind zeitintensiv (10–20% der Gesprächszeit) und nicht skalierbar. Mit HolySheep können Sie 100% der Kundengespräche automatisch bewerten.
Gesprächsbewertungs-Pipeline
# Automatisierte Gesprächsqualitätsbewertung
import json
from datetime import datetime
from typing import List, Dict, Tuple
class QualitätsBewerter:
"""
Automatisierte Bewertung von Call-Center-Gesprächen
mit HolySheep AI.
"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
BEWERTUNGS_KRITERIEN = {
"lösungsorientierung": {
"gewicht": 0.30,
"max_punkte": 100,
"beschreibung": "Wurde das Anliegen des Kunden gelöst?"
},
"empathie": {
"gewicht": 0.25,
"max_punkte": 100,
"beschreibung": "Wurde angemessene Empathie gezeigt?"
},
"fachkompetenz": {
"gewicht": 0.25,
"max_punkte": 100,
"beschreibung": "Wurden korrekte Informationen gegeben?"
},
"sprachliche_qualität": {
"gewicht": 0.10,
"max_punkte": 100,
"beschreibung": "Satzbau, Grammatik, Verständlichkeit"
},
"compliance": {
"gewicht": 0.10,
"max_punkte": 100,
"beschreibung": "Einhaltung von Vorschriften und Prozessen"
}
}
def bewerte_gespraech(
self,
gesprach_transkript: str,
gesprach_dauer_sekunden: int,
kunden_segment: str = "standard"
) -> Dict:
"""
Bewertet ein Call-Center-Gespräch automatisch.
Args:
gesprach_transkript: Vollständiger Text des Gesprächs
gesprach_dauer_sekunden: Dauer in Sekunden
kunden_segment: 'standard', 'premium', 'enterprise'
Returns:
Dictionary mit detaillierter Bewertung und Gesamtpunktzahl
"""
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
# Segment-spezifische Bewertungsstandards
segment_standards = {
"standard": "Bewerte nach Standard-Kundenservice-Kriterien.",
"premium": "Erhöhte Standards für Wartezeiten und Lösungszeit.",
"enterprise": "Strengste Standards, inklusive proaktiver Empfehlungen."
}
bewertungs_anweisung = self._generiere_bewertungsanweisung(segment_standards[kunden_segment])
payload = {
"model": "gpt-4.1",
"messages": [
{"role": "system", "content": bewertungs_anweisung},
{"role": "user", "content": f"Bewerte folgendes Gespräch:\n\n{gesprach_transkript}"}
],
"temperature": 0.1, # Niedrige Temperatur für konsistente Bewertungen
"response_format": {"type": "json_object"}
}
response = requests.post(
f"{self.base_url}/chat/completions",
headers=headers,
json=payload
)
if response.status_code != 200:
raise Exception(f"Bewertung fehlgeschlagen: {response.text}")
result = response.json()
bewertung = json.loads(result["choices"][0]["message"]["content"])
# Gesamtpunktzahl berechnen
gesamt_punktzahl = self._berechne_gesamtpunktzahl(bewertung)
# Quality Score kategorisieren
kategorie = self._kategorisiere_quality(gesamt_punktzahl)
return {
"gesprach_id": f"GSR_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
"bewertungszeitpunkt": datetime.now().isoformat(),
"dauer_sekunden": gesprach_dauer_sekunden,
"kunden_segment": kunden_segment,
"kategorie": kategorie,
"gesamt_punktzahl": gesamt_punktzahl,
"detail_bewertung": bewertung,
"token_verbrauch": result.get("usage", {}).get("total_tokens", 0),
"kosten_bewertung": self._berechne_kosten(result)
}
def _generiere_bewertungsanweisung(self, segment_standard: str) -> str:
"""Generiert detaillierte Bewertungsanweisung für das KI-Modell"""
kriterien_text = "\n".join([
f"- {name}: {info['beschreibung']} (Gewicht: {info['gewicht']*100}%)"
for name, info in self.BEWERTUNGS_KRITERIEN.items()
])
return f"""Du bist ein erfahrener Qualitätsmanager für Call-Center.
Bewerte das folgende Gespräch nach diesen Kriterien:
{kriterien_text}
{segment_standard}
Gib das Ergebnis als JSON zurück:
{{
"lösungsorientierung": {{
"punkte": 0-100,
"begründung": "Kurze Erklärung"
}},
"empathie": {{
"punkte": 0-100,
"begründung": "Kurze Erklärung"
}},
"fachkompetenz": {{
"punkte": 0-100,
"begründung": "Kurze Erklärung"
}},
"sprachliche_qualität": {{
"punkte": 0-100,
"begründung": "Kurze Erklärung"
}},
"compliance": {{
"punkte": 0-100,
"begründung": "Kurze Erklärung"
}},
"verbesserungsvorschläge": [
"Konkreter Vorschlag 1",
"Konkreter Vorschlag 2"
],
"stichproben_zitate": {{
"positiv": "Beispieltext aus dem Gespräch",
"negativ": "Beispieltext aus dem Gespräch"
}}
}}"""
def _berechne_gesamtpunktzahl(self, bewertung: Dict) -> float:
"""Berechnet gewichtete Gesamtpunktzahl"""
gesamt = 0
for kriterium, info in self.BEWERTUNGS_KRITERIEN.items():
punkte = bewertung.get(kriterium, {}).get("punkte", 0)
gewicht = info["gewicht"]
gesamt += punkte * gewicht
return round(gesamt, 1)
def _kategorisiere_quality(self, punkte: float) -> str:
"""Kategorisiert die Gesamtbewertung"""
if punkte >= 90:
return "AUSSERORDENTLICH"
elif punkte >= 80:
return "SEHR_GUT"
elif punkte >= 70:
return "GUT"
elif punkte >= 60:
return "BEFRIEDIGEND"
elif punkte >= 50:
return "AUSREICHEND"
else:
return "MANGELHAFT"
def _berechne_kosten(self, response_data: Dict) -> float:
"""Berechnet Kosten der Bewertung"""
tokens = response_data.get("usage", {}).get("total_tokens", 0)
return (tokens / 1_000_000) * 8.00 # GPT-4.1 Preis
def批量_bewerte(self, transkripte: List[Dict]) -> Dict:
"""
Batch-Bewertung mehrerer Gespräche.
Args:
transkripte: Liste von Dict mit 'text', 'dauer', 'segment'
"""
ergebnisse = []
gesamtkosten = 0
for i, transkript in enumerate(transkripte):
try:
ergebnis = self.bewerte_gespraech(
gesprach_transkript=transkript["text"],
gesprach_dauer_sekunden=transkript["dauer"],
kunden_segment=transkript.get("segment", "standard")
)
ergebnisse.append(ergebnis)
gesamtkosten += ergebnis["kosten_bewertung"]
except Exception as e:
ergebnisse.append({
"gesprach_id": f"FEHLER_{i}",
"status": "fehlgeschlagen",
"fehler": str(e)
})
# Statistiken berechnen
erfolgreiche = [e for e in ergebnisse if e.get("status") != "fehlgeschlagen"]
if erfolgreiche:
durchschnitt = sum(e["gesamt_punktzahl"] for e in erfolgreiche) / len(erfolgreiche)
else:
durchschnitt = 0
return {
"Gesamt Gespräche": len(transkripte),
"Erfolgreich": len(erfolgreiche),
"Fehlgeschlagen": len(transkripte) - len(erfolgreiche),
"Durchschnittspunktzahl": round(durchschnitt, 1),
"Gesamtkosten": round(gesamtkosten, 4),
"Kosten_pro_gespräch": round(gesamtkosten / len(transkripte), 4) if transkripte else 0,
"bewertungen": ergebnisse
}
Beispiel-Nutzung
bewerter = QualitätsBewerter(api_key="YOUR_HOLYSHEEP_API_KEY")
Test-Gespräch (vereinfachtes Beispiel)
beispiel_transkript = """
Agent: Guten Tag, Sie sprechen mit Max Mustermann von ServicePlus. Wie kann ich Ihnen helfen?
Kunde: Hallo, ich habe eine Frage zu meiner letzten Rechnung. Die stimmt irgendwie nicht.
Agent: Das tut mir leid zu hören. Lassen Sie mich das gerne für Sie überprüfen.
Können Sie mir Ihre Kundennummer nennen?
Kunde: Ja, die ist 12345-ABC.
Agent: Vielen Dank. Ich sehe hier Ihre Rechnung vom 15. Mai. Was genau stimmt Ihrer
Meinung nach nicht?
Kunde: Ich wurde zweimal abgerechnet für dieselbe Leistung.
Agent: Oh je, das tut mir leid. Das sollte nicht passieren. Ich kann das hier sehen -
tatsächlich wurde die Leistung "Premium-Upgrade" zweimal berechnet.
Das korrigiere ich sofort für Sie und erstelle eine Gutschrift über 29,99 Euro.
Kunde: Das wäre super, danke.
Agent: Sehr gerne. Die Gutschrift wird innerhalb von 3-5 Werktagen auf Ihrem Konto
erscheinen. Gibt es noch etwas, womit ich Ihnen helfen kann?
Kunde: Nein, das war alles. Danke für die schnelle Hilfe!
Agent: Ich danke Ihnen für Ihren Anruf und wünsche Ihnen einen schönen Tag!
"""
bewertung = bewerter.bewerte_gespraech(
gesprach_transkript=beispiel_transkript,
gesprach_dauer_sekunden=180,
kunden_segment="premium"
)
print("📊 BEWERTUNGSERGEBNIS")
print("=" * 50)
print(f"ID: {bewertung['gesprach_id']}")
print(f"Kategorie: {bewertung['kategorie']}")
print(f"Gesamtpunktzahl: {bewertung['gesamt_punktzahl']}/100")
print(f"Kosten: ${bewertung['kosten_bewertung']:.4f}")
print("\nDetailbewertung:")
for kriterium, info in bewertung['detail_bewertung'].items():
if isinstance(info, dict) and 'punkte' in info:
print(f" • {kriterium}: {info['punkte']}/100")Qualitäts-Dashboard-Daten
# Qualitätstrend-Analyse über Zeit
def generiere_qualitaetsbericht(bewertungs_ergebnisse: List[Dict]) -> Dict:
"""
Generiert einen detaillierten Qualitätsbericht mit Trends.
"""
if not bewertungs_ergebnisse:
return {"status": "keine_daten"}
# Nach Kategorien gruppieren
kategorien_count = {}
kriterien_scores = {k: [] for k in ["lösungsorientierung", "empathie",
"fachkompetenz", "sprachliche_qualität",
"compliance"]}
for ergebnis in bewertungs_ergebnisse:
if ergebnis.get("status") == "fehlgeschlagen":
continue
kat = ergebnis.get("kategorie", "UNBEKANNT")
kategorien_count[kat] = kategorien_count.get(kat, 0) + 1
for kriterium in kriterien_scores:
punkte = ergebnis.get("detail_bewertung", {}).get(kriterium, {}).get("punkte", 0)
if punkte > 0:
kriterien_scores[kriterium].append(punkte)
# Durchschnitte berechnen
kriterien_durchschnitt = {}
for kriterium, werte in kriterien_scores.items():
if werte:
kriterien_durchschnitt[kriterium] = round(sum(werte) / len(werte), 1)
else:
kriterien_durchschnitt[kriterium] = 0
# Verbesserungspotenzial identifizieren
verbesserungspotenzial = sorted(
kriterien_durchschnitt.items(),
key=lambda x: x[1]
)[:2] # Top 2 Schwächen
return {
"zeitraum": "letzte 30 Tage",
"gesamtauswertungen": len(bewertungs_ergebnisse),
"qualitätsverteilung": kategorien_count,
"kriterien_durchschnitt": kriterien_durchschnitt,
"verbesserungspotenzial": verbesserungspotenzial,
"empfehlungen": [
f"Fokus auf {potenzial[0]} (aktuell: {potenzial[1]}/100)"
for potenzial in verbesserungspotenzial
]
}Modul 3: 回访摘要 — Intelligente Rückrufzusammenfassungen
Für BPO-Dienstleister, die Rückrufaktionen (Callbacks) durchführen, sind präzise Zusammenfassungen essentiell. Ein Agent muss in Sekunden den Kontext verstehen können, ohne das gesamte Gespräch erneut lesen zu müssen.
# Rückrufzusammenfassungs-Engine
class RueckrufSummarizer:
"""
Generiert strukturierte Zusammenfassungen für Rückrufgespräche.
"""
ZUSAMMENFASSUNG_TEMPLATE = """
## Rückrufzusammenfassung
### Grunddaten
- **Kunde**: {kunde_name}
- **Kundennummer**: {kundennummer}
- **Letzter Kontakt**: {datum}
- **Grund Rückruf**: {rueckruf_grund}
### Zusammenfassung des vorherigen Gesprächs
{zusammenfassung}
### Offene Punkte
{offene_punkte}
### Vereinbarungen
{vereinbarungen}
### Empfohlener Ansprechstil
{ansprechstil}
### Checkliste für Rückruf
{checkliste}
"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
def generiere_zusammenfassung(
self,
gesprach_text: str,
kundendaten: Dict,
prioritaet: str = "normal" # 'niedrig', 'normal', 'hoch', 'kritisch'
) -> str:
"""
Generiert eine strukturierte Rückrufzusammenfassung.
"""
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
prio_texte = {
"niedrig": "Der Kunde hat Zeit, kann warten.",
"normal": "Kunde erwartet zeitnahen Rückruf.",
"hoch": "Kunde ist unzufrieden, schneller Rückruf nötig.",
"kritisch": "Eskalation erforderlich, sofortiger Rückruf."
}
payload = {
"model": "deepseek-v3.2", # Kosteneffizient für Zusammenfassungen
"messages": [
{"role": "system", "content": """Du bist ein Spezialist für
Call-Center-Zusammenfassungen. Erstelle präzise, strukturierte Zusammenfassungen
für Rückrufgespräche. Fokussiere auf:
- Kernanliegen des Kunden
- Bereits besprochene Lösungen
- Offene Fragen
- Nächste Schritte
Antworte im JSON-Format."""},
{"role": "user", "content": f"""
Erstelle eine Rückrufzusammenfassung für folgendes Gespräch:
Gesprächstext:
{gesprach_text}
Kundendaten:
- Name: {kundendaten.get('name', 'N/A')}
- Kundennummer: {kundendaten.get('kundennummer', 'N/A')}
- Segment: {kundendaten.get('segment', 'Standard')}
- Priorität: {prioritaet} ({prio_texte.get(prioritaet, '')})
Gib folgende JSON-Struktur zurück:
{{
"zusammenfassung": "3-5 Sätze Kernanliegen",
"offene_punkte": ["Punkt 1", "Punkt 2"],
"vereinbarungen": ["Vereinbarung 1"],
"ansprechstil": "Empfohlener Kommunikationsstil",
"checkliste": ["Punkt für Checkliste 1", "Punkt 2"]
}}
"""}
],
"temperature": 0.3
}
response = requests.post(
f"{self.base_url}/chat/completions",
headers=headers,
json=payload
)
if response.status_code != 200:
raise Exception(f"Zusammenfassung fehlgeschlagen: {response.text}")
result = response.json()
inhalt = json.loads(result["choices"][0]["message"]["content"])
# Template befüllen
zusammenfassung = self.ZUSAMMENFASSUNG_TEMPLATE.format(
kunde_name=kundendaten.get('name', 'Unbekannt'),
kundennummer=kundendaten.get('kundennummer', 'N/A'),
datum=datetime.now().strftime('%d.%m.%Y'),
rueckruf_grund=inhalt.get("zusammenfassung", ""
Verwandte Ressourcen
Verwandte Artikel