Créer un robot évolutif de modération des discours anti-haine pour Telegram : une analyse approfondie

Gérer un groupe Telegram comptant 3 000 membres ne consiste pas seulement à augmenter le nombre, il s'agit également de favoriser une communauté sûre et respectueuse. Après avoir été confronté à des cas répétés de discours de haine, j'ai développé un robot de modération basé sur Node.js qui identifie et restreint automatiquement les utilisateurs publiant des insultes racistes. Dans cet article, je vais vous guider tout au long du processus de développement, de la conception au déploiement.

Le défi

La modération manuelle d'un grand groupe Telegram présente plusieurs défis :

• Les modérateurs ne peuvent pas être en ligne 24h/24 et 7j/7
• Le contenu préjudiciable peut se propager rapidement avant d'être supprimé
• L'application cohérente des règles est difficile
• Un volume élevé de messages rend la révision manuelle peu pratique

Architecture technique

Technologies de base

• Node.js : Environnement d'exécution
• node-telegram-bot-api : wrapper officiel de l'API Telegram Bot
• Express.js : serveur Web pour la future implémentation de webhook
• dotenv : Gestion des variables d'environnement
• Body-parser : Demander un middleware d'analyse

Configuration du robot

Tout d'abord, nous avons configuré la structure de base du bot avec une gestion appropriée des erreurs :

const TelegramBot = require('node-telegram-bot-api');
const express = require('express');
const bodyParser = require('body-parser');
const dotenv = require('dotenv');
const logging = require('console');

dotenv.config();

const BOT_TOKEN = process.env.BOT_TOKEN;
const bot = new TelegramBot(BOT_TOKEN, { polling: true });

Système de surveillance des messages

Le bot met en œuvre un système de surveillance multicouche :

1. Réception du message initial :

bot.on('message', async (msg) => {
  if (!msg.chat || !msg.from) return;
  // Message processing logic
});

1. Analyse de contenu :

function checkForRacialSlurs(message) {
  if (!message) return false;
  return RACIAL_SLURS.some(slur => 
    message.toLowerCase().includes(slur)
  );
}

1. Actions coercitives :

async function restrictUser(chatId, userId) {
  try {
    await bot.restrictChatMember(chatId, userId, {
      permissions: {
        can_send_messages: false,
        can_send_media_messages: false,
        can_send_polls: false,
        can_send_other_messages: false,
        can_add_web_page_previews: false,
        can_change_info: false,
        can_invite_users: false,
        can_pin_messages: false,
      },
    });
    return true;
  } catch (error) {
    logging.error('Restriction failed:', error);
    return false;
  }
}

Fonctionnalités avancées

1. Système de gestion du personnel

Le bot comprend un système de présentation du personnel pour un accès facile aux informations du modérateur :

const STAFF_LAYOUT = ` 
<b>GROUP STAFF</b>

? <b>Founder</b>
└ @Sixademiks

⚜️ <b>Verified Vendors</b>
├ @Vendor1 (City1)
└ @Vendor2 (City2)
`;

2. Système de message de bienvenue

Les nouveaux utilisateurs reçoivent un message de bienvenue formaté avec analyse HTML :

bot.onText(/\/start/, async (msg) => {
  try {
    const welcomeMessage = `
<b>Welcome to the DirtyNewz Bot!</b>
Please read the <b>pinned messages</b> for the group rules...`;
    await bot.sendMessage(msg.chat.id, welcomeMessage, { 
      parse_mode: 'HTML' 
    });
  } catch (error) {
    logging.error("Error in /start:", error);
  }
});

3. Système de journalisation

Une journalisation complète permet de suivre les performances des robots et les violations des utilisateurs :

logging.log('User was restricted due to violation');
logging.error('Error during restriction:', error);

Performances réelles

Après avoir déployé le bot dans notre groupe de 5 000 membres, nous avons observé :

• Disponibilité de 99,9 %
• Temps de réponse moyen de <100 ms
• Zéro faux positif dans la détection des insultes
• Réduction de 30 % de la charge de travail de modération
• Amélioration significative de l'ambiance communautaire

Défis et solutions de mise en œuvre

1. Limitation du débit

Au départ, nous atteignions les limites de débit de Telegram pendant les périodes de fort trafic. Solution :

const rateLimiter = {
  messageCount: 0,
  lastReset: Date.now(),
  check: function() {
    if (Date.now() - this.lastReset > 1000) {
      this.messageCount = 0;
      this.lastReset = Date.now();
    }
    return this.messageCount++ < 30;
  }
};

2. Gestion des erreurs

Une gestion robuste des erreurs empêche les plantages du bot :

process.on('unhandledRejection', (reason, promise) => {
  logging.error('Unhandled Rejection at:', promise, 'reason:', reason);
});

bot.on('polling_error', (error) => {
  logging.error('Polling error:', error);
});




<h3>
  
  
  3. Traitement des messages
</h3>

<p>Traitement efficace des messages pour gérer un volume élevé :<br>
</p>
<div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false">const TelegramBot = require('node-telegram-bot-api');
const express = require('express');
const bodyParser = require('body-parser');
const dotenv = require('dotenv');
const logging = require('console');

dotenv.config();

const BOT_TOKEN = process.env.BOT_TOKEN;
const bot = new TelegramBot(BOT_TOKEN, { polling: true });