ChatGPT The Helper !

Automatisation de l’Aide sur le Serveur Discord d'iMot3k : Une Révolution Grâce à ChatGPT

Les Défis de la Modération d’un Serveur Discord

La Solution : Intégration de ChatGPT

Le Point de Départ : Un Fichier Initial Basique

import os
import re
import logging
import datetime
from openai import OpenAI, AsyncOpenAI
import nextcord
from nextcord.ext import commands

# Initialisation des variables d'environnement
FORUM_CHANNEL_IDS = os.getenv('FORUM_CHANNEL_IDS', '').split(',')
BOT_TOKEN = os.getenv('BOT_TOKEN')
GPT_CHANNEL_ID = os.getenv('GPT_CHANNEL_ID')

# Initialisation de l'API OpenAI
openai_client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
async_openai_client = AsyncOpenAI(api_key=os.getenv('OPENAI_API_KEY'))

logging.basicConfig(level=logging.INFO,
                    format='%(asctime)s %(message)s',
                    datefmt='%m/%d/%Y %I:%M:%S %p',
                    handlers=[logging.StreamHandler(),
                              logging.FileHandler("thread_log.txt")])

bot = commands.Bot(command_prefix="§")

@bot.event
async def on_ready():
    print(f"We have logged in as {bot.user}")
    await bot.change_presence(activity=nextcord.Game(name="t'aider dans les forums"))
    bot.message_context = {}

Étape 1 : Définir les Besoins et les Objectifs

1. Répondre automatiquement aux nouvelles discussions (threads) créées dans les forums spécifiques.

2. Offrir des réponses précises et pédagogiques, notamment en analysant les images postées par les utilisateurs.

3. Gérer les interactions en temps réel, tout en maintenant des coûts raisonnables.

4. Fournir un suivi et des logs détaillés pour améliorer continuellement ses performances.

Étape 2 : Intégration avec OpenAI

Initialisation du Client OpenAI

# Assurez-vous que la clé API est définie
api_key = os.getenv('OPENAI_API_KEY')
if not api_key:
    raise ValueError("La clé API 'OPENAI_API_KEY' n'est pas définie dans les variables d'environnement.")

# Initialiser le client OpenAI
client = OpenAI(api_key=api_key)

Création des Événements et Commandes Slash

class AutoReply(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    @commands.Cog.listener()
    async def on_thread_create(self, thread: nextcord.Thread):
        if thread.parent_id not in auto_reply_forum_ids:
            return

        # Récupération du premier message du thread
        messages = await thread.history(limit=1).flatten()
        if not messages:
            logger.warning(f"Aucun message trouvé dans le thread: {thread.name} (ID: {thread.id})")
            return

        base_message = messages[0]
        base_content = f"Pseudo: {base_message.author.name}\nTitre: {thread.name}\nContenu du thread: {base_message.content}"

        logger.info(f"Thread créé par {base_message.author.name} (ID: {base_message.author.id}) dans le forum (ID: {thread.parent_id})")

        image_urls = [a.url for a in base_message.attachments if a.url.endswith(('png', 'jpeg', 'jpg', 'gif', 'webp'))]
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": "Date du jour : {datetime.datetime.now()}"},
                {"role": "system", "content": "Tu es un expert ..."},
                {"role": "user", "content": base_content}
            ]
        )

        embed_content = response.choices[0].message.content.strip()
        embed = Embed(title="Réponse de iBot-GPT", description=embed_content, color=0x454FBF)
        await thread.send(embed=embed)

Étape 3 : Optimisation de la Gestion des Messages et des Fichiers

# Analyse des images et ajout du contexte au message
descriptions = {}
image_cost = 0

for attachment in base_message.attachments:
    file_extension = attachment.filename.split('.')[-1].lower()
    if file_extension in SUPPORTED_IMAGE_FORMATS:
        try:
            image_size = attachment.size
            if image_size > 512 * 512:
                image_cost += 0.002125  # Coût pour images plus grandes que 512x512
            else:
                image_cost += 0.001275  # Coût pour images jusqu'à 512x512

            response = client.chat.completions.create(
                model="gpt-4o",
                messages=[
                    {"role": "user", "content": [
                        {"type": "text", "text": "Décris cette image du point de vue d'une aide informatique."},
                        {"type": "image_url", "image_url": {"url": attachment.url}}
                    ]}
                ],
                max_tokens=500
            )
            description = response.choices[0].message.content
            descriptions[attachment.url] = description
        except Exception as e:
            logger.error(f"Erreur lors de l'appel à l'API d'OpenAI pour la description de l'image: {e}", exc_info=True)
            descriptions[attachment.url] = "Description non disponible."
    else:
        descriptions[attachment.url] = f"[Fichier non supporté: {attachment.filename}]"

    await asyncio.sleep(1)  # Petite pause pour éviter les rate limits

