Zoho Desk, OpenAI API und Flow: KI-gestützte Ticketautomation mit Self-Check

Intelligente Ticket-Automatisierung in Zoho: Ein KI-System mit Selbstkontrolle bauen

Die Automatisierung von Geschäftsprozessen ist kein neues Thema. Doch oft stoßen starre Wenn-Dann-Regeln an ihre Grenzen, insbesondere im Kundenservice. Eingehende Anfragen sind selten schwarz-weiß und erfordern Kontextverständnis. Hier kommt Künstliche Intelligenz (KI) ins Spiel. Doch was passiert, wenn die KI sich unsicher ist? Die Lösung ist nicht, die Automatisierung abzuschalten, sondern sie intelligenter zu machen. In diesem Fachartikel zeigen wir dir, wie du mit Zoho-Mitteln und externen APIs ein System zur Ticket-Kategorisierung aufbaust, das seine eigenen Grenzen kennt. Es sortiert E-Mails und Anfragen zuverlässig vor und leitet unklare Fälle gezielt zur manuellen Prüfung weiter – ein lernendes System, das Effizienz und Qualität vereint.

Das Praxisbeispiel: Der überflutete Support-Eingang

Stell dir ein wachsendes B2B-Unternehmen im Bereich der Leistungselektronik oder ein E-Commerce-Portal vor. Täglich treffen hunderte E-Mails im zentralen Posteingang von Zoho Desk ein. Darunter sind:

Technische Supportanfragen von Bestandskunden.
Vertriebsanfragen von neuen Interessenten.
Rechnungen von Lieferanten.
Terminanfragen für Beratungsgespräche.
Irrelevante Newsletter und Spam.

Die manuelle Sichtung und Zuweisung dieser Tickets an die richtigen Teams oder Agenten kostet wertvolle Zeit und ist fehleranfällig. Eine falsche Zuweisung führt zu Verzögerungen und Frustration beim Kunden. Das Ziel ist es, diesen Prozess zu 90 % zu automatisieren, aber die restlichen 10 % der komplexen oder unklaren Fälle sicher zu erkennen und einem Menschen zur Entscheidung vorzulegen.

Schritt-für-Schritt: Dein selbstregulierendes KI-System in Zoho Desk

Wir bauen dieses System direkt in Zoho Desk mithilfe einer Custom Function, die durch eine Workflow-Regel bei jeder Ticketerstellung ausgelöst wird. Als „Gehirn“ nutzen wir eine externe KI-API, beispielsweise von OpenAI (GPT-Modelle), Cohere oder ein selbst gehostetes Open-Source-Modell.

Schritt 1: Die Workflow-Regel in Zoho Desk anlegen

Navigiere in den Einstellungen von Zoho Desk zu Automatisierung → Workflow-Regeln. Erstelle eine neue Regel für das Modul „Tickets“.

Wann? Wähle „Bei Erstellung“.
Bedingung? Lege fest, für welche Tickets die Regel gelten soll, z.B. für Tickets, deren Kategorie leer ist.
Aktion? Wähle „Benutzerdefinierte Funktionen“ und erstelle eine neue Funktion.

Schritt 2: Die Deluge Custom Function – Das Herzstück der Logik

Die Custom Function, geschrieben in der Zoho-eigenen Skriptsprache Deluge, führt die eigentliche Arbeit aus. Sie holt die Ticketdaten, ruft die KI-API auf und verarbeitet die Antwort.

Zuerst definieren wir die Argumente. Die Funktion benötigt die ID des Tickets, um darauf zugreifen zu können. Nennen wir das Argument ticketId.

// Argument: ticketId (Long)
// Holt die relevanten Ticketdetails
ticketDetails = zoho.desk.getById(ticketId, "tickets");
ticketSubject = ticketDetails.get("subject");
ticketDescription = ticketDetails.get("description");

// Begrenze die Textlänge, um API-Limits und Kosten zu schonen
// Viele Modelle haben ein Token-Limit. 5000 Zeichen sind ein guter Startwert.
contextText = ticketSubject + " n " + ticketDescription;
if(contextText.length() > 5000)
{
	contextText = contextText.substring(0, 5000);
}

// Hier folgt der API-Aufruf...

Schritt 3: Der API-Aufruf an das KI-Modell

