tablekit-mcp
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., "@tablekit-mcpConvert this CSV to a Markdown table, right-align the numbers."
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.
tablekit-mcp
A tiny, dependency-free MCP server for tabular data — convert, align, reshape and inspect tables without breaking them.
Tables are where language models quietly fail: they drop rows when converting a big CSV to JSON, they misalign Markdown columns, they transpose a table and shuffle the wrong cell. tablekit does those jobs with plain deterministic code instead of guessing.
Zero network access. Zero file system access. Pure Python standard library. It takes a string and returns a string.
Why this exists
Task | Asking the model to do it | Letting tablekit do it |
CSV → JSON, 200 rows | Rows get silently dropped or truncated | Every row survives |
Fix a ragged Markdown table | Columns drift, especially with CJK text | Re-aligned by real display width |
Transpose / sort / filter | Off-by-one row errors | Deterministic |
"What's wrong with this table?" | Vague guess | Type inference, empty counts, duplicate report |
Chinese / Japanese / Korean tables line up correctly. Most tools measure string length; tablekit measures display width, so 苹果 counts as 4 cells and the pipes actually match.
Related MCP server: mcp-csv
Tools
Tool | What it does |
| Convert between |
| Re-align a messy Markdown table so every column lines up |
|
|
| Structure report: row/column counts, per-column type, empty counts, distinct values, dirty-data warnings |
Formats accept the aliases .md, .csv, .htm — paste a filename extension and it just works.
Install
Option 1 — run straight from GitHub (uv)
uvx --from git+https://github.com/Orange123Eleven/tablekit-mcp tablekit-mcpOption 2 — clone and install
git clone https://github.com/Orange123Eleven/tablekit-mcp
cd tablekit-mcp
uv venv && uv pip install -e .Configure your client
Claude Desktop (claude_desktop_config.json):
{
"mcpServers": {
"tablekit": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/Orange123Eleven/tablekit-mcp",
"tablekit-mcp"
]
}
}
}Cursor / Cline / Windsurf / VS Code — same shape, e.g. .cursor/mcp.json:
{
"mcpServers": {
"tablekit": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/Orange123Eleven/tablekit-mcp",
"tablekit-mcp"
]
}
}
}Restart the client and the four tools appear in the tool list.
What it looks like in use
1. A CSV with Chinese headers, converted to a readable Markdown table
Input:
名称,数量,单价
苹果,3,5.50
进口香蕉,150,2.00Ask: "turn this into a Markdown table, right-align the numbers"
Output:
| 名称 | 数量 | 单价 |
| -------- | ---: | ---: |
| 苹果 | 3 | 5.50 |
| 进口香蕉 | 150 | 2.00 |2. A broken table gets repaired
Input (note the short row):
| name | team | score |
| ------ | --------- | ----- |
| Ana | Red | 91 |
| Ben | Blue |table_inspect reports:
Rows: 2 | Columns: 3
| Column | Type | Empty | Distinct | Most frequent |
| --- | --- | --- | --- | --- |
| name | text | 0 | 2 | Ana (1) |
| team | text | 0 | 2 | Red (1) |
| score | integer | 1 | 1 | 91 (1) |
Issues found:
- 各行列数不一致(少则 2 列,多则 3 列),已按最大列数补空。3. HTML table scraped from a page → CSV
Ask: "here's the HTML, give me a CSV I can paste into Excel" — one call, no row loss.
Safety
This server is deliberately boring, and that is the point:
No network requests. It never phones home.
No file system access. It cannot read or write your files. You paste text in, you get text back.
No third-party dependencies. Only the MCP SDK itself.
Stateless. Nothing is stored between calls.
Deterministic. Same input, same output, every time.
中文说明
给中文用户的一句话:表格数据的小工具,专治中文表格对不齐、大表格转换丢行。
四种工具:格式互转 / 对齐美化 / 转置排序筛选 / 结构体检
支持 Markdown、CSV、TSV、JSON、HTML 五种格式
中文按 2 格宽度对齐,
| 名称 | 数量 |这种表格能真正对齐(大多数工具做不到)纯本地、不联网、不碰你的文件、无第三方依赖
上面「Configure your client」里的配置直接抄就行。
Development
python3 tests/test_core.py -v # 42 tests, standard library onlyThe processing logic lives in src/tablekit_mcp/core.py and has no MCP dependency, so it can be tested and reused on its own. src/tablekit_mcp/server.py is a thin wrapper that exposes it over MCP.
License
MIT
Available Tools
4 toolstable_alignA
Re-align a messy Markdown table so every column lines up.
Use this when a Markdown table is ragged, when pipes are not aligned in the source, when a row has the wrong number of cells, or when Chinese characters make the columns drift. This is a focused shortcut for table_convert(..., to_format="markdown"); it always outputs Markdown.
Args: text: The table as text. Defaults to reading it as Markdown. from_format: How to read the input. markdown, csv, tsv, json or html. aligns: Per-column alignment, e.g. "left,right", or a single value. Empty means no explicit alignment markers.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| aligns | No | ||
| from_format | No | markdown |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the output format (Markdown) and the transformation nature, but does not mention edge cases, side effects, or how it handles malformed input beyond 'wrong number of cells.' It gives enough to be safe but not exhaustive, so a 3 is appropriate.
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 well-structured with a front-loaded purpose, explicit usage triggers, and a clean Args block. It is efficient but includes a few redundant clarifications (e.g., 'Defaults to reading it as Markdown' appears twice), which slightly reduces conciseness.
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 3-parameter tool with an output schema present, the description covers purpose, usage, parameters, and output format. It omits only minor details like error behavior or whether the original table is preserved, which are not critical for a straightforward transformation tool.
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 coverage is 0%, so the description must compensate, and it does thoroughly. The Args section explains each parameter: text's default reading as Markdown, from_format's accepted values, and aligns' per-column syntax with the meaning of empty. This fully compensates for the schema gap.
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 opens with a clear, specific verb and resource: 'Re-align a messy Markdown table so every column lines up.' It explicitly differentiates from siblings by calling itself a focused shortcut for table_convert(..., to_format='markdown'), making its scope 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?
The description provides explicit conditions for use ('when a Markdown table is ragged, when pipes are not aligned...') and names the alternative (table_convert) with a clear distinction (always outputs Markdown). This leaves no ambiguity about when to select this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
table_convertA
Convert tabular data between formats, without losing or reshuffling rows.
Use this whenever a table needs to change shape: CSV to Markdown, Markdown to JSON, HTML table to CSV, and so on. Rows are never silently dropped, and ragged rows are padded rather than truncated. Markdown output is column-aligned with East-Asian wide characters counted as two cells, so Chinese tables line up correctly.
Args: text: The whole table as text. from_format: Source format. markdown, csv, tsv, json or html (aliases: md, htm). to_format: Target format. markdown, csv, tsv, json or html (aliases: md, htm). aligns: Markdown output only. Per-column alignment as a comma-separated list, e.g. "left,right,center", or one value applied to every column, e.g. "center". Empty means leave the default alignment. indent: JSON output indentation width. Default 2.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| aligns | No | ||
| indent | No | ||
| to_format | Yes | ||
| from_format | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does so well. It discloses strong behavioral guarantees: 'Rows are never silently dropped, and ragged rows are padded rather than truncated.' It also details the Markdown alignment behavior with East-Asian wide characters counted as two cells. These go far beyond the bare conversion verb and give an agent a reliable mental model of the tool's behavior.
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 front-loaded with a one-sentence summary, immediately followed by usage context and behavioral guarantees, then a structured Args list. Every sentence earns its place: the wide-character note, row-preservation guarantee, and alias examples are all operationally relevant. No filler or repetition.
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 tool has 5 parameters, no annotations, and no schema descriptions, the description covers all essential information: full parameter semantics, behavioral edge cases, and explicit usage triggers. The output schema exists, so return values do not need to be explained. An agent has enough to select and call this tool correctly without additional investigation.
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 0%, so the description must compensate. The Args section fully compensates by explaining each parameter's meaning, acceptable values, aliases (md, htm), example formats ("left,right,center"), and defaults (indent 2, aligns empty). This adds substantial value beyond the schema titles and enables correct invocation.
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 opens with a specific verb+resource+scope: 'Convert tabular data between formats.' It immediately clarifies the exact operation and gives concrete format-pair examples (CSV to Markdown, Markdown to JSON, HTML table to CSV), which distinguishes it from sibling tools like table_align, table_transform, and table_inspect. The behavior is stated as 'change shape,' making the tool's role 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 explicitly says 'Use this whenever a table needs to change shape,' providing a clear triggering condition. However, it does not mention when not to use it or name alternative sibling tools for alignment or inspection, so the guidance lacks exclusions and alternative routing. This is clear context but not full when/when-not coverage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
table_inspectA
Report the structure and data quality of a table before working on it.
Returns row and column counts, a per-column summary (inferred type, empty count, distinct values, most frequent values) and a list of problems such as duplicate headers, ragged rows, fully duplicated rows and empty rows. Call this first when a table looks suspicious, then fix it with table_transform.
Args: text: The whole table as text. from_format: How to read the input. markdown, csv, tsv, json or html.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| from_format | No | markdown |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden for behavioral disclosure. It clearly describes what the tool returns (structure and quality metrics) but does not explicitly state that the operation is non-destructive or mention any side effects, error conditions, or permissions. Since it is a 'report' tool, read-only behavior is implied but not stated, leaving a moderate gap.
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 compact and well-organized. It front-loads the purpose, then lists outputs, usage guidance, and parameters. Every sentence contributes value—no filler or redundancy. The flow is logical and easy to parse.
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 is fairly simple (2 params, output schema exists) and the description covers the input semantics, output content, and usage sequence. It lacks explicit error-handling notes (e.g., unsupported formats) or size limitations, but these are minor given the clarity of the rest. The inclusion of the sibling for the next step adds completeness.
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 0%, so the description must compensate. The Args section explains both parameters: 'text: The whole table as text' and 'from_format: How to read the input. markdown, csv, tsv, json or html.' This adds meaning beyond the schema's bare titles and types, though it omits constraints like size limits or encoding, keeping it just shy of a 5.
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 ('Report'), resource ('a table'), and enumerates the exact output (row/column counts, per-column summary, list of problems). It also explicitly differentiates from siblings by positioning itself as the first step before table_transform, so an agent can distinguish it without inspecting other tools.
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 gives a clear directive: 'Call this first when a table looks suspicious, then fix it with table_transform.' This specifies when to use the tool and names the alternative for the follow-up action, effectively covering the usage context and a key sibling distinction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
table_transformA
Reshape a table: transpose, pick or rename columns, sort, dedupe, filter.
Prefer this over editing rows by hand when the change is mechanical, because the whole table is processed at once and row order is preserved.
Args: text: The whole table as text. operation: What to do. transpose | select_columns | rename_columns | sort | dedupe | drop_empty_rows | filter. from_format: How to read the input. markdown, csv, tsv, json or html. to_format: How to write the result. markdown, csv, tsv, json or html. columns: For select_columns: the column names to keep, in output order. A 1-based column number is also accepted, e.g. "2". renames: For rename_columns: a mapping of old name to new name. sort_by: For sort: the column to sort on. descending: For sort: set true for descending order. numeric: For sort: set true to sort numerically instead of as text. column: For filter: the column to test. operator: For filter: == | != | > | >= | < | <= | contains | startswith | endswith | empty | not_empty. value: For filter: the value to compare against. aligns: Markdown output only. Per-column alignment or a single value.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| value | No | ||
| aligns | No | ||
| column | No | ||
| columns | No | ||
| numeric | No | ||
| renames | No | ||
| sort_by | No | ||
| operator | No | ||
| operation | Yes | ||
| to_format | No | markdown | |
| descending | No | ||
| from_format | No | markdown |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It usefully states that the whole table is processed at once and row order is preserved, but does not mention statelessness, error handling, or data-size limits. Coverage is partial but not misleading.
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 front-loaded with a one-line summary, followed by a usage guideline and a structured Args block. Given 13 parameters and no schema descriptions, the detail in the Args block is necessary. Every sentence earns its place; there is no redundancy.
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 complex tool with 13 parameters and an output schema, the description covers all parameters and operation options, and the output schema handles return-structure explanation. Some edge cases (e.g., empty input, invalid format behavior) are unspecified, but an agent can correctly call the tool with the given 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 0%, and the description's Args section fully compensates: it explains every parameter, including operation-specific behavior (e.g., 1-based column numbers for select_columns, the operator list for filter, and format options). This goes well beyond the bare schema.
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 opens with a specific verb ('reshape') and resource ('a table'), and enumerates the supported operations (transpose, select_columns, rename_columns, sort, dedupe, filter). This makes the core purpose clear. It does not explicitly name sibling tools, so differentiation from tools like table_convert or table_align is implicit rather than spelled out.
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 provides a clear usage context: prefer this over manual row editing for mechanical changes, citing whole-table processing and row-order preservation. It does not, however, mention when to use sibling tools such as table_convert or table_align, leaving alternative selection to inference.
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.
4 tool updates
v0.1.0- First observed
table_align - First observed
table_convert - First observed
table_inspect - First observed
table_transform
TDQS
Scored across 4 tools
The four tools have largely distinct purposes: align for realignment, convert for format changes, transform for reshaping, and inspect for analysis. However, table_align is a subset of table_convert (always outputs markdown) which could cause confusion when deciding which tool to use. This minor overlap prevents a perfect score.
All tool names follow the consistent pattern 'table_<verb>' using snake_case: table_align, table_convert, table_transform, table_inspect. The verbs are clear and predictable, making the API easy to navigate.
With 4 tools, the server covers the core operations (convert, transform, inspect, align) without bloat. While slightly on the lean side, the scope is focused and each tool justifies its existence. A couple more tools (e.g., merge or split) might be expected but the current count is reasonable.
The toolkit provides solid coverage for tabular data manipulation: format conversion, structural transformation, inspection, and alignment. Missing operations like merging tables or creating from scratch are not critical for the stated purpose, but there are minor gaps (e.g., no direct row insertion/deletion) that agents can work around using transform operations.
Maintenance
Related MCP Connectors
Open, inspect, filter, edit and convert xlsx and csv files from your AI chat. Processing is local.
Open, inspect, filter, edit and convert xlsx and csv files from your AI chat. Processing is local.
Open, inspect, filter, edit and convert xlsx and csv files from your AI chat. Processing is local.
Convert between 200+ format pairs: JSON, CSV, XML, YAML, PDF, Excel, DOCX and more.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables an AI assistant to preview, query, aggregate, and convert CSV/TSV data safely with no API key.3MIT
- AlicenseNot gradedqualityBmaintenanceConverts CSV to JSON and JSON to CSV offline, supporting RFC 4180 with header detection and custom delimiters.14 npmMIT
- AlicenseNot gradedqualityDmaintenanceBidirectional CSV ↔️ JSON ↔️ Markdown transformer exposed as an HTTP-based MCP server, enabling format conversion through natural language.36 npmMIT
- AlicenseNot gradedqualityBmaintenanceEnables interaction with table data in a Federated Wiki, supporting CSV, TSV, JSON, and markdown pipe tables, with CRUD operations via REST and MCP tools.3 npmMIT