Freshdesk: KI-Assistent für Support-Agenten

TL;DR

Freshdesk kombiniert mit einem RAG-System verwandelt Ihre Agenten sofort in Experten. Der KI-Assistent analysiert jedes Ticket, durchsucht Ihre Wissensdatenbank und schlägt kontextbezogene Antworten vor. Ergebnis : 35% Reduktion der Bearbeitungszeit und eine deutliche Verbesserung der Kundenzufriedenheit. Dieser Leitfaden behandelt die technische Integration, Support-Workflows und die wichtigsten Kennzahlen.

Freshdesk + RAG : Die Gewinnerkombination

Warum Freshdesk ideal für RAG ist

Freshdesk bietet mehrere Vorteile für eine RAG-Integration :

Gemessener ROI der Integration

Unternehmen, die RAG + Freshdesk nutzen, stellen fest :

• 35% de réduction du temps moyen de traitement (AHT)
• 28% d'amélioration du taux de résolution au premier contact
• 50% de réduction du temps d'onboarding des nouveaux agents
• 22% d'augmentation du score CSAT

Freshdesk-Integrationsarchitektur

Custom App-Ansatz (empfohlen)

Erstellen Sie eine Freshdesk-App, die RAG-Vorschläge anzeigt :

DEVELOPERjavascript
// app/scripts/app.js - Freshdesk Custom App

client.events.on("app.activated", async function() {
  const ticketData = await client.data.get("ticket");
  await loadRAGSuggestions(ticketData);
});

