Créer un agent IA intelligent pour la modération de contenu avec une sortie structurée

Construire un agent intelligent d'IA pour la modération de contenu avec une sortie structurée

Dans ce tutoriel, nous allons explorer comment créer un agent d'IA intelligent capable de modérer du contenu et de générer des rapports structurés. Nous allons utiliser les nouvelles fonctionnalités d'OpenAI pour la sortie structurée et l'appel de fonctions afin de construire ce système avancé. Notre objectif est de développer une IA capable d'analyser le contenu efficacement et de fournir des résultats détaillés et organisés.

L'évolution des sorties d'IA

OpenAI a récemment introduit des capacités de sortie structurée, ce qui a changé notre manière de travailler avec les modèles d'IA. Avant cette mise à jour, les développeurs étaient confrontés à de nombreux défis lors de l'utilisation de contenu généré par l'IA. Les réponses étaient généralement simplement du texte brut ou des formats JSON simples. Cela a posé des problèmes tant pour les développeurs que pour les entreprises.

Le manque de structure dans les sorties d'IA conduisait souvent à des informations incohérentes. Les développeurs devaient écrire du code complexe pour donner un sens aux réponses de l'IA, ce qui prenait beaucoup de temps et pouvait entraîner des erreurs. Il était également difficile de contrôler la manière dont l'IA présentait l'information, rendant l'utilisation de ces sorties dans les systèmes existants compliquée.

Ces limitations ont rendu spécialement difficile la construction d'applications fiables pour des tâches nécessitant des données précises et structurées. Les équipes travaillant sur des documents légaux, des rapports de conformité et des analyses commerciales passaient plus de temps à gérer les sorties d'IA qu'à en tirer réellement des bénéfices.

Le changement de jeu : Sorties structurées

Mais maintenant, les choses ont changé. OpenAI a introduit quelque chose appelé "sorties structurées." Cela signifie que l'IA peut désormais nous fournir des informations dans un format beaucoup plus facile à utiliser. Imaginez demander une recette et recevoir une liste d'ingrédients et d'étapes soigneusement organisée, au lieu de juste un bloc de texte. C'est le genre d'amélioration dont nous parlons.

Pour notre agent de modération de contenu, c'est vraiment excitant. Nous pouvons maintenant demander à l'IA des types d'informations spécifiques dans des formats exacts. Besoin de clauses légales, de chiffres financiers ou d'exigences de conformité ? L'IA peut les fournir d'une manière structurée qui est facile à utiliser. Cela permet de gagner beaucoup de temps et d'efforts dans le traitement et l'organisation de l'information.

Mais ce n'est pas tout. OpenAI a également ajouté quelque chose appelé "appel de fonction" à ses modèles d'IA. C'est comme donner à notre agent d'IA la capacité d'appuyer sur des boutons et de tirer des leviers en fonction des informations qu'il traite. Il ne fournit pas seulement des données ; il peut également effectuer des actions.

En combinant les sorties structurées et l'appel de fonctions, notre agent devient incroyablement puissant. Il peut travailler avec plusieurs sources d'informations, prendre des décisions complexes et créer des rapports hautement personnalisés. C'est comme avoir un assistant super intelligent qui peut non seulement comprendre des informations complexes mais aussi en faire quelque chose d'utile.

Ce type d'IA peut être vraiment utile pour les entreprises qui doivent examiner beaucoup de contenu rapidement. Elle peut aider à garantir que le contenu respecte certaines normes, signaler des problèmes potentiels, et même suggérer des améliorations. Et parce qu'elle fonctionne rapidement et de manière cohérente, elle peut libérer des modérateurs humains pour se concentrer sur des tâches plus complexes.

Dans ce tutoriel, nous allons passer en revue la manière de construire ce type d'agent d'IA. Nous vous montrerons comment le configurer, comment utiliser ces nouvelles fonctionnalités et comment le faire fonctionner pour vos besoins spécifiques. À la fin, vous aurez un outil puissant qui peut aider pour toutes sortes de tâches de modération de contenu.

Allons coder

Tout d'abord, créons un nouveau répertoire pour notre projet :

