Support Client IA : Reduire les tickets avec le RAG

Le support client represente souvent 15 a 25% des couts operationnels d'une entreprise. Une etude Gartner revele que 70% des tickets de niveau 1 concernent des questions repetitives dont la reponse existe deja dans la documentation. Le RAG transforme cette realite en automatisant les reponses tout en preservant la qualite de service.

Le cout cache du support traditionnel

Anatomie d'un ticket de support

Chaque ticket suit un cycle couteux :

Multipliez par des milliers de tickets mensuels, et le support devient un gouffre financier.

Les questions qui reviennent sans cesse

Analysez vos tickets : vous constaterez que 60 a 80% concernent :

• Ou est ma commande ?
• Comment retourner un produit ?
• Quels sont vos horaires ?
• Comment modifier mon abonnement ?
• Mot de passe oublie
• Problemes de paiement standards

Ces questions ont des reponses claires et documentees. Pourquoi mobiliser des agents humains ?

Architecture RAG pour le support client

┌─────────────────────────────────────────────────────────────┐
│                    CANAUX D'ENTREE                          │
├──────────┬──────────┬──────────┬──────────┬────────────────┤
│  Widget  │  Email   │  Chat    │  Slack   │   API          │
│   Web    │  Parser  │  Live    │   Bot    │   Externe      │
└────┬─────┴────┬─────┴────┬─────┴────┬─────┴───────┬────────┘
     │          │          │          │             │
     └──────────┴──────────┴──────────┴─────────────┘
                           │
                           ▼
              ┌─────────────────────────┐
              │   Classification        │
              │   Intent Detection      │
              └───────────┬─────────────┘
                          │
         ┌────────────────┼────────────────┐
         ▼                ▼                ▼
    ┌─────────┐     ┌─────────┐     ┌─────────┐
    │   RAG   │     │  Action │     │ Escalade│
    │ Reponse │     │   API   │     │  Humain │
    └────┬────┘     └────┬────┘     └────┬────┘
         │               │               │
         └───────────────┴───────────────┘
                         │
                         ▼
              ┌─────────────────────────┐
              │    Reponse Client       │
              └─────────────────────────┘

Les trois modes de reponse

1. Reponse RAG pure : Questions factuelles dont la reponse est dans la base de connaissances.

2. Action API : Requetes necessitant une action systeme (suivi commande, modification compte).

3. Escalade humaine : Cas complexes, plaintes, situations emotionnelles.

Construire la base de connaissances support

Sources a indexer

DEVELOPERpython
SUPPORT_SOURCES = {
    "faq": {
        "path": "/docs/faq",
        "priority": "high",
        "update_frequency": "daily"
    },
    "procedures": {
        "path": "/docs/procedures",
        "priority": "high",
        "update_frequency": "weekly"
    },
    "product_docs": {
        "path": "/docs/products",
        "priority": "medium",
        "update_frequency": "on_change"
    },
    "past_tickets": {
        "path": "/tickets/resolved",
        "priority": "medium",
        "update_frequency": "daily",
        "filter": "satisfaction >= 4"
    },
    "policies": {
        "path": "/docs/policies",
        "priority": "high",
        "update_frequency": "on_change"
    }
}

Structure optimale d'un article FAQ

DEVELOPERmarkdown
# Comment retourner un produit ?

## Reponse courte
Vous avez 30 jours pour retourner un produit non utilise.
Connectez-vous a votre espace client > Mes commandes > Demander un retour.

## Conditions
- Produit non utilise, dans son emballage d'origine
- Delai : 30 jours apres reception
- Exceptions : produits personnalises, hygiene, alimentaire

## Procedure detaillee
1. Connectez-vous a votre espace client
2. Allez dans "Mes commandes"
3. Selectionnez la commande concernee
4. Cliquez sur "Demander un retour"
5. Selectionnez les articles a retourner
6. Choisissez le motif
7. Imprimez l'etiquette prepayee

## Delais de remboursement
- Validation retour : 2-3 jours ouvres apres reception
- Remboursement : 5-7 jours ouvres sur le moyen de paiement original

