Analyse du code source de ChatGPT-Feishu : Mécanismes de traitement d'événements et d'interaction avec l'API OpenAI

ChatGPT-Feishu est un assistant intelligent conçu pour les utilisateurs de la plateforme Feishu, intégrant de manière transparente les capacités avancées d'OpenAI dans l'environnement de discussion de Feishu. Cet article se penche sur le code source central du projet, révélant les mécanismes de traitement des événements et les principes d'interaction avec l'API OpenAI, permettant aux développeurs de comprendre comment le robot reçoit les messages, traite les instructions et génère des réponses intelligentes.

Vue d'ensemble des modules fonctionnels clés

La logique principale de ChatGPT-Feishu se concentre dans le fichier event.js, qui contient trois modules fonctionnels principaux :

• Système de traitement des événements : Responsable de la réception et de l'analyse des événements de message de la plateforme Feishu
• Centre d'analyse des commandes : Gère les commandes spéciales envoyées par les utilisateurs (comme /clear pour effacer le contexte, /image pour générer des images)
• Couche d'interaction OpenAI : Gère la communication avec l'API OpenAI, traite l'historique des conversations et les limites de tokens

Ces modules forment une chaîne de traitement complète via des appels de fonctions, du message reçu à la réponse générée par l'IA, constituant le flux de travail principal du robot.

Flux de traitement des événements : du message à la réponse

Les événements de message de la plateforme Feishu sont poussés vers le service du robot via Webhook, et la fonction principale module.exports dans event.js est chargée de recevoir et de traiter ces événements :

1. Vérification et filtrage des événements : D'abord, vérifie la légalité de l'événement et filtre les événements en double

// Pour un même événement, on ne le traite qu'une seule fois
const nombre = await BaseEvenements.where({ id_evenement: idEvenement }).count();
if (nombre != 0) {
  enregistrerLog("événement répétif ignoré");
  return { code: 1 };
}

2. Détermination du type de message : Distinction entre les messages privés (p2p) et les messages de groupe (group), dans le cas d'un groupe il faut que le robot soit mentionné pour déclencher une réponse

// Pour un groupe, il faut mentionner le robot
if (params.evenement.message.type_chat === "groupe") {
  // Si le robot n'est pas mentionné, on sort
  if (params.evenement.message.mentions[0].nom != NOM_ROBOT_FEISHU) {
    enregistrerLog("le nom du bot ne correspond pas au premier mentionné");
    return { code: 0 };
  }
}

3. Distribution et traitement des messages : Les messages valides sont transmis à la fonction gererReponse pour un traitement ultérieur

Conception du système de commandes : rendre le robot plus intelligent

ChatGPT-Feishu met en œuvre un système de commandes flexible, géré par la fonction traiterCommande pour traiter diverses commandes utilisateur :

• Ensemble de commandes de base :
• /clear : Efface l'historique de la conversation actuelle
• /help : Affiche les informations d'aide
• /image [prompt] : Génère une image
• Flux de traitement des commandes :

async function traiterCommande(parametresCommande) {
  if(parametresCommande && parametresCommande.action.startsWith("/image")){
    // Logique de génération d'image
    url = await obtenirImageOpenAI(indication);
    await repondre(parametresCommande.idMessage,url);
    return;
  }
  switch (parametresCommande && parametresCommande.action) {
    case "/aide":
      await cmdAide(parametresCommande.idMessage);
      break;
    case "/effacer":
      await cmdEffacer(parametresCommande.idSession, parametresCommande.idMessage);
      break;
    default:
      await cmdAide(parametresCommande.idMessage);
      break;
  }
}

Cette conception permet aux utilisateurs d'interagir avec le robot via des commandes simples, améliorant considérablement l'expérience utilisateur.

Interaction avec l'API OpenAI : le travail en coulisses des réponses intelligentes

L'interaction avec l'API OpenAI constitue la capacité principale du robot, réalisée par la fonction obtenirReponseOpenAI :

1. Construction de la requête API :