mkdir structuredOutput

Ensuite, configurons un environnement virtuel. Cela nous aidera à gérer nos dépendances de projet séparément des autres projets Python.

• Pour Windows : python -m venv venv
• Pour macOS et Linux : python3 -m venv venv

Avec notre environnement virtuel activé, installons les bibliothèques requises :

pip install openai supabase-py python-dotenv

Maintenant, créons un fichier app.py dans le répertoire structuredOutput. Ce sera le fichier principal de notre projet.

Ensuite, créons un fichier .env dans le même répertoire. Ce fichier stockera nos informations sensibles comme les clés API. Ajoutez les espaces réservés suivants au fichier :

OPENAI_API_KEY=
SUPABASE_URL=
SUPABASE_KEY=

Ne vous inquiétez pas si vous n'avez pas encore ces clés. Dans la section suivante, nous vous guiderons pour créer un compte Supabase, configurer une table et obtenir les informations d'identification nécessaires. Nous expliquerons également comment obtenir votre clé API OpenAI si vous ne l'avez pas déjà.

En configurant notre environnement de cette manière, nous garantissons que notre projet est organisé, que nos dépendances sont gérées et que nos informations sensibles sont conservées en sécurité. Cette approche nous prépare au succès alors que nous avançons dans la construction de notre agent de sortie structurée.

Configuration des clés API

Maintenant que nous avons notre structure de projet en place, obtenons les clés d'API nécessaires pour notre application.

Clé API OpenAI

1. Visitez votre tableau de bord OpenAI à https://platform.openai.com/settings/organization/general
2. Cherchez la section des clés API et créez une nouvelle clé secrète.
3. Copiez cette clé et collez-la dans votre fichier .env pour la variable OPENAI_API_KEY.

Introduction à Supabase

Supabase est une alternative open-source à Firebase qui fournit une suite d'outils pour créer des applications évolutives et sécurisées. Elle offre une base de données PostgreSQL, une authentification, des API instantanées et des abonnements en temps réel, le tout dans un seul package.

Nous utilisons Supabase dans ce projet pour plusieurs raisons :

• Configuration facile : Supabase fournit une interface conviviale pour créer et gérer des bases de données.
• Puissance de PostgreSQL : Elle est construite sur PostgreSQL, ce qui nous donne accès à une base de données robuste et complète.
• Capacités en temps réel : Supabase permet la synchronisation des données en temps réel, ce qui peut être utile pour la génération collaborative de documents.
• Authentification intégrée : Bien que nous ne l'utilisions pas dans ce tutoriel, le système d'authentification de Supabase peut être précieux pour sécuriser votre application à l'avenir.
• Évolutivité : Supabase est conçu pour évoluer avec votre application, ce qui le rend adapté aussi bien aux petits projets qu'aux déploiements à grande échelle.

Configuration de Supabase

Maintenant, configurons votre projet Supabase :

1. Visitez https://supabase.com/dashboard/sign-up pour créer un compte Supabase si vous n'en avez pas déjà un.
2. Une fois connecté, cliquez sur "Nouveau projet" et suivez les instructions pour créer un nouveau projet.
3. Après la création de votre projet, vous serez dirigé vers le tableau de bord du projet.
4. Dans la barre latérale gauche, cliquez sur la page d'accueil de votre projet et faites défiler vers le bas pour trouver la section API.
5. Ici, vous trouverez l'URL de votre projet et la clé API. Copiez-les et ajoutez-les à votre fichier .env pour les variables SUPABASE_URL et SUPABASE_KEY respectivement.

Votre fichier .env devrait maintenant ressembler à cela (avec vos vraies clés, bien sûr) :

OPENAI_API_KEY=VOTRE_CLÉ_API_OPENAI
SUPABASE_URL=VOTRE_URL_SUPABASE
SUPABASE_KEY=VOTRE_CLÉ_SUPABASE

Étapes suivantes

Félicitations ! Vous avez maintenant configuré les comptes et les clés API nécessaires pour notre projet. Dans la section suivante, nous allons nous plonger dans la création de notre table Supabase, sélectionner les champs appropriés et configurer le schéma pour notre système de génération de documents. Cela posera les bases pour stocker et récupérer les données structurées avec lesquelles notre agent d'IA travaillera.