## Questions connexes
- [Comment suivre mon retour ?](/faq/suivi-retour)
- [Qui paie les frais de retour ?](/faq/frais-retour)
- [Puis-je echanger au lieu de retourner ?](/faq/echange)

---
Tags: retour, remboursement, echange, renvoi, renvoyer
Derniere mise a jour: 2024-01-15

Cette structure permet au RAG de trouver rapidement la reponse courte tout en ayant acces aux details si necessaire.

Detection d'intention et routage

Classifier les requetes

DEVELOPERpython
from enum import Enum
from pydantic import BaseModel

class IntentType(Enum):
    INFORMATION = "information"      # Reponse RAG
    TRANSACTION = "transaction"      # Action API
    COMPLAINT = "complaint"          # Escalade prioritaire
    TECHNICAL = "technical"          # Support technique
    URGENT = "urgent"                # Escalade immediate

class IntentClassifier:
    def __init__(self, llm):
        self.llm = llm

    async def classify(self, message: str, context: dict = None) -> dict:
        prompt = f"""
        Analyse ce message client et determine :
        1. L'intention principale (information, transaction, complaint, technical, urgent)
        2. Le niveau de priorite (low, medium, high, critical)
        3. L'emotion detectee (neutral, frustrated, angry, satisfied)
        4. Les entites extraites (numero commande, produit, date, etc.)

        Message : {message}
        Contexte client : {context}

        Reponds en JSON.
        """

        response = await self.llm.generate(prompt, temperature=0)
        return self._parse_classification(response)

    def _parse_classification(self, response: str) -> dict:
        # Parse et valide la reponse JSON
        import json
        try:
            return json.loads(response)
        except:
            return {
                "intent": IntentType.INFORMATION,
                "priority": "medium",
                "emotion": "neutral",
                "entities": {}
            }

Routage intelligent

DEVELOPERpython
class SupportRouter:
    def __init__(self, rag_service, action_service, escalation_service):
        self.rag = rag_service
        self.actions = action_service
        self.escalation = escalation_service

    async def route(self, message: str, classification: dict) -> dict:
        intent = classification["intent"]
        priority = classification["priority"]
        emotion = classification["emotion"]

        # Escalade immediate pour cas critiques
        if priority == "critical" or emotion == "angry":
            return await self.escalation.create_ticket(
                message=message,
                classification=classification,
                priority="high"
            )

        # Plaintes : toujours escalader
        if intent == IntentType.COMPLAINT:
            return await self.escalation.create_ticket(
                message=message,
                classification=classification,
                priority="medium"
            )

        # Transactions : verifier si action possible
        if intent == IntentType.TRANSACTION:
            action_result = await self.actions.try_action(
                message=message,
                entities=classification.get("entities", {})
            )
            if action_result["success"]:
                return action_result
            # Sinon, fallback sur RAG

        # Par defaut : reponse RAG
        return await self.rag.answer(
            query=message,
            context=classification
        )

Personnalisation des reponses

Adapter au profil client

DEVELOPERpython
class PersonalizedResponder:
    def __init__(self, llm, customer_service):
        self.llm = llm
        self.customers = customer_service

    async def generate_response(
        self,
        query: str,
        rag_context: str,
        customer_id: str
    ) -> str:
        # Recuperer le profil client
        profile = await self.customers.get_profile(customer_id)

        # Adapter le ton et le niveau de detail
        tone = self._determine_tone(profile)

        prompt = f"""
        Tu es un assistant support de [Entreprise].

        PROFIL CLIENT :
        - Anciennete : {profile.get('tenure', 'nouveau')}
        - Valeur : {profile.get('value_segment', 'standard')}
        - Historique : {profile.get('ticket_count', 0)} tickets precedents
        - Langue preferee : {profile.get('language', 'fr')}

        TON A ADOPTER : {tone}

        DOCUMENTATION PERTINENTE :
        {rag_context}

        QUESTION CLIENT :
        {query}

        Genere une reponse :
        - Directe et actionnable
        - Adaptee au profil client
        - Avec les liens utiles si pertinent
        - Maximum 3 paragraphes
        """

        return await self.llm.generate(prompt, temperature=0.3)

    def _determine_tone(self, profile: dict) -> str:
        if profile.get('value_segment') == 'vip':
            return "Premium et attentionne, propose des solutions proactives"
        elif profile.get('ticket_count', 0) > 10:
            return "Efficace et direct, evite les explications basiques"
        elif profile.get('tenure') == 'nouveau':
            return "Accueillant et pedagogique, explique les etapes en detail"
        return "Professionnel et chaleureux"

