Construindo um Plugin Personalizado do ChatGPT para API Gateway
July 12, 2023
ChatGPT Plugins servem como pontes que conectam o ChatGPT a APIs externas para usar os dados dessas APIs de forma inteligente. Esses plugins permitem que o ChatGPT realize uma variedade de tarefas, como recuperar informações atualizadas de outras APIs, incluindo resultados esportivos, dados do mercado de ações ou notícias urgentes, e ajudar os usuários a realizar ações como reservar voos ou pedir comida. Enquanto isso, o API Gateway é uma ferramenta poderosa que permite aos desenvolvedores criar, implantar e gerenciar APIs em escala. Ele atua como um gateway entre o ChatGPT e os serviços de backend, fornecendo recursos como autenticação, limitação de taxa e transformações de solicitação/resposta.
Você pode ler no post anterior onde exploramos como o API Gateway pode ser útil para desenvolvedores de plugins do ChatGPT para expor, proteger, gerenciar e monitorar seus endpoints de API. Este post guia você passo a passo pelo método simples e direto de desenvolver um Plugin do ChatGPT para o API Gateway. Como um bônus divertido, você também aprenderá como adicionar seu plugin ao ChatGPT e testá-lo. Então, acomode-se e vamos embarcar nessa jornada!
Como criar um Plugin do ChatGPT para o API Gateway
Conforme o guia de introdução no site da OpenAI, para construir qualquer novo plugin personalizado do ChatGPT, precisamos seguir estes 3 passos gerais:
- Desenvolver uma API ou usar uma existente, que implemente a especificação OpenAPI.
- Documentar a API usando o formato OpenAPI YAML ou JSON.
- Gerar um arquivo de manifesto JSON do plugin que contenha informações essenciais sobre o plugin.
Seguindo os passos acima, vamos construir um plugin personalizado para o ChatGPT que atua como API Gateway para serviços de API de backend. Como exemplo, na interface do usuário do ChatGPT, se um usuário quiser introduzir um API Gateway na frente de uma Conference API existente para obter detalhes sobre as sessões e tópicos de um palestrante, o plugin é capaz de receber comandos no chat e, em seguida, encaminhar a solicitação do usuário para a Admin API do Apache APISIX, que cria uma Rota com a configuração de entrada especificada pelo usuário. Essa pode ser outra abordagem para usar o Chatbot para configurar os recursos do API Gateway. Veja um exemplo de saída abaixo:
Após o comando ser executado com sucesso, o APISIX cria a rota e registra um Upstream para nossa API de backend Conference. Assim, você pode acessar o domínio e o caminho da URL do API Gateway para obter uma resposta através do Gateway. Por exemplo, esta solicitação GET para o endpoint http://localhost:9080/speaker/1/sessions retorna todas as sessões do palestrante da Conference API. Você também pode realizar operações básicas como obter todas as rotas, uma rota por Id, atualizar uma rota existente ou criar uma rota com plugins e upstream diretamente perguntando ao ChatGPT.
Para entender o fluxo de dados entre os diversos componentes, você pode consultar o diagrama arquitetônico fornecido:
Pré-requisitos
- Antes de começar, é bom ter um entendimento básico do APISIX. Familiaridade com o conceito de API gateway e seus principais conceitos, como rotas, upstream, Admin API, plugins e o protocolo HTTP também será benéfico.
- Docker é usado para instalar o etcd e o APISIX em contêineres.
- Baixe o Visual Studio Code compatível com seu sistema operacional, ou use qualquer outro editor de código como IntelliJ IDEA, PyCharm, etc.
- Para desenvolver Plugins personalizados do ChatGPT, você precisa ter uma conta ChatGPT Plus e entrar na lista de espera de plugins.
O repositório de código completo para o Plugin do API Gateway está localizado aqui. Vamos passar pelos passos um a um, incluindo trechos de código, arquivos e entender como configurar o API Gateway, documentar a API na definição OpenAPI e criar um arquivo de manifesto do plugin.
A stack de tecnologia empregada para o desenvolvimento deste plugin inclui o seguinte:
- Uma Conference API pública existente, onde usamos dois endpoints da API para recuperar as sessões e tópicos de um palestrante na demonstração. Você pode descobrir outras APIs no seu navegador.
- O Apache APISIX API Gateway para expor a Admin API e gerenciar o tráfego da API.
- Um script Python para executar o plugin, hospedar o manifesto do plugin, a especificação OpenAPI e os arquivos de logo do plugin na URL local http://localhost:5000/.
- O projeto usa Docker por conveniência para construir, implantar e executar o APISIX, etcd e nosso script Python com um único comando
docker compose up.
Seguiremos uma série de passos para criar o plugin. Na Parte 1, focaremos na configuração do APISIX. A Parte 2 envolverá o desenvolvimento do plugin do ChatGPT em si, e a Parte 3 envolve conectar o plugin ao ChatGPT e testá-lo. Embora apresentemos os passos em ordem sequencial, você pode pular qualquer um deles com base na sua familiaridade com o assunto.
Parte 1: Configurar o Apache APISIX
Passo 1: Definir a Configuração do APISIX
Primeiro, criamos um arquivo de configuração do APISIX. As configurações do APISIX podem ser definidas usando vários métodos, incluindo arquivos de configuração estáticos, geralmente escritos em YAML. No arquivo apisix.yml, fornecemos um exemplo de configuração:
deployment:
etcd:
host:
- "http://etcd:2397"
admin:
admin_key_required: false
allow_admin:
- 0.0.0.0/0
Você também pode consultar o ChatGPT para entender o que o arquivo apisix.yml acima significa. Basicamente, essa configuração define o modo de implantação para o APISIX. Aqui, usamos uma opção tradicional simples onde o APISIX usa o armazenamento etcd para armazenar detalhes de configuração conforme os obtém da Admin API. Também desativamos a chave de administração admin_key_required para fins de demonstração.
Passo 2: Registrar o APISIX e o etcd no Docker Compose
No último passo, criamos um arquivo docker-compose.yml e registramos o APISIX e o etcd lá como serviços para construí-lo, implantá-lo e executá-lo. E a Admin API do APISIX estará disponível na porta: 9180 e o Gateway pode ser acessado na porta: 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: Desenvolvimento do plugin do ChatGPT
Passo 1: Criar um manifesto do plugin
Todo plugin requer um arquivo de manifesto ai-plugin.json que fornece informações importantes sobre o seu plugin, como seu nome, descrição, ativos de logo e assim por diante. Leia mais sobre cada campo do arquivo de manifesto aqui e a OpenAI inclui algumas melhores práticas para criar descrições de modelo (description_for_model). Quando você instala o plugin na interface do ChatGPT, a interface procurará o arquivo de manifesto no seu domínio (http://localhost:5000/.well-known/ai-plugin.json). Isso ajuda o ChatGPT a entender como interagir com o seu plugin.
Crie um novo arquivo chamado ai-plugin.json e cole o seguinte 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"
}
Você pode notar que o arquivo também especifica a URL para o arquivo http://localhost:5000/openapi.yaml.
Quando um usuário interage com o ChatGPT, ele se referirá ao arquivo
openapi.yamlpara entender as descrições dos endpoints. Com base nessas informações, o ChatGPT determinará o endpoint mais adequado para utilizar em resposta ao prompt do usuário.
Passo 2: Criar uma especificação OpenAPI
A especificação OpenAPI é um padrão para descrever APIs REST. Ela é usada para especificar cada endpoint da API que o plugin usará para se comunicar com o modelo. Leia mais aqui. Aqui está um exemplo do arquivo 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
...
# Veja a versão completa no repositório do GitHub
A especificação OpenAPI acima é apenas uma extração do esquema real da Admin API e você pode facilmente adicionar mais esquemas de API se necessário. Em nossa demonstração de plugin, usamos apenas caminhos relacionados a Rotas.
Passo 3: Adicionar endpoints para arquivos estáticos do plugin (Opcional para localhost)
Em seguida, criamos um app Flask em Python para expor nossos arquivos estáticos como endpoints para o logo do plugin, manifesto e especificação OpenAPI. O ChatGPT faz uma chamada para os endpoints da API para buscar todas as informações necessárias para o 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: Configurar o CORS para permitir chat.openapi.com é necessário para o ChatGPT acessar seu 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 encaminhar solicitações do ChatGPT para o API Gateway
@app.route('/<path:path>', methods=['GET', 'POST'])
def wrapper(path):
headers = {
'Content-Type': 'application/json',
}
url = f'{api_url}/{path}'
print(f'Encaminhando chamada: {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} não implementado no wrapper para {path=}')
return response.content
if __name__ == '__main__':
app.run(debug=True,host='0.0.0.0')
Quando o script é executado, você pode acessar os arquivos no domínio da API:
ai-plugin.jsonestará disponível no caminho URI http://localhost:5000/.well-known/ai-plugin.jsonopenapi.yamlestará acessível no caminho URI http://localhost:5000/openapi.yamllogo.pngestará disponível no caminho URI http://localhost:5000/logo.png
Observe que habilitamos o CORS no código acima apenas para testar o plugin localmente implantado com a interface do ChatGPT. Se o plugin estiver rodando em um servidor remoto, você não precisa da parte do proxy. Consulte a documentação da OpenAI para rodar o plugin remotamente.
Passo 4: Dockerizar o app Python
Para rodar o app Python automaticamente com o Docker, criamos um Dockerfile e o registramos no arquivo docker-compose.yml. Aprenda como dockerizar um app Python aqui.
FROM python:3.9
WORKDIR /app
COPY requirements.txt requirements.txt
RUN pip3 install -r requirements.txt
COPY . .
CMD ["python","main.py"]
Finalmente, nosso arquivo docker-compose.yml fica assim:
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 o ChatGPT com o plugin personalizado
Passo 1: Implantar o plugin personalizado
Uma vez que você tenha concluído o desenvolvimento do seu plugin personalizado, é hora de implantá-lo e rodá-lo localmente. Para iniciar o projeto, execute simplesmente o seguinte comando a partir do diretório raiz do projeto:
docker compose up
Quando você inicia o projeto, o Docker baixa quaisquer imagens necessárias para rodar. Você pode ver que os serviços APISIX, etcd e o app Python (chatgpt-config) estão rodando.
Passo 2: Conectar o plugin personalizado à interface do ChatGPT
Então, você implantou o plugin do ChatGPT, os arquivos de configuração do plugin estão acessíveis via API e agora você está pronto para testá-lo. Se você tiver uma conta Plus, devemos primeiro habilitar o plugin no GPT-4, pois ele está desabilitado por padrão. Precisamos ir para as configurações e clicar na opção beta e clicar em “Habilitar plugins”. Em seguida, clique na barra de plugins no topo do ChatGPT, navegue até “Plugin Store” e selecione “Desenvolva seu próprio plugin”. Forneça a URL local para o plugin (localhost:5000).
Depois de clicar em “Encontrar um arquivo de manifesto”, se tudo estiver configurado corretamente, você verá que o ChatGPT valida com sucesso tanto o manifesto quanto o arquivo de especificação OpenAPI.
Passo 3: Testar o plugin personalizado
Agora que o plugin está conectado à interface do ChatGPT, podemos escrever um comando simples:
Como não temos nenhuma rota no APISIX, podemos criar uma nova. Aqui, dependendo da linguagem usada no nosso prompt, o ChatGPT escolherá chamar os endpoints apropriados do APISIX. Por favor, tente escrever um comando com mais detalhes específicos para que o ChatGPT possa criar uma Rota corretamente.
Agora que a rota foi criada, você pode acessar o endpoint do Gateway para buscar detalhes das sessões da Conference: http://localhost:9080/speaker/1/sessions. Você também pode substituir essa Conference API pela sua API de backend.
Outros casos de uso do plugin personalizado do API Gateway
Agora você pode se perguntar: O que mais você pode fazer com este plugin além de simplesmente rotear as solicitações? Há muitas coisas que você pode melhorar neste plugin ou adicionar recursos extras que o APISIX oferece via a Admin API. Como colocamos o API Gateway na frente da Conference API e o API Gateway atende a todas as solicitações que vêm do plugin primeiro, você pode alcançar pelo menos o seguinte:
- Segurança: Suponha que agora você queira proteger a Conference API, sem o API Gateway em vigor, você ainda pode proteger a troca de dados entre a interface do ChatGPT e o plugin usando métodos de Autenticação de Plugin da OpenAI. No entanto, a comunicação entre o plugin e o seu serviço de backend ainda permanece insegura até que você implemente algumas preocupações transversais no código Python, em vez de gastar tempo com isso:
- Podemos implementar medidas de segurança como autenticação, autorização e limitação de taxa com o API Gateway para proteger a Conference API de acessos não autorizados e possíveis ataques. O ChatGPT pode falar com o API Gateway livremente, mas a comunicação entre o API Gateway e o serviço de backend pode ser absolutamente segura.
- Cache: É possível armazenar em cache respostas semelhantes da Conference API para que possamos mostrar dados para o ChatGPT rapidamente.
- Versionamento: Podemos criar a segunda versão da Conference API para rotear as solicitações do plugin do ChatGPT para o serviço mais novo sem alterar nenhuma configuração e sem tempo de inatividade.
- Balanceamento de Carga: Podemos distribuir as solicitações recebidas entre várias instâncias da Conference API, garantindo alta disponibilidade e utilização eficiente de recursos.
- Transformação de Solicitação: Podemos modificar as solicitações feitas à Conference API, permitindo transformação de dados, validação ou transformar solicitações de REST para GraphQL ou para chamadas de serviço gRPC.
- Monitoramento e Análise: O API Gateway fornece plugins robustos de monitoramento e análise, permitindo que você colete insights valiosos sobre o uso da API, desempenho e possíveis problemas.
Se você quiser usar o Apache APISIX API Gateway como uma porta de entrada para a comunicação entre plugins personalizados do ChatGPT e APIs de backend, você pode conferir este repositório API Gateway entre plugins personalizados do ChatGPT e APIs de backend
Próximos passos
Ao longo do post, você aprendeu como criar o plugin personalizado para o API Gateway com funcionalidades básicas. Agora você pode pegar o projeto de exemplo como base e melhorar as funcionalidades adicionando mais especificações da Admin API do APISIX ao arquivo openapi.yaml para usar e testar outros plugins e adicionar consumidores de API e mais. Sinta-se à vontade para contribuir com o projeto no GitHub criando pull requests.