KI-Kundensupport: Tickets mit RAG reduzieren

Der Kundensupport macht oft 15 bis 25 % der Betriebskosten eines Unternehmens aus. Eine Gartner-Studie zeigt, dass 70 % der Level-1-Tickets sich auf sich wiederholende Fragen beziehen, deren Antwort bereits in der Dokumentation vorhanden ist. RAG verwandelt diese Realität, indem es Antworten automatisiert und gleichzeitig die Servicequalität erhält.

Die versteckten Kosten des traditionellen Supports

Anatomie eines Support-Tickets

Jedes Ticket durchläuft einen kostenintensiven Zyklus:

Multiplizieren Sie das mit Tausenden von Tickets pro Monat, und der Support wird zu einem finanziellen Loch.

Die immer wiederkehrenden Fragen

Analysieren Sie Ihre Tickets: Sie werden feststellen, dass 60 bis 80 % sich auf Folgendes beziehen:

• Wo ist meine Bestellung?
• Wie kann ich ein Produkt zurücksenden?
• Wie sind Ihre Öffnungszeiten?
• Wie ändere ich mein Abonnement?
• Passwort vergessen
• Standard-Zahlungsprobleme

Diese Fragen haben klare und dokumentierte Antworten. Warum sollten menschliche Agenten dafür eingesetzt werden?

RAG-Architektur für den Kundensupport

┌─────────────────────────────────────────────────────────────┐
│                    EINGANGSKANÄLE                            │
├──────────┬──────────┬──────────┬──────────┬────────────────┤
│  Widget  │  E-Mail  │  Chat    │  Slack   │   API          │
│   Web    │  Parser  │  Live    │   Bot    │   Extern       │
└────┬─────┴────┬─────┴────┬─────┴────┬─────┴───────┬────────┘
     │          │          │          │             │
     └──────────┴──────────┴──────────┴─────────────┘
                           │
                           ▼
              ┌─────────────────────────┐
              │   Classification        │
              │   Intent Detection      │
              └───────────┬─────────────┘
                          │
         ┌────────────────┼────────────────┐
         ▼                ▼                ▼
    ┌─────────┐     ┌─────────┐     ┌─────────┐
    │   RAG   │     │ Aktion  │     │Eskalation│
    │ Antwort │     │   API   │     │  Mensch │
    └────┬────┘     └────┬────┘     └────┬────┘
         │               │               │
         └───────────────┴───────────────┘
                         │
                         ▼
              ┌─────────────────────────┐
              │    Kundenantwort        │
              └─────────────────────────┘

Die drei Antwortmodi

1. Reine RAG-Antwort: Faktische Fragen, deren Antwort in der Wissensdatenbank steht.

2. API-Aktion: Anfragen, die eine Systemaktion erfordern (Bestellverfolgung, Kontoveränderung).

3. Menschliche Eskalation: Komplexe Fälle, Beschwerden, emotionale Situationen.

Aufbau der Support-Wissensdatenbank

Quellen zu indexieren

DEVELOPERpython
SUPPORT_SOURCES = {
    "faq": {
        "path": "/docs/faq",
        "priority": "high",
        "update_frequency": "daily"
    },
    "procedures": {
        "path": "/docs/procedures",
        "priority": "high",
        "update_frequency": "weekly"
    },
    "product_docs": {
        "path": "/docs/products",
        "priority": "medium",
        "update_frequency": "on_change"
    },
    "past_tickets": {
        "path": "/tickets/resolved",
        "priority": "medium",
        "update_frequency": "daily",
        "filter": "satisfaction >= 4"
    },
    "policies": {
        "path": "/docs/policies",
        "priority": "high",
        "update_frequency": "on_change"
    }
}

Optimale Struktur eines FAQ-Artikels

DEVELOPERmarkdown
# Wie kann ich ein Produkt zurücksenden?

## Kurze Antwort
Sie haben 30 Tage Zeit, um ein unbenutztes Produkt zurückzusenden.
Loggen Sie sich in Ihren Kundenbereich ein > Meine Bestellungen > Rücksendung anfordern.

## Bedingungen
- Unbenutztes Produkt, in der Originalverpackung
- Frist: 30 Tage nach Erhalt
- Ausnahmen: personalisierte Produkte, Hygieneartikel, Lebensmittel

## Detaillierte Vorgehensweise
1. Loggen Sie sich in Ihren Kundenbereich ein
2. Gehen Sie zu "Meine Bestellungen"
3. Wählen Sie die betreffende Bestellung aus
4. Klicken Sie auf "Rücksendung anfordern"
5. Wählen Sie die zurückzusendenden Artikel aus
6. Wählen Sie den Grund aus
7. Drucken Sie das frankierte Etikett aus

