【開発者向け】これさえ読めばOK！ChatGPTプラグインの作り方

1{
2    "schema_version": "v1",
3    "name_for_human": "TODO Plugin",
4    "name_for_model": "todo",
5    "description_for_human": "Plugin for managing a TODO list. You can add, remove and view your TODOs.",
6    "description_for_model": "Plugin for managing a TODO list. You can add, remove and view your TODOs.",
7    "auth": {
8        "type": "none"
9    },
10    "api": {
11        "type": "openapi",
12        "url": "http://localhost:3333/openapi.yaml",
13        "is_user_authenticated": false
14    },
15    "logo_url": "http://localhost:3333/logo.png",
16    "contact_email": "support@example.com",
17    "legal_info_url": "http://www.example.com/legal"
18}

1openapi: 3.0.1
2info:
3  title: TODO Plugin
4  description: A plugin that allows the user to create and manage a TODO list using ChatGPT.
5  version: 'v1'
6servers:
7  - url: http://localhost:3333
8paths:
9  /todos:
10    get:
11      operationId: getTodos
12      summary: Get the list of todos
13      responses:
14        "200":
15          description: OK
16          content:
17            application/json:
18              schema:
19                $ref: '#/components/schemas/getTodosResponse'
20components:
21  schemas:
22    getTodosResponse:
23      type: object
24      properties:
25        todos:
26          type: array
27          items:
28            type: string
29          description: The list of todos.

1import requests
2import os
3
4import yaml
5from flask import Flask, jsonify, Response, request, send_from_directory
6from flask_cors import CORS
7
8app = Flask(__name__)
9
10PORT = 3333
11
12# Note: Setting CORS to allow chat.openapi.com is required for ChatGPT to access your plugin
13CORS(app, origins=[f"http://localhost:{PORT}", "https://chat.openai.com"])
14
15api_url = 'https://example.com'
16
17
18@app.route('/.well-known/ai-plugin.json')
19def serve_manifest():
20    return send_from_directory(os.path.dirname(__file__), 'ai-plugin.json')
21
22
23@app.route('/openapi.yaml')
24def serve_openapi_yaml():
25    with open(os.path.join(os.path.dirname(__file__), 'openapi.yaml'), 'r') as f:
26        yaml_data = f.read()
27    yaml_data = yaml.load(yaml_data, Loader=yaml.FullLoader)
28    return jsonify(yaml_data)
29
30
31@app.route('/openapi.json')
32def serve_openapi_json():
33    return send_from_directory(os.path.dirname(__file__), 'openapi.json')
34
35
36@app.route('/<path:path>', methods=['GET', 'POST'])
37def wrapper(path):
38
39    headers = {
40    'Content-Type': 'application/json',
41    }
42
43    url = f'{api_url}/{path}'
44    print(f'Forwarding call: {request.method} {path} -> {url}')
45
46    if request.method == 'GET':
47        response = requests.get(url, headers=headers, params=request.args)
48    elif request.method == 'POST':
49        print(request.headers)
50        response = requests.post(url, headers=headers, params=request.args, json=request.json)
51    else:
52        raise NotImplementedError(f'Method {request.method} not implemented in wrapper for {path=}')
53    return response.content
54
55
56if __name__ == '__main__':
57    app.run(port=PORT)

1{
2    "schema_version": "v1",
3    "name_for_human": "Sport Stats",
4    "name_for_model": "sportStats",
5    "description_for_human": "Get current and historical stats for sport players and games.",
6    "description_for_model": "Get current and historical stats for sport players and games. Always display results using markdown tables.",
7    "auth": {
8        "type": "none"
9    },
10    "api": {
11        "type": "openapi",
12        "url": "PLUGIN_HOSTNAME/openapi.yaml",
13        "is_user_authenticated": false
14    },
15    "logo_url": "PLUGIN_HOSTNAME/logo.png",
16    "contact_email": "support@example.com",
17    "legal_info_url": "https://example.com/legal"
18}

