Overview
Creator ships a built-in MCP (Model Context Protocol) server. Any MCP-capable AI assistant — Claude on claude.ai, Claude Code, MCP Inspector — can connect to your Creator account and, from a chat, do everything the editor does:
- Browse your workspace and organizations
- Create folders, courses, microlearnings and question banks
- Add, edit, move and delete lessons and all 46 brick types with their full configuration
- Manage the organization's theme library and choose each content's theme (colors, fonts, cover, custom CSS)
- Export to SCORM, web or PDF, export the question bank (GIFT, Moodle XML or QTI 2.1), publish share links, manage snapshots, duplicate and translate
Authentication uses OAuth against your SLXD account: the assistant never sees your password and you can revoke access at any time. Everything the assistant does is limited to what your user can do — organization membership and roles are enforced on every call.
Connecting
The MCP endpoint is your organization's connector URL:
https://<your-organization>.slxd.app/mcp/creator
You don't have to build it by hand: the SLXD platform lists it under Organization > Connectors, next to the connectors of the other products in the suite.
claude.ai
- Go to Settings > Connectors > Add custom connector
- Paste the endpoint URL
- Complete the sign-in and authorize the access
Claude Code
claude mcp add --transport http creator https://<your-organization>.slxd.app/mcp/creator
The first call opens the browser to sign in and authorize.
Clients register themselves automatically (OAuth dynamic client registration) — there is nothing to configure server-side.
How the tools work
The server exposes a curated set of top-level tools (workspace browsing, content/lesson CRUD, bricks, theme, export, file uploads, duplicating a content) plus three meta-tools that unlock the full catalog:
browse_workspace covers three needs: browse one folder level, search the whole scope by title/name with query, or map the entire folder tree in a single call with recursive: true (every folder with its parentId). To clone a content — lessons, bricks and assets — as a template, use duplicate_content (top-level); duplicate_lesson does the same for a single lesson.
Beyond authoring, the catalog also covers: full trash lifecycle for folders (restore_folder, delete_folder_permanently) and batch content ops (batch_move_contents, batch_trash_contents); copying a content to another space, always a copy and never a move (copy_content_to_tenant); version management (rename_snapshot, delete_snapshot); searching licensed stock libraries and importing an asset under a content (search_stock_images/import_stock_image, search_stock_icons/import_stock_icon); and auditing and fixing accessibility issues (see below). Media the model generates itself is uploaded with request_asset_upload.
| Meta-tool | Purpose |
|---|---|
find_tools | Search the whole catalog by keyword (publishing, snapshots, translation, templates, trash…) |
tool_schema | Get the input schema of any catalog tool |
run_tool | Execute a catalog tool by name |
For bricks, list_brick_types lists every type grouped by category (text, media, collections, questions, games, lesson structure — structure) with a "when to use" hint to pick the right one for a teaching goal, and get_brick_type_schema returns the exact authoring shape (with an example) for each one — rich text is authored as plain HTML. Inline code (<code>) works in every multi-line text field and code blocks (<pre><code class="language-…">, the language kept) in full-format ones (get_brick_type_schema lists them under richText); single-line fields reject both with an error naming the field. What is saved but changed on the way —a tag, attribute or style the editor cannot keep, a link in a field without links, paragraphs joined in a single-line field— comes back in the add_brick and update_brick result under warnings, field by field, so there is no need to re-read the lesson to find out.
The structure category holds the CONDITIONAL type (Conditional content): add_brick takes its branches and their bricks in one call, get_lesson returns the bricks nested inside each branch, and update_brick, move_brick and delete_brick work on the whole group. The condition grammar and the rules (one level, never in exams or banks) are in Conditional Content; the manifest and messages of the simulations it reads are in Embed Packages and Simulations.
Choosing the right brick
To help the assistant pick the most appropriate brick, list_brick_types carries per-type "when to use" guidance, and the creator://guides/brick-selection resource is a full selection guide (intent → recommended bricks). Both are generated from the same source, so they never drift, and both work in any MCP client.
Themes
Themes live in the organization's theme library and each content uses one. Several contents can share the same theme, so changing a theme changes every content that uses it.
| Tool | What for |
|---|---|
list_themes | See the library's themes, how many contents use each one and which is the default theme (the one new contents get) |
get_theme | Read a theme by contentId (the one that content uses) or by themeId. It also returns its version and how many contents use it |
get_theme_schema | See what a theme can hold, without reading any theme: for each field, its exact path, the form it takes (one length or up to four, a colour as text such as palette:accent in brick styles or as {"paletteId": "accent"} elsewhere, options, ranges), its default value or the field it takes its value from, what it changes on screen and the brick types that use it. Without filters it lists the sections and what the theme cannot change (with the alternative); filter by section, by brickType (e.g. TIMELINE) or by text with search |
update_theme | Change a theme by contentId or by themeId. It affects every content that uses it, and the response says how many (affectedContents). If you pass the version you read and someone else changed the theme in the meantime, nothing is saved and you have to read it again. What it saves differently from how it arrived, or with a problem, comes back in warnings, field by field: a field that does not exist (with the closest one), a value in another form (with the form that field takes, as get_theme_schema gives it) or out of range, a value saved another way, what it drops from a custom font (only regular, regularItalic, bold and boldItalic, weights 400 and 700) and, if the colours change, a “Text on accent” that does not reach AA contrast (4.5:1) with the accent; without a value of its own, that text uses the text colour |
create_theme | Create a theme: with the default look, from a preset, or as a copy of another theme or of a content's theme |
set_content_theme | Choose a content's theme |
apply_theme_preset | Give a content the look of a preset: it gets a library theme identical to the preset, which is created if there is none |
reset_theme | Put the organization's default theme back on a content |
delete_theme | Delete a theme that no content uses (not even in the trash) and that is not the default theme |
To change the look of a single content whose theme others share, copy its theme (create_theme with fromContentId), give it the copy with set_content_theme and edit the copy. Changing a content's theme does not modify the one it stops using: it stays in the library. import_theme_from_content no longer exists: using another content's theme means choosing it with set_content_theme.
Anyone who can edit contents in the organization can edit its themes.
Uploading files
Creator content uses files — images, video, audio, subtitles, downloadable attachments, custom fonts, embed packages — and the MCP can upload them. The binary never travels through the MCP (no base64): the tool mints a short-lived presigned upload URL and the client sends the file straight to storage, out of band.
The flow for a brick asset:
- Call
request_asset_uploadwith the targetcontentId, thekind(image|video|audio|subtitle|attachment|font) and the file'scontentType(e.g.image/png). For a theme file (logo, lesson header image, icons, customwoff2fonts), passthemeIdinstead ofcontentId: the file stays with the theme and does not depend on any content; onlyimageandfontare accepted. Each kind has a MIME allowlist, so a mismatched type is rejected up front. - The tool returns
{ uploadUrl, path, curlCommand, expiresAt }. Upload the file — run the returnedcurlCommand(replacing<local-file>with the real path) orPUTthe bytes touploadUrlwith the exactContent-Type. The URL expires after 15 minutes. - Put the returned
pathinto the brick's media field viaadd_brick/update_brick(imagePath,videoPath,audioPath,filePath,posterPath,subtitlesPath,front*/back*/…), or into the theme viaupdate_theme(logo, customwoff2fonts), with the samethemeId. The cover image and the course title belong to each content, not to the theme: upload the image with thecontentIdand set it withupdate_content(coverImagePath;courseTitlefor the course title);get_contentreturns them. To replace the cover image, put the new path incoverImagePath: the image changes and the course title and the overlay stay as they were; the previous file is not deleted, the storage sweep collects it. The image overlay and the course title's position and styles stay in the theme. The lesson header image also belongs to the content: set it withupdate_content(lessonHeaderImagePath) and the theme shows it withlessonHeader.background.type: image; each lesson can carry its own withupdate_lesson(headerImagePath;nullinherits again), which always wins. The veil stays in the theme (lessonHeader.image.overlay).
list_content_assets returns the files already uploaded for a content, so an existing asset can be reused instead of uploaded again.
SVG images are the one exception: an SVG is code, so it is never uploaded through a signed URL (request_asset_upload refuses image/svg+xml). Send it with upload_svg_image instead — the SVG travels in the call, as text (svg) or base64 (svgBase64), up to 5 MB, with contentId or themeId. The server sanitizes it with the same rules as the editor (scripts, event attributes, external links and resources are removed) and stores only the result; use the returned path in any image field. If it cannot be read safely, nothing is stored and the error carries a stable code: [svg_not_svg], [svg_malformed] or [svg_too_large]. An SVG is always shown as an image, which loads no font from outside: if its text does not embed its font (or is not converted to outlines), the result carries a svg_text_without_font warning and the text will use whatever font the learner's device has. The stock libraries (import_stock_icon, import_stock_image) sanitize SVGs the same way. import_stock_image only accepts a downloadUrl exactly as search_stock_images returned it, with the same provider, and only stores images: the type is read from the downloaded bytes (PNG, JPEG, WebP, GIF, AVIF or a sanitized SVG, up to 30 MB), never from the URL or the Content-Type. Anything else stores nothing and fails with a stable code: [stock_url_not_allowed], [stock_not_image], [stock_too_large], [stock_blocked_target] (a redirect to a non-https or internal address) or [stock_too_many_redirects].
Embed bricks (a self-contained index.html + assets package) use request_embed_upload: upload each file of the package under the same folderId, then set the returned embedFolderPrefix on the EMBED brick. These land in the private embeds bucket with their Content-Type pinned, and are served to viewers through short-lived, per-folder URLs — never from a public domain. For the package to complete the brick (and so honour its blocker) or set its own height, also upload a slxd-embed.json at its root —e.g. {"protocol":"slxd-embed","version":1,"capabilities":["complete","resize"]}— before setting the folder on the brick: it is read when the folder is written and kept in the read-only embedPackage property. add_brick and update_brick warn (warnings) when the blocker cannot be honoured. For a simulation, also declare state, result and interaction, and write simulationId (unique within the content: a repeated one is rejected), scored and weight on the brick — get_brick_type_schema describes the protocol and the scoring; a brick written before the package declared the new capabilities needs its embedFolderPrefix written again to re-read the manifest. Its slxd-embed.json may also declare the variables of its state, with their type ("variables": {"trust": "number", "reused": "boolean"}), for conditional content to read them; grade, score, maxScore, ending and kind are reserved names (they always read the package's result) and a package that declares them as variables is not accepted when uploaded. The manifest, the messages and their limits are explained in Embed Packages and Simulations.
Imports follow the same presigned pattern:
- Articulate Rise —
start_rise_import(upload the.zip) →confirm_rise_import→ pollget_rise_importuntilcompletedto read the createdcontentId.
Document import (Import document) is intentionally not exposed over MCP: its parse step depends on browser-side extraction in the app, so the flow can't complete headlessly — do it in the app.
All upload tools authorize the target content or theme (scope + organization membership; for a theme, also permission to edit themes) before signing, and the server builds the storage key — a client never supplies a raw path.
Accessibility
The same WCAG 2.2 checker that powers the editor's accessibility checker is exposed over MCP, so an assistant can review and fix a course end to end:
audit_content_accessibility— error/warning counts per lesson across a content. Start here for a course-wide overview.audit_lesson_accessibility— every issue in one lesson: the rule, the WCAG criterion, the affected brick, a reason and remediation text (in the content's language), and — when a safe fix exists — anautofixesdescriptor.apply_accessibility_autofix— applies one of those descriptors (mark an image decorative, fix a heading level, enable a table header, …) to the exact brick/item. One undo step; changes reach an open editor in real time, same asupdate_brick.generate_accessibility_alt_text— for images with no safe deterministic fix, sends the image to the configured AI vision model and returns suggested alt text. It does not write anything — apply the result withapply_accessibility_autofix(kind: "set-property", or"set-item-property"/"set-character-property"for gallery/dialog images). Consumes organization credits, like other AI tools.
A typical flow: call audit_content_accessibility, pick a lesson with issues, call audit_lesson_accessibility on it, apply the deterministic fixes, generate and apply alt text for the rest, then re-run the lesson audit to confirm it's clean.
Instructional design
An assistant can build and check a whole instructional design — for example, rebuild one from an Excel file you give it. The tools start with design_matrix_. design_matrix_create, design_matrix_get, design_matrix_list, design_matrix_validate and design_matrix_generate_course are top-level; the rest are reached through find_tools and run_tool.
| Tool | What for |
|---|---|
design_matrix_create | Create a design: name, duration, level, audience, language (idioma; by default, your account's) and the structure pattern (fixed once chosen) |
design_matrix_get | Read the whole design in one call — details, competencies, objectives, structure tree and activities — with the ids you need for any edit |
design_matrix_list | List designs, or the trash with inTrash: true |
design_matrix_update, design_matrix_delete, design_matrix_restore | Edit the details (its language too); move a design to the trash and bring it back (deleting it for good is only in the app) |
design_matrix_competencia_create, _update, _delete, _reorder | Competencies |
design_matrix_objetivo_create, _update, _delete, _set_competencias, _reorder | Objectives, with their Bloom level, their visible key (clave, optional) and the competencies they serve |
design_matrix_node_create, _rename, _update_horas, _update_objetivo_general, _set_rol, _reorder, _move, _change_level, _subdivide, _delete | The structure tree: modules, units, sections and subsections; _set_rol marks a section as its unit's introduction or summary |
design_matrix_node_link_objetivo, design_matrix_node_unlink_objetivo | Link an objective to a leaf of the tree, or unlink it |
design_matrix_aa_*, design_matrix_ae_* (create, update, delete, set_objetivos, reorder) | Learning activities (aa, of a unit or a section) and evaluation activities (ae, of a unit), and the objectives they serve |
design_matrix_validate | Run the same checks as the app's Validation panel and read each finding as a sentence, in the design's language or the one you ask for (locale) and with the title of the item it refers to |
design_matrix_export | Get a signed download link for the Excel workbook (.xlsx), with labels in the design's language or the one you ask for (locale); the link expires after about 24 hours |
design_matrix_generate_course | Create the courses from a design that passes validation, in the design's language unless you ask for another (locale). Only one generation at a time per design; if one stops halfway, asking again with the same scope picks up what was missing without duplicating courses. With leccionActividades and leccionesEvaluacion (true, false or "separadas") you choose, as in the app's dialog, whether the activities lessons are created and where the quizzes go |
design_matrix_redaccion_status | See how the AI writing of the generated courses is going, and whether the generation is still running, without using credits |
design_matrix_review_context | Get the material to review the wording and alignment with the assistant's own AI model: the same criteria as the app's AI review, without using credits |
design_matrix_dictamen_submit | Register the assistant's findings as pending reviews, labelled "Agent review" in the app's AI review section; nothing in the design changes until you accept them there. Without using credits |
design_matrix_dictamen_list | List a design's review findings, from the app's AI or from the assistant, and their status |
Deleting a design, node, competency, objective or activity needs confirm: true, like any other destructive action. The app's own AI review and the AI writing of generated courses are not available over MCP — they use credits and need the on-screen confirmation — so do them in the app; the writing status can be checked with design_matrix_redaccion_status. Your assistant can do the review itself instead, with its own AI model and without using credits: it asks for the material with design_matrix_review_context and registers its findings with design_matrix_dictamen_submit. They appear in the app's AI review section labelled "Agent review", pending until you accept, correct or dismiss them there.
The tools that replace a whole set of links (design_matrix_objetivo_set_competencias, design_matrix_aa_set_objetivos and design_matrix_ae_set_objetivos) accept expectedUpdatedAt, that item's updatedAt as design_matrix_get returned it: if someone has changed it in the meantime, the call is rejected without writing anything and the assistant knows it has to read it again.
The design's updatedAt returned by design_matrix_get and design_matrix_list changes with any edit to its content —competencies, objectives, structure, links, activities or hours—, not just its details: comparing it tells you whether anything has changed since your last read.
Live collaboration
Brick edits made through MCP are merged through the collaboration server: if someone has the lesson open in the editor, they see the assistant's changes appear in real time, and nobody's work is overwritten.
Destructive actions
Deleting content, lessons, bricks or themes, going back to the default theme, restoring snapshots and emptying the trash all require an explicit confirm: true. Without it, the tool answers with a preview of what would happen so the assistant can ask you first.
Operations notes
- The OAuth authorization server is part of the app (Better Auth
mcpplugin); tokens live in theoauth_*tables and expire after 1 hour (refresh tokens: 7 days). - The endpoint is rate-limited per user (120 requests/minute).
- When billing is enabled, MCP access is gated by the plan's
apiAccessfeature, exactly like API keys.