Dữ liệu thống kê - Việt Nam

Dữ liệu thống kê - Việt Nam · Ações GPT

AlphaNotes

This is the backend for a GPT that provides tools to create summaries and study aids for YouTube videos and web articles.

  • POST /create_summaryCreate a summary of the video

    This endpoint returns the title, the thumbnail's URL (show after title), and the transcript or video summary. Use this endpoint when the user asks for a summary. Also follow the instruction from the assistant_hint.

  • POST /scrape_githubScrape a GitHub repository

    This endpoint scrapes text content of the given GitHub repository. It returns various details about the files and content. Use this endpoint when the user asks for a summary of a GitHub repository. Also follow the instruction from the assistant_hint.

  • POST /generate_notesGenerate notes and study aids for the video course

    This endpoint returns the title, the thumbnail's URL, always show after title, and the transcript or already made notes. Use this endpoint when the user asks to generate notes or a study aid. Also follow the instruction from the assistant_hint.

  • POST /get_transcriptGet the transcript of a video

    This endpoint returns the title, the thumbnail's URL (show after title), the transcript of a video, and a pdf link. Use it when the user asks for the video transcript only. The user might ask follow up questions on it, so don't call other endpoints but use what you get.

  • POST /create_pdfCreate PDF from Markdown and upload to File.io

    This endpoint converts Markdown text to PDF and provides a file.io link. Use it for user requests to generate/create/make/export/print a PDF from generated content. Don't add dev contact in the pdf. Adapt Markdown for JSON input.

  • POST /summarize_articleScrape an article and returns its content for summarization

    This endpoint scrapes the content of an article and returns its content along with listing any YouTube links found in the article. Use this endpoint when the user asks for an article summary or gives a URL that is not from YouTube. Also, follow the instruction from the assistant_hint.

  • POST /take_notes_from_articleScrape an article and returns its content for generating study aids

    This endpoint scrapes the content of an article and returns it along with listing any YouTube links found. Use this endpoint when the user asks for making notes of an article or gives a URL that is not from YouTube asking for notes. Also, follow the instruction from the assistant_hint.

  • POST /search_videosSearch for YouTube videos

    This endpoint searches for YouTube videos based on the query term and region code using the YouTube API V3. Come up with a good search query based on what the user needs. Use the US region code if no region or language are specified.

  • GET /get_helpGet help description

    This endpoint returns a help description.

Esquema API original
{
  "openapi": "3.0.0",
  "info": {
    "title": "AlphaNotes",
    "version": "0.1.0",
    "description": "This is the backend for a GPT that provides tools to create summaries and study aids for YouTube videos and web articles."
  },
  "paths": {
    "/create_summary": {
      "post": {
        "summary": "Create a summary of the video",
        "operationId": "videoSummary",
        "description": "This endpoint returns the title, the thumbnail's URL (show after title), and the transcript or video summary.  Use this endpoint when the user asks for a summary. Also follow the instruction from the assistant_hint.\n",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Video"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/VideoResponse"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/scrape_github": {
      "post": {
        "summary": "Scrape a GitHub repository",
        "operationId": "scrapeGithubRepository",
        "description": "This endpoint scrapes text content of the given GitHub repository. It returns various details about the files and content. Use this endpoint when the user asks for a summary of a GitHub repository. Also follow the instruction from the assistant_hint.",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "url": {
                    "type": "string",
                    "example": "https://github.com/soos3d/chat-gpt-aerodex-plugin",
                    "description": "URL of the GitHub repository to scrape."
                  }
                },
                "required": [
                  "url"
                ]
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/GHResponse"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/generate_notes": {
      "post": {
        "summary": "Generate notes and study aids for the video course",
        "operationId": "generateNotes",
        "description": "This endpoint returns the title, the thumbnail's URL, always show after title, and the transcript or already made notes. Use this endpoint when the user asks to generate notes or a study aid. Also follow the instruction from the assistant_hint.\n",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/VideoURL"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/NotesResponse"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/get_transcript": {
      "post": {
        "summary": "Get the transcript of a video",
        "operationId": "videoTranscript",
        "description": "This endpoint returns the title, the thumbnail's URL (show after title), the transcript of a video, and a pdf link. Use it when the user asks for the video transcript only. The user might ask follow up questions on it, so don't call other endpoints but use what you get.\n",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Video"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/VideoResponse"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/create_pdf": {
      "post": {
        "summary": "Create PDF from Markdown and upload to File.io",
        "operationId": "createPdf",
        "description": "This endpoint converts Markdown text to PDF and provides a file.io link.  Use it for user requests to generate/create/make/export/print a PDF from generated content. Don't add dev contact in the pdf. Adapt Markdown for JSON input.\n",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/TextModel"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successfully Created PDF and Uploaded to Dropbox",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/SharedLinkResponse"
                }
              }
            }
          },
          "400": {
            "description": "Dropbox API Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          },
          "500": {
            "description": "An unexpected error occurred",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/summarize_article": {
      "post": {
        "summary": "Scrape an article and returns its content for summarization",
        "operationId": "summarizeArticle",
        "description": "This endpoint scrapes the content of an article and returns its content along with listing any YouTube links found in the article. Use this endpoint when the user asks for an article summary or gives a URL that is not from YouTube. Also, follow the instruction from the assistant_hint.\n",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Article"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/SuccessfulArticleResponse"
                }
              }
            }
          },
          "404": {
            "description": "Article Not Found",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/UnavailableArticleError"
                }
              }
            }
          },
          "413": {
            "description": "Article Too Long",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ArticleTooLongError"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          },
          "500": {
            "description": "Processing Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ProcessingError"
                }
              }
            }
          }
        }
      }
    },
    "/take_notes_from_article": {
      "post": {
        "summary": "Scrape an article and returns its content for generating study aids",
        "operationId": "notesArticle",
        "description": "This endpoint scrapes the content of an article and returns it along with listing any YouTube links found. Use this endpoint when the user asks for making notes of an article or gives a URL that is not from YouTube asking for notes.  Also, follow the instruction from the assistant_hint.\n",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Article"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/SuccessfulArticleResponse"
                }
              }
            }
          },
          "404": {
            "description": "Article Not Found",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/UnavailableArticleError"
                }
              }
            }
          },
          "413": {
            "description": "Article Too Long",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ArticleTooLongError"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          },
          "500": {
            "description": "Processing Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ProcessingError"
                }
              }
            }
          }
        }
      }
    },
    "/search_videos": {
      "post": {
        "summary": "Search for YouTube videos",
        "operationId": "searchVideos",
        "description": "This endpoint searches for YouTube videos based on the query term and region code using the YouTube API V3. Come up with a good search query based on what the user needs. Use the US region code if no region or language are specified.\n",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "query_term": {
                    "type": "string",
                    "description": "The search term for querying YouTube videos."
                  },
                  "region_code": {
                    "type": "string",
                    "description": "The region code for filtering YouTube videos.",
                    "nullable": true
                  }
                }
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "assistant_hint": {
                      "type": "string"
                    },
                    "data": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "404": {
            "description": "Video Not Found",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "detail": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "detail": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "500": {
            "description": "Processing Error",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "detail": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          }
        }
      }
    },
    "/get_help": {
      "get": {
        "summary": "Get help description",
        "description": "This endpoint returns a help description.",
        "operationId": "getHelp",
        "parameters": [],
        "responses": {
          "200": {
            "description": "Successful response",
            "headers": {
              "X-PluginLab-Ignore-Quota": {
                "schema": {
                  "type": "string",
                  "example": "1"
                }
              }
            },
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "description": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "HTTPValidationError": {
        "type": "object",
        "title": "HTTPValidationError",
        "properties": {
          "detail": {
            "type": "array",
            "title": "Detail",
            "items": {
              "$ref": "#/components/schemas/ValidationError"
            }
          }
        }
      },
      "ValidationError": {
        "type": "object",
        "title": "ValidationError",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "properties": {
          "loc": {
            "type": "array",
            "title": "Location",
            "items": {
              "anyOf": [
                {
                  "type": "string"
                },
                {
                  "type": "integer"
                }
              ]
            }
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          }
        }
      },
      "Video": {
        "type": "object",
        "title": "Video",
        "required": [
          "url"
        ],
        "properties": {
          "url": {
            "type": "string",
            "title": "Url"
          }
        }
      },
      "VideoURL": {
        "type": "object",
        "title": "VideoURL",
        "required": [
          "url"
        ],
        "properties": {
          "url": {
            "type": "string",
            "title": "Url"
          }
        }
      },
      "VideoResponse": {
        "type": "object",
        "title": "VideoResponse",
        "required": [
          "title",
          "thumbnail_url",
          "token_count",
          "content",
          "assistant_hint"
        ],
        "properties": {
          "title": {
            "type": "string",
            "description": "The title of the video"
          },
          "thumbnail_url": {
            "type": "string",
            "format": "uri",
            "description": "The URL of the video thumbnail"
          },
          "token_count": {
            "type": "integer",
            "description": "The token count"
          },
          "content": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/Transcript"
              },
              {
                "$ref": "#/components/schemas/Summary"
              }
            ]
          },
          "assistant_hint": {
            "type": "string",
            "description": "The instructions to follow"
          }
        }
      },
      "GHResponse": {
        "type": "object",
        "title": "GHResponse",
        "required": [
          "files_content"
        ],
        "properties": {
          "total_token_count": {
            "type": "integer",
            "description": "The token count of the content"
          },
          "assistant_hint": {
            "type": "string",
            "description": "The instructions to follow"
          },
          "files": {
            "type": "string",
            "description": "The path and content of the files"
          },
          "files_count": {
            "type": "integer",
            "description": "How many files were scraped"
          }
        }
      },
      "NotesResponse": {
        "type": "object",
        "title": "NotesResponse",
        "required": [
          "title",
          "thumbnail_url",
          "token_count",
          "assistant_hint",
          "content"
        ],
        "properties": {
          "title": {
            "type": "string",
            "description": "The title of the video"
          },
          "thumbnail_url": {
            "type": "string",
            "format": "uri",
            "description": "The URL of the video thumbnail"
          },
          "token_count": {
            "type": "integer",
            "description": "The token count of the content"
          },
          "assistant_hint": {
            "type": "string",
            "description": "The instructions to follow"
          },
          "content": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/Transcript"
              },
              {
                "$ref": "#/components/schemas/Notes"
              }
            ]
          }
        }
      },
      "Transcript": {
        "type": "string",
        "description": "The full transcript of the video"
      },
      "Notes": {
        "type": "string",
        "description": "The generated notes for the video"
      },
      "Summary": {
        "type": "string",
        "description": "The generated summary of the video"
      },
      "TextModel": {
        "type": "object",
        "title": "TextModel",
        "required": [
          "text"
        ],
        "properties": {
          "text": {
            "type": "string",
            "description": "Markdown text to be converted to PDF",
            "example": "## This is a title\nThis is some text."
          }
        }
      },
      "SharedLinkResponse": {
        "type": "object",
        "title": "SharedLinkResponse",
        "required": [
          "link"
        ],
        "properties": {
          "link": {
            "type": "string",
            "format": "uri",
            "description": "Shareable Dropbox link of the uploaded PDF"
          }
        }
      },
      "ChunkResponse": {
        "type": "object",
        "properties": {
          "unique_id": {
            "type": "string",
            "description": "The unique ID associated with the video transcript"
          },
          "video_title": {
            "type": "string",
            "description": "The title of the video"
          },
          "current_chunk_index": {
            "type": "integer",
            "description": "The index of the current chunk"
          },
          "next_chunk_to_fetch": {
            "type": "integer",
            "description": "The index of the next chunk to fetch"
          },
          "Chunks_left_to_fetch": {
            "type": "integer",
            "description": "The number of chunks left to fetch"
          },
          "chunk": {
            "type": "object",
            "description": "The content of the current chunk"
          }
        }
      },
      "Article": {
        "type": "object",
        "properties": {
          "url": {
            "type": "string",
            "format": "uri"
          }
        }
      },
      "SuccessfulArticleResponse": {
        "type": "object",
        "properties": {
          "article_content": {
            "type": "string"
          },
          "youtube_links": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "source": {
            "type": "string",
            "format": "uri"
          },
          "assistant_hint": {
            "type": "string"
          }
        }
      },
      "UnavailableArticleError": {
        "type": "object",
        "properties": {
          "UNAVAILABLE_ARTICLE_ERROR": {
            "type": "string"
          }
        }
      },
      "ProcessingError": {
        "type": "object",
        "properties": {
          "PROCESSING_ERROR": {
            "type": "string"
          }
        }
      },
      "ArticleTooLongError": {
        "type": "object",
        "properties": {
          "ARTICLE_TOO_LONG": {
            "type": "string"
          }
        }
      }
    }
  },
  "servers": [
    {
      "url": "https://ainotes.alphanotes.one"
    }
  ]
}

