Création d'un Plugin Personnalisé ChatGPT pour API Gateway

Bobur Umurzokov

Bobur Umurzokov

July 12, 2023

Technology

ChatGPT Plugins servent de ponts reliant ChatGPT à des API externes pour utiliser intelligemment les données de ces API. Ces plugins permettent à ChatGPT d'effectuer une gamme de tâches, telles que la récupération d'informations en temps réel à partir d'autres API, y compris les résultats sportifs, les données boursières ou les actualités, et d'aider les utilisateurs à effectuer des actions comme la réservation de vols ou la commande de nourriture. Parallèlement, API Gateway est un outil puissant qui permet aux développeurs de créer, déployer et gérer des API à grande échelle. Il agit comme une passerelle entre ChatGPT et les services backend, fournissant des fonctionnalités telles que l'authentification, la limitation de débit et les transformations de requêtes/réponses.

Vous pouvez lire dans le post précédent où nous avons exploré comment API Gateway peut être utile pour les développeurs de plugins ChatGPT pour exposer, sécuriser, gérer et surveiller leurs points de terminaison API. Ce post vous guide étape par étape à travers la méthode simple et directe de développement d'un plugin ChatGPT pour API Gateway. En bonus amusant, vous apprendrez également comment ajouter votre plugin à ChatGPT et l'essayer. Alors, installez-vous confortablement, et embarquons pour ce voyage !

Comment créer un plugin ChatGPT pour API Gateway

Comme le guide de démarrage sur le site web d'OpenAI l'indique, pour construire tout nouveau plugin personnalisé ChatGPT, nous devons suivre ces 3 étapes générales :

  1. Développer une API ou utiliser une API existante qui implémente la spécification OpenAPI.
  2. Documenter l'API en utilisant soit le format OpenAPI YAML, soit JSON.
  3. Générer un fichier manifeste JSON de plugin qui contient des informations essentielles sur le plugin.

En suivant les étapes ci-dessus, nous allons construire un plugin personnalisé pour ChatGPT qui agit comme API Gateway pour les services API backend. Par exemple, dans l'interface utilisateur de ChatGPT, si un utilisateur souhaite introduire un API Gateway devant une API Conference existante pour obtenir des détails sur les sessions et les sujets d'un conférencier, le plugin est capable de recevoir des commandes dans le chat et de transmettre la requête de l'utilisateur à l'API Admin d'Apache APISIX, qui crée une Route avec la configuration d'entrée spécifiée par l'utilisateur. Cela peut être une autre approche pour utiliser le Chatbot pour configurer les fonctionnalités de l'API Gateway. Voir un exemple de sortie ci-dessous :

Chatbot pour configurer les fonctionnalités de l'API Gateway

Après l'exécution réussie de la commande, APISIX crée la route et enregistre un Upstream pour notre API backend Conference. Ainsi, vous pouvez accéder au domaine et au chemin URL de l'API Gateway pour obtenir une réponse via la passerelle. Par exemple, cette requête GET à l'endpoint http://localhost:9080/speaker/1/sessions renvoie toutes les sessions du conférencier de l'API Conference. Vous pouvez également effectuer des opérations de base comme obtenir toutes les routes, une route par Id, mettre à jour une route existante ou créer une route avec des plugins et des upstream directement en demandant à ChatGPT.

Pour comprendre le flux de données entre les différents composants, vous pouvez vous référer au diagramme architectural fourni :

Prérequis

Le dépôt de code entier pour le plugin complet d'API Gateway se trouve ici. Passons en revue les étapes une par une, y compris les extraits de code, les fichiers et comprenons comment configurer l'API Gateway, documenter l'API dans la définition OpenAPI, et créer un fichier manifeste de plugin.

La pile technologique utilisée pour le développement de ce plugin comprend les éléments suivants :

  1. Une API publique existante Conference API où nous utilisons deux endpoints API pour récupérer les sessions et les sujets d'un conférencier dans la démo. Vous pouvez découvrir d'autres API dans votre navigateur.
  2. Apache APISIX API Gateway pour exposer l'API Admin et gérer le trafic API.
  3. Un script Python pour exécuter le plugin, héberger le manifeste de plugin, la spécification OpenAPI et les fichiers de logo du plugin sur l'URL locale http://localhost:5000/.
  4. Le projet utilise Docker pour la commodité de construire, déployer et exécuter APISIX, etcd, et notre script Python avec une seule commande docker compose up.

Nous suivrons une série d'étapes pour créer le plugin. Dans la Partie 1, nous nous concentrerons sur la configuration d'APISIX. La Partie 2 concernera le développement du plugin ChatGPT lui-même, et la Partie 3 impliquera la connexion du plugin à ChatGPT et son test. Bien que nous présentions les étapes dans l'ordre, vous êtes libre de sauter l'une d'entre elles en fonction de votre familiarité avec le sujet.

Partie 1 : Configurer Apache APISIX

Étape 1 : Définir la configuration d'APISIX

