KI Chatbot Kundenservice: 60% weniger Tickets + €84k gespart [Setup 2025]

KI_Chatbot_Architektur:
  Frontend:
    - Widget: Intercom/Drift Alternative (Open Source)
    - Kanäle: Website, WhatsApp Business, E-Mail
    - Design: Markenkonform, Mobile-Optimiert
  
  Backend (RAG-Pipeline):
    Embedding-Generation:
      - Model: text-embedding-ada-002 (OpenAI)
      - Quellen: FAQ, Produktkataloge, Versandinfos, Retouren
      - Dokumente: 1.240 Seiten indexiert
      - Update: Täglich automatisch
    
    Vector-Database:
      - Technologie: Weaviate (Self-Hosted)
      - Similarity Search: Cosine
      - Response-Time: \\<200ms
    
    LLM (Response-Generation):
      - Model: GPT-4-Turbo (Azure OpenAI EU)
      - Temperature: 0.3 (konsistente Antworten)
      - Max Tokens: 300
      - Fallback: Vorgegebene Antworten
    
    Integration:
      - CRM: Salesforce API
      - E-Commerce: Shopify Webhooks
      - Ticketing: Zendesk (für Eskalation)
      - Analytics: Custom Dashboard (Grafana)

  Kosten:
    - Azure OpenAI: €180/Mt
    - Weaviate Hosting: €45/Mt
    - Widget-Lizenz: €79/Mt (Open Source Alternative: €0)
    - Total: **€304/Mt = €3.648/Jahr**

# Produktions-Ready RAG-Chatbot

from openai import AzureOpenAI
import weaviate
from typing import List, Dict

