An AI agent can write SQL, draft an email, and refactor a repo. Ask it to deduplicate a 50,000-row customer file and it will cheerfully hand you a pandas.drop_duplicates() one-liner that finds zero matches. The model knows the concept. It does not know your data, and it has no tool that actually solves entity resolution.
The Model Context Protocol (MCP) is the missing wire. It lets a host like Claude Code, Cursor, or any agent runtime call real tools running on your machine — with real schemas, real parameters, and real results. Golden Suite was built as a set of composable Python packages from day one, which makes it a near-perfect fit. This post walks through how we expose Golden Suite over MCP, what that unlocks for AI workflows, and where the roadmap goes from here.
What MCP actually is
MCP is a thin JSON-RPC protocol that standardises three things between an AI host and an external server:
-
Tools — typed functions the model can call (
goldenmatch.dedupe,infermap.map_schema) - Resources — readable artifacts the model can pull into context (a sample of a CSV, a profiling report)
- Prompts — pre-baked instruction templates the host can offer the user
The host handles the LLM. The server handles the work. The contract between them is a stable schema, which means the same Golden Suite MCP server works in Claude Desktop, Cursor, Continue, or a custom Agent SDK app — without rewriting any glue code.
Why Golden Suite fits
Each Golden Suite package is already a small, well-typed Python API:
| Package | What it does | Natural MCP tool |
|---|---|---|
| infermap | Schema mapping between source and target | map_schema(source, target) |
| GoldenCheck | Profiling and data quality scanning |
profile(path), quality_report(path)
|
| GoldenFlow | Auto-transformation of messy values | clean(path, rules?) |
| GoldenMatch | Entity resolution and deduplication | dedupe(path, config?) |
| GoldenPipe | Orchestrates the full pipeline | run_pipeline(path) |
Wrapping these as MCP tools is mostly metadata — the underlying functions already accept paths, return structured results, and stream progress. A minimal server looks like this:
from mcp.server.fastmcp import FastMCP
from goldenmatch import dedupe
from infermap import map_schema
from goldenpipe import run_pipeline
mcp = FastMCP("golden-suite")
@mcp.tool()
def goldenmatch_dedupe(path: str, threshold: float = 0.85) -> dict:
"""Deduplicate a CSV using fuzzy entity resolution."""
result = dedupe(path, threshold=threshold)
return {
"input_rows": result.input_rows,
"clusters": result.clusters,
"golden_records": result.golden_records,
"match_rate": result.match_rate,
}
@mcp.tool()
def infermap_map(source_csv: str, target_schema: str) -> dict:
"""Map columns from a source CSV to a target schema."""
return map_schema(source_csv, target_schema).to_dict()
@mcp.tool()
def goldenpipe_run(path: str) -> dict:
"""Run profile → clean → dedupe in one shot."""
return run_pipeline(path).summary()
if __name__ == "__main__":
mcp.run()
Drop that into a Claude Desktop config and the model now has hands.
What this actually unlocks
The interesting part is not "Claude can call dedupe." It is what happens when a planning model can chain these tools against real files in a single conversation.
1. Conversational data cleaning
A user drags a CSV into Claude and says "make this usable." The agent calls goldencheck_profile, sees 18% missing zip codes and three different date formats, calls goldenflow_clean, then goldenmatch_dedupe, and reports back: "5,426 rows in, 4,891 golden records out, 535 fuzzy duplicates merged. Here are 12 clusters that look low-confidence — want to review them?" No code written, no docs read.
2. Schema mapping inside an ETL agent
Today, mapping a vendor's cust_id to your customer_id is a human-in-the-loop chore. With infermap exposed over MCP, an agent building an ingestion pipeline can call infermap_map(source, target), get a confidence-scored mapping, and only ask the human about the columns it isn't sure about. The boring 80% disappears.
3. Reverse ETL where the AI is the ETL
Once the agent can both map and match, it can take an arbitrary file and merge it into an existing identity store without a pre-written job. That is the underlying bet behind Golden Suite — an autonomous identity layer — and MCP is the surface that lets the agent reach it.
4. Honest accuracy reporting
Because the tools return structured results (cluster counts, match rates, confidence histograms), the model can quote real numbers instead of inventing them. When an agent says "I deduplicated this," you can verify the claim against the tool output. That is a much better story than "trust the LLM."
What stays hard
MCP does not solve everything. A few things still need care:
- Resource limits. Running a 401K-row dedup inside an interactive chat session is a great way to OOM your laptop. The server has to enforce row limits or stream to a background job.
-
Auth and scoping. An agent with a
dedupe(path)tool can read any file the server can read. Path allowlists matter. - Determinism. LLM-boost paths use embeddings and an LLM tiebreaker — runs need to be reproducible enough that "the agent did it" is auditable.
- Cost visibility. When the agent triggers a paid LLM-boost step, the user should see it before it happens, not after.
None of these are MCP problems specifically — they are the same problems any agent-callable tool has — but they shape how the server gets built.
Future direction
The MCP server is the front door. The interesting roadmap is what sits behind it.
Phase 2 — Identity Store as a resource. Once the persistent identity store lands, MCP exposes it as a resource the agent can read from and write to. An agent ingesting a new file does not just dedupe within the file — it merges into the canonical store and gets back stable IDs.
Conversational correction. The paid Golden Suite features are built around correcting the model's mistakes in natural language ("merge these two clusters", "split this one"). MCP makes this a first-class loop: the agent surfaces low-confidence clusters as a prompt, the user corrects them in chat, and the corrections feed back into the matcher's learned config.
Ingestion connectors as MCP tools. The Phase 2 ingestion layer (warehouses, databases, SaaS APIs) becomes a family of MCP tools — snowflake_pull, salesforce_pull, postgres_pull — that hand data straight into the existing pipeline tools. The agent can then say "pull yesterday's leads from Salesforce, dedupe against the identity store, and push the merges back." End-to-end, with no glue code.
Multi-agent pipelines. Once each step is an MCP tool, you can run a planner agent that decomposes a high-level goal ("clean and merge all of Q1's vendor files") into parallel sub-agents, each calling the same Golden Suite server. The server becomes the shared substrate; the agents become disposable.
Public hosted MCP endpoint. Long-term, a hosted Golden Suite MCP server means you don't have to install anything — point your agent host at a URL, authenticate, and you have a data cleaning toolkit. That is the Golden Suite product surface in one sentence.
Key takeaways
- MCP is the standard wire between AI hosts and real tools — it removes the per-host glue code.
- Golden Suite's package boundaries map almost one-to-one onto MCP tools.
- The unlock is not "Claude can call dedupe" — it is conversational, end-to-end data cleaning where the agent chains profile → clean → match → merge against real data.
- The roadmap points at the identity store, conversational correction, ingestion connectors, and a hosted endpoint — each one extends what an agent can do without leaving the chat.
Try it
Golden Suite is on PyPI today — pip install goldenmatch, pip install infermap, pip install goldenpipe. The MCP server wrapper is the thinnest layer on top, and if you want to point Claude Desktop or Cursor at a local Golden Suite install, the snippet above is a working starting point. Star the repo, try the live tools in the playground, and if you want an MCP-first workflow shipped sooner rather than later — let me know what you would call first.
Originally published at https://bensevern.dev
Top comments (0)