Einen intelligenten KI-Agenten für die Inhaltsmoderation mit strukturiertem Output erstellen

Ein intelligenter KI-Agent für die Inhaltsmoderation mit strukturiertem Output erstellen

In diesem Tutorial werden wir erkunden, wie man einen intelligenten KI-Agenten erstellt, der Inhalte moderieren und strukturierte Berichte erstellen kann. Wir verwenden die neuen Funktionen von OpenAI für strukturierten Output und Funktionsaufrufe, um dieses fortschrittliche System zu erstellen. Unser Ziel ist es, eine KI zu entwickeln, die Inhalte effektiv analysieren und detaillierte, organisierte Ergebnisse bereitstellen kann.

Die Evolution der KI-Ausgaben

OpenAI hat kürzlich die Fähigkeiten für strukturierten Output eingeführt, die unsere Arbeit mit KI-Modellen verändert haben. Vor diesem Update standen Entwickler vor vielen Herausforderungen beim Einsatz von KI-generierten Inhalten. Die Antworten waren in der Regel nur reiner Text oder einfache JSON-Formate. Dies führte zu Problemen für Entwickler und Unternehmen.

Der Mangel an Struktur in den KI-Ausgaben führte oft zu inkonsistenten Informationen. Entwickler mussten komplexen Code schreiben, um die Antworten der KI zu verstehen, was viel Zeit in Anspruch nahm und zu Fehlern führen konnte. Es war auch schwierig zu steuern, wie die KI Informationen präsentierte, was die Nutzung dieser Ausgaben in bestehenden Systemen erschwerte.

Diese Einschränkungen machten es insbesondere herausfordernd, zuverlässige Anwendungen für Aufgaben zu erstellen, die präzise, strukturierte Daten benötigten. Teams, die an juristischen Dokumenten, Compliance-Berichten und Geschäftsanalyse arbeiteten, fanden sich in der Situation, mehr Zeit mit der Verarbeitung von KI-Ausgaben zu verbringen, als tatsächlich von ihnen zu profitieren.

Der Wendepunkt: Strukturierte Ausgaben

Aber jetzt hat sich alles verändert. OpenAI hat etwas namens "strukturierte Ausgaben" eingeführt. Das bedeutet, dass die KI uns jetzt Informationen in einem Format geben kann, das viel einfacher zu verwenden ist. Stellen Sie sich vor, Sie fragen nach einem Rezept und erhalten eine schön organisierte Liste von Zutaten und Schritten zurück, anstatt nur einen Block Text. Das ist die Art von Verbesserung, von der wir sprechen.

Für unseren Inhaltsmoderationsagenten ist das wirklich aufregend. Wir können die KI jetzt nach bestimmten Arten von Informationen in genauen Formaten fragen. Brauchen Sie rechtliche Klauseln, finanzielle Zahlen oder Compliance-Anforderungen? Die KI kann diese in einer strukturierten Weise bereitstellen, die einfach zu handhaben ist. Das spart viel Zeit und Mühe bei der Verarbeitung und Organisation von Informationen.

Aber das ist noch nicht alles. OpenAI hat auch etwas namens "Funktionsaufrufe" zu seinen KI-Modellen hinzugefügt. Das ist wie das Verleihen der Fähigkeit an unseren KI-Agenten, Knöpfe zu drücken und Hebel zu ziehen, basierend auf den Informationen, die er verarbeitet. Es bietet nicht nur Daten an; es kann auch Aktionen ausführen.

Durch die Kombination von strukturierten Ausgaben und Funktionsaufrufen wird unser Agent unglaublich leistungsfähig. Er kann mit mehreren Informationsquellen arbeiten, komplexe Entscheidungen treffen und hochgradig angepasste Berichte erstellen. Es ist wie ein superintelligenter Assistent, der nicht nur komplexe Informationen verstehen kann, sondern auch etwas Nützliches damit tun kann.

Diese Art von KI kann für Unternehmen, die eine große Menge von Inhalten schnell überprüfen müssen, sehr nützlich sein. Sie kann sicherstellen, dass Inhalte bestimmten Standards entsprechen, potenzielle Probleme erkennen und sogar Verbesserungen vorschlagen. Und weil sie schnell und konsistent arbeitet, kann sie menschlichen Moderatoren helfen, sich auf komplexere Aufgaben zu konzentrieren.