Gestion du contexte conversationnel

DEVELOPERpython
class ConversationManager:
    def __init__(self, redis_client):
        self.redis = redis_client
        self.max_history = 10

    async def add_message(self, conversation_id: str, role: str, content: str):
        key = f"conversation:{conversation_id}"

        message = {
            "role": role,
            "content": content,
            "timestamp": datetime.now().isoformat()
        }

        await self.redis.rpush(key, json.dumps(message))
        await self.redis.ltrim(key, -self.max_history, -1)
        await self.redis.expire(key, 3600 * 24)  # 24h TTL

    async def get_context(self, conversation_id: str) -> list:
        key = f"conversation:{conversation_id}"
        messages = await self.redis.lrange(key, 0, -1)
        return [json.loads(m) for m in messages]

    async def build_prompt_context(self, conversation_id: str) -> str:
        history = await self.get_context(conversation_id)

        context_parts = []
        for msg in history[-5:]:  # 5 derniers messages
            role = "Client" if msg["role"] == "user" else "Assistant"
            context_parts.append(f"{role}: {msg['content']}")

        return "\n".join(context_parts)

Metriques et amelioration continue

KPIs essentiels

DEVELOPERpython
class SupportMetrics:
    def __init__(self, db):
        self.db = db

    def calculate_metrics(self, period_days: int = 30) -> dict:
        return {
            # Efficacite
            "deflection_rate": self._deflection_rate(period_days),
            "first_contact_resolution": self._fcr_rate(period_days),
            "avg_response_time": self._avg_response_time(period_days),

            # Qualite
            "csat_score": self._csat_score(period_days),
            "escalation_rate": self._escalation_rate(period_days),
            "reopen_rate": self._reopen_rate(period_days),

            # Volume
            "total_conversations": self._total_conversations(period_days),
            "automated_responses": self._automated_count(period_days),
            "human_interventions": self._human_count(period_days),

            # Contenu
            "top_intents": self._top_intents(period_days),
            "unanswered_queries": self._unanswered_queries(period_days),
            "knowledge_gaps": self._identify_gaps(period_days)
        }

    def _deflection_rate(self, days: int) -> float:
        """Taux de tickets evites grace a l'IA"""
        query = """
        SELECT
            COUNT(CASE WHEN escalated = false THEN 1 END)::float /
            COUNT(*)::float * 100 as deflection_rate
        FROM support_conversations
        WHERE created_at > NOW() - INTERVAL '%s days'
        """
        result = self.db.execute(query, [days])
        return round(result[0]['deflection_rate'], 1)

    def _identify_gaps(self, days: int) -> list:
        """Identifie les questions sans bonne reponse"""
        query = """
        SELECT query, COUNT(*) as count, AVG(satisfaction) as avg_sat
        FROM support_conversations
        WHERE created_at > NOW() - INTERVAL '%s days'
        AND (satisfaction < 3 OR escalated = true)
        GROUP BY query
        HAVING COUNT(*) >= 3
        ORDER BY count DESC
        LIMIT 20
        """
        return self.db.execute(query, [days])

Boucle d'amelioration

