Applications conversationnelles avec les LLM

Introduction

Les modèles de langage permettent de créer des applications conversationnelles sophistiquées capables de comprendre et de répondre de manière naturelle aux utilisateurs. Ce tutoriel explore les différentes façons d’implémenter des chatbots et des assistants virtuels avec les LLM.

Types d’applications conversationnelles

1. Chatbots

Service client
Support technique
Vente et marketing
FAQ interactive
Assistant personnel

2. Assistants virtuels

Assistant personnel
Assistant de productivité
Assistant éducatif
Assistant de santé
Assistant financier

3. Agents conversationnels

Agents de recherche
Agents de recommandation
Agents de planification
Agents de prise de décision
Agents de coordination

Implémentation

1. Base de conversation

from openai import OpenAI
import json
from typing import List, Dict, Any

class ConversationManager:
    def __init__(self, api_key: str):
        self.client = OpenAI(api_key=api_key)
        self.conversation_history: List[Dict[str, str]] = []
    
    def add_message(self, role: str, content: str):
        self.conversation_history.append({
            "role": role,
            "content": content
        })
    
    def get_response(self, user_message: str) -> str:
        # Ajouter le message de l'utilisateur
        self.add_message("user", user_message)
        
        # Obtenir la réponse du modèle
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=self.conversation_history,
            temperature=0.7
        )
        
        # Extraire et sauvegarder la réponse
        assistant_message = response.choices[0].message.content
        self.add_message("assistant", assistant_message)
        
        return assistant_message
    
    def clear_history(self):
        self.conversation_history = []

2. Gestionnaire de contexte

class ContextManager:
    def __init__(self):
        self.context: Dict[str, Any] = {}
    
    def update_context(self, key: str, value: Any):
        self.context[key] = value
    
    def get_context(self, key: str) -> Any:
        return self.context.get(key)
    
    def clear_context(self):
        self.context = {}
    
    def get_context_summary(self) -> str:
        return json.dumps(self.context, indent=2)

3. Gestionnaire d’intentions

class IntentManager:
    def __init__(self, api_key: str):
        self.client = OpenAI(api_key=api_key)
    
    def detect_intent(self, message: str) -> Dict[str, Any]:
        prompt = f"""
        Analyse le message suivant et identifie :
        1. L'intention principale
        2. Les entités importantes
        3. Le sentiment
        4. Le niveau d'urgence
        
        Message : {message}
        
        Réponds au format JSON.
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "Tu es un expert en analyse d'intentions."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.3
        )
        
        return json.loads(response.choices[0].message.content)

Applications avancées

1. Assistant de service client

class CustomerServiceAssistant:
    def __init__(self, api_key: str):
        self.conversation_manager = ConversationManager(api_key)
        self.context_manager = ContextManager()
        self.intent_manager = IntentManager(api_key)
    
    def handle_query(self, user_message: str) -> str:
        # Détecter l'intention
        intent = self.intent_manager.detect_intent(user_message)
        
        # Mettre à jour le contexte
        self.context_manager.update_context("current_intent", intent)
        
        # Préparer le prompt système
        system_prompt = self._create_system_prompt(intent)
        
        # Obtenir la réponse
        response = self.conversation_manager.get_response(user_message)
        
        return response
    
    def _create_system_prompt(self, intent: Dict[str, Any]) -> str:
        return f"""
        Tu es un assistant de service client professionnel.
        
        Contexte actuel :
        - Intention : {intent['intent']}
        - Sentiment : {intent['sentiment']}
        - Urgence : {intent['urgency']}
        
        Réponds de manière :
        1. Professionnelle et empathique
        2. Précise et concise
        3. Orientée vers la solution
        4. Adaptée au niveau d'urgence
        """

2. Assistant personnel

class PersonalAssistant:
    def __init__(self, api_key: str):
        self.conversation_manager = ConversationManager(api_key)
        self.context_manager = ContextManager()
        self.tasks = []
    
    def handle_request(self, user_message: str) -> str:
        # Analyser la demande
        intent = self.intent_manager.detect_intent(user_message)
        
        if intent['intent'] == 'task_management':
            return self._handle_task_management(user_message)
        elif intent['intent'] == 'information_request':
            return self._handle_information_request(user_message)
        else:
            return self.conversation_manager.get_response(user_message)
    
    def _handle_task_management(self, user_message: str) -> str:
        # Extraire les détails de la tâche
        task_details = self._extract_task_details(user_message)
        
        # Ajouter la tâche
        self.tasks.append(task_details)
        
        return f"J'ai ajouté la tâche : {task_details['title']}"
    
    def _handle_information_request(self, user_message: str) -> str:
        # Rechercher l'information demandée
        context = self.context_manager.get_context_summary()
        
        prompt = f"""
        Contexte actuel : {context}
        
        Question : {user_message}
        
        Fournis une réponse précise et pertinente.
        """
        
        return self.conversation_manager.get_response(prompt)

Optimisation et personnalisation

1. Gestion de la personnalité

class PersonalityManager:
    def __init__(self, api_key: str):
        self.client = OpenAI(api_key=api_key)
    
    def generate_personality(self, traits: Dict[str, float]) -> str:
        prompt = f"""
        Crée une personnalité pour un assistant avec les traits suivants :
        
        Traits : {json.dumps(traits, indent=2)}
        
        Définis :
        1. Le ton de voix
        2. Le style de communication
        3. Les expressions caractéristiques
        4. Les réponses types
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "Tu es un expert en création de personnalités."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.8
        )
        
        return response.choices[0].message.content