In diesem Tutorial werden wir durchgehen, wie man diesen KI-Agenten erstellt. Wir zeigen Ihnen, wie man ihn einrichtet, wie man diese neuen Funktionen nutzt und wie man ihn für Ihre spezifischen Bedürfnisse anpasst. Am Ende haben Sie ein leistungsstarkes Werkzeug, das bei allen Arten von Inhaltsmoderationstasks helfen kann.

Lasst uns codieren

Zuerst erstellen wir ein neues Verzeichnis für unser Projekt:

mkdir structuredOutput

Als Nächstes richten wir eine virtuelle Umgebung ein. Das hilft uns, die Abhängigkeiten unseres Projekts getrennt von anderen Python-Projekten zu verwalten.

• Für Windows: python -m venv venv
• Für macOS und Linux: python3 -m venv venv

Mit unserer aktivierten virtuellen Umgebung installieren wir die erforderlichen Bibliotheken:

pip install openai supabase-py python-dotenv

Nun erstellen Sie eine app.py-Datei im structuredOutput-Verzeichnis. Dies wird die Hauptdatei für unser Projekt sein.

Erstellen Sie als Nächstes eine .env-Datei im selben Verzeichnis. Diese Datei wird unsere sensiblen Informationen wie API-Schlüssel speichern. Fügen Sie die folgenden Platzhalter in die Datei ein:

OPENAI_API_KEY=
SUPABASE_URL=
SUPABASE_KEY=

Keine Sorge, wenn Sie diese Schlüssel noch nicht haben. Im nächsten Abschnitt führen wir Sie durch die Erstellung eines Supabase-Kontos, die Einrichtung einer Tabelle und das Erlangen der erforderlichen Anmeldeinformationen. Wir erklären auch, wie Sie Ihren OpenAI-API-Schlüssel erhalten, falls Sie noch keinen haben.

Indem wir unsere Umgebung auf diese Weise einrichten, stellen wir sicher, dass unser Projekt organisiert ist, unsere Abhängigkeiten verwaltet werden und unsere sensiblen Informationen sicher aufbewahrt werden. Dieser Ansatz legt den Grundstein für den Erfolg, während wir mit dem Bau unseres strukturierten Ausgabe-Agents fortfahren.

Einrichten der API-Schlüssel

Jetzt, da wir unsere Projektstruktur erstellt haben, lassen Sie uns die erforderlichen API-Schlüssel für unsere Anwendung abrufen.

OpenAI API-Schlüssel

1. Besuchen Sie Ihr OpenAI-Dashboard unter https://platform.openai.com/settings/organization/general
2. Suchen Sie den Abschnitt API-Schlüssel und erstellen Sie einen neuen geheimen Schlüssel.
3. Kopieren Sie diesen Schlüssel und fügen Sie ihn in Ihre .env-Datei für die Variable OPENAI_API_KEY ein.

Einführung in Supabase

Supabase ist eine Open-Source-Alternative zu Firebase, die eine Suite von Werkzeugen für den Aufbau skalierbarer und sicherer Anwendungen bietet. Es bietet eine PostgreSQL-Datenbank, Authentifizierung, sofortige APIs und Echtzeit-Abonnements, alles in einem Paket.

Wir verwenden Supabase in diesem Projekt aus mehreren Gründen:

• Einfache Einrichtung: Supabase bietet eine benutzerfreundliche Schnittstelle zur Erstellung und Verwaltung von Datenbanken.
• PostgreSQL-Power: Es basiert auf PostgreSQL und gibt uns Zugriff auf eine robuste, voll ausgestattete Datenbank.
• Echtzeitfähigkeiten: Supabase ermöglicht eine Echtzeitsynchronisierung von Daten, was für die kollaborative Dokumentenerstellung nützlich sein kann.
• Integrierte Authentifizierung: Auch wenn wir es in diesem Tutorial nicht verwenden, kann das Authentifizierungssystem von Supabase in Zukunft für die Sicherung Ihrer Anwendung wertvoll sein.
• Skalierbarkeit: Supabase ist so konzipiert, dass es mit Ihrer Anwendung skaliert, was es sowohl für kleine Projekte als auch für groß angelegte Bereitstellungen geeignet macht.