## Erstattungsfristen
- Bestätigung der Rücksendung: 2-3 Werktage nach Erhalt
- Erstattung: 5-7 Werktage auf das ursprüngliche Zahlungsmittel

## Verwandte Fragen
- [Wie kann ich meine Rücksendung verfolgen?](/faq/suivi-retour)
- [Wer trägt die Rücksendekosten?](/faq/frais-retour)
- [Kann ich statt einer Rücksendung tauschen?](/faq/echange)

---
Tags: Rücksendung, Erstattung, Umtausch, Retoure
Letzte Aktualisierung: 2024-01-15

Diese Struktur ermöglicht es dem RAG, die kurze Antwort schnell zu finden und gleichzeitig bei Bedarf auf die Details zuzugreifen.

Intent-Erkennung und Routing

Anfragen klassifizieren

DEVELOPERpython
from enum import Enum
from pydantic import BaseModel

class IntentType(Enum):
    INFORMATION = "information"      # RAG-Antwort
    TRANSACTION = "transaction"      # API-Aktion
    COMPLAINT = "complaint"          # Prioritäre Eskalation
    TECHNICAL = "technical"          # Technischer Support
    URGENT = "urgent"                # Sofortige Eskalation

class IntentClassifier:
    def __init__(self, llm):
        self.llm = llm

    async def classify(self, message: str, context: dict = None) -> dict:
        prompt = f"""
        Analysiere diese Kundennachricht und bestimme:
        1. Die Hauptabsicht (information, transaction, complaint, technical, urgent)
        2. Die Prioritätsstufe (low, medium, high, critical)
        3. Die erkannte Emotion (neutral, frustrated, angry, satisfied)
        4. Die extrahierten Entitäten (Bestellnummer, Produkt, Datum usw.)

        Nachricht: {message}
        Kundenkontext: {context}

        Antworte im JSON-Format.
        """

        response = await self.llm.generate(prompt, temperature=0)
        return self._parse_classification(response)

    def _parse_classification(self, response: str) -> dict:
        # JSON-Antwort parsen und validieren
        import json
        try:
            return json.loads(response)
        except:
            return {
                "intent": IntentType.INFORMATION,
                "priority": "medium",
                "emotion": "neutral",
                "entities": {}
            }

Intelligentes Routing

DEVELOPERpython
class SupportRouter:
    def __init__(self, rag_service, action_service, escalation_service):
        self.rag = rag_service
        self.actions = action_service
        self.escalation = escalation_service

    async def route(self, message: str, classification: dict) -> dict:
        intent = classification["intent"]
        priority = classification["priority"]
        emotion = classification["emotion"]

        # Sofortige Eskalation bei kritischen Fällen
        if priority == "critical" or emotion == "angry":
            return await self.escalation.create_ticket(
                message=message,
                classification=classification,
                priority="high"
            )

        # Beschwerden: immer eskalieren
        if intent == IntentType.COMPLAINT:
            return await self.escalation.create_ticket(
                message=message,
                classification=classification,
                priority="medium"
            )

        # Transaktionen: prüfen, ob eine Aktion möglich ist
        if intent == IntentType.TRANSACTION:
            action_result = await self.actions.try_action(
                message=message,
                entities=classification.get("entities", {})
            )
            if action_result["success"]:
                return action_result
            # Andernfalls Fallback auf RAG

        # Standardmäßig: RAG-Antwort
        return await self.rag.answer(
            query=message,
            context=classification
        )

Personalisierung der Antworten

An das Kundenprofil anpassen

DEVELOPERpython
class PersonalizedResponder:
    def __init__(self, llm, customer_service):
        self.llm = llm
        self.customers = customer_service

    async def generate_response(
        self,
        query: str,
        rag_context: str,
        customer_id: str
    ) -> str:
        # Kundenprofil abrufen
        profile = await self.customers.get_profile(customer_id)

        # Ton und Detaillierungsgrad anpassen
        tone = self._determine_tone(profile)

        prompt = f"""
        Du bist ein Support-Assistent von [Unternehmen].

        KUNDENPROFIL:
        - Zugehörigkeit: {profile.get('tenure', 'neu')}
        - Wert: {profile.get('value_segment', 'standard')}
        - Historie: {profile.get('ticket_count', 0)} vorherige Tickets
        - Bevorzugte Sprache: {profile.get('language', 'de')}

        ANZUWENDENDER TON: {tone}

        RELEVANTE DOKUMENTATION:
        {rag_context}

        KUNDENFRAGE:
        {query}

        Generiere eine Antwort:
        - Direkt und umsetzbar
        - An das Kundenprofil angepasst
        - Mit nützlichen Links, falls relevant
        - Maximal 3 Absätze
        """

        return await self.llm.generate(prompt, temperature=0.3)

    def _determine_tone(self, profile: dict) -> str:
        if profile.get('value_segment') == 'vip':
            return "Erstklassig und aufmerksam, schlägt proaktiv Lösungen vor"
        elif profile.get('ticket_count', 0) > 10:
            return "Effizient und direkt, vermeidet einfache Erklärungen"
        elif profile.get('tenure') == 'nouveau':
            return "Freundlich und pädagogisch, erklärt die Schritte im Detail"
        return "Professionell und herzlich"

