jdatamunch-mcp
jDataMunch is an MCP server that indexes local or GitHub-hosted tabular data (CSV, Excel, Parquet, JSONL) and lets agents query profiles, rows, aggregations, joins, and data health without pasting rows into context.
Index local data files or GitHub repos incrementally, with configurable profiling depth and format/sheet/encoding options.
List, validate, inspect history for, and delete indexed datasets and repos.
Orient in datasets via
describe_dataset,describe_column,sample_rows,get_distribution, andget_correlations.Query data server-side with filtered
get_rows,aggregate,join_datasets, read-only sandboxedrun_sql, andplan_queryintent routing.Search columns and values with keyword or embedding-based semantic search, tune ranking weights, and check embedding drift.
Assess data quality and schema risk: health grades/radars, hotspots, schema drift, key/join suggestions, similar/unused columns, drop safety, and schema impact.
Ingest SQL logs for runtime traffic analysis, inspect redaction logs, and view perf telemetry and token-savings stats.
Redact PII/credentials from returned values by default while keeping numeric stats intact.
Produce deterministic Markdown handoff reports and retrieve the version-current agent policy snippet.
Enables indexing tabular data files (CSV, Excel, Parquet, JSONL) directly from GitHub repositories, including private repositories, for local profiling and server-side querying.
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., "@jdatamunch-mcp Index ./data/sales.csv and give me a summary of the columns"
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.
jDataMunch MCP: Tabular Data Retrieval for AI Agents
jDataMunch is an MCP server for coding agents and analysts that answers questions about CSV, Excel, Parquet, and JSONL files without pasting the rows into the context window.
Index a dataset once, then retrieve column profiles, filtered rows, server-side aggregations, and cross-dataset joins — so a million-row file costs thousands of tokens instead of millions.
Install · Quickstart · Benchmarks · Commercial licensing
Free for personal use. Commercial use requires a paid license — terms below.
Why jDataMunch?
The problem. The default way an agent explores a spreadsheet is to paste it into the prompt. A 255 MB CSV with a million rows costs roughly 111 million tokens that way, and the model still has to reason through a million rows to answer "what columns are in here?"
The mechanism. jDataMunch profiles the file once — columns, types, cardinality, null rates, distributions — and stores that locally. Queries then run against the data, not against a copy of it in the prompt: filters, aggregations, and joins execute server-side and return only results.
The outcome. Orientation questions are answered from the profile. Row-level questions return matching rows. The raw file never enters the context window.
Related MCP server: mcp-csv-analyst
Evidence
Measured on a real public dataset, not estimated. Full harness and per-query results in benchmarks/.
Corpus: LAPD crime records — 1,004,894 rows, 28 columns, 255 MB Baseline: 111,028,360 tokens to paste the raw file
describe_dataset: ~892 tokens, schema plus one column ~1,200: a 99,059× reduction (mean of five per-task ratios) Methodology & harness · Full results
Task | Without jDataMunch | With jDataMunch | Reduction |
Understand a dataset's shape | Paste 111M tokens |
| ~124,000× |
Schema + one column deep-dive | Paste 111M tokens |
| ~93,000× |
Filter to matching rows | Load all 1M rows |
| ~99%+ |
Count by category | Return all rows, aggregate in the model |
| ~99.9% |
What these numbers are and are not. The reduction is measured against pasting the complete file, which is what a naive agent does and what the token bill reflects. It is not measured against a competent human analyst who would never paste a 255 MB CSV. The multiple scales with file size: a 200-row spreadsheet has far less to save, and the honest figure there is closer to "no meaningful difference."
Typical latencies from the same run: describe_dataset plus describe_column on a single column, 22 to 40 ms; describe_column alone is 223 to 387 tokens.
Install
Requirements: Python 3.10+, any MCP-compatible client.
There is no install step. jdatamunch-mcp is a stdio MCP server with no CLI subcommands, so nothing needs to land on your PATH — point your client at uvx and it fetches and runs the server on demand.
Claude Code setup:
claude mcp add jdatamunch -- uvx jdatamunch-mcpNothing else. Don't have uv yet?
Reading Excel or Parquet? Those pull optional extras, which uvx takes on the --from argument:
claude mcp add jdatamunch -- uvx --from "jdatamunch-mcp[excel,parquet]" jdatamunch-mcpCommand | Use it when |
| You want it resolved once instead of per-launch |
| You already standardise on pipx |
| Inside a virtualenv you manage yourself. ⚠ Refused on PEP 668 distros (Ubuntu 24.04+, Debian 12+) — use one of the two above. |
Extras take the usual bracket form here: uv tool install "jdatamunch-mcp[excel,parquet]". Registering the server still works the same way; substitute jdatamunch-mcp for uvx jdatamunch-mcp in the claude mcp add line above.
Restart Claude Code, then type /mcp — jdatamunch should be listed. That listing is the verification step; running the server directly just waits on stdin.
Full per-client setup, including Claude Desktop, Cursor, and Windsurf: QUICKSTART.md.
Quickstart
Assumes: jDataMunch installed and registered with your client, and a CSV to hand.
Everything happens inside your agent — there is no separate indexing command. Ask it to index:
Using jdatamunch, index ./data/sales.csv
It calls index_local, which returns the dataset name, row and column counts, and detected types. Then:
Using jdatamunch, describe the sales dataset and tell me which columns have missing values.
The agent calls describe_dataset, which returns column names, inferred types, cardinality, null rates, and sample values — without reading a single row into context. _meta.tokens_saved reports what that cost against loading the file.
Next step: describe_column for a distribution on one column, or aggregate to group and count server-side.
What you can do
Orient in a dataset you have never seen.
describe_dataset,describe_column,sample_rows,get_distribution,get_correlations.Query without loading rows.
get_rowswith filters,aggregatewithgroup_by,run_sql, andplan_queryto preview cost before running.Work across datasets.
suggest_joins,suggest_keys,join_datasets.Find data-quality problems.
get_dataset_health,data_health_radar,get_data_hotspots(null rate, cardinality anomalies, outlier spread),get_schema_drift,find_unused_columns.Preflight schema changes.
check_column_drop_safeandget_schema_impactbefore you drop or rename.Search semantically.
search_dataandfind_similar_columnswhen you know what you mean but not what it is called.Index from GitHub.
index_repopulls CSV, Excel, Parquet, and JSONL straight from a repository, incrementally by HEAD SHA, private repos included.
39 tools in total. Full reference: USER-MANUAL.md.
How it works
Everything runs locally. The dataset is profiled on your machine and the index is stored on your machine; no hosted service is involved in indexing or querying.
data.csv ──► profiler ──► column stats + local index
│
MCP client ◄── query ─┘ (filters, aggregates, joins
execute server-side)Aggregations and filters run against the stored data rather than being simulated in the model, which is why the row count barely affects the token cost of an answer. Sampling-based statistics report their error bounds (roughly 2% standard error) rather than presenting an estimate as exact.
Supported formats
Format | Extensions | Install extra |
CSV / TSV |
| built in |
JSON Lines |
| built in |
Excel |
|
|
Parquet |
|
|
Security and privacy
Local-first. Your data is profiled and indexed on your machine and is not uploaded.
The base package's only default network behavior is an anonymous savings counter — a random ID plus aggregate token counts. No data, no column names, no file paths, no PII. Opt out completely:
JDATAMUNCH_SHARE_SAVINGS=0index_repo reaches GitHub only when you invoke it, using a token you supply. Embedding providers are called only when you configure one. There is no scheduler and no background reporting.
Full detail, including what each optional extra pulls in: SECURITY.md.
Limitations
Savings scale with file size. On a small spreadsheet the difference is negligible; the benchmark figures come from a 255 MB file.
Sampled statistics are sampled. Distribution and correlation figures on very large files carry a stated error bound rather than being exact.
Excel and Parquet need optional extras, which pull additional dependencies.
A default
describe_columnwill not be labelledoffloadable. jDataMunch does not assert index freshness it cannot prove, so the cheap freshness reading answersunknownand the annotation fails closed. That is deliberate — see the annotation section.jDataMunch does not read code or prose. Code symbols belong to jcodemunch-mcp; documentation sections to jdocmunch-mcp.
Offloadable-work annotation
JMUNCH_OFFLOADABLE=1 (suite-wide) or JDATAMUNCH_OFFLOADABLE=1 (this server only) makes describe_column carry an advisory _meta.offloadable block marking whether the answer is simple and self-contained enough to hand to a cheaper model.
It is a label and nothing else. jDataMunch never calls another model, never routes the request, and never touches your API keys. Off by default; you decide what happens next.
The verdict is tri-state and reason-coded: not_evaluated ("we did not assess it") is not not_offloadable ("this is not simple work"). It fails closed — any unknown bearing on the answer disqualifies, because a false offloadable sends real work to a model that will confabulate over the gap. verify_with names the call that would adjudicate a cheaper model's answer.
Identical field contract across all three jMunch servers, with a pinned contract digest that fails the build in any one of them that drifts.
Documentation
Doc | What it covers |
Zero-to-indexed in three steps | |
Full guide for analysts, ops, and non-developers | |
Data handling, network behavior, vulnerability reporting | |
How the benchmark is run and what it measures | |
Development setup and the CLA requirement | |
Release history |
Licensing and commercial use
Released under the jDataMunch-MCP Dual-Use License (full terms). Free for non-commercial use. Commercial use requires a paid license, one-time, sold by jMunch LLC.
jDataMunch only: Builder, $39 (1 developer) · Studio, $149 (up to 5) · Platform, $499 (org-wide internal deployment)
Full jMunch suite (code + docs + data): Trio Builder, $99 · Trio Studio, $449 · Trio Platform, $2,499
Personal and other non-commercial use is free. Work use at a for-profit company, or for client or paid work, needs a license, paid once.
Support and project status
Actively maintained. Issues and bug reports: GitHub Issues. Commercial licensing questions go through jcodemunch.com.
Part of the jMunch suite alongside jcodemunch-mcp (code symbols) and jdocmunch-mcp (documentation sections). All three implement jMRI, the open retrieval interface spec — same response envelope, same token accounting.
Available Tools
39 toolsaggregateARead-only
Server-side aggregations (GROUP BY). Saves orders of magnitude in tokens vs returning rows for the LLM to aggregate. Functions: count, sum, avg, min, max, count_distinct, median. limit capped at 1000.
Inputs: dataset (required), aggregations (required), limit, having, +8 more.
analyze_perfARead-only
Per-tool latency and cache-hit telemetry. Returns p50/p95/max latency and error rate per tool, the slowest tools by p95, and result-cache hit rates (aggregate / get_correlations / get_data_hotspots are the cached tools). window=session reads the always-on in-memory ring; window=1h/24h/7d/all reads the persistent SQLite sink (requires JDATAMUNCH_PERF_TELEMETRY=1). Sibling of jcodemunch / jdocmunch analyze_perf.
Inputs: top, tool, window.
check_column_drop_safeARead-only
Composite preflight: is this column safe to drop? Fuses four signals — primary-key status, foreign-key participation, cross-dataset name match, and runtime traffic — into a single verdict plus ranked blockers and a recommended_action. Verdict tiers: pk_blocking, fk_blocking, runtime_observed, cross_dataset_blocking, safe_to_drop. Read-only. The killer feature of the Phase-1 sibling-parity batch.
Inputs: column (required), dataset_id (required), window_days.
check_embedding_driftA
Detect whether the embedding provider has drifted since it was pinned. Column embeddings power semantic search_data and find_similar_columns; if the provider model changes underneath a stored index, saved vectors stop matching the live encoder and semantic ranking quietly degrades. Pins a 16-string canary in <index_path>/embed_canary.json and recomputes it on demand, reporting cosine drift. Call with force=true once to set the baseline, then again after a suspected provider change. Sibling of jcodemunch / jdocmunch check_embedding_drift.
Inputs: force, threshold.
data_health_radarARead-only
Six-axis health radar for a dataset: null_health, type_confidence, cardinality_health, pk_presence, semantic_coverage, schema_stability (omitted when <2 history snapshots). Optional 7th axis runtime_coverage when traces ingested. Returns 0-100 score per axis + composite + A-F grade. Pairs with diff_data_health_radar for snapshot deltas. Mirrors jcm's six-axis health radar.
Inputs: dataset (required), window_days, include_runtime.
delete_datasetA
Delete an indexed dataset and its SQLite store. Frees disk space. Irreversible — the dataset must be re-indexed to use again.
Inputs: dataset (required).
describe_columnARead-only
Deep profile of a single column. Full value distribution for low-cardinality columns, histogram bins for numeric, temporal range for datetime. Default detail='compact' gives counts, range or stats, and top values as [value, count] pairs; detail='full' adds samples, percentages and a summary. top_n capped at 200; histogram_bins capped at 50.
Inputs: column (required), dataset (required), top_n, detail, +3 more.
describe_datasetARead-only
Primary orientation tool. Default detail='compact' returns one row per column: name, type, null%, distinct count, and the min/max (numbers, dates) or most frequent values (text; every value when 10 or fewer), plus date formats and unique columns. detail='full' adds samples, top values with counts, mean, median and summaries. Statistics come from the index, not a re-read of the source. On wide tables (60+ columns), results are auto-paginated — use columns=[] to select specific ones, or columns_offset to page through remaining columns.
Inputs: dataset (required), detail, columns, columns_offset.
diff_data_health_radarARead-only
Diff two data_health_radar payloads. Pure function — pass the radar sub-field from two data_health_radar responses (e.g. yesterday vs today). Returns per-axis deltas, composite delta, grade change, regression and improvement lists (threshold: 3 points), one-line verdict.
Inputs: current (required), baseline (required).
embed_datasetA
Precompute column embeddings for semantic search. Optional warm-up — search_data with semantic=true lazily embeds on first use. Running embed_dataset upfront eliminates that latency. Requires an embedding provider (JDATAMUNCH_EMBED_MODEL, GOOGLE_API_KEY, or OPENAI_API_KEY).
Inputs: dataset (required), force.
finalize_handoffA
Finalize one canonical Markdown handoff for a completed data audit/analysis (jdatamunch.handoff/v1; suite parity with jCodeMunch). The server assembles YOUR sections deterministically, validates every evidence_refs entry against what this session actually retrieved (column ids like '::#column' or dataset names served by search_data / describe_dataset / describe_column — unknown refs fail closed), persists the result session-scoped, and returns a compact receipt {handoff_id, resource_uri, sha256, length, canonical:true}. Read the immutable body via the munch://handoff/ resource; repeated reads are byte-identical. Appendices are included exactly once; no character limit; never writes to your data.
Inputs: task (required), dataset (required), sections (required), evidence_refs (required), +2 more.
find_similar_columnsARead-only
Multi-signal cross-dataset column consolidation. Fuses name (token Jaccard), type, top-value overlap, cardinality similarity, and (when present) embedding cosine into a composite score. Clusters via union-find and classifies each cluster: near_duplicate, naming_drift, parallel_definition, or overlapping_topic. Use to find duplicate columns across datasets, surface naming drift (email vs email_address), or detect the same conceptual column spread across multiple datasets. Mirrors jcm's find_similar_symbols. Every signal is heuristic, so a high score means investigate, not merge.
Inputs: top_n, datasets, min_score, same_type_only.
find_unused_columnsARead-only
Surface columns with zero or stale runtime traffic. Reads runtime_query_calls (populated by ingest_sql_log) and surfaces columns that haven't been queried within window_days. Excludes primary-key candidates and audit fields (created_at / updated_at / dbt_*) by default. Refuses to run with explicit error when no runtime data has been ingested — would otherwise trivially flag every column.
Inputs: dataset_id (required), min_calls, exclude_pk, window_days, +1 more.
get_correlationsARead-only
Compute pairwise Pearson correlations between numeric columns. Returns pairs sorted by |r| descending, filtered to significant correlations. Use this to discover relationships in the data without manual exploration. top_n capped at 200.
Inputs: dataset (required), top_n, method, columns, +1 more.
get_data_hotspotsARead-only
Return the highest-risk columns in a dataset ranked by a composite score combining: null rate, cardinality anomalies, numeric outlier spread, and (v1.10.0) runtime traffic from runtime_query_calls when traces exist. When include_runtime is true but no traces are ingested, the response carries an honest-hint caveat in _meta.runtime_caveat rather than silently scoring on static signals alone. top_n capped at 50.
Inputs: dataset (required), top_n, window_days, include_runtime.
get_dataset_healthARead-only
Composite quality grade (A–F) for a dataset (B4). Combines null severity, type-confidence, constant-column count, primary-key presence, semantic-typing coverage, and drift history into a single score with a structured breakdown. Grades structure and completeness, not whether the values are right.
Inputs: dataset (required).
get_dataset_historyARead-only
Return the last N profile snapshots for a dataset. Snapshots are appended on every successful index_local — use this to detect schema/content drift over multiple ingests of the same dataset. n capped at 50.
Inputs: dataset (required), n.
get_distributionARead-only
Unified bin-counts for any column type (B8). Numeric → equal-width bins between min/max; datetime → time-bucket bins; categorical / string → top-n + 'other' bucket. Token-cheap way to ask 'what does this column look like?'. Bin counts only (default 20 bins); it never returns the underlying rows.
Inputs: column (required), dataset (required), bins.
get_redaction_logARead-only
Forensic accounting of PII redactions for a dataset. Returns per-pattern counts from runtime_redaction_log (populated by ingest_sql_log with redact=True), so operators can verify the chokepoint is firing on production traffic. Filter by source and lookback window. Empty result with no traces ingested is not an error — it just means no scrubbing has happened yet.
Inputs: dataset_id (required), source, since_days.
get_rowsARead-only
Filtered row retrieval via structured filters. All filters are SQL-parameterized (no injection). Operators: eq, neq, gt, gte, lt, lte, contains, in, is_null, between. Use columns=[] to project — reduces tokens significantly on wide tables. Prefer aggregate() for summaries over paginating through rows. Rows come back as arrays under a 'fields' header (row_format='objects' for dicts). Returns at most limit rows (default 50); page with offset instead of raising it.
Inputs: dataset (required), limit, offset, redact, +7 more.
get_schema_driftARead-only
Compare schema (columns, types, nullability) between two indexed datasets. Detects added/removed columns, type changes, and null-rate shifts. Pure in-memory comparison — no re-reading source files. Useful for detecting schema changes between dataset versions. Assessment: 'identical' | 'additive' (only additions) | 'breaking' (removals or type changes).
Inputs: dataset_a (required), dataset_b (required).
get_schema_impactARead-only
Transitive impact of a column-level schema change (drop_column, rename_column, retype_column). Walks the inferred FK graph to max_depth, surfaces direct + transitive hits across datasets, and normalises blast_score to [0, 1]. For retype_column, also flags type_mismatch entries at FK edges whose partner type wouldn't survive the retype. Read-only.
Inputs: column (required), dataset_id (required), kind, new_name, +3 more.
get_session_statsARead-only
Return cumulative token savings and cost avoided across all tool calls. Savings are modelled estimates, not per-call measurements.
Inputs: no named parameters.
index_localA
Index a local data file (CSV, Excel, Parquet, or JSONL). Profiles all columns, detects types, computes statistics, and loads rows into SQLite for fast filtered retrieval. Set incremental=true (default) to skip re-indexing if file is unchanged. CSV, Excel, Parquet and JSONL only; any other format is rejected.
Inputs: path (required), name, depth, sheet, +4 more.
index_repoA
Index data files from a GitHub repository. Discovers CSV, Excel, Parquet, and JSONL files, downloads them, and indexes each via the same pipeline as index_local. Datasets are named {owner}--{repo}--{filename}. Max 50 MB per file, 20 files per repo. Set GITHUB_TOKEN env var for private repos or to avoid rate limits.
Inputs: url (required), incremental, github_token.
ingest_sql_logA
Ingest a SQL log file (pg_stat_statements CSV or generic JSONL, .gz transparently) into the per-dataset runtime tables. Each query is parsed for table + column refs, redacted at the chokepoint (string + numeric literals + cell-PII registry), and rolled up into runtime_query_calls keyed by (fingerprint, table, column). Tables in the log that don't match any indexed dataset count as unmapped. Foundational primitive for find_unused_columns, check_column_drop_safe, and data_health_radar (v1.6.0 sibling-parity Phase 1).
Inputs: file_path (required), redact, source, max_rows.
jdatamunch_guideARead-only
Return the version-current CLAUDE.md / AGENT.md policy snippet for jdatamunch-mcp. Lets an agent keep a one-line CLAUDE.md (e.g. "Call jdatamunch_guide and strictly follow its instructions.") instead of pasting a static snippet that drifts from the installed version. Idempotent, no dataset context required. Sibling of jcodemunch_guide and jdocmunch_guide.
Inputs: no named parameters.
join_datasetsARead-only
Join two indexed datasets via SQL JOIN. Uses ATTACH DATABASE to combine two SQLite stores into one query. Supports inner, left, right, and cross joins. Use columns_a/columns_b to project — reduces tokens on wide tables. Row limit capped at 500. Prefer aggregate() on join results for summaries.
Inputs: dataset_a (required), dataset_b (required), join_column_a (required), join_column_b (required), +9 more.
list_datasetsARead-only
List every indexed dataset with its row count, column count, and source file. Call it first to find the dataset name every other tool needs, and to confirm a file was actually indexed. Lists only datasets under the active storage_path.
Inputs: no named parameters.
list_reposARead-only
List GitHub repositories indexed via index_repo. Shows repo name, HEAD SHA, dataset count, total rows, and dataset names for each repo. Covers repos indexed with index_repo only; a dataset added by index_local is not listed here.
Inputs: no named parameters.
plan_queryARead-only
Map a natural-language intent into a ranked tool-call sequence for the given dataset (B3). Pure routing — no LLM call. Built-in intents: summarize, anomalies, compare, join, filter, trend, correlate.
Inputs: dataset (required), intent.
run_sqlARead-only
Read-only sandboxed SQL escape hatch (B1). Accepts a single SELECT (or WITH … SELECT) statement. The first dataset is the main connection; additional datasets are ATTACHed under schema names (e.g. <dataset>.rows). Statement runs under PRAGMA query_only=1 with a 10-second budget and 500-row cap. Use this for HAVING / window functions / CTEs / multi-way joins that the structured tools don't cover.
Inputs: sql (required), datasets (required), limit, redact, +2 more.
sample_rowsARead-only
Return a sample of rows. Useful for understanding data shape without prior knowledge. Method: 'head', 'tail', or 'random'. Use columns=[] on wide tables to reduce response size. Pass seed (int) with method='random' for deterministic, reproducible sampling. A sample shows shape, not distribution; use get_distribution when you need the spread.
Inputs: dataset (required), n, seed, method, +4 more.
search_dataARead-only
Search across column names and values. Returns column-level results with IDs — tells you where to look, not the data itself. Use before get_rows or describe_column. max_results capped at 50. Set semantic=true for embedding-based search (requires an embedding provider: JDATAMUNCH_EMBED_MODEL, GOOGLE_API_KEY, or OPENAI_API_KEY).
Inputs: query (required), dataset (required), semantic, max_results, +3 more.
suggest_joinsARead-only
Discover FK candidates between this dataset and other indexed datasets (B5). For each non-PK column in the source, scans up to 20 other datasets' PK candidates and proposes joins where containment ≥ 95%. Sample-based (500 distinct values per source column).
Inputs: dataset (required).
suggest_keysARead-only
Rank primary-key candidates for a dataset (B5). Each entry carries a confidence score plus the reasons that raised it (integer column, UUID format, no nulls, exact-count unique). Candidates are ranked from profile statistics, so confirm against the source system before treating one as the key.
Inputs: dataset (required).
summarize_datasetA
Generate natural-language summaries for a dataset and all its columns. Works on already-indexed datasets — reads profiles from index.json, generates summaries, and writes them back. No re-parsing of source files. Summaries are also auto-generated during index_local.
Inputs: dataset (required).
tune_weightsA
Inspect, set, or reset the weight vector search_data uses to rank columns (name/value/type match weights plus the BM25 and semantic blend scales). Omit all args to inspect the effective weights and their source. Pass set_weights (a {weight: number} object) to override, or reset=true to clear. Scope with dataset (per-dataset overrides win over the global default, which wins over built-ins). Honored by search_data at query time. Unlike jcodemunch/jdocmunch, weights are tuned explicitly here (no ranking ledger). Tunable: name_exact, name_substr, name_word, ai_summary_word, value_exact, value_substr, type_boost, bm25_scale, semantic_scale, default_semantic_weight. Affects search_data ranking only; no other tool reads these weights.
Inputs: reset, dataset, set_weights.
validate_indexARead-only
Verify an indexed dataset's on-disk integrity. Runs SQLite PRAGMA integrity_check, cross-checks row count and column list against index.json, and verifies index.json content hash. Reports stale-lock state from interrupted index_local runs. Returns overall_status: 'ok' | 'warning' | 'error'. Checks the integrity of the index, never the correctness of the underlying data.
Inputs: dataset (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 39 tools
The descriptions are unusually explicit about boundaries (cross-referencing siblings, stating 'use before X', 'pairs with Y'), but several clusters still overlap: get_dataset_health vs data_health_radar vs get_data_hotspots, and describe_dataset vs describe_column vs get_distribution vs sample_rows all answer variations of 'what is in this data?' An agent can be steered wrong when it just wants a quick column or health readout.
Almost everything is snake_case with a verb_noun shape (list_datasets, get_rows, suggest_joins, delete_dataset, validate_index, run_sql). The deviations are minor: a few noun-first tools such as data_health_radar and diff_data_health_radar sit alongside get_dataset_health, and bare verbs like aggregate and sample_rows lack a resource noun.
39 tools is well past the comfortable range and the surface spans many sub-domains: indexing, profiling, search, SQL, joins, schema drift, health, runtime-log ingestion, embeddings, telemetry, handoff. Individual tools are justified, but the breadth forces agents to triage a large catalog before acting.
Coverage is broad and near-complete: index (local + repo), describe, search, filter, aggregate, join, raw SQL escape hatch, schema drift/impact, health, delete, integrity validation, embeddings and handoff. Gaps are minor — no repo-level unindex, no dataset rename/metadata update, and no export of results back out.
Maintenance
Related MCP Connectors
Query, join, profile, clean and convert CSV/JSON/Parquet with server-side DuckDB over MCP.
Token-free MCP server for structured RevoGrid Core, Pro, and Enterprise knowledge retrieval.
ParseHub.dev is a hosted document-to-records service with a remote MCP server. Agents can upload a CSV, PDF, or Word file, summarize and analyze CSV data (filter, sort, group_by, and more), read text from PDF and Word files, extract attendees, agenda items, and action items from meeting notes, ask a question about an uploaded document, and store files as database records to list and read later. Each account sees only its own files and records. **Endpoint:** `https://parsehub.dev/mcp` (Streamable HTTP, stateless) **Auth:** API key in the `X-API-Key` header (keys start with `mcp_`), or `Authorization: Bearer <API key or JWT>`. Every request without credentials returns 401. **Plans:** Free (100 API requests/month, 1 document upload), or 5,000 requests/month on the $9/month or $42/year plan. Every MCP request counts toward the allowance. **Tools:** upload_csv, summarize_csv, analyze_csv, upload_document, read_document, extract_meeting_notes, ask_document, database_status, list_database_documents, get_database_document, store_document, extract_stored_meeting_notes, export_database (administrators only). Not affiliated with ParseHub (parsehub.com), the web-scraping tool. ParseHub.dev does not scrape websites. By Poietes LLC. Docs: https://parsehub.dev/guide#connect-via-mcp
Teable is an AI spreadsheet for business that combines a familiar spreadsheet interface with a structured database. Its remote MCP server lets AI agents inspect project and table structure, read and update records, and access the Teable API through OAuth with existing project permissions. Website: [teable.ai](https://teable.ai)
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn MCP server that provides AI assistants with structured, type-safe access to tabular datasets from CSV files. It enables users to list, describe, and query data using filters and projections with support for hot reloading.MIT
- AlicenseAqualityNot gradedmaintenanceAn MCP server that enables AI assistants to load, query, and analyze local CSV files using tools for filtering, aggregation, and grouping. It provides capabilities to describe schemas, calculate statistics, and sample data directly from CSV files.6-
- AlicenseNot gradedqualityDmaintenanceMCP server that turns Excel files into queryable databases, enabling AI agents to filter, aggregate, group, sort data and export results as new Excel files.2MIT
- FlicenseNot gradedqualityDmaintenanceAn MCP server that answers natural-language questions over CSV, Excel, and SQL data by providing deterministic tools for loading, profiling, querying, cleaning, statistical analysis, visualization, and reporting. It enables LLMs to plan and interpret while all computation is done exactly through MCP tools.-