RAG-Migration: Vom Legacy-Chatbot zum modernen KI-System (ohne alles kaputt zu machen)

TL;DR

Ihr Dialogflow/Watson/Custom-Chatbot stoesst an eine glaeserne Decke bei 40-60% Loesungsrate. Moderne RAG-Systeme erreichen 70-90%. Dieser Leitfaden begleitet Sie durch die Migration: Bestandsaufnahme, Datenextraktion, Parallelbetrieb und schrittweiser Umstieg. Typische Timeline: 4-8 Wochen. Das Geheimnis: Schalten Sie das alte System nie ab, bevor das neue seine Ueberlegenheit unter realen Bedingungen bewiesen hat.

Warum migrieren: Die glaeserne Decke der Legacy-Chatbots

Die Bestandsaufnahme

Intent-basierte Chatbots (Dialogflow, Watson Assistant, Rasa, Custom NLU) waren 2018-2022 revolutionaer. 2026 sind sie zum schwachen Glied in Ihrer Support-Kette geworden.

Die Grenzen von Intent-basierten Systemen

Nutzer: "Ich moechte die Lieferadresse meiner
         Bestellung von letzter Woche aendern"

LEGACY-CHATBOT (Intent-basiert):
├── Erkannter Intent: "adresse_aendern" (Konfidenz: 0,67)
├── Entities: adresse=null, bestellung=null
├── Antwort: "Um Ihre Adresse zu aendern, gehen Sie zu
│              Einstellungen > Lieferadresse"
└── Problem: versteht "Bestellung von letzter Woche" nicht

RAG-CHATBOT:
├── Versteht: Adressaenderung + spezifische Bestellung
├── Findet: Liefer-FAQ + Aenderungsbedingungen + Historie
├── Antwort: "Um die Lieferadresse einer bereits aufgegebenen
│              Bestellung zu aendern, kontaktieren Sie uns
│              innerhalb von 2h nach der Bestellung. Falls die
│              Frist abgelaufen ist, kann ich den Status pruefen.
│              Wie lautet Ihre Bestellnummer?"
└── Ergebnis: Kontextuelle Loesung, kein Skript

Zeichen, dass es Zeit fuer eine Migration ist

• Die Fallback-Rate uebersteigt 25% der Gespraeche
• Das Team verbringt mehr als 10 Stunden/Woche mit der Pflege von Intents
• Nutzer formulieren dieselbe Frage 3+ Mal um, ohne eine Antwort zu erhalten
• Ein neues Thema hinzuzufuegen dauert mehr als einen Tag
• Der Chatbot-CSAT liegt unter 3/5
• Sie haben ueber 300 Intents und es wird unuebersichtlich

Bestandsaufnahme des bestehenden Systems: Der erste Schritt

Vollstaendiges Inventar

DEVELOPERpython
class LegacyChatbotAudit:
    """
    Vollstaendige Pruefung des Legacy-Chatbots vor der Migration.
    """

    def __init__(self, platform: str):
        self.platform = platform  # dialogflow, watson, rasa, custom

    def audit_intents(self):
        """Inventar der Intents und ihrer Nutzung."""
        return {
            "total_intents": 342,
            "active_intents": 218,        # > 1 Mal/Monat genutzt
            "dormant_intents": 89,         # Seit 6 Monaten nicht genutzt
            "broken_intents": 35,          # Konfidenz < 0,5
            "top_20_intents_coverage": 0.73  # 20 Intents = 73% des Traffics
        }

    def audit_training_data(self):
        """Analyse der Trainingsdaten."""
        return {
            "total_utterances": 15420,
            "avg_utterances_per_intent": 45,
            "languages": ["de", "en"],
            "quality_score": 0.62,         # Viele Duplikate
            "exportable": True              # Als CSV exportierbar
        }

    def audit_conversations(self):
        """Analyse der realen Gespraeche."""
        return {
            "monthly_conversations": 8500,
            "avg_turns": 4.2,
            "resolution_rate": 0.47,       # 47% Loesung
            "fallback_rate": 0.28,         # 28% Fallback
            "escalation_rate": 0.25,       # 25% Eskalation an Mensch
            "csat_score": 2.8              # Von 5
        }

    def audit_integrations(self):
        """Inventar der bestehenden Integrationen."""
        return {
            "channels": ["website_widget", "facebook_messenger"],
            "crm": "salesforce",
            "ticketing": "zendesk",
            "analytics": "google_analytics",
            "webhooks": 12,
            "custom_apis": 5
        }

Entscheidungsmatrix: Was wird migriert?

6-Stufen-Migrationsplan

Stufe 1: Datenextraktion (Woche 1)

