Erstellen eines benutzerdefinierten ChatGPT-Plugins für API Gateway

ChatGPT Plugins fungieren als Brücken, die ChatGPT mit externen APIs verbinden, um die Daten dieser APIs intelligent zu nutzen. Diese Plugins ermöglichen es ChatGPT, eine Vielzahl von Aufgaben zu übernehmen, wie z. B. das Abrufen aktueller Informationen von anderen APIs, einschließlich Sportergebnissen, Börsendaten oder aktuellen Nachrichten, sowie Benutzern bei der Durchführung von Aktionen wie Flugbuchungen oder Essensbestellungen zu helfen. In der Zwischenzeit ist API Gateway ein leistungsstarkes Tool, das Entwicklern ermöglicht, APIs zu erstellen, bereitzustellen und zu verwalten. Es fungiert als Gateway zwischen ChatGPT und Backend-Diensten und bietet Funktionen wie Authentifizierung, Ratenbegrenzung und Anfrage-/Antwort-Transformationen.

Sie können im vorherigen Beitrag nachlesen, wo wir untersucht haben, wie API Gateway für ChatGPT-Plugin-Entwickler hilfreich sein kann, um ihre API-Endpunkte bereitzustellen, zu sichern, zu verwalten und zu überwachen. Dieser Beitrag führt Sie Schritt für Schritt durch die unkomplizierte und direkte Methode, ein ChatGPT-Plugin für API Gateway zu entwickeln. Als zusätzlichen Bonus lernen Sie auch, wie Sie Ihr Plugin zu ChatGPT hinzufügen und ausprobieren können. Machen Sie es sich also bequem, und lassen Sie uns diese Reise beginnen!

Wie man ein ChatGPT-Plugin für API Gateway erstellt

Wie im Getting Started-Leitfaden auf der OpenAI-Website beschrieben, müssen wir, um ein neues benutzerdefiniertes ChatGPT-Plugin zu erstellen, diese allgemeinen 3 Schritte befolgen:

1. Entwickeln Sie eine API oder verwenden Sie eine bestehende, die die OpenAPI-Spezifikation implementiert.
2. Dokumentieren Sie die API entweder im OpenAPI YAML- oder JSON-Format.
3. Generieren Sie eine JSON-Plugin-Manifest-Datei, die wesentliche Informationen über das Plugin enthält.

Indem wir die oben genannten Schritte befolgen, werden wir ein benutzerdefiniertes Plugin für ChatGPT erstellen, das als API Gateway für Backend-API-Dienste fungiert. Als Beispiel: In der ChatGPT-Benutzeroberfläche kann ein Benutzer, der ein API Gateway vor einer bestehenden Conference API einführen möchte, um Details über die Sitzungen und Themen eines Sprechers zu erhalten, Befehle im Chat eingeben, und das Plugin leitet die Anfrage des Benutzers an die Apache APISIX Admin API weiter, die eine Route mit der vom Benutzer angegebenen Eingabekonfiguration erstellt. Dies kann ein weiterer Ansatz sein, den Chatbot zur Konfiguration der API Gateway-Funktionen zu verwenden. Siehe Beispielausgabe unten:

Nachdem der Befehl erfolgreich ausgeführt wurde, erstellt APISIX die Route und registriert einen Upstream für unsere Conference-Backend-API. So können Sie über die API Gateway-Domain und den URL-Pfad eine Antwort über das Gateway erhalten. Beispielsweise gibt diese GET-Anfrage an den Endpunkt http://localhost:9080/speaker/1/sessions alle Sitzungen des Sprechers von der Conference API zurück. Sie können auch grundlegende Operationen wie alle Routen abrufen, eine Route nach ID abrufen, eine bestehende Route aktualisieren oder eine Route mit Plugins und Upstream erstellen direkt durch Anfragen an ChatGPT durchführen.

Um einen Einblick in den Datenfluss zwischen den verschiedenen Komponenten zu erhalten, können Sie sich auf das bereitgestellte Architekturdiagramm beziehen:

Voraussetzungen

• Bevor Sie beginnen, ist es gut, ein grundlegendes Verständnis von APISIX zu haben. Vertrautheit mit API-Gateways und deren Schlüsselkonzepten wie Routen, Upstream, Admin API, Plugins und dem HTTP-Protokoll wird ebenfalls von Vorteil sein.
• Docker wird verwendet, um den containerisierten etcd und APISIX zu installieren.
• Laden Sie Visual Studio Code herunter, das mit Ihrem Betriebssystem kompatibel ist, oder verwenden Sie einen anderen Code-Editor wie IntelliJ IDEA, PyCharm usw.
• Um benutzerdefinierte ChatGPT-Plugins zu entwickeln, benötigen Sie ein ChatGPT Plus-Konto und müssen sich auf der Plugins-Warteliste eintragen.

