Creación de un Plugin Personalizado de ChatGPT para API Gateway

Bobur Umurzokov

Bobur Umurzokov

July 12, 2023

Technology

ChatGPT Plugins sirven como puentes que conectan ChatGPT con APIs externas para utilizar los datos de estas APIs de manera inteligente. Estos plugins permiten que ChatGPT realice una variedad de tareas, como recuperar información actualizada de otras APIs, incluyendo resultados deportivos, datos del mercado de valores o noticias de última hora, y ayudar a los usuarios a realizar acciones como reservar vuelos o pedir comida. Mientras tanto, API Gateway es una herramienta poderosa que permite a los desarrolladores construir, desplegar y gestionar APIs a escala. Actúa como una puerta de enlace entre ChatGPT y los servicios backend, proporcionando características como autenticación, limitación de tasa y transformaciones de solicitud/respuesta.

Puedes leer en la publicación anterior donde exploramos cómo API Gateway puede ser útil para los desarrolladores de plugins de ChatGPT para exponer, asegurar, gestionar y monitorear sus puntos finales de API. Esta publicación te guía paso a paso a través del método sencillo y directo de desarrollar un Plugin de ChatGPT para API Gateway. Como un extra divertido, también aprenderás cómo agregar tu plugin a ChatGPT y probarlo. Así que, ponte cómodo y ¡comencemos este viaje!

Cómo crear un Plugin de ChatGPT para API Gateway

Como indica la guía de inicio en el sitio web de OpenAI, para construir cualquier nuevo plugin personalizado de ChatGPT, necesitamos seguir estos 3 pasos generales:

  1. Desarrollar una API o usar una existente, que implemente la especificación OpenAPI.
  2. Documentar la API utilizando el formato OpenAPI YAML o JSON.
  3. Generar un archivo de manifiesto JSON del plugin que contenga información esencial sobre el plugin.

Siguiendo los pasos anteriores, vamos a construir un plugin personalizado para ChatGPT que actúe como API Gateway para los servicios de API backend. Como ejemplo, en la interfaz de usuario de ChatGPT, si un usuario desea introducir un API Gateway frente a una API de Conferencias existente para obtener detalles sobre las sesiones y temas de un orador, el plugin es capaz de recibir comandos en el chat y luego reenviar la solicitud del usuario a la API de Administración de Apache APISIX, que crea una Ruta con la configuración de entrada especificada por el usuario. Este puede ser otro enfoque para usar el Chatbot para configurar las características del API Gateway. Ver el resultado de muestra a continuación:

Chatbot para configurar las características del API Gateway

Después de que el comando se ejecuta con éxito, APISIX crea la ruta y registra un Upstream para nuestra API backend de Conferencias. Por lo tanto, puedes acceder al dominio y la URL del API Gateway para obtener una respuesta a través del Gateway. Por ejemplo, esta solicitud GET a http://localhost:9080/speaker/1/sessions devuelve todas las sesiones del orador desde la API de Conferencias. También puedes realizar operaciones básicas como obtener todas las rutas, una ruta por Id, actualizar una ruta existente o crear una ruta con plugins y upstream directamente preguntando a ChatGPT.

Para comprender el flujo de datos entre los diversos componentes, puedes referirte al diagrama arquitectónico proporcionado:

Requisitos previos

El repositorio completo del código para el Plugin de API Gateway se encuentra aquí. Vamos a revisar los pasos uno por uno, incluyendo fragmentos de código, archivos y entender cómo configurar el API Gateway, documentar la API en la definición OpenAPI y crear un archivo de manifiesto del plugin.

La pila tecnológica empleada para el desarrollo de este plugin incluye lo siguiente:

  1. Una API pública existente de Conferencias donde usamos dos puntos finales de API para recuperar la información de sesiones y temas de un orador en la demo. Puedes descubrir otras APIs en tu navegador.
  2. Apache APISIX API Gateway para exponer la API de Administración y gestionar el tráfico de la API.
  3. Un script en Python para ejecutar el plugin, alojar el manifiesto del plugin, la especificación OpenAPI y los archivos del logo del plugin en la URL local http://localhost:5000/.
  4. El proyecto utiliza Docker por conveniencia para construir, desplegar y ejecutar APISIX, etcd y nuestro script de Python con un solo comando docker compose up.

Seguiremos una serie de pasos para crear el plugin. En la Parte 1, nos enfocaremos en configurar APISIX. La Parte 2 implicará el desarrollo del plugin de ChatGPT en sí, y la Parte 3 consiste en conectar el plugin a ChatGPT y probarlo. Aunque presentamos los pasos en orden secuencial, eres libre de saltar cualquiera de ellos según tu familiaridad con el tema.

Parte 1: Configurar Apache APISIX

Paso 1: Definir la configuración de APISIX

