ChatGPT Plugin

Mindomo

Create mind maps

Brand: Unknown

Category: Pending
Primary Subcategory: Pending

Integration details

Description

Mindomo helps users find, view, create, edit, theme, export, and manage mind maps and smart diagram templates from ChatGPT. Diagram preview tools can render an inline ChatGPT widget that fetches and mounts Mindomo's read-only viewer directly in the widget document, while the server enforces account permissions, plan gates, rate limits, and per-tool scopes.

Integration type: Plugin
Verification status: Not applicable
Platform: ChatGPT
Category: Pending
Primary Subcategory: Pending
Secondary Subcategories: None listed
Brand: Unknown
Access: Account required
First tracked: 2026-10-15
Tool count: 24
Geography: US

Agent DiscoverabilityChatGPT Plugin Discovery Score

ChatGPT organic discovery is live

Your score is coming

ChatGPT now suggests Plugins on its own when they match a user's request.Your Plugin Discovery Score measures how often yours appears, and it will show here as soon as it’s ready.

ChatGPT recommends Airtable when a user asks it to update a CRM. — ChatGPT surfaces Airtable because it matches the user's request.

Primary Subcategory

Competitive lineup

No Primary Subcategory assigned yetOnce Mindomo has a Primary Subcategory, the Plugins and Connectors it competes with will appear here with their scores.

Tools

24 tools agents can invoke