Papr_Memory

This plugin allows the model to access and interact with the user's personal memory graph. It can retrieve information from past conversations, meeting transcripts, documents, and more. Use it when the user's query pertains to information that may be stored in their personal memory.

  • POST /add_memoryAccepts memory item objects with content, type, metadata, context, and relationships_json.
  • POST /get_memoryAccepts search query objects with query, context, and relation_type.
  • PUT /update_memoryUpdate an existing memory item objects with content, type, metadata, context, and relationships_json.
  • DELETE /delete_memoryDelete an existing memory item object using the id.
Esquema API original
{
  "openapi": "3.1.0",
  "info": {
    "title": "Papr_Memory",
    "description": "This plugin allows the model to access and interact with the user's personal memory graph. It can retrieve information from past conversations, meeting transcripts, documents, and more. Use it when the user's query pertains to information that may be stored in their personal memory.",
    "version": "v1"
  },
  "servers": [
    {
      "url": "https://memory.papr.ai"
    }
  ],
  "paths": {
    "/add_memory": {
      "post": {
        "operationId": "add_memory_post",
        "x-openai-isConsequential": false,
        "summary": "Accepts memory item objects with content, type, metadata, context, and relationships_json.",
        "security": [
          {
            "OAuth2": [
              "openid",
              "profile",
              "email",
              "offline_access"
            ]
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/AddMemoryRequest"
                }
              }
            }
          },
          "400": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ValidationError"
                }
              }
            }
          }
        },
        "requestBody": {
          "description": "",
          "required": false,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AddMemoryRequest"
              }
            }
          }
        }
      }
    },
    "/get_memory": {
      "post": {
        "operationId": "get_memory_post",
        "x-openai-isConsequential": false,
        "summary": "Accepts search query objects with query, context, and relation_type.",
        "security": [
          {
            "OAuth2": [
              "openid",
              "profile",
              "email",
              "offline_access"
            ]
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/GetMemoryResponse"
                }
              }
            }
          },
          "400": {
            "description": "Memory Not Found",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "requestBody": {
          "description": "",
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "description": "",
                "properties": {
                  "query": {
                    "type": "string",
                    "description": "Question or query from the user to search an item in memory"
                  },
                  "context": {
                    "type": "array",
                    "description": "",
                    "items": {
                      "type": "object",
                      "description": "",
                      "properties": {
                        "role": {
                          "type": "string",
                          "description": "Person who created the memory item in context ",
                          "enum": [
                            "user",
                            "assistant"
                          ]
                        },
                        "content": {
                          "type": "string",
                          "description": "Content of a memory item or conversation that is related to query "
                        }
                      },
                      "required": [
                        "role",
                        "content"
                      ]
                    }
                  },
                  "relation_type": {
                    "type": "string",
                    "description": "Relationship type given query and context that defines relationship type between memory items you want to find in memory "
                  }
                },
                "required": [
                  "query"
                ]
              }
            }
          }
        }
      }
    },
    "/update_memory": {
      "put": {
        "operationId": "update_memory_put",
        "x-openai-isConsequential": true,
        "summary": "Update an existing memory item objects with content, type, metadata, context, and relationships_json.",
        "security": [
          {
            "OAuth2": [
              "openid",
              "profile",
              "email",
              "offline_access"
            ]
          }
        ],
        "parameters": [
          {
            "in": "query",
            "name": "id",
            "schema": {
              "type": "string"
            },
            "required": true,
            "description": "ID of the memory item that needs to be updated"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response"
          },
          "400": {
            "description": "Memory Not Found",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ValidationError"
                }
              }
            }
          }
        },
        "requestBody": {
          "description": "",
          "required": false,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/EditMemoryRequest"
              }
            }
          }
        }
      }
    },
    "/delete_memory": {
      "delete": {
        "operationId": "delete_memory_delete",
        "x-openai-isConsequential": true,
        "summary": "Delete an existing memory item object using the id.",
        "security": [
          {
            "OAuth2": [
              "openid",
              "profile",
              "email",
              "offline_access"
            ]
          }
        ],
        "parameters": [
          {
            "in": "query",
            "name": "id",
            "schema": {
              "type": "string"
            },
            "required": true,
            "description": "ID of the memory item that needs to be deleted"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response"
          },
          "404": {
            "description": "Memory Not Found",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ValidationError"
                }
              }
            }
          }
        }
      }
    }
  },
  "components": {
    "securitySchemes": {
      "OAuth2": {
        "type": "oauth2",
        "flows": {
          "authorizationCode": {
            "authorizationUrl": "/login",
            "tokenUrl": "/token",
            "refreshUrl": "/refresh",
            "scopes": {
              "openid": "OpenID",
              "profile": "Profile access",
              "email": "Email access",
              "offline_access": "Offline access"
            }
          }
        }
      }
    },
    "schemas": {
      "AddMemoryRequest": {
        "type": "object",
        "description": "AddMemoryRequest Schema",
        "properties": {
          "content": {
            "type": "string",
            "description": "The content of the memory item you want to add to memory"
          },
          "type": {
            "type": "string",
            "description": "Content type of the memory item we currently only support text, code_snippet or pdf document",
            "enum": [
              "text",
              "code_snippet",
              "document"
            ]
          },
          "imageGenerationCategory": {
            "type": "string",
            "description": "Categories of memory items to specify their nature and content. The system will decide to auto-generate images for certain categories based on their relevance for visual representation.",
            "enum": [
              "narrative_element",
              "rpg_action",
              "object_description",
              "art_idea",
              "dream_or_fantasy",
              "historical_event",
              "personal_memory",
              "biological_concept",
              "cultural_reference",
              "travel",
              "mood_or_emotion",
              "web_development",
              "technical_log",
              "code_snippet",
              "error_message",
              "business_management",
              "project_management",
              "document",
              "instruction",
              "structured_list",
              "communication",
              "medical",
              "technical_analysis",
              "resume",
              "personal_identifiers",
              "ambiguous_concept",
              "art_related",
              "product_idea",
              "calendar_event",
              "other"
            ],
            "x-enum-descriptions": [
              "Visualizing scenes, characters, or events from stories.",
              "RPG game moves or interactions.",
              "Descriptions of particular objects, places, or scenes.",
              "Ideas for art projects, tattoos, room decorations, or clothing designs.",
              "Dreams or imaginative scenarios.",
              "Memories referencing historical or fictional events.",
              "Specific past events or memories.",
              "Biological organisms, anatomy, or phenomena.",
              "Cultural or mythological references.",
              "Memories related to travel experiences or places.",
              "Abstract feelings or emotions.",
              "Anything related to web development, including frontend, backend, and databases.",
              "Logs or technical data.",
              "Pieces of code or programming-related content.",
              "Specific error messages or issues.",
              "Operations, strategies, and details about managing a business.",
              "Management of projects, tasks, or teams.",
              "Formal papers, reports, or written content.",
              "Step-by-step guides or how-tos.",
              "Bullet-point information or lists.",
              "General category that can encompass emails, chats, meetings, etc.",
              "Medical-related memories or information.",
              "Detailed technical analysis or breakdowns.",
              "Professional CVs or resumes.",
              "Personal or sensitive information.",
              "Concepts that are unclear or not easily defined.",
              "General category for art-related content.",
              "Ideas, concepts, or plans related to startups, new products, or business ventures.",
              "Memories or notes related to scheduling, events, appointments, or reminders to be added to a calendar.",
              "Any other memory category not listed above."
            ]
          },
          "metadata": {
            "type": "object",
            "description": "Metadata used in Neo4J and Pinecone for a memory item. You can use the properties listed for this metadata and add additional properties as you see fit. ",
            "properties": {
              "topics": {
                "type": "string",
                "description": "List of topics related to the content, context & conversation history "
              },
              "hierarchical structures": {
                "type": "string",
                "description": "We tend to organize information hierarchically, from broad categories to specific details. Add Hierarchical Structures to enable users to navigate from broad topics to more specific ones."
              },
              "createdAt": {
                "type": "string",
                "description": "Time of when this memory item was created"
              },
              "location": {
                "type": "string",
                "description": "Location where the meeting item was captured, could be a meeting room or users physical location"
              },
              "emoji tags": {
                "type": "string",
                "description": "Emoji tags related to the memory item and conversation history"
              },
              "emotion tags": {
                "type": "string",
                "description": "Emotion tags related to the memory item and conversation history"
              },
              "conversationId": {
                "type": "string",
                "description": "Unique identifier for the conversation to which this memory item is related."
              },
              "sourceUrl": {
                "type": "string",
                "description": "The URL from where the memory item was captured or referenced."
              }
            }
          },
          "context": {
            "type": "array",
            "description": "Context can be conversation history or any relevant context for a memory item. Don't include the memory item you are already adding in content.",
            "items": {
              "type": "object",
              "description": "",
              "properties": {
                "role": {
                  "type": "string",
                  "description": "Person who created content for a context list",
                  "enum": [
                    "user",
                    "assistant"
                  ]
                },
                "content": {
                  "type": "string",
                  "description": "Content of the previous message that was in conversation history either from user or assistant"
                }
              },
              "required": [
                "role",
                "content"
              ]
            }
          },
          "relationships_json": {
            "type": "array",
            "description": "Array of relationships that we can use in Graph DB (neo4J) that define the relationships between content and context  ",
            "items": {
              "type": "object",
              "description": "",
              "properties": {
                "related_item_id": {
                  "type": "string",
                  "description": "Relationship that will be used in Graph DB between content and list of context",
                  "enum": [
                    "TextMemoryItem",
                    "previous_memory_item_id"
                  ]
                },
                "relation_type": {
                  "type": "string",
                  "description": "The relationship type that defines the neo4j relationship between newly added memory item and the memory item we are creating a relationship with."
                },
                "related_item_type": {
                  "type": "string",
                  "description": "Memory item type inside context that you want to relate",
                  "enum": [
                    "TextMemoryItem"
                  ]
                },
                "metadata": {
                  "type": "object",
                  "description": "metadata for the relation between content and memory item in context",
                  "properties": {}
                }
              },
              "required": [
                "related_item_id",
                "relation_type",
                "related_item_type",
                "metadata"
              ]
            }
          }
        },
        "required": [
          "content",
          "type",
          "metadata",
          "imageGenerationCategory"
        ]
      },
      "AddMemoryAttachFile": {
        "type": "object",
        "description": "AddMemoryAttachFile Schema",
        "properties": {
          "file": {
            "type": "string",
            "format": "binary",
            "description": "File to be uploaded"
          },
          "content": {
            "type": "string",
            "description": "The content of the memory item you want to add to memory"
          },
          "type": {
            "type": "string",
            "description": "Content type of the memory item we currently only support text, code_snippet or pdf document",
            "enum": [
              "document"
            ]
          },
          "imageGenerationCategory": {
            "type": "string",
            "description": "Categories of memory items to specify their nature and content. The system will decide to auto-generate images for certain categories based on their relevance for visual representation.",
            "enum": [
              "narrative_element",
              "rpg_action",
              "object_description",
              "art_idea",
              "dream_or_fantasy",
              "historical_event",
              "personal_memory",
              "biological_concept",
              "cultural_reference",
              "travel",
              "mood_or_emotion",
              "web_development",
              "technical_log",
              "code_snippet",
              "error_message",
              "business_management",
              "project_management",
              "document",
              "instruction",
              "structured_list",
              "communication",
              "medical",
              "technical_analysis",
              "resume",
              "personal_identifiers",
              "ambiguous_concept",
              "art_related",
              "product_idea",
              "calendar_event",
              "other"
            ],
            "x-enum-descriptions": [
              "Visualizing scenes, characters, or events from stories.",
              "RPG game moves or interactions.",
              "Descriptions of particular objects, places, or scenes.",
              "Ideas for art projects, tattoos, room decorations, or clothing designs.",
              "Dreams or imaginative scenarios.",
              "Memories referencing historical or fictional events.",
              "Specific past events or memories.",
              "Biological organisms, anatomy, or phenomena.",
              "Cultural or mythological references.",
              "Memories related to travel experiences or places.",
              "Abstract feelings or emotions.",
              "Anything related to web development, including frontend, backend, and databases.",
              "Logs or technical data.",
              "Pieces of code or programming-related content.",
              "Specific error messages or issues.",
              "Operations, strategies, and details about managing a business.",
              "Management of projects, tasks, or teams.",
              "Formal papers, reports, or written content.",
              "Step-by-step guides or how-tos.",
              "Bullet-point information or lists.",
              "General category that can encompass emails, chats, meetings, etc.",
              "Medical-related memories or information.",
              "Detailed technical analysis or breakdowns.",
              "Professional CVs or resumes.",
              "Personal or sensitive information.",
              "Concepts that are unclear or not easily defined.",
              "General category for art-related content.",
              "Ideas, concepts, or plans related to startups, new products, or business ventures.",
              "Memories or notes related to scheduling, events, appointments, or reminders to be added to a calendar.",
              "Any other memory category not listed above."
            ]
          },
          "metadata": {
            "type": "object",
            "description": "Metadata used in Neo4J and Pinecone for a memory item. You can use the properties listed for this metadata and add additional properties as you see fit. ",
            "properties": {
              "topics": {
                "type": "string",
                "description": "List of topics related to the content, context & conversation history "
              },
              "hierarchical structures": {
                "type": "string",
                "description": "We tend to organize information hierarchically, from broad categories to specific details. Add Hierarchical Structures to enable users to navigate from broad topics to more specific ones."
              },
              "createdAt": {
                "type": "string",
                "description": "Time of when this memory item was created"
              },
              "location": {
                "type": "string",
                "description": "Location where the meeting item was captured, could be a meeting room or users physical location"
              },
              "emoji tags": {
                "type": "string",
                "description": "Emoji tags related to the memory item and conversation history"
              },
              "emotion tags": {
                "type": "string",
                "description": "Emotion tags related to the memory item and conversation history"
              },
              "conversationId": {
                "type": "string",
                "description": "Unique identifier for the conversation to which this memory item is related."
              },
              "sourceUrl": {
                "type": "string",
                "description": "The URL from where the memory item was captured or referenced."
              }
            }
          },
          "context": {
            "type": "array",
            "description": "Context can be conversation history or any relevant context for a memory item. Don't include the memory item you are already adding in content.",
            "items": {
              "type": "object",
              "description": "",
              "properties": {
                "role": {
                  "type": "string",
                  "description": "Person who created content for a context list",
                  "enum": [
                    "user",
                    "assistant"
                  ]
                },
                "content": {
                  "type": "string",
                  "description": "Content of the previous message that was in conversation history either from user or assistant"
                }
              },
              "required": [
                "role",
                "content"
              ]
            }
          },
          "relationships_json": {
            "type": "array",
            "description": "Array of relationships that we can use in Graph DB (neo4J) that define the relationships between content and context  ",
            "items": {
              "type": "object",
              "description": "",
              "properties": {
                "related_item_id": {
                  "type": "string",
                  "description": "Relationship that will be used in Graph DB between content and list of context",
                  "enum": [
                    "TextMemoryItem",
                    "previous_memory_item_id"
                  ]
                },
                "relation_type": {
                  "type": "string",
                  "description": "The relationship type that defines the neo4j relationship between newly added memory item and the memory item we are creating a relationship with."
                },
                "related_item_type": {
                  "type": "string",
                  "description": "Memory item type inside context that you want to relate",
                  "enum": [
                    "TextMemoryItem"
                  ]
                },
                "metadata": {
                  "type": "object",
                  "description": "metadata for the relation between content and memory item in context",
                  "properties": {}
                }
              },
              "required": [
                "related_item_id",
                "relation_type",
                "related_item_type",
                "metadata"
              ]
            }
          }
        },
        "required": [
          "content",
          "type",
          "metadata",
          "imageGenerationCategory"
        ]
      },
      "HTTPValidationError": {
        "type": "object",
        "description": "HTTP Validation Error",
        "properties": {
          "Detail": {
            "type": "array",
            "description": "",
            "items": {
              "$ref": "#/components/schemas/ValidationError"
            }
          }
        }
      },
      "ValidationError": {
        "type": "object",
        "properties": {
          "Location": {
            "type": "array",
            "description": "",
            "items": {
              "type": "string",
              "description": ""
            }
          },
          "Message": {
            "type": "string",
            "description": ""
          },
          "Error Type": {
            "type": "string",
            "description": ""
          }
        },
        "required": [
          "Location",
          "Message",
          "Error Type"
        ]
      },
      "GetMemoryResponse": {
        "type": "object",
        "properties": {
          "results": {
            "type": "array",
            "description": "",
            "items": {
              "type": "object",
              "description": "",
              "properties": {}
            }
          }
        },
        "required": [
          "results"
        ]
      },
      "EditMemoryRequest": {
        "type": "object",
        "description": "EditMemoryRequest",
        "properties": {
          "content": {
            "type": "string",
            "description": "New content for the memory item, this will replace existing content for this memory item"
          },
          "metadata": {
            "type": "object",
            "description": "Metadata used in Neo4J and Pinecone for a memory item. You can use the properties listed for this metadata and add additional properties as you see fit. ",
            "properties": {
              "topics": {
                "type": "string",
                "description": "List of topics related to the content, context & conversation history "
              },
              "hierarchical structures": {
                "type": "string",
                "description": "We tend to organize information hierarchically, from broad categories to specific details. Add Hierarchical Structures to enable users to navigate from broad topics to more specific ones."
              },
              "updatedAt": {
                "type": "string",
                "description": "Time of when this memory item was updated"
              },
              "location": {
                "type": "string",
                "description": "Location where the meeting item was captured, could be a meeting room or users physical location"
              },
              "emoji tags": {
                "type": "string",
                "description": "Emoji tags related to the memory item and conversation history"
              },
              "emotion tags": {
                "type": "string",
                "description": "Emotion tags related to the memory item and conversation history"
              }
            },
            "required": [
              "updatedAt"
            ]
          }
        },
        "required": [
          "content"
        ]
      }
    }
  }
}

