Comment créer un plugin pour ChatGPT, le guide complet

Introduction

Développez votre premier plugin pour votre application et ChatGPT. Les plugins OpenAI permettent de connecter ChatGPT à des applications tierces. Ces plugins permettent à ChatGPT d'interagir avec les API définies par les développeurs, augmentant ainsi les capacités de ChatGPT et lui permettant d'effectuer un large éventail d'actions.

Les plugins peuvent permettre à ChatGPT de faire des choses comme :

• Récupérer des informations en temps réel (par exemple, scores sportifs, cours des actions, dernières nouvelles, etc.)
• Récupérer des informations de base (par exemple, documents d'entreprise, notes personnelles, etc.)
• Effectuer des actions au nom de l'utilisateur (par exemple, réserver un vol, commander de la nourriture, etc.)

Les plugins sont en alpha limité et peuvent ne pas encore être accessibles. Rejoignez la liste d'attente pour obtenir un accès. Pendant cette phase alpha, nous travaillerons en étroite collaboration avec les utilisateurs et les développeurs pour faire évoluer le système de plugins, qui pourrait évoluer de manière significative.

Si vous souhaitez avoir un exemple en exécution pendant que vous lisez la documentation et apprenez-en davantage sur les plugins, vous pouvez commencer par le répertoire quickstart.

Les développeurs de plugins exposent une ou plusieurs API endpoints, accompagnées d'un fichier manifeste standard et d'une spécification OpenAPI. Ces éléments définissent la fonctionnalité du plugin, permettant à ChatGPT de consommer les fichiers et d'appeler les API définies par les développeurs.

Le modèle d'IA agit comme un appelant d'API intelligent. Étant donné une spécification d'API et une description en langage naturel de l'utilisation de l'API, le modèle appelle de manière proactive l'API pour effectuer des actions. Par exemple, si un utilisateur demande "Où dois-je séjourner à Paris pour quelques nuits ?", le modèle peut choisir d'appeler l'API d'un plugin de réservation d'hôtel, recevoir la réponse de l'API et générer une réponse pour l'utilisateur en combinant les données de l'API et ses capacités de langage naturel.

Avec le temps, nous prévoyons que le système évoluera pour répondre à des cas d'utilisation plus avancés.

Processus des plugins

Pour construire un plugin, il est important de comprendre le processus de bout en bout.

1. Créez un fichier manifeste

Créez un fichier manifeste et hébergez-le à yourdomain.com/.well-known/ai-plugin.json. Le fichier comprend des métadonnées sur votre plugin (nom, logo, etc.), des détails sur l'authentification requise (type d'auth, URL OAuth, etc.) et une spécification OpenAPI pour les points de terminaison que vous souhaitez exposer.

Lors de la création du fichier, assurez-vous de :

• Utiliser les champs de description OpenAPI pour fournir une description en langage naturel des différents champs.
• Exposer seulement 1 à 2 endpoints au début avec un nombre minimum de paramètres pour minimiser la longueur du texte.

2. Enregistrez votre plugin dans l'interface utilisateur de ChatGPT

Sélectionnez le modèle de plugin dans le menu déroulant en haut, puis cliquez sur "Plugins", "Plugin Store" et enfin "Installer un plugin non vérifié" ou "Développer votre propre plugin". Si l'authentification est nécessaire, fournissez un client_id et un client_secret OAuth 2 ou une clé API.

3. Les utilisateurs activent votre plugin

Les utilisateurs doivent activer manuellement votre plugin dans l'interface utilisateur de ChatGPT (ChatGPT n'utilisera pas votre plugin par défaut). Pendant l'alpha, les développeurs de plugins pourront partager leur plugin avec 15 utilisateurs supplémentaires (seuls les autres développeurs peuvent installer des plugins non vérifiés actuellement). Au fil du temps, nous déploierons un moyen de soumettre votre plugin pour examen afin de l'exposer à l'ensemble de la base d'utilisateurs de ChatGPT.

Si une authentification est requise, les utilisateurs seront redirigés via OAuth vers votre plugin ; vous pouvez également créer de nouveaux comptes à ce stade si nécessaire.

À l'avenir, nous espérons développer des fonctionnalités pour aider les utilisateurs à découvrir des plugins utiles et populaires.

4. Les utilisateurs commencent une conversation

OpenAI injectera une description compacte de votre plugin dans un message à ChatGPT, invisible pour les utilisateurs finaux. Cela inclura la description du plugin, les points de terminaison et des exemples.

