MCP App Store
by KeenEthics
Dokki icon

Dokki MCP Server for ChatGPT

By Dokki

Overview

Dokki is an agent-native collaboration OS: a shared workspace where people and agents create knowledge together, live. Connect it to find, read, write, organize and share the documents, tables and interactive pages you and your team keep in Dokki, without copy and paste. What you can ask for: - Find and read: search your workspaces by meaning or exact text, list what a workspace holds, then read a document, a table, an interactive page, slides, a diagram, a mind map, a canvas or the text of a stored file. - Create: new documents, tables, folders and interactive pages, from scratch or from a template, or a copy of an existing one. - Edit: insert, replace or rewrite part of a document; add, update or delete table rows and columns; update a page's code, a diagram or a design. Edits appear live for anyone who has the document open. - Organize: rename, move, tag, or move to Trash. - Share: invite a person by email as viewer, commenter or editor, or set a resource's link access. - Preview: see a rendered document, table or page inline. Who it's for: people and teams who keep their plans, notes, trackers and docs in Dokki. It works only inside your Dokki workspaces: it does not act in your other accounts and does not run Dokki agents. Sign-in is OAuth with your Dokki account. On Dokki's consent screen you choose which workspaces the connection can reach (Personal, whole organizations, or specific workspaces) and which kinds of actions it may take. It never gets more than your own Dokki permissions. Tools that replace, remove or share content are marked as such, so you are asked before they run. Items moved to Trash can be restored from Trash in Dokki.

How to connect

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

Tools

artifact_patch

ChatGPT
Partially edit an artifact's source code by finding and replacing a specific string. Uses 3-way merge to safely combine with concurrent human edits. Call artifact_read first to see the current source. Write artifacts as a complete HTML document — that is the default and the only format to use for a new artifact. Component and Screen variants are the explicit exception: keep their maintained JSX module shape so Components can expose named React exports and Screens can import them with dokki:component/id:<resource-uuid>. Use the stable UUID form for every new component reference; legacy name slugs are compatibility-only. HTML renders directly, so it cannot fail a compile step. Put styles in a <style> tag and behaviour in a <script> tag; nothing is injected for you, so add your own CSS (or <script src='https://cdn.tailwindcss.com'></script> for Tailwind, https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js for diagrams, https://cdn.jsdelivr.net/npm/chart.js for charts). The sandbox blocks browser storage: localStorage, sessionStorage, document.cookie and indexedDB all THROW on an opaque origin, which takes the whole page down — not just the save. Artifact writes that use them are rejected. For Artifact-owned durable collaborative JSON, use await window.dokki.state.get(key?), set(key, value), delete(key), and subscribe(listener); this API persists in the Artifact Y.Doc and syncs between collaborators. Use one key per independently edited entity. Use window.dokki.presence only for ephemeral cursors, selections, and viewers. A Diagram's visible content lives in that collaborative state: use diagram_read and diagram_update for nodes and edges. Never replace a Diagram with a static HTML snapshot through artifact_update or artifact_patch. A Design is a separate spatial-design resource. Use design_read and design_update with the returned spatial_contract; preserve its collaborative source. Design it to stand on its own: it renders isolated, inheriting no theme or font, so define both light and dark yourself with prefers-color-scheme, give body an explicit background, and use semantic HTML with real keyboard focus states. JSX (a default-exported React 18 component with framer-motion, lucide-react, recharts, mermaid and Tailwind preloaded) is DEPRECATED and being retired because its compile step is unreliable. Only keep JSX when editing an artifact whose current source is already JSX, or when the user explicitly asks for a React component; never choose it for a new artifact. Live workspace data: inside the artifact, await window.dokki.readTable(resourceId) resolves to { columns: [{ id, name, type }], rows, total, truncated }. Each row is { id, [column id]: value }: keyed by COLUMN ID, never by the column's name, so resolve a column with columns.find(c => c.name === 'Revenue').id. An empty cell may be missing, and a row carries version once its table keeps row versions. At most 1000 rows come back; truncated is true when there are more, and total counts them all. await window.dokki.readDocument(resourceId) returns { title, markdown }. Both take a Dokki resource UUID, read as the current viewer, and only reach resources in the artifact's own workspace that BOTH the viewer and the artifact's author can read. Prefer this over pasting a snapshot of the data into the source when the artifact should track the table. Always handle rejection — the viewer may lack access, and it is unavailable on published pages. To change a table from the page, await window.dokki.createRow(tableId, values), updateRow(tableId, rowId, changes, { expectedVersion }?) and deleteRow(tableId, rowId, { expectedVersion }?) take the same column-id keys; create and update resolve to the stored row { id, version, ...values }. The first write to each table waits until a person who can edit that table allows this artifact once — you cannot allow it yourself — so treat a rejection as normal; published pages never write. MCP App HTML/static preview is off by default on artifact_read; call preview_resource when an inline preview is useful.