Tout d'abord, nous créons un fichier de configuration pour APISIX. Les configurations d'APISIX peuvent être définies en utilisant diverses méthodes, y compris les fichiers de configuration statiques généralement écrits en YAML. Dans le fichier apisix.yml, nous avons fourni un exemple de configuration :

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

Vous pouvez également consulter ChatGPT pour comprendre ce que signifie le fichier apisix.yml ci-dessus. En gros, cette configuration définit le mode de déploiement pour APISIX. Ici, nous utilisons une option traditionnelle simple où APISIX utilise le stockage etcd pour stocker les détails de configuration tels qu'il les obtient de l'API Admin. Nous désactivons également la clé Admin admin_key_required pour les besoins de la démo.

Étape 2 : Enregistrer APISIX et etcd dans Docker Compose

Dans la dernière étape, nous créons un fichier docker-compose.yml et y enregistrons APISIX et etcd en tant que services pour les construire, les déployer et les exécuter. Et l'API Admin d'APISIX sera disponible sur le port : 9180 et la passerelle sur le port : 9080

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"

Partie 2 : Développement du plugin ChatGPT

Étape 1 : Créer un manifeste de plugin

Chaque plugin nécessite un fichier manifeste ai-plugin.json qui fournit des informations importantes sur votre plugin, comme son nom, sa description, ses logos, etc. Lisez-en plus sur chaque champ du fichier manifeste ici et OpenAI inclut quelques bonnes pratiques pour créer des descriptions de modèle (description_for_model). Lorsque vous installez le plugin sur l'interface ChatGPT, celle-ci cherchera le fichier manifeste sur votre domaine (http://localhost:5000/.well-known/ai-plugin.json). Cela aide ChatGPT à comprendre comment interagir avec votre plugin.

Créez un nouveau fichier nommé ai-plugin.json et collez le code suivant :

{
    "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"
}

Vous remarquerez que le fichier spécifie également l'URL vers le fichier http://localhost:5000/openapi.yaml.

Lorsqu'un utilisateur interagit avec ChatGPT, celui-ci se référera au fichier openapi.yaml pour comprendre les descriptions des endpoints. Sur la base de ces informations, ChatGPT déterminera l'endpoint le plus approprié à utiliser en réponse à l'invite de l'utilisateur.

Étape 2 : Créer une spécification OpenAPI

La spécification OpenAPI est une norme pour décrire les API REST. Elle est utilisée pour spécifier chaque endpoint API que le plugin utilisera pour communiquer avec le modèle. Lisez-en plus ici. Voici un exemple de fichier openapi.yaml :

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
...
# Voir la version complète sur le dépôt GitHub

La spécification OpenAPI ci-dessus est juste un extrait du véritable schéma de l'API Admin et vous pouvez facilement ajouter plus de schémas API si nécessaire. Dans notre démo de plugin, nous n'avons utilisé que les chemins liés aux routes.

Étape 3 : Ajouter des endpoints pour les fichiers statiques du plugin (Optionnel pour localhost)

Ensuite, nous créons une application Flask en Python pour exposer nos fichiers statiques en tant qu'endpoints pour le logo du plugin, le manifeste, et la spécification OpenAPI. ChatGPT effectue un appel aux endpoints API pour récupérer toutes les informations nécessaires pour le plugin personnalisé :

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

# Note : L'activation de CORS pour autoriser chat.openapi.com est nécessaire pour que ChatGPT accède à votre plugin
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')

# Pour rediriger les requêtes de ChatGPT vers l'API Gateway
@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')

Lorsque le script s'exécute, vous pouvez accéder aux fichiers sur le domaine API :

  1. ai-plugin.json sera disponible sur le chemin URI http://localhost:5000/.well-known/ai-plugin.json
  2. openapi.yaml sera accessible sur le chemin URI http://localhost:5000/openapi.yaml
  3. logo.png sera disponible sur le chemin URI http://localhost:5000/logo.png

Notez que nous avons activé CORS dans le code ci-dessus uniquement pour tester le plugin localement déployé avec l'interface ChatGPT. Si le plugin est exécuté sur un serveur distant, vous n'avez pas besoin de la partie proxy. Référez-vous à la documentation OpenAI pour exécuter le plugin à distance.

Étape 4 : Dockeriser l'application Python

Pour exécuter l'application Python automatiquement avec Docker, nous créons un Dockerfile et l'enregistrons dans le fichier docker-compose.yml. Apprenez comment dockeriser une application Python ici.

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

Enfin, notre fichier docker-compose.yml ressemble à ceci :

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'

Partie 3 : Intégrer ChatGPT avec le plugin personnalisé

Étape 1 : Déployer le plugin personnalisé

Une fois que vous avez terminé le développement de votre plugin personnalisé, il est temps de le déployer et de l'exécuter localement. Pour démarrer le projet, exécutez simplement la commande suivante depuis le répertoire racine du projet :

docker compose up

Lorsque vous démarrez le projet, Docker télécharge les images nécessaires pour l'exécution. Vous pouvez voir que les services APISIX, etcd et l'application Python (chatgpt-config) sont en cours d'exécution.

Déployer le plugin personnalisé

