This MCP server lets AI agents convert PDF/CSV files to Markdown through PromptReady's cloud OCR, while managing login, credits, conversion settings, and downloads.
Authenticate: login opens Google OAuth in a browser and stores credentials locally; logout clears them. Environment tokens can also be used.
Check credits: get_credits returns the user's PromptReady credit balance and email.
Manage conversion defaults: get_convert_settings / set_convert_settings view and update saved defaults for engine (paddle, paddle_vl15, glm_ocr), tables, images, and reference removal.
Convert files: convert_pdf uploads a local PDF/CSV and queues conversion, optionally waiting for completion and downloading the Markdown output (default engine PaddleOCR-VL, tables on, images off).
Track jobs: get_status checks conversion status for the current session.
Download results: wait_and_download polls until completion and saves the generated .md file to a specified directory.
Human-friendly slash commands: MCP prompts such as /promptready:convert, /promptready:credits, /promptready:settings, and /promptready:login provide easy entry points for users.
Works with MCP hosts: Can be added to Claude Code, Cursor, Grok, Claude Desktop, and generic MCP clients via stdio.
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., "@PromptReady MCP Convert /home/user/report.pdf to markdown"
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.
Official Model Context Protocol client for PromptReady — convert PDF/CSV to Markdown from AI agents (Grok, Claude Code, Cursor, and other MCP hosts).
Same PromptReady account and credits as the web app.
Browser Google login (tokens stay on your machine)
get_credits, convert_pdf, get_status, wait_and_download
Slash commands for humans: /promptready:convert and five more (below)
Saved convert defaults (engine, tables, images) — not on every call
Factory default: PaddleOCR-VL, tables on, images off
Related MCP server: Markitdown MCP Server
pip install promptready-mcpOr run it without installing:
uvx promptready-mcpgit clone https://github.com/hydrojwh/promptready-mcp.git
cd promptready-mcp
python3 -m venv .venv && source .venv/bin/activate
pip install -e .promptready-mcp-loginIf you installed with uvx, the login command lives in the same package:
uvx --from promptready-mcp promptready-mcp-loginEither opens Google OAuth and saves credentials to
~/.config/promptready/credentials.json (file mode 0600). That path is in your
home directory, so it survives uvx cache resets. You can also log in from inside
an MCP host by calling the login tool.
After you sign in, the browser returns to http://127.0.0.1:18765/callback — a
local page started by the login command. No Supabase configuration is needed.
If browser-based Google login is not an option, the same command accepts email and password:
promptready-mcp-login --email you@x.comLeave out --password and you will be prompted for it instead — this keeps the
password out of your shell history.
Already have an access token? Set PROMPTREADY_ACCESS_TOKEN in the environment
(MCP host or shell). Environment variables take precedence over the saved
credentials file.
If you are already in an MCP-capable agent, skip the JSON editing and just ask:
Install the PromptReady MCP server for me. The PyPI package is
promptready-mcp(stdio commandpromptready-mcp). Add it to your MCP config, then I will run thelogintool.
In Claude Code the agent can use the built-in CLI:
claude mcp add promptready -- promptready-mcpHosts do not pick up MCP config changes mid-session. After changing the
config, restart the host or reconnect the server — in Claude Code, open the
/mcp panel and reconnect.
The /mcp panel shows server status and lists the connected servers'
tools, but it does not run them: picking a tool in that list will
not invoke it. Tools are invoked through normal conversation — ask the
agent to convert a file and it calls convert_pdf for you. If a call
fails, reconnect from the panel first.
claude mcp add promptready -- promptready-mcpThe default scope is local (this project only). Use --scope user to
register it for all your projects, or --scope project to share the
registration through a committed .mcp.json.
Add to ~/.cursor/mcp.json (or .cursor/mcp.json for a single project):
{
"mcpServers": {
"promptready": {
"command": "promptready-mcp"
}
}
}[mcp_servers.promptready]
command = "promptready-mcp"
enabled = true
tool_timeout_sec = 3600{
"mcpServers": {
"promptready": {
"command": "promptready-mcp"
}
}
}No access token in config files required after login.
GUI hosts start servers with a narrow PATH, so a console script installed by
pip install --user is often invisible to them — the host reports a spawn
failure or "server disconnected" rather than a missing command.
Two reliable fixes:
{ "mcpServers": { "promptready": {
"command": "uvx", "args": ["promptready-mcp"] } } }or point at the absolute path of the script:
/ABS/PATH/.venv/bin/promptready-mcp.
Tool | Purpose |
| Browser auth / clear local credentials |
| Credit balance |
| Saved convert defaults |
| Upload path → queue (optional |
| Job status |
| Poll + save |
Downloaded names follow the web app: {name}_PaddleOCR-VL.md (engine label).
Credits are deducted by the server when a job is queued, exactly as on the web
app. convert_pdf(wait=True) can run for a long time, so give the host a high
tool timeout.
MCP prompts are the human entry point: instead of describing what you
want, you pick a command. Hosts that surface prompts as slash commands
(Claude Code does) show them as /promptready:<name>:
Slash command | Purpose |
| Log in (opens the browser Google sign-in) |
| Log out on this machine |
| Show your credit balance |
| Convert a PDF/CSV to Markdown |
| Show the PromptReady web app URL |
| Show — and optionally change — convert defaults |
Each command expands to a short instruction; the agent then calls the
matching tool (login, get_credits, convert_pdf, …) for you.
/promptready:convert optionally takes two positional arguments, input
path then output directory. Pick the command from the slash menu (hosts
may list it as promptready:convert (MCP)) and append the arguments:
/promptready:convert (MCP) report.pdf markdown-outArguments are split on whitespace and cannot be quoted, so paths with
spaces do not fit on the command line — run the command bare and give
the paths in chat instead. With no arguments the command asks you for
them. The conversion itself always goes through the convert_pdf tool:
never re-run it for the same file while a download is pending — that
queues a fresh conversion and spends fresh credits; the expanded command
tells the agent to call wait_and_download instead.
Hosts that do not map prompts to slash commands simply ignore this section; the tools keep working as before.
Tokens are never hardcoded in this repository.
Do not commit ~/.config/promptready/* or .env.
Only use the official package linked from https://promptready.space
Vulnerability reports: see SECURITY.md
Using the cloud API is subject to the Terms of Service and Privacy Policy. This MIT-licensed client does not grant free unlimited conversion.
./scripts/smoke_stdio.shMIT — see LICENSE.
Upload a local PDF/CSV and queue conversion (same credits as the web app).
Uses saved user settings (get_convert_settings / set_convert_settings), not per-call engine flags. Factory default: paddle, tables on, images off.
Args: path: Absolute or home-relative path to a .pdf or .csv file. wait: If true, poll until done and download markdown (can take many minutes). timeout_sec: Max wait when wait=true (default 3600). output_dir: Directory for downloaded .md when wait=true.
Returns JSON with job info; if wait=true and completed, includes local md path.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | ||
| wait | No | ||
| output_dir | No | promptready-out | |
| timeout_sec | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses queuing behavior, use of saved settings, defaults (paddle, tables on, images off), wait polling, and return format. It lacks statement on destructive potential or authentication requirements, but overall it is transparent.
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 brief summary followed by parameter details. It is slightly verbose but every sentence adds value. Could be tightened but remains clear.
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 complexity (async conversion, wait/async) and presence of output schema, the description covers main behavior, parameters, and return. Missing explicit mention of authentication prerequisites, but siblings imply it. Mostly complete.
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 0%, so description must add meaning. It explains path (absolute or home-relative, file types), wait (polling, time-consuming), timeout_sec (max wait when wait=true, default), and output_dir (for downloaded markdown). This fully compensates for the schema's lack of descriptions.
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 uploads a local PDF/CSV and queues conversion. It specifies using saved settings and mentions waiting behavior, distinguishing it from siblings like wait_and_download.
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 explains that the tool uses saved user settings (not per-call flags) and provides factory defaults. It discusses wait behavior and timeout but does not explicitly contrast with the wait_and_download sibling or state when not to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Show saved convert defaults for this machine (not per-file options).
Defaults live in ~/.config/promptready/settings.json. convert_pdf always uses these until you change them with set_convert_settings.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but the description discloses that the tool reads from a specific config file (~/.config/promptready/settings.json) and is machine-specific. It implies read-only behavior, which is appropriate for a 'get' operation. The information is accurate and helpful.
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 concise (two sentences) with no wasted words. It is front-loaded with the main purpose in the first sentence and provides additional details in the second. Excellent structure.
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's simplicity (no parameters, output schema exists), the description is complete. It explains what the tool does, where the data comes from, how it relates to convert_pdf and set_convert_settings, and that it is machine-specific. No gaps remain.
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?
With zero parameters, the schema is empty and description coverage is 100%. The description explains that no parameters are needed, which is sufficient. Baseline for zero-param tools is 4, and the description adds context by stating it shows defaults for the machine.
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 'Show saved convert defaults', distinguishing from per-file options. It specifies the file location and that convert_pdf uses these defaults, making the tool's purpose unambiguous.
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 indicates when to use the tool (to see defaults) and notes that it is not for per-file options. It mentions set_convert_settings as the companion for changing defaults, providing context for alternatives. Sibling tools like login/get_credits are clearly unrelated, so no further differentiation needed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the calling user's PromptReady credit balance.
Returns JSON: ok + credit_balance + email, or ok:false + error. Requires prior login (promptready-mcp-login / login tool) or env token.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the return format (JSON with ok, credit_balance, email, or error) and authentication requirement. This is adequate for a simple read operation, though it could mention idempotency.
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 two sentences: the first states the purpose concisely, and the second provides essential details about return format and prerequisites. No wasteful text.
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's simplicity (no parameters, read-only, output schema exists), the description covers the purpose, return values, and usage prerequisites completely.
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 description adds meaning about the return structure and prerequisites, fully compensating for the lack of parameter documentation.
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 'Get the calling user's PromptReady credit balance' with a specific verb and resource, distinguishing it from sibling tools like login, logout, and PDF conversion tools.
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 mentions the prerequisite of prior login or env token, providing clear context for when to use the tool. However, it does not explicitly exclude alternatives or provide when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get conversion status for the authenticated user's current session job.
Uses GET /api/v1/convert/status (session = user_id when logged in).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries full burden. It discloses the HTTP method (GET) and authentication scope (authenticated user's session), but does not mention idempotency, rate limits, or behavior when no job exists. The output schema is present but not referenced.
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 two concise sentences. The first states the core purpose, the second adds technical detail (HTTP method and session context). No extraneous information.
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?
With no parameters and an output schema (unknown content), the description covers the resource and authentication. It lacks explicit sequencing (e.g., 'call after starting a job') but is otherwise sufficient for a simple status check.
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?
There are zero parameters, and schema coverage is 100%. The description does not need to explain parameters, and the absence is self-evident. Baseline for no parameters is 4.
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 verb 'Get' and the resource 'conversion status for the authenticated user's current session job'. It distinguishes from sibling tools like convert_pdf (performs conversion) and get_convert_settings (retrieves settings) by specifying it's for status of a specific session job.
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 after starting a conversion job but does not explicitly state when to use this tool versus alternatives like wait_and_download. No exclusions or contextual triggers are provided, leaving the agent to infer proper usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Open the browser Google login page and save tokens for this machine.
Starts a local callback on http://127.0.0.1:18765/callback, opens PromptReady Google OAuth, stores credentials under ~/.config/promptready/credentials.json (mode 600), and applies them to this process.
Users should run this once (or use CLI: promptready-mcp-login) instead of pasting tokens manually. Requires Supabase redirect allowlist for that URL.
| Name | Required | Description | Default |
|---|---|---|---|
| timeout_sec | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses local callback URL, credential storage path and permissions (mode 600), and process application. Without annotations, it covers key behavioral aspects well, though doesn't mention idempotency or re-login behavior.
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?
Three paragraphs with relevant details, but includes slightly verbose phrasing like 'Starts a local callback...' could be streamlined. Generally acceptable length.
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?
Does not describe return value or output schema, despite the tool having one. No error handling or prerequisite details (e.g., Supabase config). For a simple auth tool with one param, it lacks completeness.
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?
Only parameter `timeout_sec` is not explained in the description; schema shows only a title and default. With 0% schema description coverage, the description fails to add meaning beyond the default value.
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?
Clearly states it opens a Google login page and saves tokens, with specific verb ('open', 'save') and resource ('browser Google login page', 'tokens for this machine'). Distinguishes from unrelated sibling tools like convert_pdf.
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?
Advises running once instead of manual token pasting, mentions a CLI alternative, and notes Supabase redirect requirement. No explicit when-not-to-use or alternative authentication methods, but sufficient for basic use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Remove saved MCP credentials from this machine and clear env tokens.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, but the description discloses the destructive nature (removes credentials) and specifies local machine scope and token clearing, adding behavioral context.
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, concise sentence with no unnecessary words, efficiently conveying the tool's purpose.
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 parameter-less tool with an output schema, the description sufficiently explains the tool's action without needing further detail.
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?
No parameters are present, and the baseline for 0 parameters is 4; no parameter information is needed.
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 removes saved credentials and clears tokens, distinguishing it from sibling tools like login which likely save credentials.
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?
Usage is implied as logging out, but no explicit guidance on when to use vs alternatives or any exclusions is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Update saved convert defaults (persists for future convert_pdf calls).
Only pass fields you want to change. Example: set engine to paddle_vl15 once, then every convert uses that until changed again.
Args: engine: paddle | paddle_vl15 | glm_ocr include_tables: keep markdown tables include_images: include image/visual extraction (heavier) remove_references: strip references section when supported
| Name | Required | Description | Default |
|---|---|---|---|
| engine | No | ||
| include_images | No | ||
| include_tables | No | ||
| remove_references | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses that changes persist for future 'convert_pdf' calls and that only desired fields need be passed. It does not mention reversibility or error conditions, but the behavior is well-explained for a settings mutation.
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 concise and front-loaded with the main purpose. It includes an example and bullet-pointed arguments. Minor redundancy (e.g., 'persists for future' repeated) but overall well-structured.
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 adequately covers the tool's core function but does not mention the output schema (likely a status or updated settings), error scenarios, or prerequisites. For a settings tool with a simple interface, this is adequate but leaves some gaps.
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?
Despite 0% schema description coverage, the description adds meaningful semantics for each parameter: enumerates engine options, explains 'include_tables', 'include_images' as heavier, and 'remove_references' as stripping when supported. This compensates for the lack of schema descriptions.
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 verb 'update' and the resource 'saved convert defaults', and distinguishes from sibling tools like 'convert_pdf' and 'get_convert_settings' by emphasizing it updates persisted settings.
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 guidance: 'Only pass fields you want to change' and an example of setting the engine once for future conversions. However, it does not explicitly state when not to use or mention alternatives like 'get_convert_settings' for reading.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Poll get_status until completed/failed/cancelled, then download markdown if available.
Args: timeout_sec: Max seconds to wait (OCR can take many minutes). poll_interval_sec: Sleep between polls (default 3). output_dir: Where to write the .md file. source_path: Optional original file path (used only for output filename).
| Name | Required | Description | Default |
|---|---|---|---|
| output_dir | No | promptready-out | |
| source_path | No | ||
| timeout_sec | No | ||
| poll_interval_sec | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description bears full weight. It discloses polling behavior, timeout, defaults, and output format. It could be more explicit about the outcome on 'failed' or 'cancelled' states, but 'if available' covers 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?
The description is concise with a clear action statement followed by a structured Args list. Every sentence adds value, and the key action is front-loaded.
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 presence of an output schema, the description adequately covers polling, timeout, download. It could mention error handling or edge cases, but is sufficient for typical use.
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 0%, but the description includes an Args section that explains each parameter's purpose and default. This adds significant meaning beyond the schema names.
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 polls get_status until a terminal state and then downloads markdown. The verb 'poll' and 'download' with resource 'status' and 'markdown' make the purpose explicit, differentiating it from siblings like get_status or convert_pdf.
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 after a conversion by mentioning OCR and polling. It provides timeout guidance. However, it does not explicitly state when not to use this tool (e.g., for simple status checks use get_status).
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.3.0convert_pdfget_convert_settingsget_creditsget_statusloginlogoutset_convert_settingswait_and_downloadScored across 8 tools
Tools have distinct purposes: auth, settings, conversion, status, download. However, convert_pdf with wait=true and wait_and_download both handle waiting and downloading, which could cause slight confusion, but descriptions clarify their different roles.
All names use snake_case, but inconsistent patterns: some are verb_noun (convert_pdf, get_credits), others are bare verbs (login, logout), and wait_and_download uses 'and'. Minor deviations from a strict verb_noun pattern.
8 tools feel appropriate for a PDF conversion service, covering auth, settings, conversion, and status. Not excessive nor too sparse, though a few additional tools (e.g., list conversions) could be added.
The tool set covers the essential lifecycle: auth, configuration, conversion, status polling, and download. Minor gaps like listing past conversions or deleting jobs exist, but core workflow is complete.
Convert documents and web pages to clean Markdown: PDF, DOCX, XLSX, EPUB, scanned files, any URL.
Clean, repair, and convert AI-generated Markdown to HTML/PDF/DOCX/PNG; save and share documents.
Convert files, URLs, and documents to clean, AI-ready Markdown via MCP.
Convert PDF, DOCX, HTML, and URLs to clean, LLM-ready markdown with tables preserved
