Hugging Face's logo

Datasets:
happynood
/
quantmcp-results

Languages:
English
Tags:
tool-use
function-calling
mcp
model-context-protocol
benchmark
quantization
License:
Dataset card Files
xet
 Community
quantmcp-results / README.md
happynood's picture
happynood
Upload README.md with huggingface_hub
8ed8eb2 verified
preview code
|
Raw
History Blame Contribute Delete
6.24 kB
metadata 
license: mit
language:
  - en
tags:
  - tool-use
  - function-calling
  - mcp
  - model-context-protocol
  - benchmark
  - quantization
  - leaderboard
pretty_name: QuantMCP Results

QuantMCP Results

Real benchmark results for the QuantMCP benchmark, measuring how quantization degrades LLM function-calling reliability against real, unmodified Model Context Protocol server tool schemas — and whether that degradation matches what QuantCall already measured on curated BFCL/ToolACE schemas. Every row comes from an actual quantmcp run execution against a real, sandboxed MCP server — no fabricated or hand-edited numbers.

Headline finding: Cross-Benchmark Consistency (CBC)

CBC (Spearman rho) = -0.755 (n=8 model×quant pairs, 3 model families) — see data/cbc.json.

QuantCall's BFCL-measured quantization degradation does not reliably carry over to real MCP schemas: the correlation is negative (degradation directions often flip), and it got more negative, not less, as more data was added. With 2 model families (Qwen3-0.6B, Llama-3.2-1B) the estimate was -0.551 (n=6) — itself the product of three increasingly-averaged computations that ranged -0.824 to -0.265 before stabilizing. Adding Qwen3-1.7B as a 3rd family (a real within-family size contrast against Qwen3-0.6B) moved it to -0.755 (n=8): the sign held, the magnitude strengthened. See docs/RUN_REAL.md in the GitHub repo for the full convergence table and honesty caveats — n=8 is still far too few for a rigorous p-value on a Spearman correlation.

Files

File Grain Description
data/raw_results/**/*.result.json + *.manifest.json one pair per real run Every real run this project has produced (96 result files across 3 model families × 4 server tiers, with varying quant/repeat coverage per family — Qwen3-0.6B and Llama-3.2-1B at 4 quant levels with 3 independent repeats on tiers U1-U3, Qwen3-1.7B at 3 quant levels, single run, no fp16 (its bf16 weights don't fit a 4GB card at a usable context length — see docs/RUN_REAL.md)), each with a full manifest (git SHA, config/fixture hashes, hardware fingerprint). The model field is a portable ~/models/... path, not a specific machine's absolute path. Since Phase 7, each file also carries a instances array (one entry per task instance, tagged with the tool it targeted) enabling the per-tool SCI regression below.
data/mcp_runs.csv one row per real run Flattened, path-sanitized view of every raw_results file
data/mcp_tier_breakdown.csv one row per server tier Mean SVR-MCP/TSR/η per tier, annotated with that tier's real Schema Complexity Index (SCI)
data/cbc.json one row per (model, quant) pair Cross-Benchmark Consistency deltas against QuantCall's published BFCL numbers, plus the Spearman rho itself
data/sci_regression.json one row per live tool Per-tool Schema Complexity Index (SCI) paired with its own Δ SVR-MCP (fp16 vs. Q4_K_M), plus an OLS slope and bootstrap 95% CI across all 38 covered tools — the statistically-powered version of the SCI-vs-degradation question that mcp_tier_breakdown.csv's 4-tier view alone can't answer

Schema: data/mcp_runs.csv

Column Type Description
model string Sanitized model name (local GGUF paths stripped to a canonical name — see report/published.py::sanitize_model_name in the GitHub repo)
quant string Quantization level: fp16, Q8_0, Q5_K_M, Q4_K_M (Qwen3-1.7B: Q8_0/Q5_K_M/Q4_K_M only)
tier string MCP server tier: filesystem, git, sqlite, or memory
n int Number of task instances evaluated
svr_mcp float Schema-Validity Rate against the real, live tool schema (SVR-MCP, spec §4.1)
tsr float Task Success Rate — the call was schema-valid and produced the correct outcome (spec §4.2)
vram_gb float Peak VRAM usage in GB for this run
eta float Reliability-per-VRAM: (0.5*svr_mcp + 0.5*tsr) / vram_gb
pareto_optimal bool Whether this (model, quant, tier) config sits on the reliability-vs-VRAM Pareto frontier

Schema: data/cbc.json 

{
  "rho": -0.755,
  "n_pairs": 8,
  "table": [
    {"model": "...", "quant": "...", "baseline_quant": "...", "delta_svr_bfcl": ..., "delta_svr_mcp": ...}
  ]
}

delta_svr_bfcl is QuantCall's published BFCL SVR delta vs. that model's own baseline quant (fp16 for every family except Qwen3-1.7B, which uses Q8_0 — see baseline_quant per row); delta_svr_mcp is this project's equivalent delta on real MCP schemas (pooled across all four server tiers, weighted by task count).

Schema: data/sci_regression.json 

{
  "n": 38,
  "slope": 0.045,
  "intercept": ...,
  "slope_ci": [-0.064, 0.170],
  "points": [
    {"tool": "...", "tier": "...", "sci": ..., "delta_svr": ..., "n_baseline": ..., "n_quant": ...}
  ]
}

slope/slope_ci describe the OLS fit of Δ SVR-MCP (fp16 minus Q4_K_M pass rate, pooled across model families weighted by n) against each live tool's own SCI. The 95% CI is a percentile bootstrap over the (SCI, Δ) pairs, not a parametric estimate.

How to Submit

  1. Run the benchmark on your hardware following docs/RUN_REAL.md.
  2. Verify your result.json contains a manifest block with a git SHA and fixture hash.
  3. Open a PR on GitHub adding your result file under results/.
  4. Run quantmcp leaderboard results/ --output-dir leaderboard/ and include the regenerated CSVs in your PR.

Links