DEVELOPERpython
class KnowledgeImprover:
    def __init__(self, metrics, kb_service, llm):
        self.metrics = metrics
        self.kb = kb_service
        self.llm = llm

    async def weekly_improvement(self):
        # 1. Identifier les lacunes
        gaps = self.metrics._identify_gaps(days=7)

        # 2. Pour chaque lacune significative
        for gap in gaps[:10]:
            # Analyser les conversations echouees
            failed_convs = await self._get_failed_conversations(gap['query'])

            # Generer une suggestion d'article
            suggestion = await self._generate_article_suggestion(
                query=gap['query'],
                conversations=failed_convs
            )

            # Creer un ticket pour l'equipe contenu
            await self._create_content_ticket(suggestion)

        # 3. Identifier les articles obsoletes
        outdated = await self._find_outdated_articles()
        for article in outdated:
            await self._create_review_ticket(article)

    async def _generate_article_suggestion(
        self,
        query: str,
        conversations: list
    ) -> dict:
        prompt = f"""
        Analyse ces conversations de support qui ont echoue :

        Question recurrente : {query}

        Conversations :
        {json.dumps(conversations, indent=2)}

        Genere une suggestion d'article FAQ qui repondrait a cette question.
        Inclus : titre, reponse courte, reponse detaillee, tags.
        """

        return await self.llm.generate(prompt, temperature=0.5)

Integration avec les outils existants

Connexion CRM (Salesforce, Hubspot)

DEVELOPERpython
class CRMIntegration:
    def __init__(self, crm_client):
        self.crm = crm_client

    async def enrich_context(self, customer_email: str) -> dict:
        """Enrichit le contexte avec les donnees CRM"""
        customer = await self.crm.get_contact(email=customer_email)

        if not customer:
            return {}

        return {
            "customer_name": customer.get("name"),
            "company": customer.get("company"),
            "segment": customer.get("segment"),
            "lifetime_value": customer.get("ltv"),
            "open_opportunities": customer.get("open_opps"),
            "recent_purchases": customer.get("recent_orders", [])[:5],
            "support_history": customer.get("ticket_count"),
            "nps_score": customer.get("nps")
        }

    async def log_interaction(
        self,
        customer_email: str,
        interaction: dict
    ):
        """Log l'interaction dans le CRM"""
        await self.crm.create_activity(
            contact_email=customer_email,
            type="support_chat",
            subject=interaction.get("intent"),
            description=interaction.get("summary"),
            outcome=interaction.get("resolution")
        )

Webhook pour escalade

DEVELOPERpython
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

class EscalationRequest(BaseModel):
    conversation_id: str
    customer_email: str
    priority: str
    summary: str
    transcript: list

@app.post("/webhooks/escalate")
async def escalate_to_helpdesk(request: EscalationRequest):
    """Cree un ticket dans le helpdesk (Zendesk, Freshdesk, etc.)"""

    ticket = {
        "subject": f"Escalade IA - {request.summary[:50]}",
        "description": format_transcript(request.transcript),
        "priority": map_priority(request.priority),
        "requester": {"email": request.customer_email},
        "custom_fields": {
            "ai_conversation_id": request.conversation_id,
            "ai_escalation_reason": request.summary
        }
    }

    result = await helpdesk_client.create_ticket(ticket)

    return {
        "ticket_id": result["id"],
        "ticket_url": result["url"]
    }

Cas d'usage par secteur

E-commerce

SaaS / B2B

Services financiers

Bonnes pratiques

1. Transparence IA

Toujours indiquer quand le client parle a une IA et offrir l'option de parler a un humain.

2. Escalade gracieuse

Ne jamais laisser un client dans une impasse. Si l'IA ne peut pas aider, transferer immediatement.

3. Feedback loop

Collecter systematiquement le feedback pour ameliorer les reponses.

4. Mise a jour continue

Les politiques changent, les produits evoluent. Mettre a jour la KB en continu.

5. Test avant deploiement

Tester chaque nouvel article avec des vraies questions avant de le mettre en production.

Pour aller plus loin

• Base de connaissances intelligente - Centraliser le savoir
• Fondamentaux du Retrieval - Optimiser la recherche
• RGPD et Chatbots - Conformite des donnees clients

Automatisez votre support avec Ailog

Deployer un support client RAG performant necessite une infrastructure robuste et une expertise pointue. Avec Ailog, beneficiez d'une solution cle en main :

• Widget integrable en 3 minutes sur votre site
• Connecteurs natifs vers vos sources (FAQ, docs, tickets resolus)
• Detection d'intention et routage automatique
• Escalade seamless vers votre helpdesk existant
• Analytics temps reel pour mesurer le deflection rate
• Hebergement France conforme RGPD

Testez Ailog gratuitement et reduisez vos tickets niveau 1 de 70%.