Freshdesk : Assistant IA pour agents support

TL;DR

Freshdesk combiné à un système RAG transforme vos agents en experts instantanés. L'assistant IA analyse chaque ticket, recherche dans votre base de connaissances et suggère des réponses contextuelles. Résultat : 35% de réduction du temps de traitement et une amélioration notable de la satisfaction client. Ce guide couvre l'intégration technique, les workflows d'assistance et les métriques clés.

Freshdesk + RAG : Le combo gagnant

Pourquoi Freshdesk est idéal pour le RAG

Freshdesk offre plusieurs avantages pour une intégration RAG :

ROI mesuré de l'intégration

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

Architecture d'intégration Freshdesk

Approche Custom App (recommandée)

Créer une application Freshdesk qui affiche les suggestions RAG :

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 {
    // Appel à votre backend RAG
    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");

  // Réponse suggérée
  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>
    `;
  }

  // Sources pertinentes
  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) {
  // Insérer dans l'éditeur de réponse Freshdesk
  await client.interface.trigger("setValue", {
    id: "editor",
    value: text
  });
}

Backend RAG pour 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):
    """
    Génère des suggestions RAG pour un ticket Freshdesk.
    """
    # 1. Rechercher dans la base de connaissances
    documents = await search_knowledge_base(request.query)

    # 2. Récupérer le contexte client
    customer = await get_freshdesk_customer(request.requester_email)
    previous_tickets = await get_customer_tickets(customer["id"])

    # 3. Trouver des tickets similaires résolus
    similar = await find_similar_resolved_tickets(request.query)

    # 4. Générer la suggestion
    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 avec Freshdesk Solutions

Import des articles Solutions

DEVELOPERpython
class FreshdeskKBSync:
    """
    Synchronise les articles Freshdesk Solutions avec le 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:
        """
        Synchronise toutes les catégories et articles.
        """
        stats = {"categories": 0, "folders": 0, "articles": 0}

        async with httpx.AsyncClient() as client:
            # Récupérer les catégories
            categories = await self._get_categories(client)
            stats["categories"] = len(categories)

            for category in categories:
                # Récupérer les dossiers de chaque catégorie
                folders = await self._get_folders(client, category["id"])
                stats["folders"] += len(folders)

                for folder in folders:
                    # Récupérer et indexer les articles
                    articles = await self._get_articles(client, folder["id"])

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

        return stats

    async def _index_article(self, article: dict, category: dict, folder: dict):
        """
        Indexe un article dans le système RAG.
        """
        # Nettoyer le contenu HTML
        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 pour mise à jour temps réel

DEVELOPERpython
@app.post("/freshdesk/webhook/article")
async def handle_article_update(payload: dict):
    """
    Reçoit les webhooks de mise à jour d'articles.
    """
    event = payload.get("event")
    article_id = payload.get("data", {}).get("article_id")

    if event == "article.created" or event == "article.updated":
        # Récupérer et réindexer l'article
        article = await fetch_article(article_id)
        await sync.index_article(article)
        return {"status": "indexed"}

    elif event == "article.deleted":
        # Supprimer du RAG
        await rag.delete_document(f"freshdesk_article_{article_id}")
        return {"status": "deleted"}

    return {"status": "ignored"}

Workflows d'assistance agent

Workflow 1 : Suggestion à l'ouverture du ticket

DEVELOPERpython
class TicketOpenWorkflow:
    """
    Déclenché quand un agent ouvre un ticket.
    """

    async def execute(self, ticket_id: int) -> dict:
        # Récupérer le ticket
        ticket = await self.freshdesk.get_ticket(ticket_id)

        # Préparer le contexte
        context = await self._build_context(ticket)

        # Générer les suggestions
        suggestions = await self.rag_assistant.suggest(
            query=f"{ticket['subject']}\n{ticket['description']}",
            context=context
        )

        # Enrichir avec des métriques
        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:
        """
        Construit le contexte complet pour le RAG.
        """
        # Historique client
        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
        )

        # Produit/Company associé
        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 : Assistance pendant la rédaction

DEVELOPERpython
class RealtimeAssistWorkflow:
    """
    Fournit une assistance en temps réel pendant la rédaction.
    """

    async def assist_typing(
        self,
        ticket_id: int,
        partial_response: str
    ) -> dict:
        """
        Appelé pendant que l'agent tape sa réponse.
        """
        ticket = await self.freshdesk.get_ticket(ticket_id)

        # Analyser l'intention de la réponse en cours
        intent = await self.analyze_response_intent(partial_response)

        # Suggérer des compléments
        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:
        """
        Suggère des procédures pertinentes.
        """
        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)
        }

Intégration avec 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"
        }

Métriques et amélioration continue

Dashboard agent

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 loop

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)

Intégration avec Ailog

Ailog simplifie l'intégration Freshdesk :

DEVELOPERpython
from ailog import AilogClient

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

# Configuration en une ligne
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"
)

# L'assistant est prêt
suggestions = client.support.suggest(
    ticket_id=12345,
    include_similar=True
)

Conclusion

L'intégration RAG + Freshdesk transforme l'expérience agent et client. Les suggestions intelligentes réduisent la charge cognitive des agents tout en améliorant la qualité et la cohérence des réponses. Commencez par le déploiement de la Custom App, mesurez l'adoption, puis affinez les modèles avec le feedback.

Ressources complémentaires

• Zendesk + RAG - Alternative Zendesk
• Classification automatique des tickets - Routage intelligent
• Escalade intelligente - Quand transférer à un humain
• RAG pour le support client - Guide pilier