excel-o365
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@excel-o365Create a workbook called Q3 Sales, add a worksheet, and create a table with the sample data."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Excel Office 365 MCP Toolbox
Un servidor MCP (Model Context Protocol) desarrollado en Python con FastMCP para gestionar archivos de Microsoft Excel en Office 365 (OneDrive / SharePoint) a través de Microsoft Graph API.
🚀 Características
Crear libros de Excel (
.xlsx): Crea archivos nuevos en OneDrive o SharePoint.Listar libros de Excel: Explora y lista archivos
.xlsxen carpetas.Agregar hojas de trabajo: Añade nuevas pestañas a un libro existente.
Crear tablas: Convierte rangos en tablas estructuradas con encabezados.
Agregar filas a tablas: Inserta/añade nuevas filas de datos a una tabla de Excel.
Leer filas de tablas: Extrae encabezados y filas de una tabla existente.
Related MCP server: Aspose.Cells Cloud MCP Server
🏗️ Arquitectura de la Solución
El siguiente diagrama ilustra la arquitectura de componentes y el flujo de integración entre el servidor FastMCP en Python, Google Cloud Run, Microsoft Entra ID y Microsoft Graph API en Office 365:
flowchart TD
subgraph Server["⚡ Excel FastMCP Server (Python / FastMCP)"]
ServerCore["FastMCP Core (server.py)"]
subgraph Tools["🛠️ Herramientas MCP"]
WorkbooksTool["workbooks.py\n(excel_create_workbook, excel_list_workbooks)"]
SheetsTool["sheets.py\n(excel_add_worksheet)"]
TablesTool["tables.py\n(excel_create_table, excel_add_table_rows, excel_get_table_rows)"]
end
GraphClient["GraphExcelService (graph_client.py)\n- Plantilla In-Memory OpenXML XLSX\n- API Async REST Graph Client"]
AuthModule["Módulo de Autenticación (auth.py / config.py)\n- ClientSecretCredential (MSAL / Azure Identity)"]
end
subgraph CloudRunInfra["☁️ Infraestructura GCP (Cloud Run)"]
CloudRunService["Google Cloud Run (excel-mcp-toolbox)"]
SecretManager["GCP Secret Manager\n(MS_CLIENT_SECRET)"]
end
subgraph MS365["🏢 Microsoft 365 & Entra ID"]
EntraID["Microsoft Entra ID (Azure AD)\n- OAuth 2.0 Client Credentials"]
GraphAPI["Microsoft Graph API v1.0\n- /users/{target_email}/drive"]
Office365["OneDrive for Business / SharePoint"]
end
CloudRunService --> ServerCore
SecretManager -.->|"Inyecta MS_CLIENT_SECRET"| AuthModule
ServerCore --> Tools
Tools --> GraphClient
GraphClient --> AuthModule
AuthModule -->|"1. Solicita Token Bearer OAuth2"| EntraID
EntraID -->|"2. Token de Acceso (Files.ReadWrite.All)"| AuthModule
GraphClient -->|"3. Peticiones REST HTTPS"| GraphAPI
GraphAPI -->|"4. Persistencia de Libros (.xlsx)"| Office365
style Server fill:#e6f4ea,stroke:#34a853,stroke-width:2px
style Tools fill:#ffffff,stroke:#34a853,stroke-width:1px
style CloudRunInfra fill:#e8f0fe,stroke:#4285f4,stroke-width:2px
style MS365 fill:#fef7e0,stroke:#fbbc04,stroke-width:2pxComponentes de la Arquitectura
Servidor FastMCP (
excel-mcp-toolbox):server.py: Punto de entrada que inicializa el servidor FastMCP e integra los módulos de herramientas.tools/: Expone las 6 herramientas atómicas con parámetros simplificados (strpara listas y filas) y respuestas formateadas en JSON explícito.graph_client.py: Servicio asíncrono que genera la estructura OpenXML de un.xlsxen memoria mediantezipfiley realiza llamadas REST HTTPS a Microsoft Graph API.auth.py&config.py: Gestión de credenciales mediantepydantic-settingsy autenticación OAuth 2.0 App-Only (ClientSecretCredential).
Infraestructura en GCP (Cloud Run & Secret Manager):
Cloud Run: Ejecuta el contenedor del servidor en un entorno serverless ligero (base
python:3.11-slim).Secret Manager: Almacena de forma segura la credencial sensible
MS_CLIENT_SECRET, inyectándola al contenedor en tiempo de ejecución.
Microsoft 365 & Entra ID (Azure AD):
Entra ID: Otorga permisos de aplicación
Files.ReadWrite.Allpara interactuar con OneDrive/SharePoint del usuario destino (TARGET_USER_EMAIL).Microsoft Graph API: Procesa las operaciones de creación de archivos, pestañas, tablas y formateo de datos.
🛠️ Requisitos Previos
Python 3.11+
uv (Gestor de paquetes de Python)
Registro de Aplicación en Microsoft Entra ID (Azure AD) con permisos
Files.ReadWriteoFiles.ReadWrite.All.
📦 Configuración e Instalación
Clonar e instalar dependencias:
uv venv .venv source .venv/bin/activate uv pip install -e .Configurar variables de entorno (
.env): Copia.env.examplea.envy completa tus credenciales de Azure AD:cp .env.example .envEdita
.env:MS_TENANT_ID=tu-tenant-id MS_CLIENT_ID=tu-client-id MS_CLIENT_SECRET=tu-client-secret DEFAULT_DRIVE_TYPE=onedrive
🚦 Uso con Clientes MCP (Cursor, Claude Desktop, Antigravity)
Agrega la configuración del servidor a la sección de MCP servers de tu cliente:
{
"mcpServers": {
"excel-o365": {
"command": "uv",
"args": [
"--directory",
"/ruta/a/excel-mcp-toolbox",
"run",
"excel-mcp"
]
}
}
}🧪 Pruebas
Para ejecutar la suite de pruebas unitarias:
uv run pytest☁️ Despliegue en Google Cloud Run
Este proyecto incluye soporte nativo para ejecutarse como un servicio de contenedor HTTP con Streamable HTTP (streamable-http) en Google Cloud Run.
1. Variables de Configuración
Proyecto GCP:
tu-proyecto-gcpRegión:
us-central1Artifact Registry:
containersSecret Manager:
excel-mcp-client-secretServicio Cloud Run:
excel-mcp-toolbox
2. Pasos de Despliegue Manuales con gcloud
Guardar el secreto sensible en Secret Manager:
gcloud secrets create excel-mcp-client-secret \ --replication-policy="automatic" \ --project="tu-proyecto-gcp" echo -n "TU_MS_CLIENT_SECRET" | gcloud secrets versions add excel-mcp-client-secret \ --data-file=- \ --project="tu-proyecto-gcp"Compilar la imagen del contenedor con Cloud Build:
gcloud builds submit \ --tag us-central1-docker.pkg.dev/tu-proyecto-gcp/containers/excel-mcp-toolbox:latest \ --project="tu-proyecto-gcp"Desplegar en Cloud Run:
gcloud run deploy excel-mcp-toolbox \ --image us-central1-docker.pkg.dev/tu-proyecto-gcp/containers/excel-mcp-toolbox:latest \ --region us-central1 \ --project tu-proyecto-gcp \ --no-allow-unauthenticated \ --port 8080 \ --set-env-vars MS_TENANT_ID="tu-tenant-id",MS_CLIENT_ID="tu-client-id",TARGET_USER_EMAIL="usuario@tu-empresa.com" \ --set-secrets MS_CLIENT_SECRET=excel-mcp-client-secret:latest
3. Despliegue Automatizado
También puedes ejecutar el script ejecutable ./deploy.sh cargando las variables desde tu archivo .env:
./deploy.sh📄 Licencia
Este proyecto está licenciado bajo los términos de la Licencia Apache 2.0. Consulta el archivo LICENSE para más información.
Available Tools
6 toolsexcel_add_table_rowsExcel Add Table RowsBRead-only
Append one or more rows of data into an existing Excel table.
| Name | Required | Description | Default |
|---|---|---|---|
| rows | Yes | Comma-separated values for a row (e.g. '2026-09-06, Laptop Pro, 1200'), or multiple rows separated by newlines. | |
| index | No | Optional 0-indexed row position (default None appends to the end). | |
| site_id | No | Optional SharePoint Site ID. | |
| drive_id | No | Optional SharePoint Drive ID. | |
| worksheet_name | Yes | Worksheet name (e.g. 'Sheet1'). | |
| item_id_or_path | Yes | Drive item ID or file path (e.g. '/Reports/Sales.xlsx'). | |
| table_name_or_id | Yes | Name or ID of the table (e.g. 'Table1' or 'SalesData'). |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description says 'Append one or more rows, which is a mutating operation, yet annotations declare readOnlyHint: true. This is a direct annotation contradiction and could cause an agent to treat a write operation as side-effect-free. No behavioral context such as insertion semantics is provided beyond the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one front-loaded sentence with a clear verb and object and no filler. It is appropriately sized for a straightforward append operation, though the misleading annotation prevents the overall definition from being fully trustworthy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Even with rich schema coverage and an output schema, the description fails to reconcile its mutating behavior with the readOnlyHint annotation. An agent relying on annotations would wrongly assume this operation is safe and read-only, so the definition is materially incomplete and potentially misleading.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters. The description adds little beyond confirming rows can be one or more, which is baseline-level value and does not require extra compensation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Append'), names the resource ('existing Excel table'), and specifies the payload ('one or more rows of data'). The word 'existing' clearly separates it from create_workbook and create_table siblings, so an agent can tell its purpose at a glance.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'existing Excel table' implies this tool is for adding rows to a table that already exists, which gives some contextual guidance. However, there are no explicit when-to-use or when-not-to-use instructions, and no alternatives are named, so the agent must infer selection logic from the sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
excel_add_worksheetExcel Add WorksheetBRead-only
Add a new worksheet/tab to an existing Excel workbook.
| Name | Required | Description | Default |
|---|---|---|---|
| site_id | No | Optional SharePoint Site ID. | |
| drive_id | No | Optional SharePoint Drive ID. | |
| worksheet_name | Yes | Name of the new worksheet to create. | |
| item_id_or_path | Yes | Drive item ID or file path (e.g. '/Reports/Sales.xlsx' or item ID). |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations declare readOnlyHint=true, which is contradicted by the description's 'Add a new worksheet' – adding is a mutation, not a read-only operation. This is a serious inconsistency. The description also does not disclose behavior such as whether an existing worksheet with the same name will be overwritten or cause an error, or whether the operation requires write permissions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core action and resource. It earns its place with no wasted words, though it could have added a brief usage note without becoming bloated.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the annotation contradiction (readOnlyHint=true for a mutating operation), the description is incomplete and misleading. It also lacks guidance on naming constraints or behavior when the worksheet already exists. The output schema exists, so return values are covered, but the core behavioral context is flawed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all four parameters. The description adds no extra meaning beyond the schema, but the baseline of 3 applies because the schema carries the full burden. The description does not clarify the relationship between site_id/drive_id and item_id_or_path, but that is not required given full schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Add') and resource ('new worksheet/tab to an existing Excel workbook'), which clearly identifies the operation. It does not explicitly differentiate from siblings like excel_create_workbook, but the resource distinction (worksheet vs workbook) is reasonably clear from the wording.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context: adding a worksheet to an existing workbook, which distinguishes it from creating a workbook. However, it does not explicitly state when to use this tool versus alternatives like excel_create_workbook or excel_create_table, nor does it mention any prerequisites such as the workbook needing to exist or the worksheet name being unique.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
excel_create_tableExcel Create TableCRead-only
Create a structured table within a range of an Excel worksheet.
| Name | Required | Description | Default |
|---|---|---|---|
| address | Yes | Cell range for the table (e.g. 'A1:D1' or 'A1:D10'). | |
| site_id | No | Optional SharePoint Site ID. | |
| drive_id | No | Optional SharePoint Drive ID. | |
| table_name | No | Optional custom table name (e.g. 'SalesData'). | |
| has_headers | No | Whether the first row contains column headers (default True). | |
| worksheet_name | Yes | Worksheet name (e.g. 'Sheet1'). | |
| item_id_or_path | Yes | Drive item ID or file path (e.g. '/Reports/Sales.xlsx'). |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description directly contradicts the annotations: it says 'Create' which implies a mutating operation, while annotations declare readOnlyHint: true and destructiveHint: false. Although the description is otherwise transparent about creating a table, the contradiction with structured metadata is a serious flaw that prevents reliable agent decision-making.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single clear sentence with no filler or redundant wording. It is appropriately front-loaded with the core action and object. Only a slight loss for being too brief to carry behavioral context independently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values do not need explaining, and the input schema is well-covered. However, the annotation contradiction leaves the tool's actual mutating behavior undisclosed, and there is no mention of preconditions, side effects, or how the table relates to existing worksheet data. This is insufficient for safe autonomous use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers 100% of parameters with meaningful descriptions, so the baseline of 3 applies. The tool description itself adds no parameter-level meaning beyond what the schema already provides. It does not repeat or expand on details like address range, headers, or optional identifiers.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource: 'Create a structured table within a range of an Excel worksheet.' This clearly distinguishes the tool from siblings like excel_add_table_rows or excel_list_workbooks. It does not explicitly name a sibling, but the core action and target are unmistakable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to use this tool versus alternatives, such as when a table should be created versus when rows should be added to an existing table. The description simply states the action with no context about prerequisites, typical workflow, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
excel_create_workbookExcel Create WorkbookBRead-only
Create a new Excel workbook (.xlsx) in OneDrive or SharePoint.
| Name | Required | Description | Default |
|---|---|---|---|
| site_id | No | Optional SharePoint Site ID. | |
| drive_id | No | Optional SharePoint Drive ID. | |
| filename | Yes | Name of the Excel file (e.g. 'Financial_Report.xlsx'). | |
| folder_path | No | Target folder path in OneDrive/SharePoint (default '/'). | / |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description says 'Create', which is a state-changing write operation, while annotations declare readOnlyHint=true. This is a direct contradiction. The description also omits any behavioral context about permissions, overwrite behavior, or location selection.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single clear sentence that front-loads the action and resource. There is no wasted text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a creation tool with a contradictory annotation, the description leaves out important behavioral context such as how the target location is chosen, what happens if the file already exists, and whether credentials/permissions are needed. The output schema reduces the need to describe return values, but the overall guidance is still thin.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all four parameters. The description adds minimal value beyond the schema, only hinting that the destination is OneDrive or SharePoint.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Create') and resource ('new Excel workbook (.xlsx)'), and clearly locates the action in OneDrive or SharePoint. It is easily distinguished from sibling tools like excel_create_table or excel_add_worksheet.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to use this tool versus alternatives, nor are exclusions or prerequisites mentioned. The agent must infer usage from the tool name and one-line description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
excel_get_table_rowsExcel Get Table RowsARead-only
Get column headers and data rows from an existing Excel table.
| Name | Required | Description | Default |
|---|---|---|---|
| site_id | No | Optional SharePoint Site ID. | |
| drive_id | No | Optional SharePoint Drive ID. | |
| worksheet_name | Yes | Worksheet name (e.g. 'Sheet1'). | |
| item_id_or_path | Yes | Drive item ID or file path (e.g. '/Reports/Sales.xlsx'). | |
| table_name_or_id | Yes | Name or ID of the table. |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that the tool returns both column headers and data rows, which is useful. It does not disclose details like pagination, row limits, or whether the entire table is returned, but given the annotations, this is acceptable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, concise sentence that front-loads the action and the resource. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has an output schema, so return values are already documented. The description covers the core purpose and the annotations cover safety. The only minor gap is that it doesn't mention any limitations (e.g., whether it returns all rows or paginates), but for a read-only list-like operation, this is not a critical omission.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all five parameters. The description adds no additional meaning beyond what the schema provides, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Get') and resource ('column headers and data rows from an existing Excel table'), which clearly distinguishes it from sibling tools like excel_create_table or excel_add_table_rows. It doesn't explicitly name a sibling, but the action is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context: it is for reading from an existing table, not creating or writing. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites (e.g., that the table must already exist).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
excel_list_workbooksExcel List WorkbooksARead-only
List Excel workbooks (.xlsx, .xls) in a target OneDrive or SharePoint folder.
| Name | Required | Description | Default |
|---|---|---|---|
| site_id | No | Optional SharePoint Site ID. | |
| drive_id | No | Optional SharePoint Drive ID. | |
| folder_path | No | Target folder path to list (default '/'). | / |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the file extension filter and target folder, but does not disclose behaviors like pagination, recursion depth, or whether it returns full metadata. This adds some context beyond the schema and annotations, but not rich behavioral detail. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that states the action, resource, and scope with no wasted words. It is appropriately concise and immediately informative.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has three optional parameters fully documented in the schema, annotations cover safety, and an output schema exists, so return-value explanation is unnecessary. The description covers the core purpose and target folder. It might benefit from a note about permission requirements or that it only lists metadata, but these are minor given the available structured information.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%: all three parameters (site_id, drive_id, folder_path) have descriptions in the schema, so the baseline is 3. The tool description does not add additional semantics, such as how site_id and drive_id relate or how to obtain them. It adds no value beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'List' and the resource 'Excel workbooks (.xlsx, .xls)', with the target location 'OneDrive or SharePoint folder'. This is specific and distinguishes it from sibling tools that create tables, workbooks, or manipulate rows. An agent can immediately understand its role without ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage: when you need to list Excel workbooks in a folder. However, it does not explicitly state when to use this tool over alternatives, mention prerequisites (e.g., site_id/drive_id requirements), or note that it is read-only compared to other operations. The usage context is clear but not elaborated with exclusions or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
6 tool updates
v0.1.0- First observed
excel_add_table_rows - First observed
excel_add_worksheet - First observed
excel_create_table - First observed
excel_create_workbook - First observed
excel_get_table_rows - First observed
excel_list_workbooks
TDQS
Scored across 6 tools
Each tool targets a distinct operation: listing workbooks, creating workbooks, creating tables, adding worksheets, appending rows, and reading rows. There is no overlap or ambiguity between them.
All tools follow a consistent excel_<verb>_<noun> pattern (list_workbooks, create_table, create_workbook, add_worksheet, add_table_rows, get_table_rows). The naming convention is uniform and predictable.
Six tools is well-scoped for an Excel/O365 server handling workbook and table operations. Each tool addresses a meaningful need without redundancy or bloat.
The core lifecycle of workbook creation, worksheet addition, table creation, row insertion, and row retrieval is covered. Minor gaps exist (no delete/update operations, no listing worksheets), but common workflows are supported.
Maintenance
Related MCP Connectors
Generate, edit, merge, translate and PDF-convert PowerPoint (.pptx) over MCP. 8 tools.
OneDrive (Microsoft Graph) MCP Pack
Manage Microsoft 365 email, calendar, contacts and inbox rules via the Graph API with OAuth 2.0.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables reading and writing Excel files (text, formulas, and images on Windows) via MCP tools with pagination support.3MIT
- AlicenseCqualityBmaintenanceAutomates Microsoft Excel spreadsheet creation and editing via MCP tools for any MCP-compatible client.37MIT
- AlicenseAqualityDmaintenanceEnables reading and writing Excel workbooks (.xlsx) through MCP. Supports listing sheets, tables, pivot tables, reading cell data, exporting to CSV/text/Markdown, and creating/modifying Excel files.14GPL 3.0
- FlicenseNot gradedqualityAmaintenanceMCP server that integrates with OneDrive and Excel Workbooks via Microsoft Graph API for creating and modifying worksheets.-