Verwaltung des Gesprächskontexts

DEVELOPERpython
class ConversationManager:
    def __init__(self, redis_client):
        self.redis = redis_client
        self.max_history = 10

    async def add_message(self, conversation_id: str, role: str, content: str):
        key = f"conversation:{conversation_id}"

        message = {
            "role": role,
            "content": content,
            "timestamp": datetime.now().isoformat()
        }

        await self.redis.rpush(key, json.dumps(message))
        await self.redis.ltrim(key, -self.max_history, -1)
        await self.redis.expire(key, 3600 * 24)  # 24h TTL

    async def get_context(self, conversation_id: str) -> list:
        key = f"conversation:{conversation_id}"
        messages = await self.redis.lrange(key, 0, -1)
        return [json.loads(m) for m in messages]

    async def build_prompt_context(self, conversation_id: str) -> str:
        history = await self.get_context(conversation_id)

        context_parts = []
        for msg in history[-5:]:  # Letzte 5 Nachrichten
            role = "Client" if msg["role"] == "user" else "Assistant"
            context_parts.append(f"{role}: {msg['content']}")

        return "\n".join(context_parts)

Metriken und kontinuierliche Verbesserung

Wesentliche KPIs

DEVELOPERpython
class SupportMetrics:
    def __init__(self, db):
        self.db = db

    def calculate_metrics(self, period_days: int = 30) -> dict:
        return {
            # Effizienz
            "deflection_rate": self._deflection_rate(period_days),
            "first_contact_resolution": self._fcr_rate(period_days),
            "avg_response_time": self._avg_response_time(period_days),

            # Qualität
            "csat_score": self._csat_score(period_days),
            "escalation_rate": self._escalation_rate(period_days),
            "reopen_rate": self._reopen_rate(period_days),

            # Volumen
            "total_conversations": self._total_conversations(period_days),
            "automated_responses": self._automated_count(period_days),
            "human_interventions": self._human_count(period_days),

            # Inhalt
            "top_intents": self._top_intents(period_days),
            "unanswered_queries": self._unanswered_queries(period_days),
            "knowledge_gaps": self._identify_gaps(period_days)
        }

    def _deflection_rate(self, days: int) -> float:
        """Anteil der durch KI vermiedenen Tickets"""
        query = """
        SELECT
            COUNT(CASE WHEN escalated = false THEN 1 END)::float /
            COUNT(*)::float * 100 as deflection_rate
        FROM support_conversations
        WHERE created_at > NOW() - INTERVAL '%s days'
        """
        result = self.db.execute(query, [days])
        return round(result[0]['deflection_rate'], 1)

    def _identify_gaps(self, days: int) -> list:
        """Identifiziert Fragen ohne gute Antwort"""
        query = """
        SELECT query, COUNT(*) as count, AVG(satisfaction) as avg_sat
        FROM support_conversations
        WHERE created_at > NOW() - INTERVAL '%s days'
        AND (satisfaction < 3 OR escalated = true)
        GROUP BY query
        HAVING COUNT(*) >= 3
        ORDER BY count DESC
        LIMIT 20
        """
        return self.db.execute(query, [days])

Verbesserungsschleife

DEVELOPERpython
class KnowledgeImprover:
    def __init__(self, metrics, kb_service, llm):
        self.metrics = metrics
        self.kb = kb_service
        self.llm = llm

    async def weekly_improvement(self):
        # 1. Lücken identifizieren
        gaps = self.metrics._identify_gaps(days=7)

        # 2. Für jede bedeutende Lücke
        for gap in gaps[:10]:
            # Fehlgeschlagene Konversationen analysieren
            failed_convs = await self._get_failed_conversations(gap['query'])

            # Vorschlag für einen Artikel generieren
            suggestion = await self._generate_article_suggestion(
                query=gap['query'],
                conversations=failed_convs
            )

            # Ein Ticket für das Content-Team erstellen
            await self._create_content_ticket(suggestion)

        # 3. Veraltete Artikel identifizieren
        outdated = await self._find_outdated_articles()
        for article in outdated:
            await self._create_review_ticket(article)

    async def _generate_article_suggestion(
        self,
        query: str,
        conversations: list
    ) -> dict:
        prompt = f"""
        Analysiere diese gescheiterten Support-Konversationen:

        Wiederkehrende Frage: {query}

        Konversationen:
        {json.dumps(conversations, indent=2)}

        Generiere einen Vorschlag für einen FAQ-Artikel, der diese Frage beantwortet.
        Enthalte: Titel, kurze Antwort, ausführliche Antwort, Tags.
        """

        return await self.llm.generate(prompt, temperature=0.5)