Étape 2 : Connecter le plugin personnalisé à l'interface ChatGPT

Vous avez donc déployé le plugin ChatGPT, les fichiers de configuration du plugin sont accessibles via l'API et vous êtes prêt à le tester. Si vous avez un compte Plus, nous devons d'abord activer le plugin dans GPT-4 car il est désactivé par défaut. Nous devons aller dans les paramètres et cliquer sur l'option bêta puis sur "Activer les plugins". Ensuite, cliquez sur la barre pop-up des plugins en haut de ChatGPT, naviguez vers "Plugin Store" et sélectionnez "Développez votre propre plugin". Fournissez l'URL locale pour le plugin (localhost:5000).

Connecter le plugin personnalisé à l'interface ChatGPT

Après avoir cliqué sur "Trouver un fichier manifeste", si tout est configuré correctement, vous verrez que ChatGPT valide avec succès à la fois le fichier manifeste et la spécification OpenAPI.

Trouver un fichier manifeste

Étape 3 : Tester le plugin personnalisé

Maintenant que le plugin est connecté à l'interface ChatGPT, nous pouvons écrire une commande simple :

Afficher toutes les routes

Puisque nous n'avons aucune route dans APISIX, nous pouvons en créer une nouvelle. Ici, en fonction du langage utilisé dans notre invite, ChatGPT choisira d'appeler les endpoints APISIX appropriés. Essayez d'écrire une commande avec des détails plus spécifiques pour que ChatGPT puisse créer une Route correctement.

Créer une route dans APISIX

Maintenant que la route a été créée, vous pouvez accéder à l'endpoint de la passerelle pour récupérer les détails des sessions de la conférence : http://localhost:9080/speaker/1/sessions. Vous pouvez également remplacer cette API Conference par votre propre API backend.

Autres cas d'utilisation du plugin personnalisé d'API Gateway

Maintenant, vous pouvez vous poser la question : Que pouvez-vous faire d'autre avec ce plugin que simplement router les requêtes ? Il y a beaucoup de choses que vous pouvez améliorer dans ce plugin ou ajouter des fonctionnalités supplémentaires qu'APISIX offre via l'API Admin. Parce que nous avons placé l'API Gateway devant l'API Conference et que l'API Gateway sert toutes les requêtes provenant du plugin en premier, vous pouvez réaliser au moins les actions suivantes :

  • Sécurité : Supposons que vous souhaitiez maintenant sécuriser l'API Conference, sans API Gateway en place, vous pouvez toujours sécuriser l'échange de données entre l'interface ChatGPT et le plugin en utilisant les méthodes d'Authentification de Plugin d'OpenAI. Cependant, la communication entre le plugin et votre service backend reste non sécurisée jusqu'à ce que vous implémentiez certaines préoccupations transversales dans le code Python, au lieu de passer du temps sur cela :
    • Nous pouvons implémenter des mesures de sécurité comme l'authentification, l'autorisation et la limitation de débit avec l'API Gateway pour protéger l'API Conference contre les accès non autorisés et les attaques potentielles. ChatGPT peut parler librement à l'API Gateway, mais la communication entre l'API Gateway et le service backend peut être absolument sécurisée.
  • Mise en cache : Il est possible de mettre en cache des réponses similaires de l'API Conference afin que nous puissions afficher rapidement les données pour ChatGPT.
  • Versioning : Nous pouvons créer la deuxième version de l'API Conference pour router les requêtes du plugin ChatGPT vers le service le plus récent sans changer de configuration ni de temps d'arrêt.
  • Équilibrage de charge : Nous pouvons répartir les requêtes entrantes sur plusieurs instances de l'API Conference, assurant une haute disponibilité et une utilisation efficace des ressources.
  • Transformation des requêtes : Nous pouvons modifier les requêtes faites à l'API Conference, permettant la transformation des données, la validation ou la transformation des requêtes de REST à GraphQL ou vers des appels de service gRPC.
  • Surveillance et analyse : L'API Gateway fournit des plugins robustes de surveillance et d'analyse, vous permettant de recueillir des informations précieuses sur l'utilisation des API, les performances et les problèmes potentiels.

Si vous souhaitez utiliser Apache APISIX API Gateway comme porte d'entrée pour la communication entre les plugins personnalisés ChatGPT et les API backend, vous pouvez consulter ce dépôt API Gateway entre les plugins personnalisés ChatGPT et les API backend

Prochaines étapes

Tout au long de ce post, vous avez appris à créer le plugin personnalisé pour l'API Gateway avec les fonctionnalités de base. Maintenant, vous pouvez prendre le projet d'exemple comme base et améliorer les fonctionnalités en ajoutant plus de spécifications de l'API Admin d'APISIX au fichier openapi.yaml pour utiliser et tester d'autres plugins et ajouter des consommateurs d'API et plus encore. N'hésitez pas à contribuer au projet GitHub en soumettant des pull requests.

Ressources connexes

Tags:
ChatGPT Custom Plugin
API Gateway ChatGPT
Developer ChaGPT plugin
Admin API
API Management