How To Create A ChatGPT Plugin 

Do you want to explore the potential of ChatGPT plugins? It helps you to enhance its capabilities and address limitations. There are lots of Plugins, like the WolframAlpha plugin for math problem-solving, that can overcome ChatGPT’s shortcomings. 

Another solution is the ChatGPT retrieval plugin, which connects to a vector database for improved context usage and acts as long-term memory. Anyone can contribute to enhancing ChatGPT use cases without retraining the model by creating plugins. 

If you find ChatGPT struggles with specific topics, you can create a plugin to improve its performance. In this guide, You’ll learn how to create a ChatGPT Plugin using the simple steps. 

Meanwhile, you can also check out the best ChatGPT plugins for searching the web or the best ChatGPT extensions for Chrome.


The Procedure To Create A ChatGPT Plugin

To make your own ChatGPT plugin, follow these steps we used for the Weaviate Retrieval Plugin. This plugin links ChatGPT to Weaviate, helping it find and store information. 

We’ll guide you through each step with code snippets and share our challenges. Our technology stacks include:

  • We use the Python language exclusively for development.
  • FastAPI is used as the core server to execute the plugin.
  • Pytest was used to write and execute our test suite.
  • Docker facilitated the creation of containers for building, testing, and deploying the plugin.

That’s it; Hope you understand the tech stack for creating a plugin. Let’s go to the main steps to create a ChatGPT Plugin. 


Here Are The Steps To Create A ChatGPT Plugin

Here’s a simplified breakdown of creating a ChatGPT Plugin:

  1. Build a web application with your preferred endpoint.
  2. Develop The OpenAI Specific Functionality.
  3. Deploy the plugin remotely using

If you already understand this, you can skip steps based on your comfort level with the process. So, without any further delay, let’s get started with our procedure: 


Procedure 1: Building a Web Application

Step 1: Development Environment Setup

For our development environment, we used Dev Containers, updating the devcontainer.json file to include, Docker, and Poetry. Additional dev container templates can be found at


Step 2: Testing the Setup

After the environment setup, we tested by creating a dummy endpoint in FastAPI, ensuring the Weaviate instance was running, and validating the FastAPI endpoint. 