Einrichten von Supabase

Jetzt richten wir Ihr Supabase-Projekt ein:

1. Besuchen Sie https://supabase.com/dashboard/sign-up, um ein Supabase-Konto zu erstellen, falls Sie noch keins haben.
2. Nachdem Sie sich angemeldet haben, klicken Sie auf "Neues Projekt" und folgen Sie den Anweisungen zur Erstellung eines neuen Projekts.
3. Nachdem Ihr Projekt erstellt wurde, werden Sie zum Projekt-Dashboard weitergeleitet.
4. Im linken Seitenbereich klicken Sie auf Ihre Projekt-Homepage und scrollen nach unten, um den API-Bereich zu finden.
5. Hier finden Sie Ihre Projekt-URL und Ihren API-Schlüssel. Kopieren Sie diese und fügen Sie sie in Ihre .env-Datei für die Variablen SUPABASE_URL und SUPABASE_KEY ein.

Ihre .env-Datei sollte jetzt etwa so aussehen (natürlich mit Ihren tatsächlichen Schlüsseln):

OPENAI_API_KEY=YOUR_OPENAI_API_KEY
SUPABASE_URL=YOUR_SUPABASE_URL
SUPABASE_KEY=YOUR_SUPABASE_KEY

Nächste Schritte

Großartige Arbeit! Sie haben jetzt die erforderlichen Konten und API-Schlüssel für unser Projekt eingerichtet. Im nächsten Abschnitt werden wir uns mit der Erstellung unserer Supabase-Tabelle befassen, die geeigneten Felder auswählen und das Schema für unser Dokumentenerstellungssystem einrichten. Dies wird die Grundlage für die Speicherung und den Abruf der strukturierten Daten bilden, mit denen unser KI-Agent arbeiten wird.

Erstellen der Supabase-Tabelle

Jetzt, wo wir unser Supabase-Projekt eingerichtet haben, erstellen wir die Tabelle, die unsere Moderationsdaten speichert. Diese Tabelle wird das Rückgrat unseres strukturierten Ausgabesystems sein und es uns ermöglichen, Moderationsergebnisse effizient zu speichern und abzurufen.

Schritte zum Erstellen der Tabelle

1. Gehen Sie in Ihrem Supabase-Projekt-Dashboard zur Seitenleiste und klicken Sie auf die Registerkarte "Tabellen-Editor".
2. Klicken Sie auf die Schaltfläche "Neue Tabelle erstellen".
3. Benennen Sie Ihre Tabelle MODERATION_TABLE.
4. Deaktivieren Sie vorerst die Option "Row Level Security (RLS) aktivieren". (Hinweis: In einer Produktionsumgebung möchten Sie geeignete Sicherheitsregeln einrichten.)

Einrichten des Schemas

Für unser Moderationsprojekt benötigen wir ein spezifisches Schema, das verschiedene Aspekte der Inhaltsmoderation berücksichtigen kann. Im Supabase-UI sehen Sie einen Abschnitt mit dem Titel "Spalten" mit Optionen für "Über Datentypen" und "Daten über eine Tabelle importieren". Darunter finden Sie Felder für "Name", "Typ", "Standardwert" und "Primär".

Hier ist das Schema, das wir verwenden werden:

• id (text) - Als Primär festlegen
• content_id (text)
• status (text)
• content (text)
• reported_to (text)
• is_offensive (bool)
• confidence_score (float4)
• flagged_terms (text)
• created_at (timestamp) - Setzen Sie den Standardwert auf now()
• moderation_result (text)

Fügen Sie jede dieser Spalten mithilfe der Supabase-UI zu Ihrer Tabelle hinzu. Stellen Sie sicher, dass Sie den richtigen Datentyp für jede Spalte festlegen und die Spalte id als Primärschlüssel markieren.

Nachdem Sie alle Spalten hinzugefügt haben, klicken Sie auf die Schaltfläche "Speichern", um Ihre Tabelle zu erstellen.

Nächste Schritte

