artwork-preflight-mcp
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., "@artwork-preflight-mcpcheck examples/04-low-res.png against the die-cut-sticker-3in preset"
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.
artwork-preflight-mcp
An MCP server that tells an agent whether a customer's artwork can actually be printed.
Print shops lose time in the same place every day: a file arrives, it looks fine on screen, and only at the proof stage does someone notice it is 900 px wide, has no bleed, or hides a logo 2 mm from the cut line. Those checks are mechanical. This server exposes them as tools, so an agent can answer "what is wrong with this file, and what should we tell the customer" before a human opens it.
It reads files. It never modifies artwork and never places an order.
$ npx artwork-preflight-mcp # speaks MCP over stdioWhat it checks
Check | Fails when |
| pixels per inch of the finished piece fall below the product minimum |
| artwork is a different shape from the product, so fitting it means cropping |
| artwork is exactly trim size, so any cut movement shows white |
| inset content sits closer to the edge than the cut tolerance allows |
| the file has alpha but the product prints on solid stock |
| file is RGB and the press runs CMYK |
| the file declares no resolution, so bleed cannot be confirmed |
| the declared resolution implies a size this product is not, and was ignored |
Errors block printing. Warnings are things the customer should know before approving a proof.
Related MCP server: design-critique-mcp
Tools
Tool | Scope | What it returns |
|
| pixel size, declared dpi, colour space, ICC profile, alpha, content box |
|
| every issue found against a print product, each with a severity |
|
| the print products this server knows, with their physical requirements |
|
| per issue: one message for the customer, one action for the operator |
A fix names the number to change:
{
"code": "resolution",
"customerMessage": "At die-cut sticker, 3 x 3 in this file needs to be at least 971 x 971 px. Yours is 300 x 300 px. Send the original artwork, a vector file, or order a smaller size.",
"operatorAction": "Do not upscale. Upscaled raster art prints soft and the customer blames the press."
}Try it
examples/ holds five files covering the cases that actually arrive. Point the server at that
folder and run the checks below - the expected result is what you should see, verbatim.
PREFLIGHT_ROOT=./examples node dist/index.jsFile | Preset | Expected |
|
| ok - one |
|
| ok - no issues at all |
|
| error |
|
| error |
|
| ok, with a |
|
| ok - 3000 px tagged 96 dpi; the tag is ignored, 927 dpi effective |
|
| error |
|
| errors |
That last row is the point of presets: a file is not "good" or "bad" on its own, only against something you are about to print it on.
A full report looks like this (04-low-res.png, abbreviated):
{
"preset": "die-cut-sticker-3in",
"ok": false,
"effectiveDpi": 93,
"sizeIntent": "unknown",
"issues": [
{
"code": "missing-density",
"severity": "warning",
"message": "The file declares no resolution, so we cannot tell whether bleed was included. Resolution below is measured against the finished size."
},
{
"code": "resolution",
"severity": "error",
"message": "Effective resolution is 93 dpi, below the 300 dpi this product needs.",
"detail": { "requiredWidthPx": 971, "actualWidthPx": 300 }
}
]
}The examples are committed so the server can be tried without setting anything up, and
regenerated with npm run examples - every one of them states its defect in code, in
scripts/make-examples.mjs, next to the numbers that cause it.
Install
npm install
npm run buildClaude Code / Claude Desktop config:
{
"mcpServers": {
"preflight": {
"command": "node",
"args": ["/absolute/path/to/artwork-preflight-mcp/dist/index.js"],
"env": {
"PREFLIGHT_ROOT": "/absolute/path/to/incoming-artwork",
"PREFLIGHT_SCOPES": "inspect,check,fix",
"PREFLIGHT_AUDIT_LOG": "/var/log/preflight-audit.jsonl"
}
}
}
}Variable | Default | Meaning |
| current directory | every file path is resolved inside this directory |
| all | which tools get registered at all |
| unset | JSONL file to append one line per call |
Design notes
Read-only, by construction. No tool writes, converts or flattens anything. A preflight service that silently "fixes" a customer's file is how you end up printing 5,000 stickers with a background someone's code guessed at.
Scopes decide registration, not permission. A tool outside PREFLIGHT_SCOPES is never
listed, so the model cannot call it and be refused - it does not exist in that session.
Refusing a tool the model can see is a prompt-injection surface; not having it is not.
Paths are resolved inside one root. Without that, a server that takes a file path from a model is a general-purpose file reader wearing a print-shop hat.
The audit log counts, it does not copy. Each line records tool, file name, duration and issue count. Artwork contents and full paths stay out: an audit trail that copies the customer's file is not an audit trail, it is a second copy.
A full-bleed design is not a safe-area error. Content touching all four edges is deliberate - that is what bleed is for. Only an inset design that is inset too little gets flagged. Most naive preflight rules get this wrong and train people to ignore warnings.
A declared resolution is a hint, not a fact. 72 and 96 dpi are what editors write when
nobody set anything, and a 3000 px logo tagged 96 dpi is not a low-resolution file - it is an
untagged one. So the dpi in a file is trusted only when it implies a size this product could
plausibly be (trim, or trim plus bleed). Otherwise it is ignored, sizeIntent says unknown,
and resolution is measured as pixels per inch of the finished piece. Every millimetre figure
quoted to a customer comes from a resolution we believed; quoting "your logo is 794 mm wide"
from a meaningless tag destroys trust in the whole report.
Shape is reported as shape. When artwork does not match the product's proportions, the
answer is aspect-mismatch, not a size in millimetres. Cropping or padding changes someone's
design, so the server names the conflict and stops.
Test fixtures are generated; examples are committed. A folder of bad3.png files tells
nobody what is wrong with them six months later, so test/fixtures.ts builds each test case
with the defect named in code. The files in examples/ are the exception: a reader should be
able to clone and run something immediately, and scripts/make-examples.mjs keeps them
reproducible rather than mysterious.
Limits
Raster formats only. SVG, PDF and AI files are the other half of a real preflight service and are not handled here; vector artwork should never fail a resolution check to begin with.
Colour handling is coarse: the server reports the colour space and whether an ICC profile is present. It does not soft-proof, check ink coverage, or predict a specific shift.
Spot colours, overprint and trapping are out of scope.
The content box comes from trimming uniform borders, so a design on a busy photographic background will report no inset even when its text is close to the edge.
Presets are hard-coded in
src/domain/presets.ts. A real deployment would read them from the product catalogue.
Development
npm run typecheck
npm testTests generate their fixtures into a temp directory and run entirely offline.
License
MIT
Available Tools
4 toolscheck_print_readinessCheck print readinessARead-only
Check an artwork file against a print product and return every problem found, each with a severity. Errors block printing; warnings are things the customer should know before approving a proof.
| Name | Required | Description | Default |
|---|---|---|---|
| file | Yes | Path to the artwork file, relative to the artwork root. | |
| preset | Yes | Print product to check against. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true. The description adds useful behavioral context by stating the tool returns every problem found with severity and clearly separating errors (block printing) from warnings (customer awareness). No contradiction with annotations.
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?
Two sentences with no filler. The action and target are front-loaded, and the second sentence earns its place by defining the error/warning output semantics.
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?
For a read-only check with only two fully documented parameters, the description covers purpose, return shape (problems with severity), and the practical meaning of the two severity classes. The lack of an output schema is compensated by the description's explanation of what is returned.
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 100%, so both file and preset are already well documented. The description uses the phrase 'print product' to reinforce preset's meaning but adds no new parameter details beyond the schema, so baseline 3 applies.
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?
States a specific verb (Check), resource (artwork file), and target (print product), and clarifies the return value: every problem with severity. The phrase 'against a print product' distinguishes it from siblings like inspect_artwork and list_presets.
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 use when validating an artwork against a print product and explains the error/warning distinction, but it does not explicitly state when to choose this over inspect_artwork or suggest_fixes, nor does it name any alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
inspect_artworkInspect artworkARead-only
Read the technical properties of an artwork file: pixel size, declared resolution, colour space, ICC profile, transparency and where the visible content sits. Reports what the file says; makes no judgement about whether it can be printed.
| Name | Required | Description | Default |
|---|---|---|---|
| file | Yes | Path to the artwork file, relative to the artwork root. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint already signals a safe read operation, and the description adds useful behavioral nuance: it reports raw file-declared values rather than making interpretive judgements. This goes beyond the annotation by clarifying the tool's non-evaluative stance and what specific attributes it exposes.
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 compact and front-loaded: the first clause states the core action and resource, the enumeration adds concrete detail, and the final sentence disambiguates from print-readiness tools. Every sentence earns its place with no 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?
For a single-parameter, read-only inspection tool with no output schema, the description fully covers what the tool does, what it reports, and what it deliberately does not do. An agent has enough information to decide whether to call it and to interpret the result as a factual metadata report rather than a print-readiness verdict.
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 100%, so the file parameter is already well documented as a path relative to the artwork root. The description adds context about what will be read from that file but does not add new meaning specific to the file parameter itself, which aligns with the baseline score.
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 names a specific verb ('Read') and resource ('technical properties of an artwork file') and enumerates concrete properties it inspects: pixel size, resolution, colour space, ICC profile, transparency, and content placement. It further distinguishes itself from print-related siblings by explicitly saying it makes no judgement about whether the file can be printed.
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 clearly frames this as an inspection tool for reading what the file reports, and the explicit disclaimer 'makes no judgement about whether it can be printed' implies the agent should look elsewhere for print-readiness evaluation. It does not name sibling tools like check_print_readiness or suggest_fixes directly, so the routing guidance is clear but not fully explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_presetsList print presetsARead-only
List the print products this server knows how to check, with their physical requirements.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already establishes the read-only nature, and the description does not contradict it. The description adds the scope and output content but does not disclose any additional behavioral traits such as pagination, ordering, or data-source specifics. With annotations present, this is acceptable but not especially rich.
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?
One concise sentence that front-loads the action and resource, then adds the relevant qualifier ('this server knows how to check') and output details. No filler or repetition.
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?
For a zero-parameter read-only listing tool, the description adequately states what the operation returns. A bit more specificity about the format or content of 'physical requirements' would improve completeness, but the context is largely sufficient.
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?
The tool has zero parameters, and the schema is fully complete, so there is nothing for the description to explain. The baseline of 4 applies because no parameter coverage gap exists.
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 states a specific verb ('List'), an explicit resource ('print products this server knows how to check'), and the output scope ('with their physical requirements'). This clearly distinguishes it from sibling tools like inspect_artwork, check_print_readiness, and suggest_fixes.
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 intended usage is implied by the wording: this tool enumerates available print products before checking readiness. However, there is no explicit statement about when to use this versus alternatives, nor any exclusions or workflow guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
suggest_fixesSuggest fixesARead-only
Turn the problems found in an artwork file into concrete actions - one message written for the customer and one for whoever handles the job internally. Suggests only; it never modifies the file.
| Name | Required | Description | Default |
|---|---|---|---|
| file | Yes | Path to the artwork file, relative to the artwork root. | |
| preset | Yes | Print product to check against. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already signals safety, but the description adds useful behavioral details: it produces exactly two messages with different audiences and explicitly states it never modifies the file. That goes beyond the annotation without contradicting it.
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?
Two sentences with no filler. The primary purpose is front-loaded, and the important side-effect guarantee ('never modifies the file') is placed at the end as a clear qualifier.
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?
For a simple, read-only tool with two well-documented parameters, the description is largely complete. It explains the output concept (two messages) and the safety profile. Since there is no output schema, slightly more detail about the exact return format would have pushed this to a 5.
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 100%, so the schema already explains both parameters clearly: file is a relative path and preset is an enum of print products. The description adds no extra parameter-level meaning, so the baseline score of 3 is appropriate.
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 states a specific action: turning artwork problems into two concrete messages (customer-facing and internal). It also clarifies that the tool only suggests and never modifies the file. It does not explicitly name or contrast a sibling tool, so it stops short of full differentiation.
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 phrase 'problems found in an artwork file' implies this tool is used after analysis, and the read-only nature implies it is not a replacement for inspect_artwork or check_print_readiness. However, it never states explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
v0.1.0- First observed
check_print_readiness - First observed
inspect_artwork - First observed
list_presets - First observed
suggest_fixes
TDQS
Scored across 4 tools
Each tool has a clearly distinct role: inspect_artwork reads raw file properties, check_print_readiness validates against a product, list_presets enumerates available products, and suggest_fixes generates recommendations. There is no overlap or ambiguity between them.
All four tool names follow a consistent verb_noun pattern: inspect_artwork, check_print_readiness, list_presets, suggest_fixes. The naming convention is uniform and predictable.
With four tools, the server is tightly scoped to the preflight workflow. Each tool earns its place, covering the essential operations without unnecessary bloat or missing coverage.
The domain is artwork preflight, and the set covers the full workflow: inspect raw properties, check against a specific product, discover available products, and get recommended fixes. There are no obvious dead ends or missing operations for a non-mutating preflight service.
Maintenance
Related MCP Connectors
Preflight QA for AI-agent deliverables with structured verdicts and repair guidance.
Identity verification, document checks, sanctions/PEP screening and case review as agent tools.
Give agents instant OG image generation, social metadata audits, and rendering guidance.
Real 3D-print slicing, quoting, DFM, orientation & material/settings advisors. Free personal tier.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables AI assistants to inspect, modify, export, and validate design documents with 47 tools covering design, code generation, branding, and print/mockup workflows.1 npm1MIT
- AlicenseAqualityDmaintenanceEnables AI assistants to analyze design images for composition, color harmony, typography, and accessibility compliance with actionable recommendations.66MIT

mcp-reviewofficial
AlicenseAqualityAmaintenanceAn MCP server for in-loop design review of web previews. It enables agents to submit a preview URL, receive structured findings with suggested fixes, and recheck after applying changes, while never editing code itself.51MIT- FlicenseNot gradedqualityBmaintenanceEnables programmatic document proofing for print, with real ink coverage measurement and waste page detection, letting agents decide what to print before any sheet is produced.-