Lorsqu'un utilisateur pose une question pertinente, le modèle peut choisir d'invoquer un appel API de votre plugin s'il semble pertinent. Pour les demandes POST, il est nécessaire que les développeurs construisent un flux de confirmation utilisateur.

Le modèle intégrera les résultats de l'API dans sa réponse à l'utilisateur. Le modèle peut inclure des liens renvoyés par les appels API dans sa réponse. Ceux-ci seront affichés sous forme d'aperçus enrichis en utilisant le protocole OpenGraph (où nous récupérons les champs site_name, title, description, image, et url).

Actuellement, nous enverrons le pays et l'état de l'utilisateur dans l'en-tête de conversation du plugin (si vous êtes en Bretagne, par exemple, cela ressemblerait à {"openai-subdivision-1-iso-code": "FR-BRE"}). Pour obtenir des sources de données supplémentaires, les utilisateurs devront accepter via un écran de consentement. Ceci est utile pour le shopping, les restaurants, la météo, et bien plus encore. Pour en apprendre plus, consultez la page Wikipedia ISO 3166.

Démarrage

Créer un plugin prend 3 étapes :

1. Construire une API
2. Documenter l'API au format OpenAPI yaml ou JSON
3. Créer un fichier manifeste JSON qui définira les métadonnées pertinentes pour le plugin

Le reste de cette section portera sur la création d'un plugin de liste de tâches (todo list) en définissant la spécification OpenAPI ainsi que le fichier manifeste.

Manifeste du plugin

Chaque plugin nécessite un fichier ai-plugin.json, qui doit être hébergé sur le domaine de l'API. Par exemple, une entreprise appelée example.com rendrait le fichier JSON du plugin accessible via un domaine https://example.com puisque c'est là que leur API est hébergée. Lorsque vous installez le plugin via l'interface de ChatGPT, en interne, nous recherchons un fichier situé à /.well-known/ai-plugin.json. Le dossier /.well-known est obligatoire et doit exister sur votre domaine pour que ChatGPT puisse se connecter à votre plugin. Si aucun fichier n'est trouvé, le plugin ne peut pas être installé. Pour le développement local, vous pouvez utiliser HTTP mais si vous pointez vers un serveur distant, HTTPS est requis.

Voici l'apparence minimale du fichier ai-plugin.json requis :

{
    "schema_version": "v1",
    "name_for_human": "TODO Plugin",
    "name_for_model": "todo",
    "description_for_human": "Plugin pour gérer une liste de tâches. Vous pouvez ajouter, supprimer et consulter vos TODOS.",
    "description_for_model": "Plugin pour gérer une liste de tâches. Vous pouvez ajouter, supprimer et consulter vos TODOS.",
    "auth": {
        "type": "none"
    },
    "api": {
        "type": "openapi",
        "url": "http://localhost:3333/openapi.yaml",
        "is_user_authenticated": false
    },
    "logo_url": "http://localhost:3333/logo.png",
    "contact_email": "support@example.com",
    "legal_info_url": "http://www.example.com/legal"
}

Si vous voulez voir toutes les options possibles pour le fichier de plugin, vous pouvez vous référer à la définition ci-dessous.

Voici des exemples avec différentes méthodes d'authentification :

// App-level API keys
type ManifestServiceHttpAuth  = BaseManifestAuth & {
  type: 'service_http';
  authorization_type: HttpAuthorizationType;
  verification_tokens: {
    [service: string]?: string;
  };
}

// User-level HTTP authentication
type ManifestUserHttpAuth  = BaseManifestAuth & {
  type: 'user_http';
  authorization_type: HttpAuthorizationType;
}

type ManifestOAuthAuth  = BaseManifestAuth & {
  type: 'oauth';

  // OAuth URL où l'utilisateur est dirigé pour que le flux d'authentification OAuth commence.
  client_url: string;

  // Les scopes OAuth nécessaires pour effectuer des opérations au nom de l'utilisateur.
  scope: string;

  // Endpoint utilisé pour échanger le code OAuth avec le token d'accès.
  authorization_url: string;

  // Lors de l'échange du code OAuth avec le token d'accès, l'en-tête 'content-type' attendu. Par exemple : 'content-type: application/json'
  authorization_content_type: string;

  // Lors de l'inscription de l'ID client OAuth et des secrets, le service de plugin affichera un jeton unique.
  verification_tokens: {
    [service: string]?: string;
  };
}

