Give your agent real Word and Excel.

One MCP server. The agent opens your workbook or document, reads it the way the engine reads it — formulas, macros, Power Query, paragraphs, comments — proposes a change, applies it after you say yes, and hands the file back as a copy that Excel and Word open without a repair dialog. No pixels, no screenshots, no “export to markdown and hope”.

Connect in one minute

Any MCP client that speaks streamable HTTP, or the Docker image below over stdio. No account, no key. Each session gets its own private editor cabin on our server; files are deleted after 24 hours.

{ "mcpServers": { "sumoffice": { "command": "npx", "args": ["-y", "mcp-remote", "https://view.sumoffice.com/mcp"] } } }

Claude Desktop: claude_desktop_config.json. Claude Code: claude mcp add --transport http sumoffice https://view.sumoffice.com/mcp. Cursor and others: the same URL as a remote server.

Local files, over stdio. The same server as a Docker image on your machine: the agent passes a path under the mounted folder, the file opens in a private cabin on our server just like above.

{ "mcpServers": { "sumoffice": { "command": "docker", "args": ["run", "-i", "--rm", "-v", "/path/to/files:/work", "hissih/sumoffice-mcp"] } } }

Image hissih/sumoffice-mcp on Docker Hub, linux/amd64 and arm64, 0.3.0. Then document_open_file with path: "/work/report.xlsm".

What the agent can do

Open	`document_open_file` — your file by `url` or as `base64` + `name` (.docx .doc .odt .xlsx .xlsm .xlsb .xls .ods, up to 50 MB). `document_open` — a demo file by name, to try things.
Read a workbook	`sheet_describe` (tabs, used ranges, revision), `sheet_read` (values and formulas of a range), `sheet_find`, `macro_list` / `macro_read_source` / `macro_plan` (the VBA project: entry points, routes, blockers — nothing runs), `query_list` / `query_explain` (Power Query steps and load targets), `workbook_inspect` (the whole application model in one call).
Read a document	`document_describe`, `document_read` (paragraphs as a window), `document_find`, `document_comments` (comments and tracked changes).
Change	`sheet_propose_edits` → `sheet_apply`: up to 20 cells, previewed by the engine first (what would change, whether errors appear, whether input numbers get overwritten). `document_propose_replacement` → `document_apply`: the new text of one paragraph, with before/after and checks (numbers, dates, links kept). Nothing changes until the apply call, and a stale proposal is refused, not silently applied.
Get it back	`document_save_copy` — the edited file as a 24-hour download link (a macro workbook comes back as .xlsm with the VBA project untouched). `document_export_pdf` — the document laid out by the engine, as PDF, with the page count.

Proof, 20 September 2026

Workbook with VBA and a dynamic-array UDF (from the Enron corpus): the agent opened it, read A1:F12, proposed H2 = SUM(B2:B5) and a label in H1, applied, saved a copy. Microsoft Excel 16 opened the copy with no repair dialog; xl/vbaProject.bin in the copy is byte-identical to the original; H2 holds the formula and its computed value.
Document: the agent replaced paragraph 1, applied, saved a copy and rendered a PDF. Microsoft Word 16 opened the copy and shows the new text as paragraph 1; styles.xml and every package part are unchanged; the PDF carries the edit.
Both runs were driven by a plain MCP client over HTTPS from a laptop, against the public server above — not a lab build.

What it refuses, on purpose

Writing into your original. Every change lives in the session's cabin and comes back as a copy you download.
Running macros or refreshing queries in this version. The agent can read and plan them; running on a copy is in the editor's agent panel today and comes to MCP next.
Guessing. A missing paragraph, an unknown sheet, an edit outside the previewed window, a proposal made on an older revision — each is a refusal with the reason, not a best effort.

Scope today

Remote server on our infrastructure (Frankfurt), one file per session, sessions expire after 10 minutes of silence, five concurrent sessions per server. Cell edits are values and formulas in a rectangular window; paragraph edits replace the text of one paragraph and keep its formatting. Want the same server inside your own network, next to your files, with the editors as a server? Write to us.

What happens to the file

The bytes go over HTTPS to our server and open in a private editor cabin for your MCP session. Nothing in the file is executed.
The opened file and every copy or PDF are deleted after 24 hours. Not copied to storage, analytics or third parties. Details in the privacy policy.

Made by SumOffice. Privacy · Contact