A converter behind a protocol, not another SDK
Most MCP write-ups are catalogues: here are forty tools, here is the host, watch the model pick one. The more useful story is the opposite — a server that exposes exactly one tool, does one thing, and gets driven end to end from a real client to see whether it holds up.
That is what happened with Microsoft's markitdown-mcp, a package that puts the open-source MarkItDown document converter behind the Model Context Protocol. The tester installed it into a clean virtual environment, connected a client over STDIO, and made four real conversion calls. One disclosure worth repeating: the author maintains markitdown.tech, a site built on the MarkItDown library but not affiliated with Microsoft; the server under test is Microsoft's own open-source package.
Why it matters beyond one package: the boring plumbing question for every agent project is how the model reads a PDF, a spreadsheet, or a web page. The answer historically has been "write a parser per format, badly, in each app." A single-tool conversion server replaces that with a protocol call.
What the run actually demonstrates

Figure: Editorial context image from the source page (preview only; rights remain with the publisher) · Credit / further reading: dev.to
One tool is a contract, not a limitation
A conversion server that exposes a single tool removes a whole class of agent failure. There is no tool-selection ambiguity, no routing decision for the model to misread, no capability matrix where three of six converters silently do the same thing slightly differently. The contract is narrow: hand it a resource, get text back. Narrow contracts are auditable in a way that forty-tool servers are not — you can read the entire surface in a sitting and reason about what it can and cannot touch.
STDIO is the right default for document work
Binding the server to standard input/output rather than a network socket means it runs as a local process. No listener, no exposed port, no auth layer to get wrong. Documents are frequently the most sensitive material in a workflow — contracts, financials, internal specs — so a local-first transport is not a retrograde choice, it is the correct one. It also makes the whole thing reproducible: the same container, the same call, the same output, which is exactly what distributed teams need when they cannot look over each other's shoulders.
The failure path is the actual specification
The genuinely informative part of running four calls instead of one is that you get to see the server misbehave. Any converter can handle a clean, born-digital PDF. What separates a server you would wire into Claude Desktop or an autonomous agent from a demo is what it returns when the path is wrong, the format is unsupported, or the file is far larger than expected. A structured, human-readable error tells the agent what to do next and lets it recover. A stack trace, an empty string, or a silent success with half the content missing does not fail loudly — it poisons everything downstream.
Why builders should care now
Parser sprawl is a real tax. Every internal tool that "supports document upload" tends to grow its own half-broken extraction path, its own table handling, its own peculiar behaviour on scanned pages. Nobody owns it, and every model-facing feature inherits its bugs.
MCP changes the shape of that work. Adding document support becomes configuration rather than a codebase: point the host at a server, list the tool, done. That is a genuine reduction in maintenance surface — and it is portable. The same server works whether the caller is a desktop assistant, a batch job, or an agent running in a remote engineering pod.
There is a second, quieter benefit: markdown as the interchange format. Models consume markdown far more efficiently than raw HTML or PDF byte streams, and it preserves enough structure — headings, lists, tables — for the model to reason about layout instead of guessing at it. Conversion quality stops being an aesthetic concern and becomes a direct input to token cost and answer quality.
The catch: conversion is lossy, and the loss is silent

Figure: HEXOPS original illustration inspired by the topic (not a copy of the source article imagery) · Credit / further reading: dev.to
Markdown cannot faithfully represent everything. Multi-column PDFs collapse into reading-order mush. Merged table cells flatten. Footnotes detach from their anchors. Scanned pages without an OCR layer come back thin or empty.
In a chat window, a human notices the missing table and re-uploads. In an agent pipeline, a clean-looking markdown blob with a missing column is far more dangerous than an outright error, because nothing in the loop flags it. The server can only be as honest as its output allows — and most converters today do not report what they dropped.
What to watch next
Watch whether MCP conversion servers converge on a shared result schema that carries warnings alongside text — a "converted with caveats" envelope. Watch the security model, too: any server that can fetch a URL is an SSRF surface, and any server that can read a local path is a traversal surface, so host-side permission prompts per tool will matter more than the tool's own code.
Also worth tracking: whether hosts make per-tool permissions visible rather than a single blanket approval at install time; whether servers standardise a version and health handshake so an agent can verify the tool it expects is the tool it got; and whether anyone publishes repeatable benchmarks for conversion fidelity and token savings across common formats, rather than vibes.
Key takeaways
- A single-tool MCP server is a design decision, not a shortfall: narrow contracts are auditable and hard for a model to misuse.
- STDIO transport keeps document conversion local, sandboxed and reproducible — the right default for sensitive material.
- The failure path, not the happy path, determines whether an agent can recover from a bad call.
- Conversion is lossy and silently so; missing structure in clean-looking markdown is a bigger risk than a visible error.
- markdown as the interchange format ties conversion quality directly to token cost and answer quality.
Next steps
- Spin up the server in a throwaway virtual environment and make four calls yourself: a clean PDF, a spreadsheet, an HTML page, and one deliberately broken input.
- Log the response for the broken input. If it is not structured and actionable, wrap it before it reaches an agent.
- Audit what your current pipeline does with a merged-cell table; most silently lose it.
- Treat URL-fetching and local-path-reading as separate permissions when you wire the tool into a host.
- Re-measure token spend on converted documents against raw HTML — the delta is usually the business case.



