Membangun Plugin Kustom ChatGPT untuk API Gateway

ChatGPT Plugins berfungsi sebagai jembatan yang menghubungkan ChatGPT ke API eksternal untuk menggunakan data dari API tersebut secara cerdas. Plugin ini memungkinkan ChatGPT melakukan berbagai tugas, seperti mengambil informasi terkini dari API lain termasuk hasil olahraga, data pasar saham, atau berita terbaru, serta membantu pengguna dalam melakukan tindakan seperti memesan tiket pesawat atau memesan makanan. Sementara itu, API Gateway adalah alat yang kuat yang memungkinkan pengembang untuk membangun, menerapkan, dan mengelola API dalam skala besar. Ini bertindak sebagai gateway antara ChatGPT dan layanan backend, menyediakan fitur seperti autentikasi, pembatasan kecepatan, dan transformasi permintaan/tanggapan.

Anda dapat membaca dari postingan sebelumnya di mana kami menjelajahi bagaimana API Gateway dapat membantu pengembang plugin ChatGPT untuk mengekspos, mengamankan, mengelola, dan memantau endpoint API mereka. Postingan ini akan memandu Anda langkah demi langkah melalui metode yang sederhana dan langsung untuk mengembangkan Plugin ChatGPT untuk API Gateway. Sebagai bonus, Anda juga akan belajar cara menambahkan plugin Anda ke ChatGPT dan mencobanya. Jadi, buat diri Anda nyaman, dan mari kita mulai perjalanan ini!

Cara membuat Plugin ChatGPT untuk API Gateway

Seperti yang dinyatakan dalam panduan memulai di situs web OpenAI, untuk membangun plugin ChatGPT kustom baru, kita perlu mengikuti 3 langkah umum berikut:

1. Mengembangkan API atau menggunakan API yang sudah ada, yang mengimplementasikan spesifikasi OpenAPI.
2. Mendokumentasikan API menggunakan format OpenAPI YAML atau JSON.
3. Membuat file manifes plugin JSON yang berisi informasi penting tentang plugin.

Dengan mengikuti langkah-langkah di atas, kita akan membangun plugin kustom untuk ChatGPT yang bertindak sebagai API Gateway untuk layanan API backend. Sebagai contoh, di antarmuka pengguna ChatGPT, jika seorang pengguna ingin memperkenalkan API Gateway di depan Conference API yang sudah ada untuk mendapatkan detail tentang sesi dan topik pembicara, plugin ini mampu menerima perintah dalam chat dan kemudian meneruskan permintaan pengguna ke Admin API Apache APISIX, yang membuat Route dengan konfigurasi input yang ditentukan pengguna. Ini bisa menjadi pendekatan lain untuk menggunakan Chatbot untuk mengonfigurasi fitur API Gateway. Lihat contoh output di bawah ini:

Setelah perintah berhasil dijalankan, APISIX membuat route dan mendaftarkan Upstream untuk API backend Conference kami. Jadi, Anda dapat mengakses domain API Gateway dan jalur URL untuk mendapatkan respons melalui Gateway. Misalnya, permintaan GET ke endpoint http://localhost:9080/speaker/1/sessions mengembalikan semua sesi pembicara dari Conference API. Anda juga dapat melakukan operasi dasar seperti mendapatkan semua route, route berdasarkan Id, memperbarui route yang ada, atau membuat route dengan plugin dan upstream langsung dengan bertanya kepada ChatGPT.

Untuk memahami aliran data antara berbagai komponen, Anda dapat merujuk pada diagram arsitektur yang disediakan:

Prasyarat

• Sebelum memulai, ada baiknya memiliki pemahaman dasar tentang APISIX. Keakraban dengan API gateway, dan konsep-konsep utamanya seperti route, upstream, Admin API, plugin, dan protokol HTTP juga akan bermanfaat.
• Docker digunakan untuk menginstal etcd dan APISIX yang dikontainerisasi.
• Unduh Visual Studio Code yang kompatibel dengan sistem operasi Anda, atau gunakan editor kode lain seperti IntelliJ IDEA, PyCharm, dll.
• Untuk mengembangkan Plugin ChatGPT kustom, Anda perlu memiliki akun ChatGPT Plus dan bergabung dengan daftar tunggu plugin.