async function loadRAGSuggestions(ticket) {
  const query = `${ticket.subject}\n${ticket.description}`;

  try {
    // Aufruf Ihres RAG-Backends
    const response = await fetch("https://your-rag-api.com/suggest", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${await client.iparams.get("rag_api_key")}`
      },
      body: JSON.stringify({
        query: query,
        ticket_id: ticket.id,
        requester_email: ticket.requester.email
      })
    });

    const suggestions = await response.json();
    renderSuggestions(suggestions);
  } catch (error) {
    console.error("RAG suggestion error:", error);
    showFallback();
  }
}

function renderSuggestions(suggestions) {
  const container = document.getElementById("suggestions-container");

  // Vorgeschlagene Antwort
  if (suggestions.suggested_response) {
    container.innerHTML += `
      <div class="suggestion-card">
        <h4>Vorgeschlagene Antwort</h4>
        <p class="confidence">Konfidenz: ${Math.round(suggestions.confidence * 100)}%</p>
        <div class="response-text">${suggestions.suggested_response}</div>
        <button onclick="insertResponse('${escapeQuotes(suggestions.suggested_response)}')">
          In die Antwort einfügen
        </button>
      </div>
    `;
  }

  // Relevante Quellen
  if (suggestions.sources && suggestions.sources.length > 0) {
    let sourcesHtml = '<div class="sources-list"><h4>Quellen</h4><ul>';
    suggestions.sources.forEach(source => {
      sourcesHtml += `
        <li>
          <a href="${source.url}" target="_blank">${source.title}</a>
          <span class="score">${Math.round(source.score * 100)}%</span>
        </li>
      `;
    });
    sourcesHtml += '</ul></div>';
    container.innerHTML += sourcesHtml;
  }
}

async function insertResponse(text) {
  // In den Freshdesk-Antworteditor einfügen
  await client.interface.trigger("setValue", {
    id: "editor",
    value: text
  });
}

RAG-Backend für Freshdesk

DEVELOPERpython
from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel
import httpx

app = FastAPI()

class FreshdeskTicketRequest(BaseModel):
    query: str
    ticket_id: int
    requester_email: str

class RAGSuggestionResponse(BaseModel):
    suggested_response: str
    confidence: float
    sources: list[dict]
    similar_tickets: list[dict]

@app.post("/suggest", response_model=RAGSuggestionResponse)
async def get_suggestions(request: FreshdeskTicketRequest):
    """
    Erzeugt RAG-Vorschläge für ein Freshdesk-Ticket.
    """
    # 1. In der Wissensdatenbank suchen
    documents = await search_knowledge_base(request.query)

    # 2. Kundenkontext abrufen
    customer = await get_freshdesk_customer(request.requester_email)
    previous_tickets = await get_customer_tickets(customer["id"])

    # 3. Ähnliche gelöste Tickets finden
    similar = await find_similar_resolved_tickets(request.query)

    # 4. Vorschlag generieren
    suggestion = await generate_response(
        query=request.query,
        documents=documents,
        customer_context=customer,
        similar_tickets=similar
    )

    return RAGSuggestionResponse(
        suggested_response=suggestion["response"],
        confidence=suggestion["confidence"],
        sources=[{
            "title": doc.metadata["title"],
            "url": doc.metadata["url"],
            "score": doc.score
        } for doc in documents[:3]],
        similar_tickets=[{
            "id": t["id"],
            "subject": t["subject"],
            "resolution": t["resolution_note"]
        } for t in similar[:2]]
    )

Synchronisation mit Freshdesk Solutions

Import von Solutions-Artikeln

DEVELOPERpython
class FreshdeskKBSync:
    """
    Synchronisiert Freshdesk Solutions-Artikel mit dem RAG.
    """

    def __init__(self, domain: str, api_key: str, rag_client):
        self.base_url = f"https://{domain}.freshdesk.com/api/v2"
        self.headers = {"Authorization": f"Basic {api_key}"}
        self.rag = rag_client

    async def sync_all_articles(self) -> dict:
        """
        Synchronisiert alle Kategorien und Artikel.
        """
        stats = {"categories": 0, "folders": 0, "articles": 0}

        async with httpx.AsyncClient() as client:
            # Kategorien abrufen
            categories = await self._get_categories(client)
            stats["categories"] = len(categories)

            for category in categories:
                # Ordner jeder Kategorie abrufen
                folders = await self._get_folders(client, category["id"])
                stats["folders"] += len(folders)

                for folder in folders:
                    # Artikel abrufen und indexieren
                    articles = await self._get_articles(client, folder["id"])

                    for article in articles:
                        if article["status"] == 2:  # Veröffentlicht
                            await self._index_article(article, category, folder)
                            stats["articles"] += 1

        return stats

    async def _index_article(self, article: dict, category: dict, folder: dict):
        """
        Indexiert einen Artikel im RAG-System.
        """
        # HTML-Inhalt bereinigen
        clean_content = self._strip_html(article["description"])

        metadata = {
            "source": "freshdesk_solutions",
            "article_id": article["id"],
            "title": article["title"],
            "url": f"https://{self.domain}.freshdesk.com/support/solutions/articles/{article['id']}",
            "category": category["name"],
            "folder": folder["name"],
            "tags": article.get("tags", []),
            "created_at": article["created_at"],
            "updated_at": article["updated_at"]
        }

        await self.rag.index_document(
            content=f"# {article['title']}\n\n{clean_content}",
            metadata=metadata,
            doc_id=f"freshdesk_article_{article['id']}"
        )

    async def _get_categories(self, client: httpx.AsyncClient) -> list:
        response = await client.get(
            f"{self.base_url}/solutions/categories",
            headers=self.headers
        )
        return response.json()

    async def _get_folders(self, client: httpx.AsyncClient, category_id: int) -> list:
        response = await client.get(
            f"{self.base_url}/solutions/categories/{category_id}/folders",
            headers=self.headers
        )
        return response.json()

    async def _get_articles(self, client: httpx.AsyncClient, folder_id: int) -> list:
        response = await client.get(
            f"{self.base_url}/solutions/folders/{folder_id}/articles",
            headers=self.headers
        )
        return response.json()

Webhook für Echtzeit-Aktualisierungen

DEVELOPERpython
@app.post("/freshdesk/webhook/article")
async def handle_article_update(payload: dict):
    """
    Empfängt Webhooks zu Artikelaktualisierungen.
    """
    event = payload.get("event")
    article_id = payload.get("data", {}).get("article_id")

    if event == "article.created" or event == "article.updated":
        # Artikel abrufen und reindexieren
        article = await fetch_article(article_id)
        await sync.index_article(article)
        return {"status": "indexed"}

    elif event == "article.deleted":
        # Aus dem RAG löschen
        await rag.delete_document(f"freshdesk_article_{article_id}")
        return {"status": "deleted"}

    return {"status": "ignored"}

Support-Workflows für Agenten

Workflow 1 : Vorschläge beim Öffnen des Tickets

DEVELOPERpython
class TicketOpenWorkflow:
    """
    Wird ausgelöst, wenn ein Agent ein Ticket öffnet.
    """

    async def execute(self, ticket_id: int) -> dict:
        # Ticket abrufen
        ticket = await self.freshdesk.get_ticket(ticket_id)

        # Kontext vorbereiten
        context = await self._build_context(ticket)

        # Vorschläge erzeugen
        suggestions = await self.rag_assistant.suggest(
            query=f"{ticket['subject']}\n{ticket['description']}",
            context=context
        )

        # Mit Metriken anreichern
        suggestions["priority_suggestion"] = self._suggest_priority(
            ticket, suggestions
        )
        suggestions["group_suggestion"] = self._suggest_group(
            ticket, suggestions
        )

        return suggestions

    async def _build_context(self, ticket: dict) -> dict:
        """
        Erstellt den vollständigen Kontext für RAG.
        """
        # Kundenhistorie
        requester = await self.freshdesk.get_contact(ticket["requester_id"])
        previous_tickets = await self.freshdesk.get_tickets(
            requester_id=requester["id"],
            status=["resolved", "closed"],
            limit=5
        )

        # Zugehöriges Produkt/Unternehmen
        company = None
        if ticket.get("company_id"):
            company = await self.freshdesk.get_company(ticket["company_id"])

        return {
            "requester": requester,
            "previous_tickets": previous_tickets,
            "company": company,
            "custom_fields": ticket.get("custom_fields", {})
        }

Workflow 2 : Unterstützung während des Schreibens

DEVELOPERpython
class RealtimeAssistWorkflow:
    """
    Bietet Echtzeitunterstützung während des Schreibens.
    """

    async def assist_typing(
        self,
        ticket_id: int,
        partial_response: str
    ) -> dict:
        """
        Wird aufgerufen, während der Agent seine Antwort tippt.
        """
        ticket = await self.freshdesk.get_ticket(ticket_id)

        # Absicht der aktuellen Antwort analysieren
        intent = await self.analyze_response_intent(partial_response)

        # Ergänzungen vorschlagen
        if intent == "needs_procedure":
            return await self._suggest_procedures(ticket, partial_response)
        elif intent == "needs_article":
            return await self._suggest_articles(ticket, partial_response)
        elif intent == "needs_template":
            return await self._suggest_templates(ticket, partial_response)

        return {"suggestions": []}

    async def _suggest_procedures(
        self,
        ticket: dict,
        partial: str
    ) -> dict:
        """
        Schlägt relevante Verfahren vor.
        """
        procedures = await self.rag.search(
            query=partial,
            filter={"type": "procedure"},
            top_k=3
        )

        return {
            "type": "procedures",
            "suggestions": [{
                "title": p.metadata["title"],
                "steps": self._extract_steps(p.text),
                "insert_text": self._format_procedure(p)
            } for p in procedures]
        }

Workflow 3 : Validierung vor dem Versand

DEVELOPERpython
class PreSendValidationWorkflow:
    """
    Validiert die Antwort vor dem Versand.
    """

    async def validate(
        self,
        ticket: dict,
        response: str
    ) -> dict:
        """
        Prüft die Qualität und Relevanz der Antwort.
        """
        validations = {}

        # 1. Vollständigkeit prüfen
        questions = await self._extract_questions(ticket["description"])
        answered = await self._check_questions_answered(questions, response)
        validations["completeness"] = {
            "score": len(answered) / len(questions) if questions else 1.0,
            "unanswered": [q for q in questions if q not in answered]
        }

        # 2. Konsistenz mit der Wissensdatenbank prüfen
        kb_check = await self._verify_against_kb(response)
        validations["kb_consistency"] = kb_check

        # 3. Ton und Stil prüfen
        tone_check = await self._check_tone(response)
        validations["tone"] = tone_check

        # 4. Gesamtscore
        overall_score = (
            validations["completeness"]["score"] * 0.4 +
            validations["kb_consistency"]["score"] * 0.4 +
            validations["tone"]["score"] * 0.2
        )

        return {
            "valid": overall_score >= 0.7,
            "score": overall_score,
            "validations": validations,
            "suggestions": self._generate_improvement_suggestions(validations)
        }

Integration mit Freddy AI

Freshdesk bietet Freddy AI an, das eine Ergänzung zum RAG-System sein kann :

DEVELOPERpython
class FreddyRAGHybrid:
    """
    Kombiniert Freddy AI und maßgeschneidertes RAG.
    """

    async def get_hybrid_suggestions(
        self,
        ticket: dict
    ) -> dict:
        """
        Kombiniert die Vorschläge von Freddy und RAG.
        """
        # Freddy-Vorschläge abrufen
        freddy_suggestions = await self.get_freddy_suggestions(ticket["id"])

        # RAG-Vorschläge abrufen
        rag_suggestions = await self.rag.suggest(
            query=f"{ticket['subject']}\n{ticket['description']}"
        )

        # Intelligent zusammenführen
        merged = self._merge_suggestions(freddy_suggestions, rag_suggestions)

        return merged

    def _merge_suggestions(
        self,
        freddy: dict,
        rag: dict
    ) -> dict:
        """
        Strategie zur Zusammenführung der Vorschläge.
        """
        # RAG priorisieren bei hoher Konfidenz
        if rag["confidence"] > 0.85:
            return {
                "primary": rag["suggested_response"],
                "alternative": freddy.get("suggested_response"),
                "source": "rag",
                "articles": rag["sources"] + freddy.get("articles", [])
            }

        # Freddy priorisieren bei geringer RAG-Konfidenz
        if rag["confidence"] < 0.5 and freddy.get("confidence", 0) > 0.7:
            return {
                "primary": freddy["suggested_response"],
                "alternative": rag["suggested_response"],
                "source": "freddy",
                "articles": freddy.get("articles", []) + rag["sources"]
            }

        # Andernfalls beide vorschlagen
        return {
            "rag_suggestion": rag["suggested_response"],
            "freddy_suggestion": freddy.get("suggested_response"),
            "rag_confidence": rag["confidence"],
            "source": "both"
        }

Metriken und kontinuierliche Verbesserung

Agenten-Dashboard

DEVELOPERpython
class AgentPerformanceMetrics:
    """
    Agenten-Performance-Metriken mit RAG.
    """

    async def get_agent_metrics(
        self,
        agent_id: int,
        period: str = "week"
    ) -> dict:
        tickets = await self._get_agent_tickets(agent_id, period)

        rag_assisted = [t for t in tickets if t.get("rag_used")]
        manual = [t for t in tickets if not t.get("rag_used")]

        return {
            "agent_id": agent_id,
            "period": period,
            "total_tickets": len(tickets),
            "rag_usage": {
                "count": len(rag_assisted),
                "percentage": len(rag_assisted) / len(tickets) * 100,
                "avg_resolution_time": self._avg_time(rag_assisted),
                "first_contact_resolution": self._fcr_rate(rag_assisted)
            },
            "manual": {
                "count": len(manual),
                "avg_resolution_time": self._avg_time(manual),
                "first_contact_resolution": self._fcr_rate(manual)
            },
            "improvement": {
                "time_saved": self._calculate_time_saved(rag_assisted, manual),
                "fcr_improvement": self._fcr_improvement(rag_assisted, manual)
            }
        }

Feedback-Schleife

DEVELOPERpython
class RAGFeedbackLoop:
    """
    Sammelt und nutzt Agenten-Feedback.
    """

    async def record_feedback(
        self,
        ticket_id: int,
        suggestion_id: str,
        action: str,  # "used", "modified", "rejected"
        modification: str = None
    ):
        """
        Erfasst das Feedback zu einem Vorschlag.
        """
        feedback = {
            "ticket_id": ticket_id,
            "suggestion_id": suggestion_id,
            "action": action,
            "modification": modification,
            "timestamp": datetime.utcnow()
        }

        await self.db.insert("rag_feedback", feedback)

        # Bei Änderung: aus der Änderung lernen
        if action == "modified" and modification:
            await self._learn_from_modification(suggestion_id, modification)

    async def _learn_from_modification(
        self,
        suggestion_id: str,
        modification: str
    ):
        """
        Verbessert das RAG-System basierend auf Agenten-Änderungen.
        """
        original = await self._get_original_suggestion(suggestion_id)

        # Unterschied analysieren
        analysis = await self.analyze_modification(
            original=original["response"],
            modified=modification
        )

        # Bei wiederkehrendem Muster eine Regel erstellen
        if await self._is_recurring_pattern(analysis):
            await self._create_improvement_rule(analysis)

Integration mit Ailog

Ailog vereinfacht die Freshdesk-Integration :

DEVELOPERpython
from ailog import AilogClient

client = AilogClient(api_key="your-key")

# Einzeilige Konfiguration
client.integrations.freshdesk.connect(
    domain="your-company",
    api_key="freshdesk-api-key",
    sync_solutions=True,
    enable_agent_assist=True,
    webhook_url="https://your-app.com/freshdesk/webhook"
)

# Der Assistent ist bereit
suggestions = client.support.suggest(
    ticket_id=12345,
    include_similar=True
)

Fazit

Die Integration RAG + Freshdesk verwandelt die Erfahrung für Agenten und Kunden. Intelligente Vorschläge reduzieren die kognitive Belastung der Agenten und verbessern gleichzeitig die Qualität und Konsistenz der Antworten. Beginnen Sie mit dem Einsatz der Custom App, messen Sie die Adoption und verfeinern Sie dann die Modelle mit dem Feedback.

Weitere Ressourcen

• Zendesk + RAG - Alternative : Zendesk
• Automatische Ticketklassifikation - Intelligentes Routing
• Intelligente Eskalation - Wann an einen Menschen weiterleiten
• RAG für den Kundensupport - Leitfaden