var donnees = JSON.stringify({
  modele: MODELE_OPENAI,
  messages: prompt
});

2. Configuration de la requête :

var configuration = {
  methode: "post",
  url: "https://api.openai.com/v1/chat/completions",
  enTetes: {
    Autorisation: `Bearer ${CLE_OPENAI}`,
    "Content-Type": "application/json",
  },
  donnees: donnees,
  delaiAttente: 50000
};

3. Gestion des erreurs :

try{
  const reponse = await axios(configuration);
  if (reponse.status === 429) {
    return 'Trop de questions, je suis un peu étourdi, veuillez réessayer plus tard';
  }
  return reponse.data.choices[0].message.content;
   }catch(erreur){
  enregistrerLog(erreur.response.data)
  return "Question trop difficile, erreur. (uДu〃).";
}

Gestion des conversations : maintien du contexte et contrôle des tokens

Pour offrir une expérience de conversation cohérente, ChatGPT-Feishu met en œuvre un mécanisme de gestion des conversations :

1. Construction de la conversation : La fonction construireConversation charge les messages historiques depuis la base de données pour construire le contexte complet de la conversation

async function construireConversation(idSession, question) {
  let prompt = [];
  // Récupère les enregistrements historiques de la table Message pour construire la question
  const messagesHistoriques = await TableMessage.where({ idSession }).trouver();
  for (const elementConversation of messagesHistoriques) {
      prompt.push({"role": "user", "content": elementConversation.question})
      prompt.push({"role": "assistant", "content": elementConversation.reponse})
  }
  // Ajoute la dernière question
  prompt.push({"role": "user", "content": question})
  return prompt;
}

2. Stockage de la conversation : La fonction sauvegarderConversation enregistre le nouveau contenu de la conversation
3. Contrôle des tokens : La fonction supprimerConversation garantit que la conversation ne dépasse pas les limites de tokens du modèle, en supprimant automatiquement les messages les plus anciens

Déploiement et configuration : faire fonctionner le robot

Pour que le robot ChatGPT-Feishu fonctionne correctement, une configuration appropriée des variables d'environnement est nécessaire :

const ID_APPLICATION_FEISHU = process.env.APPID || ""; // ID de l'application Feishu
const SECRET_APPLICATION_FEISHU = process.env.SECRET || ""; // Secret de l'application Feishu
const NOM_ROBOT_FEISHU = process.env.NOMBOT || ""; // Nom du robot Feishu
const CLE_OPENAI = process.env.CLE || ""; // Clé OpenAI
const MODELE_OPENAI = process.env.MODELE || "gpt-3.5-turbo"; // Modèle utilisé
const MAX_TOKEN_OPENAI = process.env.MAX_TOKEN || 1024; // Valeur maximale de tokens

Ces configurations sont injectées via des variables d'environnement, garantissant que les informations sensibles ne sont pas codées en dur dans le code, tout en offrant des options de déploiement flexibles.

Exploration de nouvelles possibilités

Le code source de ChatGPT-Feishu démontre comment intégrer de manière transparente la plateforme Feishu avec l'API OpenAI pour réaliser les fonctionnalités d'un robot intelligent. En comprenant les mécanismes de traitement des événements, la conception du système de commandes et l'interaction avec l'API, les développeurs peuvent étendre davantage les fonctionnalités du robot, telles qu'ajouter de nouvelles commandes, prendre en charge davantage de types de messages ou optimiser les stratégies de gestion des conversations.

L'architecture simple et l'organisation claire du code du projet en font un excellent exemple pour apprendre à construire des robots de conversation. Que ce soit pour étendre les fonctionnalités ou personnaliser son propre robot, une compréhension approfondie de ces principes d'implémentation fondamentaux est une étape indispensable.

Pour commencer à utiliser ou à contribuer à ce projet, vous pouvez cloner le dépôt : https://gitcode.com/gh_mirrors/ch/ChatGPT-Feishu et suivre les instructions du README pour le déploiement et la configuration.