Mit unserer Supabase-Tabelle, die jetzt eingerichtet ist, haben wir eine solide Grundlage für die Speicherung der strukturierten Ausgabe unseres KI-Moderationsagents. Im nächsten Abschnitt werden wir mit dem Aufbau des Python-Codes beginnen, um mit dieser Tabelle zu interagieren, einschließlich Funktionen zum Einfügen neuer Moderationseinträge und zum Abrufen vorhandener. Dies wird den Kern der Datenverwaltungskapazitäten unseres Moderationssystems bilden.

In die tatsächliche Codierung eintauchen

Lasst uns diesen Code in Abschnitte aufteilen und dann in jede Funktion eintauchen. Wir beginnen mit den ersten beiden Abschnitten.

Imports und erste Einrichtung

Dieser Abschnitt richtet unsere Umgebung ein, indem er notwendige Bibliotheken importiert und wichtige Komponenten initialisiert. Wir verwenden Pydantic zur Datenvalidierung, OpenAI für KI-Interaktionen und Supabase für Datenbankoperationen. Colorama wird für farbige Konsolenausgaben verwendet, um die Lesbarkeit zu verbessern.

Datenbankoperationen

Diese Funktion, supabase_operation, ist ein vielseitiger Helfer für die Interaktion mit unserer Supabase-Datenbank. Sie unterstützt verschiedene Operationen wie Einfügen, Auswählen, Aktualisieren und Löschen. Lassen Sie uns das aufschlüsseln:

• Wir beginnen mit der Erstellung eines Abfrageobjekts für unsere MODERATION_TABLE.
• Je nach Operation (einfügen, auswählen, aktualisieren oder löschen) passen wir die Abfrage entsprechend an.
• Wenn Filter bereitgestellt werden, wenden wir sie auf die Abfrage an. Dies ermöglicht spezifischere Datenbankoperationen.
• Schließlich führen wir die Abfrage aus und geben das Ergebnis zurück.

Diese Funktion abstrahiert die Komplexität der Datenbankoperationen und erleichtert es, verschiedene Aktionen auf unseren Moderationsdaten im restlichen Code durchzuführen.

Datenmodelle und Moderationsfunktionen

Untersuchen wir den nächsten Abschnitt unseres Codes, der unsere Datenmodelle und Kernmoderationsfunktionen definiert.

Dieser Abschnitt definiert die Kernstrukturen und Funktionen für unser Moderationssystem:

• Pydantic-Modelle: Wir verwenden Pydantic zur Definition strukturierter Datenmodelle. ModerationResult stellt das Kernmoderationsergebnis dar, während ModerationOutput zusätzliche Metadaten über die moderierten Inhalte enthält.
• moderate_text-Funktion: Dies ist unsere Hauptmoderationsfunktion. So funktioniert sie:
• Sie nimmt eine content_id und den zu moderierenden Inhalt entgegen.
• Sie überprüft den Inhalt anhand einer Liste vordefinierter beleidigender Begriffe.
• Sie berechnet, ob der Inhalt beleidigend ist, und weist eine Vertrauensbewertung zu.
• Das Ergebnis wird in ein Wörterbuch formatiert, das unserem ModerationOutput-Modell entspricht.
• Das Ergebnis wird dann in unsere Supabase-Datenbank eingefügt, indem wir die zuvor definierte supabase_operation-Funktion verwenden.
• Schließlich wird das Moderationsergebnis zurückgegeben.
• Diese Funktion bildet den Kern unseres Moderationssystems. Es handelt sich um eine vereinfachte Version, die mit ausgefeilteren Moderationstechniken, wie z.B. Machine-Learning-Modellen oder komplexeren Regelsets, erweitert werden könnte.

Die Verwendung von Pydantic-Modellen stellt sicher, dass unsere Daten im gesamten Anwendungsbereich konsistent strukturiert sind, was die Verarbeitung und Validierung erleichtert.

Die Funktion block_content nimmt eine content_id als Eingabe. Sie soll Inhalte als blockiert kennzeichnen, wenn sie als zu beleidigend erachtet werden. Diese Funktion erstellt einen Datensatz in unserer Datenbank, der angibt, dass der Inhalt blockiert wurde, zusammen mit dem Grund. Es ist eine entscheidende Funktion zur Aufrechterhaltung der Inhaltsstandards auf einer Plattform.