DEVELOPERpython
# Export aus Dialogflow
def export_dialogflow_intents(project_id: str):
    """
    Exportiert alle Dialogflow-Intents in strukturiertem Format.
    """
    from google.cloud import dialogflow_v2

    client = dialogflow_v2.IntentsClient()
    parent = f"projects/{project_id}/agent"

    intents = []
    for intent in client.list_intents(request={"parent": parent}):
        intents.append({
            "name": intent.display_name,
            "training_phrases": [
                tp.parts[0].text
                for tp in intent.training_phrases
            ],
            "responses": [
                msg.text.text[0]
                for msg in intent.messages
            ],
            "parameters": [
                {"name": p.display_name, "entity": p.entity_type_display_name}
                for p in intent.parameters
            ]
        })

    return intents


# Export aus Watson Assistant
def export_watson_intents(workspace_id: str, api_key: str):
    """
    Exportiert alle Watson-Intents in strukturiertem Format.
    """
    from ibm_watson import AssistantV1

    assistant = AssistantV1(
        version="2024-08-14",
        iam_apikey=api_key,
        url="https://api.eu-de.assistant.watson.cloud.ibm.com"
    )

    response = assistant.list_intents(
        workspace_id=workspace_id,
        export=True
    ).get_result()

    return [{
        "name": intent["intent"],
        "examples": [ex["text"] for ex in intent.get("examples", [])],
        "description": intent.get("description", "")
    } for intent in response["intents"]]

Stufe 2: Knowledge Base aufbauen (Woche 2)

Wandeln Sie Ihre Intents in strukturierte Dokumente um:

DEVELOPERpython
def intents_to_knowledge_base(intents: list) -> list:
    """
    Konvertiert Legacy-Intents in Dokumente
    fuer die RAG Knowledge Base.
    """
    documents = []

    for intent in intents:
        doc = {
            "title": intent["name"].replace("_", " ").title(),
            "content": intent["responses"][0] if intent["responses"] else "",
            "metadata": {
                "source": "legacy_chatbot",
                "original_intent": intent["name"],
                "variant_questions": intent["training_phrases"][:10],
                "category": extract_category(intent["name"])
            }
        }
        documents.append(doc)

    return documents


# Upload zu Ailog
from ailog import AilogClient

client = AilogClient(api_key="ihr-api-schluessel")

for doc in documents:
    client.knowledge_base.add_document(
        title=doc["title"],
        content=doc["content"],
        metadata=doc["metadata"]
    )

# Bestehende Quellen hinzufuegen
client.knowledge_base.add_source(
    source_type="zendesk",
    url="https://ihr-help-center.zendesk.com",
    sync_frequency="daily"
)

Stufe 3: Konfiguration und Test (Woche 3)

DEVELOPERpython
def run_regression_test(legacy_questions: list, rag_client):
    """
    Vergleicht RAG-Antworten mit Legacy-Antworten.
    """
    results = {
        "rag_better": 0,
        "rag_equal": 0,
        "rag_worse": 0,
        "rag_only": 0  # Fragen ohne Legacy-Antwort
    }

    for q in legacy_questions:
        rag_response = rag_client.chat(q["question"])

        if q["legacy_answered"]:
            similarity = compute_similarity(
                rag_response.answer,
                q["legacy_response"]
            )
            relevance = rag_response.confidence

            if relevance > 0.8 and similarity > 0.6:
                results["rag_equal"] += 1
            elif relevance > 0.85:
                results["rag_better"] += 1
            else:
                results["rag_worse"] += 1
        else:
            if rag_response.confidence > 0.7:
                results["rag_only"] += 1

    return results

Stufe 4: Parallelbetrieb (Woche 4-5)

Der Parallelbetrieb ist der Schluessel zu einer risikofreien Migration:

┌─────────────────────────────────────┐
│           LOAD BALANCER              │
│                                      │
│   ┌─────────┐    ┌─────────┐        │
│   │ Legacy  │    │   RAG   │        │
│   │ Chatbot │    │ Chatbot │        │
│   └────┬────┘    └────┬────┘        │
│        │              │              │
│   Woche 4:       Woche 4:           │
│   90% Traffic    10% Traffic         │
│                                      │
│   Woche 5:       Woche 5:           │
│   50% Traffic    50% Traffic         │
│                                      │
│   Woche 6:       Woche 6:           │
│   10% Traffic    90% Traffic         │
│                                      │
│   Woche 7:       Woche 7:           │
│   0% (Backup)    100% Traffic        │
└─────────────────────────────────────┘

Stufe 5: Monitoring und Anpassung (Woche 5-6)

Stufe 6: Umstieg und Stilllegung (Woche 7-8)