Il y a aussi des limites à la longueur de certains champs dans le fichier manifeste qui sont susceptibles de changer avec le temps :

• 50 caractères maximum pour name_for_human
• 50 caractères maximum pour name_for_model
• 120 caractères maximum pour description_for_human
• 8000 caractères maximum pour description_for_model (diminuera avec le temps)

De plus, nous avons une limite de 100 000 caractères (diminuera avec le temps) pour la longueur du corps de la réponse de l'API qui est également susceptible de changer.

Définition OpenAPI

La prochaine étape consiste à créer la spécification OpenAPI pour documenter l'API. Le modèle de ChatGPT ne sait rien de votre API en dehors de ce qui est défini dans la spécification OpenAPI et le fichier manifeste. Cela signifie que si vous avez une API étendue, vous n'avez pas besoin d'exposer toutes les fonctionnalités au modèle et pouvez choisir des points de terminaison spécifiques.

La spécification OpenAPI est l'enveloppe qui se situe au-dessus de votre API. Une spécification OpenAPI de base ressemblera à ceci :

openapi: 3.0.1
info:
  title: TODO Plugin
  description: Un plugin qui permet à l'utilisateur de créer et gérer une liste de tâches (TODO) à l'aide de ChatGPT.
  version: 'v1'
servers:
  - url: http://localhost:3333
paths:
  /todos:
    get:
      operationId: getTodos
      summary: Obtenir la liste des tâches
      responses:
        "200":
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/getTodosResponse'
components:
  schemas:
    getTodosResponse:
      type: object
      properties:
        todos:
          type: array
          items:
            type: string
          description: La liste des tâches.

Nous commençons par définir la version, le titre, la description et le numéro de version de la spécification. Lorsqu'une requête est exécutée dans ChatGPT, il examinera la description définie dans la section info pour déterminer si le plugin est pertinent pour la requête de l'utilisateur.

Gardez à l'esprit les limites suivantes dans votre spécification OpenAPI, qui sont sujettes à changement:

• 200 caractères maximum pour chaque champ de description / résumé de l'API dans la spécification de l'API
• 200 caractères maximum pour chaque champ de description de paramètre d'API dans la spécification de l'API

Exécution d'un plugin

Une fois que vous avez créé une API, un fichier manifeste et une spécification OpenAPI pour votre API, vous êtes maintenant prêt à connecter le plugin via l'interface utilisateur de ChatGPT. Il y a deux endroits différents où votre plugin peut fonctionner : localement dans un environnement de développement ou sur un serveur distant.

Pour connecter le plugin avec ChatGPT, naviguez vers le magasin de plugins et sélectionnez "Develop your own plugin". Entrez votre adresse localhost et le numéro de port (par exemple, localhost:3333). Notez que seul le type d'authentification "none" est actuellement pris en charge pour le développement localhost.

Débogage

Par défaut, le chat n'affiche pas les appels de plugin et autres informations qui ne sont pas affichés à l'utilisateur. Pour obtenir une image plus complète de la manière dont le modèle interagit avec votre plugin, vous pouvez voir la demande et la réponse en cliquant sur la flèche vers le bas sur le nom du plugin après avoir interagi avec le plugin.

Un appel de modèle au plugin consistera généralement en un message du modèle contenant des paramètres de type JSON qui sont envoyés au plugin, suivi d'une réponse du plugin, et enfin un message du modèle utilisant les informations renvoyées par le plugin.

Si vous développez un plugin localhost, vous pouvez également ouvrir la console de développement en allant dans "Paramètres" et en basculant "Open plugin devtools". De là, vous pouvez voir des journaux plus verbeux et "refresh plugin" qui récupère à nouveau le Plugin et la spécification OpenAPI.

Bonnes pratiques

Voici quelques bonnes pratiques à suivre lors de la rédaction de votre description_for_model et des descriptions dans votre spécification OpenAPI, ainsi que lors de la conception de vos réponses d'API :

