MCP App Store
by KeenEthics
CourseIO icon

CourseIO MCP Server for ChatGPT

By DevsVilla International Private Limited

Overview

CourseIO helps teachers, lecturers and professors create complete online courses for their students. Give it a topic, and it builds lessons with a teaching script, slides, captions, a narrated video, a quiz for each module and a handout. You can then export the course to your school's, college's or university's learning platform. With CourseIO in ChatGPT, you can: - Create a course: describe the topic, who it's for (for example, Year 9 science, an A-level revision course or a first-year university module) and how many lessons you want. - Improve a lesson: read a lesson's script or slides, make it clearer, and save the changes you approve. - Update a video: after a lesson changes, rebuild that lesson's video. - Translate a course: make a copy of a course in another language. - Export a course: download it as SCORM, cmi5, Common Cartridge or Moodle for your LMS. - Check your work: see your courses and their lessons. You stay in control: - Nothing that uses your CourseIO credits happens until you confirm it. - You choose which CourseIO organisation ChatGPT can use, and you can disconnect at any time in CourseIO under Settings > Connected apps. - CourseIO only receives the requests ChatGPT sends on your behalf. It never sees your conversation. Editing, rebuilding and translating need Course Studio to be turned on for your organisation. You need a CourseIO account to connect.

How to connect

  1. ChatGPT: Open the CourseIO listing in the ChatGPT app directory and choose Connect. ChatGPT listing CourseIO exposes 16 tools here.

Tools

courseio_cancel_generation

ChatGPT
Stops what is running on a course and refunds the credits for work not done: the course's own generation (refunded in full; the course is marked failed), a Course Studio rebuild (unfinished lessons refunded), or a translation — for a translation pass the NEW course's id (new_course.course_id from courseio_translate_course, or target_course_id from courseio_get_operation), not the original's. This cannot be undone. Rebuilds and translations are Course Studio features (available when features.course_studio is true in courseio_get_account). Only call it when the user asks to stop. Carrying on later means starting, and paying for, a new run; a stopped course can't be restarted over this connection: the user retries it in the CourseIO app. Returns the refunded credits. When nothing is running there is nothing to cancel and the call fails with an explanation; courseio_get_course shows the course's status.

courseio_create_course

ChatGPT
Creates the course a quote describes and starts generating it, charging the quoted lesson credits. Only call it after showing the user the quote from courseio_quote_course (cost and balance) and getting their go-ahead. Takes just the quote_id; to change the course, get a new quote. Safe to retry: calling again with the same quote_id returns the same course and charges nothing more. Generation then runs in the background for a while (the result says roughly how long): tell the user, and check progress later with courseio_get_course rather than waiting in a loop. The result links to the course in the CourseIO app.

courseio_export_course

ChatGPT
Builds a downloadable package of a finished course for a learning management system. Formats: scorm12 (SCORM 1.2, the most widely supported: Moodle, Canvas, Blackboard, TalentLMS, Docebo...), scorm2004, cmi5 (xAPI; needs an LMS with an LRS), common_cartridge (imports as native pages and quizzes: Canvas, Moodle, Blackboard, Brightspace, Schoology), moodle (SCORM + question bank XML + Common Cartridge with an import guide) or raw (just the files: MP4, SRT, PDF, PPTX, markdown, quiz JSON/XML). For Moodle prefer format moodle. video_mode: bundled puts every lesson video in the package (self-contained, large); youtube or vimeo embed the videos already published there from CourseIO (small package). Free (no credits). Building takes from seconds to several minutes; follow it with courseio_get_export, which gives the download link when it is ready. If an export of this course is already building, that export is returned instead of starting another (already_building: true).

courseio_get_account

ChatGPT
Who you are connected as in CourseIO: the organisation and user this connection acts for, the organisation's lesson credit balance, how lesson length turns into credits, and which optional features are on (Course Studio editing, AI presenters). Call it to see the credit balance, the credit rules, or whether Course Studio and AI presenters are on. It is free and changes nothing. Credits are only spent by paid tools, and only with a quote_id from the matching quote tool.