Seluruh repositori kode untuk Plugin API Gateway lengkap dapat ditemukan di sini. Mari kita bahas langkah-langkahnya satu per satu termasuk cuplikan kode, file, dan memahami cara menyiapkan API Gateway, mendokumentasikan API dalam definisi OpenAPI, dan membuat file manifes plugin.

Stack teknologi yang digunakan untuk pengembangan plugin ini meliputi:

1. API publik Conference API yang sudah ada di mana kami menggunakan dua endpoint API untuk mengambil informasi sesi dan topik pembicara dalam demo. Anda dapat menemukan API lain di browser Anda.
2. Apache APISIX API Gateway untuk mengekspos Admin API dan mengelola lalu lintas API.
3. Skrip Python untuk menjalankan plugin, menghosting file manifes plugin, spesifikasi OpenAPI, dan logo plugin di URL lokal http://localhost:5000/.
4. Proyek ini menggunakan Docker untuk kemudahan dalam membangun, menerapkan, dan menjalankan APISIX, etcd, dan skrip Python kami dengan satu perintah docker compose up.

Kami akan mengikuti serangkaian langkah untuk membuat plugin. Pada Bagian 1, kami akan fokus pada penyiapan APISIX. Bagian 2 akan melibatkan pengembangan plugin ChatGPT itu sendiri, dan Bagian 3 melibatkan menghubungkan plugin ke ChatGPT dan mengujinya. Meskipun kami menyajikan langkah-langkah secara berurutan, Anda dapat melewatkan beberapa langkah berdasarkan keakraban Anda dengan materi.

Bagian 1: Menyiapkan Apache APISIX

Langkah 1: Mendefinisikan Konfigurasi APISIX

Pertama, kami membuat file konfigurasi APISIX. Konfigurasi APISIX dapat didefinisikan menggunakan berbagai metode, termasuk file konfigurasi statis yang biasanya ditulis dalam YAML. Dalam file apisix.yml, kami memberikan contoh konfigurasi:

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

Anda juga dapat berkonsultasi dengan ChatGPT untuk memahami apa arti file apisix.yml di atas. Pada dasarnya, konfigurasi ini mendefinisikan mode penyebaran untuk APISIX. Di sini, kami menggunakan opsi tradisional sederhana di mana APISIX menggunakan penyimpanan etcd untuk menyimpan detail konfigurasi yang didapat dari Admin API. Kami juga menonaktifkan kunci Admin admin_key_required untuk keperluan demo.

Langkah 2: Mendaftarkan APISIX dan etcd di Docker Compose

Pada langkah terakhir, kami membuat file docker-compose.yml dan mendaftarkan APISIX dan etcd di sana sebagai layanan untuk membangun, menerapkan, dan menjalankannya. Dan Admin API APISIX akan tersedia di port: 9180 dan Gateway dapat diakses di 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"

Bagian 2: Pengembangan plugin ChatGPT

Langkah 1: Membuat manifes plugin

