Support client augmenté par l'IA

# Architecture du support augmenté

┌─────────────────────────────────────────────────────────────┐
│                    Interface Client                          │
│  Chatbot Web / WhatsApp / Messenger / API / Email           │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                 Orchestrateur IA (LLM)                       │
│  - Classification intention                                  │
│  - Extraction entités (produit, version, erreur)            │
│  - Détection urgence / sentiment                            │
└─────────────────────────────────────────────────────────────┘
                              │
              ┌───────────────┼───────────────┐
              ▼               ▼               ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│  Graphe produits │ │  Graphe tickets │ │  Base articles  │
│  - Versions      │ │  - Historique    │ │  - FAQ          │
│  - Compatibilités│ │  - Solutions     │ │  - Tutoriels    │
│  - Dépendances   │ │  - Contextes     │ │  - Vidéos       │
└─────────────────┘ └─────────────────┘ └─────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    Agent humain (escalade)                   │
│  - Dashboard avec suggestions IA                            │
│  - Accès à tout l'historique client                         │
│  - Résolution assistée                                      │
└─────────────────────────────────────────────────────────────┘

@prefix : <http://support.example.org/ontology#> .

# Entités support
:Client a owl:Class .
:Produit a owl:Class .
:Version a owl:Class .
:Ticket a owl:Class .
:Solution a owl:Class .
:ArticleBase a owl:Class .

# Relations
:possèdeProduit a owl:ObjectProperty .
:signaleProblème a owl:ObjectProperty .
:estRésoluPar a owl:ObjectProperty .
:estLiéÀ a owl:ObjectProperty .
:précède a owl:ObjectProperty .  # versions

# Règles d'inférence
# Si un client signale un problème sur une version obsolète
[ (:signaleProblème ?c ?p), (:estSurVersion ?c ?v), (:précède ?v ?nv) 
  -> (:recommandationMiseÀJour ?c ?nv) ]

# Si problème déjà résolu pour un autre client
[ (:problème ?p), (:estRésoluPar ?p ?s), (:contexteSimilaire ?p ?cp) 
  -> (:suggérerSolution ?cp ?s) ]

class SupportChatbot:
    def __init__(self, kg, vector_db, llm):
        self.kg = kg
        self.vector_db = vector_db
        self.llm = llm
        self.sessions = {}  # mémoire par session
    
    async def process_message(self, session_id, user_message, client_context):
        # 1. Récupération du contexte client
        if session_id not in self.sessions:
            self.sessions[session_id] = {
                'history': [],
                'client': client_context,
                'resolved': False
            }
        
        # 2. Classification de l'intention
        intent = await self.classify_intent(user_message)
        # Intents: "panne", "facturation", "information", "réclamation", "sav"
        
        # 3. Extraction des entités
        entities = await self.extract_entities(user_message)
        # {produit: "ProX", version: "2.1", erreur: "erreur 404"}
        
        # 4. Recherche dans le graphe de connaissances
        if intent == "panne":
            # Recherche de solutions connues pour ce problème
            solutions = self.kg.query(f"""
                SELECT ?solution ?article WHERE {{
                    ?prob a :Problème ;
                        :aPourProduit "{entities['produit']}" ;
                        :aPourErreur "{entities['erreur']}" ;
                        :estRésoluPar ?solution .
                    ?solution :documentéDans ?article .
                }}
            """)
            
            if solutions:
                # Solution trouvée
                response = self.format_solution(solutions[0])
                self.sessions[session_id]['resolved'] = True
                return response
        
        # 5. Recherche sémantique dans la base d'articles
        similar_articles = self.vector_db.similarity_search(user_message, k=3)
        
        # 6. Génération de réponse avec LLM
        response = await self.llm.generate(f"""
            Contexte client: {client_context}
            Historique: {self.sessions[session_id]['history'][-3:]}
            Intent: {intent}
            Entities: {entities}
            Articles similaires: {similar_articles}
            
            Question client: {user_message}
            
            Réponse (en français, professionnel, empathique):
        """)
        
        # 7. Mise à jour de l'historique
        self.sessions[session_id]['history'].append({
            'user': user_message,
            'assistant': response,
            'intent': intent,
            'resolved': len(similar_articles) > 0
        })
        
        # 8. Si non résolu, proposition d'escalade
        if not self.sessions[session_id]['resolved']:
            response += "\n\nSouhaitez-vous être mis en relation avec un agent ?"
        
        return response
    
    async def escalate_to_human(self, session_id, agent_id):
        """Escalade vers un agent humain avec contexte"""
        context = self.sessions[session_id]
        
        # Préparation du dashboard agent
        agent_dashboard = {
            'client': context['client'],
            'history': context['history'],
            'suggestions': self.generate_suggestions(context),
            'kb_articles': self.find_relevant_articles(context)
        }
        
        return agent_dashboard