Construire un agent AI intelligent pour la modération de contenu avec sortie structurée
Dans ce tutoriel, nous allons explorer comment créer un agent AI intelligent qui peut modérer le contenu et générer des rapports structurés. Nous utiliserons 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 efficacement le contenu et de fournir des résultats détaillés et organisés.
L'évolution des sorties AI
OpenAI a récemment introduit des capacités de sortie structurée, ce qui a changé notre façon de travailler avec les modèles AI. Avant cette mise à jour, les développeurs faisaient face à de nombreux défis lors de l'utilisation de contenu généré par l'IA. Les réponses étaient généralement juste du texte brut ou des formats JSON simples. Cela a causé des problèmes à la fois pour les développeurs et les entreprises.
Le manque de structure dans les sorties AI conduisait souvent à des informations incohérentes. Les développeurs devaient écrire un code complexe pour donner un sens aux réponses de l'IA, ce qui prenait beaucoup de temps et pouvait mener à des erreurs. Il était également difficile de contrôler comment l'IA présentait les informations, rendant son utilisation dans les systèmes existants compliquée.
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 donner des informations dans un format beaucoup plus facile à utiliser. Imaginez demander une recette et recevoir une liste bien organisée d'ingrédients et d'étapes, plutôt qu'un gros bloc de texte. Voilà le genre d'amélioration dont nous parlons.
Pour notre agent de modération de contenu, c'est vraiment excitant. Nous pouvons désormais demander à l'IA des types spécifiques d'informations dans des formats exacts. Besoin de clauses légales, de chiffres financiers ou d'exigences de conformité ? L'IA peut les fournir de manière structurée et facile à utiliser. Cela fait gagner beaucoup de temps et d'efforts dans le traitement et l'organisation des informations.
Mais ce n'est pas tout. OpenAI a également ajouté quelque chose appelé "appel de fonction" à ses modèles AI. C'est comme donner à notre agent AI la capacité d'appuyer sur des boutons et de tirer des leviers en fonction de l'information qu'il traite. Il ne fournit pas seulement des données - il peut aussi agir.
En combinant les sorties structurées et l'appel de fonction, notre agent devient incroyablement puissant. Il peut travailler avec plusieurs sources d'information, 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 faire quelque chose d'utile avec. Ce type d'IA peut être vraiment utile pour les entreprises qui doivent examiner beaucoup de contenu rapidement. Il peut aider à s'assurer que le contenu respecte certaines normes, signaler les problèmes potentiels et même suggérer des améliorations. Et parce qu'il fonctionne rapidement et de manière cohérente, il peut libérer les modérateurs humains pour se concentrer sur des tâches plus complexes.
Passons au codage
Tout d'abord, créez un nouveau dossier pour notre projet :
mkdir structuredOutput
Ensuite, mettons en place 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 env
Pour macOS et Linux :
python3 -m venv env
Avec notre environnement virtuel activé, installons les bibliothèques requises :
pip install openai supabase
Maintenant, créez un fichier app.py dans le répertoire structuredOutput. Ce sera le fichier principal de notre projet.
Ensuite, créez 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 à travers la création d'un compte Supabase, la configuration d'une table et l'obtention des informations d'identification nécessaires. Nous expliquerons également comment obtenir votre clé API OpenAI si vous n'en avez pas déjà une.
Configuration des clés API
Maintenant que nous avons notre structure de projet en place, obtenons les clés API nécessaires pour notre application.
Clé API OpenAI
Pour obtenir votre clé API OpenAI :
- Visitez votre tableau de bord OpenAI à OpenAI Dashboard.
- Cherchez la section Clés API et créez une nouvelle clé secrète.
- 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 un ensemble d'outils pour créer des applications évolutives et sécurisées. Il offre une base de données PostgreSQL, une authentification, des APIs 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.
- La puissance de PostgreSQL : Il est construit 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 de données en temps réel, ce qui peut être utile pour la génération de documents collaboratifs.
- 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.
- Scalabilité : Supabase est conçu pour évoluer avec votre application, ce qui le rend adapté aux petits projets et aux déploiements à grande échelle.
Configuration de Supabase
Maintenant, configurons votre projet Supabase :
- Visitez Supabase Sign Up pour créer un compte Supabase si vous n'en avez pas déjà un.
- Une fois connecté, cliquez sur "Nouveau projet" et suivez les instructions pour créer un nouveau projet.
- Après la création de votre projet, vous serez dirigé vers le tableau de bord du projet.
- Dans la barre latérale de gauche, cliquez sur votre page d'accueil du projet et faites défiler vers le bas pour trouver la section API.
- Vous y trouverez votre URL de projet et votre 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 à ceci (avec vos clés réelles, bien sûr) :
OPENAI_API_KEY= SUPABASE_URL= SUPABASE_KEY=
Étapes suivantes
Bravo ! Vous avez maintenant configuré les comptes nécessaires et les clés API pour notre projet. Dans la section suivante, nous plongerons dans la création de notre table Supabase, le choix des champs appropriés et la configuration du schéma pour notre système de génération de documents. Cela sera la base pour stocker et récupérer les données structurées avec lesquelles notre agent AI va travailler.
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, permettant de stocker et de récupérer les résultats de modération efficacement.
Étapes pour créer la table
- Dans votre tableau de bord de projet Supabase, recherchez la barre latérale et cliquez sur l'onglet "Éditeur de table".
- Cliquez sur le bouton "Créer une nouvelle table".
- Nommez votre table
MODERATION_TABLE
. - Désélectionnez l'option "Activer la sécurité au niveau des lignes (RLS)" pour l'instant. (Remarque : Dans un environnement de production, vous voudrez mettre en place des règles de sécurité adéquates.)
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 une feuille de calcul". En dessous, vous trouverez des champs pour "Nom", "Type", "Valeur par défaut" et "Primaire".
Voici le schéma que nous allons utiliser :
- id (texte) - Défini comme primaire
- content_id (texte)
- statut (texte)
- contenu (texte)
- reported_to (texte)
- is_offensive (booléen)
- confidence_score (float4)
- flagged_terms (texte)
- created_at (timestamp) - Définir la valeur par défaut à maintenant()
- 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 AI. Dans la section suivante, nous commencerons à construire le code Python pour interagir avec cette table, y compris les fonctions pour insérer de nouvelles entrées de modération et récupérer celles existantes. Cela formera le noyau des capacités de gestion des données de notre système de modération.
Entrons dans le codage réel
Décomposons ce code en sections puis plongeons dans chaque fonction. Nous commencerons par les deux premières sections.
Imports 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 AI, et Supabase pour les opérations de base de données. Colorama est utilisé pour la sortie console colorée, 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, facilitant ainsi 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 principales.
Cette section définit les structures et fonctions de base pour 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 principale de la modération, tandis queModerationOutput
inclut des métadonnées supplémentaires sur le contenu modéré. - Fonction moderate_text : C'est notre fonction de modération principale. 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é en 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 précédemment. - Enfin, elle retourne le résultat de la modération.
- Cette fonction constitue le noyau 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 structurées de manière cohérente dans toute l'application, ce qui facilite le travail avec et la validation.
Fonctions de blocage et de signalement
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 borderline 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 aux utilisateurs la chance de modifier leur comportement avant que des actions plus sévères soient prises.
La fonction report_to_human
est notre recours pour les cas complexes. Elle prend à la fois le content_id
et le contenu lui-même. Cette fonction signale le contenu pour une revue 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.
Ces fonctions travaillent ensemble pour créer un système de modération complet, permettant flexibilité et nuance dans la modération de contenu.
Initialisation et définition du schéma
Nous devons maintenant initialiser le client et définir nos schémas.
Tout d'abord, nous initialisons le client OpenAI. Ce client est notre porte d'entrée pour interagir avec les puissants modèles de langage d'OpenAI. La clé API est cruciale car elle authentifie nos requêtes aux services d'OpenAI.
Définitions des schémas de fonction
Maintenant, examinons chaque schéma de fonction individuellement :
- Le schéma de
moderate_text_function
définit comment notre IA doit comprendre et utiliser notre fonction principale de modération. - Le schéma de
block_content_function
est utilisé lorsque le contenu doit être bloqué complètement. - Le schéma de
issue_warning_function
décrit comment émettre un avertissement pour un contenu borderline. - Le schéma de
report_to_human_function
est utilisé lorsque l'IA estime qu'une intervention humaine est nécessaire.
Nous compilons tous ces schémas de fonction en une seule liste, représentant l'ensemble des outils disponibles pour notre IA pour la modération de contenu.
Configuration des messages initiaux
Cette section initialise la liste des messages, qui est cruciale 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 comme assistant à la modération de contenu.
- Le deuxième message simule une entrée utilisateur initiale pour commencer la conversation.
Boucle de conversation principale
Le cœur de notre système de modération de contenu est la boucle de conversation principale. Cette boucle gère l'interaction continue entre l'utilisateur et l'IA, traitant les entrées, les réponses et exécutant les actions de modération.
1. 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, donnant à l'utilisateur une indication claire qu'il peut commencer à interagir.
2. Gestion des entrées utilisateur
À chaque itération, nous gérons l'entrée utilisateur. Le système invite l'utilisateur avec un préfixe vert "Utilisateur :" et vérifie si l'utilisateur souhaite quitter la conversation en comparant leur entrée à une liste de commandes de sortie.
3. Analyse du contenu
Avec l'entrée de l'utilisateur capturée, nous envoyons une requête à l'API OpenAI, passant l'historique complet de la conversation, les fonctions disponibles, et spécifiant que l'IA peut décider d'appeler une fonction.
4. Traitement de la réponse
Après avoir reçu la réponse de l'API, nous la traitons. Nous vérifions si l'IA a décidé d'appeler une fonction. Si c'est le cas, nous extrayons le nom de la fonction et les arguments, nous préparant ainsi à exécuter l'action appropriée de modération.
5. Exécution de la fonction
Selon la fonction appelée, différentes actions sont entreprises, telles que le blocage de contenu ou l'émission d'avertissements. Chaque action est exécutée, et son résultat est imprimé pour que l'utilisateur puisse le voir.
6. Achèvement du cycle et gestion des erreurs
Cette section gère les exceptions et fournit une mise à jour finale du statut. Nous confirmons que le journal de modération a été enregistré dans la base de données, assurant que les utilisateurs soient 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 :
- Ouvrez votre terminal ou votre invite de commande.
- Accédez au répertoire contenant
app.py
. - Exécutez la commande suivante :
python app.py
.
Cela démarrera l'agent, et vous verrez le message d'initialisation. Vous pourrez ensuite commencer à interagir avec le système en tapant vos messages.
Flux de travail de l'agent
Dans une application réelle, cet agent ferait partie d'un système plus large et asynchrone :
- Tous les messages dans un chat ou une plateforme de médias sociaux seraient envoyés à cet agent pour la modération.
- L'agent traiterait chaque message de manière asynchrone, permettant une modération en temps réel à volume élevé.
En fonction de la décision de l'agent, les messages pourraient être autorisés à passer immédiatement, bloqués pour publication, signalés pour une révision humaine, ou déclencher des avertissements 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.
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. Les points clés à retenir incluent :
- Configuration d'un environnement de développement pour des applications alimentées par l'IA.
- Intégration de l'API OpenAI pour un traitement avancé du langage.
- Mise en œuvre d'une solution de base de données utilisant Supabase pour l'enregistrement et la persistance des données.
- Création d'une boucle de modération de contenu interactive et robuste.
Ce projet sert de base pour construire des systèmes d'IA plus complexes et démontre le potentiel de la combinaison des sorties structurées avec l'appel de fonction dans des applications pratiques. À mesure que la technologie AI continue d'évoluer, ces systèmes joueront un rôle crucial dans le maintien d'environnements en ligne sûrs et productifs.
Laisser un commentaire
Tous les commentaires sont modérés avant d'être publiés.
Ce site est protégé par hCaptcha, et la Politique de confidentialité et les Conditions de service de hCaptcha s’appliquent.