Skip to main content
Glama

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

PyPI version PyPI - Python Version License MCP Local-first

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

describe_dataset → ~892 tokens

~124,000×

Schema + one column deep-dive

Paste 111M tokens

describe_dataset + describe_column → ~1,200 tokens

~93,000×

Filter to matching rows

Load all 1M rows

get_rows with filters → matching rows only

~99%+

Count by category

Return all rows, aggregate in the model

aggregate(group_by=[...]) → 21 rows

~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-mcp

Nothing 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-mcp

Command

Use it when

uv tool install jdatamunch-mcp

You want it resolved once instead of per-launch

pipx install jdatamunch-mcp

You already standardise on pipx

pip install jdatamunch-mcp

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_rows with filters, aggregate with group_by, run_sql, and plan_query to 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_safe and get_schema_impact before you drop or rename.

  • Search semantically. search_data and find_similar_columns when you know what you mean but not what it is called.

  • Index from GitHub. index_repo pulls 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

.csv, .tsv

built in

JSON Lines

.jsonl

built in

Excel

.xlsx, .xls

pip install "jdatamunch-mcp[excel]"

Parquet

.parquet

pip install "jdatamunch-mcp[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=0

index_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_column will not be labelled offloadable. jDataMunch does not assert index freshness it cannot prove, so the cheap freshness reading answers unknown and 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

QUICKSTART.md

Zero-to-indexed in three steps

USER-MANUAL.md

Full guide for analysts, ops, and non-developers

SECURITY.md

Data handling, network behavior, vulnerability reporting

benchmarks/METHODOLOGY.md

How the benchmark is run and what it measures

CONTRIBUTING.md

Development setup and the CLA requirement

CHANGELOG.md

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 tools
aggregateA
Read-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_perfA
Read-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_safeA
Read-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_radarA
Read-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_columnA
Read-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_datasetA
Read-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_radarA
Read-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_columnsA
Read-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_columnsA
Read-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_correlationsA
Read-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_hotspotsA
Read-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_healthA
Read-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_historyA
Read-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_distributionA
Read-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_logA
Read-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_rowsA
Read-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_driftA
Read-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_impactA
Read-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_statsA
Read-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_guideA
Read-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_datasetsA
Read-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_datasetsA
Read-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_reposA
Read-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_queryA
Read-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_sqlA
Read-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_rowsA
Read-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_dataA
Read-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_joinsA
Read-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_keysA
Read-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_indexA
Read-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

    A3.8/5.0

    Scored across 39 tools

    Disambiguation3/5

    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.

    Naming Consistency4/5

    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.

    Tool Count2/5

    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.

    Completeness4/5

    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

    ActivityMaintained
    ResponsivenessLimited data

    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.

      https://mcp.rv-grid.com
    • 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

      https://parsehub.dev/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)

      https://mcp.teable.ai/mcp

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      An 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
    • A
      license
      A
      quality
      Not graded
      maintenance
      An 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
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server that turns Excel files into queryable databases, enabling AI agents to filter, aggregate, group, sort data and export results as new Excel files.
      2
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      An 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.
      -