Création de la table Supabase

Maintenant que nous avons configuré notre projet Supabase, créons la table qui stockera nos données de modération. Cette table sera la colonne vertébrale de notre système de sortie structurée, nous permettant de stocker et de récupérer les résultats de modération de manière efficace.

Étapes pour créer la table

1. Dans votre tableau de bord du projet Supabase, cherchez la barre latérale et cliquez sur l'onglet "Éditeur de table".
2. Cliquez sur le bouton "Créer une nouvelle table".
3. Nommez votre table MODERATION_TABLE.
4. Désélectionnez l'option "Activer la sécurité au niveau des lignes (RLS)" pour l'instant. (Remarque : Dans un environnement de production, vous voudriez mettre en place des règles de sécurité appropriées.)

Configuration du schéma

Pour notre projet de modération, nous avons besoin d'un schéma spécifique qui peut accueillir divers aspects de la modération de contenu. Dans l'interface utilisateur de Supabase, vous verrez une section intitulée "Colonnes" avec des options pour "À propos des types de données" et "Importer des données via un tableur". En dessous, vous trouverez des champs pour "Nom", "Type", "Valeur par défaut" et "Principal".

Voici le schéma que nous allons utiliser :

• id (texte) - Défini comme Principal
• content_id (texte)
• status (texte)
• content (texte)
• reported_to (texte)
• is_offensive (bool)
• confidence_score (float4)
• flagged_terms (texte)
• created_at (timestamp) - Définir la valeur par défaut à now()
• moderation_result (texte)

Ajoutez chacune de ces colonnes à votre table en utilisant l'interface utilisateur de Supabase. Assurez-vous de définir le bon type de données pour chaque colonne et de marquer la colonne id comme clé primaire.

Après avoir ajouté toutes les colonnes, cliquez sur le bouton "Enregistrer" pour créer votre table.

Étapes suivantes

Avec notre table Supabase maintenant configurée, nous avons une base solide pour stocker la sortie structurée de notre agent de modération IA. Dans la section suivante, nous commencerons à construire le code Python pour interagir avec cette table, y compris des fonctions pour insérer de nouvelles entrées de modération et en récupérer des existantes. Cela formera le cœur des capacités de gestion des données de notre système de modération.

Entrons dans le codage réel

Décortiquons ce code en sections et plongeons ensuite dans chaque fonction. Nous commencerons par les deux premières sections.

Importations et configuration initiale

Cette section configure notre environnement en important les bibliothèques nécessaires et en initialisant les composants clés. Nous utilisons Pydantic pour la validation des données, OpenAI pour les interactions avec l'IA, et Supabase pour les opérations de base de données. Colorama est utilisé pour la sortie colorée dans la console, améliorant la lisibilité.

Opérations de base de données

Cette fonction, supabase_operation, est un helper polyvalent pour interagir avec notre base de données Supabase. Elle prend en charge diverses opérations telles que l'insertion, la sélection, la mise à jour et la suppression. Décomposons-la :

• Nous commençons par créer un objet de requête pour notre MODERATION_TABLE.
• Selon l'opération (insertion, sélection, mise à jour ou suppression), nous modifions la requête en conséquence.
• Si des filtres sont fournis, nous les appliquons à la requête. Cela permet des opérations de base de données plus spécifiques.
• Enfin, nous exécutons la requête et retournons le résultat.

Cette fonction abstrait les complexités des opérations de base de données, rendant plus facile l'exécution de diverses actions sur nos données de modération dans le reste du code.

Modèles de données et fonctions de modération

Examinons la section suivante de notre code, qui définit nos modèles de données et nos fonctions de modération fondamentales.

Cette section définit les structures et fonctions de base de notre système de modération :