Der entscheidende Teil ist der Prompt, also die Anweisung an die KI. Wir wollen nicht nur eine Kategorie, sondern auch eine prozentuale Einschätzung, wie sicher sich die KI bei ihrer Entscheidung ist. Das Ergebnis soll im JSON-Format zurückgegeben werden, damit wir es leicht verarbeiten können.

Ein guter Prompt könnte so aussehen:

string prompt = "Analysiere den folgenden Support-Ticket-Text und kategorisiere ihn. Gib deine Antwort ausschließlich als JSON-Objekt mit den Schlüsseln 'category' und 'confidence_score' zurück. Der confidence_score soll ein Wert zwischen 0 und 100 sein, der deine Sicherheit bei der Kategorisierung widerspiegelt. Die möglichen Kategorien sind: 'Vertrieb', 'Technischer Support', 'Buchhaltung', 'Allgemein', 'Spam'.nnTicket-Text:n" + contextText;

Nun rufen wir die API auf. Hier als Beispiel ein Aufruf an eine fiktive KI-API. Den API-Schlüssel solltest du sicher in einer „Connection“ in Zoho speichern, anstatt ihn direkt in den Code zu schreiben.

// API-Aufruf vorbereiten
api_url = "https://api.external-ai-provider.com/v1/categorize";
headers = Map();
headers.put("Authorization","Bearer Dein-API-Schlüssel-hier");
headers.put("Content-Type","application/json");

body = Map();
body.put("prompt", prompt);
body.put("model", "text-categorizer-v2");

// API aufrufen
apiResponse = invokeurl
[
	url :api_url
	type :POST
	headers:headers
	parameters:body.toString()
];

// Antwort verarbeiten
info "API Response: " + apiResponse;

Schritt 4: Den Konfidenz-Schwellenwert implementieren

Die KI antwortet idealerweise mit einem JSON-Objekt wie diesem:

{"category": "Technischer Support", "confidence_score": 95}

Oder bei einer unsicheren Anfrage:

{"category": "Allgemein", "confidence_score": 60}

Diese Antwort parsen wir und wenden unsere Kernlogik an. Wir definieren einen Schwellenwert (Threshold), zum Beispiel 70%. Liegt der Wert der KI darunter, weisen wir eine spezielle Kategorie zu, die wir „Manuelle Prüfung“ nennen.

// Schwellenwert als Variable definieren, um ihn leicht anpassen zu können
threshold = 70;
humanReviewCategory = "Manuelle Prüfung";

try 
{
    // JSON-Antwort parsen
    jsonResponse = apiResponse.toJSON();
    aiCategory = jsonResponse.get("category");
    confidence = jsonResponse.get("confidence_score").toDecimal();

    updateMap = Map();

    // Logik des Schwellenwerts
    if (confidence >= threshold)
    {
        // KI ist sicher genug -> Kategorie setzen
        updateMap.put("category", aiCategory);
    }
    else
    {
        // KI ist unsicher -> Zur manuellen Prüfung aussteuern
        updateMap.put("category", humanReviewCategory);
    }
    
    // Ticket in Zoho Desk aktualisieren
    updateResponse = zoho.desk.update(ticketId, "tickets", updateMap);
    info "Ticket " + ticketId + " updated: " + updateResponse;
}
catch (e)
{
    // Fehlerbehandlung, falls die API nicht erreichbar ist oder falsches Format liefert
    info "Fehler bei der Verarbeitung von Ticket " + ticketId + ": " + e;
    
    // Fallback: Ticket zur manuellen Prüfung markieren
    fallbackMap = Map();
    fallbackMap.put("category", humanReviewCategory);
    zoho.desk.update(ticketId, "tickets", fallbackMap);
}

Schritt 5: Eine Ansicht für die manuelle Prüfung einrichten

Um den Prozess abzuschließen, erstelle in Zoho Desk eine neue „Benutzerdefinierte Ansicht“. Filtere hier alle Tickets, deren Kategorie gleich „Manuelle Prüfung“ ist. Dein Team hat nun eine klare Arbeitsliste mit genau den Tickets, die menschliche Intelligenz erfordern.

Tipps und Best Practices