Sider Tools API

An API for various tools that are available from Sider AI to be used with any GPT.

  • GET /googleGPT/search_with_rerankGoogle Search With Rerank

    :param query: The search query. :param language: ISO-639-1 language code. :param time: The time period to search for. Options are "h" for past hour, "d" for past day, "w" for past week, and "m" for past month. :param country :param count: count/2 results returned.

  • GET /linkReader/extractUrl Extract

    Extracts information from a single URL or a list of URLs. :param url: A single URL or a string formatted as a JSON list of URLs.

  • GET /scholarGPT/scholarScholar Search

    :param query: Search query. :param language: language code. :param year_start: Start year. :param year_end: End year. :param sorted: false for relevance, true for date.

  • GET /scholarGPT/patentsGet Patents

    :param query: Search query. :param language: language code. :param country :param sort: "new", "old", None. :param before: type:YYYYMMDD :param after: type:YYYYMMDD :param status: "GRANT", "APPLICATION"

  • GET /googleGPT/searchGoogle Search

    :param query: The search query. :param language: language code. :param time: Time period. Options are "h" for past hour, "d" for past day, "w" for past week, and "m" for past month. :param country: country. :param count: The number of search results to return.

  • GET /googleGPT/imagesImage Search

    :param query: The search query. :param language: language code. :param time: Time period. Options are "h" for past hour, "d" for past day, "w" for past week, and "m" for past month. :param country: country. :param count: The number of search results to return.

  • GET /googleGPT/videosVideo Search

    The search query. :param language: language code. :param time: Time period. Options are "h" for past hour, "d" for past day, "w" for past week, and "m" for past month. :param country: country. :param count: The number of search results to return.

  • GET /shopping/product_searchProduct Search

    :param query: The search query. :param language :param time: The time period to search for articles. Options are "h" for past hour, "d" for past day, "w" for past week, and "m" for past month. :param country: The country to search for articles. :param location

  • GET /shopping/get_product_sellersGet Product Sellers

    :param product_id: The product ID. :param language: The language code of the articles to search for. :param country: The country to search for articles. :param location: The location to search for articles.

  • GET /newsGPT/newsNews Search

    :param query: The search query. :param language: The language code of the articles to search for. :param time: The time period to search for articles. Options are "w" for past week, "h" for past hour, "d" for past day, and "m" for past month. :param country: The country to search for articles.

  • POST /sider/presenter/api/slidesGenerate Slides

    :param type: Allowed types: [reveal] :param slides: The slides content. :param theme: Select Theme from: [beigo,blood,dracula,moon,night,serif,simple,sky,white] :param transition: Select Transition from: [none, fade, slide, convex, concave, zoom]

  • POST /sider/presenter/api/graphGenerate Graph

    :param type: Allowed types: [mermaid] :param code: The code for the graph.

  • POST /sider/presenter/api/pdfGenerate Pdf

    :param type: Allowed types: [pdf] :param markdown: The markdown content to be converted to PDF. :param url: The URL of the page to be converted to PDF.

  • POST /sider/presenter/api/docGenerate Doc

    :param type: Allowed types: [docx] :param markdown: The markdown content to be converted to DOCX. :param html: The HTML content to be converted to DOCX.

  • POST /sider/presenter/api/sheetGenerate Sheet

    :param type: Allowed types: [xlsx] :param csv: The CSV content to be converted to XLSX.

  • POST /sider/presenter/api/mapGenerate Map

    :param type: Allowed types: [default] :param longitude: The longitude of the location. :param latitude: The latitude of the location. :param zoom: The zoom level of the map.

  • POST /sider/presenter/api/screenshotGet Screenshot

    :param url: The URL of the page to be screenshotted. :param width: The width of the screenshot. :param height: The height of the screenshot.

  • POST /sider/presenter/api/tts/generateGenerate Tts

    :param text: The text to be converted to speech. :param voice: voice selected from the list of available voices.

  • GET /sider/presenter/api/tts/list_voicesList Voices
