KitchenSink4XL lets an AI assistant safely read, edit, validate, and manage Excel .xlsx/.xlsm workbooks locally through MCP, with optional Windows/Excel-powered operations.
Inspect workbooks: metadata, sheet and table info, grid views, ranges, cells, formulas, styles, diagnostics, validation checks, and formula audits.
Edit data: set values and formulas, batch edits, clear/copy/move ranges, find/replace, import CSV/TSV/JSON, and export ranges.
Change structure: add/delete/rename/reorder/copy/hide sheets; insert/delete rows and columns with reference rewriting; create tables; merge cells; sort and filter.
Format and organize: fonts, fills, borders, number formats, column widths and row heights, grouping/outlines, freeze panes, hyperlinks, comments, images, and charts (some via optional packs).
Manage workbooks: create/copy, backups/restore/snapshot/purge, document properties, calculation settings, protection, page layout, headers/footers, and export.
Use optional Excel/COM features: recalculation, pivot tables, PDF export, sheet rendering, format conversion, encryption, autofit, goal seek, sparklines, and opens-clean validation.
Stay safe: automatic rotating backups, atomic verified saves, round-trip hazard checks, explicit loss handling, protection respect, read-only mode, path sandboxing, and configurable tool packs.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@KitchenSink4XL Recalculate the workbook and show which formula cells changed"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Read and edit Excel workbooks with your AI assistant, and know whether each formula result is fresh, cached or missing.
Your AI gets 131 actions in Excel, a backup before every change, and a check after every save.
KitchenSink4XL is an MCP server that lets Claude Code, the Codex CLI, Copilot CLI, Claude Desktop and other local MCP clients work with .xlsx and .xlsm files: formulas, tables, formatting, structural edits and data checks. When it reads a formula cell, it tells your AI whether the value was just calculated, remembered from the last save, or never calculated at all, so a stale number does not end up in your report. This is the free Community edition, licensed under the AGPL-3.0.
Product page · llms.txt · Changelog
Platform: the file tools run on Windows and Linux (macOS is untested in this release). Recalculation, pivot tables, PDF export and the other Excel-powered features need Windows with Microsoft Excel installed.
The package needs Python 3.12 or newer. Run the commands below in PowerShell or a terminal, not in an AI chat.
Claude Code or Codex CLI. Install uv, run the line for your app, and start a new session:
claude mcp add xl -s user -- uvx kitchensink4xlcodex mcp add xl -- uvx kitchensink4xlClaude Desktop. Install uv and restart Claude Desktop. Download the .mcpb file from the latest release, then open Settings > Extensions > Advanced settings > Install extension and choose the file. The first launch downloads the Python package, so it needs a network connection.
Any other local MCP client. Use uvx as the command and kitchensink4xl as its argument, or install the package and run kitchensink4xl as the server command:
pip install kitchensink4xlThe first launch through uvx builds the environment and can take 20 to 30 seconds; later launches start in about two. If your client times out on the first run, start it once from a terminal and try again.
Related MCP server: Excel MCP Server
Tell whether a formula's value was calculated, cached or missing before you use it, with the affected cells named.
Read a range or summarize a large table without pulling every row into your AI's context.
Write formulas, values and number formats into an existing workbook.
Insert and delete rows and columns while formulas, tables, named ranges, charts and cross-sheet references follow.
Sort and filter the way Excel does, and format tables for a client or a colleague.
Import and export CSV and JSON.
Check a workbook for structural problems before you share it.
On Windows with Excel: recalculate for real, build pivot tables, run goal seek, export to PDF and render a sheet to an image.
In total the server offers 69 operations in 7 tools, 131 counting each action an operation can take (for example each kind of worksheet or table change). The whole tool list costs about 5.5k tokens of your AI's working memory at startup. Figures come from scripts/measure_surface.py and scripts/count_operations.py.
A workbook stores the last answer each formula produced, not a guarantee that the answer is current. If something upstream changed and nobody recalculated, the old number still looks like a real one. KitchenSink4XL labels every formula result it returns: freshly calculated, remembered from the last save, or not calculated yet. Values someone typed in carry no label, because there is nothing to recalculate. When it matters, the xl_app tool asks a private, hidden Excel to recalculate and returns results marked as calculated.
Inserting a column affects everything to its right: formulas, totals, charts, tables and named ranges on other sheets. KitchenSink4XL moves what should move and is tested against Excel's own behavior for formulas, tables, named ranges, charts and cross-sheet references. When an edit cannot be done safely, it refuses and says why instead of guessing.
The server lists seven tools, all from the first message, with nothing to switch on. Every tool except xl_help takes an op (the operation to run) and args (its arguments, including the path of the workbook). xl_help returns the arguments and a worked example for any operation. Token figures count the full tools/list entry the client receives and come from scripts/measure_surface.py.
Tool | Operations | Approx. tokens | What it covers |
| 18 | ~1.0k | The grid view, labeled reads of cells and ranges, server-side query and aggregation, search, tables, diagnostics, validation checks, formula and style audits, and the inspectors for pivots, connections, external links and VBA |
| 10 | ~0.8k | Cell values and formulas, range writes, copy and move, the anchored batch editor, find and replace, and data import |
| 11 | ~0.9k | Number and cell formats, named styles, format copying, column widths and row heights, merges, conditional formatting, comments, hyperlinks, images, charts and sheet view settings |
| 9 | ~0.8k | Worksheets, row and column inserts and deletes that carry their references, tables, named ranges including LAMBDA definitions, sorting, filters and data validation |
| 9 | ~0.8k | New workbooks and copies, backups, document properties, protection, page layout, headers and footers, and export |
| 12 | ~0.9k | A private hidden Excel on Windows, never your own session: real recalculation, pivot tables, PDF export, sheet images, format conversion, encryption, autofit, goal seek, sparklines and an opens-clean check. Also updates the server when you ask ( |
| 0 | ~0.2k | The arguments and a worked example for any operation, and how locations are written |
All seven | 69 | ~5.5k | Loaded once at the start; nothing to switch on later |
Your AI calls a tool by naming the operation and passing its arguments:
xl_read(op="get_grid_view", args={"path": "C:/data/budget.xlsx"})
xl_edit(op="set_cell", args={"path": "C:/data/budget.xlsx", "location": "C1", "value": "Total"})For a recipe, ask your AI to call get_workflows. The server's own instructions add about 500 tokens to the figures above. Clients that load tool schemas on first use pay close to nothing until a tool is called.
Administrators who want a narrower server can set KS4XL_READ_ONLY=1, which lists only the operations that read, or list the tools or operations to remove in KS4XL_FORBID (see Configuration). What is removed no longer counts toward the cost.
Before every change, the workbook is backed up into two rotating slots in a hidden .ks4xl-backups/ folder next to it. manage_backups lists, restores and prunes them. The slots capture changes made through this server only; an edit made in Excel or another program is not captured.
Saves are atomic and validated, and each write is checked after saving, with the backup restored if the check fails. Other programs may see the workbook's path missing for a few milliseconds during a save, as with Office's own saves; this server's own calls wait that out. With verify_com=true (or KS4XL_VERIFY_COM=1 for every save), the saved file must also open cleanly in a hidden Excel.
An ordinary cell edit keeps the rest of the workbook byte for byte (printer settings, shared strings, row heights, pictures, external links and other parts), so Excel opens the result without a repair prompt. The full rewrite used by structural edits carries those parts back, along with custom properties, sensitivity labels and the password to modify.
Before a save, a scan names any part of the workbook the writer cannot preserve, and refuses the loss unless the call explicitly allows that specific kind.
Writes honor sheet and workbook protection and refuse with PROTECTED when the protection forbids the change.
Destructive calls keep a labeled snapshot of the workbook as it was, restorable by label.
Text that merely looks like a formula is never turned into one. The cell's type decides.
Ambiguous targets are refused with every candidate listed.
xl_app uses its own hidden Excel instance, never the workbook you have open, and leaves no stray Excel processes behind. A workbook open in Excel can be read but not changed.
A workbook with a password to modify is refused by every xl_app operation that would open it for editing, with the remedy, so Excel's Password dialog does not land on your desktop. An encrypted workbook is refused before Excel starts unless a password is given.
query_range, export_range and the aggregates include rows hidden by an autofilter. Excel's SUBTOTAL skips them, so totals on a filtered sheet can differ from Excel's status bar.
Exclude .ks4xl-backups/ from cloud sync tools; the backup files change on every edit and sync clients can hold locks that slow saves down.
The server runs on your computer. KitchenSink4AI never receives your files or usage data. Your AI app may send prompts, file contents and tool results to its own provider under that app's settings and terms. The update check described below contacts PyPI at most once a week and sends only the package name and the installed version. Choosing Update now downloads the new version from PyPI, or the new bundle from GitHub for Claude Desktop. The server's startup banner is switched off, so the framework it runs on makes no version check of its own. The Privacy Policy covers the product, purchases and support.
Launch settings are environment variables in the server's configuration. They are read once at start, and no tool call, argument or prompt can change them.
Variable | What it does |
|
|
| A comma-separated list of tool or operation names to remove from the tool list and from |
| Restricts every path the server reads or writes to these folders (separated by |
| Wall-clock bound for one call, in seconds (default 300) |
| Ceiling on the size of one reply, in characters (default 80,000) |
| Who signs a note when the call names no author, or names an email address, which is never written as an author: |
|
|
|
|
| Maximum time for a COM call |
|
|
|
|
Settings from earlier versions are handled for you: an old default (KS4XL_MODE set to lite, full or everything, or KS4XL_PACK_POLICY=auto) is ignored with a one-line notice, and a setting that locked the tools (KS4XL_PACK_POLICY=locked or a KS4XL_MODE list of tool groups) stops the start with a message naming what to use instead. To limit the tools yourself, use KS4XL_READ_ONLY or KS4XL_FORBID.
Sandboxing. With KS4XL_ALLOWED_ROOTS set, the containment check runs on canonical paths, so ..\ traversal, symbolic links and junctions, short names, case tricks and lookalike folder names are all caught. A blocked call returns a typed error naming the path and the allowed roots before any file is opened.
Update check and update notices. At most once a week, after you use a tool, the server asks PyPI in the background which version of kitchensink4xl is newest. The request names only the package and the installed version and contains no documents, file names or identifiers. When a newer version exists and the server runs through uvx or the Claude Desktop extension, your AI app shows a short notice with Update now and Not now, where the app supports one. Otherwise your AI mentions the new version once and offers to update. It never downloads or installs a new version unless you choose Update now in its notice or ask your AI to update it. To turn notices off, ask your AI to turn off KitchenSink4XL update notices; KS4XL_UPDATE_NOTICES=off turns them off everywhere, and KS4XL_UPDATE_CHECK=off turns the check off completely (KS4XL_NO_UPDATE_CHECK=1 also works). The setting is kept in the server's own state folder, so it survives updates.
Claude Desktop extension settings. Verify every save with Excel turns on the hidden-Excel open check (off by default, since it adds a round trip through Excel on every write). Limit the server to one folder confines every path the server touches, reads included, to a folder you choose.
Point any MCP client at the installed command:
{"mcpServers": {"xl": {"command": "kitchensink4xl"}}}xl-mcp is an equivalent command, and python -m ks4xl_community_launch starts the same server for a client that wants an interpreter and a module. The shared core, xlsx_mcp, does not run on its own: python -m xlsx_mcp and python -m xlsx_mcp.server stop with a message that names the launcher. Driving Excel (xl_app) uses the optional extra, pip install kitchensink4xl[com], which does nothing outside Windows.
com_render_sheet needs a signed-in desktop session. Rendering a sheet to an image goes through Excel's clipboard, which a hidden Excel in a non-interactive session cannot use. Every other xl_app operation runs unattended.
A desktop tool, not a shared service. The server runs under your account on your computer, and xl_app drives an Excel in your Windows session. It is not designed to be shared by a team from one installation.
Deleting a sheet breaks references to it. Formulas and names that point at a deleted sheet show #REF!, as they do in Excel. Renaming a sheet rewrites them. Audit references first if you are unsure.
File edits cannot recalculate. After a write through the file tools, cells downstream keep their old cached values until Excel recalculates. The labels tell you which values are affected, and recalculate in xl_app fixes them.
Version 2.0 regroups the 69 flat tools of 1.2.x into the seven tools above. Every operation keeps its name except enable_tools and disable_tools, which are gone, but you now call it as an operation of a tool: xl_edit with op="set_cell" instead of a tool named set_cell. The command names, the package name and the install routes are unchanged.
If you called | It now lives in |
|
|
|
|
|
|
|
|
|
|
|
|
| Gone. Every operation is available from the start |
A few values changed spelling, and the old spellings still work: conditional-format and validation values are snake_case (greater_than, last_7_days, text_length), and manage_chart takes at_cell instead of anchor. Your old KS4XL_MODE and KS4XL_PACK_POLICY defaults need no editing; see the note on settings above. docs/surface_map.md lists every 1.2.5 tool beside its replacement and every changed value, and the migrate-from-v1 recipe in get_workflows gives your AI the same map. The changelog lists everything else that changed.
The suite has 5,340 tests in tests/unit, and it runs on every pull request. Structural edits are checked against Excel's own recalculation, formulas across every documented function family are written and reopened without repair prompts, and the fixture workbooks include features that only Excel can author, such as pivot tables, slicers and shapes. A separate set of gates that drives a real Excel runs locally on Windows.
Please open an issue when something fails, is refused unexpectedly or returns a wrong number. Rebuild the structure with placeholder data rather than attaching a private workbook, and include the output of get_server_info, which is designed to be safe to share. Feature ideas are welcome here. For security issues, follow SECURITY.md.
The Business edition pairs these tools with a Windows installer, a signed update channel and support under the Business terms. Update checks tell you when a covered release is available, and nothing installs on its own. See pricing. The Community edition stays free under the AGPL, including business use that meets its terms.
Bug reports, fixes, tests and documentation are welcome. See CONTRIBUTING.md; first-time contributors agree to the Contributor License Agreement.
KitchenSink4XL is dual-licensed.
AGPL-3.0. Free for anyone, including businesses, for any use that complies with the AGPL. Its terms include sharing your source code, with your modifications, when you distribute the software or make it available over a network.
Commercial license. For organizations that want to build KitchenSink4XL into their own products or services without the AGPL's source-sharing obligations. Contact licensing@kitchensink4.ai.
Provided as is, without warranty of any kind, under the terms of the license.
Copyright (c) 2026 Alvut Consulting, LLC. KitchenSink4AI is a product line of Alvut Consulting, LLC. KitchenSink4AI tools are built with the help of AI coding assistants, and every release goes through the full test suite before it ships.
Not affiliated with, endorsed by, or sponsored by Microsoft Corporation. Microsoft and Excel are trademarks of the Microsoft group of companies. GitHub and Copilot are trademarks of the Microsoft group of companies. Claude is a trademark of Anthropic. Codex and OpenAI are trademarks of OpenAI. All other trademarks are the property of their respective owners.
Needs Microsoft Excel on Windows: full recalculation, real pivot tables, PDF export, sheet render to PNG, format conversion, password encryption, exact autofit, goal seek, sparklines and the opens-clean check. Reads go through xl_read, and cell, format and structure edits through xl_edit, xl_format and xl_structure. Ops that change the workbook back it up first. These ops run in a private hidden Excel that this server starts and closes. They never attach to or change the user's own Excel, and a workbook the user has open in Excel is refused, not edited. Ops, one per line, as name(required; opt optional): what it does. path, backup and verify_com are not repeated; xl_help shows them:
recalculate(opt engine timeout_seconds allow_network): Recalculate every formula in a hidden Excel and save the results; a circular reference is named.
com_manage_pivot(action; opt name source_sheet source_range dest_sheet dest_cell rows columns filters values timeout_seconds allow_network): Create, refresh, delete or list real pivot tables through Excel.
com_export_pdf(output; opt scope sheet range_a1 overwrite timeout_seconds allow_network): Export to PDF via Excel's real renderer.
com_render_sheet(output; opt sheet range_a1 overwrite timeout_seconds allow_network): Render a sheet or range to a PNG exactly as Excel shows it; the workbook is not changed.
com_convert_format(output; opt format overwrite timeout_seconds allow_network): Convert the workbook to xlsx, xlsm, xlsb, xls, csv or ods with Excel's own Save As; the source is never overwritten.
com_save_with_password(password; opt current_password timeout_seconds allow_network): Encrypt the workbook with Excel's real password encryption; the password cannot be recovered, so keep the backup.
com_autofit(opt sheet columns rows timeout_seconds allow_network): True column and row autofit using Excel's real text metrics (the file tier can only estimate widths). More ops follow, in the same format, in the op parameter's description.
Inputs: op (required), args.
Values and formulas: set one or many cells, write, clear, copy or move ranges, the batch editor (apply_edits), find and replace, and CSV, TSV or JSON import. A string starting with '=' is always stored as a formula. Formatting is xl_format; sheets, rows and tables are xl_structure. Every change backs the file up first, saves atomically and verifies after writing. Refuses a workbook open in Excel, and a workbook whose fragile parts a save would drop unless allow_loss is true. Ops, one per line, as name(required; opt optional): what it does. path, backup and verify_com are not repeated; xl_help shows them:
set_cell(location, value; opt sheet allow_loss): Write one cell by location; a string starting with '=' is always stored as a formula.
set_cells(cells; opt sheet echo_cells allow_loss): Write many individually addressed cells as ONE atomic batch, the scatter complement to write_range.
write_range(location, data; opt sheet parse_dates echo_cells allow_loss): Write a rectangular 2D block of values and formulas from the location's top-left cell; ragged rows are refused.
clear_range(location; opt what sheet allow_loss): Clear a cell or range: what='contents' removes values and formulas, 'formats' resets styles to default, 'all' does both.
copy_range(source, dest; opt what adjust_formulas sheet allow_loss): Copy a source rectangle to a destination anchor (location objects, may name different sheets).
move_range(source, dest; opt sheet allow_loss): Move a rectangle on the same sheet, rewriting every reference into it so references follow the cells.
apply_edits(edits; opt echo_cells allow_loss): Apply many addressed edits as ONE atomic batch.
replace_cells(find, replace; opt look_in match match_case sheet location dry_run formulas allow_loss): Find and replace across a workbook, sheet or range (exact, contains or regex); dry_run=true changes nothing. More ops follow, in the same format, in the op parameter's description.
Inputs: op (required), args.
How cells look and what sits on the sheet: number formats, fonts, fills, borders, named styles, the format painter, column widths and row heights, merges, conditional formats, comments, hyperlinks, images, charts and sheet view. Values are xl_edit. Every change backs the file up first; refuses a workbook open in Excel. Ops, one per line, as name(required; opt optional): what it does. path, backup and verify_com are not repeated; xl_help shows them:
format_cells(location; opt number_format font fill border alignment sheet allow_loss): Apply formatting to a range, merging onto the existing style so unspecified attributes are preserved.
apply_style(style; opt location define sheet allow_loss): Apply a NAMED cell style to a range, optionally defining it first.
copy_format(source, dest; opt sheet allow_loss): Copy one cell's complete format onto every cell of a destination range, leaving values untouched.
set_dimensions(opt sheet column_widths row_heights autofit_columns hide_columns hide_rows group_rows group_columns ungroup_rows ungroup_columns outline_summary allow_loss): Set column widths and row heights, hide or group rows and columns; autofit here is an estimate (xl_app com_autofit is exact).
set_merge(action; opt location sheet confirm_data_loss allow_loss): Merge or unmerge cell ranges, or list every merge.
manage_conditional_format(action; opt location cf_type params sheet index allow_loss): Add, list or delete conditional-formatting rules (cell_is, formula, color scales, data bars, icon sets and more).
manage_comment(action; opt location text author sheet allow_loss): Add, edit, delete or list cell notes; list also reads threaded comments. Leave author out to sign with the user's own name, or pass author="assistant" to sign as "AI Assistant via KS4XL". More ops follow, in the same format, in the op parameter's description.
Inputs: op (required), args.
Read-only help. Call it when an op's arguments are unclear or after a BAD_PARAMS refusal. With no arguments it lists every tool and its ops; with op it returns that op's full arguments, an example call and the tool that runs it; topic='location' explains the location object. Reads no file.
Inputs: op, topic.
Read-only: look at a workbook before changing it (grid view, cells, queries, find, tables, audits, checks). Never changes a file, and works while it is open in Excel. To change anything use xl_edit, xl_format, xl_structure, xl_workbook or xl_app. Ops, one per line, as name(required; opt optional): what it does. path, backup and verify_com are not repeated; xl_help shows them:
get_workbook_metadata(): Read sheets, true used ranges, names, tables and a hazard summary; the call to orient before editing.
get_grid_view(opt location sheet max_rows max_cols values): Show a sheet or range as a compact A1 table with formula and merge markers, plus an anchor token for later edits.
read_range(location; opt values sheet): Read a cell or range by location; values='displayed' gives the text Excel shows, 'both' labels each value.
get_cells(cells; opt values sheet): Read many individually addressed cells in one call, the scatter complement to the rectangular read_range.
query_range(opt location sheet header columns where match order_by aggregate group_by limit offset distinct records values): Filter, sort, page and aggregate a range on the server, so only the rows and columns needed come back.
find_cells(query; opt look_in match match_case sheet location limit offset): Find every cell whose value or formula matches (exact, contains or regex), with its address; pages with limit and offset.
get_table(name; opt columns values records): Read a table's data by its name (case-insensitive).
diagnose_workbook(): Scan for fragile parts (pivots, slicers, shapes, macros, queries) a file save would drop, and recommend the route.
validate(opt checks): Run read-only checks (default structure, references, calc_staleness) and return one report.
audit_formulas(opt location sheet): Audit formulas in a range, sheet or workbook: external references, volatile functions, missing cached values, errors. More ops follow, in the same format, in the op parameter's description.
Inputs: op (required), args.
Workbook structure: add, rename, delete or hide sheets, insert or delete rows and columns (references are rewritten), tables, named ranges, sort, filters and data validation. Values are xl_edit. Every change backs the file up first; refuses a workbook open in Excel. Ops, one per line, as name(required; opt optional): what it does. path, backup and verify_com are not repeated; xl_help shows them:
manage_worksheet(action; opt sheet new_name index state allow_loss): Add, delete, rename, copy, reorder, hide or unhide a sheet; rename rewrites references to it and delete turns them into #REF!, as Excel does.
modify_grid_structure(action, at; opt count sheet allow_loss): Insert or delete rows or columns and rewrite every reference on every sheet; references inside a deleted band become #REF!.
create_table(location, name; opt header style row_stripes col_stripes totals_row totals sheet allow_loss): Turn a range into an Excel table (ListObject) named name.
manage_table(name, action; opt values index column new_name new_ref style on totals row_stripes col_stripes sheet allow_loss): Add or delete rows and columns, rename, resize, toggle totals, restyle or unlist the table named name (action).
manage_name(action; opt name refers_to scope new_name allow_loss): Add, delete, rename, update or list defined names; an ambiguous name refuses until scope is given.
sort_range(location, keys; opt has_header sheet allow_loss): Sort a range or table body by one or more keys, writing the rows back reordered.
set_filter(location; opt criteria sheet allow_loss): Apply an autofilter and hide the rows that do not meet all criteria; rows with uncalculated formulas stay visible.
clear_filter(opt location sheet allow_loss): Remove the autofilter from a sheet and unhide the rows it hid, the reverse of set_filter. More ops follow, in the same format, in the op parameter's description.
Inputs: op (required), args.
Whole files: create, copy, backups, document properties, protection, page layout, headers and footers, and export of a range or sheets to CSV, TSV or JSON. Exports never overwrite the workbook or its backups. Edits inside a sheet belong to the other tools; manage_backups lists, restores and snapshots the automatic backups. Ops, one per line, as name(required; opt optional): what it does. path, backup and verify_com are not repeated; xl_help shows them:
create_workbook(opt sheets overwrite): Create a new .xlsx workbook at path with the given sheet names (default a single 'Sheet1').
copy_workbook(src, dst; opt overwrite): Copy a workbook byte for byte from src to dst; an existing dst is replaced only with overwrite=true, after a backup.
manage_backups(action; opt path directory source scope dry_run label dest_dir): List, restore, purge or snapshot the automatic backups (prev and anchor slots, and the copies deletes and clears keep); purge is a dry run unless dry_run=false.
set_workbook_properties(opt title author subject keywords category comments calc_mode full_calc_on_load iterative_calc max_iterations max_change allow_loss): Set document properties and calculation settings (mode, full calc on load, iteration); with none it reports them.
set_protection(action; opt sheet password options unlock_ranges locked structure windows scope allow_loss): Protect or unprotect sheets and workbook structure; advisory only, not encryption (xl_app com_save_with_password encrypts).
set_page_layout(opt sheet orientation paper_size margins scale fit_to_width fit_to_height print_area print_title_rows print_title_cols gridlines headings allow_loss): Set print settings: orientation, paper size, margins, scale or fit, print area and repeated titles; unset values stay.
set_header_footer(opt sheet header footer apply_to raw allow_loss): Write the three-section page headers and footers. More ops follow, in the same format, in the op parameter's description.
Inputs: op (required), args.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 7 tools
The seven tools split by resource domain (read, edit, format, structure, workbook, app, help), and each description explicitly cross-references where a neighboring tool owns an operation (values=edit, formatting=format, sheets/rows/tables=structure). A few boundaries are inherently fuzzy — clear_range with what='formats', apply_style vs format_cells, and the deliberate autofit duplication (set_dimensions estimate vs xl_app com_autofit exact) — but the descriptions call these out, so misselection is unlikely rather than impossible.
Every tool follows the same 'xl_' + lowercase domain-noun convention (xl_read, xl_edit, xl_format, xl_structure, xl_workbook, xl_app, xl_help), with no mixing of camelCase, snake_case, or verb styles. The set is a resource taxonomy rather than verb_noun, but it is applied perfectly consistently and is easy to predict and extend.
Seven top-level tools is well within the ideal range and each namespace earns its place as a genuine domain (read, edit, format, structure, workbook, Excel COM, help). The caveat is that each 'tool' is a mega-tool with 8-10+ listed ops plus an undisclosed tail ('more ops follow in the op parameter's description'), which makes the effective surface much larger than seven suggests.
The surface covers the full Excel lifecycle end to end: creation and copying (xl_workbook), reading and auditing (xl_read), values and formulas (xl_edit), styling and objects (xl_format), sheets/rows/tables/names/validation (xl_structure), plus real-Excel operations like pivots, PDF/PNG export, and password encryption (xl_app). Backups, validation, dry-run, and help are also present, so there are no obvious dead ends for the stated domain.
The Excel engine for AI agents: read, check and edit Excel models over MCP.
Convert, create and edit Word, PowerPoint, Excel and PDF documents from any AI agent.
Connect AI assistants to Google Sheets through controlled tools for reading and updating rows.
AI access to Quadratic spreadsheets: open files, run Python/SQL, query connected databases.