Das gesamte Code-Repository für das vollständige API Gateway-Plugin befindet sich hier. Lassen Sie uns die Schritte einzeln durchgehen, einschließlich Code-Snippets, Dateien und dem Verständnis, wie man das API Gateway einrichtet, die API in der OpenAPI-Definition dokumentiert und eine Plugin-Manifest-Datei erstellt.

Der Technologie-Stack, der für die Entwicklung dieses Plugins verwendet wird, umfasst Folgendes:

1. Eine bestehende öffentliche Conference API, bei der wir zwei API-Endpunkte verwenden, um die Sitzungen und Themen eines Sprechers in der Demo abzurufen. Sie können andere APIs in Ihrem Browser entdecken.
2. Apache APISIX API Gateway, um die Admin API verfügbar zu machen und den API-Datenverkehr zu verwalten.
3. Ein Python-Skript, um das Plugin auszuführen, das Plugin-Manifest, die OpenAPI-Spezifikation und die Plugin-Logo-Dateien auf der lokalen Host-URL http://localhost:5000/ zu hosten.
4. Das Projekt verwendet Docker für die Bequemlichkeit, um APISIX, etcd und unser Python-Skript mit einem einzigen docker compose up-Befehl zu erstellen, bereitzustellen und auszuführen.

Wir werden eine Reihe von Schritten befolgen, um das Plugin zu erstellen. In Teil 1 konzentrieren wir uns auf die Einrichtung von APISIX. Teil 2 umfasst die Entwicklung des ChatGPT-Plugins selbst, und Teil 3 beinhaltet die Verbindung des Plugins mit ChatGPT und dessen Test. Während wir die Schritte in sequentieller Reihenfolge präsentieren, können Sie jeden davon basierend auf Ihrer Vertrautheit mit dem Thema überspringen.

Teil 1: Apache APISIX einrichten

Schritt 1: APISIX-Konfiguration definieren

Zuerst erstellen wir eine APISIX-Konfigurationsdatei. APISIX-Konfigurationen können auf verschiedene Arten definiert werden, einschließlich statischer Konfigurationsdateien, die typischerweise in YAML geschrieben werden. In der apisix.yml-Datei haben wir eine Beispielkonfiguration bereitgestellt:

deployment:
  etcd:
    host:
      - "http://etcd:2397"
  admin:
    admin_key_required: false
    allow_admin:
      - 0.0.0.0/0

Sie können auch ChatGPT konsultieren, um zu verstehen, was die obige apisix.yml-Datei bedeutet. Grundsätzlich definiert diese Konfiguration den Bereitstellungsmodus für APISIX. Hier verwenden wir eine einfache traditionelle Option, bei der APISIX etcd-Speicher verwendet, um Konfigurationsdetails zu speichern, die es von der Admin API erhält. Wir deaktivieren auch den Admin-Schlüssel admin_key_required für die Demo.

Schritt 2: APISIX und etcd in Docker Compose registrieren

Im letzten Schritt erstellen wir eine docker-compose.yml-Datei und registrieren APISIX und etcd dort als Dienste, um sie zu erstellen, bereitzustellen und auszuführen. Die APISIX Admin API wird auf Port 9180 verfügbar sein, und das Gateway können Sie auf Port 9080 erreichen.

version: "3"

services:
  apisix:
    image: apache/apisix:3.3.0-debian
    volumes:
      - ./apisix_conf/config.yaml:/usr/local/apisix/conf/config.yaml:ro
    restart: always
    ports:
      - "9080:9080"
      - "9180:9180"
    depends_on:
      - etcd
  etcd:
    image: bitnami/etcd:3.5.9
    environment:
      ETCD_ENABLE_V2: "true"
      ALLOW_NONE_AUTHENTICATION: "yes"
      ETCD_ADVERTISE_CLIENT_URLS: "http://0.0.0.0:2397"
      ETCD_LISTEN_CLIENT_URLS: "http://0.0.0.0:2397"

Teil 2: ChatGPT-Plugin-Entwicklung

Schritt 1: Ein Plugin-Manifest erstellen