DEVELOPERpython
# Pre-Cutover-Checkliste
cutover_checklist = {
    "leistung": {
        "loesungsrate_rag_hoeher": True,      # RAG > Legacy
        "csat_rag_hoeher": True,               # Hoehere Zufriedenheit
        "latenz_akzeptabel": True,              # p95 < 3s
        "keine_kritische_regression": True      # Keine krit. Regression
    },
    "integrationen": {
        "crm_verbunden": True,                 # CRM funktioniert
        "ticketing_verbunden": True,            # Ticketing funktioniert
        "analytics_verbunden": True,            # Analytics vorhanden
        "eskalationspfad_getestet": True        # Eskalation getestet
    },
    "operativ": {
        "team_geschult": True,                  # Team geschult
        "runbook_dokumentiert": True,           # Verfahren dokumentiert
        "rollback_plan_getestet": True,         # Rollback-Plan getestet
        "monitoring_alerts_gesetzt": True       # Alerts konfiguriert
    },
    "rechtlich": {
        "datenmigration_konform": True,         # DSGVO-konform
        "legacy_aufbewahrungsplan": True,       # Legacy-Retention
        "datenschutzerklaerung_aktualisiert": True  # Erklaerung aktuell
    }
}

all_checks_passed = all(
    all(checks.values())
    for checks in cutover_checklist.values()
)

if all_checks_passed:
    print("GO fuer den Umstieg!")
else:
    print("STOP - Blockierende Punkte loesen")

Typische Migrations-Timeline

Vergleich: Legacy-Chatbot vs. RAG-Chatbot

Risikomanagement

Risiken und Massnahmen

Rollback-Plan

Halten Sie das Legacy-System mindestens 4 Wochen nach dem Umstieg betriebsbereit:

DEVELOPERpython
ROLLBACK_CONFIG = {
    "legacy_system_status": "standby",      # Bereit zur Wiederaufnahme
    "traffic_switch_time": "< 5 Minuten",   # Umschaltzeit
    "data_sync": "bidirectional",            # Gespraechssynchronisation
    "trigger_conditions": {
        "error_rate_above": 0.10,            # > 10% Fehler
        "csat_below": 3.0,                   # CSAT < 3/5
        "resolution_below": 0.40,            # Loesung < 40%
        "latency_p95_above": 5000            # p95 > 5s
    }
}

FAQ

Wie lange dauert eine vollstaendige Migration?

Rechnen Sie mit 4 bis 8 Wochen fuer eine typische Migration. Verlaengernde Faktoren: Anzahl der Intents (> 500), komplexe Integrationen (Custom Webhooks), hohes Volumen (> 50K Gespraeche/Monat), Mehrsprachigkeit (> 3 Sprachen). Mit einer Loesung wie Ailog wird die Setup-Phase dank nativer Konnektoren auf wenige Tage reduziert.

Kann man eine schrittweise Migration ohne Ausfallzeit durchfuehren?

Absolut. Es ist sogar die empfohlene Methode. Der Parallelbetrieb (Shadow Mode oder Split Traffic) ermoeglicht den Systemvergleich unter realen Bedingungen, ohne die Nutzer zu beeintraechtigen. Beginnen Sie mit 10% des Traffics auf RAG und steigern Sie schrittweise. Das Legacy-System bleibt waehrend der gesamten Transition als Backup aktiv.

Was machen wir mit den Trainingsdaten des Legacy-Systems?

Trainingsdaten (Utterances, Intents, Entities) sind wertvoll fuer Tests. Verwenden Sie sie als Testset, um zu validieren, dass RAG historische Fragen korrekt beantwortet. Geskriptete Antworten koennen in FAQ-Dokumente fuer die Knowledge Base umgewandelt werden. Loeschen Sie sie nie vor der Validierung. Lesen Sie unseren Leitfaden zu Chunking-Strategien fuer optimierten Import.

Kann RAG komplexe Entscheidungsbaeume verarbeiten?

Ja, aber anders. Entscheidungsbaeume (Diagnose, Produktkonfiguration) werden in strukturierte Dokumente umgewandelt, die RAG zur Gespraechsfuehrung nutzt. Fuer sehr starre Workflows (Rueckgabeprozesse, Eskalation) kombinieren Sie RAG mit Geschaeftsregeln. Die RAG-Agenten-Orchestrierung behandelt dieses Thema ausfuehrlich.

Was kostet eine Migration zu RAG?

Die Hauptkosten sind der Zeitaufwand fuer Audit und Konfiguration. Mit Ailog liegen die Softwarekosten bei 49-299 EUR/Monat je nach Volumen. Vergleichen Sie mit den Wartungskosten Ihres Legacy-Systems (10-20h/Woche eines Entwicklers). Die Migration amortisiert sich typischerweise in 2-3 Monaten durch reduzierte Wartung und verbesserte Loesungsrate.

---

Die Migration von einem Legacy-Chatbot zu einem RAG-System ist kein technologisches Wagnis -- sie ist eine wirtschaftliche Selbstverstaendlichkeit. Intent-basierte Chatbots haben ihre Zeit gehabt. RAG bietet bessere Qualitaet, weniger Wartung und muehelose Skalierbarkeit.

Bereit fuer den Umstieg? Testen Sie Ailog kostenlos und erleben Sie den Unterschied zu Ihrem aktuellen Chatbot.