A Makefile automates tasks, and a local server-run command checks network connectivity. Visit [localhost:8000/docs](http://localhost:8000/docs) for the Swagger UI.


Step 3: Implementing Vector Embeddings Function

To link a vector database to ChatGPT, we implemented a function to generate vector embeddings. The chosen function utilizes the ada-002 model from OpenAI, which is suitable for template retrieval.


import openai

def get_embedding(text):


    Get the embedding for a given text.


    results = openai.Embedding.create(input=text, model=”text-embedding-ada-002″)

    return results[“data”][0][“embedding”]



Step 4: Initializing Weaviate Client and Database

Functions were created to initialize the Weaviate Python client and set up the Weaviate instance with a predefined schema if it doesn’t exist.


import weaviate

import os

import logging

INDEX_NAME = “Document”


    “class”: INDEX_NAME,

    “properties”: [

        {“name”: “text”, “dataType”: [“text”]},

        {“name”: “document_id”, “dataType”: [“string”]},



def get_client():


    Get a client to the Weaviate server


    host = os.environ.get(“WEAVIATE_HOST”, “http://localhost:8080”)

    return weaviate.Client(host)

def init_db():


    Create the schema for the database if it doesn’t exist yet


    client = get_client()

    if not client.schema.contains(SCHEMA):

        logging.debug(“Creating schema”)



        class_name = SCHEMA[“class”]

        logging.debug(f”Schema for {class_name} already exists”)

        logging.debug(“Skipping schema creation”)



Step 5: Initializing Database on Server Start

We integrated the database initialization functions into the FastAPI server using FastAPI’s lifespan feature in the main server Python script.


from fastapi import FastAPI

from contextlib import asyncontextmanager

from .database import get_client, init_db


async def lifespan(app: FastAPI):



app = FastAPI(lifespan=lifespan)

def get_weaviate_client():


    Get a client to the Weaviate server


    yield get_client()


With these steps completed, the initial server setup and testing are finished, paving the way for implementing endpoints for ChatGPT interaction with our plugin.


Procedure 2: Develop The OpenAI Specific Functionality

Developing OpenAI-specific functionality for the Weaviate Retrieval Plugin involved three main steps.


Step 1: Development of Weaviate Retrieval Plugin Endpoints

The plugin introduced three specific endpoints: /upsert, /query, and /delete. These endpoints allowed ChatGPT to interact with a Weaviate instance, enabling the addition, querying, and deletion of objects. 

Test-driven development was employed, and the implementation for the /upsert endpoint is illustrated with a corresponding test. 

The endpoint, for example, successfully upserts documents into Weaviate, which ensures the correct status code, content, ID, and vectors.


Step 2: Prepare Plugin Manifest Files

This step involved creating two critical files in the well-known directory: ai-plugin.json and openapi.yaml. The ai-plugin.json file provided information such as the app’s name, description, authentication details, and API details. 

The openapi.yaml file specified the exposed endpoints and their descriptions for ChatGPT to understand and utilize them correctly.


Step 3: Local Deployment and Testing

To locally deploy the plugin, FastAPI’s CORSMiddleware was used to enable cross-requests from http://localhost:8000 and 

Local testing allowed developers to ensure correct functionality through the ChatGPT UI, testing endpoints like /upsert and /query.

The primary takeaway emphasized the importance of well-documented descriptions in docstrings, plugins, and endpoint descriptions. These descriptions were crucial for ChatGPT to interpret and utilize the endpoints effectively. Insufficient or unclear descriptions could lead to incorrect usage by ChatGPT, prompting it to retry.

Throughout the process, careful attention was given to creating manifest files, understanding that ChatGPT relied on these files to determine when to use endpoints and how to use them correctly.

That’s it. The development and deployment process involved thorough testing, documentation, and attention to detail to ensure seamless integration of the Weaviate Retrieval Plugin with ChatGPT.


Procedure 3: Deploy the plugin remotely using

In the final stage of deploying your plugin remotely to for ChatGPT, there are two key steps to follow.


Step 1: Prepare for Remote Deployment

  1. Create a Remote Weaviate Instance: Set up a Weaviate instance on Weaviate Cloud Services (WCS). This will serve as the remote environment for your plugin.
  2. Add a Dockerfile: Modify the OpenAI-provided Dockerfile template to suit your remote environment. This file helps set up your environment on and launch the server.
  3. Update Plugin Manifest Files: Adjust the ai-plugin.json and openapi.yaml files to use authentication through a bearer token. Replace the localhost configuration with your WCS instance details.
  4. Update App for Authentication: Ensure all communication within your app is authenticated. This is a crucial step for secure remote deployment.


Step 2: Deploy to and Install in ChatGPT

  1. Follow Detailed Deployment Instructions: Execute the steps provided in the detailed instructions to deploy your plugin to These instructions guide you through the process seamlessly.
  1. Install in ChatGPT: After successful deployment, open ChatGPT in your browser. If you have alpha access to the plugin, you can install it by specifying the hosted URL and providing the bearer token for authentication.

That’s it. This process involves transitioning from local testing to a remote environment. You establish a Weaviate instance in the cloud, adjust configuration files for secure communication, and then follow deployment instructions. 

The final step is integrating your plugin into ChatGPT by specifying the hosted URL and authenticating it with the provided bearer token. This ensures a smooth and secure deployment for users with alpha access to your plugin.


Frequently Asked Questions

Are ChatGPT plugins free?

No, you need to pay a subscription fee to use ChatGPT plugins. Many plugins made by third-party developers charge users for using them.

Can I sell the ChatGPT plugins?

Yes, you’re allowed to sell ChatGPT plugins.

How do I market my plugin?

To market your plugin well, focus on online platforms. You can use social media for ads, engage with potential users in forums, create helpful video tutorials, and collaborate with influencers.

What is the code interpreter plugin for ChatGPT?

The Code Interpreter for ChatGPT is a new feature in OpenAI’s GPT-4. It combines powerful language skills with programming abilities.

Do plugin developers make money?

Yes, they can make money by selling plugins, earning a commission from sales, or getting payments based on usage. The details depend on their arrangements with platforms and users.

Leave a Comment