Die Funktion issue_warning wird für Inhalte verwendet, die grenzwertig unangemessen sind. Sie nimmt ebenfalls eine content_id und protokolliert eine Warnung in der Datenbank. Diese Funktion ist nützlich, um Benutzer zu verfolgen, die häufig fragwürdige Inhalte veröffentlichen, oder um Benutzern die Möglichkeit zu geben, ihr Verhalten zu ändern, bevor strengere Maßnahmen ergriffen werden.

Die Funktion report_to_human ist unser Rückfall für komplexe Fälle. Sie nimmt sowohl die content_id als auch den Inhalt selbst entgegen. Diese Funktion kennzeichnet Inhalte zur Überprüfung durch einen menschlichen Moderator, was für die Handhabung nuancierter Situationen, die die KI möglicherweise nicht genau beurteilen kann, unerlässlich ist.

Jede dieser Funktionen gibt ein Wörterbuch zurück, das Informationen über die durchgeführte Aktion enthält. Sie verwenden alle unsere Funktion supabase_operation, um Datensätze in die Datenbank einzufügen, wodurch sichergestellt wird, dass alle Moderationsaktionen protokolliert und nachverfolgbar sind.

Erste Einrichtung der Nachrichten

In diesem Abschnitt wird die Nachrichtenliste initialisiert, die für die Aufrechterhaltung des Gesprächskontexts mit der KI entscheidend ist:

• Die erste Nachricht legt die Systemrolle fest und definiert das Verhalten der KI als Inhaltsmoderationsassistent.
• Die zweite Nachricht simuliert eine anfängliche Benutzereingabe, um das Gespräch zu beginnen.

Diese Nachrichten liefern den ersten Kontext für die KI und bereiten die Bühne für den Moderationsprozess.

Hauptkonversationsschleife

Das Herz unseres Inhaltsmoderationssystems ist die Hauptkonversationsschleife. Diese Schleife verwaltet die laufende Interaktion zwischen dem Benutzer und der KI, verarbeitet Eingaben, bearbeitet Antworten und führt Moderationsaktionen aus.

Initialisierung

Die Schleife beginnt mit einer Initialisierungsphase. Wir drucken eine Willkommensnachricht aus, um zu signalisieren, dass das Moderationssystem bereit ist. Dies gibt dem Benutzer eine klare Indikation, dass er mit dem System interagieren kann. Die Verwendung von farbigem Text verbessert die Benutzererfahrung.

Wir treten dann in eine unendliche While-Schleife ein, die es unserem System ermöglicht, kontinuierlich Benutzereingaben zu akzeptieren und zu verarbeiten, bis es ausdrücklich gestoppt wird.

Verarbeitung der Benutzereingabe

In jeder Iteration verarbeiten wir die Benutzereingabe. Das System fordert den Benutzer mit einem grünen „Benutzer:“ Präfix auf. Wir überprüfen dann, ob der Benutzer das Gespräch beenden möchte, indem wir seine Eingabe mit einer Liste von Beendigungsbefehlen vergleichen. Wenn er nicht beendet, fügen wir seine Eingabe unserer Nachrichtenliste hinzu und bewahren die gesamte Gesprächshistorie.

Inhaltsanalyse

Nachdem die Eingabe des Benutzers erfasst wurde, bewegen wir uns zur Analysephase. Wir zeigen an, dass die Inhaltsanalyse läuft, und fügen eine kurze Pause für die bessere Benutzererfahrung ein. Das System sendet dann eine Anfrage an die OpenAI-API, übergibt die gesamte Gesprächshistorie, verfügbare Funktionen und stellt sicher, dass die KI entscheiden kann, ob eine Funktion aufgerufen werden soll.

Verarbeitung der Antwort

Nachdem wir die API-Antwort erhalten haben, verarbeiten wir sie. Wir überprüfen, ob die KI entschieden hat, eine Funktion aufzurufen. Wenn ja, extrahieren wir den Funktionsnamen und die Argumente, um die entsprechende Moderationsaktion auszuführen.

FunktionseExecution

Je nach aufgerufener Funktion werden unterschiedliche Aktionen ausgeführt:

• Für die Textmoderation rufen wir die Funktion moderate_text auf und verarbeiten ihr Ergebnis. Abhängig vom Moderationsergebnis können zusätzliche Maßnahmen ergriffen werden, wie das Blockieren von Inhalten oder das Ausstellen von Warnungen.
• Andere Funktionen verwalten Aktionen wie das Blockieren von Inhalten, das Ausstellen von Warnungen oder das Berichten an menschliche Moderatoren. Jede Aktion wird ausgeführt und ihr Ergebnis wird dem Benutzer angezeigt.

Reguläre KI-Antwort

Wenn kein Funktionsaufruf erfolgt, drucken wir einfach die Antwort der KI an den Benutzer aus.

Fertigstellung des Zyklus

Dieser Abschnitt verwaltet Ausnahmen und bietet ein finales Status-Update. Der Ausnahmeblock fängt und zeigt alle Fehler an, die während der Ausführung der Hauptschleife auftreten, und druckt sie zur Sichtbarkeit in Rot. Die letzte Druckanweisung, unabhängig von Fehlern, bestätigt, dass das Moderationsprotokoll in der Datenbank gespeichert wurde, was in grün angezeigt wird, um positives Feedback zu geben. Dies stellt sicher, dass die Benutzer über Fehler und die erfolgreiche Durchführung des Moderationsprozesses informiert sind.

Agent ausführen

Um den Inhaltsmoderationsagenten auszuführen, folgen Sie diesen Schritten:

1. Öffnen Sie Ihr Terminal oder Ihre Eingabeaufforderung.
2. Navigieren Sie zu dem Verzeichnis, das app.py enthält.
3. Führen Sie den folgenden Befehl aus:

python app.py

Dies startet den Agenten, und Sie sehen die Initialisierungsnachricht. Sie können dann beginnen, mit dem System zu interagieren, indem Sie Ihre Nachrichten eingeben.

Workflow des Agenten

In einer realen Anwendung wäre dieser Agent wahrscheinlich Teil eines größeren, asynchronen Systems. So könnte es funktionieren:

• Jede Nachricht in einem Chat oder sozialen Medien würde an diesen Agenten zur Moderation gesendet.
• Der Agent würde jede Nachricht asynchron verarbeiten, was eine Moderation in Echtzeit bei hohem Volumen ermöglicht.
• Je nach Entscheidung des Agents könnten Nachrichten:
• Sofort zugelassen werden
• Vom Posten blockiert werden
• Zur menschlichen Überprüfung gekennzeichnet werden
• Warnungen oder Maßnahmen gegen Benutzerkonten auslösen
• Die Moderationsergebnisse würden in der Datenbank zur Überprüfung und Verbesserung des Systems im Laufe der Zeit protokolliert.

Dieses Setup ermöglicht eine skalierbare, KI-gestützte Inhaltsmoderation, die große Mengen von Nachrichten in mehreren Unterhaltungen oder Plattformen gleichzeitig verwalten kann, um ein sichereres und kontrolliertes Benutzererlebnis zu bieten.

Fazit

In diesem Tutorial haben wir ein anspruchsvolles KI-gestütztes System zur Inhaltsmoderation unter Verwendung der strukturierten Ausgabefähigkeiten und der Funktionsaufrufe von OpenAI erstellt. Dieses System demonstriert, wie man:

• Eine Entwicklungsumgebung für KI-gesteuerte Anwendungen einrichtet
• Die OpenAI-API für fortgeschrittene Sprachverarbeitung integriert
• Eine Datenbanklösung mit Supabase für Protokollierung und Datenspeicherung implementiert
• Eine robuste, interaktive Moderationsschleife erstellt

Indem Sie python app.py ausführen, können Sie den Agenten starten und die Echtzeit-Inhaltsmoderation erleben. In einer Produktionsumgebung könnte dieses System so skaliert werden, dass es viele Konversationen asynchron verarbeitet, was eine effiziente, KI-gesteuerte Moderation für verschiedene Plattformen bietet.

Dieses Projekt dient als Grundlage für den Aufbau komplexerer KI-Systeme und zeigt das Potenzial der Kombination von strukturierten Ausgaben mit Funktionsaufrufen in praktischen Anwendungen. Während sich die KI-Technologie weiterentwickelt, werden Systeme wie dieses eine entscheidende Rolle bei der Aufrechterhaltung sicherer und produktiver Online-Umgebungen spielen.