• Modèles Pydantic : Nous utilisons Pydantic pour définir des modèles de données structurés. ModerationResult représente la sortie de modération principale, tandis que ModerationOutput inclut des métadonnées supplémentaires sur le contenu modéré.
• Fonction moderate_text : C'est notre fonction principale de modération. Voici comment elle fonctionne :
• Elle prend un content_id et le contenu à modérer.
• Elle vérifie le contenu par rapport à une liste de termes offensants prédéfinis.
• Elle calcule si le contenu est offensant et attribue un score de confiance.
• Le résultat est formaté dans un dictionnaire qui correspond à notre modèle ModerationOutput.
• Le résultat est ensuite inséré dans notre base de données Supabase en utilisant la fonction supabase_operation que nous avons définie plus tôt.
• Enfin, elle retourne le résultat de modération.
• Cette fonction constitue le cœur de notre système de modération. C'est une version simplifiée qui pourrait être étendue avec des techniques de modération plus sophistiquées, telles que des modèles d'apprentissage automatique ou des ensembles de règles plus complexes.

L'utilisation des modèles Pydantic garantit que nos données sont systématiquement structurées tout au long de l'application, facilitant leur manipulation et leur validation.

La fonction block_content prend un content_id en entrée. Elle est conçue pour marquer le contenu comme bloqué lorsqu'il est jugé trop offensant. Cette fonction crée un enregistrement dans notre base de données indiquant que le contenu a été bloqué, ainsi que la raison. C'est une fonction cruciale pour maintenir les normes de contenu sur une plateforme.

La fonction issue_warning est utilisée pour le contenu qui est à la limite de l'inapproprié. Elle prend également un content_id et enregistre un avertissement dans la base de données. Cette fonction est utile pour suivre les utilisateurs qui publient fréquemment du contenu douteux ou pour donner une chance aux utilisateurs de modifier leur comportement avant de prendre des mesures plus sévères.

La fonction report_to_human est notre solution de secours pour les cas complexes. Elle prend à la fois le content_id et le contenu lui-même. Cette fonction signale le contenu pour un examen par un modérateur humain, ce qui est essentiel pour gérer des situations nuancées que l'IA pourrait ne pas être équipée pour juger avec précision.

Chacune de ces fonctions retourne un dictionnaire contenant des informations sur l'action entreprise. Elles utilisent toutes notre fonction supabase_operation pour insérer des enregistrements dans la base de données, garantissant que toutes les actions de modération sont enregistrées et traçables.

Configuration des messages initiaux

Cette section initialise la liste des messages, ce qui est crucial pour maintenir le contexte de la conversation avec l'IA :

• Le premier message définit le rôle du système, définissant le comportement de l'IA en tant qu'assistant de modération de contenu.
• Le deuxième message simule une entrée utilisateur initiale pour commencer la conversation.

Ces messages fournissent le contexte initial pour l'IA, préparant le terrain pour le processus de modération.

La boucle principale de conversation

Le cœur de notre système de modération de contenu est la boucle principale de conversation. Cette boucle gère l'interaction continue entre l'utilisateur et l'IA, en traitant les entrées, en traitant les réponses et en exécutant des actions de modération.

Initialisation

La boucle commence par une phase d'initialisation. Nous imprimons un message de bienvenue pour signaler que le système de modération est prêt. Cela donne à l'utilisateur une indication claire qu'il peut commencer à interagir avec le système. L'utilisation de texte coloré améliore l'expérience utilisateur.

Nous entrons ensuite dans une boucle infinie, permettant à notre système de continuer à accepter et à traiter l'entrée utilisateur jusqu'à ce qu'on lui dise explicitement d'arrêter.

Gestion de l'entrée utilisateur

À chaque itération, nous gérons l'entrée utilisateur. Le système invite l'utilisateur avec un préfixe vert "Utilisateur :". Nous vérifions ensuite si l'utilisateur souhaite quitter la conversation en comparant son entrée avec une liste de commandes de sortie. S'ils ne sortent pas, nous ajoutons leur entrée à notre liste de messages, maintenant ainsi l'historique complet de la conversation.

Analyse de contenu

Avec l'entrée de l'utilisateur capturée, nous passons à la phase d'analyse. Nous indiquons que l'analyse du contenu est en cours et ajoutons une brève pause pour une meilleure UX. Le système envoie ensuite une requête à l'API d'OpenAI, transmettant l'historique complet de la conversation, les fonctions disponibles et spécifiant que l'IA peut décider d'appeler une fonction.