Setiap plugin memerlukan file manifes ai-plugin.json yang memberikan informasi penting tentang plugin Anda, seperti nama, deskripsi, aset logo, dan sebagainya. Baca lebih lanjut tentang setiap bidang file manifes di sini dan OpenAI menyertakan beberapa praktik terbaik untuk membuat deskripsi model (description_for_model). Saat Anda menginstal plugin di antarmuka ChatGPT, antarmuka akan mencari file manifes di domain Anda (http://localhost:5000/.well-known/ai-plugin.json). Ini membantu ChatGPT memahami cara berinteraksi dengan plugin Anda.

Buat file baru bernama ai-plugin.json dan tempelkan kode berikut:

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

Anda mungkin memperhatikan bahwa file tersebut juga menentukan URL ke file http://localhost:5000/openapi.yaml.

Ketika pengguna berinteraksi dengan ChatGPT, ia akan merujuk ke file openapi.yaml untuk memahami deskripsi endpoint. Berdasarkan informasi ini, ChatGPT akan menentukan endpoint yang paling sesuai untuk digunakan dalam menanggapi prompt pengguna.

Langkah 2: Membuat spesifikasi OpenAPI

Spesifikasi OpenAPI adalah standar untuk mendeskripsikan REST API. Ini digunakan untuk menentukan setiap endpoint API yang akan digunakan plugin untuk berkomunikasi dengan model. Baca lebih lanjut di sini. Berikut adalah contoh file 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
...
# Lihat versi lengkap di repositori GitHub

Spesifikasi OpenAPI di atas hanyalah ekstraksi dari skema Admin API yang sebenarnya dan Anda dapat dengan mudah menambahkan lebih banyak skema API jika diperlukan. Dalam demo plugin kami, kami hanya menggunakan path yang terkait dengan Route.

Langkah 3: Menambahkan endpoint untuk file statis plugin (Opsional untuk localhost)

Selanjutnya, kami membuat aplikasi Flask dalam Python untuk mengekspos file statis kami sebagai endpoint untuk logo plugin, manifes, dan spesifikasi OpenAPI. ChatGPT melakukan panggilan ke endpoint API untuk mengambil semua informasi yang diperlukan untuk plugin kustom:

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

# Catatan: Mengatur CORS untuk mengizinkan chat.openapi.com diperlukan agar ChatGPT dapat mengakses plugin Anda
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')

# Untuk memproksi permintaan dari ChatGPT ke 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')

Saat skrip dijalankan, Anda dapat mengakses file di domain API:

1. ai-plugin.json akan tersedia di jalur URI http://localhost:5000/.well-known/ai-plugin.json
2. openapi.yaml akan dapat diakses di jalur URI http://localhost:5000/openapi.yaml
3. logo.png akan tersedia di jalur URI http://localhost:5000/logo.png

Perhatikan bahwa kami mengaktifkan CORS dalam kode di atas hanya untuk menguji plugin yang di-deploy secara lokal dengan antarmuka ChatGPT. Jika plugin berjalan di server jarak jauh, Anda tidak memerlukan bagian proxy. Lihat dokumentasi OpenAI untuk menjalankan plugin dari jarak jauh.

Langkah 4: Dockerisasi aplikasi Python

Untuk menjalankan aplikasi Python secara otomatis dengan Docker, kami membuat Dockerfile dan mendaftarkannya di file docker-compose.yml. Pelajari cara mendockerisasi aplikasi Python di sini.

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

Akhirnya, file docker-compose.yml kami terlihat seperti ini:

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'

Bagian 3: Mengintegrasikan ChatGPT dengan plugin kustom

Langkah 1: Menerapkan plugin kustom

Setelah Anda menyelesaikan pengembangan plugin kustom Anda, saatnya untuk menerapkan dan menjalankannya secara lokal. Untuk memulai proyek, jalankan perintah berikut dari direktori root proyek:

docker compose up

Saat Anda memulai proyek, Docker akan mengunduh gambar yang diperlukan untuk dijalankan. Anda dapat melihat bahwa layanan APISIX, etcd, dan aplikasi Python (chatgpt-config) sedang berjalan.

Langkah 2: Menghubungkan plugin kustom ke antarmuka ChatGPT

Jadi, Anda telah menerapkan plugin ChatGPT, file konfigurasi plugin dapat diakses melalui API dan sekarang Anda siap untuk mengujinya. Jika Anda memiliki akun Plus, kami harus terlebih dahulu mengaktifkan plugin di GPT-4 karena secara default dinonaktifkan. Kami perlu pergi ke pengaturan dan mengklik opsi beta dan klik "Enable plugins". Kemudian klik bilah pop-up plugin di bagian atas ChatGPT, navigasikan ke "Plugin Store" dan pilih "Develop your own plugin". Berikan URL lokal untuk plugin (localhost:5000).

Setelah Anda mengklik "Find a manifest file", jika semuanya diatur dengan benar, Anda akan melihat ChatGPT memvalidasi file manifes dan spesifikasi OpenAPI dengan sukses.

Langkah 3: Menguji plugin kustom

Sekarang plugin terhubung ke antarmuka ChatGPT, kita dapat menulis perintah sederhana:

Karena kami tidak memiliki route di APISIX, kami dapat membuat yang baru. Di sini tergantung pada bahasa yang digunakan dalam prompt kami, ChatGPT akan memilih untuk memanggil endpoint APISIX yang sesuai. Silakan coba menulis perintah dengan detail yang lebih spesifik sehingga ChatGPT dapat membuat Route dengan benar.

Sekarang route telah dibuat, Anda dapat mengakses endpoint Gateway untuk mengambil detail sesi Conference: http://localhost:9080/speaker/1/sessions. Anda juga dapat mengganti Conference API ini dengan API backend Anda sendiri.

Kasus penggunaan lain untuk plugin kustom API Gateway

Sekarang Anda mungkin bertanya: Apa lagi yang bisa Anda lakukan dengan plugin ini selain sekadar merutekan permintaan? Ada banyak hal yang dapat Anda tingkatkan pada plugin ini atau menambahkan fitur tambahan yang ditawarkan APISIX melalui Admin API. Karena kami menempatkan API Gateway di depan Conference API dan API Gateway melayani semua permintaan yang datang dari plugin terlebih dahulu, Anda dapat mencapai setidaknya hal-hal berikut:

• Keamanan: Asumsikan bahwa sekarang Anda ingin mengamankan Conference API, tanpa API Gateway di tempat, Anda masih dapat mengamankan pertukaran data antara antarmuka ChatGPT dan plugin dengan menggunakan metode Plugin Authentication dari OpenAI. Namun, komunikasi antara plugin dan layanan backend Anda tetap tidak aman sampai Anda menerapkan beberapa kekhawatiran lintas dalam kode Python, alih-alih menghabiskan waktu untuk ini:
  • Kami dapat menerapkan langkah-langkah keamanan seperti autentikasi, otorisasi, dan pembatasan kecepatan dengan API Gateway untuk melindungi Conference API dari akses yang tidak sah dan potensi serangan. ChatGPT dapat berbicara dengan API Gateway secara bebas tetapi komunikasi antara API Gateway dan layanan backend dapat benar-benar aman.
• Caching: Dimungkinkan untuk menyimpan respons API Conference yang serupa sehingga kami dapat menampilkan data untuk ChatGPT dengan cepat.
• Versioning: Kami dapat membuat versi kedua dari Conference API untuk merutekan permintaan plugin ChatGPT ke layanan terbaru tanpa mengubah konfigurasi apa pun dan tanpa downtime.
• Load Balancing: Kami dapat mendistribusikan permintaan masuk ke beberapa instance Conference API, memastikan ketersediaan tinggi dan pemanfaatan sumber daya yang efisien.
• Transformasi Permintaan: Kami dapat memodifikasi permintaan yang dibuat ke Conference API, memungkinkan transformasi data, validasi, atau mengubah permintaan dari REST ke GraphQL atau ke panggilan layanan gRPC.
• Pemantauan dan Analitik: API Gateway menyediakan plugin pemantauan dan analitik yang kuat, memungkinkan Anda mengumpulkan wawasan berharga tentang penggunaan API, kinerja, dan masalah potensial.

Jika Anda ingin menggunakan Apache APISIX API Gateway sebagai pintu depan untuk komunikasi antara plugin kustom ChatGPT dan API backend, Anda dapat memeriksa repositori ini API Gateway antara plugin kustom ChatGPT dan API backend

Langkah selanjutnya

Sepanjang postingan ini, Anda telah belajar cara membuat plugin kustom untuk API Gateway dengan fungsionalitas dasar. Sekarang Anda dapat mengambil proyek sampel sebagai dasar dan meningkatkan fungsionalitas dengan menambahkan lebih banyak spesifikasi Admin API APISIX ke file openapi.yaml untuk menggunakan dan menguji plugin lainnya dan menambahkan konsumen API dan banyak lagi. Jangan ragu untuk berkontribusi pada proyek GitHub dengan mengajukan pull request.

Sumber daya terkait

• API Gateway Untuk Plugin ChatGPT