Apply a theme to a diagram — restyles the whole map (topics without a per-topic style override) to the theme's look. Provide the diagram GUID and a theme GUID (from list_themes). Applies the theme's visual style; it does not switch the map's layout.
apply_theme
Create an ENTIRE diagram in ONE call: its title, the full nested topic tree, and (optionally) relations, boundaries, summaries, a theme (themeId — styles the map in the same call, no separate apply_theme), and TEMPLATE-map content (per-topic 'template' settings + 'templateTopics' prototype trees linked via template.prototypeRefs; finish with edit_diagram_template for the map-level template settings). The fastest way to build a map from scratch — prefer this over separate create_diagram + edit_* calls. There is NO server topic limit — send the WHOLE map, even 1000+ topics with relations/boundaries/summaries, in a single call; the server creates it atomically. IMPORTANT: this CREATES A NEW diagram every time — call it exactly ONCE per map. If a map is too large to emit in one tool call, build the core here, then EXTEND THE SAME diagram with edit_topics(op=create, diagramId=<the returned diagramId>) — do NOT call build_diagram again for the same map (that would make a second, separate diagram). Topics have no ids yet when you write the request, so to anchor a relation/boundary/summary put a unique 'ref' on the branch and reference that ref. Main topics are automatically balanced across the left and right sides of the central topic. Returns the diagram id, link, rootTopicId and per-entity counts. LIMITATION — branches here carry TITLES ONLY (plus nested subtopics and 'template' settings). TASK DATA (deadlines/due dates, priority, progress, duration, assignees, milestones), topic notes/descriptions, icons, links and per-topic styling are NOT accepted by this tool and are SILENTLY IGNORED if you send them. If the map needs ANY of those — above all tasks or deadlines — do NOT use build_diagram: call create_diagram {title, themeId} and then ONE edit_topics {op:"create", branches:[…]}, whose branches take the FULL Topic shape including 'task'. Same two-call cost, and the data actually lands. Never fake a task or a deadline by writing "TASK: …" or "DEADLINE: …" into a title here.
build_diagram
Create a new empty diagram (a plain mindmap with a single root topic) from a title, in the user's root folder with the default theme. Returns the new diagram's metadata (its id is the GUID) including link (a clickable URL that opens the new diagram) and rootTopicId (the central topic's shortId). Use rootTopicId to update the central topic — you do NOT need to call read_diagram just to find the root; and edit_topics op=create with no parentId already adds under the root automatically. Pass themeId to style it in the same call. This tool plus ONE edit_topics {op:"create"} is the way to build a map that needs TASK DATA (deadlines, priority, progress, assignees, milestones) or topic notes/icons/styling — build_diagram cannot carry any of those.
create_diagram
Move a diagram to the recycle bin (a recoverable soft delete — the same as deleting from the dashboard; NOT a permanent erase — the recycle bin keeps it for 30 days). Provide the diagram GUID. Only the owner (or a user with delete rights) can delete. Deleting an already-deleted diagram is a no-op. Returns the resulting status.
delete_diagram
Create, update or delete boundaries (contours grouping anchored topics) in a diagram. Choose the operation with 'op': • op=create — add boundaries. Provide 'boundaries', each with anchorTopicIds (at least one existing topic shortId) and optional style/label. Returns new boundary shortIds. • op=update — change boundaries. Provide 'boundaries', each with its id (shortId) plus the fields to change (shape/anchors). • op=delete — remove boundaries. Provide 'ids' (boundary shortIds). WHEN to add one: boundaries are OPT-IN — default to none. Add one only when the user asks to group/highlight a set of topics, or when the grouping is genuinely NOT already expressed by the tree; topics that share a parent are already grouped by that parent. All ids are shortIds.
edit_boundaries
Create, update or delete comments on a diagram's topics. Choose the operation with 'op': • op=create — add comments. Provide 'comments', each with topicId (existing topic shortId) and text. Returns the new comment ids; author and date are set by the server. • op=update — change a comment's text. Provide 'comments', each with topicId, id and the new text. • op=delete — remove comments. Provide 'comments', each with topicId and id. topicId is a topic shortId; a comment id is an opaque id returned by a read or a create.
edit_comments
Change THIS diagram's own visual style directly (no theme): background fill color, alternate-colour palette, and/or background image (url/fit/opacity/blur). Supply only the parts to change. Note the palette recolours the branch CONNECTOR lines here; making the topics themselves take their branch colour is a per-level fill setting, which only a theme carries — so for "filled topics in different colours" author a theme with edit_themes instead. To restyle via a reusable theme, use apply_theme.
edit_diagram_style
Turn a diagram into a reusable smart TEMPLATE map, or edit its template settings (merge-patch: send only the fields to change). Setting ANY field makes the map behave as a template — there is no separate map type. Fields: welcome-screen title/description/image, readOnly (the map opens in guided fill-in template mode instead of the free editor), hideWiki (hide the wiki help panel), cloneReadOnly and published — the last two need map admin + publish rights; published is scoped to the current user and does not make the template globally public. LIFECYCLE: the AUTHOR keeps readOnly:false (freely editable, template affordances visible) and sets cloneReadOnly:true; when a user picks 'use template', the map is CLONED and the copy gets readOnly=true from cloneReadOnly — it opens in guided fill-in mode where only placeholders and prototype inserts are interactive. Topic-level smart-template behavior (placeholder text, wiki help, fixed/placeholder/locked type, repeatable prototype branches) is edited with edit_topics via each topic's 'template' property; read the prototype trees with read_template_branches.
edit_diagram_template
Create, update or delete relations (concept-map links) in a diagram. Choose the operation with 'op': • op=create — add relations. Provide 'relations', each with startTopicId + endTopicId (existing topic shortIds) and optional label/stroke/markers/routing. Returns new relation shortIds. • op=update — change relations. Provide 'relations', each with its id (shortId) plus the fields to change (endpoints and/or style). • op=delete — remove relations. Provide 'ids' (relation shortIds). WHEN to add one: relations are OPT-IN — add them only when the user explicitly asks for connections / dependencies / flow / a concept map, and only when the link carries information the topic hierarchy does NOT already express (cause→effect, dependency, cross-reference). Do NOT relate MAIN topics (the direct children of the central/root topic) to each other — a mind map already connects them through the central topic, so those relations are redundant clutter. Prefer DEEPER topics in NEIGHBOURING branches: main topics sit half-right / half-left of the centre, so a link between distant branches is drawn as a long line across the whole map. All ids are shortIds.
edit_relations
Create, update or delete summaries (a brace over anchored topics plus a callout topic) in a diagram. Choose the operation with 'op': • op=create — add summaries. Provide 'summaries', each with anchorTopicIds (at least one existing topic shortId) and an optional callout topic/style. Returns each summary's id and its callout shortId. • op=update — change summaries. Provide 'summaries', each with its id (shortId) plus the fields to change (brace shape/anchors). To change a callout's text, use edit_topics (op=update) on the callout topic. • op=delete — remove summaries. Provide 'ids' (summary shortIds). WHEN to add one: summaries are OPT-IN — default to none. Add one only when the user asks for a summary/conclusion, or when the callout states something genuinely NEW that the spanned topics do not already say. All ids are shortIds.
edit_summaries
Create, update, clone or delete a theme — the single tool for theme authoring. Choose with 'op': • op=create-from-recipe — THE EASY PATH, use this by default. Provide 'recipe': describe the LOOK (palette, how many levels are filled, shape, connector) and the server builds the whole style tree. Returns the new id plus 'resolvedTheme' and a one-line 'summary'. • op=update-from-recipe — provide 'themeId' + 'recipe'; re-synthesizes that theme seeded from its CURRENT look, so a partial recipe acts as a patch (e.g. recipe={palette:{name:'ocean'}} recolours it and keeps its shapes, spacing and fonts). • op=create — provide 'theme' (a raw MapThemeJSON) when you need pixel-level control the recipe cannot express; returns the new theme id. • op=update — provide 'themeId' + 'theme'; FULL REPLACE of that theme (get_theme it first, modify, send back). Returns the id. • op=clone — provide 'themeId'; duplicates ANY theme (built-ins included) into your own editable copy and returns the new id. The fastest starting point when the user likes an existing look: clone it, then op=update the copy. • op=delete — provide 'themeId'. Only the user's own themes are editable (built-in gallery themes are read-only). Creating a theme does not apply it — call apply_theme, or pass recipe.applyToDiagramId to do both in one call. AUTHORING A THEME BY HAND (op=create/update). Only needed when op=create-from-recipe cannot express what you want — that op covers "vibrant colours, filled main topics, transparent rest" with {"palette":{"colors":[…]},"filledLevels":2}. If you do write the tree yourself: a theme is one canvas + one ALTERNATE-COLOUR palette + one style entry PER DEPTH. Three steps: (1) diagram.alternateColors.colors = the branch colour cycle (this is what "different colours per branch" means); diagram.fill.value = the canvas colour. (2) For every level you want FILLED with its branch colour, set that topics[i] style.fill.mode = "inherit-connection" — NOT "solid". "solid" paints every branch the same flat colour and the palette becomes invisible. Add border.mode "inherit-connection" + a width so the outline matches too. (3) For every level you want plain, set style.fill.mode = "transparent". HARD RULE: topics needs AT LEAST 3 entries — [0] root, [1] main topics, [2] level 2, whose style also covers every level deeper than the array. Indices 0/1/2 are read individually: omit one and that level falls back to a Mindomo default rather than to the level above. Do NOT set connector.stroke.color: that pins one line colour for the whole level and overrides the palette. Worked example — "vibrant alternate colours for the branches, filled main topics, transparent for the rest": {"op":"create","theme":{"type":"mindmap", "diagram":{"fill":{"value":"#fcfcfc","style":"solid"}, "alternateColors":{"mode":"palette","colors":["#ff6961","#ffb480","#f8f38d","#42d6a4","#08cad1","#59adf6","#9d94ff","#c780e8"], "lightText":"#ffffff","darkText":"#2d2d2d","lightnessFactor":0.6}}, "topics":[ {"style":{"shape":"capsule","fill":{"mode":"inherit-connection","pattern":"flat-border-dropshadow"},"border":{"mode":"inherit-connection","width":4},"font":{"size":25,"bold":true}}}, {"style":{"shape":"capsule","fill":{"mode":"inherit-connection","pattern":"flat-border"},"border":{"mode":"inherit-connection","width":2},"font":{"size":16}}}, {"style":{"shape":"line-bottom","fill":{"mode":"transparent"},"font":{"size":12,"color":"#2d2d2d"}}}], "summaryTopic":{"style":{"fill":{"mode":"inherit-connection"},"border":{"mode":"inherit-connection","width":2}}}}} If the user wants the level BELOW the main topics filled too, make topics[2] inherit-connection as well and append a transparent topics[3]. Creating a theme does not apply it — call apply_theme next.
edit_themes
Add, update, move, delete or restore topics in a diagram — the single tool for ALL topic edits. Choose the operation with 'op': • op=create — ADD topics (with optional nested subtopics). Provide 'branches'; each branch's parentId is optional (omit to add under the root/central topic). SUCCESS RESPONSE: {revision, branches} where 'branches' is the created topics as a TREE mirroring your request — each node is {id (the new shortId), title, subtopics[]}, all nesting levels, in request order. This IS the success result (a revision + the id tree = done); there is no separate {success:true} flag. Use these ids to anchor relations/boundaries/summaries — no follow-up read needed. Send the WHOLE map in ONE call (up to 1000 topics, nested subtopics count) — the server batches it internally, so prefer one big op=create over many small ones. New MAIN topics (added under the root) are auto-balanced across the left/right sides on a mindmap; set layout.orientation (mindmap-left/mindmap-right) on a branch to pick a side explicitly. op=create branches take the FULL Topic shape — title, description (topic notes), task (deadlines, priority, progress, duration, assignees, milestone), style, icons, links, layout, connector, collapsed, template — so a topic can be created WITH its deadline already set. This is the ONLY create path that carries task data (build_diagram does NOT), so a whole project map with tasks and deadlines is create_diagram {title, themeId} + this one call. • op=update — merge-patch existing topics (send only the fields to change). Provide 'topics', each with its id. Supports title, description, task {checkable (true = it IS a task — renders the checkbox), schedule {startDate, endDate — endDate is the DEADLINE / due date, yyyy-MM-dd}, priority(0-4; 0=highest), progressPercent(0-100), duration {value,unit}, isMilestone (a dated checkpoint), assignees (add/remove users by id, or virtual by uid)}, style {fill,border,font,shape,box}, connector {stroke,anchor,routing,markers,label} (the branch line), layout.orientation, collapsed, icons (emoji shortnames), links, media {url,path,type,size}, audio {url,path} (send media/audio with no url/path to clear it), and template (smart-template settings for TEMPLATE maps: placeholder/wiki/type, and fromTopicIds — existing child topics the server clones into the topic's insertable prototype branch; see edit_diagram_template / read_template_branches). layout.orientation on a topic restyles its subtree; on the ROOT topic it switches the whole map's layout (org-chart, timeline, fishbone, tree-*, concept, …). To REBALANCE a map (spread main topics evenly left/right), update the ROOT with layout.orientation="mindmap". NOTE: task.recurrence, task.occurrences, task.showCompleted, task.schedule.completedAt, task.completedBy, task.autoCalculate and task.color are applied on op=create ONLY — set them when creating the topic; sending them here has no effect. • op=move — reparent and/or reorder one topic. Provide 'topicId' (+ optional 'parentId', 'position', 'orientation'). Use orientation=mindmap-left/right to move a main topic to the other side. Re-mints the id; 'movedTopics' maps old→new. • op=delete — soft-delete topics (subtrees cascade). Provide 'ids' (topic shortIds). Returns a deleteCommandId. • op=restore — undo a delete. Provide 'ids' = the deleteCommandId(s) from op=delete. All ids are shortIds.
edit_topics
Export a diagram to a file. Provide the diagram GUID and a format; the file is returned as Base64 (contentBase64) with filename, mimeType and sizeBytes — decode contentBase64 to obtain the bytes. Plan tiers: FREE — txt, mom (Mindomo native); PREMIUM — pdf, png, svg, docx (Word), md (Markdown), opml, html, mm (FreeMind), mmap (MindManager); PROFESSIONAL — xls (Excel), pptx (PowerPoint). A format above the user's plan returns an upgrade message. Large exports are rejected — export those from the Mindomo app.
export_diagram
Get a diagram's metadata (name, dates, theme, type, creator, and link — a clickable URL that opens the diagram in the browser) by its id (GUID). This is ALSO the tool to SHOW a diagram: call it whenever the user asks to see / show / display / preview a map — hosts that support MCP widgets render the result as an inline interactive view of the map; otherwise present the link for the user to open. To support inline display, this tool may create or reuse the diagram's revocable AI viewer link in the user's Mindomo account.
get_diagram
Get a theme as JSON (its full MapThemeJSON definition) by id. Use to inspect a theme or to obtain a starting point: get a theme, modify the returned JSON, then edit_themes(op=update) it back. To start from a built-in instead, edit_themes(op=clone) is one call and loses nothing.
get_theme
List the diagrams the current user owns. Returns each diagram's id (GUID), name, modification date and link (a clickable URL that opens the diagram in the browser). Use the id with get_diagram / read_diagram / read_branches / open_diagram.
list_diagrams
List the themes available to the user: the built-in gallery plus the user's own. Each has id (GUID), layout (normal|concept|organigram|timeline|fishbone), builtin, and isDefault (the standard look for that layout). Themes are unnamed — to style a new map pick a built-in id for the target layout and pass it as themeId to build_diagram/create_diagram (or apply_theme later); inspect one with get_theme only if the exact colors matter.
list_themes
Read a topic and its subtree from a diagram. Omit topicId to read all root topics. depth 0 = just the topic (no children), N = N levels deep, -1 = the whole subtree. Ids are shortIds; topic user ids (assignees/completedBy/audit.createdBy) resolve to names via the 'users' list.
read_branches
Read a whole diagram: all topics (full tree), relations, boundaries and summaries, all with shortId ids. Use for a complete picture; read_branches for a single subtree. Topic user ids (assignees/completedBy/audit.createdBy/comment authors) resolve to names via the 'users' list. To support inline display, this tool may create or reuse the diagram's revocable AI viewer link in the user's Mindomo account.
read_diagram
Read a diagram's template-branch PROTOTYPE trees — the hidden insertable topics a smart-template topic offers (created with edit_topics via template.fromTopicIds). Each array element is a full Topic tree (same shape as read_branches topics, nested subtopics, ids are shortIds); join them to their owner topic via the owner's template.prototypeIds (from read_branches/read_diagram). Prototypes are NOT part of the normal topic tree — this is the only read that returns them. Optional topicId filters to one owner topic's prototypes.
read_template_branches
Rename a diagram and/or set its description. Provide the diagram GUID and a new name and/or description (both optional). Metadata change — no edit session needed; not covered by undo_change (rename again to revert). Setting a name also unlinks the diagram name from the root topic's title, as renaming in the Mindomo app does.
rename_diagram
Search across the diagrams the user can access. Use 'query' for the keyword search (matches all content — titles, notes, comments, links — like the dashboard). Optional structured filters to narrow: tasks (open|closed|all|due), priority (0-4), progress, assignedToId/assignedToName/assignedToEmail, createdById/createdByName/createdByEmail (topic creator), due/start/closed/created/modified (date windows), is (task|open|due), diagramsCreatedByMe, mapsCreatedById/mapsCreatedByName/mapsCreatedByEmail/mapsVisibility/mapsModified (diagram scope), limit. Returns matching diagrams (full GUID id) each with a link (a clickable URL that opens the diagram in the browser), its lightweight matching topics (shortId), a topicLinks map (topic shortId → clickable URL that opens that topic), and a users list resolving the user ids it references (createdBy, topic assignees/completedBy/audit.createdBy) to names.
search_diagrams
Search topics within one diagram. Use 'query' for the keyword search (matches all content like the dashboard); same structured filters as search_diagrams (diagramsCreatedByMe is ignored here). Returns the diagram id, its matching topics (shortId ids), a topicLinks map (topic shortId → clickable URL that opens that topic), and a users list resolving the topics' user ids (assignees/completedBy/audit.createdBy) to names.
search_topics
Revert a change previously made by THIS app on the diagram — either the change named by 'undoId' (returned by every write tool) or, when omitted, the app's most recent change. • To revert several changes, call once per change, NEWEST FIRST (undoIds in reverse order); undoing an older change while your own newer change still touches the same topics is refused as a conflict. • Only this app's changes qualify — a person's edits (or another app's) are never reverted; resolving without undoId skips right past them. • Covers topic create/delete/move, topic property updates, relations, boundaries, summaries, comments, and diagram style/theme/template changes. Value changes are revertible for 30 days (UNDO_EXPIRED after); a change whose previous value could not be captured answers UNDO_UNSUPPORTED. Reverting an op=restore is simply op=delete with the same topics; build_diagram's initial content is not a change and cannot be reverted. • If a later change by someone else touches the same topics, the revert is refused (UNDO_CONFLICT) rather than clobbering their work.
undo_change

FAQs

Mindomo ChatGPT Plugin FAQ

How the directory, categories and Discoverability Score work.

Read the methodology

How do I improve Mindomo's ChatGPT Plugin discoverability?

The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.

Where is this profile measured?

This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.