MCP App Store
by KeenEthics
Ploxs Presentations icon

Ploxs Presentations MCP Server for ChatGPT

By Ploxs

Overview

Create editable Google Slides presentations from your notes or an outline. Use Ploxs to prepare meeting decks, project updates, proposals, and lessons; apply a saved brand style; and add charts and images. Review existing slides and revise their content and layout through chat. Presentations are saved to your connected Google account, with a link to open and continue editing in Google Slides. A Ploxs account and a connected Google account are required. Ploxs accesses only presentations authorized through that Google account.

How to connect

  1. ChatGPT: Open the Ploxs Presentations listing in the ChatGPT app directory and choose Connect. ChatGPT listing Ploxs Presentations exposes 38 tools here.

Tools

add_slides

ChatGPT
Insert new slides into an existing deck without replacing existing slides. Pass complete final HTML frames authored by the chat agent against get_presentation_frame_spec, including Chart.js graphs and Ploxs hosted icon placeholders. Ploxs validates, converts, and inserts them without AI design or infographic generation. Use insertion_placement before/after with anchor_slide_number, or end to append. MCP does not expose the legacy server-generated content path. Track the task before dependent edits; a failed multi-frame insertion can leave completed slides applied, reported in the task result. When this change adds or changes a Chart.js chart, call prepare_chart_editor first so the user can preview and edit it, place it as <canvas data-ploxs-chart-id="chart_N"></canvas>, and pass chart_session_id. For images the user supplied in the chat, royalty-free images the user picks, or AI images they review, call prepare_image_portal once with deck_ref. Wait until it is ready, place each with <img data-ploxs-image-id="presentation_image_N">, and pass asset_session_id.

connect_presentation

ChatGPT
Connect a user-selected Google Slides URL or file id to Ploxs for later edits, including decks Ploxs did not make. Does not edit slides or change sharing permissions. If Ploxs cannot open the file yet, it returns a short-lived link: give it to the user, who picks the exact file in Google's Picker, then call this again. For a deck Ploxs did not make, first call it with only the presentation: it returns an onboarding report (exact theme colours and fonts, every slide's text, slide images, a PDF link). Write a style_config that reproduces that deck and call again with it to finish connecting. A deck that is already connected keeps its saved style.

create_presentation_from_html

ChatGPT
Checklist step 4: validate and convert the complete FINAL HTML frame array into one NEW Google Slides deck, exactly as authored. Send every slide of the deck in this one call. Creation is credit-free because no AI model runs in this conversion path. Submit once - validation is built in and invalid frames queue nothing, so never send the same frames through a separate validation tool first. For images (chat attachments, royalty-free, AI), first complete prepare_image_portal, put its returned imageIds in <img data-ploxs-image-id="..."> elements, and pass its ready sessionId as asset_session_id. Under the user's "AI + royalty-free" image setting a new deck without images comes back with a warning. For the style, pass the style_ref returned by get_html_frame_spec; retyping style_config risks rejecting the whole authored deck. Initial creation only; later changes use editing tools on the deckRef.

delete_slides

ChatGPT
Delete the specified slides and their content from an existing deck. Only delete slides the user requested. This tool has no undo operation. Read the current outline to confirm the slide numbers before deleting; read it again before subsequent edits. Returns an asynchronous edit task; wait with wait_for_presentation_edit before dependent changes.

duplicate_slide

ChatGPT
Create a copy of one existing slide immediately after the original. Preserves the original slide. Slide numbers can change after duplication, so read the updated outline before dependent edits. Returns an asynchronous edit task; wait with wait_for_presentation_edit before dependent changes.

edit_chart

ChatGPT
Update one prepared chart in the private session returned by prepare_chart_editor. Overwrites the specified values, labels, or settings and can replace earlier user edits. When the chart has no prior user edits, the update also replaces its Reset baseline, so the previous version is not guaranteed recoverable. This tool does not change the live slide. When chartReview is review, changes after Done reopen review and placement must wait for Done again. Place the prepared result separately with replace_chart or with chart_session_id in edit_slide or add_slides.

edit_elements

ChatGPT
Make small changes to one existing slide's own elements in one step, with no redraw: text inside an element (replace_text with find and replace, or across the slide without element_id), an element's whole text (set_text), font size, weight, italics, underline, colour, and font (style_text), alignment (align), a shape's fill (fill), an element's place and size in stage px (move), and deleting an element (delete). Element ids, text, sizes, and places come from read_slide. Keeps everything it does not name; use it for a wording, size, colour, or position change instead of a new frame. Returns an asynchronous edit task; wait with wait_for_presentation_edit before dependent changes.

