Summary: This MCP server converts documents both ways — PDF→Markdown and Markdown→PDF — for use from any MCP client.
(Note: the README also describes assembly-app upload tools — upload_issue, issue_draft, upload_renders, save_login, saved_login — but only the two converters below are present in this server schema.)
convert_pdftomd — turn a PDF into Markdown (headings, lists, tables, images; watermark stripping and optional YAML front-matter). Returns the Markdown text and can also write a .md file via output_path.
convert_mdtopdf — render Markdown (from md_path or raw markdown_text) into a PDF at a required output_path, using a clean print stylesheet, with optional title and custom css. Returns a confirmation with path, byte size, and page count.
Typical uses: extract editable Markdown from a report PDF, or produce a shareable, print-ready PDF from notes — usable by any MCP client such as Claude Code or Claude Desktop.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Assembly MCP Convert the file report.pdf to Markdown and save as report.md"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A small Model Context Protocol server that gives any MCP client (Claude Code, Claude Desktop, …) document-conversion and assembly-app upload tools:
Tool | Direction | Engine |
| PDF → Markdown | assembly-app |
| Markdown → PDF | |
| files → draft issue → issued | assembly-app |
| images → Renders tab | assembly-app |
| Revit DWG → lines on Site → Revit Maps | assembly-app |
convert_pdftomd and the upload tools run the assembly-app CLIs from self-contained bundles in
cli/bin/*.mjs (built by cli/build.mjs), so no assembly-app checkout is needed to use them —
just Node ≥ 22. The bundles talk straight to the app's server (Supabase at newapi-next.assembly.nz)
as the signed-in person. See Building the CLI bundles. convert_mdtopdf renders
Markdown/HTML → PDF with WeasyPrint (pure-Python, no TeX toolchain).
Python ≥ 3.11
uv (recommended) or pip
Node ≥ 22 — runs the bundled CLIs in cli/bin/. convert_pdftomd also needs
cd cli && npm ci --omit=dev once (pdf.js + the native canvas module).
An assembly-app checkout is optional: only used when a bundle is missing (falls back to
<ASSEMBLY_APP_DIR>/apps/frontend/scripts/<name>.ts) and for env="dev" config (its
apps/frontend/.env.local).
WeasyPrint native libraries — only needed for convert_mdtopdf
(convert_pdftomd works without them):
Linux (Debian/Ubuntu): apt install libpango-1.0-0 libpangoft2-1.0-0 libgdk-pixbuf-2.0-0 libffi-dev
macOS: brew install pango gdk-pixbuf libffi
Windows: install the
GTK3 runtime.
Without it, convert_pdftomd still works and convert_mdtopdf returns a
clear "install GTK" error.
Related MCP server: mcp-pdf2md
git clone https://github.com/AssemblyJustin/assembly-mcp.git
cd assembly-mcp
uv sync # creates .venv and installs everythingRun the server directly to confirm it starts (it speaks MCP over stdio and will
wait for a client — Ctrl-C to exit):
uv run assembly-mcpFrom anywhere, register the server (adjust the path to your clone):
claude mcp add assembly -- uv --directory /ABSOLUTE/PATH/TO/assembly-mcp run --no-sync assembly-mcp(--no-sync: on Windows, a second Claude session's uv run otherwise tries to reinstall the
assembly-mcp.exe the first session is running, fails with "file in use", and the server never
connects. Run uv sync yourself after pulling.)
Then the tools are available in your session. This repo also ships matching slash commands — run
Claude Code from inside the repo (or copy .claude/commands/* into your project) to use:
/convert-pdftomd report.pdf report.md
/convert-mdtopdf notes.md notes.pdf
/upload issues
/upload renders
/dwgtogeomapEdit claude_desktop_config.json
(macOS: ~/Library/Application Support/Claude/,
Windows: %APPDATA%\Claude\) and add:
{
"mcpServers": {
"assembly": {
"command": "uv",
"args": ["--directory", "C:\\ABSOLUTE\\PATH\\TO\\assembly-mcp", "run", "--no-sync", "assembly-mcp"]
}
}
}Restart Claude Desktop. The tools appear under the 🔌 tools menu.
convert_pdftomdConvert a PDF file to Markdown. PDF→Markdown runs the assembly-app pdf2md
converter (pdf.js) — headings, lists, ruled tables, images (saved to
<stem>_images/). Requires node ≥ 22 and cli/ installed (npm ci --omit=dev).
Argument | Type | Default | Description |
| string | — | Path to the source |
| string |
| Optional path to also write the |
| bool |
| Kept for compatibility; always on in the unified converter. |
| bool |
| Kept for compatibility; always on in the unified converter. |
Returns the Markdown text (prefixed with a <!-- pdf2md: … --> summary
comment giving page/table/image counts and the output path).
This is a code-only extraction. It does not run vision-based verification, so treat the output as a high-quality first pass, not a certified copy.
convert_mdtopdfConvert Markdown to a PDF file. Provide either md_path or
markdown_text.
Argument | Type | Default | Description |
| string | — | Where to write the |
| string |
| Path to a source |
| string |
| Raw Markdown (alternative to |
| string |
| Document title (falls back to front-matter |
| string |
| CSS to replace the built-in print stylesheet. |
Renders Markdown → HTML → PDF with a clean A4 print stylesheet (tables, code blocks, page numbers) and verifies the PDF magic bytes before writing.
upload_issue / issue_draft / upload_renders / dwg_to_geomapUpload to an assembly-app project as the person doing it. These are thin wrappers over the
assembly-app CLIs upload-issues, upload-renders and upload-dwg-geomap, run from the bundles in
cli/bin/ (node ≥ 22; no checkout). Each signs in as uploader_email, so the database's own
permission rules apply: people can only upload to projects they're on, and viewers and clients can't upload.
The slash command /upload issues / /upload renders (.claude/commands/upload.md) drives them;
/dwgtogeomap (.claude/commands/dwgtogeomap.md) drives dwg_to_geomap.
Tool | Does |
| Files → a draft issue (Transmittal) on the project's Documents tab. Returns |
| Issues that draft (allocates the issue number, which can't be undone). |
| Images → the project's Renders tab. Skips non-images and images already there. |
| A Revit DWG → stored lines on the project's Site → Revit Maps tab. The DWG is converted by civil-map-service ( |
| Checks the login by signing in, then saves it to |
| Who |
uploader_email is optional everywhere: omitted, the tools act as the saved default.
project is the project number (e.g. 2610) or UUID. issue_type is the issue purpose: For
Information / Review / Approval / Construction / Tender / Coordination / Record (or an org's own).
Setup (once per machine):
Login: nothing to do by hand. The first /upload asks for the person's app email + password
once and save_login stores them in ~/.assembly/credentials.json
({"_default": "<email>", "<email>": "<password>"}, several people allowed). After that it never
asks again. ASSEMBLY_PASSWORD still works for scripted use.
Prod: set ASSEMBLY_SUPABASE_ANON_KEY to the prod app's public anon key (URL defaults to
https://newapi-next.assembly.nz; override with ASSEMBLY_SUPABASE_URL).
Dev (env="dev"): read from the checkout's apps/frontend/.env.local.
uv run pytest # smoke tests (PDF→MD skips without node/assembly-app; MD→PDF skips without GTK)Project layout:
src/assembly_mcp/
server.py FastMCP server — registers the tools (stdio); convert_pdftomd
shells out to the assembly-app pdf2md CLI (_app_dir())
md_to_pdf.py python-markdown → WeasyPrint rendering
.claude/commands/ /convert-pdftomd, /convert-mdtopdf, /upload and /dwgtogeomap slash commands
tests/ smoke testsMIT — see LICENSE.
cli/bin/*.mjs are esbuild bundles of the assembly-app operator CLIs (upload-issues, upload-renders,
upload-product, upload-dwg-geomap, upload-artifact, upload-panomap, pdf2md). They are built
from a private repo, so they are gitignored here (this repo is public) and reach the shared copy on
P: through push-to-p.sh. Rebuild after the app's CLIs change (build from main, which is what prod runs):
cd cli
npm ci
ASSEMBLY_APP_DIR=<assembly-app checkout on main> npm run build # writes bin/*.mjs + bin/SOURCE.jsonbin/SOURCE.json records the app commit the bundles came from.
Convert Markdown to a PDF file.
Renders Markdown → HTML → PDF with WeasyPrint (the Assembly MD→PDF stack)
using a clean print stylesheet. Provide EITHER `md_path` OR `markdown_text`.
A PDF is binary, so `output_path` is required.
Args:
output_path: Path to write the resulting `.pdf` (required).
md_path: Path to a source `.md` file.
markdown_text: Raw Markdown string (alternative to `md_path`).
title: Optional document title (falls back to front-matter `title`).
css: Optional CSS to replace the built-in print stylesheet.
Returns:
A confirmation string with the output path, byte size, and page count.
| Name | Required | Description | Default |
|---|---|---|---|
| css | No | ||
| title | No | ||
| md_path | No | ||
| output_path | Yes | ||
| markdown_text | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fully carries the burden of behavioral disclosure. It reveals the rendering stack (WeasyPrint), input alternatives, the binary nature of output requiring a path, the title fallback to front-matter, and the exact return format (confirmation string with output path, byte size, page count). It does not mention overwrite behavior or error conditions when both inputs are provided, but the disclosed details substantially exceed what a minimal description would provide.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is longer than average but well-structured: a one-line purpose, a pipeline/usage explanation, an Args list, and a Returns note. Every sentence carries information—there is no filler or repetition of schema fields. The front-loaded purpose sentence ensures the core meaning is immediately visible.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 5 parameters, 0% schema description coverage, no annotations, and an output schema, the description covers the essentials well: pipeline, input constraints, parameter semantics, and return value format. Minor gaps exist—such as overwrite policy or behavior when both md_path and markdown_text are supplied—but the description is largely complete for an AI agent to select and use the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate entirely. It does so comprehensively with an Args block that explains all five parameters: output_path (required), md_path, markdown_text (the alternative), title (with fallback behavior), and css (replacement for built-in stylesheet). This adds meaning far beyond the bare schema types and defaults.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb+resource: 'Convert Markdown to a PDF file.' It then details the rendering pipeline (Markdown → HTML → PDF with WeasyPrint), which clearly distinguishes this tool from its sibling convert_pdftomd (the reverse conversion). This is a precise, unambiguous purpose statement.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context: 'Provide EITHER `md_path` OR `markdown_text`' and explains why `output_path` is required (PDF is binary). It also notes the title fallback behavior and CSS replacement option. However, it does not explicitly name convert_pdftomd as the alternative for the reverse conversion, so it stops short of an explicit when-not-to-use statement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Convert a PDF file to Markdown.
Uses PyMuPDF with font-size heading detection, running header/footer
removal, table extraction, and optional watermark stripping — the Assembly
PDF→MD pipeline. Returns the Markdown text; when `output_path` is given it
also writes a `.md` file there.
Args:
pdf_path: Path to the source `.pdf` file.
output_path: Optional path to also write the Markdown to (`.md`).
strip_watermarks: Remove Standards-NZ / IHS style watermark lines and
light-grey overlay text.
front_matter: Prepend YAML front-matter linking back to the source PDF.
Returns:
The converted Markdown as a string.
| Name | Required | Description | Default |
|---|---|---|---|
| pdf_path | Yes | ||
| output_path | No | ||
| front_matter | No | ||
| strip_watermarks | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully discloses the conversion process (PyMuPDF, heading detection, header/footer removal, table extraction), optional watermark stripping, side effects (writing a file when output_path is given), and the return value. This goes well beyond basic expectations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear summary, Args section, and Returns section. It is appropriately sized for a tool with four parameters, and every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is complete: it covers the conversion process, all parameters, side effects, and return value. The presence of an output schema doesn't override the need for context, and the description provides rich behavioral context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must explain each parameter. It does so clearly: pdf_path as source .pdf, output_path as optional write target, strip_watermarks for specific watermark removal, and front_matter for YAML prepending. This adds meaning beyond the raw schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Convert a PDF file to Markdown.' It identifies the specific resource (PDF), the output format (Markdown), and the direction of conversion, which distinguishes it from the sibling tool convert_mdtopdf.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by stating the conversion direction and pipeline details, but it does not explicitly mention when to use this tool instead of the sibling convert_mdtopdf, nor does it provide any exclusions or alternative scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0convert_mdtopdfconvert_pdftomdScored across 2 tools
The two tools are exact inverses: one converts PDF to Markdown, the other Markdown to PDF. There is zero overlap or ambiguity between them.
Both tool names follow the identical convert_<source>to<target> pattern (convert_pdftomd, convert_mdtopdf). The naming is perfectly consistent and predictable.
The server has only 2 tools, which is on the low end, but the scope is tightly focused on bidirectional PDF/Markdown conversion. The count is slightly under the typical 3-15 range yet entirely reasonable for the stated purpose.
The tool surface fully covers the domain of PDF-Markdown conversion in both directions. There are no obvious missing operations for a conversion-focused utility.
Extract text and metadata from PDFs; convert Markdown or text to PDF
Render Markdown and LLM output into accessible PDF/UA-1 PDFs. No headless Chromium.
Convert Markdown, HTML, and web pages to high-quality PDF with Prince.
Markdown in, any format out. PDFs merged, split, watermarked. Runs on our own doc engines.
