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

Construire un agent d'IA intelligent 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 des sorties structurées 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 d'IA

OpenAI a récemment introduit des capacités de sortie structurée, ce qui a changé notre façon de travailler avec des modèles d'IA. 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 sous forme de texte brut ou de formats JSON simples. Cela a posé des problèmes tant pour les développeurs que pour les entreprises.

L'absence de structure dans les sorties d'IA menait souvent à une information incohérente. 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 les informations, ce qui compliquait l'utilisation de ces sorties dans les systèmes existants.

Ces limitations rendaient particulièrement 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 juridiques, des rapports de conformité et des analyses commerciales passaient plus de temps à traiter les sorties de l'IA qu'à réellement en bénéficier.

Le changement de donne : Les 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 d'ingrédients et d'étapes bien organisée, plutôt qu'un simple bloc de texte. C'est ce type d'amélioration dont nous parlons.

Pour notre agent de modération de contenu, c'est réellement passionnant. Nous pouvons désormais demander à l'IA des types spécifiques d'informations dans des formats précis. Besoin de clauses juridiques, de chiffres financiers ou d'exigences de conformité ? L'IA peut fournir cela de manière structurée et facile à gérer. 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 d'IA. Cela revient à donner à notre agent IA la capacité d'appuyer sur des boutons et de tirer des leviers en fonction des informations qu'il traite. Il ne se contente pas de fournir des données ; il peut aussi prendre des actions.

En combinant les sorties structurées et l'appel de fonction, 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 capable non seulement de comprendre des informations complexes, mais aussi de faire quelque chose d'utile avec.

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

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

Passons au code

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

mkdir structuredOutput

Ensuite, configurons un environnement virtuel. Cela nous aidera à gérer les dépendances de notre 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-py pydantic colorama

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 dans le fichier :

OPENAI_API_KEY=your_openai_api_key
SUPABASE_URL=your_supabase_url
SUPABASE_KEY=your_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 encore.

En configurant notre environnement de cette manière, nous nous assurons que notre projet est organisé, que nos dépendances sont gérées et que nos informations sensibles sont sécurisées. Cette approche nous prépare au succès alors que nous continuons à construire notre agent de sortie structurée.

Configuration des clés API

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

Clé API OpenAI

Pour obtenir votre 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 un ensemble d'outils pour construire des applications évolutives et sécurisées. Il 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 : Il est construit au-dessus de 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'utilisons 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 s'adapter à votre application, ce qui le rend adapté tant 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 redirigé vers le tableau de bord du projet.
4. Dans la barre latérale gauche, cliquez sur votre page d'accueil de projet et faites défiler vers le bas pour trouver la section API.

Ici, vous 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=your_openai_api_key
SUPABASE_URL=your_supabase_url
SUPABASE_KEY=your_supabase_key

Prochaines étapes

Bravo ! 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, la sélection des champs appropriés et la mise en place du 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 sur lesquelles notre agent 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 efficacement.

Étapes pour créer la table

1. Dans le tableau de bord de votre 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ésactivez 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.)

Mise en place du schéma

Pour notre projet de modération, nous avons besoin d'un schéma spécifique qui puisse 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 "Principal".

Voici le schéma que nous utiliserons :

• id (texte) - Défini comme Principal
• content_id (texte)
• status (texte)
• content (texte)
• reported_to (texte)
• is_offensive (booléen)
• confidence_score (float4)
• flagged_terms (texte)
• created_at (timestamp) - Définir la valeur par défaut sur 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.

Prochaines étapes

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 allons commencer à construire le code Python pour interagir avec cette table, y compris des fonctions pour insérer de nouvelles entrées de modération et récupérer celles 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écomposons ce code en sections puis plongeons dans chaque fonction. Nous allons commencer 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 IA, 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 assistant polyvalent pour interagir avec notre base de données Supabase. Elle prend en charge diverses opérations comme 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.
• En fonction de 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 l'exécution de diverses actions sur nos données de modération tout au long du 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 centrales.

Cette section définit les structures et fonctions principales 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 que ModerationOutput inclut des métadonnées supplémentaires sur le contenu modéré.
• Fonction moderate_text : C'est notre principale fonction de modération. Voici comment elle fonctionne :

def moderate_text(content_id: str, content: str) -> ModerationOutput:
    # Vérifiez le contenu par rapport à une liste de termes offensants
    # Calculez si le contenu est offensant et attribuez un score de confiance
    # Insérer le résultat dans Supabase
    return result

Le blocage de contenu et les fonctions d'avertissement

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 aux utilisateurs une chance de modifier leur comportement avant que des actions plus sévères ne soient prises.

La fonction report_to_human est notre solution de secours pour les cas complexes. Cette fonction signale le contenu pour révision par un modérateur humain, ce qui est essentiel pour gérer des situations nuancées que l'IA pourrait ne pas être en mesure de juger avec précision.

Initialisation du client et définition des 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 demandes aux services d'OpenAI.

Maintenant, examinons chaque schéma de fonction individuellement :

• Le schéma moderate_text_function définit comment notre IA doit comprendre et utiliser notre fonction principale de modération.
• Le schéma block_content_function est utilisé lorsque le contenu doit être bloqué immédiatement.
• Le schéma issue_warning_function décrit comment émettre un avertissement pour du contenu borderline.
• Le schéma report_to_human_function est utilisé lorsque l'IA détermine qu'une intervention humaine est nécessaire.

Enfin, nous compilons tous ces schémas de fonction en une seule liste. Cette liste représente l'arsenal complet disponible pour notre IA en matière de 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 un assistant de modération de contenu.
• Le deuxième message simule une entrée utilisateur initiale pour démarrer la conversation.

Ces messages fournissent le contexte initial pour l'IA, posant les bases du 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, traitant les entrées, traitant les réponses, et 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 d'accepter et de traiter continuellement les entrées utilisateurs jusqu'à ce qu'on lui demande explicitement de s'arrêter.

Gestion des entrées utilisateurs

À chaque itération, nous gérons l'entrée de l'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.

Analyse du 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 expérience utilisateur. Le système envoie ensuite une requête à l'API 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 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. En fonction de 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 fonctions gèrent des actions comme le blocage de contenu, l'émission d'avertissements ou le signalement à des modérateurs humains.

Gestion des erreurs et conclusion

Cette section gère les exceptions et fournit une mise à jour finale sur l'état. La dernière instruction d'impression, quelle que soit l'erreur, confirme que le journal de modération a été enregistré dans la base de données.

Exécution de l'agent

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

1. Ouvrez votre terminal ou invite de commande.
2. Naviguez vers le répertoire contenant app.py.
3. Exécutez la commande suivante :

python app.py

Flux de travail de l'agent

Dans une application réelle, cet agent ferait probablement partie d'un système plus large et asynchrone qui gère des messages à haut volume dans les chats ou sur les plateformes de médias sociaux.

• Tous les messages seraient envoyés à cet agent pour modération.
• Les messages pourraient être autorisés, bloqués ou signalés pour révision en fonction des résultats de la modération.

Conclusion

Dans ce tutoriel, nous avons construit un système de modération de contenu sophistiqué alimenté par IA, 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 des applications alimentées par IA
• Intégrer l'API d'OpenAI pour un traitement linguistique avancé
• Mettre en œuvre une solution de base de données utilisant Supabase pour l'enregistrement et la persistance des données
• Créer une boucle de modération de contenu robuste et interactive

Ce projet sert de base à la construction de systèmes d'IA plus complexes, mettant en avant le potentiel de ces technologies dans des applications pratiques.