← Word MCP Server

Word MCP Server 920e524c965a49b4e6ae978dec82fd31e8656e1f

source_git · helloworld-open/word-mcp-server · current release

81
Tools
3
Resources
0
Templates
3
Prompts

Observation

Observed 2026-08-25T10:33:11.873Z using mcpSecurity-inventory. Status: succeeded. Negotiated protocol: 2025-06-18.

Server capabilities
{
  "tools": {
    "listChanged": true
  },
  "prompts": {
    "listChanged": true
  },
  "resources": {
    "listChanged": true
  }
}

Tools 81

ToolCategoryAnnotationsRisk
word_add_bookmarkWHEN: need to create a navigation anchor for hyperlinks or cross-references within the document. WHAT: adds a bookmark at the current cursor position with a unique name. CONSTRAINT: name is permanent; rename by deleting and re-adding. Use with word_add_hyperlink subAddress or word_go_to({what:'bookmark'}) to jump here.
Input schema
{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1,
      "maxLength": 100,
      "pattern": "^[a-zA-Z_\\u4e00-\\u9fff][a-zA-Z0-9_\\u4e00-\\u9fff]*$",
      "description": "Bookmark name (alphanumeric + underscore, start with letter or Chinese character). Example: 'section2_intro'"
    },
    "quiet": {
      "type": "boolean",
      "description": "简洁输出模式"
    }
  },
  "required": [
    "name"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_add_commentWHEN: need to add review notes or feedback visible in the Review pane (like Google Docs comments). WHAT: adds a comment linked to the current text selection. CONSTRAINT: comments appear in the Review pane and are visible in print layout. For printed page-bottom notes, use word_add_footnote instead.
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "maxLength": 10000,
      "description": "Comment text (review note)"
    },
    "quiet": {
      "type": "boolean",
      "description": "简洁输出模式"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_add_footnoteWHEN: need to add an explanatory note at the bottom of the page. WHAT: inserts a footnote at the cursor position and places the cursor inside the footnote area to type content. CONSTRAINT: footnotes appear at page bottom in print layout; for review notes visible in the Review pane, use word_add_comment instead.
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "maxLength": 10000,
      "description": "Footnote text (appears at the bottom of the page)"
    },
    "quiet": {
      "type": "boolean",
      "description": "简洁输出模式"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_add_hyperlinkWHEN: need to insert a clickable link to a URL or document location. WHAT: inserts hyperlink at cursor with display text and target address. CONSTRAINT: address must be a valid URL or file path; subAddress links to a bookmark within a document (requires existing bookmark via word_add_bookmark).
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "maxLength": 1000,
      "description": "Display text (visible clickable text in the document)"
    },
    "address": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2083,
      "description": "URL (e.g., 'https://example.com') or file path (e.g., 'C:\\docs\\file.docx')"
    },
    "subAddress": {
      "type": "string",
      "maxLength": 255,
      "description": "Anchor or bookmark name within the target document to link to a specific location"
    },
    "screenTip": {
      "type": "string",
      "maxLength": 500,
      "description": "Tooltip text shown on hover (default: the address)"
    },
    "quiet": {
      "type": "boolean",
      "description": "简洁输出模式"
    }
  },
  "required": [
    "text",
    "address"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_add_table_columnAdd a new column to a table. WHEN: need to insert a column to accommodate more data. NOT: want to add a row? use word_add_table_row.
Input schema
{
  "type": "object",
  "properties": {
    "tableIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Table index (1-based, default: 1)"
    },
    "column": {
      "type": "integer",
      "minimum": 1,
      "description": "Add to left of this column (omit to append at end)"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_add_table_rowAdd a new row to a table. WHEN: need to insert a row at the end of the table. NOT: want to add a column instead? use word_add_table_column.
Input schema
{
  "type": "object",
  "properties": {
    "tableIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Table index (1-based, default: 1)"
    },
    "data": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 100000
      },
      "maxItems": 100,
      "description": "Cell data for the new row"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_apply_styleWHEN: need to apply Word's built-in paragraph styles (Heading 1, Title, Normal, etc.) to content. WHAT: sets the paragraph style of the current selection or cursor position. CONSTRAINT: only built-in styles work; custom styles created in Word are not listed. For individual font/paragraph properties, use word_set_font or word_set_paragraph.
Input schema
{
  "type": "object",
  "properties": {
    "styleName": {
      "type": "string",
      "minLength": 1,
      "maxLength": 255,
      "description": "Style name (e.g. 'Heading 1', 'Heading 2', 'Normal', 'Title', 'Subtitle', 'Quote')"
    }
  },
  "required": [
    "styleName"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_apply_table_styleApply a built-in Word table style by name. WHEN: need quick, professional table formatting with pre-designed colors/borders. NOT: want custom border or shading settings? use word_set_table_borders or word_set_table_shading.
Input schema
{
  "type": "object",
  "properties": {
    "tableIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Table index (1-based, default: 1)"
    },
    "styleName": {
      "type": "string",
      "minLength": 1,
      "maxLength": 255,
      "description": "Style name (e.g. 'Table Grid', 'Light List Accent 1')"
    }
  },
  "required": [
    "styleName"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_backspaceWHEN: need to delete the last N characters before the cursor (like pressing Backspace N times). WHAT: removes characters one at a time before the cursor position. CONSTRAINT: max 1000 characters at once. For large deletions, select text first then use word_delete.
Input schema
{
  "type": "object",
  "properties": {
    "count": {
      "type": "integer",
      "minimum": 1,
      "maximum": 1000,
      "description": "Number of backspaces (default: 1). Each backspace deletes one character before the cursor."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_batch_opsWHEN: need to perform multiple document insert operations at different locations in one pass for 5-10x speedup. WHAT: batch-executes markdown insert operations (by heading/paragraph/table/bookmark/cursor) with automatic DOM consistency checking between operations. CONSTRAINT: max 50 operations per call. For a single operation, use word_insert_at which has simpler error reporting.
Input schema
{
  "type": "object",
  "properties": {
    "ops": {
      "type": "array",
      "items": {
        "anyOf": [
          {
            "type": "object",
            "properties": {
              "by": {
                "type": "string",
                "enum": [
                  "heading",
                  "paragraph",
                  "table",
                  "bookmark",
                  "cursor"
                ],
                "description": "Target type (default: heading)"
              },
              "match": {
                "type": "string",
                "maxLength": 5000,
                "description": "Text to match (for heading/paragraph)"
              },
              "matchMode": {
                "type": "string",
                "enum": [
                  "exact",
                  "contains",
                  "startsWith",
                  "regex"
                ],
                "description": "Matching mode (default: exact)"
              },
              "occurrence": {
                "type": "integer",
                "minimum": 1,
                "maximum": 1000,
                "description": "Which occurrence to target (1-based, default: 1)"
              },
              "offsetDirection": {
                "type": "string",
                "enum": [
                  "before",
                  "after"
                ],
                "description": "Offset direction from the matched element"
              },
              "offsetCount": {
                "type": "integer",
                "minimum": 1,
                "maximum": 1000,
                "description": "Number of paragraphs to offset (default: 1)"
              },
              "name": {
                "type": "string",
                "minLength": 1,
                "maxLength": 255,
                "description": "Bookmark name (required when by='bookmark')"
              },
              "level": {
                "type": "integer",
                "minimum": 1,
                "maximum": 9,
                "description": "Heading level filter (1-9). Applied BEFORE match and occurrence, narrowing to same-level headings only."
              },
              "action": {
                "type": "string",
                "const": "insert",
                "description": "Insert markdown content at the located position"
              },
              "text": {
                "type": "string",
                "minLength": 1,
                "maxLength": 100000,
                "description": "Markdown content to insert"
              }
            },
            "required": [
              "action",
              "text"
            ],
            "additionalProperties": false
          }
        ]
      },
      "minItems": 1,
      "maxItems": 50,
      "description": "操作列表，按文档顺序排列"
    }
  },
  "required": [
    "ops"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_clipboardWHEN: need to move or duplicate content within or between documents (cut/copy/paste). WHAT: action=copy copies selection to clipboard; action=cut removes and copies; action=paste inserts clipboard at cursor. CONSTRAINT: copy/cut require prior selection; paste requires clipboard content from a prior copy/cut.
Input schema
{
  "type": "object",
  "properties": {
    "action": {
      "type": "string",
      "enum": [
        "copy",
        "cut",
        "paste"
      ],
      "description": "'copy' to copy selection to clipboard, 'cut' to remove and copy, 'paste' to insert clipboard content at cursor"
    }
  },
  "required": [
    "action"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_closeWHEN: done editing and want to return to NO_DOC state or switch to a different document workflow. WHAT: closes the active document (does NOT close Word). CONSTRAINT: if saveChanges=false, unsaved changes may be lost. After close, use word_document to open another file or word_stream_start to create new.
Input schema
{
  "type": "object",
  "properties": {
    "saveChanges": {
      "type": "boolean",
      "description": "Whether to save changes before closing (default: false). Set true to avoid losing edits."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_deleteWHEN: want to remove selected content from the document. WHAT: deletes the current selection (like pressing Delete key). CONSTRAINT: requires prior selection via word_select_text, word_select_all, or word_select_current. Does NOT work on empty selection; use word_backspace instead.
Input schema
{
  "type": "object",
  "properties": {}
}
—— · ——
word_delete_table_columnDelete a column from a table. WHEN: need to remove an unwanted column. NOT: want to delete a row? use word_delete_table_row.
Input schema
{
  "type": "object",
  "properties": {
    "tableIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Table index (1-based, default: 1)"
    },
    "column": {
      "type": "integer",
      "minimum": 1,
      "description": "Column number to delete (1-based)"
    }
  },
  "required": [
    "column"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_delete_table_rowDelete a row from a table. WHEN: need to remove an unwanted row. NOT: want to delete a column instead? use word_delete_table_column.
Input schema
{
  "type": "object",
  "properties": {
    "tableIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Table index (1-based, default: 1)"
    },
    "rowIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Row number to delete (1-based)"
    }
  },
  "required": [
    "rowIndex"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_documentWHEN: need to switch to an already-open document, open an existing file, or create an untitled document. WHAT: if path is provided and file exists, opens it; if already open, switches to it. If no path, creates/reuses an untitled document. CONSTRAINT: preferred over word_open which forces a new window. Error if path does not exist on disk.
Input schema
{
  "type": "object",
  "properties": {
    "path": {
      "type": "string",
      "minLength": 1,
      "maxLength": 4096,
      "description": "Path to an existing .docx file. Omit to create an untitled document or reuse the active one."
    },
    "title": {
      "type": "string",
      "maxLength": 255,
      "description": "Document title shown in Word title bar (used only when creating untitled doc with no path)"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_edit_cellWHEN: need to update one cell's content and you know the table index (default: 1). WHAT: sets the text of a specific cell by table index, row, and column. CONSTRAINT: tableIndex is 1-based; default=1 if only one table exists. For batch updates, use word_edit_cells.
Input schema
{
  "type": "object",
  "properties": {
    "tableIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Table index (1-based, default: 1). Use word_get_info to check table count."
    },
    "row": {
      "type": "integer",
      "minimum": 1,
      "description": "Row number (1-based)"
    },
    "column": {
      "type": "integer",
      "minimum": 1,
      "description": "Column number (1-based)"
    },
    "text": {
      "type": "string",
      "maxLength": 100000,
      "description": "New cell text"
    }
  },
  "required": [
    "row",
    "column",
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_edit_cell_atEdit a table cell by first locating the table semantically. WHEN: need to edit a specific cell but don't know the table index. NOT: already know the table index? use word_edit_cell.
Input schema
{
  "type": "object",
  "properties": {
    "by": {
      "type": "string",
      "enum": [
        "heading",
        "paragraph",
        "table",
        "bookmark",
        "cursor"
      ],
      "description": "Target type (default: heading)"
    },
    "match": {
      "type": "string",
      "maxLength": 5000,
      "description": "Text to match (for heading/paragraph)"
    },
    "matchMode": {
      "type": "string",
      "enum": [
        "exact",
        "contains",
        "startsWith",
        "regex"
      ],
      "description": "Matching mode (default: exact)"
    },
    "occurrence": {
      "type": "integer",
      "minimum": 1,
      "maximum": 1000,
      "description": "Which occurrence to target (1-based, default: 1)"
    },
    "offsetDirection": {
      "type": "string",
      "enum": [
        "before",
        "after"
      ],
      "description": "Offset direction from the matched element"
    },
    "offsetCount": {
      "type": "integer",
      "minimum": 1,
      "maximum": 1000,
      "description": "Number of paragraphs to offset (default: 1)"
    },
    "name": {
      "type": "string",
      "minLength": 1,
      "maxLength": 255,
      "description": "Bookmark name (required when by='bookmark')"
    },
    "level": {
      "type": "integer",
      "minimum": 1,
      "maximum": 9,
      "description": "Heading level filter (1-9). Applied BEFORE match and occurrence, narrowing to same-level headings only."
    },
    "row": {
      "type": "integer",
      "minimum": 1,
      "maximum": 1000,
      "description": "Row number (1-based)"
    },
    "column": {
      "type": "integer",
      "minimum": 1,
      "maximum": 1000,
      "description": "Column number (1-based)"
    },
    "text": {
      "type": "string",
      "maxLength": 100000,
      "description": "New cell text"
    }
  },
  "required": [
    "row",
    "column",
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_edit_cellsBatch-fill multiple table cells with a 2D data array. WHEN: need to fill an entire table or section of a table efficiently. NOT: just one cell to update? use word_edit_cell.
Input schema
{
  "type": "object",
  "properties": {
    "tableIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Table index (1-based, default: 1)"
    },
    "data": {
      "type": "array",
      "items": {
        "type": "array",
        "items": {
          "type": "string",
          "maxLength": 100000
        },
        "maxItems": 100
      },
      "minItems": 1,
      "maxItems": 1000,
      "description": "2D array of cell data (row-major)"
    }
  },
  "required": [
    "data"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_export_to_pdfWHEN: need a PDF copy of the current document for sharing or preview without changing the original docx. WHAT: exports the current document to PDF at the specified path. CONSTRAINT: does NOT change the active document or its save state. For saving in other formats (RTF, TXT, HTML), use word_save_as.
Input schema
{
  "type": "object",
  "properties": {
    "path": {
      "type": "string",
      "minLength": 1,
      "maxLength": 4096,
      "description": "Output PDF path (default: same name as source document with .pdf extension). Required if document is untitled."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_find_replaceWHEN: need to replace specific words or phrases across the entire document. WHAT: searches for text and replaces with new text, optionally case-sensitive or whole-word. CONSTRAINT: modifies document content; use word_find_text first to preview matches. Supports replace-all or single replace.
Input schema
{
  "type": "object",
  "properties": {
    "findText": {
      "type": "string",
      "minLength": 1,
      "maxLength": 5000,
      "description": "Text to find"
    },
    "replaceWith": {
      "type": "string",
      "maxLength": 5000,
      "description": "Replacement text"
    },
    "matchCase": {
      "type": "boolean",
      "description": "Case sensitive search (default: false)"
    },
    "matchWholeWord": {
      "type": "boolean",
      "description": "Match whole words only (default: false)"
    },
    "replaceAll": {
      "type": "boolean",
      "description": "Replace all occurrences (default: true). Set to false to replace only the first occurrence."
    }
  },
  "required": [
    "findText",
    "replaceWith"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_find_textWHEN: need to locate a keyword or phrase before editing. WHAT: searches forward/backward from cursor and positions cursor at the first match. CONSTRAINT: cursor moves to match; does NOT modify text. Use word_find_replace if replacement is needed.
Input schema
{
  "type": "object",
  "properties": {
    "findText": {
      "type": "string",
      "minLength": 1,
      "maxLength": 5000,
      "description": "Text to search for (case-insensitive by default)"
    },
    "matchCase": {
      "type": "boolean",
      "description": "Case sensitive search (default: false)"
    },
    "matchWholeWord": {
      "type": "boolean",
      "description": "Match whole words only (default: false)"
    },
    "direction": {
      "type": "string",
      "enum": [
        "forward",
        "backward"
      ],
      "description": "Search direction (default: forward)"
    },
    "wrap": {
      "type": "boolean",
      "description": "Wrap around to beginning/end if not found (default: true)"
    }
  },
  "required": [
    "findText"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_get_bookmarksWHEN: need to see available bookmarks for navigation or hyperlink targets. WHAT: lists all bookmarks with index and name. CONSTRAINT: read-only. For adding new bookmarks, use word_add_bookmark.
Input schema
{
  "type": "object",
  "properties": {}
}
—— · ——
word_get_commentsWHEN: need to review existing comments/feedback in the document. WHAT: lists all comments with index, author, and text preview. CONSTRAINT: read-only. For adding new comments, use word_add_comment.
Input schema
{
  "type": "object",
  "properties": {}
}
—— · ——
word_get_cursor_infoWHEN: need to know the current cursor position and selection range before editing. WHAT: returns cursor character offset, selection status, and selected text preview. CONSTRAINT: read-only; does NOT modify cursor position or document. Use before word_select_text or word_insert_at to verify position.
Input schema
{
  "type": "object",
  "properties": {}
}
—— · ——
word_get_infoWHEN: need to check document size, word count, page count, table count, or save status. WHAT: returns document statistics (words, paragraphs, pages, characters, sections, saved state). CONSTRAINT: read-only; does not modify document. For heading outline, use word_get_structure.
Input schema
{
  "type": "object",
  "properties": {}
}
—— · ——
word_get_listsWHEN: need to review bullet/numbered list structure or verify list content. WHAT: returns all lists with hierarchy (indentation level), item text, and item prefix (bullet/number). CONSTRAINT: read-only. For creating new lists, use word_insert_list.
Input schema
{
  "type": "object",
  "properties": {}
}
—— · ——
word_get_paragraphWHEN: need to read a specific paragraph's text when you know its index (e.g., from word_get_structure). WHAT: returns the text content of a single paragraph by 1-based index with preview truncation at 200 chars. CONSTRAINT: read-only. For full document content, use word_get_text.
Input schema
{
  "type": "object",
  "properties": {
    "index": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "description": "Paragraph index (1-based). Use word_get_structure() output like 'H1 ¶3 — Introduction' to find paragraph indices."
    }
  },
  "required": [
    "index"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_get_sectionsWHEN: need to understand document layout boundaries or section formatting. WHAT: returns all sections with orientation, column count, and page dimensions. CONSTRAINT: read-only. For changing section layout, use word_set_page_setup or word_insert_section_break.
Input schema
{
  "type": "object",
  "properties": {}
}
—— · ——
word_get_statusWHEN: always call first to understand what state Word is in before deciding the next action. WHAT: returns current state: NO_WORD (Word not running), NO_DOC (Word running, no document), DOC_ACTIVE (document open with details), or DIALOG (Word blocked by modal dialog). CONSTRAINT: read-only; zero side effects on Word state. Essential before any operation to avoid errors.
Input schema
{
  "type": "object",
  "properties": {
    "path": {
      "type": "string",
      "minLength": 1,
      "maxLength": 4096,
      "description": "Optional file path to check if a specific file is open, tracked, and active"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_get_structureWHEN: need to navigate or understand the document's organization via heading hierarchy. WHAT: returns a hierarchical outline with paragraph indices (e.g., 'H1 ¶3 — Introduction'). CONSTRAINT: read-only. For full text content, use word_get_text. Paragraph indices from this output can be used with word_go_to_paragraph.
Input schema
{
  "type": "object",
  "properties": {}
}
—— · ——
word_get_table_dataWHEN: need to read table content as structured data to verify or analyze it. WHAT: extracts all rows and columns of a table by index (1-based) with table count info. CONSTRAINT: read-only. For editing table content, use word_edit_cell or word_edit_cells.
Input schema
{
  "type": "object",
  "properties": {
    "index": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "default": 1,
      "description": "Table index (1-based). Use word_get_info to check table count."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_get_textWHEN: need to read the entire document content to understand what's written. WHAT: returns the full plain text of the current document. CONSTRAINT: read-only. For documents over 10,000 characters, a summary with pagination info is returned instead. For heading structure, use word_get_structure.
Input schema
{
  "type": "object",
  "properties": {}
}
—— · ——
word_go_toWHEN: need to jump to a structural location (page/section/line/bookmark/document-end). WHAT: navigates to the first/last/next/previous occurrence of the target type. CONSTRAINT: 'bookmark' requires an existing bookmark created via word_add_bookmark. For exact paragraph navigation, use word_go_to_paragraph.
Input schema
{
  "type": "object",
  "properties": {
    "what": {
      "type": "string",
      "enum": [
        "page",
        "section",
        "line",
        "bookmark",
        "end"
      ],
      "description": "Target (default: page)"
    },
    "which": {
      "type": "string",
      "enum": [
        "first",
        "last",
        "next",
        "previous"
      ],
      "description": "Which occurrence (default: first)"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_go_to_paragraphWHEN: you know the exact paragraph index from word_get_structure. WHAT: moves cursor to the start of a specific paragraph by 1-based index. CONSTRAINT: requires valid paragraph index; use word_get_structure() first to obtain indices. For heading-based navigation, use word_select_at({by:'heading', match:'...'}).
Input schema
{
  "type": "object",
  "properties": {
    "index": {
      "type": "integer",
      "minimum": 1,
      "maximum": 1000000,
      "description": "Paragraph index (1-based, obtained from word_get_structure output like 'H1 ¶3')"
    }
  },
  "required": [
    "index"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_insert_atInsert Markdown content at a semantic location. Supports headings, bold, italic, lists, tables, code blocks, blockquotes. WHEN: need to write structured content at a specific heading/paragraph. NOT: creating a new document? use word_stream_start instead.
Input schema
{
  "type": "object",
  "properties": {
    "by": {
      "type": "string",
      "enum": [
        "heading",
        "paragraph",
        "table",
        "bookmark",
        "cursor"
      ],
      "description": "Target type (default: heading)"
    },
    "match": {
      "type": "string",
      "maxLength": 5000,
      "description": "Text to match (for heading/paragraph)"
    },
    "matchMode": {
      "type": "string",
      "enum": [
        "exact",
        "contains",
        "startsWith",
        "regex"
      ],
      "description": "Matching mode (default: exact)"
    },
    "occurrence": {
      "type": "integer",
      "minimum": 1,
      "maximum": 1000,
      "description": "Which occurrence to target (1-based, default: 1)"
    },
    "offsetDirection": {
      "type": "string",
      "enum": [
        "before",
        "after"
      ],
      "description": "Offset direction from the matched element"
    },
    "offsetCount": {
      "type": "integer",
      "minimum": 1,
      "maximum": 1000,
      "description": "Number of paragraphs to offset (default: 1)"
    },
    "name": {
      "type": "string",
      "minLength": 1,
      "maxLength": 255,
      "description": "Bookmark name (required when by='bookmark')"
    },
    "level": {
      "type": "integer",
      "minimum": 1,
      "maximum": 9,
      "description": "Heading level filter (1-9). Applied BEFORE match and occurrence, narrowing to same-level headings only."
    },
    "text": {
      "type": "string",
      "maxLength": 100000,
      "description": "Markdown content to insert"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_insert_breakWHEN: need to force a page break or add a horizontal line separator. WHAT: type=page inserts a page break (content continues on next page); type=line inserts a horizontal rule line. CONSTRAINT: page break changes pagination. For section breaks (different margins/orientation) use word_insert_section_break.
Input schema
{
  "type": "object",
  "properties": {
    "type": {
      "type": "string",
      "enum": [
        "page",
        "line"
      ],
      "description": "'page' for a page break (new page), 'line' for a horizontal rule (thematic break)"
    }
  },
  "required": [
    "type"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_insert_chartWHEN: need to visualize data as a chart (column, bar, line, pie, area). WHAT: inserts a chart with 2D data array at cursor position. CONSTRAINT: first row = column headers, first column = row labels. Chart data is embedded and editable in Word. For inserting image files from disk, use word_insert_image.
Input schema
{
  "type": "object",
  "properties": {
    "type": {
      "type": "string",
      "enum": [
        "column",
        "bar",
        "line",
        "pie",
        "area"
      ],
      "description": "Chart type: 'column'=vertical bars, 'bar'=horizontal bars, 'line'=line graph, 'pie'=circular, 'area'=filled line"
    },
    "data": {
      "type": "array",
      "items": {
        "type": "array",
        "items": {
          "type": [
            "string",
            "number"
          ]
        },
        "minItems": 1
      },
      "minItems": 1,
      "maxItems": 100,
      "description": "2D data table. First row = headers (strings). First column = categories/labels. Example for sales by quarter: [['Q1','Q2','Q3'], [100, 200, 150]]"
    },
    "title": {
      "type": "string",
      "maxLength": 255,
      "description": "Chart title shown above the chart"
    },
    "width": {
      "type": "number",
      "exclusiveMinimum": 0,
      "maximum": 1000,
      "description": "Width in points (default: 400). About 14cm at 72dpi."
    },
    "height": {
      "type": "number",
      "exclusiveMinimum": 0,
      "maximum": 1000,
      "description": "Height in points (default: 250). About 9cm at 72dpi."
    },
    "quiet": {
      "type": "boolean",
      "description": "简洁输出模式"
    }
  },
  "required": [
    "type",
    "data"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_insert_imageWHEN: need to embed a picture from disk into the document. WHAT: inserts an image (jpg, png, gif, bmp) at the cursor position at optional dimensions. CONSTRAINT: file must exist on disk; only raster formats supported (no SVG). The image is embedded (copied into .docx), not linked.
Input schema
{
  "type": "object",
  "properties": {
    "imagePath": {
      "type": "string",
      "minLength": 1,
      "maxLength": 4096,
      "description": "Full path to the image file (supported: .jpg, .png, .gif, .bmp)"
    },
    "width": {
      "type": "number",
      "exclusiveMinimum": 0,
      "maximum": 1000,
      "description": "Width in points (default: original image width). 72pt = 1 inch."
    },
    "height": {
      "type": "number",
      "exclusiveMinimum": 0,
      "maximum": 1000,
      "description": "Height in points (default: original image height). Omit to preserve aspect ratio."
    },
    "quiet": {
      "type": "boolean",
      "description": "简洁输出模式"
    }
  },
  "required": [
    "imagePath"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_insert_listWHEN: need to create a structured bulleted or numbered list. WHAT: inserts a multi-item list at the cursor position. CONSTRAINT: supports bullet or numbered types only (no checkboxes). For rich markdown content (lists with headings/tables), use word_stream_block instead.
Input schema
{
  "type": "object",
  "properties": {
    "type": {
      "type": "string",
      "enum": [
        "bullet",
        "number"
      ],
      "description": "List type: 'bullet' for unordered (•), 'number' for ordered (1. 2. 3.)"
    },
    "items": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 100000
      },
      "minItems": 1,
      "maxItems": 500,
      "description": "List items as plain text strings. Each item becomes one list entry."
    }
  },
  "required": [
    "type",
    "items"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_insert_paragraphWHEN: need to add spacing or move to a new line. WHAT: inserts N paragraph breaks (blank lines) at the cursor position. CONSTRAINT: max 100 breaks. For rich content (headings, lists, tables) use word_stream_block or word_insert_at instead.
Input schema
{
  "type": "object",
  "properties": {
    "count": {
      "type": "integer",
      "minimum": 1,
      "maximum": 100,
      "description": "Number of paragraph breaks (default: 1)"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_insert_section_breakWHEN: need to change page layout (margins, orientation, columns) within the same document. WHAT: inserts a section divider that allows different formatting per section. CONSTRAINT: type=nextPage starts new section on next page; type=continuous starts on same page. After insertion, page setup settings apply to the new section only.
Input schema
{
  "type": "object",
  "properties": {
    "type": {
      "type": "string",
      "enum": [
        "nextPage",
        "continuous",
        "evenPage",
        "oddPage"
      ],
      "description": "Section break type (default: nextPage). nextPage=new section on next page, continuous=same page, evenPage/oddPage=start on even/odd numbered page"
    },
    "quiet": {
      "type": "boolean",
      "description": "简洁输出模式"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_insert_tableWHEN: the user wants to add tabular data to the current document. WHAT: creates a new table at the cursor position with N rows × M columns, optionally filled with data. CONSTRAINT: max 500 rows × 100 columns. Fails if cursor is inside a header/footer. For batch-filling existing tables, use word_edit_cells.
Input schema
{
  "type": "object",
  "properties": {
    "rows": {
      "type": "integer",
      "minimum": 1,
      "maximum": 500,
      "description": "Number of rows (max 500)"
    },
    "columns": {
      "type": "integer",
      "minimum": 1,
      "maximum": 100,
      "description": "Number of columns (max 100)"
    },
    "data": {
      "type": "array",
      "items": {
        "type": "array",
        "items": {
          "type": "string",
          "maxLength": 100000
        },
        "maxItems": 100
      },
      "maxItems": 1000,
      "description": "Optional 2D cell data array (array of rows, each row is array of cell strings). Example: [['Name','Age','City'],['Alice','30','NYC']]"
    },
    "autoFitBehavior": {
      "type": "string",
      "enum": [
        "fixed",
        "contents",
        "window"
      ],
      "description": "Auto-fit behavior: 'fixed'=fixed column widths, 'contents'=fit to content, 'window'=fit to page width"
    },
    "quiet": {
      "type": "boolean",
      "description": "简洁输出模式"
    }
  },
  "required": [
    "rows",
    "columns"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_insert_textboxWHEN: need positioned overlay text outside the normal document flow (e.g., callout, sidebar, annotation). WHAT: inserts a floating text box at specified position and dimensions. CONSTRAINT: text box is positioned absolutely (not inline with text). For normal inline content, use word_stream_block or word_type_text.
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "maxLength": 10000,
      "description": "Text content inside the text box (plain text only)"
    },
    "width": {
      "type": "number",
      "exclusiveMinimum": 0,
      "maximum": 1000,
      "description": "Width in points (default: 200). About 7cm at 72dpi."
    },
    "height": {
      "type": "number",
      "exclusiveMinimum": 0,
      "maximum": 1000,
      "description": "Height in points (default: 100). About 3.5cm at 72dpi."
    },
    "orientation": {
      "type": "string",
      "enum": [
        "horizontal",
        "vertical"
      ],
      "description": "Text orientation inside the box (default: horizontal)"
    },
    "positionLeft": {
      "type": "number",
      "minimum": 0,
      "maximum": 2000,
      "description": "Left position from page edge in points (default: 50)"
    },
    "positionTop": {
      "type": "number",
      "minimum": 0,
      "maximum": 2000,
      "description": "Top position from page edge in points (default: 50)"
    },
    "quiet": {
      "type": "boolean",
      "description": "简洁输出模式"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_insert_tocWHEN: document has headings and needs an auto-generated table of contents. WHAT: inserts a Table of Contents field at the cursor position that builds from document headings. CONSTRAINT: TOC is a field that requires manual update (right-click > Update Field) after headings change. For manual item lists, use word_insert_list instead.
Input schema
{
  "type": "object",
  "properties": {}
}
—— · ——
word_list_stylesWHEN: need to see what styles are available in the document before applying one. WHAT: lists all in-use styles (both built-in and custom) with their type. CONSTRAINT: read-only; does not modify document. Use before word_apply_style to discover available style names.
Input schema
{
  "type": "object",
  "properties": {}
}
—— · ——
word_locateResolve a semantic location in the document and return position info. WHEN: need to find where a heading/paragraph/table/bookmark is before editing. NOT: want to move cursor? use word_select_at instead.
Input schema
{
  "type": "object",
  "properties": {
    "by": {
      "type": "string",
      "enum": [
        "heading",
        "paragraph",
        "table",
        "bookmark",
        "cursor"
      ],
      "description": "Target type (default: heading)"
    },
    "match": {
      "type": "string",
      "maxLength": 5000,
      "description": "Text to match (for heading/paragraph)"
    },
    "matchMode": {
      "type": "string",
      "enum": [
        "exact",
        "contains",
        "startsWith",
        "regex"
      ],
      "description": "Matching mode (default: exact)"
    },
    "occurrence": {
      "type": "integer",
      "minimum": 1,
      "maximum": 1000,
      "description": "Which occurrence to target (1-based, default: 1)"
    },
    "offsetDirection": {
      "type": "string",
      "enum": [
        "before",
        "after"
      ],
      "description": "Offset direction from the matched element"
    },
    "offsetCount": {
      "type": "integer",
      "minimum": 1,
      "maximum": 1000,
      "description": "Number of paragraphs to offset (default: 1)"
    },
    "name": {
      "type": "string",
      "minLength": 1,
      "maxLength": 255,
      "description": "Bookmark name (required when by='bookmark')"
    },
    "level": {
      "type": "integer",
      "minimum": 1,
      "maximum": 9,
      "description": "Heading level filter (1-9). Applied BEFORE match and occurrence, narrowing to same-level headings only."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_merge_table_cellsMerge a range of table cells into one cell. WHEN: need to combine cells for a header spanning multiple columns or rows. NOT: need to split a merged cell back? undo with word_undo_redo.
Input schema
{
  "type": "object",
  "properties": {
    "tableIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Table index (1-based, default: 1)"
    },
    "rowStart": {
      "type": "integer",
      "minimum": 1,
      "description": "Start row (1-based)"
    },
    "colStart": {
      "type": "integer",
      "minimum": 1,
      "description": "Start column (1-based)"
    },
    "rowEnd": {
      "type": "integer",
      "minimum": 1,
      "description": "End row (1-based)"
    },
    "colEnd": {
      "type": "integer",
      "minimum": 1,
      "description": "End column (1-based)"
    }
  },
  "required": [
    "rowStart",
    "colStart",
    "rowEnd",
    "colEnd"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_openWHEN: need to open a file that is not already tracked by the session, forcing a fresh window. WHAT: opens an existing .docx file from disk in a new Word window. CONSTRAINT: always creates a new window. Use word_document instead for smart switching (preferred in most cases). File must exist on disk.
Input schema
{
  "type": "object",
  "properties": {
    "path": {
      "type": "string",
      "minLength": 1,
      "maxLength": 4096,
      "description": "Full path to the .docx file to open in a new Word window"
    }
  },
  "required": [
    "path"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_quitWHEN: need to completely shut down Microsoft Word (e.g., to force-restart after a hang). WHAT: closes all documents and quits Word.exe. CONSTRAINT: already-saved files are preserved; unsaved changes may be lost. Server restarts Word automatically on next operation. Use word_close instead for normal document closing.
Input schema
{
  "type": "object",
  "properties": {}
}
—— · ——
word_replace_variablesWHEN: generating documents from templates with {{placeholder}} markers such as {{clientName}}, {{date}}, {{amount}}. WHAT: finds all {{key}} patterns in the document and replaces each with the corresponding value from the provided object. CONSTRAINT: keys must match exactly (case-sensitive). For plain text find-and-replace without templates, use word_find_replace.
Input schema
{
  "type": "object",
  "properties": {
    "variables": {
      "type": "object",
      "additionalProperties": {
        "type": "string",
        "maxLength": 100000
      },
      "propertyNames": {
        "minLength": 1,
        "maxLength": 100
      },
      "description": "Key-value pairs: keys are variable names (without {{}}), values are replacement text"
    }
  },
  "required": [
    "variables"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_saveWHEN: want to persist changes to the current file. WHAT: saves the active document, creating a .bak backup before overwriting. CONSTRAINT: undo history is cleared after save. Cannot undo past a save boundary. For saving to a new path or format, use word_save_as.
Input schema
{
  "type": "object",
  "properties": {}
}
—— · ——
word_save_asWHEN: need to create a copy, export to different format (PDF, RTF, TXT, HTML), or save to a new location. WHAT: saves the current document with a new path/format, then switches to the new file. CONSTRAINT: format is auto-detected from file extension. For PDF export without changing the active document, use word_export_to_pdf.
Input schema
{
  "type": "object",
  "properties": {
    "path": {
      "type": "string",
      "minLength": 1,
      "maxLength": 4096,
      "description": "Full save path (e.g., 'C:\\output\\report.pdf' or 'C:\\output\\copy.docx')"
    },
    "format": {
      "type": "string",
      "enum": [
        "docx",
        "doc",
        "pdf",
        "rtf",
        "txt",
        "html",
        "mht",
        "xml",
        "odt",
        "dotx",
        "dotm",
        "docm"
      ],
      "description": "File format (default: determined from file extension). Use 'pdf' for PDF, 'txt' for plain text."
    }
  },
  "required": [
    "path"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_select_allWHEN: need to format, copy, or delete the entire document at once. WHAT: selects all content in the active document (Ctrl+A). CONSTRAINT: selection covers the full document range; subsequent actions (delete, set_font, copy) apply to every paragraph.
Input schema
{
  "type": "object",
  "properties": {}
}
—— · ——
word_select_atMove cursor to a semantic location (heading/paragraph/table/bookmark). WHEN: need to navigate precisely without calculating paragraph numbers. NOT: just want to check location? use word_locate.
Input schema
{
  "type": "object",
  "properties": {
    "by": {
      "type": "string",
      "enum": [
        "heading",
        "paragraph",
        "table",
        "bookmark",
        "cursor"
      ],
      "description": "Target type (default: heading)"
    },
    "match": {
      "type": "string",
      "maxLength": 5000,
      "description": "Text to match (for heading/paragraph)"
    },
    "matchMode": {
      "type": "string",
      "enum": [
        "exact",
        "contains",
        "startsWith",
        "regex"
      ],
      "description": "Matching mode (default: exact)"
    },
    "occurrence": {
      "type": "integer",
      "minimum": 1,
      "maximum": 1000,
      "description": "Which occurrence to target (1-based, default: 1)"
    },
    "offsetDirection": {
      "type": "string",
      "enum": [
        "before",
        "after"
      ],
      "description": "Offset direction from the matched element"
    },
    "offsetCount": {
      "type": "integer",
      "minimum": 1,
      "maximum": 1000,
      "description": "Number of paragraphs to offset (default: 1)"
    },
    "name": {
      "type": "string",
      "minLength": 1,
      "maxLength": 255,
      "description": "Bookmark name (required when by='bookmark')"
    },
    "level": {
      "type": "integer",
      "minimum": 1,
      "maximum": 9,
      "description": "Heading level filter (1-9). Applied BEFORE match and occurrence, narrowing to same-level headings only."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_select_currentWHEN: need to quickly format or copy the word or paragraph under the cursor without specifying character positions. WHAT: selects either the current word (cursor within a word) or the current paragraph (cursor within any paragraph). CONSTRAINT: scope=word selects one word; scope=paragraph selects the entire containing paragraph.
Input schema
{
  "type": "object",
  "properties": {
    "scope": {
      "type": "string",
      "enum": [
        "word",
        "paragraph"
      ],
      "description": "Selection scope: 'word' for the single word under cursor, 'paragraph' for the entire current paragraph"
    }
  },
  "required": [
    "scope"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_select_textWHEN: need to select a precise character range for targeted formatting or copying. WHAT: selects text from character position N with length L (0-based). CONSTRAINT: requires knowing start/length from word_get_cursor_info. For whole-document selection use word_select_all; for current word/paragraph use word_select_current.
Input schema
{
  "type": "object",
  "properties": {
    "start": {
      "type": "integer",
      "minimum": 0,
      "description": "Starting character position (0-based). Use word_get_cursor_info to find positions."
    },
    "length": {
      "type": "integer",
      "minimum": 1,
      "maximum": 1000000,
      "description": "Number of characters to select"
    }
  },
  "required": [
    "start",
    "length"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_set_body_indentWHEN: formatting a document (especially Chinese academic papers) where each body paragraph needs standard first-line indent. WHAT: applies first-line indent to all paragraphs using the 'Normal' style. CONSTRAINT: only affects 'Normal' style paragraphs; explicitly-formatted paragraphs are skipped. For individual paragraphs, use word_set_paragraph({firstLineIndent:...}).
Input schema
{
  "type": "object",
  "properties": {
    "indent": {
      "type": "number",
      "minimum": 0,
      "maximum": 10,
      "description": "First line indent in cm. For Chinese 12pt font: 0.74cm ≈ 2 characters. For English 12pt: ~1.27cm ≈ 5 spaces."
    }
  },
  "required": [
    "indent"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_set_cell_fontSet font formatting for a specific table cell. WHEN: after filling a cell, to style its text. NOT: want to format all cells at once? consider word_apply_table_style.
Input schema
{
  "type": "object",
  "properties": {
    "tableIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Table index (1-based, default: 1)"
    },
    "row": {
      "type": "integer",
      "minimum": 1,
      "description": "Row number (1-based)"
    },
    "column": {
      "type": "integer",
      "minimum": 1,
      "description": "Column number (1-based)"
    },
    "name": {
      "type": "string",
      "maxLength": 100,
      "description": "Font name (e.g. 'Arial')"
    },
    "size": {
      "type": "number",
      "minimum": 1,
      "maximum": 1638,
      "description": "Font size in points"
    },
    "bold": {
      "type": "boolean",
      "description": "Bold"
    },
    "italic": {
      "type": "boolean",
      "description": "Italic"
    },
    "underline": {
      "type": "string",
      "enum": [
        "none",
        "single",
        "double",
        "wavy"
      ],
      "description": "Underline style"
    },
    "color": {
      "type": "string",
      "enum": [
        "auto",
        "black",
        "blue",
        "turquoise",
        "bright_green",
        "pink",
        "red",
        "yellow",
        "white",
        "dark_blue",
        "teal",
        "green",
        "violet",
        "dark_red",
        "dark_yellow",
        "gray_50",
        "gray_25"
      ],
      "description": "Font color"
    },
    "strikethrough": {
      "type": "boolean",
      "description": "Strikethrough"
    }
  },
  "required": [
    "row",
    "column"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_set_cell_vertical_alignmentSet vertical alignment for a specific cell. WHEN: text inside a cell needs to be top/bottom aligned. NOT: want horizontal alignment? use word_set_paragraph.
Input schema
{
  "type": "object",
  "properties": {
    "tableIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Table index (1-based, default: 1)"
    },
    "row": {
      "type": "integer",
      "minimum": 1,
      "description": "Row number (1-based)"
    },
    "column": {
      "type": "integer",
      "minimum": 1,
      "description": "Column number (1-based)"
    },
    "alignment": {
      "type": "string",
      "enum": [
        "top",
        "center",
        "bottom"
      ],
      "description": "Vertical alignment"
    }
  },
  "required": [
    "row",
    "column",
    "alignment"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_set_column_widthSet the width of a specific column in points. WHEN: need to adjust column width for better table layout. NOT: want to set row height? use word_set_row_height.
Input schema
{
  "type": "object",
  "properties": {
    "tableIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Table index (1-based, default: 1)"
    },
    "column": {
      "type": "integer",
      "minimum": 1,
      "description": "Column number (1-based)"
    },
    "width": {
      "type": "number",
      "minimum": 1,
      "maximum": 5000,
      "description": "Width in points (e.g. 100 ≈ 3.5cm)"
    }
  },
  "required": [
    "column",
    "width"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_set_columnsWHEN: need newspaper-style multi-column text layout (like a newsletter). WHAT: sets the current section to N columns with optional spacing. CONSTRAINT: applies to current section only; use word_insert_section_break first to create separate sections with different column counts.
Input schema
{
  "type": "object",
  "properties": {
    "count": {
      "type": "integer",
      "minimum": 1,
      "maximum": 4,
      "description": "Number of columns (1-4). 1=single column (normal), 2=newspaper style, 3-4=narrower columns"
    },
    "spacing": {
      "type": "number",
      "minimum": 0,
      "maximum": 20,
      "description": "Space between columns in cm (default: document default, typically 1.27cm)"
    }
  },
  "required": [
    "count"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_set_fontWHEN: need to change text appearance (font, size, bold, color, etc.) on selected text or set forward-typing style. WHAT: applies font formatting to current selection, or sets the default for subsequently typed text if nothing is selected. CONSTRAINT: must select text first for retroactive formatting; without selection only affects NEW text after cursor.
Input schema
{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 100,
      "description": "Font name (e.g. 'Arial', 'SimSun', 'Times New Roman', 'Calibri')"
    },
    "size": {
      "type": "number",
      "minimum": 1,
      "maximum": 1638,
      "description": "Font size in points (e.g. 12 for body text, 16 for headings)"
    },
    "bold": {
      "type": "boolean",
      "description": "Bold formatting"
    },
    "italic": {
      "type": "boolean",
      "description": "Italic formatting"
    },
    "underline": {
      "type": "string",
      "enum": [
        "none",
        "single",
        "double",
        "wavy"
      ],
      "description": "Underline style"
    },
    "color": {
      "type": "string",
      "enum": [
        "auto",
        "black",
        "blue",
        "turquoise",
        "bright_green",
        "pink",
        "red",
        "yellow",
        "white",
        "dark_blue",
        "teal",
        "green",
        "violet",
        "dark_red",
        "dark_yellow",
        "gray_50",
        "gray_25"
      ],
      "description": "Font color (enumerated Word color)"
    },
    "strikethrough": {
      "type": "boolean",
      "description": "Strikethrough"
    },
    "highlightColor": {
      "$ref": "#/properties/color",
      "description": "Highlight (marker) color"
    },
    "superscript": {
      "type": "boolean",
      "description": "Superscript (e.g., for footnotes or exponents)"
    },
    "subscript": {
      "type": "boolean",
      "description": "Subscript (e.g., for chemical formulas)"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_set_page_numbersWHEN: every page needs automatic page numbering. WHAT: inserts page number field in header or footer with optional alignment for the specified section. CONSTRAINT: page numbers are auto-generated (update when pages change). For custom text alongside page numbers, use word_set_page_region with page number field.
Input schema
{
  "type": "object",
  "properties": {
    "target": {
      "type": "string",
      "enum": [
        "header",
        "footer"
      ],
      "description": "Where to place page numbers (header=top, footer=bottom)"
    },
    "alignment": {
      "type": "string",
      "enum": [
        "left",
        "center",
        "right"
      ],
      "description": "Page number alignment (default: center)"
    },
    "sectionIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Section index (1-based, default: last/current section)"
    },
    "quiet": {
      "type": "boolean",
      "description": "简洁输出模式"
    }
  },
  "required": [
    "target"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_set_page_regionWHEN: every page needs repeating text at the top (header) or bottom (footer). WHAT: sets header or footer text with optional alignment for the current or specified section. CONSTRAINT: headers/footers repeat on every page of the section. For page numbers only, use word_set_page_numbers which is simpler.
Input schema
{
  "type": "object",
  "properties": {
    "target": {
      "type": "string",
      "enum": [
        "header",
        "footer"
      ],
      "description": "'header' for top of page, 'footer' for bottom of page"
    },
    "text": {
      "type": "string",
      "maxLength": 5000,
      "description": "Header/footer text content (plain text)"
    },
    "alignment": {
      "type": "string",
      "enum": [
        "left",
        "center",
        "right"
      ],
      "description": "Text alignment within the header/footer region"
    },
    "sectionIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Section index (1-based, default: last/current section)"
    },
    "quiet": {
      "type": "boolean",
      "description": "简洁输出模式"
    }
  },
  "required": [
    "target",
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_set_page_setupWHEN: need to set page dimensions, margins, or orientation before/after writing content. WHAT: configures page layout for the current section (margins, paper size, orientation). CONSTRAINT: margins apply to current section only; use word_insert_section_break first for different layouts per section.
Input schema
{
  "type": "object",
  "properties": {
    "topMargin": {
      "type": "number",
      "minimum": 0,
      "maximum": 100,
      "description": "Top margin in cm (default: 2.54cm / 1 inch)"
    },
    "bottomMargin": {
      "type": "number",
      "minimum": 0,
      "maximum": 100,
      "description": "Bottom margin in cm"
    },
    "leftMargin": {
      "type": "number",
      "minimum": 0,
      "maximum": 100,
      "description": "Left margin in cm"
    },
    "rightMargin": {
      "type": "number",
      "minimum": 0,
      "maximum": 100,
      "description": "Right margin in cm"
    },
    "orientation": {
      "type": "string",
      "enum": [
        "portrait",
        "landscape"
      ],
      "description": "Page orientation: portrait (vertical) or landscape (horizontal)"
    },
    "pageWidth": {
      "type": "number",
      "minimum": 5,
      "maximum": 100,
      "description": "Page width in cm (default: 21cm for A4 portrait)"
    },
    "pageHeight": {
      "type": "number",
      "minimum": 5,
      "maximum": 100,
      "description": "Page height in cm (default: 29.7cm for A4)"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_set_paragraphWHEN: need to adjust paragraph layout (alignment, indentation, line spacing, spacing before/after). WHAT: sets formatting for the current paragraph(s). CONSTRAINT: applies to the paragraph containing the cursor. For document-wide defaults, configure Normal style via word_stream_start baseStyleProfile.
Input schema
{
  "type": "object",
  "properties": {
    "alignment": {
      "type": "string",
      "enum": [
        "left",
        "center",
        "right",
        "justify"
      ],
      "description": "Paragraph alignment"
    },
    "leftIndent": {
      "type": "number",
      "minimum": -100,
      "maximum": 100,
      "description": "Left indent in cm (negative values for outdenting/hanging)"
    },
    "rightIndent": {
      "type": "number",
      "minimum": -100,
      "maximum": 100,
      "description": "Right indent in cm"
    },
    "firstLineIndent": {
      "type": "number",
      "minimum": -100,
      "maximum": 100,
      "description": "First line indent in cm (e.g., 0.74 ≈ 2 Chinese characters at 12pt)"
    },
    "spaceBefore": {
      "type": "number",
      "minimum": 0,
      "maximum": 1584,
      "description": "Space before paragraph in points (12pt ≈ one blank line)"
    },
    "spaceAfter": {
      "type": "number",
      "minimum": 0,
      "maximum": 1584,
      "description": "Space after paragraph in points"
    },
    "lineSpacing": {
      "type": "number",
      "minimum": 0,
      "maximum": 1584,
      "description": "Line spacing value. With 'multiple' rule: 1.5=1.5x, 2=double. With 'exactly': value in points."
    },
    "lineSpacingRule": {
      "type": "string",
      "enum": [
        "single",
        "one_point_five",
        "double",
        "at_least",
        "exactly",
        "multiple"
      ],
      "description": "Line spacing rule: 'single'=default, 'multiple'=multiplier in lineSpacing, 'exactly'=fixed pts"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_set_propertiesWHEN: need to fill in document metadata for search/filing/organization purposes. WHAT: sets document-level properties (title, author, subject, keywords, comments, category). CONSTRAINT: metadata is embedded in the .docx file; visible in File > Info. Does NOT affect visible document content.
Input schema
{
  "type": "object",
  "properties": {
    "title": {
      "type": "string",
      "maxLength": 255,
      "description": "Document title (appears in file properties, search results)"
    },
    "author": {
      "type": "string",
      "maxLength": 255,
      "description": "Author name"
    },
    "subject": {
      "type": "string",
      "maxLength": 255,
      "description": "Subject or category description"
    },
    "keywords": {
      "type": "string",
      "maxLength": 1000,
      "description": "Keywords for search (comma-separated, e.g., 'report, Q3, financial')"
    },
    "comments": {
      "type": "string",
      "maxLength": 5000,
      "description": "Comments/description for the document"
    },
    "category": {
      "type": "string",
      "maxLength": 255,
      "description": "Category (e.g., 'Report', 'Proposal', 'Invoice')"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_set_row_heightSet the height of a specific row in points. WHEN: need to adjust row height for content fit or visual spacing. NOT: want to set column width? use word_set_column_width.
Input schema
{
  "type": "object",
  "properties": {
    "tableIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Table index (1-based, default: 1)"
    },
    "row": {
      "type": "integer",
      "minimum": 1,
      "description": "Row number (1-based)"
    },
    "height": {
      "type": "number",
      "minimum": 1,
      "maximum": 5000,
      "description": "Height in points (e.g. 30 ≈ 1cm)"
    }
  },
  "required": [
    "row",
    "height"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_set_table_bordersSet table border style, color, and width. WHEN: table exists and needs visual styling. NOT: want background color? use word_set_table_shading.
Input schema
{
  "type": "object",
  "properties": {
    "tableIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Table index (1-based, default: 1)"
    },
    "inside": {
      "type": "object",
      "properties": {
        "style": {
          "type": "string",
          "enum": [
            "none",
            "single",
            "dot",
            "dash_small",
            "dash_large",
            "dash",
            "dash_dot",
            "double"
          ],
          "description": "Border line style"
        },
        "color": {
          "type": "string",
          "enum": [
            "auto",
            "black",
            "blue",
            "turquoise",
            "bright_green",
            "pink",
            "red",
            "yellow",
            "white",
            "dark_blue",
            "teal",
            "green",
            "violet",
            "dark_red",
            "dark_yellow",
            "gray_50",
            "gray_25"
          ],
          "description": "Border color"
        },
        "size": {
          "type": "integer",
          "minimum": 2,
          "maximum": 48,
          "description": "Line width in 1/4pt (8=1pt)"
        }
      },
      "additionalProperties": false
    },
    "outside": {
      "type": "object",
      "properties": {
        "style": {
          "type": "string",
          "enum": [
            "none",
            "single",
            "dot",
            "dash_small",
            "dash_large",
            "dash",
            "dash_dot",
            "double"
          ],
          "description": "Border line style"
        },
        "color": {
          "$ref": "#/properties/inside/properties/color",
          "description": "Border color"
        },
        "size": {
          "type": "integer",
          "minimum": 2,
          "maximum": 48,
          "description": "Line width in 1/4pt (8=1pt)"
        }
      },
      "additionalProperties": false
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_set_table_shadingSet background shading color for a table or a specific row. WHEN: need to add background color to highlight table header or rows. NOT: want to set borders instead? use word_set_table_borders.
Input schema
{
  "type": "object",
  "properties": {
    "tableIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Table index (1-based, default: 1)"
    },
    "color": {
      "type": "string",
      "pattern": "^#[0-9a-fA-F]{6}$",
      "description": "Hex color like #E8F0FE"
    },
    "target": {
      "type": "string",
      "enum": [
        "table",
        "row"
      ],
      "description": "Apply to entire table or first row only"
    },
    "rowIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Row number when target='row' (1-based, default: 1)"
    }
  },
  "required": [
    "color"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_set_track_changesWHEN: before making edits that need to be reviewed later in a collaborative workflow. WHAT: enables or disables Word's Track Changes (revision marking). CONSTRAINT: when enabled, all insertions/deletions are marked in red/underline for review. To finalize (accept/reject all changes), use word_track_changes_apply.
Input schema
{
  "type": "object",
  "properties": {
    "enable": {
      "type": "boolean",
      "description": "true to enable track changes (revisions recorded), false to disable (edits apply directly)"
    }
  },
  "required": [
    "enable"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_set_watermarkWHEN: need to indicate document status (DRAFT, CONFIDENTIAL, SAMPLE) with a background watermark. WHAT: adds or removes a diagonal text watermark across every page. CONSTRAINT: only one watermark at a time; setting a new one replaces the old. Watermarks appear behind text. For repeating text in a specific region, use headers/footers instead.
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "maxLength": 100,
      "description": "Watermark text (e.g., 'DRAFT', 'CONFIDENTIAL', 'SAMPLE', 'URGENT')"
    },
    "remove": {
      "type": "boolean",
      "description": "Set true to remove existing watermarks (text is ignored)"
    },
    "fontSize": {
      "type": "integer",
      "minimum": 12,
      "maximum": 200,
      "description": "Font size in points (default: 48). Larger = more prominent."
    },
    "color": {
      "type": "string",
      "enum": [
        "auto",
        "black",
        "blue",
        "turquoise",
        "bright_green",
        "pink",
        "red",
        "yellow",
        "white",
        "dark_blue",
        "teal",
        "green",
        "violet",
        "dark_red",
        "dark_yellow",
        "gray_50",
        "gray_25"
      ],
      "description": "Watermark text color (default: gray)"
    },
    "quiet": {
      "type": "boolean",
      "description": "简洁输出模式"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_stream_blockWHEN: after word_stream_start, to write document content incrementally in chapters/sections. WHAT: writes a Markdown content block into the active streaming session — content appears in Word in real time. CONSTRAINT: requires an active streaming session created by word_stream_start. Supports headings, bold, italic, lists, tables, code blocks, blockquotes.
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "maxLength": 100000,
      "description": "Markdown content to write. Send chapters/sections one at a time. Supports: # H1, ## H2, **bold**, *italic*, - lists, 1. numbered, |table|, ```code```, > quote, --- hr."
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_stream_endWHEN: finished writing all content with word_stream_block calls. WHAT: ends the streaming session, saves the document, and optionally exports to PDF. CONSTRAINT: after this call, no more word_stream_block calls are allowed. Use word_document to reopen the saved file for further editing.
Input schema
{
  "type": "object",
  "properties": {
    "save": {
      "type": "boolean",
      "description": "Whether to save the document (default: true). Set false to discard the streaming session."
    },
    "exportPath": {
      "type": "string",
      "maxLength": 4096,
      "description": "Optional PDF export path (e.g., 'C:\\output\\report.pdf'). Only valid when save=true."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_stream_startWHEN: creating a new document from scratch. WHAT: starts a streaming session — creates a new document with optional title, author, page setup, and base style configuration. Content is written incrementally with word_stream_block. CONSTRAINT: auto-closes any existing active document. For editing existing files, use word_document instead.
Input schema
{
  "type": "object",
  "properties": {
    "title": {
      "type": "string",
      "maxLength": 255,
      "description": "Document title (set in document properties and title bar)"
    },
    "author": {
      "type": "string",
      "maxLength": 255,
      "description": "Document author (set in document properties)"
    },
    "templatePath": {
      "type": "string",
      "maxLength": 4096,
      "description": "Full path to .dotx or .dotm template file. Styles and content from the template are inherited."
    },
    "orientation": {
      "type": "string",
      "enum": [
        "portrait",
        "landscape"
      ],
      "description": "Page orientation (default: portrait)"
    },
    "topMargin": {
      "type": "number",
      "minimum": 0,
      "maximum": 100,
      "description": "Top margin in cm (default: 2.54)"
    },
    "bottomMargin": {
      "type": "number",
      "minimum": 0,
      "maximum": 100,
      "description": "Bottom margin in cm (default: 2.54)"
    },
    "leftMargin": {
      "type": "number",
      "minimum": 0,
      "maximum": 100,
      "description": "Left margin in cm (default: 3.17 for binding)"
    },
    "rightMargin": {
      "type": "number",
      "minimum": 0,
      "maximum": 100,
      "description": "Right margin in cm (default: 3.17)"
    },
    "baseStyleProfile": {
      "type": "object",
      "additionalProperties": {
        "type": "object",
        "properties": {
          "font": {
            "type": "object",
            "properties": {
              "name": {
                "type": "string",
                "maxLength": 100,
                "description": "Font name (e.g., 'SimSun' for Chinese body, 'Calibri' for English)"
              },
              "size": {
                "type": "number",
                "minimum": 1,
                "maximum": 1638,
                "description": "Font size in points (e.g., 12 for body, 16 for heading)"
              },
              "bold": {
                "type": "boolean",
                "description": "Bold"
              },
              "italic": {
                "type": "boolean",
                "description": "Italic"
              },
              "color": {
                "type": "string",
                "enum": [
                  "auto",
                  "black",
                  "blue",
                  "turquoise",
                  "bright_green",
                  "pink",
                  "red",
                  "yellow",
                  "white",
                  "dark_blue",
                  "teal",
                  "green",
                  "violet",
                  "dark_red",
                  "dark_yellow",
                  "gray_50",
                  "gray_25"
                ],
                "description": "Font color"
              },
              "underline": {
                "type": "string",
                "enum": [
                  "none",
                  "single",
                  "double",
                  "wavy"
                ],
                "description": "Underline style"
              },
              "strikethrough": {
                "type": "boolean",
                "description": "Strikethrough"
              },
              "highlight": {
                "type": "string",
                "maxLength": 20,
                "description": "Highlight color: enum name (e.g., 'yellow') or hex (e.g., '#FFF0E0')"
              }
            },
            "additionalProperties": false
          },
          "paragraph": {
            "type": "object",
            "properties": {
              "alignment": {
                "type": "string",
                "enum": [
                  "left",
                  "center",
                  "right",
                  "justify"
                ],
                "description": "Paragraph alignment"
              },
              "firstLineIndent": {
                "type": "number",
                "minimum": -100,
                "maximum": 100,
                "description": "First line indent in cm (0.74 ≈ 2 Chinese chars at 12pt)"
              },
              "spaceBefore": {
                "type": "number",
                "minimum": 0,
                "maximum": 1584,
                "description": "Space before paragraph in points"
              },
              "spaceAfter": {
                "type": "number",
                "minimum": 0,
                "maximum": 1584,
                "description": "Space after paragraph in points"
              },
              "lineSpacing": {
                "type": "number",
                "minimum": 0,
                "maximum": 1584,
                "description": "Line spacing value. With 'multiple' rule: 1.5=1.5x spacing."
              },
              "lineSpacingRule": {
                "type": "string",
                "enum": [
                  "single",
                  "one_point_five",
                  "double",
                  "at_least",
                  "exactly",
                  "multiple"
                ],
                "description": "Line spacing rule (default: 'multiple' with lineSpacing=1.15)"
              },
              "keepWithNext": {
                "type": "boolean",
                "description": "Keep this paragraph with the next (prevents page break between them)"
              },
              "pageBreakBefore": {
                "type": "boolean",
                "description": "Always start this paragraph on a new page"
              },
              "borders": {
                "type": "object",
                "properties": {
                  "style": {
                    "type": "string",
                    "enum": [
                      "none",
                      "single",
                      "dot",
                      "dash",
                      "double"
                    ],
                    "description": "Border line style"
                  },
                  "color": {
                    "$ref": "#/properties/baseStyleProfile/additionalProperties/properties/font/properties/color",
                    "description": "Border color"
                  },
                  "size": {
                    "type": "number",
                    "minimum": 1,
                    "maximum": 48,
                    "description": "Line width in quarter-points (8 = 1pt)"
                  },
                  "sides": {
                    "type": "array",
                    "items": {
                      "type": "string",
                      "enum": [
                        "top",
                        "bottom",
                        "left",
                        "right"
                      ]
                    },
                    "description": "Which sides to apply border (default: all four)"
                  }
                },
                "required": [
                  "style"
                ],
                "additionalProperties": false
              }
            },
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      "propertyNames": {
        "maxLength": 100
      },
      "description": "Pre-configure built-in styles (Normal, Heading 1-9, Title, etc.). Font and paragraph settings defined here are inherited by all content using those styles — zero per-block COM overhead."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_table_to_textConvert a table to plain text (removes table structure). WHEN: need to convert table content to regular text paragraphs separated by a delimiter. NOT: want to keep the table structure? edit its cells with word_edit_cells instead.
Input schema
{
  "type": "object",
  "properties": {
    "tableIndex": {
      "type": "integer",
      "minimum": 1,
      "description": "Table index (1-based, default: 1)"
    },
    "separator": {
      "type": "string",
      "maxLength": 10,
      "description": "Separator character (default: tab)"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_text_to_tableConvert selected text into a table. WHEN: text is structured with tab/separator delimiters. NOT: no selection? use word_select_text first.
Input schema
{
  "type": "object",
  "properties": {
    "separator": {
      "type": "string",
      "maxLength": 10,
      "description": "Column separator in text (default: tab)"
    },
    "autoFitBehavior": {
      "type": "string",
      "enum": [
        "fixed",
        "contents",
        "window"
      ],
      "description": "Auto-fit behavior"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_track_changes_applyWHEN: finished reviewing tracked changes and want to finalize the document. WHAT: action=accept applies all revisions; action=reject discards all revisions and reverts to original text. CONSTRAINT: affects ALL tracked changes at once; there is no per-change selection. Cannot be undone after word_save.
Input schema
{
  "type": "object",
  "properties": {
    "action": {
      "type": "string",
      "enum": [
        "accept",
        "reject"
      ],
      "description": "'accept' to apply all tracked changes into final text, 'reject' to discard all changes and revert to original"
    }
  },
  "required": [
    "action"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_undo_redoWHEN: need to revert a mistake or restore after undoing too far. WHAT: action=undo reverses the last N actions; action=redo re-applies previously undone N actions. CONSTRAINT: undo history is cleared after word_save. Cannot undo past a save boundary. Max 100 steps at once.
Input schema
{
  "type": "object",
  "properties": {
    "action": {
      "type": "string",
      "enum": [
        "undo",
        "redo"
      ],
      "description": "'undo' to revert recent actions, 'redo' to restore previously undone actions"
    },
    "count": {
      "type": "integer",
      "minimum": 1,
      "maximum": 100,
      "description": "Number of steps to undo/redo (default: 1). Each step reverses one prior action."
    }
  },
  "required": [
    "action"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
—— · ——
word_where_am_iWHEN: need to verify current cursor location after navigating with word_select_at, word_find_text, or word_go_to_paragraph. WHAT: returns the semantic heading path, position relative to nearest heading, table context (if inside a table), and document stats. CONSTRAINT: read-only; does NOT modify cursor or document. For document-level heading overview, use word_get_structure.
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
—— · ——

Resources 3

Resource templates 0

Prompts 3

Let’s talk about MCP security.

Share your details and our security team will contact you.