KI-Kundensupport : Reduzieren Sie Tickets mit dem RAG

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

┌─────────────────────────────────────────────────────────────┐
│                    CANAUX D'ENTREE                          │
├──────────┬──────────┬──────────┬──────────┬────────────────┤
│  Widget  │  Email   │  Chat    │  Slack   │   API          │
│   Web    │  Parser  │  Live    │   Bot    │   Externe      │
└────┬─────┴────┬─────┴────┬─────┴────┬─────┴───────┬────────┘
     │          │          │          │             │
     └──────────┴──────────┴──────────┴─────────────┘
                           │
                           ▼
              ┌─────────────────────────┐
              │   Classification        │
              │   Intent Detection      │
              └───────────┬─────────────┘
                          │
         ┌────────────────┼────────────────┐
         ▼                ▼                ▼
    ┌─────────┐     ┌─────────┐     ┌─────────┐
    │   RAG   │     │  Action │     │ Escalade│
    │ Reponse │     │   API   │     │  Humain │
    └────┬────┘     └────┬────┘     └────┬────┘
         │               │               │
         └───────────────┴───────────────┘
                         │
                         ▼
              ┌─────────────────────────┐
              │    Reponse Client       │
              └─────────────────────────┘

Die drei Antwortmodi

1. Reponse RAG pure : Faktische Fragen, deren Antwort in der Wissensdatenbank steht.

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

3. Escalade humaine : 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
# Comment retourner un produit ?

## Reponse courte
Vous avez 30 jours pour retourner un produit non utilise.
Connectez-vous a votre espace client > Mes commandes > Demander un retour.

## Conditions
- Produit non utilise, dans son emballage d'origine
- Delai : 30 jours apres reception
- Exceptions : produits personnalises, hygiene, alimentaire

## Procedure detaillee
1. Connectez-vous a votre espace client
2. Allez dans "Mes commandes"
3. Selectionnez la commande concernee
4. Cliquez sur "Demander un retour"
5. Selectionnez les articles a retourner
6. Choisissez le motif
7. Imprimez l'etiquette prepayee

## Delais de remboursement
- Validation retour : 2-3 jours ouvres apres reception
- Remboursement : 5-7 jours ouvres sur le moyen de paiement original

## Questions connexes
- [Comment suivre mon retour ?](/faq/suivi-retour)
- [Qui paie les frais de retour ?](/faq/frais-retour)
- [Puis-je echanger au lieu de retourner ?](/faq/echange)

---
Tags: retour, remboursement, echange, renvoi, renvoyer
Derniere mise a jour: 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"""
        Analyse ce message client et determine :
        1. L'intention principale (information, transaction, complaint, technical, urgent)
        2. Le niveau de priorite (low, medium, high, critical)
        3. L'emotion detectee (neutral, frustrated, angry, satisfied)
        4. Les entites extraites (numero commande, produit, date, etc.)

        Message : {message}
        Contexte client : {context}

        Reponds en JSON.
        """

        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"""
        Tu es un assistant support de [Entreprise].

        PROFIL CLIENT :
        - Anciennete : {profile.get('tenure', 'nouveau')}
        - Valeur : {profile.get('value_segment', 'standard')}
        - Historique : {profile.get('ticket_count', 0)} tickets precedents
        - Langue preferee : {profile.get('language', 'fr')}

        TON A ADOPTER : {tone}

        DOCUMENTATION PERTINENTE :
        {rag_context}

        QUESTION CLIENT :
        {query}

        Genere une reponse :
        - Directe et actionnable
        - Adaptee au profil client
        - Avec les liens utiles si pertinent
        - Maximum 3 paragraphes
        """

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

    def _determine_tone(self, profile: dict) -> str:
        if profile.get('value_segment') == 'vip':
            return "Premium et attentionne, propose des solutions proactives"
        elif profile.get('ticket_count', 0) > 10:
            return "Efficace et direct, evite les explications basiques"
        elif profile.get('tenure') == 'nouveau':
            return "Accueillant et pedagogique, explique les etapes en detail"
        return "Professionnel et chaleureux"

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"""
        Analyse ces conversations de support qui ont echoue :

        Question recurrente : {query}

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

        Genere une suggestion d'article FAQ qui repondrait a cette question.
        Inclus : titre, reponse courte, reponse detaillee, 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"Escalade IA - {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

• Base de connaissances intelligente - Zentralisiertes Wissen
• Fondamentaux du Retrieval - Suche optimieren
• RGPD et 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 integrable en 3 minutes sur votre site
• Connecteurs natifs vers vos sources (FAQ, docs, tickets resolus)
• Detection d'intention et routage automatique
• Escalade seamless vers votre helpdesk existant
• Analytics temps reel pour mesurer le deflection rate
• Hebergement France conforme RGPD

Testez Ailog gratuitement et reduisez vos tickets niveau 1 de 70%.