Jedes Plugin benötigt eine ai-plugin.json-Manifest-Datei, die wichtige Informationen über Ihr Plugin enthält, wie z. B. seinen Namen, Beschreibung, Logo-Assets usw. Lesen Sie mehr über jedes Feld der Manifest-Datei hier, und OpenAI enthält einige Best Practices für das Erstellen von Modellbeschreibungen (description_for_model). Wenn Sie das Plugin in der ChatGPT-Benutzeroberfläche installieren, sucht die Oberfläche nach der Manifest-Datei auf Ihrer Domain (http://localhost:5000/.well-known/ai-plugin.json). Dies hilft ChatGPT zu verstehen, wie es mit Ihrem Plugin interagieren soll.

Erstellen Sie eine neue Datei namens ai-plugin.json und fügen Sie den folgenden Code ein:

{
    "schema_version": "v1",
    "name_for_human": "APISIX plugin for ChatGPT",
    "name_for_model": "apigatewayplugin",
    "description_for_human": "API Gateway plugin to manage your backend APIs.",
    "description_for_model": "Create, retrive, manage APISIX routes, upstreams, and plugins",
    "auth": {
        "type": "none"
    },
    "api": {
        "type": "openapi",
        "url": "http://localhost:5000/openapi.yaml"
    },
    "logo_url": "http://localhost:5000/logo.png",
    "contact_email": "support@example.com",
    "legal_info_url": "http://www.example.com/legal"
}

Sie werden feststellen, dass die Datei auch die URL zur http://localhost:5000/openapi.yaml-Datei angibt.

Wenn ein Benutzer mit ChatGPT interagiert, wird es sich auf die openapi.yaml-Datei beziehen, um die Beschreibungen der Endpunkte zu verstehen. Basierend auf diesen Informationen wird ChatGPT den am besten geeigneten Endpunkt auswählen, um auf die Eingabe des Benutzers zu reagieren.

Schritt 2: Eine OpenAPI-Spezifikation erstellen

Die OpenAPI-Spezifikation ist ein Standard zur Beschreibung von REST-APIs. Sie wird verwendet, um jeden API-Endpunkt anzugeben, den das Plugin zur Kommunikation mit dem Modell verwenden wird. Lesen Sie hier mehr. Hier ist ein Beispiel für eine openapi.yaml-Datei:

openapi: 3.1.0
info:
  title: APISIX Admin API
  description: >-
    APISIX Admin API is a RESTful API that allows you to create and manage
    APISIX resources.
  version: 3.3.0
servers:
  - url: http://localhost:5000
    description: Dev Environment
tags:
  - name: Route
    description: |-
      A route defines a path to one or more upstream services.
      See [Routes](/apisix/key-concepts/routes) for more information.

paths:
  /apisix/admin/routes:
    get:
      operationId: getAllRoutes
      summary: Get All Routes
      deprecated: false
      description: Get all configured routes.
      tags:
        - Route
...
# Siehe die vollständige Version im GitHub-Repo

Die obige OpenAPI-Spezifikation ist nur ein Auszug aus dem echten Admin API-Schema, und Sie können leicht weitere API-Schemata hinzufügen, falls benötigt. In unserem Plugin-Demo haben wir nur Routen-bezogene Pfade verwendet.

Schritt 3: Endpunkte für Plugin-Statikdateien hinzufügen (Optional für localhost)

Als Nächstes erstellen wir eine Flask-App in Python, um unsere Statikdateien als Endpunkte für das Plugin-Logo, das Manifest und die OpenAPI-Spezifikation verfügbar zu machen. ChatGPT ruft die API-Endpunkte auf, um alle Informationen abzurufen, die für das benutzerdefinierte Plugin benötigt werden:

import requests
import os

import yaml
from flask import Flask, jsonify, request, send_from_directory
from flask_cors import CORS

app = Flask(__name__)

PORT = 5000

# Hinweis: Das Setzen von CORS, um chat.openapi.com zu erlauben, ist erforderlich, damit ChatGPT auf Ihr Plugin zugreifen kann
CORS(app, origins=[f"http://localhost:{PORT}", "https://chat.openai.com"])

api_url = 'http://apisix:9180'

@app.route('/.well-known/ai-plugin.json')
def serve_manifest():
    return send_from_directory(os.path.dirname(__file__), 'ai-plugin.json')

@app.route('/openapi.yaml')
def serve_openapi_yaml():
    with open(os.path.join(os.path.dirname(__file__), 'openapi.yaml'), 'r') as f:
        yaml_data = f.read()
    yaml_data = yaml.load(yaml_data, Loader=yaml.FullLoader)
    return jsonify(yaml_data)

@app.route('/logo.png')
def serve_openapi_json():
    return send_from_directory(os.path.dirname(__file__), 'logo.png')

# Um Anfragen von ChatGPT an das API Gateway weiterzuleiten
@app.route('/<path:path>', methods=['GET', 'POST'])
def wrapper(path):

    headers = {
    'Content-Type': 'application/json',
    }

    url = f'{api_url}/{path}'
    print(f'Forwarding call: {request.method} {path} -> {url}')

    if request.method == 'GET':
        response = requests.get(url, headers=headers, params=request.args)
    elif request.method in ['POST', 'DELETE', 'PATCH', 'PUT']:
        print(request.headers)
        response = requests.post(url, headers=headers, params=request.args, json=request.json)
    else:
        raise NotImplementedError(f'Method {request.method} not implemented in wrapper for {path=}')
    return response.content

if __name__ == '__main__':
    app.run(debug=True,host='0.0.0.0')

Wenn das Skript ausgeführt wird, können Sie Dateien auf der API-Domain aufrufen:

1. ai-plugin.json wird unter dem URI-Pfad http://localhost:5000/.well-known/ai-plugin.json verfügbar sein.
2. openapi.yaml wird unter dem URI-Pfad http://localhost:5000/openapi.yaml zugänglich sein.
3. logo.png wird unter dem URI-Pfad http://localhost:5000/logo.png verfügbar sein.

Beachten Sie, dass wir CORS im obigen Code nur aktiviert haben, um das Plugin lokal mit der ChatGPT-Benutzeroberfläche zu testen. Wenn das Plugin auf einem Remote-Server läuft, benötigen Sie keinen Proxy-Teil. Lesen Sie die OpenAI-Dokumentation, um das Plugin remote auszuführen.

Schritt 4: Dockerisierung der Python-App

Um die Python-App automatisch mit Docker auszuführen, erstellen wir ein Dockerfile und registrieren es in der docker-compose.yml-Datei. Erfahren Sie, wie Sie eine Python-App dockerisieren hier.

FROM python:3.9
WORKDIR /app
COPY requirements.txt requirements.txt
RUN pip3 install -r requirements.txt
COPY . .
CMD ["python","main.py"]

Schließlich sieht unsere docker-compose.yml-Datei so aus:

version: "3"

services:
  apisix:
    image: apache/apisix:3.3.0-debian
    volumes:
      - ./apisix_conf/config.yaml:/usr/local/apisix/conf/config.yaml:ro
    restart: always
    ports:
      - "9080:9080"
      - "9180:9180"
    depends_on:
      - etcd
  
  etcd:
    image: bitnami/etcd:3.5.9
    environment:
      ETCD_ENABLE_V2: "true"
      ALLOW_NONE_AUTHENTICATION: "yes"
      ETCD_ADVERTISE_CLIENT_URLS: "http://0.0.0.0:2397"
      ETCD_LISTEN_CLIENT_URLS: "http://0.0.0.0:2397"
  
  chatgpt-config:
    build: chatgpt-plugin-config
    ports:
      - '5000:5000'

Teil 3: Integration von ChatGPT mit dem benutzerdefinierten Plugin

Schritt 1: Das benutzerdefinierte Plugin bereitstellen

Sobald Sie die Entwicklung Ihres benutzerdefinierten Plugins abgeschlossen haben, ist es an der Zeit, es lokal bereitzustellen und auszuführen. Um das Projekt zu starten, führen Sie einfach den folgenden Befehl aus dem Projektstammverzeichnis aus:

docker compose up

Wenn Sie das Projekt starten, lädt Docker alle benötigten Images herunter. Sie können sehen, dass die Dienste APISIX, etcd und die Python-App (chatgpt-config) laufen.

Schritt 2: Das benutzerdefinierte Plugin mit der ChatGPT-Benutzeroberfläche verbinden

Sie haben also das ChatGPT-Plugin bereitgestellt, die Plugin-Konfigurationsdateien sind über die API zugänglich, und jetzt sind Sie bereit, es auszuprobieren. Wenn Sie ein Plus-Konto haben, müssen wir zuerst das Plugin in GPT-4 aktivieren, da es standardmäßig deaktiviert ist. Wir müssen zu den Einstellungen gehen, auf die Beta-Option klicken und „Plugins aktivieren“ auswählen. Dann klicken Sie auf die Plugin-Leiste oben in ChatGPT, navigieren Sie zum „Plugin Store“ und wählen Sie „Eigenes Plugin entwickeln“. Geben Sie die lokale Host-URL für das Plugin an (localhost:5000).

Nachdem Sie auf „Manifest-Datei suchen“ geklickt haben, wird ChatGPT, wenn alles korrekt eingerichtet ist, erfolgreich sowohl die Manifest- als auch die OpenAPI-Spezifikationsdateien validieren.

Schritt 3: Das benutzerdefinierte Plugin testen

Jetzt, da das Plugin mit der ChatGPT-Benutzeroberfläche verbunden ist, können wir einen einfachen Befehl eingeben:

Da wir keine Route in APISIX haben, können wir eine neue erstellen. Hier wird ChatGPT, abhängig von der Sprache, die in unserer Eingabeaufforderung verwendet wird, die entsprechenden APISIX-Endpunkte aufrufen. Bitte versuchen Sie, einen Befehl mit spezifischeren Details zu schreiben, damit ChatGPT eine Route korrekt erstellen kann.

Jetzt, da die Route erstellt wurde, können Sie den Gateway-Endpunkt aufrufen, um Details zu den Sitzungen der Konferenz abzurufen: http://localhost:9080/speaker/1/sessions. Sie können diese Conference API auch durch Ihre eigene Backend-API ersetzen.

Weitere Anwendungsfälle für das API Gateway benutzerdefinierte Plugin

Jetzt können Sie sich fragen: Was können Sie mit diesem Plugin sonst noch tun, außer einfach Anfragen weiterzuleiten? Es gibt viele Dinge, die Sie an diesem Plugin verbessern oder zusätzliche Funktionen hinzufügen können, die APISIX über die Admin API bietet. Da wir das API Gateway vor die Conference API geschaltet haben und das API Gateway alle Anfragen, die vom Plugin kommen, zuerst bearbeitet, können Sie mindestens Folgendes erreichen:

• Sicherheit: Angenommen, Sie möchten jetzt die Conference API sichern. Ohne API Gateway können Sie den Datenaustausch zwischen der ChatGPT-Benutzeroberfläche und dem Plugin immer noch durch die Verwendung von Plugin-Authentifizierungsmethoden von OpenAI sichern. Die Kommunikation zwischen dem Plugin und Ihrem Backend-Dienst bleibt jedoch ungesichert, bis Sie einige übergreifende Anliegen im Python-Code implementieren. Anstatt Zeit damit zu verbringen:
  • Wir können Sicherheitsmaßnahmen wie Authentifizierung, Autorisierung und Ratenbegrenzung mit dem API Gateway implementieren, um die Conference API vor unbefugtem Zugriff und potenziellen Angriffen zu schützen. ChatGPT kann frei mit dem API Gateway kommunizieren, aber die Kommunikation zwischen dem API Gateway und dem Backend-Dienst kann absolut sicher sein.
• Caching: Es ist möglich, ähnliche Antworten der Conference API zwischenzuspeichern, damit wir Daten für ChatGPT schnell anzeigen können.
• Versionierung: Wir können eine zweite Version der Conference API erstellen, um Anfragen des ChatGPT-Plugins an den neuesten Dienst weiterzuleiten, ohne die Konfiguration zu ändern oder Ausfallzeiten zu haben.
• Lastverteilung: Wir können eingehende Anfragen auf mehrere Instanzen der Conference API verteilen, um hohe Verfügbarkeit und effiziente Ressourcennutzung sicherzustellen.
• Anfrage-Transformation: Wir können die Anfragen an die Conference API modifizieren, um Datenumwandlung, Validierung oder die Umwandlung von Anfragen von REST zu GraphQL oder zu gRPC-Dienstaufrufen zu ermöglichen.
• Überwachung und Analyse: Das API Gateway bietet robuste Überwachungs- und Analyse-Plugins, mit denen Sie wertvolle Einblicke in die API-Nutzung, Leistung und potenzielle Probleme erhalten können.

Wenn Sie Apache APISIX API Gateway als Zugangspunkt für die Kommunikation zwischen benutzerdefinierten ChatGPT-Plugins und Backend-APIs verwenden möchten, können Sie dieses Repo überprüfen: API Gateway zwischen benutzerdefinierten ChatGPT-Plugins und Backend-APIs

Nächste Schritte

Im Laufe des Beitrags haben Sie gelernt, wie man das benutzerdefinierte Plugin für das API Gateway mit den grundlegenden Funktionen erstellt. Jetzt können Sie das Beispielprojekt als Grundlage nehmen und die Funktionalitäten verbessern, indem Sie weitere APISIX Admin API-Spezifikationen zur openapi.yaml-Datei hinzufügen, um andere Plugins zu verwenden und zu testen, und API-Consumer hinzufügen. Fühlen Sie sich frei, zum GitHub-Projekt beizutragen, indem Sie Pull Requests erstellen.

Verwandte Ressourcen

• API Gateway For ChatGPT Plugins