Esquema API original
{
  "openapi": "3.1.0",
  "info": {
    "title": "Sider Tools API",
    "description": "An API for various tools that are available from Sider AI to be used with any GPT.",
    "version": "1.0.0"
  },
  "paths": {
    "/googleGPT/search_with_rerank": {
      "get": {
        "summary": "Google Search With Rerank",
        "description": ":param query: The search query.\n:param language: ISO-639-1 language code.\n:param time: The time period to search for. Options are \"h\" for past hour, \"d\" for past day, \"w\" for past week, and \"m\" for past month.\n:param country\n:param count: count/2 results returned.",
        "operationId": "google_search_with_rerank_googleGPT_search_with_rerank_get",
        "parameters": [
          {
            "name": "query",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Query"
            }
          },
          {
            "name": "language",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "default": "en",
              "title": "Language"
            }
          },
          {
            "name": "time",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Time"
            }
          },
          {
            "name": "country",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Country"
            }
          },
          {
            "name": "count",
            "in": "query",
            "required": false,
            "schema": {
              "type": "integer",
              "default": 20,
              "title": "Count"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/linkReader/extract": {
      "get": {
        "summary": "Url Extract",
        "description": "Extracts information from a single URL or a list of URLs.\n:param url: A single URL or a string formatted as a JSON list of URLs.",
        "operationId": "url_extract_linkReader_extract_get",
        "parameters": [
          {
            "name": "url",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Url"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/scholarGPT/scholar": {
      "get": {
        "summary": "Scholar Search",
        "description": ":param query: Search query.\n:param language: language code.\n:param year_start: Start year.\n:param year_end: End year.\n:param sorted: false for relevance, true for date.",
        "operationId": "scholar_search_scholarGPT_scholar_get",
        "parameters": [
          {
            "name": "query",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Query"
            }
          },
          {
            "name": "language",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "default": "en",
              "title": "Language"
            }
          },
          {
            "name": "year_start",
            "in": "query",
            "required": false,
            "schema": {
              "type": "integer",
              "title": "Year Start"
            }
          },
          {
            "name": "year_end",
            "in": "query",
            "required": false,
            "schema": {
              "type": "integer",
              "title": "Year End"
            }
          },
          {
            "name": "sorted",
            "in": "query",
            "required": false,
            "schema": {
              "type": "boolean",
              "default": false,
              "title": "Sorted"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/scholarGPT/patents": {
      "get": {
        "summary": "Get Patents",
        "description": ":param query: Search query.\n:param language: language code.\n:param country\n:param sort: \"new\", \"old\", None.\n:param before: type:YYYYMMDD\n:param after: type:YYYYMMDD\n:param status: \"GRANT\", \"APPLICATION\"",
        "operationId": "get_patents_scholarGPT_patents_get",
        "parameters": [
          {
            "name": "query",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Query"
            }
          },
          {
            "name": "language",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "default": "en",
              "title": "Language"
            }
          },
          {
            "name": "country",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Country"
            }
          },
          {
            "name": "sort",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Sort"
            }
          },
          {
            "name": "before",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Before"
            }
          },
          {
            "name": "after",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "After"
            }
          },
          {
            "name": "status",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Status"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/googleGPT/search": {
      "get": {
        "summary": "Google Search",
        "description": ":param query: The search query.\n:param language: language code.\n:param time: Time period. Options are \"h\" for past hour, \"d\" for past day, \"w\" for past week, and \"m\" for past month.\n:param country: country.\n:param count: The number of search results to return.",
        "operationId": "google_search_googleGPT_search_get",
        "parameters": [
          {
            "name": "query",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Query"
            }
          },
          {
            "name": "language",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "default": "en",
              "title": "Language"
            }
          },
          {
            "name": "time",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Time"
            }
          },
          {
            "name": "country",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Country"
            }
          },
          {
            "name": "count",
            "in": "query",
            "required": false,
            "schema": {
              "type": "integer",
              "default": 10,
              "title": "Count"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/googleGPT/images": {
      "get": {
        "summary": "Image Search",
        "description": ":param query: The search query.\n:param language: language code.\n:param time: Time period. Options are \"h\" for past hour, \"d\" for past day, \"w\" for past week, and \"m\" for past month.\n:param country: country.\n:param count: The number of search results to return.",
        "operationId": "image_search_googleGPT_images_get",
        "parameters": [
          {
            "name": "query",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Query"
            }
          },
          {
            "name": "language",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "default": "en",
              "title": "Language"
            }
          },
          {
            "name": "country",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "default": "us",
              "title": "Country"
            }
          },
          {
            "name": "time",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Time"
            }
          },
          {
            "name": "count",
            "in": "query",
            "required": false,
            "schema": {
              "type": "integer",
              "default": 10,
              "title": "Count"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/googleGPT/videos": {
      "get": {
        "summary": "Video Search",
        "description": "The search query.\n:param language: language code.\n:param time: Time period. Options are \"h\" for past hour, \"d\" for past day, \"w\" for past week, and \"m\" for past month.\n:param country: country.\n:param count: The number of search results to return.",
        "operationId": "video_search_googleGPT_videos_get",
        "parameters": [
          {
            "name": "query",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Query"
            }
          },
          {
            "name": "language",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "default": "en",
              "title": "Language"
            }
          },
          {
            "name": "country",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Country"
            }
          },
          {
            "name": "time",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Time"
            }
          },
          {
            "name": "count",
            "in": "query",
            "required": false,
            "schema": {
              "type": "integer",
              "default": 10,
              "title": "Count"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/shopping/product_search": {
      "get": {
        "summary": "Product Search",
        "description": ":param query: The search query.\n:param language\n:param time: The time period to search for articles. Options are \"h\" for past hour, \"d\" for past day, \"w\" for past week, and \"m\" for past month.\n:param country: The country to search for articles.\n:param location",
        "operationId": "product_search_shopping_product_search_get",
        "parameters": [
          {
            "name": "query",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Query"
            }
          },
          {
            "name": "language",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "default": "en",
              "title": "Language"
            }
          },
          {
            "name": "time",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Time"
            }
          },
          {
            "name": "country",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Country"
            }
          },
          {
            "name": "location",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Location"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/shopping/get_product_sellers": {
      "get": {
        "summary": "Get Product Sellers",
        "description": ":param product_id: The product ID.\n:param language: The language code of the articles to search for.\n:param country: The country to search for articles.\n:param location: The location to search for articles.",
        "operationId": "get_product_sellers_shopping_get_product_sellers_get",
        "parameters": [
          {
            "name": "product_id",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Product Id"
            }
          },
          {
            "name": "language",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "default": "en",
              "title": "Language"
            }
          },
          {
            "name": "country",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Country"
            }
          },
          {
            "name": "location",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Location"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/newsGPT/news": {
      "get": {
        "summary": "News Search",
        "description": ":param query: The search query.\n:param language: The language code of the articles to search for.\n:param time: The time period to search for articles. Options are \"w\" for past week, \"h\" for past hour, \"d\" for past day, and \"m\" for past month.\n:param country: The country to search for articles.",
        "operationId": "news_search_newsGPT_news_get",
        "parameters": [
          {
            "name": "query",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Query"
            }
          },
          {
            "name": "language",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "default": "en",
              "title": "Language"
            }
          },
          {
            "name": "time",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "default": "w",
              "title": "Time"
            }
          },
          {
            "name": "country",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "default": "us",
              "title": "Country"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/sider/presenter/api/slides": {
      "post": {
        "summary": "Generate Slides",
        "description": ":param type: Allowed types: [reveal]\n:param slides: The slides content.\n:param theme: Select Theme from: [beigo,blood,dracula,moon,night,serif,simple,sky,white]\n:param transition: Select Transition from: [none, fade, slide, convex, concave, zoom]",
        "operationId": "generate_slides_sider_presenter_api_slides_post",
        "parameters": [
          {
            "name": "type",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Type"
            }
          },
          {
            "name": "theme",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Theme"
            }
          },
          {
            "name": "transition",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Transition"
            }
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "multipart/form-data": {
              "schema": {
                "$ref": "#/components/schemas/Body_generate_slides_sider_presenter_api_slides_post"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/sider/presenter/api/graph": {
      "post": {
        "summary": "Generate Graph",
        "description": ":param type: Allowed types: [mermaid]\n:param code: The code for the graph.",
        "operationId": "generate_graph_sider_presenter_api_graph_post",
        "parameters": [
          {
            "name": "type",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Type"
            }
          },
          {
            "name": "code",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Code"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/sider/presenter/api/pdf": {
      "post": {
        "summary": "Generate Pdf",
        "description": ":param type: Allowed types: [pdf]\n:param markdown: The markdown content to be converted to PDF.\n:param url: The URL of the page to be converted to PDF.",
        "operationId": "generate_pdf_sider_presenter_api_pdf_post",
        "parameters": [
          {
            "name": "type",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Type"
            }
          },
          {
            "name": "markdown",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Markdown"
            }
          },
          {
            "name": "url",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Url"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/sider/presenter/api/doc": {
      "post": {
        "summary": "Generate Doc",
        "description": ":param type: Allowed types: [docx]\n:param markdown: The markdown content to be converted to DOCX.\n:param html: The HTML content to be converted to DOCX.",
        "operationId": "generate_doc_sider_presenter_api_doc_post",
        "parameters": [
          {
            "name": "type",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Type"
            }
          },
          {
            "name": "markdown",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Markdown"
            }
          },
          {
            "name": "html",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Html"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/sider/presenter/api/sheet": {
      "post": {
        "summary": "Generate Sheet",
        "description": ":param type: Allowed types: [xlsx]\n:param csv: The CSV content to be converted to XLSX.",
        "operationId": "generate_sheet_sider_presenter_api_sheet_post",
        "parameters": [
          {
            "name": "type",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Type"
            }
          },
          {
            "name": "csv",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Csv"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/sider/presenter/api/map": {
      "post": {
        "summary": "Generate Map",
        "description": ":param type: Allowed types: [default]\n:param longitude: The longitude of the location.\n:param latitude: The latitude of the location.\n:param zoom: The zoom level of the map.",
        "operationId": "generate_map_sider_presenter_api_map_post",
        "parameters": [
          {
            "name": "type",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Type"
            }
          },
          {
            "name": "longitude",
            "in": "query",
            "required": true,
            "schema": {
              "type": "number",
              "title": "Longitude"
            }
          },
          {
            "name": "latitude",
            "in": "query",
            "required": true,
            "schema": {
              "type": "number",
              "title": "Latitude"
            }
          },
          {
            "name": "zoom",
            "in": "query",
            "required": true,
            "schema": {
              "type": "integer",
              "title": "Zoom"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/sider/presenter/api/screenshot": {
      "post": {
        "summary": "Get Screenshot",
        "description": ":param url: The URL of the page to be screenshotted.\n:param width: The width of the screenshot.\n:param height: The height of the screenshot.",
        "operationId": "get_screenshot_sider_presenter_api_screenshot_post",
        "parameters": [
          {
            "name": "url",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Url"
            }
          },
          {
            "name": "width",
            "in": "query",
            "required": true,
            "schema": {
              "type": "integer",
              "title": "Width"
            }
          },
          {
            "name": "height",
            "in": "query",
            "required": true,
            "schema": {
              "type": "integer",
              "title": "Height"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/sider/presenter/api/tts/generate": {
      "post": {
        "summary": "Generate Tts",
        "description": ":param text: The text to be converted to speech.\n:param voice: voice selected from the list of available voices.",
        "operationId": "generate_tts_sider_presenter_api_tts_generate_post",
        "parameters": [
          {
            "name": "text",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Text"
            }
          },
          {
            "name": "voice",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "title": "Voice"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/sider/presenter/api/tts/list_voices": {
      "get": {
        "summary": "List Voices",
        "operationId": "list_voices_sider_presenter_api_tts_list_voices_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "Body_generate_slides_sider_presenter_api_slides_post": {
        "properties": {
          "slides": {
            "items": {},
            "type": "array",
            "title": "Slides"
          }
        },
        "type": "object",
        "required": [
          "slides"
        ],
        "title": "Body_generate_slides_sider_presenter_api_slides_post"
      },
      "HTTPValidationError": {
        "properties": {
          "detail": {
            "items": {
              "$ref": "#/components/schemas/ValidationError"
            },
            "type": "array",
            "title": "Detail"
          }
        },
        "type": "object",
        "title": "HTTPValidationError"
      },
      "RerankRequest": {
        "properties": {
          "query": {
            "type": "string",
            "title": "Query"
          },
          "documents": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "title": "Documents"
          }
        },
        "type": "object",
        "required": [
          "query",
          "documents"
        ],
        "title": "RerankRequest"
      },
      "ValidationError": {
        "properties": {
          "loc": {
            "items": {
              "anyOf": [
                {
                  "type": "string"
                },
                {
                  "type": "integer"
                }
              ]
            },
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          }
        },
        "type": "object",
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError"
      }
    }
  },
  "servers": [
    {
      "url": "https://actions.sider.ai/gpts/action"
    }
  ]
}

Diagram to Image API

A simple API to generate flowchart, mindmap, or sequence diagram images.

  • POST /ai.chatgpt.render-flowchartRenders a flowchart

    Accepts a string describing a flowchart and returns a URL to a rendered image

  • POST /ai.chatgpt.render-mindmapRender markdown bullet list as a mindmap

    Accepts a markdown bullet list and returns a URL to a rendered image

  • POST /ai.chatgpt.render-sequence-diagramRender a sequence diagram

    Accepts a string describing a sequence diagram and returns a URL to a rendered image

Esquema API original
{
  "openapi": "3.0.0",
  "info": {
    "version": "1.0.0",
    "title": "Diagram to Image API",
    "description": "A simple API to generate flowchart, mindmap, or sequence diagram images."
  },
  "servers": [
    {
      "url": "https://whimsical.com/api"
    }
  ],
  "paths": {
    "/ai.chatgpt.render-flowchart": {
      "post": {
        "operationId": "postRenderFlowchart",
        "x-openai-isConsequential": false,
        "summary": "Renders a flowchart",
        "description": "Accepts a string describing a flowchart and returns a URL to a rendered image",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/FlowchartRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "URL to the rendered image",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/FlowchartResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid flowchart syntax provided",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "500": {
            "description": "Unexpected error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/ai.chatgpt.render-mindmap": {
      "post": {
        "operationId": "postRenderMindmap",
        "x-openai-isConsequential": false,
        "summary": "Render markdown bullet list as a mindmap",
        "description": "Accepts a markdown bullet list and returns a URL to a rendered image",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/MindmapRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "URL to the rendered image",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/MindmapResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid markdown string provided",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "500": {
            "description": "Unexpected error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/ai.chatgpt.render-sequence-diagram": {
      "post": {
        "operationId": "postRenderSequenceDiagram",
        "x-openai-isConsequential": false,
        "summary": "Render a sequence diagram",
        "description": "Accepts a string describing a sequence diagram and returns a URL to a rendered image",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/SequenceDiagramRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "URL to the rendered image",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/SequenceDiagramResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid sequence diagram syntax provided",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "500": {
            "description": "Unexpected error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "FlowchartRequest": {
        "type": "object",
        "properties": {
          "mermaid": {
            "type": "string",
            "description": "Flowchart to be rendered, in Mermaid syntax"
          },
          "title": {
            "type": "string",
            "description": "Title of the flowchart"
          }
        },
        "required": [
          "mermaid"
        ]
      },
      "FlowchartResponse": {
        "type": "object",
        "properties": {
          "imageURL": {
            "type": "string",
            "description": "URL of the rendered image"
          },
          "fileURL": {
            "type": "string",
            "description": "URL of the file in Whimsical"
          }
        }
      },
      "MindmapRequest": {
        "type": "object",
        "properties": {
          "markdown": {
            "type": "string",
            "description": "Indented, markdown bullet list of mindmap nodes"
          },
          "title": {
            "type": "string",
            "description": "Title of the mindmap"
          }
        },
        "required": [
          "markdown"
        ]
      },
      "MindmapResponse": {
        "type": "object",
        "properties": {
          "imageURL": {
            "type": "string",
            "description": "URL of the rendered image"
          },
          "fileURL": {
            "type": "string",
            "description": "URL of the file in Whimsical"
          }
        }
      },
      "SequenceDiagramRequest": {
        "type": "object",
        "properties": {
          "diagram": {
            "type": "string",
            "description": "Sequence diagram to be rendered"
          },
          "title": {
            "type": "string",
            "description": "Title of the sequence diagram"
          }
        },
        "required": [
          "diagram"
        ]
      },
      "SequenceDiagramResponse": {
        "type": "object",
        "properties": {
          "imageURL": {
            "type": "string",
            "description": "URL of the rendered image"
          },
          "fileURL": {
            "type": "string",
            "description": "URL of the file in Whimsical"
          }
        }
      },
      "Error": {
        "type": "object",
        "properties": {
          "message": {
            "type": "string",
            "description": "Error message"
          }
        }
      }
    }
  }
}

Doc Maker GPT

A GPT that allows users to create documents.

  • POST /create_document_directly_with_htmlCreate a document directly with HTML content

    Create a document directly with HTML content.

  • POST /create_document_indirectly_with_gptCreate a document indirectly by prompting a GPT model specialized for longform writing

    Create a document indirectly by prompting a GPT model specialized for longform writing

  • POST /create_pptx_indirectly_with_gptCreate a presentation indirectly by prompting a GPT model specialized for generating long presentations

    Create a presentation indirectly by prompting a GPT model specialized for generating long presentations

  • POST /create_resumeCreate Resume Endpoint
  • POST /create_spreadsheetCreate a new spreadsheet

    Create a new spreadsheet given data. Enclose all fields in double quotes.

Esquema API original
{
  "components": {
    "schemas": {
      "CreateDocumentDirectlyWithHtmlRequestV1": {
        "properties": {
          "content": {
            "description": "Content of the document in HTML format",
            "title": "Content",
            "type": "string"
          },
          "title": {
            "description": "Title of the document.",
            "title": "Title",
            "type": "string"
          }
        },
        "required": [
          "title",
          "content"
        ],
        "title": "CreateDocumentDirectlyWithHtmlRequestV1",
        "type": "object"
      },
      "CreateDocumentIndirectlyWithGptRequestV2": {
        "properties": {
          "language": {
            "default": "en",
            "description": "The two-digit ISO 639-1 code representing the expected human language for the document content.",
            "title": "Language",
            "type": "string"
          },
          "openaiFileIdRefs": {
            "default": [],
            "description": "List of files to use during document generation, such as images or PDF / DOCX / PPTX files for downstream GPT to use for writing document. Each object contains: `name` - name of the file; `id` - identifier for the file; `mime_type` - mime type of the file; `download_link` - the URL to fetch the file.",
            "items": {},
            "title": "Openaifileidrefs",
            "type": "array"
          },
          "pageCount": {
            "default": 5,
            "description": "The number of document pages (or number of presentation slides) to generate.",
            "title": "Pagecount",
            "type": "integer"
          },
          "prompt": {
            "description": "Instructions that will be used by a GPT-3.5 model to create the document. The instructions should be detailed and contain important information.",
            "title": "Prompt",
            "type": "string"
          }
        },
        "required": [
          "prompt"
        ],
        "title": "CreateDocumentIndirectlyWithGptRequestV2",
        "type": "object"
      },
      "CreateSpreadsheetRequest": {
        "properties": {
          "prompt": {
            "description": "Prompt context for creating spreadsheet - will be shown later in document UI.",
            "title": "Prompt",
            "type": "string"
          },
          "sheets": {
            "description": "List of sheets inside spreadsheet. Each sheet consists of a header row, followed by rows of data",
            "items": {
              "$ref": "#/components/schemas/DocmakerSheet"
            },
            "title": "Sheets",
            "type": "array"
          },
          "title": {
            "default": "Untitled",
            "description": "Mandatory: the title of the spreadsheet. Must be included.",
            "title": "Title",
            "type": "string"
          }
        },
        "required": [
          "prompt",
          "sheets"
        ],
        "title": "CreateSpreadsheetRequest",
        "type": "object"
      },
      "DocmakerSheet": {
        "properties": {
          "content": {
            "default": "",
            "description": "Sheet data content in CSV format. Enclose all fields in double quotes.",
            "title": "Content",
            "type": "string"
          }
        },
        "title": "DocmakerSheet",
        "type": "object"
      },
      "HTTPValidationError": {
        "properties": {
          "detail": {
            "items": {
              "$ref": "#/components/schemas/ValidationError"
            },
            "title": "Detail",
            "type": "array"
          }
        },
        "title": "HTTPValidationError",
        "type": "object"
      },
      "Markdown2ResumeRequest": {
        "properties": {
          "prompt": {
            "description": "Prompt used to describe the doc creation request. IT IS NOT USED TO CREATE DOC, only to display in UI for user to view later.",
            "title": "Prompt",
            "type": "string"
          },
          "resume_content": {
            "default": "",
            "description": "Resume content in Markdown format. Do NOT include any of the above information (name, email, phone, location, website url) here; they should be directly placed via their respective fields. When using acronyms, ensure to write out the full term as well. For example, instead of writing 'SEO', write 'Search Engine Optimization (SEO)'.",
            "title": "Resume Content",
            "type": "string"
          },
          "resume_field_email": {
            "description": "Optional: Personal email to be placed directly into the resume/cv. If supplied, do NOT include it in the formatted_markdown field.",
            "title": "Resume Field Email",
            "type": "string"
          },
          "resume_field_location": {
            "description": "Optional: Location to be placed directly into the resume/cv. If supplied, do NOT include it in the formatted_markdown field.",
            "title": "Resume Field Location",
            "type": "string"
          },
          "resume_field_name": {
            "default": "",
            "description": "Mandatory: Personal name to be placed directly into the resume/cv. Do NOT include it in the formatted_markdown field.",
            "title": "Resume Field Name",
            "type": "string"
          },
          "resume_field_phone": {
            "description": "Optional: Phone number to be placed directly into the resume/cv. If supplied, do NOT include it in the formatted_markdown field.",
            "title": "Resume Field Phone",
            "type": "string"
          },
          "resume_field_website_url": {
            "description": "Optional: Website URL to be placed directly into the resume/cv. If supplied, do NOT include it in the formatted_markdown field.",
            "title": "Resume Field Website Url",
            "type": "string"
          },
          "title": {
            "default": "Untitled",
            "description": "Mandatory: Title of the document.",
            "title": "Title",
            "type": "string"
          }
        },
        "required": [
          "prompt"
        ],
        "title": "Markdown2ResumeRequest",
        "type": "object"
      },
      "ValidationError": {
        "properties": {
          "loc": {
            "items": {
              "anyOf": [
                {
                  "type": "string"
                },
                {
                  "type": "integer"
                }
              ]
            },
            "title": "Location",
            "type": "array"
          },
          "msg": {
            "title": "Message",
            "type": "string"
          },
          "type": {
            "title": "Error Type",
            "type": "string"
          }
        },
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError",
        "type": "object"
      }
    }
  },
  "info": {
    "description": "A GPT that allows users to create documents.",
    "title": "Doc Maker GPT",
    "version": "v1"
  },
  "openapi": "3.1.0",
  "paths": {
    "/create_document_directly_with_html": {
      "post": {
        "description": "Create a document directly with HTML content.",
        "operationId": "create_document_directly_with_html",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateDocumentDirectlyWithHtmlRequestV1"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response"
          },
          "422": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            },
            "description": "Validation Error"
          }
        },
        "summary": "Create a document directly with HTML content",
        "x-openai-isConsequential": false
      }
    },
    "/create_document_indirectly_with_gpt": {
      "post": {
        "description": "Create a document indirectly by prompting a GPT model specialized for longform writing",
        "operationId": "create_document_indirectly_with_gpt",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateDocumentIndirectlyWithGptRequestV2"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response"
          },
          "422": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            },
            "description": "Validation Error"
          }
        },
        "summary": "Create a document indirectly by prompting a GPT model specialized for longform writing",
        "x-openai-isConsequential": false
      }
    },
    "/create_pptx_indirectly_with_gpt": {
      "post": {
        "description": "Create a presentation indirectly by prompting a GPT model specialized for generating long presentations",
        "operationId": "create_pptx_indirectly_with_gpt",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateDocumentIndirectlyWithGptRequestV2"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response"
          },
          "422": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            },
            "description": "Validation Error"
          }
        },
        "summary": "Create a presentation indirectly by prompting a GPT model specialized for generating long presentations",
        "x-openai-isConsequential": false
      }
    },
    "/create_resume": {
      "post": {
        "operationId": "create_resume",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Markdown2ResumeRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response"
          },
          "422": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            },
            "description": "Validation Error"
          }
        },
        "summary": "Create Resume Endpoint",
        "x-openai-isConsequential": false
      }
    },
    "/create_spreadsheet": {
      "post": {
        "description": "Create a new spreadsheet given data. Enclose all fields in double quotes.",
        "operationId": "create_spreadsheet",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateSpreadsheetRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response"
          },
          "422": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            },
            "description": "Validation Error"
          }
        },
        "summary": "Create a new spreadsheet",
        "x-openai-isConsequential": false
      }
    }
  },
  "servers": [
    {
      "url": "https://gpt.docs.aidocmaker.com"
    }
  ]
}

Diagram HelpfulDev

  • GET /diagram-guidelines**ONLY USE MERMAID and graph, sequence, mindmap, timeline, entity-relationship UNLESS THE USER ASKS FOR A DIFFERENT DIAGRAM TYPE / LANGUAGE**
  • POST /render-diagramTaking a diagram, renders it and returns a link to the rendered image. Always request the diagram guidelines endpoint before requesting this endpoint
  • GET /show-ideasShow ideas to improve the diagram
  • GET /explore-diagramsShowcase diagrams that the plugin can render
Esquema API original
{
  "openapi": "3.0.2",
  "info": {
    "title": "Diagram HelpfulDev",
    "version": "0.1.0"
  },
  "servers": [
    {
      "url": "https://diagrams.helpful.dev",
      "description": "Development server"
    }
  ],
  "paths": {
    "/diagram-guidelines": {
      "get": {
        "operationId": "get_DiagramGuidelinesRoute",
        "summary": "**ONLY USE MERMAID and graph, sequence, mindmap, timeline, entity-relationship UNLESS THE USER ASKS FOR A DIFFERENT DIAGRAM TYPE / LANGUAGE**",
        "x-openai-isConsequential": false,
        "parameters": [
          {
            "required": false,
            "schema": {
              "type": "string",
              "description": "Default or explicitly requested diagram language",
              "enum": [
                "blockdiag",
                "bpmn",
                "bytefield",
                "seqdiag",
                "actdiag",
                "nwdiag",
                "packetdiag",
                "rackdiag",
                "c4-with-plantuml",
                "d2",
                "dbml",
                "ditaa",
                "erd",
                "excalidraw",
                "graphviz",
                "mermaid",
                "nomnoml",
                "pikchr",
                "plantuml",
                "structurizr",
                "svgbob",
                "umlet",
                "vega",
                "vegalite",
                "wavedrom",
                "wireviz",
                "markmap"
              ]
            },
            "name": "explicitlyRequestedByUserDiagramLanguage",
            "in": "query"
          },
          {
            "required": true,
            "schema": {
              "type": "string",
              "description": "Type of the diagram. Strongly preffered: graph, sequence, mindmap, timeline or entity-relationship",
              "enum": [
                "sequence",
                "use-case",
                "class",
                "object",
                "activity",
                "component",
                "deployment",
                "state",
                "timing",
                "graph",
                "entity-relationship",
                "user-journey",
                "gantt",
                "pie-chart",
                "requirement",
                "gitgraph",
                "mindmap",
                "timeline",
                "block",
                "network",
                "json",
                "yaml",
                "salt-wireframe",
                "rack",
                "grid",
                "dbml",
                "ascii",
                "digital-timing",
                "line-chart",
                "bar-chart",
                "histogram"
              ]
            },
            "name": "diagramType",
            "in": "query"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "diagramGuidelines": {
                      "type": "string",
                      "description": "The requested diagram guidelines. Make sure to follow the guidelines before rendering a diagram"
                    },
                    "diagramThemes": {
                      "type": "string",
                      "description": "Diagram themes to change the style of the diagram. The themes are specific to the diagram language. Don't render a diagram using a theme unless the user asks for it"
                    },
                    "diagramLanguage": {
                      "type": "string",
                      "description": "Selected diagram language. Prefer mermaid"
                    }
                  }
                }
              }
            }
          }
        }
      }
    },
    "/render-diagram": {
      "post": {
        "operationId": "post_RenderDiagramRoute",
        "summary": "Taking a diagram, renders it and returns a link to the rendered image. Always request the diagram guidelines endpoint before requesting this endpoint",
        "x-openai-isConsequential": false,
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "diagramLanguage": {
                    "type": "string",
                    "description": "Diagram language",
                    "example": "mermaid"
                  },
                  "diagramType": {
                    "type": "string",
                    "description": "Diagram type",
                    "example": "graph"
                  },
                  "d2Theme": {
                    "type": "string",
                    "description": "Theme for d2 diagram",
                    "example": "neutral-grey_sketch"
                  },
                  "diagram": {
                    "type": "string",
                    "description": "Diagram to render. Avoid using a multiline string, instead use explicit newline characters."
                  },
                  "openaiFileIdRefs": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "properties": {
                        "name": {
                          "type": "string"
                        },
                        "id": {
                          "type": "string"
                        },
                        "mime_type": {
                          "type": "string"
                        },
                        "download_link": {
                          "type": "string"
                        }
                      },
                      "required": [
                        "name",
                        "id",
                        "mime_type",
                        "download_link"
                      ]
                    }
                  },
                  "remainingAttempts": {
                    "type": "number",
                    "description": "Track the number of remaining attempts to render the diagram",
                    "default": 3
                  }
                },
                "required": [
                  "diagramLanguage",
                  "diagramType",
                  "diagram"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "interpretingTheAPIResponse": {
                      "type": "string",
                      "description": "How to reply to the user"
                    }
                  }
                }
              }
            }
          }
        },
        "parameters": []
      }
    },
    "/show-ideas": {
      "get": {
        "operationId": "get_ShowIdeasRoute",
        "summary": "Show ideas to improve the diagram",
        "x-openai-isConsequential": false,
        "parameters": [
          {
            "required": true,
            "schema": {
              "type": "string"
            },
            "name": "diagramLanguage",
            "in": "query"
          },
          {
            "required": true,
            "schema": {
              "type": "string"
            },
            "name": "diagramType",
            "in": "query"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "interpretingAPIResponse": {
                      "type": "string",
                      "description": "This section comes after receiving the api response"
                    }
                  }
                }
              }
            }
          }
        }
      }
    },
    "/explore-diagrams": {
      "get": {
        "operationId": "get_ExploreDiagramsRoute",
        "summary": "Showcase diagrams that the plugin can render",
        "x-openai-isConsequential": false,
        "parameters": [
          {
            "description": "Choose 3 diagram types that the user might want to render, the 1st diagram type should be the latest rendered diagram type",
            "required": true,
            "schema": {
              "type": "array",
              "items": {
                "type": "string",
                "description": "Diagram type same as diagramType in diagramGuidelines",
                "example": "graph"
              }
            },
            "name": "diagramTypesToExplore",
            "in": "query"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "interpretingAPIResponse": {
                      "type": "string",
                      "description": "This section comes after receiving the api response"
                    },
                    "forMermaidHyperlinkTheDocs": {
                      "type": "string",
                      "description": "When mentioning mermaid, hyperlink the docs AT LEAST ONCE!"
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Read URL - AI Doc Marker

A GPT that allows the user to read data from a link.

  • POST /read_urlRead the contents of an URL link

    Allows for reading the contents of an URL link, including PDF/DOC/DOCX/PPT/CSV/XLS/XLSX/HTML content, Google Drive, Dropbox, OneDrive, aidocmaker.com docs. Always wrap image URLs from the response field `z1_image_urls` in Markdown, where each image has a ## DESCRIPTION.

Esquema API original
{
  "components": {
    "schemas": {
      "HTTPValidationError": {
        "properties": {
          "detail": {
            "items": {
              "$ref": "#/components/schemas/ValidationError"
            },
            "title": "Detail",
            "type": "array"
          }
        },
        "title": "HTTPValidationError",
        "type": "object"
      },
      "ReadDocV2Request": {
        "properties": {
          "f1_http_url": {
            "description": "User will pass a HTTPS or HTTP url to a file so that the file contents can be read.",
            "title": "F1 Http Url",
            "type": "string"
          },
          "f2_query": {
            "default": "",
            "description": "User will pass a query string to fetch relevant sections from the contents. It will be used for sentence-level similarity search on the document based on embeddings.",
            "title": "F2 Query",
            "type": "string"
          },
          "f3_selected_pages": {
            "default": [],
            "description": "Filter document on these page numbers. Use empty list to get all pages.",
            "items": {
              "type": "integer"
            },
            "title": "F3 Selected Pages",
            "type": "array"
          }
        },
        "required": [
          "f1_http_url"
        ],
        "title": "ReadDocV2Request",
        "type": "object"
      },
      "ValidationError": {
        "properties": {
          "loc": {
            "items": {
              "anyOf": [
                {
                  "type": "string"
                },
                {
                  "type": "integer"
                }
              ]
            },
            "title": "Location",
            "type": "array"
          },
          "msg": {
            "title": "Message",
            "type": "string"
          },
          "type": {
            "title": "Error Type",
            "type": "string"
          }
        },
        "required": [
          "loc",
          "msg",
          "type"
        ],
        "title": "ValidationError",
        "type": "object"
      }
    }
  },
  "info": {
    "description": "A GPT that allows the user to read data from a link.",
    "title": "Read URL - AI Doc Marker",
    "version": "v1"
  },
  "openapi": "3.1.0",
  "paths": {
    "/read_url": {
      "post": {
        "description": "Allows for reading the contents of an URL link, including PDF/DOC/DOCX/PPT/CSV/XLS/XLSX/HTML content, Google Drive, Dropbox, OneDrive, aidocmaker.com docs. Always wrap image URLs from the response field `z1_image_urls` in Markdown, where each image has a ## DESCRIPTION.",
        "operationId": "read_url",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ReadDocV2Request"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Successful Response"
          },
          "422": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            },
            "description": "Validation Error"
          }
        },
        "summary": "Read the contents of an URL link",
        "x-openai-isConsequential": false
      }
    }
  },
  "servers": [
    {
      "url": "https://gpt.chatpdf.aidocmaker.com"
    }
  ]
}