Einen intelligenten KI-Agenten zur Inhaltsmoderation mit strukturiertem Output erstellen

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

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

Die Entwicklung von KI-Outputs

OpenAI hat kürzlich die Möglichkeiten des strukturierten Outputs eingeführt, die geändert haben, wie wir mit KI-Modellen arbeiten. Vor diesem Update standen die Entwickler vor vielen Herausforderungen bei der Verwendung von KI-generierten Inhalten. Die Antworten waren normalerweise nur reiner Text oder einfache JSON-Formate. Dies verursachte Probleme sowohl für Entwickler als auch für Unternehmen.

Der Mangel an Struktur in KI-Outputs 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 kontrollieren, wie die KI Informationen präsentierte, was es erschwerte, diese Outputs in bestehenden Systemen zu verwenden.

Diese Einschränkungen machten es besonders 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äftsanalysen arbeiteten, fanden sich oft damit konfrontiert, mehr Zeit mit den KI-Outputs zu verbringen, als tatsächlich von ihnen zu profitieren.

Der Wendepunkt: Strukturierte Outputs

Aber jetzt hat sich alles geändert. OpenAI hat etwas eingeführt, das "strukturierte Outputs" genannt wird. Das bedeutet, dass die KI uns nun Informationen in einem Format liefern kann, das viel einfacher zu verwenden ist. Stellen Sie sich vor, Sie bitten um ein Rezept und erhalten eine ordentlich 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 Inhaltsmoderations-Agenten ist das wirklich aufregend. Wir können die KI jetzt nach bestimmten Arten von Informationen in genauen Formaten fragen. Benötigen Sie juristische Klauseln, finanzielle Zahlen oder Compliance-Anforderungen? Die KI kann diese in einer strukturierten Weise bereitstellen, die einfach zu verarbeiten ist. Dies spart viel Zeit und Aufwand beim Verarbeiten und Organisieren von Informationen.

Doch das ist nicht alles. OpenAI hat auch etwas eingeführt, das "Funktionsaufrufe" genannt wird, zu seinen KI-Modellen. Das ist, als würde man unserem KI-Agenten die Fähigkeit geben, Tasten zu drücken und Hebel zu ziehen, basierend auf den Informationen, die er verarbeitet. Es liefert nicht nur Daten; es kann auch Aktionen ausführen.

Durch die Kombination von strukturierten Outputs und Funktionsaufrufen wird unser Agent unglaublich mächtig. Er kann mit mehreren Informationsquellen arbeiten, komplexe Entscheidungen treffen und hochgradig angepasste Berichte erstellen. Es ist, als hätte man einen superintelligenten Assistenten, 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 an Inhalten schnell überprüfen müssen, sehr nützlich sein. Sie kann helfen sicherzustellen, dass Inhalte bestimmten Standards entsprechen, potenzielle Probleme kennzeichnen und sogar Verbesserungen vorschlagen. Und da sie schnell und konsistent arbeitet, kann sie menschliche Moderatoren entlasten, damit diese sich auf komplexere Aufgaben konzentrieren können.

In diesem Tutorial zeigen wir Ihnen, wie Sie einen solchen KI-Agenten erstellen können. Wir zeigen Ihnen, wie Sie ihn einrichten, wie Sie diese neuen Funktionen nutzen und wie Sie ihn auf Ihre speziellen Bedürfnisse abstimmen können. Am Ende werden Sie ein leistungsstarkes Werkzeug haben, das bei allen Arten von Inhaltsmoderationsaufgaben hilft.

Loslegen mit dem Programmieren

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

mkdir structuredOutput

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

Für Windows:

python -m venv env

Für macOS und Linux:

python3 -m venv env

Nachdem unsere virtuelle Umgebung aktiviert ist, installieren wir die erforderlichen Bibliotheken:

pip install openai supabase-py pydantic colorama

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