Étape 4 : Amélioration des Logs et de la Configuration

# Configuration du logger
logger = logging.getLogger('bot')
logger.setLevel(logging.INFO)

formatter = logging.Formatter('%(asctime)s [%(name)s] %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')

stream_handler = logging.StreamHandler()
stream_handler.setFormatter(formatter)

file_handler = logging.FileHandler("bot_log.txt")
file_handler.setFormatter(formatter)

logger.addHandler(stream_handler)
logger.addHandler(file_handler)

Étape 5 : Optimisation et Calcul des Coûts

# Calcul du coût des tokens
input_cost = prompt_tokens * 0.000005  # Coût approximatif des tokens de prompt de GPT-4o
output_cost = completion_tokens * 0.000015  # Coût approximatif des tokens de completion de GPT-4o
total_cost = input_cost + output_cost + image_cost

embed.set_footer(text=f"Total Tokens: {response.usage.total_tokens} | Coût: {total_cost:.6f} USD")

Étape 6 : Module de Commande "Ask-GPT"

class AskGpt(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    @nextcord.slash_command(name="ask-gpt", description="Pose une question à GPT-4o et reçois une réponse")
    async def ask_gpt(self, interaction: Interaction, question: str):
        if any.role.id in ask_gpt_unauthorized_role_ids for role in interaction.user.roles:
            await interaction.response.send_message("Vous n'avez pas la permission d'utiliser cette commande.", ephemeral=True)
            return

        user = interaction.user
        channel = interaction.channel

        logger.info(f"Commande /ask-gpt utilisée par {user} dans le salon {channel.name}")

        await interaction.response.defer(ephemeral=False)

        system_message = {
            "role": "system",
            "content": (
                "Tu es un expert en informatique nommé iBot-GPT. "
                "Si tu reçois une question qui ne concerne pas ce domaine, n'hésite pas à rappeler à l'utilisateur que ce serveur est axé sur l'informatique. "
                "Assure-toi toujours de t'adresser en tutoyant l'utilisateur. "
                "Pour améliorer la lisibilité, utilise le markdown pour mettre le texte en forme (gras, italique, souligné), en mettant en gras les parties importantes."
            )
        }

        user_message = {"role": "user", "content": question}

        try:
            response = client.chat.completions.create(
                model="gpt-4o",
                messages=[system_message, user_message],
                max_tokens=1500
            )

            answer = response.choices[0].message.content
            total_tokens = response.usage.total_tokens
            prompt_tokens = response.usage.prompt_tokens
            completion_tokens = response.usage.completion_tokens

            input_cost = prompt_tokens * 5 / 1_000_000  # coût des tokens d'entrée
            output_cost = completion_tokens * 15 / 1_000_000  # coût des tokens de sortie
            total_cost = input_cost + output_cost

            embed = Embed(title="Réponse de iBot-GPT", description=answer, color=0x454FBF)
            embed.set_footer(text=f"Total Tokens: {total_tokens} | Coût Total: {total_cost:.6f} USD")

            await interaction.followup.send(embed=embed)
        except Exception as e:
            logger.error(f"Erreur lors de l'appel à l'API d'OpenAI: {e}", exc_info=True)
            await interaction.followup.send(
                content="Une erreur s'est produite lors de l'appel à l'API d'OpenAI.",
            )

Amélioration Continue et Suivi des Performances

Les Défis des Modèles de Langage : Hallucinations et Faux Positifs

Le Module de Résumé : Une Aide pour les Modérateurs

Résultats et Impact sur la Communauté

1. Réponses Plus Rapides et Pertinentes : Les utilisateurs reçoivent des réponses instantanées et précises, ce qui réduit le temps d'attente et améliore l'expérience utilisateur.

2. Allègement de la Charge des Modérateurs : Les modérateurs peuvent maintenant se concentrer sur des tâches plus complexes et engageantes, sans être encombrés par des questions répétitives.

3. Amélioration de la Qualité des Discussions : La communauté engage désormais des discussions plus profondes et techniques, enrichissant ainsi le contenu du serveur.

4. Suivi et Optimisation Continue : Grâce aux logs détaillés, je peux surveiller les performances du bot et apporter des améliorations continues pour répondre aux besoins de la communauté.

Sources

ChatGPT The Helper ! Data