edit_slide

ChatGPT
Queue a replacement for a numbered slide in a user-authorized Google Slides file (for example, redesign slide 2). Pass the complete final slide HTML in html, authored by the chat agent against get_presentation_frame_spec; Ploxs validates it, resolves hosted icons, and converts it without an AI redesign. This changes the live Google file. Pass the prior creation jobId directly as deck_ref; track the returned task until it completes. When this change adds or changes a Chart.js chart, call prepare_chart_editor first so the user can preview and edit it, place it as <canvas data-ploxs-chart-id="chart_N"></canvas>, and pass chart_session_id. For images the user supplied in the chat, royalty-free images the user picks, or AI images they review, call prepare_image_portal once with deck_ref. Wait until it is ready, place each with <img data-ploxs-image-id="presentation_image_N">, and pass asset_session_id.

export_presentation

ChatGPT
Export a live deck as PDF or PPTX and get a short-lived download link to give the user. The link expires in minutes and the file is deleted within hours; call again for a fresh one. Not a way to read the deck yourself: use get_slide_images and read_slide for that.

generate_image

ChatGPT
Generate one hosted presentation image on Ploxs (uses the user's credits) and return its public URL, pixel dimensions, and actual aspect ratio. The chat agent decides where and how to use the image by placing the URL in authored slide HTML; this tool never redesigns or edits a slide. Choose the shape of the image slot first and request that aspect_ratio, then fit the result with object-fit:cover or a box using its returned aspect ratio, so the picture is never squeezed. For a NEW deck, pass the style_ref from get_html_frame_spec and place the URL in the frames before create_presentation_from_html. For an existing deck, pass its deck_ref so Ploxs uses that deck style and stores the asset with the deck. Only when reviewSettings.aiImageReview is auto (the default): under review the user checks every AI image's prompt before it is made, so Ploxs refuses this tool and the image goes on prepare_image_portal as an ai scene. Follow the IMAGES rules and generatedImages from get_account_status: add one on your own only when policy and sources allow AI images, do not overdo it, since each image costs credits, and a failed automatic image never stops the deck. For a real place, person, object, or scene, a royalty-free image the user picks for free may fit better, and when the user wants to see the prompt or add reference images, put the image on prepare_image_portal as an ai scene instead. Never tell the user they can check or edit a prompt first unless the image goes on the portal.

get_account_status

ChatGPT
Checklist step 1: check that Google Drive is connected, review credits, and read generatedImages before every new deck. Creating a deck from authored HTML frames, authored edits, and royalty-free images are credit-free; AI images (ai scenes on prepare_image_portal, or generate_image) use credits. generatedImages.policy decides whether you add images on your own (auto), let the user choose this deck's images on the style review page (ask_user), or add only images the user asks for (on_request); generatedImages.sources lists the sources you may use. reviewSettings says whether the user reviews the style (styleReview), chart edits (chartReview), and AI image prompts before generation (aiImageReview). Ploxs enforces all three.

get_chart_editor_status

ChatGPT
Check a chart editor session from prepare_chart_editor. Pass wait_seconds (for example 45) to wait while the user reviews; call again while it is still waiting. Each chart lists exactly what the user changed (type, text, values, colours, notes, lines) and the chart as it will be placed. A pie or doughnut with several series may draw them all side by side in one chart; it is still one canvas. Size each chart where you place it with width and height on its canvas, in px. When it is ready, re-check any slide text that describes the chart (a headline about a trend, a number in a caption) against the changes; notes and lines the user added are drawn on the chart, so do not repeat them as slide text; place each chart as <canvas data-ploxs-chart-id="chart_N"></canvas>, and pass the sessionId as chart_session_id to edit_slide or add_slides.

get_chart_spec

ChatGPT
Read only the Chart.js library URL, required capture rules, and a complete working HTML example in the connected deck style. Returned in both text and structuredContent so clients can read it even when the full frame spec is hidden or truncated. Author charts yourself; in an edit, pass the chart config to prepare_chart_editor so the user can preview and edit it, then place it as <canvas data-ploxs-chart-id="chart_N"></canvas> with chart_session_id in edit_slide or add_slides. Do not fall back to legacy infographic generation or fabricate data.

get_html_frame_spec

ChatGPT
Authoring contract for a new deck (checklist step 4): a catalog of composition patterns, the converter-safe CSS techniques, the icon mandate, the Chart.js protocol, and two worked frames that bracket the density range. Call get_account_status first, and once the user accepted a style review, pass its styleRef as style_ref. Call this ONCE, then think directly in HTML/CSS and put all FINAL frames straight into create_presentation_from_html in one pass. Keep the returned styleRef and pass it to create_presentation_from_html instead of re-sending the style config. The two examples are the ends of the range, not a template to copy. Do not narrate a prose slide plan, explain design choices, or print HTML in chat. Do not make a prototype or validation slide.

get_presentation_edit_status

ChatGPT
Get progress, results, partial batch results, or errors for a Google Slides edit task.

get_presentation_frame_spec

ChatGPT
Read the connected deck style, fixed slide geometry, Ploxs hosted icon contract, and Chart.js protocol before authoring a replacement or inserting slides. The full spec is returned as text and structuredContent, including charts.rules and charts.example by default. Use edit_slide with html for replacement or add_slides with frames for insertion. If a client truncates the spec, get_chart_spec returns just the chart instructions and working example.

get_presentation_image_upload_status

ChatGPT
Check progress for an image upload or royalty-free image picker session and get each image's source pixel dimensions; once it is ready, the result also shows each image as a small thumbnail under its scene heading (the user may rename scenes or add their own) so you can see what you are placing. Pass wait_seconds (for example 45) to wait while the user adds or picks images; call again while it is still waiting. When ready, place the imageIds as <img data-ploxs-image-id="presentation_image_N">, leave out skippedImageIds, and pass this sessionId as asset_session_id: to create_presentation_from_html for a new deck (checklist step 2), or to edit_slide, add_slides, or replace_image for an existing deck. Do not swap the images for generated ones.

get_presentation_outline

ChatGPT
Read the live numbered slides and text summaries from a user-authorized Google Slides file through the Google Slides API. Does not modify the presentation. Use before targeting a numbered slide for editing; slide numbers are 1-based. deck_ref accepts either the final deckRef or the ext_export_... creation jobId already present in the chat.

get_presentation_status

ChatGPT
Completion/status tool (checklist step 5), interchangeable with wait_for_presentation. Call it after create_presentation_from_html or to check an older queued deck. Each call waits up to 45s and returns stage, progress, errors, deckRef, and final Google Slides edit/view links. timedOut:true means STILL BUILDING, not failed - call this same tool again immediately. Pass 0 only for a bare snapshot.

get_slide_images

ChatGPT
Look at slides of a live Google Slides deck as images. Leave slides empty for a small image of every slide (an overview of up to 24), or name the slides to inspect closely. Images cost the user tokens, so this is not a routine check after every create or edit (results already carry a text LAYOUT CHECK): use it when the user asks to see or review the deck, reports something that looks wrong, or a warning and read_slide do not tell you enough about a slide. Name only the slides you need, then fix what you see with edit_slide. Named slides are drawn one by one and the overview from one export of the deck; a slide's image is reused until that slide changes. Each image also carries a short-lived link.

get_style_review_status

ChatGPT
Check a style review from prepare_style_review. Pass wait_seconds (for example 45) to wait while the user reviews; call again while it is still waiting. accepted: build with the returned styleRef, which carries the user's changes, passed as style_ref to get_html_frame_spec and create_presentation_from_html; never retype or adjust the style. rejected: do not build with it; ask the user to describe the style, attach a style guide, or share a website, write a new style from that, and call prepare_style_review again with previous_session_id.

list_presentations

ChatGPT
Use this when the user names a prior Ploxs deck but neither its deckRef nor its creation jobId is available in context. Find connected Google Slides decks and return reusable deckRefs for follow-up edits. Do not require this lookup when the same chat already has the creation jobId; edit tools accept that jobId directly.

list_style_configs

ChatGPT
List every style available to this account: manually saved styles, styles extracted from uploaded brand files, and styles used by recent decks. Call only when the user refers to one of those sources. Names are labels, not visual proof: inspect the full config and palette, use an id only for the user-selected match, and ask on ambiguity/conflict. Otherwise skip this potentially large result and craft a complete inline style_config; the destination tool validates it.

move_slides

ChatGPT
Move the specified existing slides before or after an anchor slide in the same deck. Preserves slide content. Slide numbers and the anchor are resolved against the current deck; the anchor cannot be one of the moved slides. Read the updated outline before dependent edits. Returns an asynchronous edit task; wait with wait_for_presentation_edit before dependent changes.

prepare_chart_editor

ChatGPT
Load a chart for an edit to an existing deck, and get a private page where the user can preview and edit it. Every chart an edit adds or changes goes through this. A specific change the user asked for ("make it a pie", "colour Store C teal"): make it yourself with changes; never ask the user to make it in the editor. Then follow the user's chartReview setting (get_account_status reviewSettings): review means give them the editorUrl and wait for Done, because Ploxs refuses to place the chart before that; auto means place it right away. On the page they can change its type (bar, horizontal bar, stacked bar, line, area, pie, doughnut, radar), orientation and stacking, title, legend (including where it sits), category and series names, axis titles, values, colours, number format, notes on the chart, and target or average lines. Free, no credits. Pass each chart as its Chart.js config in JSON (config: { type, data, options }), or as the script you already wrote (source), which Ploxs reads without running; functions such as tick callbacks are not kept, so pass format for prefixes, suffixes, and decimals. Give width and height: the chart's box on the slide, in px; the chart keeps that shape. To change a chart that is already on a slide when you do not have its config (a new chat, a deck built elsewhere), pass from_slide instead: Ploxs loads the chart as it was made, and after Done you put it back into the same picture with replace_chart with chart_id and chart_session_id, with no slide HTML. Pressing Done sends the charts and closes the page; for later changes, open a new editor. Give the user the returned editorUrl, author the slide meanwhile with each chart as <canvas data-ploxs-chart-id="chart_N"></canvas> (no script), then call get_chart_editor_status and pass the sessionId as chart_session_id to edit_slide or add_slides. Ploxs places each chart exactly as the user left it. Creating a new deck does not use this tool: author Chart.js in the frames as usual.

prepare_image_portal

ChatGPT
Open one private page, the image portal, for every image a deck needs. Pass one scene per image, each of one kind: upload (an image the user supplied in the chat, with its filename; or, with no filename, one that should be the user's own, whose card opens ready for them to add it), stock (a royalty-free image the user picks; free), or ai (an AI image: you write the prompt, and the user may edit it, add up to 4 reference images, and generate it; uses credits). On the page the user fills each scene, may skip any, turn a royalty-free scene into an AI image or back, upload their own for any, rename scenes, or add scenes of their own, then presses Done. AI scenes need the deck style: pass style_ref from get_html_frame_spec for a new deck, or deck_ref for an existing one; pass it with any scenes so the user can add AI images too. Give the user the returned portalUrl, author the frames meanwhile with <img data-ploxs-image-id="presentation_image_N"> in fixed boxes, then wait with get_presentation_image_upload_status, and pass the sessionId as asset_session_id: to create_presentation_from_html for a new deck, or to edit_slide, add_slides, or replace_image for an existing one. Follow the IMAGES rules and generatedImages from get_account_status. Under reviewSettings.aiImageReview review, every AI image goes here, even a single one the user asked for: generate_image refuses. Call them royalty-free images when talking to the user, never stock photos.

prepare_presentation_image_upload

ChatGPT
Compatibility tool: use prepare_image_portal instead when you have it, which takes these images as upload scenes on the same page as the deck's royalty-free and AI images. Create one upload link for images the user supplied in the chat, including images generated earlier in the chat. Pass their filenames once each, plus one short description of what each image shows. The upload page lists each image by its description, and the user chooses the file for each one under any filename. After all files are ready, place the returned imageIds as <img data-ploxs-image-id="presentation_image_N"> and pass sessionId as asset_session_id. For a new deck, pass it to create_presentation_from_html and do not postpone the images to a later edit. For an existing deck, pass it to edit_slide, add_slides, or replace_image with the same deck_ref; never create a new deck for this. Never generate replacements for supplied images.

prepare_stock_image_picker

ChatGPT
Compatibility tool: use prepare_image_portal instead when you have it, which takes these as stock scenes on the same page as the deck's other images. Open a private page where the user picks royalty-free images from Unsplash, Wikimedia Commons, or Pixabay for the images you want; free for the user, no credits. Pass one entry per image: the scene, its slide and how it is used there, a search, and whether it is a Commons subject. The page shows each image as a scene card with your scene as its heading above its search results (Unsplash first, Wikimedia Commons for a Commons subject; the user can switch any card), and the user picks an image for each, refines the search, uploads their own instead, or skips it; they may also rename a scene or add scenes of their own, then press Done. You do not choose the images; once they are ready, get_presentation_image_upload_status shows you each one as a thumbnail under its scene heading. Call them royalty-free images when talking to the user. Give the user the returned pickerUrl, author the frames meanwhile with <img data-ploxs-image-id="presentation_image_N"> in fixed boxes, then wait with get_presentation_image_upload_status and pass the sessionId as asset_session_id: to create_presentation_from_html for a new deck, or to edit_slide, add_slides, or replace_image (using image_id) for an existing one. Follow the IMAGES rules and generatedImages from get_account_status.

prepare_style_review

ChatGPT
Checklist step 3: the page where the user reviews a NEW deck's style before any slide is built, when reviewSettings.styleReview calls for it; with generatedImages.setting ask it also asks which images to add. get_html_frame_spec and create_presentation_from_html refuse until it is accepted whenever the settings call for a review. Free, no credits. Pass the style you would build with: a complete inline style_config, a style_config_id, or a style_ref. The page shows it on sample slides made from deck_title and preview (use the deck's real title and two to four of its real points and numbers), with the palette, fonts, layout, icon packs, and art direction each editable. Give the user the returned reviewUrl, then wait with get_style_review_status. After a rejection, ask how they want the deck to look, write a new style, and call this again with previous_session_id.

read_slide

ChatGPT
Read the exact structure of one slide of a live deck: every element with its id, kind, position and size in stage px, placeholder role, text with its fonts, sizes and colors, image crops, table cells, the slide background, layout, and speaker notes. Theme colors and inherited placeholder styles are resolved to the values you see. Use it with get_slide_images to recompose a slide faithfully, and use the element ids for native edits in replace_text, replace_image, or edit_elements.

replace_all_text

ChatGPT
Find and replace matching text across a deck or only the specified slide_numbers. Set match_case when needed. Overwrites matching text and preserves unrelated content. Use slide_numbers to limit the change when the user names particular slides. Returns an asynchronous edit task; wait with wait_for_presentation_edit before dependent changes.

replace_chart

ChatGPT
Place one prepared chart into an existing slide picture, overwriting that picture and preserving the rest of the slide. Supply chart_id and chart_session_id from prepare_chart_editor. A chart loaded with from_slide retains its target; otherwise specify both slide_number and element_id from read_slide. Required chart review must be complete before placement. Returns an asynchronous edit task; wait with wait_for_presentation_edit before dependent changes.

replace_image

ChatGPT
Replace one image element in an existing slide, preserving its frame and other elements. The new image is centre-cropped to the existing frame and overwrites the previous image. Get element_id from read_slide. Supply exactly one of image_url or image_id; image_id requires a ready asset_session_id from prepare_image_portal. Returns an asynchronous edit task; wait with wait_for_presentation_edit before dependent changes.

replace_text

ChatGPT
Replace the complete text of one element in an existing slide. Get its element_id from read_slide. Keeps the first text run's font, size, and colour and preserves other elements. Overwrites the element's previous text. Returns an asynchronous edit task; wait with wait_for_presentation_edit before dependent changes.

set_speaker_notes

ChatGPT
Replace all speaker notes for one existing slide with the supplied text. An empty string clears the notes. Overwrites previous notes and leaves visible slide content unchanged. Returns an asynchronous edit task; wait with wait_for_presentation_edit before dependent changes.

validate_style_config

ChatGPT
Optional diagnostic for a style configuration after a config error or when the user explicitly asks to inspect it. Normal creation tools validate style_config before queueing, so do not duplicate a valid-looking config through this tool as routine preflight. Put durable brand/art direction in brandGuidelines and customStyleDirective, derived from the deck's subject rather than a default look.

wait_for_presentation

ChatGPT
PRIMARY completion tool (checklist step 5), restored for client and connector compatibility. Call it immediately after create_presentation_from_html returns a jobId. Each call waits up to 45s and returns final Google Slides edit/view links when done. timedOut:true means STILL BUILDING, not failed - call this same tool again immediately. get_presentation_status is an interchangeable fallback if this name is unavailable.

wait_for_presentation_edit

ChatGPT
Wait for a Google Slides edit or batch update to complete or fail. It reports complete as soon as the change is in Google Slides; Ploxs finishes it in the background and the next change to the deck waits for that by itself. timedOut:true means still running, not failed: call again with the same task_id.

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/ploxs-presentations"><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/ploxs-presentations)