• Vos descriptions ne doivent pas tenter de contrôler l'humeur, la personnalité ou les réponses exactes de ChatGPT. ChatGPT est conçu pour écrire des réponses appropriées aux plugins.
• Vos descriptions ne doivent pas encourager ChatGPT à utiliser le plugin lorsque l'utilisateur n'a pas demandé la catégorie de service particulière de votre plugin.
• Vos descriptions ne doivent pas prescrire de déclencheurs spécifiques pour que ChatGPT utilise le plugin. ChatGPT est conçu pour utiliser votre plugin automatiquement lorsque cela est approprié.
• Les réponses de l'API du plugin doivent retourner des données brutes plutôt que des réponses en langage naturel, sauf si cela est nécessaire. ChatGPT fournira sa propre réponse en langage naturel à l'aide des données renvoyées.

Cela vous fournira un aperçu complet du processus de création, de connexion et de débogage des plugins dans ChatGPT.

Authentification du plugin

1. Aucune authentification

OpenAI prend en charge le flux sans authentification pour les applications qui n'ont pas besoin d'authentification. Cela signifie qu'un utilisateur peut envoyer des requêtes directement à votre API sans restrictions. Ce flux est particulièrement utile si vous avez une API ouverte accessible à tous.

Exemple :

"auth": {
  "type": "none"
}

2. Niveau service

Vous pouvez spécifier un secret client pendant l'installation du plugin pour permettre aux plugins OpenAI de travailler avec votre API. Dans ce cas, tout le trafic provenant des plugins OpenAI sera authentifié, mais pas au niveau de l'utilisateur.

Exemple :

"auth": {
  "type": "service_http",
  "authorization_type": "bearer",
  "verification_tokens": {
    "openai": "Replace_this_string_with_the_verification_token_generated_in_the_ChatGPT_UI"
  }
}

Ajoutez simplement les applications supplémentaires que vous souhaitez que votre plugin prenne en charge :

"verification_tokens": {
    "openai": "Replace_this_string_with_the_verification_token_generated_in_the_ChatGPT_UI",
    "other_service": "abc123"
}

3. Niveau utilisateur

Ce niveau d'authentification permet aux utilisateurs finaux de copier et coller leur clé API secrète dans le ChatGPT UI lors de l'installation du plugin.

Exemple :

"auth": {
  "type": "user_http",
  "authorization_type": "bearer"
}

4. OAuth

Le protocole de plugin est compatible avec OAuth. Voici un exemple de flux OAuth que nous attendons dans le fichier manifeste :

Exemple :

"auth": {
  "type": "oauth",
  "client_url": "https://my_server.com/authorize",
  "scope": "",
  "authorization_url": "https://my_server.com/token",
  "authorization_content_type": "application/json",
  "verification_tokens": {
    "openai": "Replace_this_string_with_the_verification_token_generated_in_the_ChatGPT_UI"
  }
}

Voici une brève description des champs OAuth :

• client_url : L'URL où ChatGPT redirigera le navigateur de l'utilisateur
• scope : Les scopes d'autorisation demandées
• authorization_url : L'URL utilisée par ChatGPT pour récupérer le jeton d'accès OAuth de l'utilisateur
• authorization_content_type : Le type de contenu utilisé pour les requêtes POST vers l'URL d'autorisation

Exemple de plugins

De notre simple plugin de liste de tâches sans authentification à un plugin de récupération plus puissant, ces exemples offrent un aperçu de ce qu'il est possible de faire grâce aux plugins.

Pendant le développement, vous pouvez exécuter le plugin localement sur votre ordinateur ou via un environnement de développement cloud comme GitHub Codespaces, Replit ou CodeSandbox.

Plugins quickstart

OpenAI a créé le répertoire plugins-quickstart pour aider les développeurs à mettre en place et exécuter un plugin en moins de 5 minutes. Si vous n'avez pas encore exécuté de plugin et que vous souhaitez vous familiariser avec les étapes minimales requises pour en exécuter un, pensez à commencer par le repo du démarrage rapide des plugins.

GitHub - openai/plugins-quickstart: Get a ChatGPT plugin up and running in under 5 minutes!

Get a ChatGPT plugin up and running in under 5 minutes! - GitHub - openai/plugins-quickstart: Get a ChatGPT plugin up and running in under 5 minutes!

GitHubopenai

Apprendre à créer un simple plugin de liste de tâches sans authentification

Pour commencer, consultez la section sans authentification, puis définissez un fichier ai-plugin.json avec les champs suivants:

{
    "schema_version": "v1",
    "name_for_human": "TODO Plugin (no auth)",
    "name_for_model": "todo",
    "description_for_human": "Plugin for managing a TODO list, you can add, remove and view your TODOs.",
    "description_for_model": "Plugin for managing a TODO list, you can add, remove and view your TODOs.",
    "auth": {
        "type": "none"
    },
    "api": {
        "type": "openapi",
        "url": "PLUGIN_HOSTNAME/openapi.yaml",
        "is_user_authenticated": false
    },
    "logo_url": "PLUGIN_HOSTNAME/logo.png",
    "contact_email": "support@example.com",
    "legal_info_url": "https://example.com/legal"
}

Notez que PLUGIN_HOSTNAME doit être le nom d'hôte réel de votre serveur de plugin.

Ensuite, nous pouvons définir les points de terminaison de l'API pour créer, supprimer et récupérer les éléments de la liste de tâches pour un utilisateur spécifique.

import json

import quart
import quart_cors
from quart import request

app = quart_cors.cors(quart.Quart(__name__), allow_origin="https://chat.openai.com")

_TODOS = {}

@app.post("/todos/<string:username>")
async def add_todo(username):
    request = await quart.request.get_json(force=True)
    if username not in _TODOS:
        _TODOS[username] = []
    _TODOS[username].append(request["todo"])
    return quart.Response(response='OK', status=200)

@app.get("/todos/<string:username>")
async def get_todos(username):
    return quart.Response(response=json.dumps(_TODOS.get(username, [])), status=200)

@app.delete("/todos/<string:username>")
async def delete_todo(username):
    request = await quart.request.get_json(force=True)
    todo_idx = request["todo_idx"]
    if 0 <= todo_idx < len(_TODOS[username]):
        _TODOS[username].pop(todo_idx)
    return quart.Response(response='OK', status=200)

@app.get("/logo.png")
async def plugin_logo():
    filename = 'logo.png'
    return await quart.send_file(filename, mimetype='image/png')

@app.get("/.well-known/ai-plugin.json")
async def plugin_manifest():
    host = request.headers['Host']
    with open("ai-plugin.json") as f:
        text = f.read()
        text = text.replace("PLUGIN_HOSTNAME", f"https://{host}")
        return quart.Response(text, mimetype="text/json")

@app.get("/openapi.yaml")
async def openapi_spec():
    host = request.headers['Host']
    with open("openapi.yaml") as f:
        text = f.read()
        text = text.replace("PLUGIN_HOSTNAME", f"https://{host}")
        return quart.Response(text, mimetype="text/yaml")

def main():
    app.run(debug=True, host="0.0.0.0", port=5002)

if __name__ == "__main__":
    main()

Enfin, nous devons mettre en place et définir une spécification OpenAPI pour correspondre aux points de terminaison définis sur notre serveur local ou distant. Vous n'avez pas besoin d'exposer l'intégralité des fonctionnalités de votre API via la spécification et pouvez choisir de donner accès à ChatGPT à certaines fonctionnalités seulement.

Il existe également de nombreux outils qui transformeront automatiquement le code de définition de votre serveur en une spécification OpenAPI, ainsi vous n'aurez pas à le faire manuellement. Dans le cas du code Python ci-dessus, la spécification OpenAPI ressemblera à :

openapi: 3.0.1
info:
    title: TODO Plugin
    description: A plugin that allows the user to create and manage a TODO list using ChatGPT. If you do not know the user's username, ask them first before making queries to the plugin. Otherwise, use the username "global".
    version: "v1"
servers:
    - url: PLUGIN_HOSTNAME
paths:
    /todos/{username}:
        get:
            operationId: getTodos
            summary: Get the list of todos
            parameters:
                - in: path
                  name: username
                  schema:
                      type: string
                  required: true
                  description: The name of the user.
            responses:
                "200":
                    description: OK
                    content:
                        application/json:
                            schema:
                                $ref: "#/components/schemas/getTodosResponse"
        post:
            operationId: addTodo
            summary: Add a todo to the list
            parameters:
                - in: path
                  name: username
                  schema:
                      type: string
                  required: true
                  description: The name of the user.
            requestBody:
                required: true
                content:
                    application/json:
                        schema:
                            $ref: "#/components/schemas/addTodoRequest"
            responses:
                "200":
                    description: OK
        delete:
            operationId: deleteTodo
            summary: Delete a todo from the list
            parameters:
                - in: path
                  name: username
                  schema:
                      type: string
                  required: true
                  description: The name of the user.
            requestBody:
                required: true
                content:
                    application/json:
                        schema:
                            $ref: "#/components/schemas/deleteTodoRequest"
            responses:
                "200":
                    description: OK

