# XLIDE (pypi · xlide-mcp)

Read, write, analyze, test and diff the VBA in Office files, and the document around it

- Trust score: 54/100 (low)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-20

## Components

- pypi · `xlide-mcp`: 54/100 (this document), [markdown](https://verifymcp.io/servers/williamsmithedward-xlide-excel-office-vba-mcp/xlide-mcp.md), [page](https://verifymcp.io/servers/williamsmithedward-xlide-excel-office-vba-mcp/xlide-mcp)

## Channel facts

- Registry: `pypi`
- Package: `xlide-mcp`
- Version: `1.0.3`
- Transport: `stdio`

## Trust breakdown

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

Scored 2026-09-20.

- **Supply Chain Security**: 50/100
  - Malware scan not yet available for this package.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs setuptools.build_meta at install time, a recognised native-build step with no shell scripting around it.
  - 1 of 33 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 32/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - License check failed: no license is declared.
  - Actively maintained (last published 0 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 82/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 9563 tokens (~187/item across 51 items; 49 tools + 2 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 51 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

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

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

### Claude

```bash
claude mcp add williamsmithedward-xlide-excel-office-vba-mcp -- uvx xlide-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "williamsmithedward-xlide-excel-office-vba-mcp": {
      "command": "uvx",
      "args": [
        "xlide-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "williamsmithedward-xlide-excel-office-vba-mcp": {
      "command": "uvx",
      "args": [
        "xlide-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add williamsmithedward-xlide-excel-office-vba-mcp -- uvx xlide-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "williamsmithedward-xlide-excel-office-vba-mcp": {
      "type": "local",
      "command": [
        "uvx",
        "xlide-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add williamsmithedward-xlide-excel-office-vba-mcp --command uvx --arg xlide-mcp
```

### Hermes

```yaml
mcp_servers:
  williamsmithedward-xlide-excel-office-vba-mcp:
    command: "uvx"
    args: ["xlide-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "williamsmithedward-xlide-excel-office-vba-mcp": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "xlide-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add williamsmithedward-xlide-excel-office-vba-mcp -t stdio -c uvx -a xlide-mcp
```

### Other

```json
{
  "mcpServers": {
    "williamsmithedward-xlide-excel-office-vba-mcp": {
      "command": "uvx",
      "args": [
        "xlide-mcp"
      ]
    }
  }
}
```

## Changelog

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

### 2026-09-20 (score 54)

First indexed and scored.

## MCP tools (49)

### `xlide_list_projects` (~168 tokens)

List Office files

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.

Input parameters:

- `subfolder` (string): Limit the search to this folder. Empty searches every workspace root.

### `xlide_project_info` (~95 tokens)

Project summary

Everything about 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. Call this once per file before working on it. Each module carries a content_token for a guarded write.

Input parameters:

- `file_path` (string, required): Absolute path to the Office file.

### `xlide_validate_project` (~89 tokens)

Validate VBA project

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.

Input parameters:

- `file_path` (string, required): Absolute path to the Office file.

### `xlide_create_project` (~107 tokens)

Create Office file

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 an existing file.

Input parameters:

- `file_path` (string, required): Absolute path to create. The extension picks the format.

### `xlide_doctor` (~67 tokens)

What this machine can do

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.

### `xlide_list_modules` (~89 tokens)

List modules

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.

Input parameters:

- `file_path` (string, required): Absolute path to the Office file.

### `xlide_read_module` (~196 tokens)

Read module

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.

Input parameters:

- `end_line` (integer): Last line to return. 0 means the end.
- `file_path` (string, required): Absolute path to the Office file.
- `include_header` (boolean): Include the Attribute VB_* header. Off by default: the header is managed for you on write, and editing it by hand is how a module loses its binding to a sheet or a form.
- `module_name` (string, required): Module name, matched without case.
- `start_line` (integer): First line to return. 0 means the start.

### `xlide_list_procedures` (~80 tokens)

List procedures

Lists the Sub, Function and Property procedures in one module, with each one's kind, scope, line number and signature. Use it to find where to change something without reading a long module in full.

Input parameters:

- `file_path` (string, required): Absolute path to the Office file.
- `module_name` (string, required): Module name, matched without case.

### `xlide_search_modules` (~136 tokens)

Search VBA

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. Plain text by default; set is_regex for a Python regular expression.

Input parameters:

- `file_path` (string, required): Absolute path to the Office file.
- `is_regex` (boolean): Treat query as a regular expression.
- `match_case` (boolean): Match case. Off by default, because VBA itself ignores case.
- `max_results` (integer): Stop after this many matches.
- `query` (string, required): Text or pattern to find.

### `xlide_write_module` (~317 tokens)

Write module

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. Ask the user first when the project is protected or signed.

Input parameters:

- `allow_invalidate_signature` (boolean): Write to a digitally signed project, dropping the signature. Ask the user first.
- `allow_protected` (boolean): Write to a password-protected project. Ask the user first.
- `expected_content_token` (string): The content_token from your read. Leave empty only when creating a module.
- `file_path` (string, required): Absolute path to the Office file.
- `include_diff` (boolean): Include a unified diff of what changed. Off in a loop that writes many modules and reads none of them back.
- `kind` (string): Kind for a module being created: 'standard' or 'class'.
- `module_name` (string, required): Module to write, or to create.
- `source` (string, required): The module's complete VBA source.

### `xlide_rename_module` (~139 tokens)

Rename module

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.

Input parameters:

- `allow_invalidate_signature` (boolean): Ask the user first.
- `allow_protected` (boolean): Ask the user first.
- `file_path` (string, required): Absolute path to the Office file.
- `module_name` (string, required): Module to rename.
- `new_name` (string, required): New name. A valid VBA identifier.

### `xlide_delete_module` (~146 tokens)

Delete module

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.

Input parameters:

- `allow_invalidate_signature` (boolean): Ask the user first.
- `allow_protected` (boolean): Ask the user first.
- `expected_content_token` (string): The content_token from your read, so a module that changed since is not deleted on the strength of a stale look at it.
- `file_path` (string, required): Absolute path to the Office file.
- `module_name` (string, required): Module to delete.

### `xlide_analyze` (~197 tokens)

Analyze VBA

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.

Input parameters:

- `file_path` (string, required): Absolute path to the Office file.
- `min_severity` (string): Lowest severity to report: 'error', 'warning' or 'information'.
- `module_name` (string): Report only this module's problems. The whole project is still analyzed, so cross-module references still resolve.

### `xlide_analyze_source` (~210 tokens)

Analyze VBA source

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.

Input parameters:

- `file_path` (string): An existing Office file this module belongs to. Its other modules are analyzed alongside, so calls into them resolve. Overrides host.
- `host` (string): 'excel', 'word', 'powerpoint' or 'access'. Empty checks the language alone, with no host object model.
- `kind` (string): 'standard', 'class', 'document' or 'userform'.
- `module_name` (string): Name to report problems against.
- `source` (string, required): The VBA source to check.

### `xlide_rules` (~100 tokens)

Analyzer rules

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.

Input parameters:

- `code` (string): One rule code. Empty lists them all.
- `search` (string): Only rules whose code or title contains this.

### `xlide_list_references` (~108 tokens)

List project references

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.

Input parameters:

- `file_path` (string, required): Absolute path to the Office file.

### `xlide_access_catalog` (~150 tokens)

Access tables and queries

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. Access files only.

Input parameters:

- `file_path` (string, required): Absolute path to the Access database.
- `include` (string): 'tables', 'queries', 'relationships' or 'all'.
- `include_system` (boolean): Include the MSys tables and relationships Access keeps its own objects in. Off by default: every database has them, and listing them buries the few that are about the user's data.

### `xlide_list_forms` (~80 tokens)

List forms

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.

Input parameters:

- `file_path` (string, required): Absolute path to the Office file.

### `xlide_read_form` (~119 tokens)

Read form design

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. Use it to understand a form's layout, or to see which control an event procedure belongs to.

Input parameters:

- `file_path` (string, required): Absolute path to the Office file.
- `form_name` (string, required): Form name, matched without case.
- `include_properties` (boolean): Include each control's set properties. Off gives just the tree.

### `xlide_manage_form` (~273 tokens)

Create, rename or delete a form

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.

Input parameters:

- `action` (string, required): 'create', 'rename' or 'delete'.
- `allow_invalidate_signature` (boolean): Ask the user first.
- `allow_protected` (boolean): Ask the user first.
- `caption` (string): For create: the caption it opens with.
- `design` (string): For create in Access: 'form' or 'report'. Elsewhere, a form.
- `file_path` (string, required): Absolute path to the Office file.
- `form_name` (string, required): The form or report to act on.
- `height` (number): For create.
- `new_name` (string): For rename: the new name.
- `width` (number): For create. Points for a UserForm, twips for Access.

### `xlide_edit_form` (~410 tokens)

Edit form design

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.

Input parameters:

- `action` (string, required): 'add_control', 'remove_control' or 'set_property'.
- `allow_invalidate_signature` (boolean): Ask the user first.
- `allow_protected` (boolean): Ask the user first.
- `caption` (string): For add_control on an Access design: the control's caption.
- `container` (string): For add_control: the Frame or page to put it in.
- `control_name` (string, required): The control to add, remove or change.
- `control_type` (string): For add_control: Label, TextBox, CommandButton, CheckBox, OptionButton, ComboBox, ListBox, Frame, MultiPage, Image, SpinButton and the rest.
- `file_path` (string, required): Absolute path to the Office file.
- `form_name` (string, required): Form to change.
- `height` (number): 0 uses the type's default.
- `left` (number): For add_control.
- `property_name` (string): For set_property: the property to set.
- `property_value`: For set_property. null clears it to the default.
- `section` (string): For add_control on an Access design: the band to put it in, such as Detail, PageHeaderSection or PageFooterSection. xlide_list_forms names the ones a design has. Ignored for a UserForm, which has no…
- `top` (number): For add_control.
- `width` (number): 0 uses the type's default.

### `xlide_list_queries` (~90 tokens)

List Power Query

Lists the Power Query queries in an Excel workbook: name, group, description, where each loads, and its applied step names. 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.

Input parameters:

- `file_path` (string, required): Absolute path to the Excel workbook.

### `xlide_read_query` (~73 tokens)

Read Power Query

Reads one query's M formula, with its description, group, load target and refresh settings. The formula is the whole let ... in expression as the Advanced Editor shows it.

Input parameters:

- `file_path` (string, required): Absolute path to the Excel workbook.
- `query_name` (string, required): Query name, matched without case.

### `xlide_write_query` (~382 tokens)

Write Power Query

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.

Input parameters:

- `action` (string, required): 'set', 'rename', 'remove', 'load' or 'unload'.
- `cell` (string): For load: the table's top-left cell.
- `columns`: For load: the column names the query returns, in order. Required, because the connection has to name them and nothing here runs the query to find out. Excel corrects them on the first refresh.
- `description` (string): For set: the query's description.
- `file_path` (string, required): Absolute path to the Excel workbook.
- `formula` (string): For set: the whole M expression, such as 'let Source = 1 in Source'.
- `group` (string): For set on a new query: the folder in the Queries pane.
- `include_diff` (boolean): For set: include a unified diff of the M that changed. Nothing to diff for the other actions.
- `new_name` (string): For rename: the new name.
- `query_name` (string, required): The query to change.
- `sheet` (string): For load: the worksheet. Empty uses the first.

### `xlide_list_sheets` (~114 tokens)

List worksheets

Lists the worksheets in an Excel file with their used ranges, whether each is hidden, and the workbook's named ranges. Call this before reading cells, so the range you ask for is one that holds data. Works on .xlsx, .xlsm and .xlam; a .xlsb or .xls keeps its grid in a binary format this server does not read.

Input parameters:

- `file_path` (string, required): Absolute path to the Excel file.
- `timeout` (number): Seconds allowed if Excel has to answer.

### `xlide_read_cells` (~167 tokens)

Read cells

Reads a range of cells from a worksheet and returns a grid of values, formulas, or both. Values are what Excel last calculated and stored, so a formula whose inputs changed outside Excel shows its old result. Ask for formulas when you need to understand what a sheet computes, and values when you need what it currently shows. At most 20,000 cells per call.

Input parameters:

- `cell_range` (string, required): A1-style range, such as A1:D50, or a single cell.
- `file_path` (string, required): Absolute path to the Excel file.
- `include` (string): 'values', 'formulas' or 'both'.
- `sheet` (string, required): Worksheet name, matched without case.
- `timeout` (number): Seconds allowed if Excel has to answer.

### `xlide_list_shapes` (~138 tokens)

List shapes and buttons

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 and, where it has one, the macro a click runs. 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.

Input parameters:

- `file_path` (string, required): Absolute path to the Excel file.
- `sheet` (string): One worksheet. Empty lists every sheet's shapes.

### `xlide_set_shape_macro` (~192 tokens)

Point a shape at a macro

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. This changes an existing shape only: adding or deleting one is not offered, because a form control lives in four parts that have to agree and a wrong one produces a workbook Excel repairs on open.

Input parameters:

- `file_path` (string, required): Absolute path to the Excel file.
- `macro` (string, required): The procedure to run, as Proc or Module.Proc. Empty clears the link.
- `shape_name` (string, required): Shape name, as xlide_list_shapes reports it.
- `sheet` (string, required): Worksheet the shape is on.

### `xlide_write_cells` (~233 tokens)

Write cells

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 value written over a formula removes that formula, which is what typing into the cell does. Only the rows you touch are rewritten, so charts, styles, pivot caches and the VBA project are untouched. Ask the user before overwriting cells that hold data. Nothing recalculates until Excel next opens the workbook.

Input parameters:

- `data` (array, required): Rows of cell values. Numbers, strings, booleans, null for empty, and strings starting with '=' for formulas.
- `file_path` (string, required): Absolute path to the Excel file.
- `sheet` (string, required): Worksheet name, matched without case.
- `start_cell` (string, required): Top-left cell of the block, such as B2.
- `timeout` (number): Seconds allowed if Excel has to do the write.

### `xlide_format_cells` (~456 tokens)

Format cells

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. Works on .xlsx, .xlsm and .xlam.

Input parameters:

- `bold`: Bold on or off.
- `border_color` (string): Border colour as hex. Defaults to automatic.
- `border_style` (string): Border on all four sides: thin, medium, thick, double, dotted, dashed, hair, or none to remove.
- `cell_range` (string, required): A1-style range, such as A1:D1, or a single cell.
- `file_path` (string, required): Absolute path to the Excel file.
- `fill_color` (string): Solid background colour as hex. 'none' clears the fill back to no fill.
- `font_color` (string): Text colour as hex, such as 'FF0000'.
- `font_name` (string): Typeface, such as 'Calibri'.
- `font_size` (number): Points. 0 leaves it alone.
- `horizontal` (string): left, center, right, fill, justify or general.
- `italic`: Italic on or off.
- `merge` (string): 'merge' joins the range into one cell, keeping only the top-left value. 'unmerge' splits it back. Empty leaves merging alone.
- `number_format` (string): Excel format code, such as '#,##0.00', '0%' or 'yyyy-mm-dd'.
- `sheet` (string, required): Worksheet name, matched without case.
- `strike`: Strikethrough on or off.
- `underline`: Single underline on or off.
- `vertical` (string): top, center, bottom, justify or distributed.
- `wrap_text`: Wrap text in the cell.

### `xlide_manage_sheet` (~287 tokens)

Add, remove or change a worksheet

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.

Input parameters:

- `action` (string, required): add, remove, rename, move, hide, show, protect or unprotect.
- `file_path` (string, required): Absolute path to the Excel file.
- `index` (integer): For add and move: 0-based position. -1 means the end.
- `new_name` (string): For rename: the new name.
- `password` (string): For protect: an optional password. Excel's sheet password is obfuscation, not encryption, so do not use one the user relies on elsewhere.
- `sheet` (string): The sheet to act on. For add, the name to give the new one.
- `very_hidden` (boolean): For hide: hide it so that Excel's own Unhide dialog does not list it. Only the VBA editor can bring it back.

### `xlide_manage_rows_columns` (~251 tokens)

Insert, delete or size rows and columns

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.

Input parameters:

- `action` (string, required): insert, delete, resize, hide, show, group or ungroup.
- `collapsed` (boolean): For group: start the new group collapsed.
- `count` (integer): How many, counting from first.
- `file_path` (string, required): Absolute path to the Excel file.
- `first` (integer, required): First row or column, 1-based. Column A is 1.
- `sheet` (string, required): Worksheet name, matched without case.
- `size` (number): For resize: column width in characters, or row height in points. -1 restores the sheet default.
- `which` (string, required): 'rows' or 'columns'.

### `xlide_manage_table` (~203 tokens)

Excel tables

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.

Input parameters:

- `action` (string): list, add or remove.
- `cell_range` (string): For add: the range including its header row, such as A1:D20.
- `file_path` (string, required): Absolute path to the Excel file.
- `sheet` (string): Worksheet. Empty lists every sheet's tables.
- `table_name` (string): For add and remove: the table's name.
- `totals_row` (boolean): For add: give the table a totals row.

### `xlide_manage_name` (~185 tokens)

Defined names

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 renaming or removing one can break code as well as formulas. action='list' changes nothing. refers_to is a formula, so it needs its sheet and its dollar signs: Data!$A$1:$A$50.

Input parameters:

- `action` (string): list, add or remove.
- `file_path` (string, required): Absolute path to the Excel file.
- `name` (string): For add and remove: the defined name.
- `refers_to` (string): For add: what it points at, such as Data!$A$1:$A$50.
- `scope` (string): A sheet name to scope it to that sheet. Empty means the workbook.

### `xlide_manage_validation` (~300 tokens)

Data validation

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.

Input parameters:

- `action` (string): list, add or clear.
- `allow_blank` (boolean): Let the cell be left empty.
- `cell_range` (string): For add and clear: the range. Empty clears the whole sheet.
- `error_message` (string): What Excel says when the entry is refused.
- `file_path` (string, required): Absolute path to the Excel file.
- `formula1` (string): The allowed values. For kind='list', either 'Red,Green,Blue' or a range like $H$1:$H$9. For the others, the bound, such as 0.
- `formula2` (string): The second bound, for between and notBetween.
- `kind` (string): whole, decimal, list, date, time, textLength or custom.
- `operator` (string): between, greaterThan, lessThan and so on.
- `sheet` (string, required): Worksheet name, matched without case.

### `xlide_manage_conditional_format` (~303 tokens)

Conditional formatting

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.

Input parameters:

- `action` (string): list, add or clear.
- `bold`: Make matching cells bold.
- `cell_range` (string): For add and clear: the range. Empty clears the whole sheet.
- `file_path` (string, required): Absolute path to the Excel file.
- `fill_color` (string): Fill to paint matching cells, as hex.
- `font_color` (string): Text colour for matching cells, as hex.
- `formula` (string): For expression: a formula for the range's top-left cell.
- `operator` (string): For cell_is: greaterThan, between, etc.
- `other_value` (string): For cell_is with between: the second value.
- `rule` (string): cell_is, expression, color_scale or data_bar.
- `sheet` (string, required): Worksheet name, matched without case.
- `value` (string): For cell_is: the value compared against.

### `xlide_manage_hyperlink` (~203 tokens)

Hyperlinks

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.

Input parameters:

- `action` (string): list, add or remove.
- `cell_range` (string): For add and remove: the cell or range.
- `display` (string): For add: text to put in the cell.
- `file_path` (string, required): Absolute path to the Excel file.
- `location` (string): For add: a place in this workbook, like Summary!A1.
- `sheet` (string, required): Worksheet name, matched without case.
- `target` (string): For add: a URL or file path to open.
- `tooltip` (string): For add: the hover text.

### `xlide_page_setup` (~103 tokens)

How a sheet prints

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.

Input parameters:

- `file_path` (string, required): Absolute path to the Excel file.
- `sheet` (string, required): Worksheet name, matched without case.

### `xlide_export_modules` (~169 tokens)

Export modules to files

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. The exported files are copies: editing one changes nothing inside the Office file until xlide_import_modules runs.

Input parameters:

- `apply` (boolean): Write the files. False previews the plan.
- `delete_stale` (boolean): Delete .bas and .cls files in the folder that match no module. Ask the user first.
- `export_folder` (string): Folder to write into. Empty uses a folder named after the file, beside it.
- `file_path` (string, required): Absolute path to the Office file.

### `xlide_import_modules` (~158 tokens)

Import modules from files

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. After applying, call xlide_analyze.

Input parameters:

- `allow_invalidate_signature` (boolean): Ask the user first.
- `allow_protected` (boolean): Ask the user first.
- `apply` (boolean): Write the modules. False previews the plan.
- `file_path` (string, required): Absolute path to the Office file.
- `source_folder` (string, required): Folder holding the .bas/.cls files.

### `xlide_git_changes` (~196 tokens)

What changed inside the file

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.

Input parameters:

- `file_path` (string, required): Absolute path to the Office file.
- `include_diff` (boolean): Include the unified diff. Off gives just what changed and by how much.
- `revision` (string): Any revision git understands: HEAD, a branch, a tag, a SHA.
- `section` (string): Only this one, named as a module or a query is named. Empty reports every one.

### `xlide_run_macro` (~249 tokens)

Run a macro

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.

Input parameters:

- `args`: Arguments, in order. Scalars only.
- `file_path` (string, required): Absolute path to the Office file.
- `procedure` (string, required): Procedure to call, as 'Proc' or 'Module.Proc'.
- `read_only` (boolean): Open the document read-only. False lets the macro change it.
- `save` (boolean): Save the document after the run. Needs read_only=false.
- `timeout` (number): Seconds before the run is terminated.

### `xlide_run_vba` (~232 tokens)

Run VBA source

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.

Input parameters:

- `args`: Arguments, in order. Scalars only.
- `file_path` (string): Run against this document instead of a new empty one.
- `host` (string): 'excel', 'word', 'powerpoint' or 'access'. Ignored with file_path.
- `procedure` (string): Procedure to call. Empty calls the first one in the source.
- `read_only` (boolean): Open the document read-only.
- `source` (string, required): VBA source to inject.
- `timeout` (number): Seconds before the run is terminated.

### `xlide_run_tests` (~148 tokens)

Run VBA tests

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.

Input parameters:

- `file_path` (string, required): Absolute path to the Office file.
- `module_name` (string): Run only this module's tests. Empty runs every module's.
- `timeout` (number): Seconds allowed for each test.

### `xlide_compile_check` (~130 tokens)

Compile check

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.

Input parameters:

- `file_path` (string, required): Absolute path to the Office file.
- `timeout` (number): Seconds to wait for the verdict.

### `xlide_live_sessions` (~104 tokens)

Live VBE sessions

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.

### `xlide_live_state` (~110 tokens)

Live editor state

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.

Input parameters:

- `pid` (integer): Which session, by process id. 0 uses the only one, or refuses.

### `xlide_live_request` (~145 tokens)

Query a live session

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.

Input parameters:

- `pid` (integer): Which session, by process id.
- `query` (string): Query string for the route, such as 'name=Module1' or 'type=Range'.
- `route` (string, required): One of the read routes listed above.

### `xlide_live_read_module` (~191 tokens)

Read a module from the editor

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.

Input parameters:

- `module_name` (string, required): Module name as the editor shows it.
- `pid` (integer): Which session, by process id.
- `project` (string): Which project, when two documents are open and both hold a module of this name.
- `surface_only` (boolean): Read the modern editor's own copy, which only exists for an open tab. Off reads the module through the editor, which always answers.

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/williamsmithedward-xlide-excel-office-vba-mcp/xlide-mcp#diagnostics

## Score history

- 2026-09-20: 54

## Common questions

### What is the XLIDE MCP server?

XLIDE is an MCP server listed in the public MCP registry as io.github.WilliamSmithEdward/xlide-excel-office-vba-mcp. Read, write, analyze, test and diff the VBA in Office files, and the document around it. This page covers its PyPI package (xlide-mcp).

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

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

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

XLIDE exposes 49 tools: xlide_list_projects, xlide_project_info, xlide_validate_project, xlide_create_project, xlide_doctor, and 44 more. Their descriptions and schemas cost roughly 8,788 tokens of context every time the server is loaded.

### Is the XLIDE MCP server still maintained?

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

## Links

- PyPI project: https://pypi.org/project/xlide-mcp/
- Socket report: https://socket.dev/pypi/package/xlide-mcp
- Repository: https://github.com/WilliamSmithEdward/xlide_mcp
- Changelog RSS feed: https://verifymcp.io/servers/williamsmithedward-xlide-excel-office-vba-mcp/xlide-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/williamsmithedward-xlide-excel-office-vba-mcp/xlide-mcp.json
- HTML version of this page: https://verifymcp.io/servers/williamsmithedward-xlide-excel-office-vba-mcp/xlide-mcp