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

Les entreprises utilisant RAG + Freshdesk constatent :

• 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>Réponse suggérée</h4>
        <p class="confidence">Confiance: ${Math.round(suggestions.confidence * 100)}%</p>
        <div class="response-text">${suggestions.suggested_response}</div>
        <button onclick="insertResponse('${escapeQuotes(suggestions.suggested_response)}')">
          Insérer dans la réponse
        </button>
      </div>
    `;
  }

  // Relevante Quellen
  if (suggestions.sources && suggestions.sources.length > 0) {
    let sourcesHtml = '<div class="sources-list"><h4>Sources</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 : Validation avant envoi

DEVELOPERpython
class PreSendValidationWorkflow:
    """
    Valide la réponse avant envoi.
    """

    async def validate(
        self,
        ticket: dict,
        response: str
    ) -> dict:
        """
        Vérifie la qualité et la pertinence de la réponse.
        """
        validations = {}

        # 1. Vérifier la complétude
        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. Vérifier la cohérence avec la KB
        kb_check = await self._verify_against_kb(response)
        validations["kb_consistency"] = kb_check

        # 3. Vérifier le ton et le style
        tone_check = await self._check_tone(response)
        validations["tone"] = tone_check

        # 4. Score global
        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)
        }

(Note: The above code block contains French comments and strings that are preserved as in the original; only code-level comments earlier in the document were translated.)

Integration mit Freddy AI

Freshdesk propose Freddy AI, qui peut être complémentaire au RAG :

DEVELOPERpython
class FreddyRAGHybrid:
    """
    Combine Freddy AI et RAG personnalisé.
    """

    async def get_hybrid_suggestions(
        self,
        ticket: dict
    ) -> dict:
        """
        Combine les suggestions Freddy et RAG.
        """
        # Récupérer les suggestions Freddy
        freddy_suggestions = await self.get_freddy_suggestions(ticket["id"])

        # Récupérer les suggestions RAG
        rag_suggestions = await self.rag.suggest(
            query=f"{ticket['subject']}\n{ticket['description']}"
        )

        # Fusionner intelligemment
        merged = self._merge_suggestions(freddy_suggestions, rag_suggestions)

        return merged

    def _merge_suggestions(
        self,
        freddy: dict,
        rag: dict
    ) -> dict:
        """
        Stratégie de fusion des suggestions.
        """
        # Prioriser RAG si confiance élevée
        if rag["confidence"] > 0.85:
            return {
                "primary": rag["suggested_response"],
                "alternative": freddy.get("suggested_response"),
                "source": "rag",
                "articles": rag["sources"] + freddy.get("articles", [])
            }

        # Prioriser Freddy si RAG peu confiant
        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"]
            }

        # Sinon, proposer les deux
        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:
    """
    Métriques de performance agent avec 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:
    """
    Collecte et utilise le feedback agent.
    """

    async def record_feedback(
        self,
        ticket_id: int,
        suggestion_id: str,
        action: str,  # "used", "modified", "rejected"
        modification: str = None
    ):
        """
        Enregistre le feedback sur une suggestion.
        """
        feedback = {
            "ticket_id": ticket_id,
            "suggestion_id": suggestion_id,
            "action": action,
            "modification": modification,
            "timestamp": datetime.utcnow()
        }

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

        # Si modifié, apprendre de la modification
        if action == "modified" and modification:
            await self._learn_from_modification(suggestion_id, modification)

    async def _learn_from_modification(
        self,
        suggestion_id: str,
        modification: str
    ):
        """
        Améliore le RAG basé sur les modifications agent.
        """
        original = await self._get_original_suggestion(suggestion_id)

        # Analyser la différence
        analysis = await self.analyze_modification(
            original=original["response"],
            modified=modification
        )

        # Si pattern récurrent, créer une règle
        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