Dokki

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_patch

Explore the user's Dokki knowledge graph: the people, organizations, concepts, places, and products across their workspace and how they connect. Returns matched `entities` (with type + document count), their `neighbors` (connected entities with relationship + strength), and the `resources` mentioning them (clickable links). SCOPE: workspaces authorized for this MCP connection by default. Pass `workspace_id` to restrict. WHEN to use: - 'How are X and Y connected/related?' - 'What do we know about <person/company/project>?' — its neighborhood, not just docs - Mapping relationships, org structure, or how topics interconnect DO NOT use for: finding a document's content (use search_workspace) or exact strings (use grep_workspace).

related_entities

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.

grep_workspace

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_insert

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_artifact_templates

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_templates

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_resources

List all workspaces the authenticated user is a member of

list_workspaces

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.

move_resource

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.

delete_resource

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

preview_resource

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_read

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_read

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_read

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_read

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.

file_extract

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_read

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_read

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

read_resource_metadata

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_read

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_read

Remove one or more tags from a resource by tag name

untag_resource

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.

update_resource

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_replace

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.

artifact_update

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.

doc_rewrite

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.

search_workspace

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.

share_resource

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.

tag_resource

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.

design_update

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.

diagram_update

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_cells

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

table_update_columns