Création d’assistants virtuels avec ChatGPT

Introduction

L’API ChatGPT permet de créer des assistants virtuels personnalisés pour différents cas d’utilisation. Dans ce tutoriel, nous allons explorer comment développer des assistants IA adaptés à vos besoins spécifiques.

Types d’assistants

1. Assistant de service client

   • Réponses aux FAQ
   • Gestion des réclamations
   • Support technique

2. Assistant personnel

   • Gestion de tâches
   • Rappels et calendrier
   • Recherche d’informations

3. Assistant spécialisé

   • Assistant juridique
   • Assistant médical
   • Assistant financier

Implémentation

1. Classe de base pour les assistants

import openai
from typing import List, Dict, Optional
import json

class VirtualAssistant:
    def __init__(self, api_key: str, system_prompt: str):
        self.api_key = api_key
        self.system_prompt = system_prompt
        self.conversation_history = []
        
    def add_to_history(self, role: str, content: str):
        """
        Ajoute un message à l'historique de conversation
        """
        self.conversation_history.append({
            "role": role,
            "content": content
        })
        
    def get_response(self, user_input: str) -> str:
        """
        Obtient une réponse de l'assistant
        """
        # Ajouter le message de l'utilisateur à l'historique
        self.add_to_history("user", user_input)
        
        try:
            response = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",
                messages=[
                    {"role": "system", "content": self.system_prompt},
                    *self.conversation_history
                ],
                temperature=0.7
            )
            
            assistant_response = response.choices[0].message.content
            
            # Ajouter la réponse à l'historique
            self.add_to_history("assistant", assistant_response)
            
            return assistant_response
        except Exception as e:
            print(f"Erreur lors de la génération de la réponse: {str(e)}")
            return "Désolé, une erreur est survenue."
            
    def clear_history(self):
        """
        Réinitialise l'historique de conversation
        """
        self.conversation_history = []

2. Assistant de service client

class CustomerServiceAssistant(VirtualAssistant):
    def __init__(self, api_key: str):
        system_prompt = """
        Vous êtes un assistant de service client professionnel et empathique.
        Votre rôle est d'aider les clients avec leurs questions et problèmes.
        
        Instructions:
        1. Soyez toujours poli et professionnel
        2. Répondez de manière claire et concise
        3. Si vous ne connaissez pas la réponse, proposez d'escalader au service client
        4. Collectez les informations nécessaires pour résoudre le problème
        5. Utilisez un ton empathique et compréhensif
        """
        super().__init__(api_key, system_prompt)
        
    def handle_complaint(self, complaint: str) -> Dict[str, str]:
        """
        Gère une réclamation client
        """
        prompt = f"""
        Analysez cette réclamation client et fournissez une réponse appropriée:
        
        Réclamation: {complaint}
        
        Fournissez:
        1. Une réponse empathique
        2. Une solution proposée
        3. Les prochaines étapes
        """
        
        response = self.get_response(prompt)
        
        return {
            'complaint': complaint,
            'response': response
        }
        
    def answer_faq(self, question: str) -> Dict[str, str]:
        """
        Répond à une question fréquente
        """
        prompt = f"""
        Répondez à cette question fréquente:
        
        Question: {question}
        
        Fournissez:
        1. Une réponse claire et concise
        2. Des informations supplémentaires pertinentes
        3. Des liens vers la documentation si nécessaire
        """
        
        response = self.get_response(prompt)
        
        return {
            'question': question,
            'answer': response
        }

3. Assistant personnel

class PersonalAssistant(VirtualAssistant):
    def __init__(self, api_key: str):
        system_prompt = """
        Vous êtes un assistant personnel intelligent et serviable.
        Votre rôle est d'aider l'utilisateur avec ses tâches quotidiennes.
        
        Instructions:
        1. Soyez proactif dans vos suggestions
        2. Gardez une trace des préférences de l'utilisateur
        3. Adaptez vos réponses au contexte
        4. Soyez concis mais informatif
        5. Proposez des alternatives quand c'est pertinent
        """
        super().__init__(api_key, system_prompt)
        
    def manage_task(self, task: str) -> Dict[str, str]:
        """
        Gère une tâche
        """
        prompt = f"""
        Aidez à gérer cette tâche:
        
        Tâche: {task}
        
        Fournissez:
        1. Un plan d'action
        2. Des rappels suggérés
        3. Des ressources utiles
        """
        
        response = self.get_response(prompt)
        
        return {
            'task': task,
            'plan': response
        }
        
    def search_information(self, query: str) -> Dict[str, str]:
        """
        Recherche des informations
        """
        prompt = f"""
        Recherchez des informations sur:
        
        Requête: {query}
        
        Fournissez:
        1. Une réponse directe
        2. Des sources fiables
        3. Des informations connexes pertinentes
        """
        
        response = self.get_response(prompt)
        
        return {
            'query': query,
            'information': response
        }