components:
    schemas:
        getTodosResponse:
            type: object
            properties:
                todos:
                    type: array
                    items:
                        type: string
                    description: The list of todos.
        addTodoRequest:
            type: object
            required:
                - todo
            properties:
                todo:
                    type: string
                    description: The todo to add to the list.
                    required: true
        deleteTodoRequest:
            type: object
            required:
                - todo_idx
            properties:
                todo_idx:
                    type: integer
                    description: The index of the todo to delete.
                    required: true

Cela vous permettra de créer un plugin de liste de tâches simple sans authentification et de vous familiariser avec le processus de développement de plugins. Vous pouvez ensuite explorer d'autres options, notamment l'ajout de fonctionnalités d'authentification et l'intégration de services tiers, pour créer des plugins plus sophistiqués et personnalisés en fonction des besoins de votre utilisateur.

Mise en production

Limite de requêtes

Il est important de mettre en place une limite de requêtes sur les points d'accès API que vous exposez. Bien que l'échelle actuelle soit limitée, ChatGPT est largement utilisé et vous devez vous attendre à un grand volume de requêtes. Vous pouvez surveiller le nombre de requêtes et définir des limites en conséquence.

Délais d'attente

Lors de l'appel aux API dans le cadre du plugin, des délais d'attente se produisent si les seuils suivants sont dépassés :

• 15 secondes aller-retour pour récupérer le fichier ai-plugin.json/openapi.yaml
• 45 secondes aller-retour pour les appels API

En augmentant l'expérience du plugin à un plus grand nombre de personnes, nous nous attendons à ce que les seuils de délai d'attente diminuent.

Mise à jour de votre plugin

Après avoir déployé votre plugin en production, vous voudrez peut-être apporter des modifications au fichier manifeste ai-plugin.json. Actuellement, les fichiers manifestes doivent être mis à jour manuellement en suivant le flux "Développer votre propre plugin" dans la boutique de plugins chaque fois que vous apportez une modification au fichier.

ChatGPT récupérera automatiquement la dernière spécification OpenAPI à chaque fois qu'une demande est faite.

Conditions d'utilisation des plugins

Pour enregistrer un plugin, vous devez accepter les Plugin Terms.

Vérification de domaine et sécurité

Pour garantir que les plugins ne peuvent effectuer des actions que sur les ressources qu'ils contrôlent, OpenAI applique des exigences sur le manifeste du plugin et les spécifications de l'API.

Définition du domaine racine du plugin

Le fichier de manifeste définit des informations présentées à l'utilisateur (tels que le logo et les informations de contact) ainsi qu'une URL où la spécification OpenAPI du plugin est hébergée. Lorsque le manifeste est récupéré, le domaine racine du plugin est établi selon les règles suivantes :

1. Si le domaine a "www." comme sous-domaine, le domaine racine supprimera "www." du domaine qui héberge le manifeste.
2. Sinon, le domaine racine est le même que le domaine qui héberge le manifeste.

Note sur les redirections : Uniquement des redirections de sous-domaines enfants sont autorisées. L'exception est pour une redirection d'un sous-domaine "www" vers un sans "www".

Exemples de domaines racines

✅ https://example.com/.well-known/ai-plugin.json
Domaine racine : example.com

✅ https://www.example.com/.well-known/ai-plugin.json
Domaine racine : example.com

✅ https://www.example.com/.well-known/ai-plugin.json → redirige vers https://example.com/.well-known/ai-plugin.json
Domaine racine : example.com

❌Redirection vers un domaine de niveau parent, un sous-domaine de même niveau ou un autre domaine est interdite.

Validation du manifeste

Certains champs du manifeste doivent satisfaire aux exigences suivantes :

• api.url - L'URL fournie à la spécification OpenAPI doit être hébergée au même niveau ou dans un sous-domaine du domaine racine.
• legal_info - Le domaine de niveau deux de l'URL fournie doit être le même que le domaine de niveau deux du domaine racine.
• contact_info - Le domaine de niveau deux de l'adresse e-mail doit être le même que le domaine de niveau deux du domaine racine.

Résolution de la spécification de l'API

Le champ api.url du manifeste fournit un lien vers une spécification OpenAPI qui définit les API que le plugin peut appeler. OpenAPI permet de spécifier plusieurs URL de base pour les serveurs. La logique suivante est utilisée pour sélectionner l'URL du serveur :

