letin: Power Query (M) MCP server

Read from the package source without running it. The installed server may list more.

• apply_transform

  Add a standard Power Query step without hand-writing M. `action` and `params` come from list_transforms, e.g. action='unpivot_other_columns', params={'keep_columns': ['Region']}; or action='group_by', params={'group_columns': ['Region'], 'aggregations': [{'name': 'Total', 'operation': 'sum', 'column': 'Amount'}]}. The step is appended to the end unless after_step names an earlier step (the next st

• copy_queries

  Copy queries between workbooks / projects / folders, bringing the queries they depend on along.

• delete_querywrite action

  Delete a query. Refuses when other queries reference it unless force=true.

• dependency_graph

  Query-to-query lineage. With `query`, only its upstream and downstream. format: 'json' or 'mermaid'. Also reports roots (read external data), leaves (final outputs), orphans and cyclic references.

• diff_queries

  Compare the queries of two sources (workbook vs workbook, workbook vs exported folder, PBIP vs PBIP ...). Line endings are ignored. To compare against a snapshot pass its `path` from list_snapshots.

• evaluate_mwrite action

  Run any M expression and get the result as data. Tables come back with column names, types and the first `rows` rows (cell errors shown as #ERROR); lists, records, scalars and functions (with signature) are described too; an M error comes back as reason + message. With `source`, the expression can reference that source's queries by name (e.g. Table.RowCount(Sales)), including unsaved edits of an o

• evaluate_query

  Freshly evaluate a query, or the query only up to `step`, and return columns, types and sample rows. Use it to get real column names before apply_transform, to see what a step does to the data, or to find the step where an error first appears (evaluate step by step).

• evaluate_steps

  Evaluate EVERY step of a query in one engine call and describe each one (columns, types, first `rows` rows, or the error). The fastest way to see how a query transforms its data and to find the step where an error first appears: one call instead of evaluate_query once per step.

• export_querieswrite action

  Write every query to `folder` as one .pq file each plus pq-manifest.json: ready to commit to git and diff in a PR. Existing .pq files in the folder are replaced.

• extract_parameter

  Turn a hard-coded text value (path, server, URL) into a Power Query parameter and reference it everywhere. With match_prefix, "C:\Data" also rewrites "C:\Data\sales.csv" to SourceFolder & "\sales.csv".

• find_in_queries

  Search the M of every query. scope: all | code | strings | comments. Returns query, step and line for each hit.

• format_m

  Pretty-print M (an expression or a section document): one step per line, long calls broken at their arguments, comments kept. The output is verified token-for-token against the input, so meaning can never change.

• format_queries

  Format one query, or every query, in place (same guarantees as format_m).

• get_query

  Full M code of one query plus its parsed steps, data sources, dependencies and dependents.

• import_queries

  Load .pq files from `folder` back into `source`. mode='update' changes/adds queries; mode='sync' also deletes queries that are not in the folder.

• lint_queries

  Audit queries for folding breakers, hard-coded paths/servers, dead steps, brittle column lists, untyped columns, duplicated logic, orphans and cycles. Each finding carries a concrete suggestion. min_severity: info | warning | error.

• list_data_sources

  Inventory of every external source (files, folders, servers, URLs) each query reads, and whether it is hard-coded or parameterised.

• list_queries

  Every query with its kind (query/function/parameter), step count, load destination, and what it depends on / is used by.

• list_snapshots

  Snapshots taken automatically before each write to this source, newest first.

• list_sources

  List workbooks open in Excel and models open in Power BI Desktop (both usable as `source`), and explain the other source forms.

• list_transforms

  Catalog of guided actions for apply_transform (unpivot, pivot, group_by, merge, filter, types, ...) with their params.

• m_function_help

  Look up the M standard library (generated from the real engine: 850+ members). Give an exact name ('Table.Group') for its signature and description, a namespace ('Table.' or 'List') to list its members, or words to search names and descriptions ('unpivot', 'split text delimiter'). Use it instead of guessing signatures.

• preview_query

  Column names and first rows of a query that is loaded to a worksheet table (open Excel workbook only). Use it to get real column names before apply_transform.

• refresh_query

  Refresh one query in an open Excel workbook and wait for it; returns the mashup engine's error text if it fails.

• remove_stepwrite action

  Delete a step and rewire the steps that used it to the step it read from.

• rename_query

  Rename a query and rewrite every reference to it in all other queries (token-aware: strings, comments and same-named columns are left alone).

• rename_step

  Rename a step inside a query and every reference to it.

• replace_in_queries

  Find and replace across all (or the listed) queries in one go, e.g. repoint a server or folder. scope: 'strings' (only inside text literals; safest, the default), 'code' (outside strings and comments), 'all'.

• restore_snapshot

  Roll back to a snapshot. With `queries`, only those are restored; otherwise the whole query set is put back (queries created since are deleted). 'latest' undoes the most recent write.

• set_query

  Replace a query's M (or create it with create_if_missing). Rejects unbalanced brackets/strings before writing. For standard actions prefer apply_transform; for renames prefer rename_query / rename_step.

• validate_m

  Check M before using it: syntax errors with line/column and a plain-English cause (missing comma between steps, unquoted step name, if without else ...), unknown steps/queries/functions with did-you-mean, and wrong argument counts for library functions. Pass `formula` (an expression or a whole section document); add `source` so its query names are known. Or pass `source` (+ optional `query`) alone

• Code scan27 source files scanned25/25
• –Live reliabilityno gateway calls yet and no remote to proben/a
• –Tool poisoningtools not inspected (local package is not executed); not countedn/a
• Auth qualitylocal package, no credentials required12/15
• Maintenancerepository not readable: repo not found3/15
• Maintainer identityno repository or website to verify2/10

Safety score

65/100

higher than 20% of 48,273 servers

Tools

31

the typical server has 7

Tools that change things

13%

typical: 0%. Fewer write tools means less an agent can break

Downloads a week

14

more than 4% of 11,915 servers with a package

Grade history

• 2026-11-01downgradeA → Cscore 65

letin: Power Query (M): common questions

Is letin: Power Query (M) MCP server safe?

With care: it is graded C, so read the findings first (65/100). Read the letin: Power Query (M) safety report

How do I install letin: Power Query (M)?

It runs on your machine. Copy the Claude Code, Cursor, VS Code or Claude Desktop config from the install section.

Does letin: Power Query (M) need an API key?

No secret keys are declared. It reads 1 setting from the environment.

Is letin: Power Query (M) maintained?

The last commit was 41 days ago (2026-09-22). The latest release is v0.2.0.

What can I use instead of letin: Power Query (M)?

Servers from other publishers that do the same job: e2e MCP server.

How does letin: Power Query (M) compare with other MCP servers?

safety score 65/100 (higher than 20% of 48,273 servers); tools 31 (the typical server has 7); tools that change things 13% (typical: 0%. Fewer write tools means less an agent can break). Full comparison.