xlide-excel-word-powerpoint-access-office-vba-mcp
Summary: xlide-mcp reads, writes, analyzes and runs VBA and the surrounding document inside Excel, Word, PowerPoint, Access and VB6 files — without needing Office for file-layer work.
Discover files & projects:
xlide_list_projects,xlide_project_info,xlide_validate_project,xlide_create_project,xlide_doctorRead/write VBA:
xlide_list_modules,xlide_read_module,xlide_write_module,xlide_edit_module,xlide_rename_module,xlide_delete_module,xlide_list_procedures,xlide_search_modules— writes are content-token guarded against stale editsStatic analysis:
xlide_analyze,xlide_analyze_source,xlide_rules(165 diagnostics, host-specific object models; errors are build failures)UserForms / Access forms:
xlide_list_forms,xlide_read_form,xlide_manage_form,xlide_edit_formReferences & Access catalog:
xlide_list_references,xlide_manage_reference,xlide_access_catalog,xlide_read_access_queryPower Query (M):
xlide_list_queries,xlide_read_query,xlide_write_query(set, rename, remove, load, unload)Sheets & cells:
xlide_list_sheets,xlide_read_cells,xlide_write_cells,xlide_evaluate_formula,xlide_check_cells,xlide_format_cells,xlide_sort_rows,xlide_remove_duplicates,xlide_copy_cellsStructure & objects:
xlide_manage_sheet,xlide_manage_rows_columns,xlide_manage_table,xlide_manage_name,xlide_manage_filter,xlide_page_setupRules, links & notes:
xlide_manage_validation,xlide_manage_conditional_format,xlide_manage_hyperlink,xlide_manage_commentShapes & charts:
xlide_list_shapes,xlide_manage_shape,xlide_update_shape,xlide_set_shape_macro,xlide_add_chartExecution (Windows + Office):
xlide_run_macro,xlide_run_vba,xlide_run_tests,xlide_compile_checkInteract with the user's Office apps:
xlide_is_open,xlide_open_in_app,xlide_close_in_appLive VBE editing:
xlide_live_sessions,xlide_live_state,xlide_live_request,xlide_live_read_moduleSource control:
xlide_export_modules,xlide_import_modules,xlide_git_changes, plus a--textconvgit driver so binary Office files diff as textFormats: Excel
.xlsm/.xlsb/.xlam/.xls/.xlsx, Word.docm/.dotm/.doc, PowerPoint.pptm/.potm, Access.accdb/.mdb, VB6.vbpSafety:
--rootpath boundary,--read-onlymode, previews for batch edits/imports/exports, and explicit flags required for overwrites, protected or signed projects, and destructive actions
Provides Git integration for Office files, including a textconv driver so VBA, Power Query, and sheet inventory render as text in git diff, git show, and git log, as well as a tool for reporting changes to modules and queries since any revision.
xlide-mcp
An MCP server for the inside of an Office file. Read, write, analyze and test the VBA in Excel, Word, PowerPoint and Access, and edit the document around it. Visual Basic 6 projects open the same way.
VBA, Power Query and OOXML worksheet edits need no Office installation and run on
Windows, macOS and Linux. Reading .xlsb and .xls cells, writing .xlsb cells,
and running macros or tests need Windows with the desktop application.
xlide_list_projects -> Budget.xlsm
xlide_project_info Budget.xlsm -> 4 modules, 2 sheets, 1 query, not signed
xlide_read_module Helpers -> the source, and a content token
xlide_write_module Helpers -> guarded by that token
xlide_analyze Budget.xlsm -> 0 errors, 2 warnings
xlide_run_tests Budget.xlsm -> 12 passedWhy
An agent asked to fix a macro works from a copied snippet with no idea what else is in the project, or asks the user to export the modules and paste them back afterwards. Both treat the Office file as opaque. The VBA project, the form designs and the M code are all readable and writable without opening the application at all.
This server makes that reachable, and bounds it. A write is refused if the module changed since it was read. An analysis error fails the change. A run happens in an application the server created and holds a deadline over. Anything that cannot be undone is the user's decision.
Related MCP server: Office MCP Server
Implementations
Directory | Language | Status |
Python 3.10+ | Reference implementation |
Other languages go in sibling directories. Python is normative: it tracks the upstream libraries, and ports track it. See docs/porting.md.
Install and run
pip install xlide-mcp # reads and writes files, any platform
pip install "xlide-mcp[live]" # adds running macros and tests, Windows
xlide-mcp --root /path/to/your/filesPoint a client at it. For Claude Desktop, Claude Code or any client that launches a server over stdio:
{
"mcpServers": {
"xlide": {
"command": "xlide-mcp",
"args": ["--root", "/path/to/your/files"]
}
}
}For VS Code, put this in .vscode/mcp.json at the workspace root. VS Code uses
servers here; the portable .mcp.json format above uses mcpServers.
{
"servers": {
"xlide": {
"type": "stdio",
"command": "uvx",
"args": ["--from", "xlide-mcp[live]", "xlide-mcp", "--root", "${workspaceFolder}"]
}
}
}Run MCP: List Servers in VS Code to start xlide and inspect its output if it
does not register. The server prints its version and allowed roots to stderr on
startup. The VS Code configuration format and commands are described in
VS Code's MCP guide.
Or install nothing and let uv fetch it on first run. uv is one binary and installs its own Python, so a machine with neither can still run this:
{
"mcpServers": {
"xlide": {
"command": "uvx",
"args": [
"--from", "xlide-mcp[live]",
"xlide-mcp", "--root", "/path/to/your/files"
]
}
}
}The live extra is safe to ask for on every platform: what it pulls in is marked
sys_platform == 'win32', so off Windows it resolves to nothing and the same
configuration works everywhere. Drop the --from pair for the file layer alone.
uvx takes the newest published version unless you pin it, as xlide-mcp@1.2.4.
There is a Dockerfile for the file layer, which is the part that needs no
Office installation. Mount the folder holding the files at /workspace, because
that is the root the container is bounded to:
docker build -t xlide-mcp .
docker run --rm -i -v "$PWD:/workspace" xlide-mcp--root is the security boundary. Every path a tool accepts is resolved,
symlinks included, and refused unless it lands inside a root. Add --read-only
to allow reads and analysis and refuse every write.
Call xlide_doctor first from a new client: it reports the workspace roots, which
layers are installed, which Office applications this machine has, and whether
each one has the Trust Center setting that module injection needs.
What it does
Files - the VBA project and the document it lives in. Most file tools need no Office installation; binary Excel grids use Excel on Windows.
The code project
Discover |
|
Modules |
|
Analysis |
|
Forms |
|
References and catalog |
|
Source control |
|
xlide_edit_module accepts preview_only=true to check a batch of line edits and
return its proposed diff without saving. The preview's content token can be used
to apply the same edits if the module has not changed.
xlide_search_modules returns tokens for matched modules, so its line numbers
can also be passed directly to a guarded edit.
Broad searches can be paged with offset and next_offset; total_match_count
reports how many matching lines exist across all pages.
xlide_list_procedures returns a content token for guarded edits at the listed
lines. Reading an empty module returns its empty body and token.
Writing an identical module or applying an unchanged module import skips the save;
the response reports saved=false.
Applying an unchanged export leaves the existing .bas and .cls files untouched.
Long Power Query formulas can be read by line; the read returns a token that
xlide_write_query can use to refuse a stale change.
Large form designs can be read in pages with offset and next_offset.
Office file, VBA module and Power Query lists also return next_offset when a
later page is available.
For crowded drawing layers, pass sheet to xlide_list_shapes and follow its
next_offset to read later shapes.
Worksheet lists mark unreadable visibility or pivot metadata as unknown, and formatted or rich
text cell reads name the cell when decoding fails instead of returning a blank.
An Excel-backed worksheet survey refuses malformed output instead of dropping sheets.
An Excel-backed cell read refuses a partial grid instead of labeling it as the full range.
Form summary lists use the same offset and next_offset paging.
Form reads distinguish missing properties or sections from a read failure, and
an unreadable Access report collection fails instead of appearing empty.
Procedure lists also return next_offset for long modules.
Structural validation problems can be read with offset and next_offset.
Access catalog lists return a next_offsets entry for each included collection.
Long saved query SQL is previewed in the catalog; xlide_read_access_query
returns the full text in character pages with a content token.
The list actions for tables, names, validation, conditional formats, hyperlinks
and comments also accept offset and max_results and return next_offset.
Merging cells keeps only the top-left value. xlide_format_cells refuses to clear
other values or formulas unless allow_overwrite=true is passed.
xlide_sort_rows sorts a range, table or filter with ordered keys;
xlide_remove_duplicates keeps the first matching row. xlide_copy_cells copies
between sheets with Paste Special options and requires allow_overwrite=true.
xlide_update_shape changes a shape's position, name, text, alt text or visibility
without removing it; it also changes a Forms control's linked cell or list range.
xlide_check_cells lists Excel's green-triangle error checks, including numbers
stored as text and inconsistent formulas, with paging for long lists.
The document around it
Power Query |
|
Sheets and cells |
|
Structure |
|
Tables and names |
|
Rules, links and notes |
|
Shapes and charts |
|
Execution - Windows with the desktop application.
xlide_run_macro, xlide_run_vba, xlide_run_tests, xlide_compile_check
Your Office applications - Windows with the desktop application. The one place this server acts inside an application the user is running, and only on the file named.
xlide_is_open, xlide_open_in_app, xlide_close_in_app
Live editor - a running xlide_vbide session inside the Visual Basic Editor.
xlide_live_sessions, xlide_live_state, xlide_live_request, xlide_live_read_module
xlide_live_read_module accepts line ranges for long unsaved source and returns
a content token for comparing that source with the saved module.
Both analysis tools return next_offset when findings exceed a page, while
keeping their full severity counts.
Formats
Host | Extensions |
Excel |
|
Word |
|
PowerPoint |
|
Access |
|
Visual Basic 6 |
|
VBA reads and writes in all of them. Power Query is available in .xlsx, .xlsm,
.xlsb and .xlam; package-based worksheet edits are available in .xlsx,
.xlsm and .xlam. A .xlsx has no VBA project by design and is listed anyway,
since its queries and sheets are fully reachable.
A recognized extension outside those sets is listed with the reason it cannot be opened. Nothing drops out of a listing without saying why.
Excel, Word and PowerPoint write no VBA project into a macro-enabled file until
its first macro exists, so a .xlsm nobody has written code in yet has none.
That is an ordinary file: the listings answer empty, and the first module
written gives it the project its application would have made.
An Access database that has never held code can likewise have no project;
xlide_write_module creates it with the first module, or
xlide_create_project adds an empty one to an existing .accdb.
A .xlsb keeps its grid in binary records and a .xls inside a compound file,
neither of them OOXML. On Windows with Excel, those go through Excel, and the
result says source: excel and recalculated: true, because opening the
workbook is what produced the values.
This path returns values only; .xls cells cannot be written through this server.
Seeing what changed
An Office file is one binary blob to git, so a commit that changed a line of VBA
and one that replaced the whole project are the same three words: Binary files differ. Two ways out, both reading the file through the same renderer.
xlide_git_changes reports what changed since any revision, one entry per module
and query, each with a unified diff. Call it before committing, or to review what
an agent just did.
xlide-mcp --textconv is a git textconv driver. Wire it up once and the file
diffs as text everywhere git looks:
echo '*.xlsm binary diff=vba' >> .gitattributes
git config diff.vba.textconv "xlide-mcp --textconv"
git config diff.vba.cachetextconv true Public Sub Greet()
- MsgBox "hello"
+ MsgBox "hello, world"
+ Debug.Print Now
End SubThat is git diff on a .xlsm. git show and git log -p convert too.
Inside VS Code beside XLIDE, there is a third way. Every write tells a running XLIDE what changed, and a module write carries its before and after, so XLIDE marks the module as an agent edit in its project tree, opens the diff, and offers Keep and Revert, as it does for its own agent tools. It needs an XLIDE that listens for this; docs/xlide-vscode-bridge.md is the protocol. With no XLIDE running, nothing changes.
binary diff=vba rather than diff=vba alone. The binary macro means
-diff -merge -text, and the later diff=vba overrides only its -diff, so the
file keeps -text and git never applies end-of-line conversion to a container it
would corrupt.
In VS Code, any side of a diff that comes out of git history renders through the
driver, because the git extension reads blobs with git show --textconv.
Comparing two revisions of a workbook therefore shows VBA. The Source Control
panel's working-tree diff does not: the right-hand side there is the file on
disk, still binary.
Both routes render VBA, Power Query and the sheet inventory. Cell values are not included, and the first line of every rendered file says so, because a reader who does not know the scope takes an empty diff for an unchanged workbook. git still stores the blob either way, so merges stay binary.
The rules it works by
These are in the server's own instructions, so every agent that connects reads them whether or not the user configured anything.
The VBA inside the file is the only source of truth for it. Exported
.basand.clsfiles are copies and go stale.A read returns a content token. Pass it back on the write, and the write is refused if anything changed the module in between.
Analysis after every change, and an error is a build failure.
A run happens in an Office instance the server created and can therefore terminate. The user's own applications are touched only through the three tools above, on the file named: unsaved work is closed only when the call says to save or discard it, and a process is ended only when asked, and only the one Windows names as holding the file.
Anything hard to undo is the user's decision: deleting a module, overwriting cells that hold data, writing to a project that is signed or password-protected. Cell overwrites and writes to signed or protected projects are refused until the call carries the flag that allows them.
A cell value is what Excel last calculated. A formula written here has no result in the file until Excel next opens it.
calculate=trueworks results out with pyOfficeEditor's formula engine, which names any cell it could not.
Security
Report a vulnerability through private vulnerability reporting, not a public issue. SECURITY.md says what to include and which versions receive fixes.
CodeQL and Semgrep scan the server and release workflows, pip-audit checks the runtime dependencies, and ClamAV and YARA-X, with the YARA Forge rules, scan every tracked file and the built wheel and sdist, on every push, pull request, daily run and release. An unexpected finding, scan warning or missing scan stops a release. Each successful release carries its security report and the SARIF results as downloadable assets. Dependabot proposes dependency and workflow updates for review.
Built on
Reads and writes VBA, UserForms and Power Query inside Office files, in pure Python. | |
The document surface: cells, formulas, formatting, tables, validation, rows and columns. | |
The static analyzer: 165 diagnostics, measured against each host's object model. | |
Runs VBA in desktop Office under a supervisor that enforces a deadline. | |
Where the tool surface, the content-token guard and the agent instructions come from. | |
The live editor session the |
Contributing
cd python
pip install -e ".[dev,live]"
python -m pytest # the file layer, no Office needed
python -m pytest -m live # the rest, real Office, Windows only
python -m ruff check src tests toolsThe generated contract under contract/ must stay current; the test
suite fails if it does not. After changing a tool:
python tools/export_contract.py
python tools/export_conformance.pyLicense
MIT.
Available Tools
65 toolsxlide_access_catalogAccess tables and queriesARead-onlyIdempotent
Lists what an Access database holds besides its code: tables with their columns, saved queries with their SQL, and the relationships between tables. An .accdb is an application rather than a document, and the VBA in it is written against these, so reading the modules alone shows half of it. Use include with offset and next_offsets to page through a large catalog. Long query SQL is previewed; use xlide_read_access_query for the whole text. If one query's SQL cannot be read, that entry has sql=null and sql_error rather than hiding the catalog. Access files only.
Inputs: file_path (required), offset, include, max_results, +1 more. Returns: object
xlide_add_chartAdd a chartA
Adds a chart of a block of cells to a worksheet and saves the workbook, written as Excel's Insert Chart writes one of the same type. The block's first row names the series and its first column holds the categories, as Excel reads a selection; a block taller than it is wide makes a series of each column. The data can be on another sheet, as Data!A1:C13. Place it with cell or left and top in points. xlide_list_shapes reports it afterwards with each series' formula.
Inputs: sheet (required), file_path (required), data_range (required), top, +8 more. Returns: object
xlide_analyzeAnalyze VBAARead-onlyIdempotent
Runs static analysis over every VBA module in an Office file and returns the problems with module, line, column, code and message. Needs no Office installation and runs nothing. Each file is measured against its own host's object model, so Word code is never judged by Excel's surface, and a Visual Basic 6 project against no host at all, because its code does not run in one. Call this after every VBA change and treat any problem at error severity as a build failure: fix it and analyze again until it is clean. Warnings are worth reading; some are style, some are the bug. Use offset and next_offset to read later findings.
Inputs: file_path (required), offset, max_results, module_name, +1 more. Returns: object
xlide_analyze_sourceAnalyze VBA sourceARead-onlyIdempotent
Runs static analysis over VBA source you are holding, before it is written to a file. Use it to check code you have just generated: it costs nothing, needs no file, and catches the compile errors that would otherwise surface in front of the user. Pass host so the code is measured against the right object model, and file_path instead if the code is destined for a file that already exists, which resolves calls into the rest of that project. Use offset and next_offset to read later findings from a long result.
Inputs: source (required), host, kind, offset, +3 more. Returns: object
xlide_check_cellsFind Excel cell error indicatorsARead-onlyIdempotent
Lists cells Excel would mark with a green error-checking triangle, such as numbers stored as text, inconsistent formulas, or formulas with cached errors. Returns the rule and cell for each finding. Excel hides ignored findings unless include_ignored=true. Formula-dependent checks use the file's cached results, which may be stale until Excel recalculates and saves it. Works on .xlsx, .xlsm and .xlam; page through long lists with offset and next_offset.
Inputs: sheet (required), file_path (required), rules, offset, +2 more. Returns: object
xlide_close_in_appClose in OfficeADestructive
Closes a file in the Office application the user has it open in, which frees it for a write. Only that file: the application stays, unless this server started the instance and nothing else is open in it. A copy holding unsaved work is left open and reported, unless save_changes saves it first or discard_changes closes it without saving; losing the user's work is their decision, so ask them. When the application does not answer, or the file stays locked, end_process ends the process Windows says holds the file, and every unsaved document in that process is lost with it: ask the user first. Where the user was in the file is remembered, and xlide_open_in_app puts them back there. Windows only.
Inputs: file_path (required), end_process, save_changes, discard_changes. Returns: object
xlide_compile_checkCompile checkARead-onlyIdempotent
Asks the real VBA editor to compile a file's project, and reports whether it accepted it. Windows only. This is the compiler's own verdict, where xlide_analyze is a static analyzer's; run the analyzer first, because it is free and needs no Office, and use this when the last word matters. Excel is made visible for the check, because a hidden instance does not surface the compile-error dialog and would report a rejection as a pass.
Inputs: file_path (required), timeout. Returns: object
xlide_copy_cellsCopy or paste cellsADestructiveIdempotent
Copies a range to another cell or block, on the same sheet or another sheet, and saves the workbook. Paste Special can select values, formulas, formats, comments, validation, links or other parts; it can also transpose, skip blanks or combine values arithmetically. The destination may hold data, which the paste can replace. Set allow_overwrite=true only after the user agrees to replace it. Formulas and their relative references move as Excel's Copy does. Works on .xlsx, .xlsm and .xlam.
Inputs: sheet (required), file_path (required), destination (required), source_range (required), +6 more. Returns: object
xlide_create_projectCreate Office file or VBA projectA
Creates a new Office file with an empty VBA project at the given absolute path, from a template the application itself authored, so it opens with no repair prompt. Extensions: .xlsm, .xlsb, .xlam, .docm, .pptm, .accdb, and .xlsx for a workbook with Power Query and no macros. It never overwrites a file or replaces a project that is already there. A .xlsm, .docm or .pptm saved before its first macro has no VBA project at all; xlide_write_module gives it one along with the first module. This tool also gives an existing .docm or .accdb with no project the empty one its application makes.
Inputs: file_path (required). Returns: object
xlide_delete_moduleDelete moduleADestructive
Permanently deletes a VBA module from an Office file and saves it. There is no undo: ask the user first, and read the module before deleting it so its code can be put back if they change their mind. Document modules cannot be deleted. For Excel, the write is refused if the server cannot check whether a shape still calls the module.
Inputs: file_path (required), module_name (required), allow_protected, expected_content_token, +1 more. Returns: object
xlide_doctorWhat this machine can doARead-onlyIdempotent
Reports what this server can reach: its workspace roots, whether it is read-only, which optional layers are installed, and, on Windows, which Office applications are available to run macros and tests. Call it when a tool reports something missing, or before promising the user a test run.
Inputs: no named parameters. Returns: object
xlide_edit_formEdit form designADestructiveIdempotent
Changes one form's design and saves the file: add a control, remove one, or set a property on one. Geometry is in points for a UserForm and twips for an Access design. Setting a property to null clears it, putting the control back at its default. Removing a container takes its children with it, so ask the user first. Adding a control does not write its event procedure; do that with xlide_write_module on the form's code module.
Inputs: action (required), file_path (required), form_name (required), control_name (required), +12 more. Returns: object
xlide_edit_moduleEdit module linesADestructiveIdempotent
Replaces, inserts or deletes several line ranges in one existing VBA module and saves once. Lines are 1-based against the original source returned by xlide_read_module, without the attribute header. Each edit has start_line, end_line inclusive, and replacement text. For insertion, set end_line to start_line - 1; an empty replacement deletes the named lines. Ranges must not overlap. expected_content_token is required and refuses a stale edit. Set preview_only to validate the edits and see the proposed diff without saving. An applied edit includes the read-back diff and new token. Analyze the file afterward.
Inputs: edits (required), file_path (required), module_name (required), expected_content_token (required), +3 more. Returns: object
xlide_evaluate_formulaEvaluate a formulaARead-onlyIdempotent
Works out what a formula would give in a cell of a workbook, without writing it there: to check a formula before xlide_write_cells, or to ask the workbook a question, such as =SUMIFS(Sales[Amount],Sales[Region],"West"). Uses pyOfficeEditor's formula engine, 493 of Excel's functions, with the workbook's cells as they stand. A formula written for one cell answers with one value, as Excel would give it there. Changes nothing. .xlsx, .xlsm and .xlam.
Inputs: sheet (required), formula (required), file_path (required), at. Returns: object
xlide_export_modulesExport modules to filesADestructiveIdempotent
Writes every VBA module in an Office file to a folder as .bas and .cls files, for source control or review. Previews by default: it reports what it would create, update and leave alone, and writes nothing until apply=true. Only when the user asks for it. Applying a plan leaves unchanged files alone. The exported files are copies: editing one changes nothing inside the Office file until xlide_import_modules runs.
Inputs: file_path (required), apply, delete_stale, export_folder. Returns: object
xlide_format_cellsFormat cellsADestructiveIdempotent
Changes how a range looks: bold and font, fill colour, borders, alignment, number format, and merging. Only what you pass is changed, so each cell keeps the rest of its own format and making a header row bold does not flatten the number formats under it. Colours are RRGGBB or AARRGGBB hex without a leading hash. A number format is an Excel format code such as '#,##0.00' or 'yyyy-mm-dd'; that code is also what decides whether a number is shown as a date. Merging clears values and formulas outside the top-left cell; allow_overwrite is required when that would discard content. Works on .xlsx, .xlsm and .xlam.
Inputs: sheet (required), file_path (required), cell_range (required), bold, +16 more. Returns: object
xlide_git_changesWhat changed inside the fileARead-onlyIdempotent
Lists what changed inside an Office file since a git revision, one entry per VBA module and Power Query, with a unified diff. git diff cannot show this: the file is binary, so a commit that changed one line and one that replaced the whole project look the same. Call this before committing, and to review what an agent or a colleague changed. Worksheet cell values are not compared. Defaults to HEAD; pass any revision git understands. Needs the file to be inside a git repository and tracked in that revision.
Inputs: file_path (required), section, revision, include_diff. Returns: object
xlide_import_modulesImport modules from filesADestructiveIdempotent
Reads .bas and .cls files from a folder back into an Office file's VBA project and saves it. Previews by default: it reports which modules would change and by how much, and writes nothing until apply=true. A file whose name matches no module creates one. Document modules such as ThisWorkbook are written but never created. Applying an unchanged plan skips the save. After a change, call xlide_analyze.
Inputs: file_path (required), source_folder (required), apply, allow_protected, +1 more. Returns: object
xlide_is_openIs the file open in OfficeARead-onlyIdempotent
Says whether a file is open in its Office application, in any running instance: read-only or for editing, with unsaved changes or not, and which processes hold it locked. Call it when a write reports the file is locked, before closing anything, or when the user asks. Windows only. Changes nothing.
Inputs: file_path (required). Returns: object
xlide_list_formsList formsARead-onlyIdempotent
Lists the UserForms in an Office file, or the forms and reports in an Access database, with each one's control count and, for Access, the sections a control can go in. A design's code is a module of the same name, read with xlide_read_module. An unreadable report collection is a failure, not an empty list. An unreadable design's sections are marked unknown with sections_error. Use offset and next_offset to read large form lists in pages.
Inputs: file_path (required), offset, max_results. Returns: object
xlide_list_modulesList modulesARead-onlyIdempotent
Lists the VBA modules in an Office file: name, kind (standard, class, document or userform), line count, and a content_token to pass to a guarded write. xlide_project_info returns this and more in one call; use this one when the file is already known and only the module list is wanted. Use offset and next_offset to read large projects in pages.
Inputs: file_path (required), offset, max_results. Returns: object
xlide_list_proceduresList proceduresARead-onlyIdempotent
Lists the Sub, Function and Property procedures in one module, with each one's kind, scope, line number and signature. The module's content_token can guard an xlide_edit_module call. Use it to find where to change something without reading a long module in full. Use offset and next_offset to page through a module with many procedures.
Inputs: file_path (required), module_name (required), offset, max_results. Returns: object
xlide_list_projectsList Office filesARead-onlyIdempotent
Finds the Office files in this server's workspace and returns their absolute paths, host application and whether their VBA can be opened. Call this first when the user has not named a file. Covers Excel (.xlsm, .xlsb, .xlam, .xls, and .xlsx for Power Query and sheets), Word (.docm, .dotm, .doc), PowerPoint (.pptm, .potm), Access (.accdb, .mdb), and Visual Basic 6 projects (.vbp, whose modules are the files its manifest names). Files whose extension is recognized but not openable are listed with the reason, so a template or add-in is not silently missing. Use offset and next_offset to read large workspaces in pages.
Inputs: offset, subfolder, max_results. Returns: object
xlide_list_queriesList Power QueryARead-onlyIdempotent
Lists the Power Query queries in an Excel workbook: name, group, description, where each loads, and its applied step names. If the M formula cannot be parsed, steps is null with steps_error rather than an empty list. Queries live outside the VBA project, so a plain .xlsx has them too. Call this when asked what a workbook does; a workbook with no macros can still be doing most of its work here. Use offset and next_offset to read large query lists in pages.
Inputs: file_path (required), offset, max_results. Returns: object
xlide_list_referencesList project referencesARead-onlyIdempotent
Lists the type libraries a VBA project references: the name code uses to qualify them, the kind, and the registry or file path the project recorded. Call it when a name will not resolve, when deciding between early and late binding, or when code works on one machine and not another: a reference names a path and a version, so a project can be broken by the machine rather than by its own code.
Inputs: file_path (required). Returns: object
xlide_list_shapesList shapes and buttonsARead-onlyIdempotent
Lists what sits on a worksheet's drawing layer: buttons, form controls, AutoShapes, text boxes, pictures, charts and groups, each with the cells it covers, its position in points and, where it has one, the macro a click runs. A form control also carries what it holds: a check box's state, a list's chosen item, a spinner's value and bounds, the cell it is linked to. Call it when asked how a workbook is started, or before renaming a Sub: a button's OnAction names a procedure and nothing rewrites it. ActiveX controls are listed but have no macro; their code is event procedures in the sheet's module. For a crowded sheet, use sheet with offset and next_offset to read later shapes.
Inputs: file_path (required), sheet, offset, max_results. Returns: object
xlide_list_sheetsList worksheetsARead-onlyIdempotent
Lists the worksheets in an Excel file with their used ranges, whether each is hidden, and the pivot tables on each, the chart sheets, and the workbook's named ranges. Call this before reading cells, so the range you ask for is one that holds data. On .xlsx, .xlsm and .xlam the file also supplies pivot tables, chart sheets and named ranges. For .xlsb and .xls, Windows with Excel is required; that path surveys sheet names, used ranges and visibility only. Unreadable visibility or pivot metadata is marked unknown with hidden_error or pivot_tables_error. A malformed Excel survey is refused rather than returned as a partial sheet list.
Inputs: file_path (required), timeout. Returns: object
xlide_live_read_moduleRead a module from the editorARead-onlyIdempotent
Reads a module's text as the running editor holds it, including edits the user has not saved. This is the one read that can differ from xlide_read_module, and the difference is exactly the user's unsaved work. Use it to see what they are actually working on; use xlide_read_module for what is in the file. surface_only=true reads the modern editor's own copy instead, which exists only for a module the user has open in a tab. start_line and end_line read a slice of long live source; content_token describes the whole live module.
Inputs: module_name (required), pid, project, end_line, +2 more. Returns: object
xlide_live_requestQuery a live sessionARead-onlyIdempotent
Calls one read route on a running xlide_vbide session and returns its JSON. Start with route='agent', which answers with the session's own route table and what each one is for. Allowed routes: agent, agent/examples, agent/routes, analyzer, doctor, engine, model, native, project, projects, state, stats, windows. Routes that drive the editor are deliberately not reachable here.
Inputs: route (required), pid, query. Returns: object
xlide_live_sessionsLive VBE sessionsARead-onlyIdempotent
Lists the running xlide_vbide sessions this machine can reach: one per Office process that has opened the Visual Basic Editor with the add-in loaded. Use it to find out whether the user has a live editor before asking about what is on their screen. Windows only, and the add-in's local API has to be switched on by the user. Each session is probed before it is listed, because a discovery file outlives the process that wrote it.
Inputs: no named parameters. Returns: object
xlide_live_stateLive editor stateARead-onlyIdempotent
What the running Visual Basic Editor is doing right now: the module and project on screen, whether the project is in break mode, whether there are unsaved edits, the procedure the caret is in, and whether the analyzer engine is answering. Use it when the user asks about what they are looking at, or before suggesting an edit to a module they may have unsaved changes in.
Inputs: pid. Returns: object
xlide_manage_commentNotes and commentsADestructiveIdempotent
Lists, writes, answers or removes the comments on a worksheet's cells. Excel has two kinds: a note, the yellow box that shows on hover, and a threaded comment, the conversation on the Review tab with replies and a resolved state. action='list' reads both and changes nothing. 'set' writes a note, replacing one already on the cell, or with kind='thread' starts a conversation; 'reply' and 'resolve' act on a thread; 'remove' takes either kind off the cell. Use a note to explain a cell to whoever reads the workbook next.
Inputs: sheet (required), file_path (required), cell, kind, +7 more. Returns: object
xlide_manage_conditional_formatConditional formattingADestructiveIdempotent
Lists, adds or clears conditional formatting: the rules that colour cells by what is in them. rule='cell_is' with an operator and a value paints cells that compare true; rule='expression' takes a formula written for the top-left cell of the range and applied relatively, the way Excel's 'Use a formula' box works; rule='color_scale' and 'data_bar' are the gradient and in-cell bar. The paint itself is the fill and font arguments, which is what Excel calls a differential format.
Inputs: sheet (required), file_path (required), bold, rule, +10 more. Returns: object
xlide_manage_filterAutofiltersADestructiveIdempotent
Lists, sets, reapplies or clears the autofilter on a worksheet or on an Excel table, and hides the rows it filters out. Excel does not apply a filter when it opens a workbook: it shows the rows as the file marks them, so the rows are worked out here, held to what Excel keeps. action='list' reads the filters and changes nothing. 'set' filters one column and keeps what the others already filter by; call it once per column. Give criteria as VBA's Range.AutoFilter spells Criteria1 and Criteria2: '>=10', '=North', '=east', '=' for blanks, '<>' for anything; or top for the top N items (negative for the bottom), or dynamic for aboveAverage, thisMonth, Q1 and the like. 'reapply' filters again after the data changed; 'clear' removes the filter and shows every row.
Inputs: sheet (required), file_path (required), top, table, +8 more. Returns: object
xlide_manage_formCreate, rename or delete a formADestructiveIdempotent
Creates a UserForm, or an Access form or report, and saves the file. A form is a designer storage and a code module of the same name, and this writes both, which is why it exists rather than xlide_write_module. Renaming and deleting work on Access designs, where both halves move together; for a UserForm they are refused, because nothing here can move the designer storage and doing half of it loses the form. Add controls afterwards with xlide_edit_form, and write its event procedures with xlide_write_module.
Inputs: action (required), file_path (required), form_name (required), width, +6 more. Returns: object
xlide_manage_hyperlinkHyperlinksADestructiveIdempotent
Lists, adds or removes hyperlinks on a worksheet. A link either goes out to a target, which is a URL or a file path, or inside the workbook to a location such as 'Summary!A1'. Pass one or the other. The cell's displayed text is separate from the link and is left alone unless you pass display.
Inputs: sheet (required), file_path (required), action, offset, +6 more. Returns: object
xlide_manage_nameDefined namesADestructiveIdempotent
Lists, adds or removes a workbook's defined names. A defined name is what lets a formula say TaxRate rather than Config!$B$7, and VBA reads them too, so removing one can break code as well as formulas. action='list' changes nothing. For a range, qualify refers_to with its sheet and use absolute addresses to avoid following the active sheet or moving with a copied formula, for example Data!$A$1:$A$50.
Inputs: file_path (required), name, scope, action, +3 more. Returns: object
xlide_manage_referenceAdd or remove a project referenceADestructiveIdempotent
Adds or removes a type library reference in a VBA project and saves the file. Use it when xlide_analyze reports missing-library-reference, or when code needs early binding, as Dim d As Scripting.Dictionary does. Name the library: Excel, Word, PowerPoint and Access work anywhere, and on Windows any library the VBA editor's References dialog lists resolves by its description (Microsoft Scripting Runtime) or by the name code writes (Scripting), taking its GUID, version and path from this machine's registry. A name that matches several libraries is refused with the candidates. Off Windows, pass guid and version. Adding the host's own library, or removing Microsoft Forms while a UserForm exists, is refused: the first is implicit and the second stops the project compiling.
Inputs: action (required), library (required), file_path (required), guid, +3 more. Returns: object
xlide_manage_rows_columnsInsert, delete or size rows and columnsADestructiveIdempotent
Inserts, deletes, resizes, hides, shows, groups or ungroups whole rows or columns. Inserting and deleting move every reference in the workbook with them: a formula pointing below an inserted row follows it, and one pointing into deleted cells becomes #REF!, exactly as Excel does it. Deleting has no undo, so ask the user first. Widths are in characters and heights in points, which is what Excel's own dialogs use. Works on .xlsx, .xlsm and .xlam.
Inputs: first (required), sheet (required), which (required), action (required), +4 more. Returns: object
xlide_manage_shapeAdd or remove a shape or buttonADestructiveIdempotent
Adds a Forms control, an AutoShape, a text box, a line or a picture to a worksheet, or removes one, and saves the workbook. The usual case is a button that runs a macro: kind='button', a caption in text, and the procedure in macro as Proc or Module.Proc, written first. Place it with cell, its top-left cell, or with left and top in points; width and height are points, with a size to start from when left at 0. Check boxes, option buttons, lists and drop-downs take linked_cell, and lists and drop-downs list_range. A Forms control lives in four parts that have to agree, and they are written and removed together. Removing a shape that runs a macro leaves the macro; removing a chart is not offered. Excel workbooks only; .xlsx, .xlsm and .xlam.
Inputs: sheet (required), action (required), file_path (required), shape_name (required), +12 more. Returns: object
xlide_manage_sheetAdd, remove or change a worksheetADestructiveIdempotent
Adds, removes, renames, moves, hides, shows, protects or unprotects a worksheet. Renaming rewrites the formulas and defined names that referred to the old name, so nothing breaks. Removing a sheet takes its cells, tables and everything on it, and formulas elsewhere that pointed at it become #REF!, which has no undo: ask the user first. Protecting a sheet stops editing in Excel; it is not a security boundary and the password is trivially recovered. Works on .xlsx, .xlsm, .xlam.
Inputs: action (required), file_path (required), index, sheet, +3 more. Returns: object
xlide_manage_tableExcel tablesADestructiveIdempotent
Lists, adds or removes Excel tables, the ListObjects that Ctrl+T creates. A table names a block so formulas can say Sales[Amount] instead of an address that breaks when rows move, and it is what a Power Query load writes into. action='list' reads them and changes nothing. Adding one takes the column names from the header row of the range you give. Removing one leaves the cells and takes the table, so structured references to it break.
Inputs: file_path (required), sheet, action, offset, +4 more. Returns: object
xlide_manage_validationData validationADestructiveIdempotent
Lists, adds or clears data validation: what a cell will accept, and the dropdown it shows. kind='list' with formula1 as a comma-separated set of values gives a dropdown; kind='list' with a range reference gives one driven by cells. The other kinds take an operator and one or two formulas, which may be literals or references. Validation stops typing in Excel, not writing through this server, and Excel does not re-check cells that already held a value.
Inputs: sheet (required), file_path (required), kind, action, +8 more. Returns: object
xlide_open_in_appOpen in OfficeA
Opens a file in its Office application on the user's screen, for them to see or work in: after a change they should look at, or to put back a copy xlide_close_in_app closed. Already open, it is brought forward instead. read_only opens a copy that cannot be saved over the file, and new_instance a separate Excel or Word the user's other files are not in. bring_to_front=false reopens it behind whatever the user is doing. Macros follow the user's Trust Center settings, as for a file they open themselves. Windows only.
Inputs: file_path (required), read_only, new_instance, bring_to_front. Returns: object
xlide_page_setupHow a sheet printsARead-onlyIdempotent
Reads how a worksheet is set up to print: orientation, paper size, margins, the print area, the rows or columns repeated on every page, whether it is scaled to fit, and the header and footer. Call it when asked why a sheet prints the way it does, or before changing a layout somebody set up deliberately.
Inputs: sheet (required), file_path (required). Returns: object
xlide_project_infoProject summaryARead-onlyIdempotent
A summary of one Office file in a single call: its VBA modules with kinds and line counts, its UserForms, its Power Query queries, its worksheets with used ranges and named ranges, and whether the VBA project is password-protected or digitally signed. has_vba_project is false for a macro-enabled file saved before its first macro, which is normal: the first xlide_write_module gives it a project. Call this once per file before working on it. Each module carries a content_token for a guarded write. For .xlsb and .xls sheet details, call xlide_list_sheets on Windows with Excel. An unreadable form or query summary is reported as unknown rather than empty.
Inputs: file_path (required). Returns: object
xlide_read_access_queryRead Access saved queryARead-onlyIdempotent
Reads the SQL of one saved query in an Access database. Use it after xlide_access_catalog when a query's SQL was previewed. offset and max_chars read long SQL in character slices; next_offset points to the next slice. content_token describes the whole SQL, so compare it across pages if the database may have changed. Access files only.
Inputs: file_path (required), query_name (required), offset, max_chars. Returns: object
xlide_read_cellsRead cellsARead-onlyIdempotent
Reads a range of cells from a worksheet and returns a grid of values, formulas, both, or the text each cell shows under its number format. On .xlsx, .xlsm and .xlam, values are what Excel last calculated and stored; calculate=true works formulas out in memory with pyOfficeEditor's engine and names cells it could not work out. A failed formatted or rich-text read names the cell and refuses rather than returning an empty value. On .xlsb and .xls, Windows with Excel is required and only calculated values are available, not formulas or formatted text. A partial grid from Excel is refused. At most 20,000 cells per call.
Inputs: sheet (required), file_path (required), cell_range (required), include, +2 more. Returns: object
xlide_read_formRead form designARead-onlyIdempotent
Reads one form's design: every control with its name, type, the container it sits in, and the properties the developer set. Properties left at their default are not stored and so are not listed. A property read failure appears as _read_error, not an empty property set; unreadable sections have sections_error. Use offset and next_offset to read large forms in pages. Use it to understand a form's layout, or to see which control an event procedure belongs to.
Inputs: file_path (required), form_name (required), offset, max_controls, +1 more. Returns: object
xlide_read_moduleRead moduleARead-onlyIdempotent
The canonical way to read VBA. Returns a module's source as the VBA editor shows it, with the attribute header stripped, plus a content_token. Pass that token back as expected_content_token when you write, and the write is refused if anything changed the module in between. start_line and end_line read a slice of a long module; both are 1-based and inclusive. line_ranges reads several slices in one call, with each pair [first, last] using body line numbers.
Inputs: file_path (required), module_name (required), end_line, start_line, +2 more. Returns: object
xlide_read_queryRead Power QueryARead-onlyIdempotent
Reads one query's M formula, with its description, group, load target and refresh settings. The formula is the let ... in expression as the Advanced Editor shows it. start_line and end_line read a slice of a long formula; the content_token always describes the whole query. If applied steps cannot be read, steps is null and steps_error gives the reason; the M formula remains available.
Inputs: file_path (required), query_name (required), end_line, start_line. Returns: object
xlide_remove_duplicatesRemove duplicate worksheet rowsADestructiveIdempotent
Removes later rows with the same values in the chosen columns, keeping the first row of each set, and saves the workbook. A range inside a table acts on the table and shrinks it. An empty columns list compares every column. This deletes data and cannot be undone in the file: ask the user before calling it. Works on .xlsx, .xlsm and .xlam.
Inputs: sheet (required), file_path (required), cell_range (required), header, +1 more. Returns: object
xlide_rename_moduleRename moduleADestructiveIdempotent
Renames a VBA module everywhere its name is stored, and saves the file. Calls to the module's procedures elsewhere in the project are not rewritten; search for the old name first with xlide_search_modules. Document modules such as ThisWorkbook and Sheet1 cannot be renamed, because the host owns them.
Inputs: new_name (required), file_path (required), module_name (required), allow_protected, +1 more. Returns: object
xlide_rulesAnalyzer rulesARead-onlyIdempotent
The analyzer's rule catalogue: every diagnostic code with its title, default severity, category, whether it mirrors a VBA compile failure, and the MS-VBAL section it enforces. Use it to explain a code to the user, or to decide whether a finding is a compile error or a judgement call.
Inputs: code, search. Returns: object
xlide_run_macroRun a macroADestructive
Runs a procedure that already exists in an Office file, in an application this server starts and owns, under a deadline. Windows only, with the application installed. The document opens read-only unless read_only=false, and closes without saving unless save=true. Returns the procedure's return value, anything it logged, and, on a VBA error, the error number and message. The failing line and call stack come from instrumentation applied to injected source, so a procedure already in the document does not carry them; run the same code through xlide_run_vba when you need them. A run that exceeds its timeout reports 'timeout' and the application is terminated. Ask the user before running a macro that changes data.
Inputs: file_path (required), procedure (required), args, save, +2 more. Returns: object
xlide_run_testsRun VBA testsA
Runs the VBA tests in an Office file: every zero-argument procedure whose name starts with Test. Windows only, with the application installed. Each test is run on its own, so one that hangs is reported as a timeout and the rest still run. Returns pass or fail per test with the assertion message, failing line, call stack and any logged output. Use PyVbaAssert and PyVbaAssertEqual in the tests; the harness supplies them.
Inputs: file_path (required), timeout, module_name. Returns: object
xlide_run_vbaRun VBA sourceADestructive
Injects VBA source into a document and calls one procedure from it, under a deadline. Windows only. Use it to check what a piece of code actually does before writing it into a file, or to read something out of a document that no existing macro exposes. With no file_path it runs in a new empty document. Errors come back as data with the failing line and call stack, never as a dialog. Call PyVbaLog "text" from the code to return output; Debug.Print and MsgBox do not work under automation.
Inputs: source (required), args, host, timeout, +3 more. Returns: object
xlide_search_modulesSearch VBAARead-onlyIdempotent
Searches every module's source in an Office file and returns each match with its module, line number and the line itself. Use it to find where a name is declared or used before changing it. content_tokens maps returned module names to tokens for guarded xlide_edit_module calls without a separate read. Use offset and next_offset to page through broad searches; total_match_count counts all matches. Plain text by default; set is_regex for a Python regular expression.
Inputs: query (required), file_path (required), offset, is_regex, +2 more. Returns: object
xlide_set_shape_macroPoint a shape at a macroADestructiveIdempotent
Changes which macro an existing shape or button runs when clicked, and saves the workbook. An empty macro clears the link. Use it after writing a Sub, so a button actually calls it, and after renaming one, because nothing rewrites an OnAction. Give the procedure as Proc or Module.Proc; it must already exist in the project, so write it first. To add a button with its macro, or to remove one, use xlide_manage_shape.
Inputs: macro (required), sheet (required), file_path (required), shape_name (required). Returns: object
xlide_sort_rowsSort worksheet rowsADestructiveIdempotent
Sorts a range, a table's data rows, or a sheet autofilter's data rows, and saves the workbook. Keys are evaluated in order; each names a column letter for a range or filter, or a header name for a table. A range can keep its first row as a header. Hidden rows keep their places. Formulas, formatting, notes and links move with their rows. This changes existing data order and has no undo in the file: ask the user before calling it. Works on .xlsx, .xlsm and .xlam.
Inputs: keys (required), sheet (required), file_path (required), header, +4 more. Returns: object
xlide_update_shapeUpdate a shape or form controlADestructiveIdempotent
Moves, resizes, renames or changes an existing shape's text, alt text or visibility without replacing it. A Forms control can also change its linked cell or list range. Coordinates and sizes are in points; omit any field to leave it unchanged, and pass an empty text or link to clear it. ActiveX, embedded objects and groups cannot be updated. Works on .xlsx, .xlsm and .xlam.
Inputs: sheet (required), file_path (required), shape_name (required), top, +9 more. Returns: object
xlide_validate_projectValidate VBA projectARead-onlyIdempotent
Checks a file's VBA project for structural problems: records that disagree with each other, a module the directory names but the container does not hold, and the like. This is about the container, not about the code; use xlide_analyze for the code. Worth calling before risky work on an old or repaired file. Use offset and next_offset to read later problems from a damaged file.
Inputs: file_path (required), offset, max_results. Returns: object
xlide_write_cellsWrite cellsADestructiveIdempotent
Writes a rectangular block of values and formulas into a worksheet, starting at one cell, and saves the file. Each row of data is a row of the sheet. A string starting with '=' is written as a formula, as you would type it into Excel 365 with no _xlfn prefixes; anything else is a value. A cell given as {"rich_text": [{"text": "Total ", "bold": true}, {"text": "42"}]} is text in more than one font. A value written over a formula removes that formula, which is what typing into the cell does. On .xlsx, .xlsm and .xlam, only the touched worksheet rows are rewritten; their cached formula results remain stale until Excel opens the file or xlide_read_cells calculates them in memory. Writing .xlsb cells needs Windows with Excel, which recalculates and saves the workbook. Writing .xls cells is not offered. Cells that hold data are refused until allow_overwrite=true; ask the user first.
Inputs: data (required), sheet (required), file_path (required), start_cell (required), +2 more. Returns: object
xlide_write_moduleWrite moduleADestructiveIdempotent
The canonical way to change VBA. Writes a module's source into the Office file and saves it. It replaces the module's whole source, so send all of it; send the body only, because the attribute header is managed for you. A module that does not exist is created: standard by default, or a class with kind='class'. Pass expected_content_token from your read and the write is refused if the module changed since. The result carries a diff of what the file now holds, read back after saving, which is what to show the user when they ask what changed. After writing, call xlide_analyze and treat any error as a build failure. Identical source is reported without saving. Ask the user first when the project is protected or signed.
Inputs: source (required), file_path (required), module_name (required), kind, +4 more. Returns: object
xlide_write_queryWrite Power QueryADestructiveIdempotent
Changes a workbook's Power Query and saves it. action='set' replaces a query's M formula, creating it if it does not exist; 'rename' renames it and rewrites the queries that reference it by name; 'remove' deletes it and everything that loaded it onto a sheet, which has no undo, so ask the user first. 'load' puts a query's result on a worksheet and 'unload' takes it back off. Loading needs the column names, because writing the connection means naming the columns and knowing them means running the query, which nothing here does; Excel settles them against the real result on the first refresh. A query already loaded keeps its rows until Excel refreshes it. Pass expected_content_token from xlide_read_query to refuse a change if that query changed meanwhile.
Inputs: action (required), file_path (required), query_name (required), cell, +8 more. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 65 tools
The descriptions are unusually thorough and generally draw clear boundaries: e.g., xlide_read_module vs xlide_live_read_module, xlide_analyze vs xlide_analyze_source vs xlide_validate_project, and xlide_manage_shape vs xlide_update_shape vs xlide_set_shape_macro are carefully distinguished. Still, with 65 tools there are many closely related families (module writes, form management, shape/chart handling, Excel cell operations) where an agent must read carefully to avoid misselection.
Every tool uses the same xlide_ prefix and snake_case, which makes the set predictable overall. The pattern is not uniformly verb_noun: several tools are noun- or state-oriented (xlide_doctor, xlide_rules, xlide_page_setup, xlide_is_open, xlide_live_state), but these are minor deviations rather than convention mixing.
At 65 tools this is very heavy for an agent's context, well beyond the 3-15 well-scoped range. The server covers an unusually broad domain (Excel, Word, PowerPoint, Access, VB6, VBA editing, live VBE, Power Query), so many tools are justified, but the surface is still too large and contains some redundancy (e.g., xlide_project_info vs xlide_list_modules, multiple analysis/compile tools).
VBA lifecycle coverage is excellent: discovery, project creation, module read/write/edit/rename/delete, analysis, compilation, references, forms, export/import, testing, live editor sessions, and git diffing are all present. There are some Excel dead ends (page setup is read-only, charts can be added but not updated or deleted, pivot table creation/modification is absent), but these are relatively minor for the stated VBA-focused purpose.
Maintenance
Related MCP Connectors
Read, analyze, and safely edit Microsoft Project MPP files.
Excel analytics: inspect, query (JSON rows), charts, and JSON-to-xlsx workbook writing.
Create Word .docx files from sections or markdown, fill templates, and read text from a .docx.
Real .docx and .xlsx files from structured data, with automatic Hebrew/Arabic RTL.
Related MCP Servers
- AlicenseDqualityDmaintenanceEnables reading, writing, editing, and converting Office documents (ODT, DOCX, ODS, XLSX, PDF, etc.) using MCP tools, with no external dependencies.1121 npmMIT
- FlicenseAqualityCmaintenanceMCP server for Microsoft Office file operations. Read, write, and create Excel, Word, and PowerPoint files directly from your local filesystem.12-
- FlicenseNot gradedqualityBmaintenanceAutomates Windows Office applications (WPS Office and Outlook) via COM automation, enabling AI assistants to perform spreadsheet, document, and email tasks.-
- AlicenseAqualityDmaintenanceMCP server for reading, writing, editing, formatting, and exporting Microsoft Office documents (Word, Excel, PowerPoint) via stdio JSON-RPC, with 47 tools and cross-platform support.473MIT