# DataRanger (pypi · dataranger)

Read-only data patrol for AI agents: find broken partitions, prove fixes, escalate the rest.

- Trust score: 68/100 (medium)
- Change this week: −11
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- pypi · `dataranger`: 68/100 (this document), [markdown](https://verifymcp.io/servers/akshaysharma1088-dataranger/dataranger.md), [page](https://verifymcp.io/servers/akshaysharma1088-dataranger/dataranger)

## Channel facts

- Registry: `pypi`
- Package: `dataranger`
- Version: `0.6.3`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Supply Chain Security**: 50/100
  - Malware scan not yet available for this package.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs hatchling.build at install time, a recognised build step with no custom scripting around it.
  - 1 of 34 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to akshaysharma1088/dataranger).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 0 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 59/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 4296 tokens (~716/item across 6 items; 6 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 30/100
  - Stability observed for 9 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 6 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 7 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the DataRanger MCP server?

DataRanger runs locally as a PyPI package, launched with uvx dataranger mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add akshaysharma1088-dataranger -- uvx dataranger mcp
```

### Cursor

```json
{
  "mcpServers": {
    "akshaysharma1088-dataranger": {
      "command": "uvx",
      "args": [
        "dataranger",
        "mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "akshaysharma1088-dataranger": {
      "command": "uvx",
      "args": [
        "dataranger",
        "mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add akshaysharma1088-dataranger -- uvx dataranger mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "akshaysharma1088-dataranger": {
      "type": "local",
      "command": [
        "uvx",
        "dataranger",
        "mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add akshaysharma1088-dataranger --command uvx --arg dataranger --arg mcp
```

### Hermes

```yaml
mcp_servers:
  akshaysharma1088-dataranger:
    command: "uvx"
    args: ["dataranger", "mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "akshaysharma1088-dataranger": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "dataranger",
        "mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add akshaysharma1088-dataranger -t stdio -c uvx -a dataranger mcp
```

### Other

```json
{
  "mcpServers": {
    "akshaysharma1088-dataranger": {
      "command": "uvx",
      "args": [
        "dataranger",
        "mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-21 (score 68, −14)

- [security regression] Malware scan: pass → unverified

### 2026-11-20 (score 82, +15)

- [security improvement] Malware scan: unverified → pass
- [functional] Package version: 0.6.0 → 0.6.3
- [functional] Package version: 0.6.0 → 0.6.2

### 2026-11-19 (score 67, +1)

No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-18 (score 66, 0)

- [functional] Package version: 0.5.4 → 0.6.0

### 2026-11-17 (score 66, −14)

- [security regression] Malware scan: pass → unverified

### 2026-11-16 (score 80, +1)

- [functional improvement] Security disclosure: fail → pass

### 2026-11-15 (score 79, 0)

- [functional] Package version: 0.5.1 → 0.5.4
- [functional] Package version: 0.5.1 → 0.5.3

### 2026-11-14 (score 79, +16)

- [security improvement] Malware scan: unverified → pass

## MCP tools (6)

### `patrol_duckdb` (~783 tokens)

Check a fact table in a DuckDB database for data-quality incidents and say which are safe to fix.
A patrol checks every daily partition of the fact table for duplicate keys, duplicate rows, missing
partitions, rows that point to no reference record, null spikes, and row counts or amounts that do not
match the source's control totals. For each problem it proposes a fix, tests that fix on a copy against
the control totals, and decides: "auto-fixed" (proven and low risk), "no action needed" (checked, the
data is right) or "escalate" (a person must decide).

Use this before trusting, querying or building on a date-partitioned table that lives in a DuckDB
database, or after a load or pipeline change to confirm the data is still right. Use patrol_files
instead when the data is in CSV, TSV or Parquet files. Use run_demo to see the output on sample data.

Behavior: The database is opened read-only. Your data is never modified and nothing is written back. The only side effect is
writing four report files to out_dir: dashboard.html, audit.jsonl, incidents.csv, fixed_version.csv
(the proposed corrected table, for review). Runs locally with no network calls;
usually a few seconds, longer for tables with millions of rows. Fails with a readable error if a
file, table or mapped column does not exist; the error lists the columns that are available.

Returns the counts (incidents, auto_fixed, no_action_needed, escalate), needs_a_person (the escalated
incidents), all_incidents (partition, problems, decision, proposed_fix, residual for each) and
outputs (paths to the report files). Pass outputs.folder and a partition to get_incident for the
full evidence behind one decision. Tell the user about every escalated incident.

Input parameters:

- `amount` (string): Numeric amount column in the fact table. It is compared with the 'amount' control total.
- `category`: Optional categorical column in the fact table. Omit if the table has none.
- `date` (string): Date column the fact table is partitioned by, one partition per calendar day. The control totals must have a column with the same name.
- `db` (string, required): Path to the DuckDB database file. Opened read-only.
- `key` (string): Column in the fact table that uniquely identifies a row (the primary key).
- `manifest_table` (string, required): Table of the source system's control totals, one row per date and segment, with columns: the date column, the segment column ('*' = whole day), n (row count) and amount (sum).
- `out_dir`: Folder to write the report files into. Created if missing; report files already there are overwritten. Omit to use a new temporary folder; its path comes back in outputs.folder.
- `ref_key` (string): Column in the reference table that the fact table's reference column must match.
- `ref_table` (string, required): Reference table that fact rows point to, for example customers.
- `reference` (string): Column in the fact table that points to the reference table (the foreign key).
- `segment` (string): Column that splits each day into segments, for example channel or region. The control totals must have a column with the same name, where '*' means the whole day.
- `table` (string, required): Fact table to check, optionally schema-qualified, for example gold.payments.
- `threshold`: Gate threshold: the largest relative gap to the control totals that a verified fix may leave and still be marked auto-fixed (0.01 = 1%). Lower is stricter. Omit for the benchmark-calibrated default,…

Output parameters:

- `all_incidents` (array)
- `auto_fixed` (integer)
- `escalate` (integer)
- `gate_threshold` (number)
- `incidents` (integer)
- `needs_a_person` (array)
- `no_action_needed` (integer)
- `note` (string)
- `outputs`
- `rows_checked` (integer)
- `table` (string)

### `patrol_files` (~817 tokens)

Check a fact table in CSV, TSV or Parquet files for data-quality incidents and say which are safe to fix.
A patrol checks every daily partition of the fact table for duplicate keys, duplicate rows, missing
partitions, rows that point to no reference record, null spikes, and row counts or amounts that do not
match the source's control totals. For each problem it proposes a fix, tests that fix on a copy against
the control totals, and decides: "auto-fixed" (proven and low risk), "no action needed" (checked, the
data is right) or "escalate" (a person must decide).

Use this before trusting, querying or building on a date-partitioned table exported as CSV, TSV or
Parquet files, or after a load or pipeline change to confirm the data is still right. Use
patrol_duckdb instead when the table lives in a DuckDB database. Use run_demo to see the output on
sample data.

Behavior: The three input files are only read. Your data is never modified and nothing is written back. The only side effect is
writing four report files to out_dir: dashboard.html, audit.jsonl, incidents.csv, fixed_version.csv
(the proposed corrected table, for review). Runs locally with no network calls;
usually a few seconds, longer for tables with millions of rows. Fails with a readable error if a
file, table or mapped column does not exist; the error lists the columns that are available.

Returns the counts (incidents, auto_fixed, no_action_needed, escalate), needs_a_person (the escalated
incidents), all_incidents (partition, problems, decision, proposed_fix, residual for each) and
outputs (paths to the report files). Pass outputs.folder and a partition to get_incident for the
full evidence behind one decision. Tell the user about every escalated incident.

Input parameters:

- `amount` (string): Numeric amount column in the fact table. It is compared with the 'amount' control total.
- `category`: Optional categorical column in the fact table. Omit if the table has none.
- `date` (string): Date column the fact table is partitioned by, one partition per calendar day. The control totals must have a column with the same name.
- `facts_file` (string, required): Path to the fact table as .csv, .tsv, .parquet or .pq. One row per event, partitioned by a date column.
- `key` (string): Column in the fact table that uniquely identifies a row (the primary key).
- `manifest_file` (string, required): Path to the source system's control totals as .csv, .tsv, .parquet or .pq: one row per date and segment, with the date column, the segment column ('*' = whole day), n (row count) and amount (sum).
- `out_dir`: Folder to write the report files into. Created if missing; report files already there are overwritten. Omit to use a new temporary folder; its path comes back in outputs.folder.
- `ref_file` (string, required): Path to the reference table that fact rows point to (for example customers), as .csv, .tsv, .parquet or .pq.
- `ref_key` (string): Column in the reference table that the fact table's reference column must match.
- `reference` (string): Column in the fact table that points to the reference table (the foreign key).
- `segment` (string): Column that splits each day into segments, for example channel or region. The control totals must have a column with the same name, where '*' means the whole day.
- `threshold`: Gate threshold: the largest relative gap to the control totals that a verified fix may leave and still be marked auto-fixed (0.01 = 1%). Lower is stricter. Omit for the benchmark-calibrated default,…

Output parameters:

- `all_incidents` (array)
- `auto_fixed` (integer)
- `escalate` (integer)
- `gate_threshold` (number)
- `incidents` (integer)
- `needs_a_person` (array)
- `no_action_needed` (integer)
- `note` (string)
- `outputs`
- `rows_checked` (integer)
- `table` (string)

### `patrol_snowflake` (~941 tokens)

Check a fact table in Snowflake for data-quality incidents and say which are safe to fix.

A patrol checks every daily partition of the fact table for duplicate keys, duplicate rows, missing
partitions, rows that point to no reference record, null spikes, and row counts or amounts that do not
match the source's control totals. For each problem it proposes a fix, tests that fix on a copy against
the control totals, and decides: "auto-fixed" (proven and low risk), "no action needed" (checked, the
data is right) or "escalate" (a person must decide).

Use this before trusting, querying or building on a date-partitioned Snowflake table, or after a load to
confirm the data is still right. Use patrol_dbt instead when the table is built by a dbt model,
patrol_duckdb for a DuckDB file and patrol_files for CSV or Parquet exports. Use run_demo to see the
output on sample data.

Behavior: connects to Snowflake with credentials already configured on this machine; none are passed
as arguments. It runs three SELECT statements and nothing else, so the warehouse is never modified,
and it selects only the mapped columns for the last `days` days, so it uses a little warehouse compute
(usually seconds for 30 days). The only side effect is writing four report files to out_dir:
dashboard.html, audit.jsonl, incidents.csv and fixed_version.csv (the proposed corrected table, for
review). Fails with a readable error if the login is refused, or a table or mapped column does not exist.

Returns the counts (incidents, auto_fixed, no_action_needed, escalate), needs_a_person (the escalated
incidents), all_incidents (partition, problems, decision, proposed_fix, residual for each) and
outputs (paths to the report files). Pass outputs.folder and a partition to get_incident for the
full evidence behind one decision. Tell the user about every escalated incident.

Input parameters:

- `amount` (string): Numeric amount column in the fact table. It is compared with the 'amount' control total.
- `category`: Optional categorical column in the fact table. Omit if the table has none.
- `connection`: Name of a connection in ~/.snowflake/connections.toml. Omit to use the server's SNOWFLAKE_ACCOUNT, SNOWFLAKE_USER, SNOWFLAKE_PASSWORD or SNOWFLAKE_PRIVATE_KEY_PATH, SNOWFLAKE_ROLE and SNOWFLAKE_WAREH…
- `date` (string): Date column the fact table is partitioned by, one partition per calendar day. The control totals must have a column with the same name.
- `days`: Read only the last N days of the fact table and control totals (today counts as day one). Use at least 30 so the checks have a baseline. Pass null to read the whole table, which can be slow and costl…
- `key` (string): Column in the fact table that uniquely identifies a row (the primary key).
- `manifest_table` (string, required): Table of the source system's control totals, one row per date and segment, with columns: the date column, the segment column ('*' = whole day), n (row count) and amount (sum).
- `out_dir`: Folder to write the report files into. Created if missing; report files already there are overwritten. Omit to use a new temporary folder; its path comes back in outputs.folder.
- `ref_key` (string): Column in the reference table that the fact table's reference column must match.
- `ref_table` (string, required): Reference table that fact rows point to, for example ANALYTICS.GOLD.CUSTOMERS.
- `reference` (string): Column in the fact table that points to the reference table (the foreign key).
- `segment` (string): Column that splits each day into segments, for example channel or region. The control totals must have a column with the same name, where '*' means the whole day.
- `table` (string, required): Fact table to check, for example ANALYTICS.GOLD.PAYMENTS. An unqualified name uses the connection's database and schema.
- `threshold`: Gate threshold: the largest relative gap to the control totals that a verified fix may leave and still be marked auto-fixed (0.01 = 1%). Lower is stricter. Omit for the benchmark-calibrated default,…

Output parameters:

- `all_incidents` (array)
- `auto_fixed` (integer)
- `escalate` (integer)
- `gate_threshold` (number)
- `incidents` (integer)
- `needs_a_person` (array)
- `no_action_needed` (integer)
- `note` (string)
- `outputs`
- `rows_checked` (integer)
- `table` (string)

### `patrol_dbt` (~1053 tokens)

Check the table behind a dbt model for data-quality incidents and say which are safe to fix.

A patrol checks every daily partition of the fact table for duplicate keys, duplicate rows, missing
partitions, rows that point to no reference record, null spikes, and row counts or amounts that do not
match the source's control totals. For each problem it proposes a fix, tests that fix on a copy against
the control totals, and decides: "auto-fixed" (proven and low risk), "no action needed" (checked, the
data is right) or "escalate" (a person must decide).

Use this after `dbt build` or `dbt run`, before trusting or publishing a date-partitioned model. It
finds the model's table from dbt's manifest, connects the way the project's profile says (DuckDB,
Snowflake and Postgres targets are supported; BigQuery is experimental), and takes the column mapping from
the model's `meta: dataranger:` block unless you pass columns here. Use patrol_snowflake or patrol_duckdb
for tables that are not dbt models, and patrol_files for CSV or Parquet exports.

Behavior: reads target/manifest.json, dbt_project.yml and profiles.yml; it does not run dbt. It then
runs three SELECT statements and nothing else, so neither the warehouse nor the dbt project is
modified. On Snowflake it selects only the mapped columns for the last `days` days. The only side
effect is writing four report files to out_dir: dashboard.html, audit.jsonl, incidents.csv and
fixed_version.csv (the proposed corrected table, for review). Fails with a readable error if the
manifest is missing (run dbt first), a model is unknown, the target type is not supported, or a
mapped column does not exist.

Returns the counts (incidents, auto_fixed, no_action_needed, escalate), needs_a_person (the escalated
incidents), all_incidents (partition, problems, decision, proposed_fix, residual for each) and
outputs (paths to the report files). Pass outputs.folder and a partition to get_incident for the
full evidence behind one decision. Tell th…

Input parameters:

- `amount`: Numeric amount column of the fact model. Omit to use meta.dataranger.amount, or amount.
- `category`: Optional categorical column of the fact model. Omit to use meta.dataranger.category, or none.
- `date`: Date column the fact model is partitioned by; the control totals need the same column. Omit to use meta.dataranger.date, or txn_date.
- `days`: Read only the last N days of the fact table and control totals (today counts as day one). Use at least 30 so the checks have a baseline. Pass null to read the whole table, which can be slow and costl…
- `key`: Primary key column of the fact model. Omit to use meta.dataranger.key, or txn_id.
- `manifest_model`: dbt model holding the source system's control totals: one row per date and segment ('*' = whole day) with n and amount. Omit if the fact model's meta.dataranger block sets manifest_model.
- `model` (string, required): Name of the dbt fact model to check, for example fct_payments. A seed, snapshot, or a source written as source_name.table_name also works.
- `out_dir`: Folder to write the report files into. Created if missing; report files already there are overwritten. Omit to use a new temporary folder; its path comes back in outputs.folder.
- `profiles_dir`: Folder that holds profiles.yml. Omit to look in DBT_PROFILES_DIR, the project folder, then ~/.dbt.
- `project_dir` (string, required): Path to the dbt project folder, the one that holds dbt_project.yml. It must have been built or parsed, so target/manifest.json exists.
- `ref_key`: Key column of the reference model. Omit to use meta.dataranger.ref_key, or customer_id.
- `ref_model`: dbt model of the reference table that fact rows point to, for example dim_customers. Omit if the fact model's meta.dataranger block sets ref_model.
- `reference`: Fact column that points to the reference model. Omit to use meta.dataranger.reference, or customer_id.
- `segment`: Column that splits each day into segments, such as channel; the control totals need the same column. Omit to use meta.dataranger.segment, or channel.
- `target`: dbt target to read from, for example prod. Omit for the profile's default target.
- `threshold`: Gate threshold: the largest relative gap to the control totals that a verified fix may leave and still be marked auto-fixed (0.01 = 1%). Lower is stricter. Omit for the benchmark-calibrated default,…

Output parameters:

- `all_incidents` (array)
- `auto_fixed` (integer)
- `escalate` (integer)
- `gate_threshold` (number)
- `incidents` (integer)
- `needs_a_person` (array)
- `no_action_needed` (integer)
- `note` (string)
- `outputs`
- `rows_checked` (integer)
- `table` (string)

### `get_incident` (~311 tokens)

Return the full evidence behind one incident from a patrol that has already run.

Use this after a patrol tool (patrol_duckdb, patrol_files, patrol_snowflake, patrol_dbt) or run_demo, when you need to explain why a partition was
auto-fixed or escalated, or to show the user what to review. A patrol records at most one incident per
partition, so the folder plus the partition date identifies it. Do not call it before a patrol.

Behavior: read-only. It reads audit.jsonl in out_dir and changes nothing; no network calls, returns
immediately, and the result is one record of a few kilobytes. Fails with a readable error if the
folder has no audit.jsonl (run a patrol first) or no incident exists for that partition.

Returns one record with: partition, detectors (the problems found), decision, context (row counts and
amounts for the day and for each segment, next to the source's control totals), candidates (every fix
that was tried, with whether it kept the invariants and the residual gap it left) and chosen (the
best-supported candidate).

Input parameters:

- `out_dir` (string, required): The outputs.folder value returned by a patrol tool or run_demo.
- `partition` (string, required): Which incident: the partition date as YYYY-MM-DD, copied from an incident's 'partition' field, or 'table-level' for a problem with the whole table such as a schema change.

### `run_demo` (~263 tokens)

Run a patrol on generated sample data, to see what DataRanger reports without touching real data.

Generates 60 days of synthetic payment transactions with planted problems (duplicates, missing days,
orphan rows, wrong amounts and some harmless decoys), then patrols them exactly as patrol_duckdb and
patrol_files do. Use this to try DataRanger, to show a user the report format, or to test your own
handling of the results. Use patrol_duckdb or patrol_files for real tables.

Behavior: needs no input data, credentials or network. The only side effect is writing the report
files (dashboard.html, audit.jsonl, incidents.csv, fixed_version.csv) to out_dir. Takes a few seconds.

Returns the same summary as the patrol tools: counts, needs_a_person, all_incidents and outputs.
Pass outputs.folder and a partition to get_incident for the evidence behind one decision.

Input parameters:

- `out_dir`: Folder to write the report files into. Created if missing; report files already there are overwritten. Omit to use a new temporary folder; its path comes back in outputs.folder.
- `seed` (integer): Random seed for the generated data. The same seed on the same day gives the same table.

Output parameters:

- `all_incidents` (array)
- `auto_fixed` (integer)
- `escalate` (integer)
- `gate_threshold` (number)
- `incidents` (integer)
- `needs_a_person` (array)
- `no_action_needed` (integer)
- `note` (string)
- `outputs`
- `rows_checked` (integer)
- `table` (string)

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/akshaysharma1088-dataranger/dataranger#diagnostics

## Score history

- 2026-11-21: 68
- 2026-11-20: 82
- 2026-11-19: 67
- 2026-11-18: 66
- 2026-11-17: 66
- 2026-11-16: 80
- 2026-11-15: 79
- 2026-11-14: 79
- 2026-11-13: 63
- 2026-11-12: 78

## Common questions

### What is the DataRanger MCP server?

DataRanger is an MCP server listed in the public MCP registry as io.github.akshaysharma1088/dataranger. Read-only data patrol for AI agents: find broken partitions, prove fixes, escalate the rest. This page covers its PyPI package (dataranger).

### Is the DataRanger MCP server safe to use?

DataRanger scores 68 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 November 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the DataRanger MCP server expose?

DataRanger exposes 6 tools: patrol_duckdb, patrol_files, patrol_snowflake, patrol_dbt, get_incident, run_demo. Their descriptions and schemas cost roughly 4,168 tokens of context every time the server is loaded.

### Is the DataRanger MCP server still maintained?

DataRanger is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the DataRanger MCP server under?

DataRanger declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the DataRanger MCP server?

VerifyMCP ran 15 checks on DataRanger, covering Known CVEs, Install scripts, Dependency health, Source repository and 11 more. One item could not be completed, a gap on our side rather than a finding about DataRanger: Malware scan. Endpoint Security and Transport & Reachability do not apply to a PyPI package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- PyPI project: https://pypi.org/project/dataranger/
- Socket report: https://socket.dev/pypi/package/dataranger
- Repository: https://github.com/akshaysharma1088/dataranger
- Changelog RSS feed: https://verifymcp.io/servers/akshaysharma1088-dataranger/dataranger.xml
- Changelog JSON feed: https://verifymcp.io/servers/akshaysharma1088-dataranger/dataranger/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/akshaysharma1088-dataranger/dataranger.json
- HTML version of this page: https://verifymcp.io/servers/akshaysharma1088-dataranger/dataranger