1import json
2import requests
3import urllib.parse
4
5import quart
6import quart_cors
7from quart import request
8
9# Note: Setting CORS to allow chat.openapi.com is only required when running a localhost plugin
10app = quart_cors.cors(quart.Quart(__name__), allow_origin="https://chat.openai.com")
11HOST_URL = "https://example.com"
12
13@app.get("/players")
14async def get_players():
15    query = request.args.get("query")
16    res = requests.get(
17        f"{HOST_URL}/api/v1/players?search={query}&page=0&per_page=100")
18    body = res.json()
19    return quart.Response(response=json.dumps(body), status=200)
20
21
22@app.get("/teams")
23async def get_teams():
24    res = requests.get(
25        "{HOST_URL}/api/v1/teams?page=0&per_page=100")
26    body = res.json()
27    return quart.Response(response=json.dumps(body), status=200)
28
29
30@app.get("/games")
31async def get_games():
32    query_params = [("page", "0")]
33    limit = request.args.get("limit")
34    query_params.append(("per_page", limit or "100"))
35    start_date = request.args.get("start_date")
36    if start_date:
37        query_params.append(("start_date", start_date))
38    end_date = request.args.get("end_date")
39
40    if end_date:
41        query_params.append(("end_date", end_date))
42    seasons = request.args.getlist("seasons")
43
44    for season in seasons:
45        query_params.append(("seasons[]", str(season)))
46    team_ids = request.args.getlist("team_ids")
47
48    for team_id in team_ids:
49        query_params.append(("team_ids[]", str(team_id)))
50
51    res = requests.get(
52        f"{HOST_URL}/api/v1/games?{urllib.parse.urlencode(query_params)}")
53    body = res.json()
54    return quart.Response(response=json.dumps(body), status=200)
55
56
57@app.get("/stats")
58async def get_stats():
59    query_params = [("page", "0")]
60    limit = request.args.get("limit")
61    query_params.append(("per_page", limit or "100"))
62    start_date = request.args.get("start_date")
63    if start_date:
64        query_params.append(("start_date", start_date))
65    end_date = request.args.get("end_date")
66
67    if end_date:
68        query_params.append(("end_date", end_date))
69    player_ids = request.args.getlist("player_ids")
70
71    for player_id in player_ids:
72        query_params.append(("player_ids[]", str(player_id)))
73    game_ids = request.args.getlist("game_ids")
74
75    for game_id in game_ids:
76        query_params.append(("game_ids[]", str(game_id)))
77    res = requests.get(
78        f"{HOST_URL}/api/v1/stats?{urllib.parse.urlencode(query_params)}")
79    body = res.json()
80    return quart.Response(response=json.dumps(body), status=200)
81
82
83@app.get("/season_averages")
84async def get_season_averages():
85    query_params = []
86    season = request.args.get("season")
87    if season:
88        query_params.append(("season", str(season)))
89    player_ids = request.args.getlist("player_ids")
90
91    for player_id in player_ids:
92        query_params.append(("player_ids[]", str(player_id)))
93    res = requests.get(
94        f"{HOST_URL}/api/v1/season_averages?{urllib.parse.urlencode(query_params)}")
95    body = res.json()
96    return quart.Response(response=json.dumps(body), status=200)
97
98
99@app.get("/logo.png")
100async def plugin_logo():
101    filename = 'logo.png'
102    return await quart.send_file(filename, mimetype='image/png')
103
104
105@app.get("/.well-known/ai-plugin.json")
106async def plugin_manifest():
107    host = request.headers['Host']
108    with open("ai-plugin.json") as f:
109        text = f.read()
110        # This is a trick we do to populate the PLUGIN_HOSTNAME constant in the manifest
111        text = text.replace("PLUGIN_HOSTNAME", f"https://{host}")
112        return quart.Response(text, mimetype="text/json")
113
114
115@app.get("/openapi.yaml")
116async def openapi_spec():
117    host = request.headers['Host']
118    with open("openapi.yaml") as f:
119        text = f.read()
120        # This is a trick we do to populate the PLUGIN_HOSTNAME constant in the OpenAPI spec
121        text = text.replace("PLUGIN_HOSTNAME", f"https://{host}")
122        return quart.Response(text, mimetype="text/yaml")
123
124
125def main():
126    app.run(debug=True, host="0.0.0.0", port=5001)
127
128
129if __name__ == "__main__":
130    main()