4. Assistant spécialisé

class SpecializedAssistant(VirtualAssistant):
    def __init__(self, api_key: str, specialization: str):
        system_prompt = f"""
        Vous êtes un assistant spécialisé en {specialization}.
        Votre rôle est de fournir des conseils et informations spécialisés.
        
        Instructions:
        1. Utilisez un langage technique approprié
        2. Citez des sources fiables
        3. Restez dans votre domaine d'expertise
        4. Soyez précis et détaillé
        5. Indiquez clairement les limites de vos conseils
        """
        super().__init__(api_key, system_prompt)
        self.specialization = specialization
        
    def provide_advice(self, query: str) -> Dict[str, str]:
        """
        Fournit des conseils spécialisés
        """
        prompt = f"""
        En tant qu'expert en {self.specialization}, fournissez des conseils sur:
        
        Question: {query}
        
        Fournissez:
        1. Une analyse détaillée
        2. Des recommandations spécifiques
        3. Des mises en garde ou précautions
        4. Des ressources supplémentaires
        """
        
        response = self.get_response(prompt)
        
        return {
            'query': query,
            'advice': response
        }

Exemples d’utilisation

1. Assistant de service client

# Création d'un assistant de service client
customer_service = CustomerServiceAssistant('votre_clé_api')

# Gestion d'une réclamation
complaint = "Mon produit ne fonctionne pas correctement depuis la mise à jour."
response = customer_service.handle_complaint(complaint)
print(f"Réponse à la réclamation: {response['response']}")

# Réponse à une FAQ
question = "Quelle est votre politique de remboursement ?"
answer = customer_service.answer_faq(question)
print(f"Réponse FAQ: {answer['answer']}")

2. Assistant personnel

# Création d'un assistant personnel
personal_assistant = PersonalAssistant('votre_clé_api')

# Gestion d'une tâche
task = "Organiser une réunion d'équipe pour la semaine prochaine"
plan = personal_assistant.manage_task(task)
print(f"Plan d'action: {plan['plan']}")

# Recherche d'informations
query = "Meilleurs restaurants végétariens à Paris"
info = personal_assistant.search_information(query)
print(f"Informations: {info['information']}")

3. Assistant spécialisé

# Création d'un assistant juridique
legal_assistant = SpecializedAssistant('votre_clé_api', 'droit')

# Conseil juridique
query = "Quelles sont les étapes pour créer une SARL en France ?"
advice = legal_assistant.provide_advice(query)
print(f"Conseil juridique: {advice['advice']}")

# Création d'un assistant médical
medical_assistant = SpecializedAssistant('votre_clé_api', 'médecine')

# Information médicale
query = "Quels sont les symptômes courants de la grippe ?"
advice = medical_assistant.provide_advice(query)
print(f"Information médicale: {advice['advice']}")

Bonnes pratiques

1. Personnalisation

   • Adaptez le système prompt au cas d’utilisation
   • Maintenez un historique de conversation pertinent
   • Personnalisez les réponses selon le contexte

2. Gestion du contexte

   • Limitez la taille de l’historique
   • Identifiez les informations importantes
   • Gérer la persistance des données

3. Sécurité et confidentialité

   • Protégez les données sensibles
   • Respectez la vie privée
   • Conformité RGPD

4. Amélioration continue

   • Collectez les retours utilisateurs
   • Analysez les conversations
   • Affinez les réponses

Ressources supplémentaires

• Documentation OpenAI API
• Guide des assistants virtuels
• Best practices pour les chatbots
• Exemples d’assistants