Traitement de la réponse

Après réception de la réponse de l'API, nous la traitons. Nous vérifions si l'IA a décidé d'appeler une fonction. Si tel est le cas, nous extrayons le nom et les arguments de la fonction, préparant à exécuter l'action de modération appropriée.

Exécution des fonctions

Selon la fonction appelée, différentes actions sont entreprises :

• Pour la modération de texte, nous appelons la fonction moderate_text et traitons son résultat. D'autres actions peuvent être entreprises en fonction de la sortie de modération, telles que le blocage de contenu ou l'émission d'avertissements.
• D'autres fonctions gèrent des actions telles que le blocage de contenu, l'émission d'avertissements ou le signalement à des modérateurs humains. Chaque action est exécutée et son résultat est imprimé pour que l'utilisateur puisse le voir.

Réponse régulière de l'IA

Si aucune fonction n’est appelée, nous imprimons simplement la réponse de l'IA à l'utilisateur.

Achèvement du cycle

Cette section gère les exceptions et fournit une mise à jour finale de l'état. Le bloc except capture et affiche toutes les erreurs qui surviennent lors de l'exécution de la boucle principale, les imprimant en rouge pour les rendre visibles. La dernière déclaration d'impression, quel que soit les erreurs, confirme que le journal de modération a été enregistré dans la base de données, affiché en vert pour un renforcement positif. Cela assure aux utilisateurs qu'ils sont informés à la fois des erreurs et de l'achèvement réussi du processus de modération.

Exécution de l'agent

Pour exécuter l'agent de modération de contenu, suivez ces étapes :

1. Ouvrez votre terminal ou votre invite de commandes.
2. Accédez au répertoire contenant app.py.
3. Exécutez la commande suivante :

python app.py

Cela démarrera l'agent, et vous verrez le message d'initialisation. Vous pouvez alors commencer à interagir avec le système en tapant vos messages.

Flux de travail de l'agent

Dans une application réelle, cet agent ferait probablement partie d'un système plus vaste et asynchrone. Voici comment cela pourrait fonctionner :

• Tous les messages dans un chat ou une plateforme de médias sociaux seraient envoyés à cet agent pour modération.
• L'agent traiterait chaque message de manière asynchrone, permettant une modération en temps réel à volume élevé.
• Selon la décision de l'agent, les messages pourraient être :
• Autorisés immédiatement
• Bloqués pour publication
• Signalés pour un examen humain
• Déclencher des avertissements ou des actions sur les comptes utilisateurs
• Les résultats de modération seraient enregistrés dans la base de données pour l'audit et l'amélioration du système au fil du temps.

Cette configuration permet une modération de contenu évolutive, alimentée par l'IA, capable de gérer de grands volumes de messages à travers plusieurs conversations ou plateformes simultanément, offrant une expérience utilisateur plus sûre et plus contrôlée.

Conclusion

Dans ce tutoriel, nous avons construit un système de modération de contenu sophistiqué alimenté par l'IA en utilisant les capacités de sortie structurée et d'appel de fonction d'OpenAI. Ce système démontre comment :

• Configurer un environnement de développement pour les applications pilotées par l'IA
• Intégrer l'API d'OpenAI pour un traitement avancé du langage
• Mettre en œuvre une solution de base de données utilisant Supabase pour la journalisation et la persistance des données.
• Créer une boucle de modération de contenu robuste et interactive

En exécutant python app.py, vous pouvez démarrer l'agent et vivre la modération de contenu en temps réel. Dans un environnement de production, ce système pourrait être étendu pour gérer plusieurs conversations de manière asynchrone, fournissant une modération efficace et alimentée par l'IA pour diverses plateformes.

Ce projet sert de base pour construire des systèmes d'IA plus complexes, démontrant le potentiel de la combinaison des sorties structurées avec l'appel de fonction dans des applications pratiques. À mesure que la technologie de l'IA continue de progresser, des systèmes comme celui-ci joueront un rôle crucial dans le maintien d'environnements en ligne sûrs et productifs.