Als nächstes erstellen Sie eine .env-Datei im selben Verzeichnis. Diese Datei speichert unsere sensiblen Informationen wie API-Schlüssel. Fügen Sie die folgenden Platzhalter in die Datei ein:

OPENAI_API_KEY=your_openai_api_key
SUPABASE_URL=your_supabase_url
SUPABASE_KEY=your_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, das Einrichten einer Tabelle und das Beschaffen der erforderlichen Anmeldeinformationen. Wir werden auch erklären, wie Sie Ihren OpenAI-API-Schlüssel erhalten, falls Sie noch keinen haben.

Durch die Einrichtung unserer Umgebung auf diese Weise stellen wir sicher, dass unser Projekt organisiert ist, unsere Abhängigkeiten verwaltet werden, und unsere sensiblen Informationen sicher aufbewahrt werden. Dieser Ansatz bereitet uns auf den Erfolg vor, während wir mit dem Aufbau unseres strukturierten Output-Agenten fortfahren.

Einrichten der API-Schlüssel

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

OpenAI API-Schlüssel

Um Ihren OpenAI-API-Schlüssel zu erhalten:

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 OPENAI_API_KEY-Variable ein

Einführung in Supabase

Supabase ist eine Open-Source-Alternative zu Firebase, die eine Reihe von Werkzeugen zum Erstellen 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 zum Erstellen und Verwalten von Datenbanken.
• PostgreSQL-Leistung: Es basiert auf PostgreSQL und gibt uns Zugang zu einer robusten, voll ausgestatteten Datenbank.
• Echtzeitfähigkeiten: Supabase ermöglicht die Echtzeit-Daten-Synchronisierung, was nützlich für die kollaborative Dokumentenerstellung sein kann.
• Integrierte Authentifizierung: Während wir dies in diesem Tutorial nicht verwenden, kann das Authentifizierungssystem von Supabase wertvoll sein, um Ihre Anwendung in Zukunft zu sichern.
• Skalierbarkeit: Supabase ist so konzipiert, dass es mit Ihrer Anwendung skalierbar ist, sodass es sowohl für kleine Projekte als auch für großangelegte Bereitstellungen geeignet ist.

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. Sobald Sie angemeldet sind, klicken Sie auf „Neues Projekt“ und folgen Sie den Anweisungen, um ein neues Projekt zu erstellen.
3. Nachdem Ihr Projekt erstellt wurde, werden Sie zum Projekt-Dashboard geleitet.
4. Im linken Seitenbereich klicken Sie auf Ihre Projekt-Homepage und scrollen Sie nach unten, um den API-Bereich zu finden.

Hier finden Sie Ihre Projekt-URL und 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 ungefähr 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

Gut gemacht! Sie haben jetzt die notwendigen Konten und API-Schlüssel für unser Projekt eingerichtet. Im nächsten Abschnitt werden wir uns mit der Erstellung unserer Supabase-Tabelle, der Auswahl der entsprechenden Felder und dem Einrichten des Schemas für unser Dokumentengenerierungssystem beschäftigen. 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, da wir unser Supabase-Projekt eingerichtet haben, lassen Sie uns die Tabelle erstellen, die unsere Moderationsdaten speichern wird. Diese Tabelle wird das Rückgrat unseres strukturierten Output-Systems sein und es uns ermöglichen, Moderationsergebnisse effizient zu speichern und abzurufen.

Schritte zur Erstellung der Tabelle

1. Gehen Sie im Dashboard Ihres Supabase-Projekts zum Seitennavigator 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 sollten 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 Tabellenkalkulation 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 festgelegt
• content_id (text)
• status (text)
• content (text)
• reported_to (text)
• is_offensive (bool)
• confidence_score (float4)
• flagged_terms (text)
• created_at (timestamp) - Standardwert auf now() festlegen
• moderation_result (text)

Fügen Sie diese Spalten mithilfe der Supabase-UI Ihrer Tabelle hinzu. Stellen Sie sicher, dass Sie den richtigen Datentyp für jede Spalte festlegen und die id-Spalte 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