2. Gestion de l’apprentissage

class LearningManager:
    def __init__(self):
        self.interactions = []
        self.feedback = []
    
    def add_interaction(self, interaction: Dict[str, Any]):
        self.interactions.append(interaction)
    
    def add_feedback(self, feedback: Dict[str, Any]):
        self.feedback.append(feedback)
    
    def analyze_performance(self) -> Dict[str, Any]:
        return {
            "total_interactions": len(self.interactions),
            "positive_feedback": len([f for f in self.feedback if f['sentiment'] == 'positive']),
            "negative_feedback": len([f for f in self.feedback if f['sentiment'] == 'negative']),
            "common_issues": self._analyze_common_issues()
        }
    
    def _analyze_common_issues(self) -> List[str]:
        # Analyser les interactions pour identifier les problèmes récurrents
        issues = []
        for interaction in self.interactions:
            if interaction.get('issue'):
                issues.append(interaction['issue'])
        return list(set(issues))

Bonnes pratiques

1. Gestion des erreurs

class ErrorHandler:
    def __init__(self):
        self.error_log = []
    
    def handle_error(self, error: Exception, context: Dict[str, Any]):
        error_entry = {
            "error_type": type(error).__name__,
            "error_message": str(error),
            "context": context,
            "timestamp": time.time()
        }
        
        self.error_log.append(error_entry)
        
        return self._generate_error_response(error)
    
    def _generate_error_response(self, error: Exception) -> str:
        if isinstance(error, OpenAIError):
            return "Désolé, je rencontre des difficultés techniques. Veuillez réessayer plus tard."
        elif isinstance(error, ValueError):
            return "Je n'ai pas compris votre demande. Pourriez-vous la reformuler ?"
        else:
            return "Une erreur inattendue s'est produite. Veuillez réessayer."

2. Monitoring et analytics

class AnalyticsManager:
    def __init__(self):
        self.metrics = {
            "total_conversations": 0,
            "average_response_time": 0,
            "success_rate": 0,
            "user_satisfaction": 0
        }
    
    def update_metrics(self, conversation_data: Dict[str, Any]):
        self.metrics["total_conversations"] += 1
        self.metrics["average_response_time"] = self._update_average(
            self.metrics["average_response_time"],
            conversation_data["response_time"]
        )
        self.metrics["success_rate"] = self._calculate_success_rate()
        self.metrics["user_satisfaction"] = self._calculate_satisfaction()
    
    def get_metrics_report(self) -> Dict[str, Any]:
        return {
            "metrics": self.metrics,
            "trends": self._calculate_trends(),
            "recommendations": self._generate_recommendations()
        }

Conclusion

Les LLM offrent des possibilités exceptionnelles pour créer des applications conversationnelles sophistiquées. En utilisant les techniques présentées dans ce tutoriel, vous pouvez :

Créer des chatbots et assistants virtuels personnalisés
Gérer efficacement le contexte et les intentions
Optimiser les réponses et la personnalité
Suivre et améliorer les performances
Gérer les erreurs et le monitoring

Dans le prochain tutoriel, nous explorerons l’utilisation des LLM pour la création d’applications de traitement du langage naturel (NLP) avancées.