vectorplease-mcp
OfficialClick 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., "@vectorplease-mcpconvert ./logo.png into a sticker SVG"
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.
@vectorplease/mcp
MCP server for Vector, Please: bitmap in, sticker-ready SVG out, from any MCP client.
Status: pre-release. Not yet published to npm.
Tools
Tool | What it does |
| Converts a PNG, JPEG or WebP (local |
| Fetches a conversion by id, for one that was still running. |
| Lists the presets: one starting point per kind of artwork. |
Related MCP server: Quiver AI MCP Server
Running
Set VECTORPLEASE_API_KEY, then:
vectorplease-mcp # stdio, for clients that launch the server
vectorplease-mcp --http # streamable HTTP on http://127.0.0.1:3333/mcp (PORT, HOST to change)The HTTP transport uses the server's own API key, so keep it on localhost or a trusted network.
Images are limited to 10 MB; URLs must be https.
License
MIT
Available Tools
3 toolsconvert_imageConvert an image to a sticker SVGA
Turns a PNG, JPEG or WebP image into a sticker-ready SVG with a white border and a die-cut outline. Give exactly one of path, url (https) or base64. Returns the SVG and quality metrics, or writes the SVG to outputPath.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | https URL of the image | |
| path | No | Local image file | |
| base64 | No | Base64-encoded image | |
| params | No | Optional overrides; see list_presets for starting points. | |
| preset | No | Preset name from list_presets | |
| outputPath | No | Write the SVG here instead of returning it |
Output Schema
| Name | Required | Description |
|---|---|---|
| id | Yes | |
| status | Yes | |
| metrics | No | |
| savedTo | No | |
| failures | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it does disclose the two output behaviors (return SVG + quality metrics, or write to outputPath). It says nothing about failure modes, input size limits, network/auth needs for URL fetches, or what the quality metrics mean, leaving meaningful behavioral gaps.
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 tight sentences, front-loaded with what the tool produces, followed by the input rule and the return/write behavior. No filler sentences.
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?
An output schema exists so return values need little explanation, and the description still covers the write-to-file alternative and the preset pointer lives in the schema. Minor gaps remain around preset-vs-params choice and limits on URL/base64 input.
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 coverage is 100%, so baseline is 3, but the description adds real value beyond the schema by stating the mutual-exclusivity constraint on path/url/base64 — the schema declares zero required parameters and cannot express 'exactly one'.
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 (convert) plus the exact input formats and the output artifact (sticker-ready SVG with white border and die-cut outline). This clearly separates it from siblings list_presets (enumeration) and get_conversion (retrieval).
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?
Gives an actionable input-selection rule: 'Give exactly one of path, url (https) or base64.', which is the main usage decision for this tool. It does not, however, say when to reach for this tool versus get_conversion or how to pick between preset and explicit params, so it stops short of full when/when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_conversionGet a conversionA
Fetches a conversion by id, for example one that was still running.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Conversion id |
Output Schema
| Name | Required | Description |
|---|---|---|
| id | Yes | |
| status | Yes | |
| metrics | No | |
| savedTo | No | |
| failures | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. 'Fetches' implies a read-only retrieval, and the mention of a still-running conversion adds useful context, but it omits permission requirements, behavior when the id is missing, and rate-limit details. For a simple getter, this is adequate but not thorough.
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 a single front-loaded sentence with no wasted words. It efficiently communicates the core operation and one relevant scenario.
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?
Complexity is low, the input schema fully documents the only parameter, and an output schema exists so return values need not be explained. The description identifies the purpose and a key use case, making it complete enough for correct invocation, though explicit usage routing is absent.
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%, and the single parameter id is documented as 'Conversion id.' The description's 'by id' adds no format or syntax beyond what the schema already provides, so baseline 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 verb and resource: 'Fetches a conversion by id.' This clearly identifies what the tool does. It does not explicitly differentiate from sibling tools, but list_presets and convert_image are dissimilar enough that ambiguity is low.
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?
'For example one that was still running' implies a use case of checking an in-progress conversion, which gives some contextual guidance. However, it does not explicitly state when to use this tool versus alternatives or any prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_presetsList presetsARead-only
Lists the conversion presets: one starting point per kind of artwork.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
readOnlyHint=true already tells the agent this is a safe read with no side effects, so the safety burden is covered by annotations. The description adds a useful disclosure about result shape (one starting point per kind of artwork), but says nothing about ordering, count, or how the presets relate to the conversion tools.
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?
A single front-loaded sentence with no filler; every phrase (verb, resource, cardinality) earns its place.
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 no-argument, read-only listing tool with no output schema, the description covers what is returned and its shape. It could go further by explaining how presets feed into convert_image, but nothing essential for invoking the tool is missing.
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 takes zero parameters, so the schema has nothing to document and the description carries no parameter burden. Baseline 4 applies for a no-parameter tool.
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 ("Lists") and resource ("conversion presets"), and the clause "one starting point per kind of artwork" clarifies what a preset is. It is clear on its own, but it never names the siblings convert_image or get_conversion to distinguish itself from them.
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?
There is no explicit when-to-use guidance, no statement of prerequisites, and no mention of the alternative tools (convert_image, get_conversion). The only hint that this is a discovery step before converting is implied by the word "presets".
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.
3 tool updates
v0.0.0- First observed
convert_image - First observed
get_conversion - First observed
list_presets
TDQS
Scored across 3 tools
Each tool has a clearly distinct purpose: list_presets discovers presets, convert_image performs the conversion, and get_conversion retrieves a prior conversion by id. The create-vs-fetch boundary between the two conversion tools is unambiguous and reinforced by the descriptions.
All three names follow a consistent verb_noun pattern (list_presets, convert_image, get_conversion) with uniform snake_case. No deviation or mixing of conventions.
The server has a narrow, well-defined purpose and three tools cover its core flow without redundancy. It sits at the low end of the ideal range, so it is slightly thin but not inappropriately so.
The pipeline of discovering presets, converting an image, and fetching a conversion result is fully covered. Minor gaps exist (e.g. no listing of past conversions or cancel/delete operations), but agents can work around them with known ids.
Maintenance
Related MCP Connectors
Convert PNG, JPG and WebP to SVG. Recolor an SVG, reduce its colors or remove its background.
Convert images to PNG, JPEG, WebP, or AVIF through one public remote MCP tool.
Hosted MCP front door to the Vectorize API: raster-to-vector tracing to SVG, PDF, EPS or DXF.
Generate and vectorize clean, editable SVG graphics from text, images, or both.
Related MCP Servers
- AlicenseAqualityBmaintenanceEnables AI-powered image to SVG vectorization, background removal, and SVG manipulation directly through MCP-compatible clients. Users can convert images, process batches, and edit vector properties like colors and complexity using the svg.new API.7631 npm1MIT
- AlicenseNot gradedqualityDmaintenanceProvides tools to generate SVG vector graphics from text prompts and convert raster images into vector formats using the Quiver AI API. It enables seamless integration of vector graphic creation and image vectorization directly within MCP-compatible clients.ISC
- AlicenseAqualityCmaintenanceMCP server for AI image generation, transformation, and style management via the Recraft API. Provides tools for text-to-image, image-to-image, inpainting, background operations, vectorization, upscaling, and custom style creation.1635 npm11MIT
- AlicenseAqualityBmaintenanceEnables generating watercolor artwork from text prompts and transforming local images into watercolor paintings, with asynchronous task handling and local file uploads, through any MCP client that supports stdio.410 npmMIT