Integration mit bestehenden Tools

CRM-Anbindung (Salesforce, Hubspot)

DEVELOPERpython
class CRMIntegration:
    def __init__(self, crm_client):
        self.crm = crm_client

    async def enrich_context(self, customer_email: str) -> dict:
        """Kontext mit CRM-Daten anreichern"""
        customer = await self.crm.get_contact(email=customer_email)

        if not customer:
            return {}

        return {
            "customer_name": customer.get("name"),
            "company": customer.get("company"),
            "segment": customer.get("segment"),
            "lifetime_value": customer.get("ltv"),
            "open_opportunities": customer.get("open_opps"),
            "recent_purchases": customer.get("recent_orders", [])[:5],
            "support_history": customer.get("ticket_count"),
            "nps_score": customer.get("nps")
        }

    async def log_interaction(
        self,
        customer_email: str,
        interaction: dict
    ):
        """Interaktion im CRM protokollieren"""
        await self.crm.create_activity(
            contact_email=customer_email,
            type="support_chat",
            subject=interaction.get("intent"),
            description=interaction.get("summary"),
            outcome=interaction.get("resolution")
        )

Webhook für Eskalation

DEVELOPERpython
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

class EscalationRequest(BaseModel):
    conversation_id: str
    customer_email: str
    priority: str
    summary: str
    transcript: list

@app.post("/webhooks/escalate")
async def escalate_to_helpdesk(request: EscalationRequest):
    """Erstellt ein Ticket im Helpdesk (Zendesk, Freshdesk, etc.)"""

    ticket = {
        "subject": f"KI-Eskalation - {request.summary[:50]}",
        "description": format_transcript(request.transcript),
        "priority": map_priority(request.priority),
        "requester": {"email": request.customer_email},
        "custom_fields": {
            "ai_conversation_id": request.conversation_id,
            "ai_escalation_reason": request.summary
        }
    }

    result = await helpdesk_client.create_ticket(ticket)

    return {
        "ticket_id": result["id"],
        "ticket_url": result["url"]
    }

Anwendungsfälle nach Branche

E-Commerce

SaaS / B2B

Finanzdienstleistungen

Best Practices

1. KI-Transparenz

Geben Sie stets an, wenn der Kunde mit einer KI spricht, und bieten Sie die Möglichkeit, mit einem Menschen zu sprechen.

2. Reibungslose Eskalation

Lassen Sie einen Kunden nie in einer Sackgasse. Wenn die KI nicht helfen kann, sofort weiterleiten.

3. Feedback-Schleife

Sammeln Sie systematisch Feedback, um die Antworten zu verbessern.

4. Kontinuierliche Aktualisierung

Richtlinien ändern sich, Produkte entwickeln sich weiter. Aktualisieren Sie die KB kontinuierlich.

5. Test vor dem Rollout

Testen Sie jeden neuen Artikel mit echten Fragen, bevor Sie ihn in Produktion nehmen.

Weiterführende Links

• Intelligente Wissensdatenbank - Zentralisiertes Wissen
• Grundlagen des Retrieval - Suche optimieren
• DSGVO und Chatbots - Datenschutzkonformität für Kundendaten

Automatisieren Sie Ihren Support mit Ailog

Der Aufbau eines leistungsfähigen RAG-Supports erfordert eine robuste Infrastruktur und tiefgehende Expertise. Mit Ailog profitieren Sie von einer schlüsselfertigen Lösung:

• Widget, in 3 Minuten auf Ihrer Website integrierbar
• Native Konnektoren zu Ihren Quellen (FAQ, Docs, gelöste Tickets)
• Intent-Erkennung und automatisches Routing
• Nahtlose Eskalation an Ihr bestehendes Helpdesk
• Echtzeit-Analytics zur Messung der Deflection Rate
• Hosting in Frankreich, DSGVO-konform

Testen Sie Ailog kostenlos und reduzieren Sie Ihre Level-1-Tickets um 70 %.