Primero, creamos un archivo de configuración de APISIX. Las configuraciones de APISIX se pueden definir utilizando varios métodos, incluyendo archivos de configuración estáticos típicamente escritos en YAML. En el archivo apisix.yml, proporcionamos un ejemplo de configuración:

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

También puedes consultar con ChatGPT para entender qué significa el archivo apisix.yml anterior. Básicamente, esta configuración define el modo de despliegue para APISIX. Aquí, usamos una opción tradicional donde APISIX utiliza el almacenamiento etcd para guardar los detalles de configuración que obtiene de la API de Administración. También deshabilitamos la clave de administración admin_key_required para la demo.

Paso 2: Registrar APISIX y etcd en Docker Compose

En el último paso, creamos un archivo docker-compose.yml y registramos APISIX y etcd allí como servicios para construirlo, desplegarlo y ejecutarlo. Y la API de Administración de APISIX estará disponible en el puerto: 9180 y el Gateway lo puedes acceder en el puerto: 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"

Parte 2: Desarrollo del plugin de ChatGPT

Paso 1: Crear un manifiesto del plugin

Cada plugin requiere un archivo de manifiesto ai-plugin.json que proporciona información importante sobre tu plugin, como su nombre, descripción, logotipos, etc. Lee más sobre cada campo del archivo de manifiesto aquí y OpenAI incluye algunas mejores prácticas para crear descripciones del modelo (description_for_model). Cuando instalas el plugin en la interfaz de ChatGPT, la interfaz buscará el archivo de manifiesto en tu dominio (http://localhost:5000/.well-known/ai-plugin.json). Esto ayuda a ChatGPT a entender cómo interactuar con tu plugin.

Crea un nuevo archivo llamado ai-plugin.json y pega el siguiente código:

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

Puedes notar que el archivo también especifica la URL al archivo http://localhost:5000/openapi.yaml.

Cuando un usuario interactúa con ChatGPT, este se referirá al archivo openapi.yaml para entender las descripciones de los puntos finales. Basándose en esta información, ChatGPT determinará el punto final más adecuado para utilizar en respuesta al mensaje del usuario.

Paso 2: Crear una especificación OpenAPI

La especificación OpenAPI es un estándar para describir APIs REST. Se utiliza para especificar cada punto final de la API que el plugin usará para comunicarse con el modelo. Lee más aquí. Aquí hay un ejemplo del archivo 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
...
# Ver la versión completa en el repositorio de GitHub

La especificación OpenAPI anterior es solo una extracción del esquema real de la API de Administración y puedes fácilmente agregar más esquemas de API si es necesario. En nuestra demo del plugin, solo usamos rutas relacionadas con Route.

Paso 3: Agregar puntos finales para archivos estáticos del plugin (Opcional para localhost)

A continuación, creamos una aplicación Flask en Python para exponer nuestros archivos estáticos como puntos finales para el logotipo del plugin, el manifiesto y la especificación OpenAPI. ChatGPT hace una llamada a los puntos finales de la API para obtener toda la información necesaria para el plugin personalizado:

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

# Nota: Habilitar CORS para permitir chat.openapi.com es necesario para que ChatGPT acceda a tu 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')

# Para redirigir solicitudes de ChatGPT al API Gateway
@app.route('/<path:path>', methods=['GET', 'POST'])
def wrapper(path):

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

    url = f'{api_url}/{path}'
    print(f'Redirigiendo llamada: {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'Método {request.method} no implementado en el wrapper para {path=}')
    return response.content

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

Cuando el script se ejecuta, puedes acceder a los archivos en el dominio de la API:

  1. ai-plugin.json estará disponible en la ruta URI http://localhost:5000/.well-known/ai-plugin.json
  2. openapi.yaml será accesible en la ruta URI http://localhost:5000/openapi.yaml
  3. logo.png estará disponible en la ruta URI http://localhost:5000/logo.png

Nota que habilitamos CORS en el código anterior solo para probar el plugin localmente desplegado con la interfaz de ChatGPT. Si el plugin se ejecuta en un servidor remoto, no necesitas la parte del proxy. Consulta la documentación de OpenAI para ejecutar el plugin de manera remota.

Paso 4: Dockerizar la aplicación Python

Para ejecutar la aplicación Python automáticamente con Docker, creamos un Dockerfile y lo registramos en el archivo docker-compose.yml. Aprende cómo dockerizar una aplicación Python aquí.

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

Finalmente, nuestro archivo docker-compose.yml se ve así:

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'

Parte 3: Integrar ChatGPT con el plugin personalizado

Paso 1: Desplegar el plugin personalizado

Una vez que hayas completado el desarrollo de tu plugin personalizado, es hora de desplegarlo y ejecutarlo localmente. Para iniciar el proyecto, simplemente ejecuta el siguiente comando desde el directorio raíz del proyecto:

docker compose up

Cuando inicias el proyecto, Docker descarga cualquier imagen que necesite para ejecutarse. Puedes ver que los servicios de APISIX, etcd y la aplicación Python (chatgpt-config) están en ejecución.

Desplegar el plugin personalizado

Paso 2: Conectar el plugin personalizado a la interfaz de ChatGPT

Entonces, has desplegado el plugin de ChatGPT, los archivos de configuración del plugin son accesibles a través de la API y ahora estás listo para probarlo. Si tienes una cuenta Plus, primero debemos habilitar el plugin en GPT-4 ya que está deshabilitado por defecto. Necesitamos ir a la configuración y hacer clic en la opción beta y luego en "Habilitar plugins". Luego haz clic en la barra emergente de plugins en la parte superior de ChatGPT, navega a "Plugin Store" y selecciona "Desarrolla tu propio plugin". Proporciona la URL local para el plugin (localhost:5000).

Conectar el plugin personalizado a la interfaz de ChatGPT

Después de hacer clic en "Encontrar un archivo de manifiesto", si todo está configurado correctamente, verás que ChatGPT valida con éxito tanto el archivo de manifiesto como la especificación OpenAPI.

Encontrar un archivo de manifiesto

Paso 3: Probar el plugin personalizado

Ahora que el plugin está conectado a la interfaz de ChatGPT, podemos escribir un comando simple:

Mostrar todas las rutas

Como no tenemos ninguna ruta en APISIX, podemos crear una nueva. Aquí, dependiendo del lenguaje utilizado en nuestro mensaje, ChatGPT elegirá llamar a los puntos finales apropiados de APISIX. Por favor, intenta escribir un comando con más detalles específicos para que ChatGPT pueda crear una Ruta correctamente.

Crear una ruta en APISIX

Ahora que la ruta ha sido creada, puedes acceder al punto final del Gateway para obtener los detalles de las sesiones de la Conferencia: http://localhost:9080/speaker/1/sessions. También puedes reemplazar esta API de Conferencias con tu propia API backend.

Otros casos de uso del plugin personalizado de API Gateway

Ahora puedes preguntarte: ¿Qué más puedes hacer con este plugin además de simplemente enrutar las solicitudes? Hay muchas cosas que puedes mejorar en este plugin o agregar características adicionales que APISIX ofrece a través de la API de Administración. Debido a que colocamos el API Gateway frente a la API de Conferencias y el API Gateway sirve todas las solicitudes que provienen del plugin primero, puedes lograr al menos lo siguiente:

  • Seguridad: Supongamos que ahora deseas asegurar la API de Conferencias, sin API Gateway en su lugar, aún puedes asegurar el intercambio de datos entre la interfaz de ChatGPT y el plugin utilizando Métodos de Autenticación de Plugin de OpenAI. Sin embargo, la comunicación entre el plugin y tu servicio backend sigue siendo insegura hasta que implementes algunas preocupaciones transversales en el código Python, en lugar de perder tiempo en esto:
    • Podemos implementar medidas de seguridad como autenticación, autorización y limitación de tasa con el API Gateway para proteger la API de Conferencias de accesos no autorizados y posibles ataques. ChatGPT puede hablar libremente con el API Gateway, pero la comunicación entre el API Gateway y el servicio backend puede ser absolutamente segura.
  • Caché: Es posible almacenar en caché respuestas similares de la API de Conferencias para que podamos mostrar datos a ChatGPT rápidamente.
  • Versionado: Podemos crear la segunda versión de la API de Conferencias para enrutar las solicitudes del plugin de ChatGPT al servicio más nuevo sin cambiar ninguna configuración y sin tiempo de inactividad.
  • Balanceo de Carga: Podemos distribuir las solicitudes entrantes entre múltiples instancias de la API de Conferencias, asegurando alta disponibilidad y uso eficiente de los recursos.
  • Transformación de Solicitudes: Podemos modificar las solicitudes hechas a la API de Conferencias, permitiendo la transformación de datos, validación o transformar solicitudes de REST a GraphQL o a llamadas de servicio gRPC.
  • Monitoreo y Análisis: El API Gateway proporciona plugins robustos de monitoreo y análisis, permitiéndote recopilar información valiosa sobre el uso de la API, el rendimiento y posibles problemas.

Si deseas usar Apache APISIX API Gateway como puerta de entrada para la comunicación entre plugins personalizados de ChatGPT y APIs backend, puedes revisar este repositorio API Gateway entre plugins personalizados de ChatGPT y APIs backend

Próximos pasos

A lo largo de la publicación, aprendiste cómo crear el plugin personalizado para API Gateway con funcionalidades básicas. Ahora puedes tomar el proyecto de muestra como base y mejorar las funcionalidades agregando más especificaciones de la API de Administración de APISIX al archivo openapi.yaml para usar y probar otros plugins y agregar consumidores de API y más. Siéntete libre de contribuir al proyecto de GitHub enviando solicitudes de extracción.

Recursos relacionados

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