1openapi: 3.0.1
2info:
3    title: Sport Stats
4    description: Get current and historical stats for sport players and games.
5    version: "v1"
6servers:
7    - url: PLUGIN_HOSTNAME
8paths:
9    /players:
10        get:
11            operationId: getPlayers
12            summary: Retrieves all players from all seasons whose names match the query string.
13            parameters:
14                - in: query
15                  name: query
16                  schema:
17                      type: string
18                  description: Used to filter players based on their name. For example, ?query=davis will return players that have 'davis' in their first or last name.
19            responses:
20                "200":
21                    description: OK
22    /teams:
23        get:
24            operationId: getTeams
25            summary: Retrieves all teams for the current season.
26            responses:
27                "200":
28                    description: OK
29    /games:
30        get:
31            operationId: getGames
32            summary: Retrieves all games that match the filters specified by the args. Display results using markdown tables.
33            parameters:
34                - in: query
35                  name: limit
36                  schema:
37                      type: string
38                  description: The max number of results to return.
39                - in: query
40                  name: seasons
41                  schema:
42                      type: array
43                      items:
44                          type: string
45                  description: Filter by seasons. Seasons are represented by the year they began. For example, 2018 represents season 2018-2019.
46                - in: query
47                  name: team_ids
48                  schema:
49                      type: array
50                      items:
51                          type: string
52                  description: Filter by team ids. Team ids can be determined using the getTeams function.
53                - in: query
54                  name: start_date
55                  schema:
56                      type: string
57                  description: A single date in 'YYYY-MM-DD' format. This is used to select games that occur on or after this date.
58                - in: query
59                  name: end_date
60                  schema:
61                      type: string
62                  description: A single date in 'YYYY-MM-DD' format. This is used to select games that occur on or before this date.
63            responses:
64                "200":
65                    description: OK
66    /stats:
67        get:
68            operationId: getStats
69            summary: Retrieves stats that match the filters specified by the args. Display results using markdown tables.
70            parameters:
71                - in: query
72                  name: limit
73                  schema:
74                      type: string
75                  description: The max number of results to return.
76                - in: query
77                  name: player_ids
78                  schema:
79                      type: array
80                      items:
81                          type: string
82                  description: Filter by player ids. Player ids can be determined using the getPlayers function.
83                - in: query
84                  name: game_ids
85                  schema:
86                      type: array
87                      items:
88                          type: string
89                  description: Filter by game ids. Game ids can be determined using the getGames function.
90                - in: query
91                  name: start_date
92                  schema:
93                      type: string
94                  description: A single date in 'YYYY-MM-DD' format. This is used to select games that occur on or after this date.
95                - in: query
96                  name: end_date
97                  schema:
98                      type: string
99                  description: A single date in 'YYYY-MM-DD' format. This is used to select games that occur on or before this date.
100            responses:
101                "200":
102                    description: OK
103    /season_averages:
104        get:
105            operationId: getSeasonAverages
106            summary: Retrieves regular season averages for the given players. Display results using markdown tables.
107            parameters:
108                - in: query
109                  name: season
110                  schema:
111                      type: string
112                  description: Defaults to the current season. A season is represented by the year it began. For example, 2018 represents season 2018-2019.
113                - in: query
114                  name: player_ids
115                  schema:
116                      type: array
117                      items:
118                          type: string
119                  description: Filter by player ids. Player ids can be determined using the getPlayers function.
120            responses:
121                "200":
122                    description: OK