Prompt Engineering ist alles: Die Qualität deiner Ergebnisse hängt direkt von der Qualität deines Prompts ab. Experimentiere damit. Gib der KI Beispiele für gute Kategorisierungen direkt im Prompt mit (sogenanntes „Few-Shot Learning“).
Starte im Beobachtungsmodus: Bevor du das Skript Tickets aktiv ändern lässt, lass es die vorgeschlagene Kategorie und den Konfidenzwert nur in ein benutzerdefiniertes Feld oder in die Notizen schreiben. So entwickelst du ein Gefühl für die Zuverlässigkeit und kannst den optimalen Schwellenwert finden.
Vermeide „Magic Values“: Hartcodierte Werte wie der Schwellenwert (70) oder Kategorienamen sollten am Anfang des Skripts in Variablen deklariert werden. So bleiben sie übersichtlich und leicht anpassbar.
Denke an die Skalierbarkeit: Für hunderte Tickets pro Tag ist eine Custom Function in Desk perfekt. Bei tausenden Anfragen könnte die Ausführung auf Zoho Catalyst, der serverlosen Plattform von Zoho, mehr Kontrolle, bessere Fehlerprotokollierung und Leistung bieten.

Das Ökosystem erweitern: Von der Ticket-Kategorie zur IoT-Steuerung

Die wahre Stärke von Zoho liegt in der Kombination seiner Apps und der Offenheit für andere Systeme. Denk dieses Szenario weiter:

Industrie 4.0 Integration: Das kategorisierte Ticket „Technischer Support“ enthält die Seriennummer einer defekten Maschine. Ein Zoho Flow wird getriggert, der per Webhook mit einem lokalen Node-RED-Server kommuniziert. Node-RED ist ein visuelles Werkzeug, das perfekt für IoT-Szenarien geeignet ist. Es kann über Protokolle wie Modbus oder direkt über einen CAN-Bus-Adapter auf die Steuerung (SPS) der Maschine zugreifen, Diagnosedaten auslesen und in einer InfluxDB (einer Zeitreihendatenbank) speichern.
Visualisierung mit Grafana: Die in InfluxDB gespeicherten Livedaten der Maschine können mit Grafana visualisiert werden. Das so erstellte Dashboard lässt sich als Widget direkt in die Ticketansicht von Zoho Desk einbetten. Der Techniker sieht also nicht nur die Fehlerbeschreibung des Kunden, sondern auch die Live-Leistungsdaten der Maschine.
Proaktive Team-Kommunikation: Sobald ein Ticket als „kritisch“ eingestuft wird, sendet das Skript eine Nachricht an einen bestimmten Kanal in Zoho Cliq, um das Bereitschaftsteam sofort zu alarmieren.
Datengestützte Optimierung: Synchronisiere alle Ticketdaten – inklusive der von der KI vorgeschlagenen Kategorie, dem Konfidenzwert und der finalen, manuell zugewiesenen Kategorie – mit Zoho Analytics. Erstelle ein Dashboard, das dir zeigt, bei welchen Themen die KI unsicher ist. Diese Erkenntnisse sind Gold wert, um deine Prompts oder deine internen Wissensdatenbanken zu verbessern.

Fazit: Intelligente Automatisierung als Wettbewerbsvorteil

Du hast gesehen, dass die Integration von KI in Zoho mehr ist als nur ein Gimmick. Durch die Implementierung eines Konfidenz-Schwellenwerts schaffst du ein robustes System, das die Stärken von Mensch und Maschine kombiniert. Es automatisiert das Alltägliche und reserviert die menschliche Expertise für die wirklich kniffligen Fälle. Dieser Ansatz zeigt, wie Zoho als offene Plattform agiert, die sich nahtlos mit spezialisierten Tech-Stacks aus der Welt der Industrieautomation (SPS, Node-RED) und Datenanalyse (Grafana, InfluxDB) verbinden lässt.

Anstatt auf eine 100%-Automatisierung zu zielen, die in der Realität oft fragil ist, baust du einen lernfähigen, transparenten Prozess. Das spart nicht nur Kosten, sondern steigert vor allem die Qualität deines Services und die Zufriedenheit deiner Mitarbeiter und Kunden.

Verwendete Zoho Apps in diesem Szenario:

Zoho Desk: Als zentrales System für das Ticket-Management.
Zoho Flow: Zur Orchestrierung von Workflows über verschiedene Apps hinweg.
Zoho Analytics: Für die Analyse und Überwachung der KI-Leistung.
Zoho Cliq: Für die sofortige Team-Benachrichtigung.
Zoho Catalyst: Als skalierbare Alternative für die Ausführung komplexer Funktionen.