# haiiibin/data-profiler-mcp [Health: Active]

**Category:** 🧮 Data Science Tools  
**Repository:** https://github.com/haiiibin/data-profiler-mcp  
**GitHub Stars:** 2  
**Views:** 4  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/haiiibin-data-profiler-mcp

## Description
Profiles tabular data files (CSV, TSV, Parquet, Excel, JSON) for LLM agents: one-call dataset overview, per-column statistics, a data-quality audit (missing values, duplicates, mixed types, outliers), and memory-saving dtype suggestions. Pure Python (pandas); files are read locally and nothing leaves your machine. pip install data-profiler-mcp.

## Tools
Capabilities this server exposes over MCP:

- **profile_dataset** — Profile a tabular data file in one call: the fastest way to understand a dataset.

    Reads the file at ``path`` (CSV, TSV, Parquet, Excel or JSON/JSONL, detected
    from the extension) and returns a structured overview:

    - file metadata (format, size),
    - shape (row and column counts, and whether the profile was sampled),
    - total memory footprint,
    - a missing-value summary and a duplicate-row count,
    - a per-column summary (dtype, inferred type, null %, unique %, sample
      values, and basic stats for numeric/datetime columns), and
    - a list of plain-language data-quality flags.

    Use this first whenever a user points you at a data file and wants to know
    what is in it. ``max_rows`` caps how many rows are read (default: up to one
    million); the result flags when the file was larger and the stats are a
    head sample. Pass 0 to remove the cap entirely.
    
- **preview_data** — Peek at actual rows of a data file.

    Returns ``n`` rows (capped at 100) as records. ``mode`` selects which rows:
    ``head`` (default), ``tail``, or ``sample`` (random). Use this to see real
    example values rather than just statistics, for example to check formatting,
    encodings, or how a specific column looks in practice.
    
- **column_stats** — Deep statistical dive on a single column.

    For numeric columns: min/max, mean, std, a full set of percentiles
    (p1/p5/q1/median/q3/p95/p99), skewness, kurtosis, zero and negative counts,
    an IQR-based outlier count with bounds, and a 10-bin histogram. For datetime
    columns: the min and max timestamp. For text/categorical columns: the top
    values with counts and percentages, plus string-length statistics.

    Reach for this after ``profile_dataset`` when one column needs closer
    inspection. Raises an error listing the available columns if ``column`` is
    not found.
    
- **detect_quality_issues** — Run a focused data-quality audit and return issues grouped by severity.

    Detects duplicate rows, all-missing and high-missing columns, constant
    columns, likely identifier columns, numbers stored as text, dates stored as
    text, columns mixing numeric and text values, leading/trailing whitespace,
    and empty (whitespace-only) strings. Each issue carries a column (or ``null`` for
    table-level), an issue code, a severity (``high``/``warning``/``info``), and
    a plain-language explanation.

    Use this when the user cares specifically about cleanliness, is preparing
    data for modeling, or asks "is anything wrong with this data?".
    
- **suggest_dtypes** — Recommend more memory-efficient or more-correct column dtypes.

    For each column, proposes a better dtype when one exists: text that is fully
    numeric to a numeric type, low-cardinality text to ``category``, and
    oversized integer/float columns downcast to smaller types. Reports per-column
    and total estimated memory savings.

    Use this to help a user shrink a DataFrame's memory footprint or fix columns
    that were loaded with the wrong type.
    
- **compare_datasets** — Diff two tabular files: what changed between version A and version B.

    Reports the row-count delta, columns added or removed in B, dtype changes on
    shared columns, and per-column null-rate (and, for numeric columns, mean)
    for both files side by side.

    Use this to compare two snapshots of the same dataset, validate a data
    pipeline's output against a baseline, or check what a transformation changed.
    

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `uvx` (confidence: high):

```json
"mcpServers": {
  "data-profiler-mcp": {
    "command": "uvx",
    "args": ["data-profiler-mcp"]
  }
}
```

## Documentation

## What haiiibin/data-profiler-mcp MCP server does

The haiiibin/data-profiler-mcp MCP server gives an MCP-compatible agent tools for examining tabular files stored on the local filesystem. Supported inputs are CSV, TSV, Parquet, Excel files with `.xlsx` or `.xls` extensions, JSON, and JSON Lines. The server detects the format from the filename and returns JSON-serializable results rather than requiring users to paste dataframe output into a conversation.

A full profile includes file format and size, row and column counts, whether the data was sampled, total memory usage, missing-value totals, duplicate-row counts, and per-column details. Column summaries can include the pandas dtype, inferred type, null and uniqueness percentages, sample values, and basic numeric or datetime statistics. Plain-language quality flags help surface problems found during profiling.

## How it works

The haiiibin/data-profiler-mcp MCP server is implemented in Python with FastMCP and reads data through pandas. Parquet support uses pyarrow, while Excel support uses openpyxl. Results are normalized for JSON output, including NumPy values, timestamps, `NaN`, and infinity values.

`profile_dataset` reads a file and produces the broadest overview in one call. `preview_data` returns actual records from the beginning, end, or a random sample of the file, with a maximum of 100 rows. `column_stats` provides a more detailed analysis for one selected column, including percentiles and IQR outlier counts for numeric data, date bounds for datetime data, or frequent values and string lengths for text.

## Setup and configuration

Python 3.10 or newer is required. Install the package with either of these commands:

```bash
pip install data-profiler-mcp
```

```bash
uv tool install data-profiler-mcp
```

After installation, configure an MCP client to run the `data-profiler-mcp` executable. For Claude Desktop, add a server entry whose command is `data-profiler-mcp`, then restart the application. The repository also documents running from a source checkout with `uv run data-profiler-mcp`, and provides a Claude Code command using `claude mcp add`.

No API key or remote service is required. The server reads files locally and does not write output to disk or send dataset contents away from the machine.

## Tools and capabilities

The haiiibin/data-profiler-mcp MCP server provides these listed tools:

- `profile_dataset`: Create a broad overview, with an optional `max_rows` cap. The default reads up to one million rows; passing `0` removes that cap.
- `preview_data`: Return head, tail, or random records for inspecting real values.
- `column_stats`: Analyze one numeric, datetime, text, or categorical column in detail.
- `detect_quality_issues`: Group findings by high, warning, or info severity. Checks include duplicates, missing or constant columns, likely identifiers, numeric or date text, mixed types, whitespace, and empty strings.
- `suggest_dtypes`: Recommend numeric conversion, categorical types, or smaller integer and float types, with estimated memory savings.
- `compare_datasets`: Compare two files for row-count changes, added or removed columns, dtype changes, and per-column null rates and numeric means.

## Limitations and notes

Profiles may represent only the beginning of a large file when the row cap is reached; the result identifies when sampling occurred. Preview output is capped at 100 rows. The tools operate on paths accessible to the local process, so the MCP client must be able to read the referenced files. The project is MIT licensed.

_Full upstream README: https://allmcps.com/mcp/haiiibin-data-profiler-mcp/readme_