courseio_get_course

ChatGPT
One course in full: its status and generation progress, settings, cost per lesson, whether Course Studio can edit it now, and its modules and lessons (ids, titles, status, whether each has a finished video). While a course is generating, or after it failed, generation.steps shows each pipeline step's status. Use it after courseio_create_course to follow generation (it takes several minutes: check back now and then rather than in a tight loop), and to find lesson_ids for courseio_get_lesson. Free; changes nothing. Get course ids from courseio_list_courses. Not possible over this connection: retrying a failed course and renaming a course or its lessons. The user does those in the CourseIO app (app_url).

courseio_get_creation_options

ChatGPT
The choices available when creating a course: every supported course language (code and name), the allowed lesson length in minutes and how it maps to lesson credits, the AI presenters on offer (with their extra cost), and up to 20 narration voices for one language, recommended voices first. Use it before courseio_quote_course when the user wants to pick a language, voice or presenter, or to check what is allowed. Pass language to get voices for the course's language. Free; changes nothing. Narration voices are optional: without voice_id CourseIO picks a suitable one.

courseio_get_export

ChatGPT
Reports on an LMS export started with courseio_export_course (or in the CourseIO app): status (queued, processing, completed, failed, expired), progress 0-100 and, once completed, a download link for the package with its filename and size. The link works for an hour (expires_at); call this again for a fresh one. Packages are kept for 7 days (available_until); after that, export again. Read only.

courseio_get_lesson

ChatGPT
One lesson: its title, status and module, links to its finished media (video, poster image, captions, slides PDF, handout) and, only when asked for with include, its texts: the narration script, the slide deck (Marp markdown), the handout (markdown), the captions (SRT) and the module's quiz. Use it to show or review a lesson, or before editing one. Every text comes with its version (version 0 means the lesson has no such text yet), which is the base_version for editing it (Course Studio: courseio_update_lesson_content — available when features.course_studio is true in courseio_get_account). Quiz questions can't be edited over this connection: the user edits them in the CourseIO app. Ask only for the parts you need; texts can be long. Texts over 30,000 characters are cut short and marked truncated; never send a truncated text back as an edit. Media links expire after an hour (see media.expires_at): call this again for fresh ones. Free; changes nothing.

courseio_get_operation

ChatGPT
Reports on a Course Studio operation: a rebuild started with courseio_rebuild_lessons or a translation started with courseio_translate_course (also ones started in the CourseIO app). Gives its status (queued, running, succeeded, failed, cancelled), progress 0-100, the step it is on, each lesson's status, the credits charged and refunded, and for a translation the id of the new course. Operations take minutes: check again every minute or two rather than in a tight loop, and tell the user how it is going. Read only.

courseio_list_courses

ChatGPT
Lists the organisation's courses, most recently updated first, with their status, language, generation progress and how many modules, lessons and finished videos each has. Filter by status, language or a name search; results are paged (page, per_page up to 50). Use it to find a course_id for the other tools, or to answer "what courses do I have?". Free; changes nothing. For a course's modules, lessons and generation steps, call courseio_get_course with its course_id. Statuses: draft (not generated yet), generating (in progress), completed, failed (stopped or cancelled).

courseio_quote_course

ChatGPT
Prices a new AI-generated course before it is created: how many lesson credits it would cost, the organisation's balance and whether it can afford it. Returns a quote_id, valid for 30 minutes, which courseio_create_course needs. Nothing is created or charged. Always quote first, tell the user the course outline you are proposing (modules × lessons, lesson length, language, presenter) together with the credit cost and their balance, and only call courseio_create_course once they agree. A course has modules_count × lessons_per_module lessons (at most 40). Each lesson costs 1 lesson credit up to 6 minutes, 2 above, plus 1 with an AI presenter. To change anything, quote again: a quote is for exactly the course it describes. Use courseio_get_creation_options for language codes, voices and presenters.