Jetzt, da unsere Supabase-Tabelle eingerichtet ist, haben wir eine solide Grundlage für die Speicherung der strukturierten Ausgaben 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 bestehender. Dies wird den Kern der Datenverwaltungskapazitäten unseres Moderationssystems bilden.

Einsteigen in den eigentlichen Code

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

Importrund Initial Setup

Dieser Abschnitt richtet unsere Umgebung ein, indem er die erforderlichen 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 farbigen Konsolenausgang 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 damit, ein Abfrageobjekt für unsere MODERATION_TABLE zu erstellen.
• Je nach Operation (Einfügen, Auswählen, Aktualisieren oder Löschen) passen wir die Abfrage entsprechend an.
• Wenn Filter bereitgestellt werden, wenden wir diese auf die Abfrage an. Dadurch sind spezifischere Datenbankoperationen möglich.
• 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 Rest des Codes auszuführen.

Datenmodelle und Moderationsfunktionen

Lassen Sie uns den nächsten Abschnitt unseres Codes untersuchen, der unsere Datenmodelle und Kernmoderationsfunktionen definiert.

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

• Pydantic-Modelle: Wir verwenden Pydantic, um strukturierte Datenmodelle zu definieren. ModerationResult stellt die zentralen Moderationsergebnisse dar, während ModerationOutput zusätzliche Metadaten zu den moderierten Inhalten enthält.
• moderate_text-Funktion: Dies ist unsere Hauptmoderationsfunktion. So funktioniert sie:

def moderate_text(content_id: str, content: str) -> ModerationOutput:
    # Überprüfen Sie den Inhalt anhand einer Liste von anstößigen Begriffen
    # Berechnen, ob der Inhalt anstößig ist und einen Vertrauensscore zuweisen
    # Ergebnis in Supabase einfügen
    return result

Die Block- und Warnfunktionen

Die block_content-Funktion nimmt eine content_id als Eingabe. Sie wurde entwickelt, um Inhalte zu markieren, wenn sie als zu anstößig angesehen werden. Diese Funktion erstellt einen Datensatz in unserer Datenbank, der angibt, dass der Inhalt blockiert wurde, zusammen mit dem Grund. Es ist eine wichtige Funktion für die Einhaltung von Inhaltsstandards auf einer Plattform.

Die issue_warning-Funktion 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 posten, oder um den Benutzern die Möglichkeit zu geben, ihr Verhalten zu ändern, bevor schwerwiegendere Maßnahmen getroffen werden.

Die report_to_human-Funktion ist unser Fallback für komplexe Fälle. Diese Funktion kennzeichnet Inhalte zur Überprüfung durch einen menschlichen Moderator, was für den Umgang mit nuancierten Situationen, die von der KI möglicherweise nicht genau beurteilt werden können, unerlässlich ist.

Initialisierung des Clients und Definition der Schemas

Zuerst initialisieren wir den OpenAI-Client. Dieser Client ist unser Zugang, um mit OpenAIs leistungsstarken Sprachmodellen zu interagieren. Der API-Schlüssel ist entscheidend, da er unsere Anfragen bei den OpenAI-Diensten authentifiziert.

Jetzt schauen wir uns jedes Funktionsschema einzeln an:

• Das moderate_text_function-Schema definiert, wie unsere KI unsere Hauptmoderationsfunktion verstehen und nutzen soll.
• Das block_content_function-Schema wird verwendet, wenn Inhalte sofort blockiert werden müssen.
• Das issue_warning_function-Schema beschreibt, wie man eine Warnung für grenzwertige Inhalte ausgibt.
• Das report_to_human_function-Schema wird verwendet, wenn die KI feststellt, dass menschliches Eingreifen erforderlich ist.

Schließlich fügen wir all diese Funktionsschema in eine einzelne Liste ein. Diese Liste stellt das gesamte Toolkit dar, das unserer KI zur Inhaltsmoderation zur Verfügung steht.