artifact_read

ChatGPT
Read the current source code of an artifact via real-time collaboration. Write artifacts as a complete HTML document — that is the default and the only format to use for a new artifact. Component and Screen variants are the explicit exception: keep their maintained JSX module shape so Components can expose named React exports and Screens can import them with dokki:component/id:<resource-uuid>. Use the stable UUID form for every new component reference; legacy name slugs are compatibility-only. HTML renders directly, so it cannot fail a compile step. Put styles in a <style> tag and behaviour in a <script> tag; nothing is injected for you, so add your own CSS (or <script src='https://cdn.tailwindcss.com'></script> for Tailwind, https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js for diagrams, https://cdn.jsdelivr.net/npm/chart.js for charts). The sandbox blocks browser storage: localStorage, sessionStorage, document.cookie and indexedDB all THROW on an opaque origin, which takes the whole page down — not just the save. Artifact writes that use them are rejected. For Artifact-owned durable collaborative JSON, use await window.dokki.state.get(key?), set(key, value), delete(key), and subscribe(listener); this API persists in the Artifact Y.Doc and syncs between collaborators. Use one key per independently edited entity. Use window.dokki.presence only for ephemeral cursors, selections, and viewers. A Diagram's visible content lives in that collaborative state: use diagram_read and diagram_update for nodes and edges. Never replace a Diagram with a static HTML snapshot through artifact_update or artifact_patch. A Design is a separate spatial-design resource. Use design_read and design_update with the returned spatial_contract; preserve its collaborative source. Design it to stand on its own: it renders isolated, inheriting no theme or font, so define both light and dark yourself with prefers-color-scheme, give body an explicit background, and use semantic HTML with real keyboard focus states. JSX (a default-exported React 18 component with framer-motion, lucide-react, recharts, mermaid and Tailwind preloaded) is DEPRECATED and being retired because its compile step is unreliable. Only keep JSX when editing an artifact whose current source is already JSX, or when the user explicitly asks for a React component; never choose it for a new artifact. Live workspace data: inside the artifact, await window.dokki.readTable(resourceId) resolves to { columns: [{ id, name, type }], rows, total, truncated }. Each row is { id, [column id]: value }: keyed by COLUMN ID, never by the column's name, so resolve a column with columns.find(c => c.name === 'Revenue').id. An empty cell may be missing, and a row carries version once its table keeps row versions. At most 1000 rows come back; truncated is true when there are more, and total counts them all. await window.dokki.readDocument(resourceId) returns { title, markdown }. Both take a Dokki resource UUID, read as the current viewer, and only reach resources in the artifact's own workspace that BOTH the viewer and the artifact's author can read. Prefer this over pasting a snapshot of the data into the source when the artifact should track the table. Always handle rejection — the viewer may lack access, and it is unavailable on published pages. To change a table from the page, await window.dokki.createRow(tableId, values), updateRow(tableId, rowId, changes, { expectedVersion }?) and deleteRow(tableId, rowId, { expectedVersion }?) take the same column-id keys; create and update resolve to the stored row { id, version, ...values }. The first write to each table waits until a person who can edit that table allows this artifact once — you cannot allow it yourself — so treat a rejection as normal; published pages never write. MCP App HTML/static preview is off by default on artifact_read; call preview_resource when an inline preview is useful.

artifact_update

ChatGPT
Replace the entire source code of an artifact. Write artifacts as a complete HTML document — that is the default and the only format to use for a new artifact. Component and Screen variants are the explicit exception: keep their maintained JSX module shape so Components can expose named React exports and Screens can import them with dokki:component/id:<resource-uuid>. Use the stable UUID form for every new component reference; legacy name slugs are compatibility-only. HTML renders directly, so it cannot fail a compile step. Put styles in a <style> tag and behaviour in a <script> tag; nothing is injected for you, so add your own CSS (or <script src='https://cdn.tailwindcss.com'></script> for Tailwind, https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js for diagrams, https://cdn.jsdelivr.net/npm/chart.js for charts). The sandbox blocks browser storage: localStorage, sessionStorage, document.cookie and indexedDB all THROW on an opaque origin, which takes the whole page down — not just the save. Artifact writes that use them are rejected. For Artifact-owned durable collaborative JSON, use await window.dokki.state.get(key?), set(key, value), delete(key), and subscribe(listener); this API persists in the Artifact Y.Doc and syncs between collaborators. Use one key per independently edited entity. Use window.dokki.presence only for ephemeral cursors, selections, and viewers. A Diagram's visible content lives in that collaborative state: use diagram_read and diagram_update for nodes and edges. Never replace a Diagram with a static HTML snapshot through artifact_update or artifact_patch. A Design is a separate spatial-design resource. Use design_read and design_update with the returned spatial_contract; preserve its collaborative source. Design it to stand on its own: it renders isolated, inheriting no theme or font, so define both light and dark yourself with prefers-color-scheme, give body an explicit background, and use semantic HTML with real keyboard focus states. JSX (a default-exported React 18 component with framer-motion, lucide-react, recharts, mermaid and Tailwind preloaded) is DEPRECATED and being retired because its compile step is unreliable. Only keep JSX when editing an artifact whose current source is already JSX, or when the user explicitly asks for a React component; never choose it for a new artifact. Live workspace data: inside the artifact, await window.dokki.readTable(resourceId) resolves to { columns: [{ id, name, type }], rows, total, truncated }. Each row is { id, [column id]: value }: keyed by COLUMN ID, never by the column's name, so resolve a column with columns.find(c => c.name === 'Revenue').id. An empty cell may be missing, and a row carries version once its table keeps row versions. At most 1000 rows come back; truncated is true when there are more, and total counts them all. await window.dokki.readDocument(resourceId) returns { title, markdown }. Both take a Dokki resource UUID, read as the current viewer, and only reach resources in the artifact's own workspace that BOTH the viewer and the artifact's author can read. Prefer this over pasting a snapshot of the data into the source when the artifact should track the table. Always handle rejection — the viewer may lack access, and it is unavailable on published pages. To change a table from the page, await window.dokki.createRow(tableId, values), updateRow(tableId, rowId, changes, { expectedVersion }?) and deleteRow(tableId, rowId, { expectedVersion }?) take the same column-id keys; create and update resolve to the stored row { id, version, ...values }. The first write to each table waits until a person who can edit that table allows this artifact once — you cannot allow it yourself — so treat a rejection as normal; published pages never write. MCP App HTML/static preview is off by default on artifact_read; call preview_resource when an inline preview is useful.

canvas_add_artboard

ChatGPT
Add one Design Component HTML artboard under a new .dc.html filename in a file-based canvas.

canvas_add_text

ChatGPT
Add one plain-text box to a page of an element-based canvas.

canvas_read

ChatGPT
Read a native Canvas (infinite board): its pages, one page's elements (bottom first, absolute x/y/w/h), next_free_spot and state_hash for canvas_update. Frame html is excerpted unless include_html. File-native: returns its files.

canvas_replace_artboard

ChatGPT
Replace the HTML content of one existing Design Component artboard in a file-based canvas.

canvas_replace_element_text

ChatGPT
Replace the text of one text box, sticky note, shape or connector on an element-based canvas.

copy_resource

ChatGPT
Copy a resource (document, table, artifact, file or whole folder) into a workspace or folder as an exact, independent copy. Needs export access to the source and write access where it lands; stays within one organization.

create_artifact

ChatGPT
Create an Artifact, Diagram, Design, Slide, Component, or Screen. Generic Artifacts require exactly one of source or template_id; Artifact variants may omit both to use their maintained starter. Use list_artifact_templates first to discover workspace-scoped template ids; a template creates an independent source snapshot. Or pass template (an id from list_templates) alone to start from that template; name then defaults to the template's. Write artifacts as a complete HTML document — that is the default and the only format to use for a new artifact. Component and Screen variants are the explicit exception: keep their maintained JSX module shape so Components can expose named React exports and Screens can import them with dokki:component/id:<resource-uuid>. Use the stable UUID form for every new component reference; legacy name slugs are compatibility-only. HTML renders directly, so it cannot fail a compile step. Put styles in a <style> tag and behaviour in a <script> tag; nothing is injected for you, so add your own CSS (or <script src='https://cdn.tailwindcss.com'></script> for Tailwind, https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js for diagrams, https://cdn.jsdelivr.net/npm/chart.js for charts). The sandbox blocks browser storage: localStorage, sessionStorage, document.cookie and indexedDB all THROW on an opaque origin, which takes the whole page down — not just the save. Artifact writes that use them are rejected. For Artifact-owned durable collaborative JSON, use await window.dokki.state.get(key?), set(key, value), delete(key), and subscribe(listener); this API persists in the Artifact Y.Doc and syncs between collaborators. Use one key per independently edited entity. Use window.dokki.presence only for ephemeral cursors, selections, and viewers. A Diagram's visible content lives in that collaborative state: use diagram_read and diagram_update for nodes and edges. Never replace a Diagram with a static HTML snapshot through artifact_update or artifact_patch. A Design is a separate spatial-design resource. Use design_read and design_update with the returned spatial_contract; preserve its collaborative source. Design it to stand on its own: it renders isolated, inheriting no theme or font, so define both light and dark yourself with prefers-color-scheme, give body an explicit background, and use semantic HTML with real keyboard focus states. JSX (a default-exported React 18 component with framer-motion, lucide-react, recharts, mermaid and Tailwind preloaded) is DEPRECATED and being retired because its compile step is unreliable. Only keep JSX when editing an artifact whose current source is already JSX, or when the user explicitly asks for a React component; never choose it for a new artifact. Live workspace data: inside the artifact, await window.dokki.readTable(resourceId) resolves to { columns: [{ id, name, type }], rows, total, truncated }. Each row is { id, [column id]: value }: keyed by COLUMN ID, never by the column's name, so resolve a column with columns.find(c => c.name === 'Revenue').id. An empty cell may be missing, and a row carries version once its table keeps row versions. At most 1000 rows come back; truncated is true when there are more, and total counts them all. await window.dokki.readDocument(resourceId) returns { title, markdown }. Both take a Dokki resource UUID, read as the current viewer, and only reach resources in the artifact's own workspace that BOTH the viewer and the artifact's author can read. Prefer this over pasting a snapshot of the data into the source when the artifact should track the table. Always handle rejection — the viewer may lack access, and it is unavailable on published pages. To change a table from the page, await window.dokki.createRow(tableId, values), updateRow(tableId, rowId, changes, { expectedVersion }?) and deleteRow(tableId, rowId, { expectedVersion }?) take the same column-id keys; create and update resolve to the stored row { id, version, ...values }. The first write to each table waits until a person who can edit that table allows this …

create_document

ChatGPT
Create a new document in a workspace with optional initial Markdown content. Or pass template (an id from list_templates) instead of content to start from that template; name then defaults to the template's.

create_folder

ChatGPT
Create a new folder in a workspace

create_table

ChatGPT
Create a new table in a workspace with optional initial columns and rows. variant "issue" creates an Issues table instead: preset columns (Key, Title, Status, Priority, Type, Owner, Project, PR, Deployment, …), a key on every row such as ENG-12, and pull requests that name a key link to its row. It takes no columns or rows. Or pass template (an id from list_templates) instead of columns to start from that template's columns, rows and view; name then defaults to the template's.

delete_resource

ChatGPT
Move a document, table, page, file or folder to Trash. It disappears from the workspace for everyone; a workspace admin can restore it from Trash in Dokki.

design_read

ChatGPT
Read the persisted collaborative nodes and edges of a Design. Returns state_hash and runtime_compatible; pass the hash to design_update so concurrent human edits are never overwritten, and use repair_runtime:true only when compatibility is false.

design_update

ChatGPT
Atomically update a collaborative Design's nodes and edges. Call design_read first and pass its state_hash as expected_state_hash. mode=replace replaces graph state while preserving compatible source; mode=merge upserts supplied items. If runtime_compatible is false, repair_runtime:true explicitly restores Dokki's collaborative runtime in the same transaction. Shapes: rectangle, rounded, diamond, circle, ellipse, hexagon, parallelogram, database. Connection handles: top, right, bottom, left. Concurrent merges: pass expected_items and expected_source_hash from design_read. City node data supports cityKind (building/home/park/plaza/school/hospital/station/road/river/bridge) and dimensions from the spatial contract. Legacy 2D city sizes use 40-1600. Follow design_read spatial_contract for 3D metre units, footprints, courtyards, compound blocks, paths and explicit relations. Preserve spatial metadata when editing.

diagram_read

ChatGPT
Read the persisted collaborative nodes and edges of a Diagram. Returns state_hash and runtime_compatible; pass the hash to diagram_update so concurrent human edits are never overwritten, and use repair_runtime:true only when compatibility is false.

diagram_update

ChatGPT
Atomically update a collaborative Diagram's nodes and edges. Call diagram_read first and pass its state_hash as expected_state_hash. mode=replace replaces graph state while preserving compatible source; mode=merge upserts supplied items. If runtime_compatible is false, repair_runtime:true explicitly restores Dokki's collaborative runtime in the same transaction. Shapes: rectangle, rounded, diamond, circle, ellipse, hexagon, parallelogram, database. Connection handles: top, right, bottom, left. Concurrent merges: pass expected_items and expected_source_hash from diagram_read. City node data supports cityKind (building/home/park/plaza/school/hospital/station/road/river/bridge) and dimensions from the spatial contract. Legacy 2D city sizes use 40-1600. Follow diagram_read spatial_contract for 3D metre units, footprints, courtyards, compound blocks, paths and explicit relations. Preserve spatial metadata when editing.

doc_delete

ChatGPT
Delete one or more nodes from a document. Returns a diff showing the change with surrounding context. You must call doc_read first to obtain node IDs.

doc_insert

ChatGPT
Insert nodes before or after a target node in a document. Returns a diff showing the change with surrounding context. You must call doc_read first to obtain node IDs.

doc_read

ChatGPT
Read document content in compact JSON format. Returns nodes with short IDs and portable inline markdown: resource mentions use @[Label](dokki://mention/KIND/RESOURCE_UUID), inline math uses $$latex$$, colored text uses <span style='color:#hex;background-color:…'>…</span>, and tables are rendered as markdown tables. Preserve these forms when editing. Does not open an MCP App preview; use preview_resource when a rendered inline preview is needed.

doc_replace

ChatGPT
Replace one or more consecutive nodes with new content in a document. Use end_node_id to replace a range (e.g. rewriting multiple paragraphs at once). Returns a diff showing the change with surrounding context. You must call doc_read first to obtain node IDs.

doc_rewrite

ChatGPT
Replace the ENTIRE document content with new nodes. Use when rewriting the whole document — bypasses doc_replace's range cap and does not require first/last node IDs. Does NOT require a prior doc_read. Returns before/after node counts.

file_extract

ChatGPT
Read a PDF, Word (docx), PowerPoint (pptx), Excel (xlsx) or text file stored in Dokki as plain text, a page at a time. A scanned PDF returns only the text Dokki has already recognised in it.

grep_workspace

ChatGPT
Find an EXACT string or regex pattern across the user's documents, tables, and artifacts. Returns line-level matches with surrounding excerpts (think: grep / ripgrep over their notes). SCOPE: searches workspaces authorized for this MCP connection by default. Pass workspace_id only to restrict to one. COVERAGE: - documents → markdown content - tables → CSV of cell values - artifacts → TSX source Each hit returns kind (which follow-up tool to use: doc_read / table_read / artifact_read), workspace_id + workspace_name (which workspace the hit lives in), and url (absolute in-app URL — cite hits as markdown links [title](url), never raw IDs). A hit also carries tags and metadata when the resource has them (absent means none) — read them before citing, e.g. skip a hit tagged superseded. WHEN to use: - User asks for an exact phrase, quote, code identifier, or error message ("find the line that says ...") - You need to verify whether something specific appears verbatim somewhere - Looking for occurrences of a name, ID, URL, function, table cell value, etc. DO NOT use for: - Conceptual / paraphrased queries → use search_workspace (semantic) - Listing files → use list_resources - External / web facts → use search_web PATTERN TIPS: - Default is plain substring (case-insensitive). Set regex:true for full regex. - Return value highlights matches with [match]…[/match] tokens around hits. - A hit's match_count tells you how many total occurrences exist in that resource; excerpts are capped per hit. - coverage.complete tells you whether the scan actually covered everything. Only treat 0 hits as "this text does not exist" when it is true; otherwise read coverage.note and narrow the search instead.

list_artifact_templates

ChatGPT
List reusable Artifact templates in a workspace. Returns metadata only, never template source. Each result includes variant (null, diagram, design, slide, component, or screen); pass the same artifact_variant when creating from a variant template. Requires admin or editor access; use the returned id with create_artifact(template_id) to create an independent snapshot.

list_resources

ChatGPT
List all resources (documents, tables, folders, artifacts) in a workspace as a tree. A resource carries tags and metadata when it has them, and omits the field when it does not — so absence means unmarked. Pinned resources are highlighted with is_pinned=true and listed separately — prioritize reading them first. Includes a short head preview by default; set head=0 or preview_head=0 to omit previews. Pass filter to instead get a FLAT list of matching resources. Big workspace? Browse level by level: pass depth (and parent_id to descend); nodes at the cut carry child_count + children_not_loaded.

list_templates

ChatGPT
List the templates a document, table or artifact can be created from: Dokki's own (meeting notes, product spec, sales pipeline, roadmap, diagram, …) and the ones the person and their team saved in the Template Center. Returns ids and summaries, never template content. Pass an id as template to create_document / create_table / create_artifact. With workspace_id, that workspace's team templates and saved artifact templates are included.

list_workspaces

ChatGPT
List all workspaces the authenticated user is a member of

mindmap_add_child

ChatGPT
Add one child node with a text label under an existing mind map node.

mindmap_read

ChatGPT
Read a Mind map: its outline (Markdown), nodes (id, text, parent, collapsed, tone, optional source pointer), layout, links and the state_hash mindmap_update requires.

mindmap_rename_node

ChatGPT
Change one mind map node's text and clear its linked transcript excerpt, if any. If the resource name follows the central topic, renaming that topic also renames the resource.

move_resource

ChatGPT
Move a resource under a new parent — a folder or a page — or to the workspace root, within its own workspace. To relocate it into another workspace, copy_resource it there and then delete the original.

preview_resource

ChatGPT
Open an interactive inline preview (MCP App) of a document, table, form, or artifact.

read_resource_metadata

ChatGPT
Read a resource's current metadata and metadata revision before making a safe incremental update. Requires edit access; viewers cannot use this tool.

search_workspace

ChatGPT
Search the user's Dokki documents, tables, artifacts, and forms by content (hybrid search). FIRST-CHOICE tool for grounding answers in the user's own content. Each result carries type (document/table/artifact/form), resource_id, workspace_id + workspace_name (which workspace the hit lives in), and url (absolute in-app URL — cite hits as markdown links [title](url), never raw IDs). A hit also carries tags and metadata when the resource has them (absent means none) — read them before citing, e.g. skip a hit tagged superseded. SCOPE: searches workspaces authorized for this MCP connection by default. Pass workspace_id only to restrict to one. WHEN to use: - User asks about something they wrote / saved before - Answer should reference their docs rather than general knowledge - Looking for facts, decisions, or numbers buried in their workspace DO NOT use for: - Listing what files exist (use a directory/listing tool) - Reading a specific known document by id - External / current-events facts QUERY TIPS: Combine entity names with topical keywords. Bare names give narrow results. Bad: 'Aurora' Good: 'Project Aurora architecture decisions timeline' The response includes provider-neutral retrieval arm status/count diagnostics and a degraded flag. A failed optional arm is never presented as successful retrieval.

share_resource

ChatGPT
Share a document, table, page, file or folder with a person by email as viewer, commenter or editor, or set its link access, which can make it readable by anyone with the link. Requires admin on the resource's workspace.

slides_add_page

ChatGPT
Insert one HTML slide into an existing native Slide deck, at the end by default. Dokki assigns a new slide ID.

slides_read

ChatGPT
Read a native Slide deck: slides, elements (z-order, bottom first), theme and state_hash for slides_update. Elements are absolutely positioned on the deck canvas (default 1920×1080). Prefer add_slides with a layout over placing pixels.

slides_replace_page

ChatGPT
Replace the content of one existing native slide with one HTML section at its current position.

table_add_columns

ChatGPT
Add one or more columns to a table.

table_add_rows

ChatGPT
Add one or more rows to a table. Each row can have optional initial values and insertion index. Values are keyed by column ID (short prefix or full UUID) or header name.

table_delete_columns

ChatGPT
Delete one or more columns from a table. Also removes all data in those columns from all rows. Supports short UUID prefix IDs from compact format.

table_delete_rows

ChatGPT
Delete one or more rows from a table by their row IDs. Supports short 8-char prefix IDs from compact format, and an Issues table's keys (ENG-12).

table_metric

ChatGPT
Compute a metric from a metric dictionary table: the dictionary's definition decides the source tables, filters and arithmetic. Returns rows of group keys and value, or every variant of a metric that is not approved, with provenance.

table_read

ChatGPT
Read the current table data including columns and rows. Does not open an MCP App preview; use preview_resource when a rendered inline preview is needed.

table_update_cells

ChatGPT
Update the values of one or more cells in a table. Supports short IDs from compact format (e.g. row '0a2b', column 'c1').

table_update_columns

ChatGPT
Update properties (header name, type, width) of one or more columns.

table_upsert_rows

ChatGPT
Write rows by key: a row whose key columns already hold the same values is updated (only the cells that differ), every other row is added. Safe to repeat. Rows tables only. Values are keyed by column ID or header name.

tag_resource

ChatGPT
Add one or more tags to a resource (document, table, folder, or artifact) by tag name. Tags that don't exist are returned in not_found; pass create_missing: true to create and apply them in the same call.

untag_resource

ChatGPT
Remove one or more tags from a resource by tag name

update_resource

ChatGPT
Rename a document, table, page, file or folder, or change its icon. metadata replaces the resource's whole metadata object; metadata_patch changes only the keys it names.

Capabilities

WritesInteractive

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/dokki"><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/dokki)