courseio_quote_rebuild

ChatGPT
Works out what rebuilding lessons would cost after their text was edited (courseio_update_lesson_content) or their settings changed in CourseIO. A rebuild redoes only what the edits affect (re-recording the narration, remaking slide images, re-timing, rendering the video) and returns, per lesson, the credits, the steps in plain words and why. Charges nothing. Leave lesson_ids out to price every lesson with changes, or name the lessons to rebuild. Next: tell the user the total in lesson credits and their balance, and only if they agree call courseio_rebuild_lessons with this quote_id and the same lesson_ids. nothing_to_do: true means every lesson already matches its edits. Refused while the course is still generating. A lesson that has no video yet can't be built over this connection: the user builds it in Course Studio in the CourseIO app.

courseio_quote_translation

ChatGPT
Works out what translating a finished course into another language would cost. A translation makes a new, separate course in that language (the original is untouched): the scripts, slides, quizzes and handouts are translated and every lesson with a finished video is narrated and rendered again in the new language, priced like a new course of that many lessons. Charges nothing. Next: tell the user the cost in lesson credits and their balance, and only if they agree call courseio_translate_course with this quote_id and the same language. Refused while the course is still generating or when it has no finished lesson videos.

courseio_rebuild_lessons

ChatGPT
Rebuilds lessons after their content was edited, so their videos (narration, slides, captions, presenter) match the edits. Costs lesson credits: only call it after courseio_quote_rebuild, once the user has seen the price and agreed. Pass that quote_id and exactly the lesson_ids given to the quote (none for every lesson with changes). If anything changed since the quote, nothing is charged and the error gives the new price: show it to the user and call again with the new quote_id only if they agree. Repeating an identical call while the rebuild is running is safe: it returns the same operation and charges nothing more (already_started). The rebuild runs in the background for a few minutes per lesson; the lessons being rebuilt can't be edited until it finishes. Follow it with courseio_get_operation. Lessons that fail are refunded.

courseio_translate_course

ChatGPT
Makes a translated copy of a finished course in another language, as a new course (the original is not changed). Costs lesson credits: only call it after courseio_quote_translation, once the user has seen the price and agreed. Pass that quote_id and the same language. Optional: voice_id for the narration (from courseio_get_creation_options for that language; default: a CourseIO voice for the language) and name for the new course (default: "<course name> (<language>)"). If the price changed since the quote, nothing is charged and the error gives the new price: show it to the user and call again with the new quote_id only if they agree. Repeating an identical call while the translation is running is safe: it returns the same operation and charges nothing more (already_started). The translation and the new course's videos take a while (minutes per lesson). Follow the translation with courseio_get_operation, then the new course with courseio_get_course. If it fails, the credits come back.

courseio_update_lesson_content

ChatGPT
Replaces one text part of a lesson in Course Studio: the narration script, the slide deck (Marp markdown, slides separated by "---"), the handout (markdown) or the captions (SRT). content replaces the whole part, so send the complete new text, never a fragment or a diff. Before calling: read the current text and its version with courseio_get_lesson (include: [the part]) and pass that version as base_version. If someone saved the part since, the call is refused with the current version: read it again, re-apply the change and retry. Free (no credits). It changes the lesson's text only: the video, narration and slide images keep showing the old version until the lesson is rebuilt, which costs lesson credits. When the user is ready, price that with courseio_quote_rebuild and, after they agree, run courseio_rebuild_lessons. Captions and the handout need no rebuild: they apply straight away. Limits: script at most 12,000 characters (about 13 minutes of narration); slides at most 100,000 characters with at least one slide; handout at most 50,000; captions at most 200,000, valid SRT that ends within the lesson. Saving text identical to what is stored changes nothing. Refused while the lesson is being rebuilt or the course is still generating. Not possible over this connection: editing quiz questions, renaming the course or a lesson, and building a lesson that has no video yet. The user does those in the CourseIO app (app_url).

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/courseio"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/courseio)