Einrichten der Anfangsnachrichten

Dieser Abschnitt initialisiert die Nachrichtenliste, die entscheidend für die Aufrechterhaltung des Gesprächstexts mit der KI ist:

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

Diese Nachrichten liefern den anfänglichen Kontext für die KI und bereiten den Boden für den Moderationsprozess.

Haupt-Gesprächsschleife

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

Initialisierung

Die Schleife beginnt mit einer Initialisierungsphase. Wir drucken eine Willkommensnachricht aus, um zu signalisieren, dass das Moderationssystem bereit ist. Das gibt dem Benutzer einen klaren Hinweis, dass er mit dem System interagieren kann. Die Verwendung von farbiger Schrift verbessert die Benutzererfahrung.

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

Benutzereingabeverarbeitung

In jeder Iteration verarbeiten wir die Benutzereingabe. Das System fordert den Benutzer mit einem grünen „Benutzer:“ Präfix auf. Dann prüfen wir, ob der Benutzer das Gespräch beenden möchte, indem wir seine Eingabe mit einer Liste von Ausstiegskommandos vergleichen.

Inhaltsanalyse

Nachdem die Eingabe des Benutzers erfasst wurde, bewegen wir uns in die Analysephase. Wir geben an, dass die Inhaltsanalyse im Gange ist, und fügen eine kurze Pause für eine bessere Benutzererfahrung hinzu. Das System sendet dann eine Anfrage an die OpenAI-API, wobei der gesamte Gesprächsverlauf, die verfügbaren Funktionen und die Angabe, dass die KI entscheiden kann, ob sie eine Funktion aufruft, übermittelt werden.

Antwortverarbeitung

Nach Erhalt der API-Antwort verarbeiten wir sie. Wir überprüfen, ob die KI entschieden hat, eine Funktion aufzurufen. Je nach aufgerufener Funktion werden unterschiedliche Aktionen durchgeführt:

• Für die Textmoderation rufen wir die moderate_text-Funktion auf und verarbeiten deren Ergebnis.
• Andere Funktionen bearbeiten Aktionen wie das Blockieren von Inhalten, das Ausstellen von Warnungen oder das Melden an menschliche Moderatoren.

Fehlerbehandlung und Fazit

Dieser Abschnitt verwaltet Ausnahmen und gibt ein abschließendes Statusupdate. Die letzte Druckanweisung, unabhängig von Fehlern, bestätigt, dass das Moderationsprotokoll in der Datenbank gespeichert wurde.

Den Agenten 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 die app.py enthält.
3. Führen Sie den folgenden Befehl aus:

python app.py

Workflow des Agenten

In einer realen Anwendung wäre dieser Agent vermutlich Teil eines größeren, asynchronen Systems, das Nachrichten mit hohem Volumen in Chats oder auf sozialen Medien verarbeitet.

• Jede Nachricht würde an diesen Agenten zur Moderation gesendet werden.
• Nachrichten könnten basierend auf den Moderationsergebnissen zugelassen, blockiert oder zur Überprüfung gekennzeichnet werden.

Fazit

In diesem Tutorial haben wir ein komplexes, KI-gestütztes Inhaltsmoderationssystem mithilfe der strukturierten Outputfähigkeiten und Funktionsaufrufe von OpenAI aufgebaut. Dieses System demonstriert, wie man:

• Eine Entwicklungsumgebung für KI-gesteuerte Anwendungen einrichten
• Die OpenAI-API für fortschrittliche Sprachverarbeitung integrieren
• Eine Datenbanklösung mit Supabase für Protokollierung und Datenpersistenz implementieren
• Eine robuste, interaktive Inhaltsmoderationsschleife erstellen

Dieses Projekt dient als Grundlage zum Aufbau komplexerer KI-Systeme und zeigt das Potenzial dieser Technologien in praktischen Anwendungen auf.