1. Parcourir la liste des URL de serveurs
2. Utiliser la première URL de serveur qui correspond exactement au domaine racine ou à un sous-domaine du domaine racine
3. Si aucun des cas ci-dessus ne s'applique, utiliser par défaut le domaine où la spécification de l'API est hébergée.

Utilisation de TLS et HTTPS

Tout le trafic avec le plugin (par exemple, la récupération du fichier ai-plugin.json, la spécification OpenAPI, les appels API) doit utiliser TLS 1.2 ou ultérieur sur le port 443 avec un certificat public valide.

Plages d'IP de sortie

ChatGPT appellera votre plugin depuis une adresse IP dans le bloc CIDR 23.102.140.112/28. Vous pouvez souhaiter autoriser explicitement ces adresses IP.

Séparément, le plugin de navigation Web d'OpenAI accède aux sites Web depuis un autre bloc d'adresses IP : 23.98.142.176/28.

FAQ

Comment les données du plugin sont-elles utilisées ?

Les plugins connectent ChatGPT à des applications externes. Si un utilisateur active un plugin, ChatGPT peut envoyer des parties de leur conversation et leur pays ou État à votre plugin.

Que se passe-t-il si une demande à mon API échoue ?

Si une demande à l'API échoue, le modèle peut réessayer la demande jusqu'à 10 fois avant d'informer l'utilisateur qu'il ne peut pas obtenir de réponse de ce plugin.

Puis-je inviter des personnes à essayer mon plugin ?

Oui, tous les plugins non vérifiés peuvent être installés par jusqu'à 15 utilisateurs. Au lancement, seuls les autres développeurs ayant accès pourront installer le plugin. Nous prévoyons d'étendre l'accès au fil du temps et mettrons en place un processus de soumission de votre plugin pour examen avant de le rendre disponible à tous les utilisateurs.

Puis-je facturer les gens pour mon plugin ?

Oui, nous vous encourageons à envisager un nombre limité d'appels API gratuits, mais comprenons que cela nécessite des ressources pour exécuter votre plugin.

Processus de revue des plugins

Nous sommes à un stade précoce de développement du magasin de plugins. Cette page donne un aperçu de la manière dont nous envisageons le processus de revue des plugins et ce à quoi ressembleront ses premières phases.

Le processus de revue des plugins évoluera considérablement avec le temps. Nous sommes ouverts aux retours d'expérience concernant l'amélioration du processus pour ceux qui créent des plugins.

Ce qu'OpenAI recherche dans un plugin

L'objectif du processus de révision est de s'assurer que les plugins sur ChatGPT sont sûrs, offrent des fonctionnalités utiles et procurent une expérience utilisateur de grande qualité.

Jusqu'à présent, les catégories de plugins les plus favorisés sont :

• Recherche d'informations spécifiques à l'utilisateur ou difficiles à trouver (recherche sur Slack, recherche dans les documents d'un utilisateur ou dans une base de données propriétaire).
• Plugins qui fonctionnent bien avec d'autres plugins (demander au modèle de planifier un week-end et faire en sorte qu'il utilise des recherches de vols, d'hôtels et de réservations de dîner).
• Plugins dotés de capacités de calcul (Wolfram, OpenAI Code Interpreter, etc).
• Plugins qui introduisent de nouvelles façons d'utiliser ChatGPT, comme les jeux.

États d'un plugin

Lors du développement d'un plugin, celui-ci peut être dans l'un des états suivants, indiquant où il se situe dans le processus de révision. Actuellement, il n'y a que quelques statuts de plugin et le processus de révision est largement manuel. Cela devrait changer à mesure que le système de plugins évolue.

Types d'utilisateurs

Actuellement, nous parlons de trois catégories d'utilisateurs en ce qui concerne l'accès aux plugins. Ceci devrait également évoluer à mesure que le système de plugins évolue.

Soumettre un plugin pour examen

Vous pouvez vous attendre à recevoir une réponse concernant un plugin soumis pour examen 14 jours après la date limite pour le lot concerné.

Vous pouvez consulter les exigences pour soumettre un plugin en utilisant le formulaire de soumission de plugin.

Si votre plugin n'est pas retenu lors de cette phase, nous vous encourageons à recueillir les commentaires des utilisateurs sur ce qui peut être amélioré pour votre plugin.