# KitchenSink4Word (pypi · kitchensink4word)

Word (.docx) MCP server: 221 operations, live editing, tracked changes, citations, mail merge.

- Trust score: 62/100 (medium)
- Change this week: +1
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-20

## Components

- pypi · `kitchensink4word`: 62/100 (this document), [markdown](https://verifymcp.io/servers/nometalalchemist-kitchensink4word/kitchensink4word.md), [page](https://verifymcp.io/servers/nometalalchemist-kitchensink4word/kitchensink4word)

## Channel facts

- Registry: `pypi`
- Package: `kitchensink4word`
- Version: `2.1.3`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-20.

- **Supply Chain Security**: 99/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs setuptools.build_meta at install time, a recognised native-build step with no shell scripting around it.
  - 2 of 22 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 32/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - License check failed: no license is declared.
  - Actively maintained (last published 4 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 58/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 6069 tokens (~209/item across 29 items; 29 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability check failed: the tool surface changed between 1.2.1 and 2.1.3: 103 tool removals, 1 breaking changes, 13 additions.
- **Tool Coverage**: 71/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 3 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 30 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the KitchenSink4Word MCP server?

KitchenSink4Word runs locally as a PyPI package, launched with uvx kitchensink4word. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add nometalalchemist-kitchensink4word -- uvx kitchensink4word
```

### Cursor

```json
{
  "mcpServers": {
    "nometalalchemist-kitchensink4word": {
      "command": "uvx",
      "args": [
        "kitchensink4word"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "nometalalchemist-kitchensink4word": {
      "command": "uvx",
      "args": [
        "kitchensink4word"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add nometalalchemist-kitchensink4word -- uvx kitchensink4word
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "nometalalchemist-kitchensink4word": {
      "type": "local",
      "command": [
        "uvx",
        "kitchensink4word"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add nometalalchemist-kitchensink4word --command uvx --arg kitchensink4word
```

### Hermes

```yaml
mcp_servers:
  nometalalchemist-kitchensink4word:
    command: "uvx"
    args: ["kitchensink4word"]
```

### Netclaw

```json
{
  "McpServers": {
    "nometalalchemist-kitchensink4word": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "kitchensink4word"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add nometalalchemist-kitchensink4word -t stdio -c uvx -a kitchensink4word
```

### Other

```json
{
  "mcpServers": {
    "nometalalchemist-kitchensink4word": {
      "command": "uvx",
      "args": [
        "kitchensink4word"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-20 (score 62, +1)

- [security regression] Stability: fail → unverified
- [security regression] Tool safety: pass → unverified
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional] First check of Schema quality: unverified
- [functional] Destructive annotations: All 3 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
- [functional] Package version: 2.1.2 → 2.1.3

### 2026-09-19 (score 61, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-09-18 (score 46, −15)

- [security regression] Malware scan: pass → unverified

### 2026-09-15 (score 61, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-09-14 (score 46, −15)

- [security regression] Malware scan: pass → unverified

### 2026-09-10 (score 61, +5)

- [security regression] Stability: fail → unverified
- [security regression] Tool safety: pass → unverified
- [security improvement] Source repository: fail → pass
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional] First check of Schema quality: unverified
- [functional] Package version: 2.0.3 → 2.1.2

### 2026-09-09 (score 56, −5)

- [security regression] Source repository: pass → fail

### 2026-09-06 (score 61, −1)

- [security regression] Malware scan: pass → unverified
- [functional] Schema quality: excellent → good
- [functional] Package version: 2.0.0 → 2.0.3
- [functional] Package version: 2.0.0 → 2.0.2

## MCP tools (29)

### `create_document` (~94 tokens)

Create Document

Create a new blank .docx file, optionally setting the title core
property. Refuses to overwrite an existing file (use copy_document with
overwrite=True for that). Parent directories are created automatically.
Populate the document afterward with insert_paragraphs, create_table,
define_style (academic pack), and other tools.
Template-driven builds live in the assembly pack.

Input parameters:

- `file_path` (string, required)
- `title`

### `copy_document` (~133 tokens)

Copy Document

Copy a document byte-for-byte, e.g. to a new DTG-stamped filename
before editing (manage_backups action='snapshot' names such a copy for
you; this tool takes an explicit dest_path). Refuses an existing
dest_path unless overwrite=True; an overwritten destination's previous
content rotates into its .ks4w-backups prev slot first, so the
overwrite is undoable via manage_backups restore.
Split/merge and multi-document work live in the assembly pack.

Input parameters:

- `dest_path` (string, required)
- `file_path` (string, required)
- `overwrite` (boolean)

### `manage_backups` (~351 tokens)

Manage Backups

Manage the automatic backups under the hidden .ks4w-backups/ folder next
to each mutated document: two stable slots per document, prev (state
before the most recent mutation) and anchor (session start).
action='list': slot files with sizes and mtimes, legacy *.bak-* files,
and orphaned slot folders whose source document is gone; give file_path
for one document or directory for a folder. action='restore': overwrite
file_path with a backup; source is 'prev', 'anchor', or a legacy *.bak-*
path. The current content rotates into prev FIRST, so a restore is
itself undoable; the payload is validated before the atomic replace, and
documents open in Word are refused. action='purge': delete backups;
scope: 'legacy', 'orphans', or 'slots'. dry_run defaults to TRUE (report
only); dry_run=False deletes. Exact paths and sizes are reported either
way. action='snapshot': save a DTG-stamped permanent copy of file_path,
YYYYMMDD_HHMM_<name>.docx (an existing leading DTG is replaced, not
stacked), optional short label suffix, optional dest_dir. Snapshots are
permanent keepers: the slots rotate on every mutation, snapshots are
never auto-pruned and no purge scope touches them. Never overwrites
(collisions get a numeric suffix); the source document is not modified.

Input parameters:

- `action` (string, required)
- `dest_dir`
- `directory`
- `dry_run` (boolean)
- `file_path`
- `label`
- `scope`
- `source`

### `get_document_info` (~89 tokens)

Get Document Info

Read a one-call document overview: paragraph/table/footnote/comment/
revision counts, sections, and package parts. Documents open in Word are
read live (same key names; live adds 'words' from Word's own
ComputeStatistics counter plus track_revisions, and omits the part
list). Read-only.

Input parameters:

- `file_path` (string, required)
- `live` (string)

### `diagnose_document` (~192 tokens)

Diagnose Document

Produce a one-call structural health report, read-only: content-type
coverage, dangling relationships and orphan parts, field balance per
story part, footnote/endnote integrity, references to undefined styles
and numbering, content-control and bookmark sanity, duplicate revision
ids, missing image targets, broken cross-references, and a per-part size
profile. Never fails on a weird-but-openable document; every check
degrades to a reported problem, and healthy=false only for problems
that render broken or lose content in Word. The deep companion to
validate(checks=['core']). No live mode BY DESIGN: this reads the saved
package's XML, stale while Word holds unsaved changes. Close the
document first, or use com_validate_opens_clean (com-live pack) /
live get_document_info.
The full validate check battery lives in the academic pack.

Input parameters:

- `file_path` (string, required)

### `get_text` (~171 tokens)

Get Text

Read body paragraphs as [{index, text, style, ...}] with effective
styles. start/end slice by paragraph index (0-based, end EXCLUSIVE);
contains filters. include_textboxes=True appends text-box content as
labeled extras, body indices untouched; textbox=true (or {"index": n})
returns ONLY text-box content, with the box_index set_textbox_text
(media-forms pack) takes; file-mode only. Open documents read live,
same shape.
Equations read via list_elements type='equations'. Read-only.
Orientation: get_document_view.

Input parameters:

- `contains`
- `end`
- `file_path` (string, required)
- `include_textboxes` (boolean)
- `live` (string)
- `start` (integer)
- `textbox`

Output parameters:

- `result`

### `find_text` (~182 tokens)

Find Text

Find text in paragraphs and table cells; returns locations plus
context. include_textboxes=True also searches text-box content as
labeled matches; file-mode only. Pass formatting={...} (bold, font,
size_pt, color, ...) to search by EFFECTIVE formatting: resolved
through run, style chain, and defaults; query=None returns every
formatted stretch; scope 'body' or 'all'; file-mode, no regex. Plain
queries search open documents live (same shape, 500-match cap).
Read-only. To read a known range, use get_text.

Input parameters:

- `context_chars` (integer)
- `file_path` (string, required)
- `formatting`
- `include_textboxes` (boolean)
- `live` (string)
- `query`
- `regex` (boolean)
- `scope` (string)

Output parameters:

- `result`

### `get_outline` (~140 tokens)

Get Outline

List every heading with its paragraph index and level. Detects
Heading styles AND w:outlineLvl overrides (direct or style-inherited);
detected_via names which. detect_formatted=True adds a heuristic scan
for direct-formatted headings (short bold/centered paragraphs). When
nothing is detected, returns a note plus flat structure counts, not an
empty list. The indices feed the location object's paragraph and
outline selectors. Open documents are read live. Read-only. TOC
generation and heading surgery: academic pack.

Input parameters:

- `detect_formatted` (boolean)
- `file_path` (string, required)
- `live` (string)

Output parameters:

- `result`

### `list_elements` (~326 tokens)

List Elements

Enumerate any collection in one call. type: tables |
images | charts | equations | bookmarks | sources | sections |
section_blocks | footnotes | endnotes | fields | reference_fields |
form_fields | content_controls | template_placeholders | index_entries |
lists | toc. Returns {type, count, items}; the ids or indices
returned are the handles the matching set_/delete_/manage_ tools
take (list then act). Highlights per type: tables reports
dimensions and the table_index other table tools take; images reports
display size and the media target; charts reports series; equations
reads math content; bookmarks excludes internal TOC bookmarks; fields
covers complex and simple fields with cached results;
reference_fields inventories Zotero, EndNote, and Mendeley fields and
flags broken pairs; form_fields and content_controls cover legacy fields
and SDTs; template_placeholders lists {{name}} and MERGEFIELD keys for
fill_template and mail_merge (assembly pack); lists groups list
paragraphs by numbering instance; toc returns TOC-family fields with
cached entries (refresh via com_refresh_fields, com-live pack, then
re-read). filter={"range": {start, end},
"name": "substring"} applies where meaningful; inapplicable filters
refuse loudly. Read-only, file mode; close documents open in Word
first.
Tools for these elements live in packs; enable_tools lists
them. To locate a string, find_text.

Input parameters:

- `file_path` (string, required)
- `filter`
- `type` (string, required)

### `get_workflows` (~112 tokens)

Get Workflows

Recommended tool sequences for common multi-step tasks, with a one-line
why per step. Call with no task to list the available tasks
('process-feedback', 'prepare-submission', 'format-citations',
'build-from-template', 'heavy-editing', 'live-editing', 'comment-partner',
'migrate-from-v1', 'bulk-edit');
call with task='<name>' for that task's step-by-step sequence and notes.
Pure guidance: reads nothing, changes nothing.

Input parameters:

- `task`

### `get_server_info` (~121 tokens)

Get Server Info

Report this server's build and environment: version, the active tool
surface (tool count, approximate token bill, per-pack state), the packs
enable_tools can load, what decided the startup surface and whether it
is locked, whether the Word application tier can run here, whether path
sandboxing is on, the host OS and Python, and the update-check state.
Needs no document, opens no file, starts no Word. Paste-safe: no path,
document name, or user name, so a bug report can carry it as it stands.

### `insert_paragraphs` (~188 tokens)

Insert Paragraphs

Insert paragraphs (items {text, style?, formatting?, heading_level?})
at a location object (omitted = document end). heading_level 1-9 makes
the item a heading (level 1 = outline 0).
inherit_format/copy_format_from clone neighbor formatting minus
outline level (file mode only); track records insertions by
author. Auto-backup in file mode; atomic validated save. Open
documents edit live, serialized; a stale text-selector target
refuses: save in Word, retry. For batches, use apply_edits.

Input parameters:

- `author` (string)
- `backup` (boolean)
- `copy_format_from`
- `file_path` (string, required)
- `inherit_format` (boolean)
- `live` (string)
- `location`
- `paragraphs` (array, required)
- `track` (boolean)

### `delete_paragraphs` (~184 tokens)

Delete Paragraphs

Delete body paragraphs by 0-based inclusive index (start, end; end
defaults to start) or by range={start, end} location objects. Refuses
ranges cutting a field or a section break; deleting every paragraph
leaves one empty one behind. track records tracked deletions.
expect_start/expect_end delete nothing unless that index still holds
the given text. Auto-backup in file mode (backup=False skips
rotation). Open documents edit live (serialized), unsaved until
saved. For batches, use apply_edits.

Input parameters:

- `author` (string)
- `backup` (boolean)
- `end`
- `expect_end`
- `expect_start`
- `file_path` (string, required)
- `live` (string)
- `range`
- `start`
- `track` (boolean)

### `set_paragraph_text` (~165 tokens)

Set Paragraph Text

Replace one paragraph's full text, keeping style and base formatting;
address it with a location object ({paragraph: N}, {search: ...},
{outline: ...}). Indices shift after edits, so pass expect (a substring
the target must contain) to refuse instead of hitting the wrong
paragraph; verify the returned replaced_text. Auto-backup in file
mode (backup=False skips rotation); atomic validated save. Edits go
live on open documents (serialized); tracked-revision paragraphs
refuse live. For batches, use apply_edits.

Input parameters:

- `backup` (boolean)
- `expect`
- `file_path` (string, required)
- `live` (string)
- `location` (object, required)
- `new_text` (string, required)

### `search_and_replace` (~387 tokens)

Search and Replace

Batch find/replace, safe across Word's fragmented runs. Each item:
{find, replace, regex?}; scope: body | footnotes | headers | all.
preview=true dry-runs the same engine without touching the file:
per-item counts, each match with paragraph index and before/after
context, the grand total, and the refusals a real run would hit;
review, then rerun with max_replacements set to the previewed total so
drift aborts instead of over-replacing. find_formatting={bold, italic,
font, size_pt, color, highlight, style, ...} restricts replacement to
text carrying that effective formatting (file mode only, no regex; an
item without find replaces each entire matching stretch, and the
replacement keeps the matched formatting). max_replacements aborts,
changing nothing, when total matches would exceed it. track records
each replacement as a tracked change by author. Sibling:
set_paragraph_text rewrites one whole paragraph when a find string
would be unwieldy. Live edits appear immediately as one Ctrl+Z step,
unsaved until the user saves; the live result adds live:true and skip
counters, and literal finds beyond Word's ~255-char limit are handled
automatically. Auto-backup in file mode (backup=False skips
rotation); atomic validated save. Documents open in Word edit live,
serialized; tracked replaces never re-match their own markup. For
anchor-scoped edits, use apply_edits.

Input parameters:

- `author` (string)
- `backup` (boolean)
- `file_path` (string, required)
- `find_formatting`
- `live` (string)
- `max_replacements`
- `preview` (boolean)
- `replacements` (array, required)
- `scope` (string)
- `track` (boolean)

### `get_document_view` (~368 tokens)

Get Document View

Read the document as an anchored markdown projection, the low-token
alternative to get_text for orientation and bulk editing. One block
per paragraph, prefixed [hex] with a stable anchor id (from
w14:paraId, which survives edits elsewhere in the document); headings
carry # prefixes, tables render as pipe tables under [t:hex] with
cells addressed t:hex:rNcN (1-based). Anchors work in every location
object ({"anchor": "hex"}) and in apply_edits ops. scope:
{"outline": "3.2"} for one heading's section, or {"paragraphs":
{"start": N, "end": M}} (end exclusive); omit for the whole document.
detail: "structure" (headings and counts only), "text" (default),
"full" (adds {++ins++}/{--del--} revision markers and [cN] comment
refs with an author legend). include: {"tables": false} to skip
tables, {"notes": "inline"} to append footnote/endnote text.
Documents without paraIds get VOLATILE anchors (flagged in the
header) that change with any edit; stamp_anchors=true writes real
paraIds so anchors become durable. Stamping is the ONE mutation this
tool can make and runs only when explicitly requested, with the
normal backup and validated save; plain reads never modify the file.
A document open in Word is read from its last saved state.
To locate a string, use find_text; to enumerate collections, use
list_elements.

Input parameters:

- `detail` (string)
- `file_path` (string, required)
- `include`
- `scope`
- `stamp_anchors` (boolean)

### `apply_edits` (~379 tokens)

Apply Edits

Apply a batch of anchor-addressed edits in one call: one lock,
backup, and validated save for the batch. Anchors come from
get_document_view. Ops (each edit has "op"): replace {anchor, find,
text, occurrence?} (omitted = every match); set_text {anchor, text}
(whole paragraph); insert {location, markdown} (headings, plain
paragraphs, lists, and pipe tables become real Word structures;
location is the standard object); delete {anchor or anchors};
set_style {anchor, style}; format {anchor, formatting,
find?, occurrence?}; set_paragraph_format {anchor, format}; set_cell
{anchor: "t:hex:rNcN", text}. The whole batch validates BEFORE
anything mutates, against BATCH-START text (never reference text an
earlier op creates); one stale anchor refuses it all (STALE_ANCHOR
lists failed ops: re-view, resend). The changed map carries per-op
results, with fresh anchors for inserted paragraphs, so follow-up
batches chain without re-viewing. Ops run in order; keep deletes
last. Auto-backup in file mode (backup=False skips rotation); atomic
validated save. A document open in Word is edited live as ONE undo
step: serialized, validated before any write, rolled back on
mid-batch failure. Markdown lists/tables are file-mode only there;
stale targets refuse: com_save_document (com-live pack) first,
re-view, resend.
Use this when a change needs two or more edits; for one, use
the standalone tool.

Input parameters:

- `atomic` (boolean)
- `backup` (boolean)
- `edits` (array, required)
- `file_path` (string, required)
- `live` (string)

### `format_text` (~173 tokens)

Format Text

Apply character formatting or change case on a text range. formatting:
bold, italic, underline, strike, font, size_pt, color, highlight,
small_caps, char_spacing_pt, language, east_asian_language, and more.
case: upper | lower | title | sentence. Target: range={start,end},
find, or both; one of formatting or case per call. Auto-backup in
file mode (backup=False skips rotation); atomic validated save.
Formatting goes live on open documents (serialized); case is
file-mode only. For batches, use apply_edits.

Input parameters:

- `backup` (boolean)
- `case`
- `file_path` (string, required)
- `find`
- `formatting`
- `live` (string)
- `occurrence`
- `range`

### `set_paragraph_format` (~175 tokens)

Set Paragraph Format

Set paragraph formatting on a batch: indices (0-based list) OR
start/end (inclusive range), exactly one form. Keys: alignment,
space_before_pt, space_after_pt, line_spacing, indent_left_pt,
indent_right_pt, first_line_indent_pt, keep_with_next, outline_level.
outline_level (0-8; null removes) never changes the look; it is off
by one from heading_level 1-9. Auto-backup; atomic validated save.
Open documents edited live (serialized; shading/borders/tab_stops
refused live). For batches, use apply_edits.

Input parameters:

- `backup` (boolean)
- `end`
- `file_path` (string, required)
- `formatting`
- `indices`
- `live` (string)
- `start`

### `apply_style` (~151 tokens)

Apply Style

Apply a named style. range={start,end} (locations or bare indices)
applies a paragraph style to those paragraphs, changing their full look
(Heading1-9 auto-created); target={search:{text, occurrence?}} applies
a character style to the matched text instead. For an outline level without visual change use
set_paragraph_format. Auto-backup (backup=False skips rotation);
atomic validated save. Refuses documents open in Word. For batches,
use apply_edits.
Defining new named styles lives in the academic pack.

Input parameters:

- `backup` (boolean)
- `file_path` (string, required)
- `range`
- `style` (string, required)
- `target`

### `create_table` (~172 tokens)

Create Table

Create a table from 2D string data with single-line borders and a bold
repeating header row (header_row=False for none). location is the
standard location object ({paragraph}, {after_heading}, {outline},
{search}, {anchor}); omit it to append at the document end; position
'after' only. To build a table from a CSV or JSON file use
import_table (protection-io pack). Auto-backup: prev/anchor slots in .ks4w-backups
(backup=False skips rotation only); atomic validated save. Refuses
documents open in Word.

Input parameters:

- `backup` (boolean)
- `data` (array, required)
- `file_path` (string, required)
- `header_row` (boolean)
- `location`
- `width_pt`

### `delete_table` (~130 tokens)

Delete Table

Delete a whole table and its contents. table_index is the 0-based
position among body-level tables in document order, as reported by
list_elements(type='tables') or get_document_view; nested tables are
removed with their host table. To clear cell values while keeping the
grid, use set_cells instead. Auto-backup: prev/anchor slots in
.ks4w-backups (backup=False skips rotation only); atomic validated
save. Refuses documents open in Word.

Input parameters:

- `backup` (boolean)
- `file_path` (string, required)
- `table_index` (integer, required)

### `get_table` (~155 tokens)

Get Table

Read one table in full: every cell's text, the merge map, and
column widths. table_index is 0-based among body-level tables in
document order. has_merges=false returns rows of strings;
has_merges=true returns {text, grid_span, vmerge} cells. For a table
nested inside a cell, pass nested={row, cell, index} addressing the
host cell (index picks among several, default 0). Write with
set_cells; reshape with modify_table_structure (media-forms pack).
Read-only; reads the last-saved state of a document open in Word.

Input parameters:

- `file_path` (string, required)
- `nested`
- `table_index` (integer, required)

### `set_cells` (~193 tokens)

Set Cells

Write many table cells in one call. Modes: edits=[{row, cell, text}]
for scattered cells, or block={origin:{row, cell}, values:[[...]]} for
a 2D block. nested={row, cell, index} targets a table nested in that
host cell (edits mode only). track records tracked changes by author.
Live mode (plain edits only) refuses vertical merges; file mode is
merge-aware. Auto-backup in file mode (backup=False skips rotation);
atomic validated save. Documents open in Word edit live, serialized.
For batches, use apply_edits.

Input parameters:

- `author` (string)
- `backup` (boolean)
- `block`
- `edits`
- `file_path` (string, required)
- `live` (string)
- `nested`
- `table_index` (integer, required)
- `track` (boolean)

### `insert_break` (~134 tokens)

Insert Break

Insert a break after the located paragraph. type: page starts a new
page; section_next / section_continuous / section_even / section_odd
start a new SECTION (own headers, margins, numbering; see
set_section_properties, academic pack). location picks the paragraph
(omit for document end). Auto-backup: prev/anchor slots in .ks4w-backups
(backup=False skips rotation only); atomic validated save. Refuses
documents open in Word.

Input parameters:

- `backup` (boolean)
- `file_path` (string, required)
- `location`
- `type` (string)

### `insert_list` (~241 tokens)

Insert List

Insert a bulleted or numbered list with real bullet/number glyphs
(numbering.xml as needed). items: strings or {text, level}
dicts (level 0-8 nests); kind: bullet | number. A call makes its own
list, so numbering restarts at 1; continue_from (a num_id from
list_elements) carries on an existing one and start_at restarts the new
one at N. levels sets per-level formats: [{level, format, text, start,
suffix, align, indent_pt, hanging_pt, font}], format one of decimal |
lowerLetter | upperLetter | lowerRoman | upperRoman | bullet | none,
text a label like '%1.%2.'.
location picks the insertion point (omit for document end).
Auto-backup to .ks4w-backups; atomic validated save. Refuses documents
open in Word.

Input parameters:

- `backup` (boolean)
- `continue_from`
- `file_path` (string, required)
- `items` (array, required)
- `kind` (string)
- `levels`
- `location`
- `start_at`

### `delete_element` (~310 tokens)

Delete Element

Delete one document element that has no lifecycle tool of its own.
type: equation | image | chart | bookmark | hyperlink | caption |
reference_list | content_control. Address equations, images, charts by
their list_elements index; reference_list (TOC, List of
Tables/Figures, index) by its read order; bookmarks by name (markers
go, the text stays; Word-internal underscore names refused); hyperlinks
by target url in `id` and/or a location search on the link text (the
link is unwrapped, display text kept, the relationship dropped once
unshared; several matches without occurrence refuse loudly listing
every candidate); captions by location (Caption-styled paragraphs
only); content controls by tag or index (the whole control including
content; locked controls refused). Deleting an image or chart also
removes its media, chart, and embedded-workbook parts once nothing else
references them. Objects with lifecycle tools stay there: notes in
manage_note (academic pack), comments in manage_comment (review
pack), sources in manage_source (references pack), tables in
delete_table, paragraphs in delete_paragraphs. Auto-backup:
prev/anchor slots in .ks4w-backups (backup=False skips rotation only);
atomic validated save. Refuses documents open in Word.

Input parameters:

- `backup` (boolean)
- `file_path` (string, required)
- `id`
- `location`
- `type` (string, required)

### `enable_tools` (~345 tokens)

Enable Tools

Enable optional tool packs mid-session (sessions start lite). Idempotent; reports tokens added. packs = names below or ['everything']; disable_tools reverses it. Task map: cell merges, tables, images, forms -> media-forms; tracked changes, comments -> review; citations -> references; TOC, notes -> academic; document merge -> assembly; PDF, live Word -> com-live; redaction -> protection-io.
Packs:
\- references (~2.9k): citations and bibliography: Word-native sources, bibliography styles, Zotero search/cite, parity checks, style conversion
\- review (~2.4k): tracked changes (read, accept/reject), comments (add, reply, resolve), reviewer reports, structured diff, anonymize
\- academic (~7.6k): notes, TOC, index, captions, cross-references, bookmarks, headers/footers, sections, styles, word counts, validation, submission prep, accessibility
\- assembly (~2.1k): multi-document work: insert/split documents, move sections, copy tables across files, templates, mail merge
\- media-forms (~5.6k): images, charts, equations, text boxes, hyperlinks, table structure (merge/split cells, rows, columns, sort), forms, content controls, field codes
\- com-live (~3.1k): drives the Word app: PDF import/export, compare/combine, proofing, readability, live editing of open documents
\- protection-io (~1.6k): protection, watermarks, redaction with verification, table CSV/JSON import/export

Input parameters:

- `packs` (array, required)

### `disable_tools` (~77 tokens)

Disable Tools

Disable previously enabled tool packs for this session and reclaim their context; the lite core always stays on. Idempotent. The result reports the packs just disabled, the approximate tokens removed, and the remaining surface. packs takes the same names as enable_tools (its description carries the menu) or ['everything'].

Input parameters:

- `packs` (array, required)

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/nometalalchemist-kitchensink4word/kitchensink4word#diagnostics

## Score history

- 2026-09-20: 62
- 2026-09-19: 61
- 2026-09-18: 46
- 2026-09-17: 61
- 2026-09-16: 61
- 2026-09-15: 61
- 2026-09-14: 46
- 2026-09-13: 61
- 2026-09-12: 61
- 2026-09-11: 61
- 2026-09-10: 61
- 2026-09-09: 56
- 2026-09-08: 61
- 2026-09-07: 61
- 2026-09-06: 61
- 2026-09-05: 62
- 2026-09-04: 62
- 2026-09-03: 66
- 2026-09-02: 66
- 2026-09-01: 65
- 2026-08-31: 65
- 2026-08-30: 64
- 2026-08-29: 64
- 2026-08-28: 63
- 2026-08-27: 49

## Common questions

### What is the KitchenSink4Word MCP server?

KitchenSink4Word is an MCP server listed in the public MCP registry as io.github.nometalalchemist/kitchensink4word. Word (.docx) MCP server: 221 operations, live editing, tracked changes, citations, mail merge. This page covers its PyPI package (kitchensink4word).

### Is the KitchenSink4Word MCP server safe to use?

KitchenSink4Word scores 62 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 20 September 2026. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the KitchenSink4Word MCP server expose?

KitchenSink4Word exposes 29 tools: create_document, copy_document, manage_backups, get_document_info, diagnose_document, and 24 more. Their descriptions and schemas cost roughly 5,838 tokens of context every time the server is loaded.

### Is the KitchenSink4Word MCP server still maintained?

KitchenSink4Word is still listed as active in the MCP registry. We last reached this channel on 20 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- PyPI project: https://pypi.org/project/kitchensink4word/
- Socket report: https://socket.dev/pypi/package/kitchensink4word
- Repository: https://github.com/KitchenSink4AI/KitchenSink4Word
- Website: https://kitchensink4.ai/KitchenSink4Word/
- Changelog RSS feed: https://verifymcp.io/servers/nometalalchemist-kitchensink4word/kitchensink4word.xml
- Changelog JSON feed: https://verifymcp.io/servers/nometalalchemist-kitchensink4word/kitchensink4word.json
- HTML version of this page: https://verifymcp.io/servers/nometalalchemist-kitchensink4word/kitchensink4word