class CustomerServiceChatbot:
    def __init__(self, config):
        # Azure OpenAI Setup (EU-Region)
        self.llm = AzureOpenAI(
            api_key=config['azure_openai_key'],
            api_version="2024-02-01",
            azure_endpoint=config['azure_endpoint']
        )
        
        # Vector DB Setup
        self.vector_db = weaviate.Client(url=config['weaviate_url'])
        
        # CRM/E-Commerce Connector
        self.crm = SalesforceConnector()
        self.shop = ShopifyConnector()
        
    def answer_customer_query(self, query: str, customer_id: str = None):
        """
        Beantwortet Kundenanfrage mit RAG
        """
        # 1. Kundenkontext laden (falls bekannt)
        customer_context = self.crm.get_customer_context(customer_id) if customer_id else {}
        
        # 2. Query Embedding erstellen
        query_embedding = self.llm.embeddings.create(
            input=query,
            model="text-embedding-ada-002"
        ).data[0].embedding
        
        # 3. Relevante Dokumente suchen (Vector Search)
        relevant_docs = self.vector_db.query.get(
            "KnowledgeBase",
            ["content", "source", "category"]
        ).with_near_vector({
            "vector": query_embedding,
            "certainty": 0.7
        }).with_limit(5).do()
        
        # 4. Kontext zusammenstellen
        context = "\n\n".join([
            doc['content'] for doc in relevant_docs['data']['Get']['KnowledgeBase']
        ])
        
        # 5. LLM-Antwort generieren
        prompt = f"""Du bist ein freundlicher Kundenservice-Assistent.

Kundenkontext:
{self._format_customer_context(customer_context)}

Wissensbasis:
{context}

Kundenanfrage: {query}

Antworte präzise, freundlich und basierend auf der Wissensbasis.
Falls du die Antwort nicht weißt, empfehle dem Kunden, den menschlichen Support zu kontaktieren.
"""

        response = self.llm.chat.completions.create(
            model="gpt-4-turbo",
            messages=[
                {"role": "system", "content": "Du bist ein professioneller Kundenservice-Assistent für einen deutschen Online-Händler."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.3,
            max_tokens=300
        )
        
        answer = response.choices[0].message.content
        
        # 6. Intent-Erkennung für Eskalation
        needs_human = self._check_escalation_needed(query, answer, customer_context)
        
        # 7. Logging & Analytics
        self._log_interaction(query, answer, relevant_docs, needs_human)
        
        return {
            'answer': answer,
            'confidence': relevant_docs['data']['Get']['KnowledgeBase'][0].get('_additional', {}).get('certainty', 0.0),
            'sources': [doc['source'] for doc in relevant_docs['data']['Get']['KnowledgeBase']],
            'escalate_to_human': needs_human
        }
    
    def _check_escalation_needed(self, query: str, answer: str, context: Dict) -> bool:
        """
        Entscheidet, ob menschlicher Agent nötig ist
        """
        escalation_keywords = ['beschwerde', 'reklamation', 'anwalt', 'unzufrieden', 'katastrophe']
        
        # Keyword-basierte Eskalation
        if any(kw in query.lower() for kw in escalation_keywords):
            return True
        
        # Sentiment-basierte Eskalation
        sentiment_score = self._analyze_sentiment(query)
        if sentiment_score < 0.3:  # Sehr negativ
            return True
        
        # Komplexe Anfrage (z.B. individuelle Rückerstattung)
        if context.get('order_total', 0) > 500 and 'rückerstattung' in query.lower():
            return True
        
        return False
    
    def _analyze_sentiment(self, text: str) -> float:
        """
        Sentiment-Analyse für Eskalations-Entscheidungen
        """
        # In Produktion: Azure Sentiment Analysis oder Custom Model
        # Placeholder: Einfache Keyword-basierte Analyse
        negative_words = ['enttäuscht', 'ärgerlich', 'katastrophe', 'unmöglich']
        positive_words = ['super', 'toll', 'danke', 'perfekt']
        
        score = 0.5  # Neutral
        for word in negative_words:
            if word in text.lower():
                score -= 0.1
        for word in positive_words:
            if word in text.lower():
                score += 0.1
        
        return max(0.0, min(1.0, score))

# Deployment
chatbot = CustomerServiceChatbot(config)

# Beispiel-Nutzung
result = chatbot.answer_customer_query(
    query="Wo ist meine Bestellung? Bestellnummer: 12345",
    customer_id="cust_abc123"
)

print(f"Antwort: {result['answer']}")
print(f"Confidence: {result['confidence']:.2%}")
print(f"Eskalation nötig: {result['escalate_to_human']}")

Multi_Channel_Integration:
  WhatsApp_Business:
    - Opt-In beim Checkout
    - Versandbenachrichtigungen + Chat
    - User: 4.200 aktiv
  
  E-Mail_Chatbot:
    - Automatische Antwort auf Support-Mails
    - Intent-Erkennung → Ticket oder Auto-Response
    - Erfolgsquote: 52% automatisch gelöst
  
  Proaktive_Kommunikation:
    - Trigger: Warenkorb-Abbruch (>€50)
    - Aktion: "Kann ich Fragen zur Bestellung beantworten?"
    - Conversion-Lift: +12% bei Antwort

Eskalations-Workflow:
  Automatische_Weiterleitung:
    - Bei komplexen Fragen
    - Bei negativem Sentiment (\<0.3)
    - Bei hohem Bestellwert (>€500) + Reklamation
  
  Human-Handoff:
    - Chatbot bereitet Zusammenfassung vor
    - Agent erhält: Query, Kontext, vorgeschlagene Lösung
    - Agent-Übernahme in \<30 Sek

<!-- DSGVO-konforme Chat-Einverständnis -->
<div class="chatbot-consent">
  <p>
    Unser KI-Chatbot nutzt Ihre Daten zur Bearbeitung Ihrer Anfrage.
    Alle Daten bleiben in der EU (Azure West Europe).
    <a href="/datenschutz-chatbot">Mehr erfahren</a>
  </p>
  <button onclick="acceptChat()">✓ Chat starten</button>
</div>