bluente-translate
OfficialThis server enables AI-powered, format-preserving document translation workflows via the Bluente platform through an MCP interface.
List supported languages (
bluente_get_supported_languages): Retrieve all language pairs available on the Bluente translation platform.Upload documents (
bluente_upload_file): Upload a source file (e.g., PDF, Word) to receive a task ID, with options to choose a translation engine (GTC, LLM, or PPE) and enable glossary matching.Check translation status (
bluente_get_translation_status): Poll the progress of a translation task by ID.Start or cancel translation (
bluente_translate_file): Initiate or cancel translation for an uploaded file, with configurable source/target languages, engine, bilingual output mode (line, paragraph, or none), and glossary options.Download translated files (
bluente_download_file): Download the completed translation in PDF, DOCX, or XLSX format once the task is ready.End-to-end workflow (
bluente_translate_document_workflow): Automate the full pipeline—upload, start translation, poll until completion, and optionally auto-download—with configurable polling intervals, max attempts, and output format.
Bluente Translate MCP Server
AI-powered. Format-preserving. Built for professional document translation workflows.
bluente-translate-mcp-server is the official open-source MCP server for exposing Bluente translation capabilities to AI clients.
It wraps Bluente APIs into production-ready MCP tools so teams can automate multilingual document workflows from Claude Desktop, Cursor, and other MCP-compatible runtimes.
Why Bluente
Bluente focuses on enterprise-grade document translation where accuracy, formatting integrity, and speed matter.
From Bluente.com and Blu Translate, the core product positioning is:
AI-powered translation for professional use cases
Original layout retention for document-centric workflows
Broad language and file-type support
Security-first handling for sensitive content
This MCP server brings those capabilities into agent workflows through a standard protocol interface.
Related MCP server: MCP Document Parse
Brand Identity
This repository is maintained by Bluente and is part of Bluente's public developer ecosystem.
Company website: https://www.bluente.com
Product page: https://www.bluente.com/translator
API docs: https://www.bluente.com/docs
Table of Contents
What You Get
Modular Node.js MCP server with clear layering (
config,client,service,tools)One-file-per-tool implementation for maintainability
Unified tool response envelope (
ok/tool/dataand structured errors)End-to-end translation workflow tool (upload -> start -> poll -> download)
CI checks and local smoke tests
Architecture
AI Client (Claude / Cursor / Agents)
|
| MCP (stdio)
v
+---------------------------------------+
| Bluente Translate MCP Server |
| |
| tools/ -> MCP tool handlers |
| services/ -> workflow orchestration |
| clients/ -> Bluente HTTP API client |
| config/ + lib/ -> env/errors/results |
+---------------------------------------+
|
| HTTPS
v
Bluente Translation APIsProject layout:
src/
clients/bluente-http-client.js
config/env.js
constants/api.js
lib/errors.js
lib/mcp-result.js
services/translation-workflow-service.js
tools/*.tool.js
tools/schemas.js
tools/register-tools.js
server.js
index.js
tests/smoke/core-smoke.test.jsSupported Bluente APIs
GET /blu_translate/supported_languagesPOST /blu_translate/uploadGET /blu_translate/checkPOST /blu_translate/translateGET /blu_translate/download
Reference: Bluente API Docs
MCP Tools
bluente_get_supported_languagesbluente_upload_filebluente_get_translation_statusbluente_translate_filebluente_download_filebluente_translate_document_workflow
These match the tools exposed by Bluente's hosted MCP server, so a prompt or
agent written against one works against the other. The differences are the two
things only a local server can do: file_path as a source, and output_path
for saving results to disk (the hosted server hands out download links instead).
Tool behavior notes:
Confirmation gate:
bluente_translate_document_workflowis a two-call flow. The first call uploads the file and returnspage_countplus a confirmation card for the user; nothing starts and no credits are deducted. Call again with the returnedtask_id,confirmed=true, and explicitto,to_type, andbilingualvalues to actually start.bluente_translate_filehas no gate and starts immediately.File sources:
file_path(a file on this machine),file_url(a public link), orfile_content_base64(under 2MB).bluente_translate_file:fromandtoare required whenaction="start"and optional whenaction="cancel".to_type:pdf,word, orpptx. The workflow tool also accepts an array (e.g.["word", "pdf"]) — extra formats are download-time conversions of the same translation and cost no extra credits.entry/status_entry:get_status(translation progress, the default) orget_page_count(the uploaded file's page count).Language codes: Bluente uses nonstandard codes (
zh,cht,jp,kor,fra,spa, ...). Common ISO spellings (zh-CN,zh-TW,ja,ko,fr,es) are auto-aliased; callbluente_get_supported_languagesfor the full list.bilingual:onkeeps the original text alongside the translation;off(default) produces a clean translated document. Whenon, setbilingual_layouttoleft-right(side by side) ortop-down(stacked) — these are the only two layouts Bluente supports. The numericvertical_bilingualflag is a deprecated alias.mode:standard(most digital documents),scanned (text)(OCR a scan into a clean text-only document),scanned (overlay)(place the translation back over the original scanned layout), orimage(re-render a graphic like a brochure or poster in the target language; 5 credits per page — the only mode charged above the standard rate, scanned modes cost the same as standard). The numericscanned0–3 flag is a deprecated alias.page_range(e.g."1-3,5"): translate only selected pages; credits are charged only for those pages.Glossary: the workflow tool always translates with the glossary enabled (matching the Bluente web product); its
glossary/custom_glossaryarguments are deprecated and ignored. On the rawbluente_translate_filetool the backend applies the glossary only when bothglossaryandcustom_glossaryare1.
Success envelope:
{
"ok": true,
"tool": "bluente_upload_file",
"data": {
"code": 0,
"message": "success",
"data": { "id": "task_xxx" }
}
}Error envelope:
{
"isError": true,
"ok": false,
"tool": "bluente_translate_file",
"error": {
"name": "BluenteApiError",
"message": "Bluente API request failed.",
"details": { "status": 401 }
}
}Quick Start
Requirements: Node.js >= 20 (check with node --version; install from nodejs.org) and a Bluente API key.
Getting an API key: log in at translate.bluente.com and go to My Files → API Keys and Webhook. Treat the key like a password — it authorizes translations billed to your account, so keep it out of version control and shared documents.
Option 1: Just let your coding agent do it
The fastest way to install: don't. If you use Claude Code, Cursor, or any MCP-capable coding agent, paste this prompt and watch it handle everything — config file, key, verification — in under a minute. Replace YOUR_KEY_HERE with your API key:
Install the Bluente Translate MCP server into this client. It's the npm package
@bluente/translate-mcp-server, run vianpx -y @bluente/translate-mcp-server(stdio), and it needs the environment variableBLUENTE_API_KEYset in the server config'senvblock. UseYOUR_KEY_HEREas the key. After configuring, verify the installation by calling thebluente_get_supported_languagestool and show me the result. Docs: https://github.com/Bluente/bluente-translate-mcp-server
The agent finds the right config file for its client, writes the block, and proves the install works by showing you the supported-language list.
Prefer not to paste your API key into an agent conversation? Have the agent use REPLACE_ME as the key, then edit the config file by hand and restart your client.
Option 2: Install manually
Claude Desktop
Open Settings → Developer → Edit Config (opens
claude_desktop_config.json).Add this block (merge into
mcpServersif it already exists), inserting your API key:{ "mcpServers": { "bluente-translate": { "command": "npx", "args": ["-y", "@bluente/translate-mcp-server"], "env": { "BLUENTE_API_KEY": "your_api_key_here" } } } }Quit and reopen Claude Desktop. The tools icon should list six
bluente_*tools.
Claude Code — one command, then restart your session and verify with /mcp:
claude mcp add bluente-translate -e BLUENTE_API_KEY=your_api_key_here -- npx -y @bluente/translate-mcp-serverCursor — Settings → MCP → Add server, or create .cursor/mcp.json in your project with the same JSON block as Claude Desktop.
Smoke test (any client): ask "What languages does Bluente translation support?" — a free, read-only call. A language list back means the key and connection both work. The first run takes a few extra seconds while npx downloads the package.
Troubleshooting the API key
The server reads BLUENTE_API_KEY from its environment — you never pass it as a tool argument or store it in a file. If the server reports Missing BLUENTE_API_KEY, the key is not reaching the server process: check the env block for typos and restart your client. When testing from a terminal, prefix the server command itself (BLUENTE_API_KEY=your_api_key_here npx -y @bluente/translate-mcp-server); in a shell pipeline the assignment must sit directly before npx — placed at the start of the line it applies only to the first command in the pipe.
Optional environment variables:
Variable | Default | Purpose |
| (required) | Your Bluente API key |
|
| API base URL |
|
| HTTP timeout in milliseconds |
Local Development
git clone https://github.com/bluente/bluente-translate-mcp-server.git
cd bluente-translate-mcp-server
npm install
cp .env.example .env # then set BLUENTE_API_KEY
npm start # run the server on stdio
npm run check # syntax check
npm test # run testsTo point an MCP client at your local checkout, use "command": "node" with "args": ["/absolute/path/to/bluente-translate-mcp-server/src/index.js"] instead of the npx config above.
Operational Notes
The workflow tool returns as soon as translation starts. Poll
bluente_get_translation_statusuntilREADY, then callbluente_download_file.auto_download=trueinstead blocks until the translation finishes and saves the file(s) to disk. Only safe for small documents — translation often takes minutes and your MCP client may time the request out first.max_poll_attemptsis a single budget shared across the upload and translation phases.Timeout is configurable via
BLUENTE_API_TIMEOUT_MS.For production, use separate API keys per environment.
Data Handling & Privacy
Documents you translate are uploaded to Bluente's API (
api.bluente.comby default) for processing. Do not translate documents you are not permitted to send to a third-party service.The AI model controls the tools. When run locally (stdio),
file_pathlets the model read any file your user account can read and upload it to Bluente, andoutput_pathlets it write downloaded files to any writable path. Review tool calls in your MCP client before approving them, especially when working with untrusted documents — a malicious document could try to instruct the model to misuse these tools.Translated output returned by tools (file contents, status payloads) enters your AI client's context and is therefore visible to your LLM provider.
Your API key stays on your machine: it is read from the environment and sent only as an
Authorizationheader to the configured Bluente API base URL. It is never logged or included in tool responses.
Security
Do not commit API keys or
.envfiles.Rotate leaked keys immediately.
Use repository private vulnerability reporting.
See SECURITY.md for disclosure policy.
Roadmap
Add text translation tools if exposed in public API docs
Add richer integration tests with API mocking
Add container image and one-command local launch profile
Contributing and Governance
Contribution guide: CONTRIBUTING.md
Security policy: SECURITY.md
Changelog: CHANGELOG.md
Code ownership: .github/CODEOWNERS
About Bluente
Bluente builds AI translation and business communication solutions for professional teams.
Website: bluente.com
Product page: Blu Translate
API documentation: bluente.com/docs
License
MIT
Available Tools
6 toolsbluente_download_fileC
Download the translated file once the task status is READY.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | ||
| to_type | No | docx | |
| output_path | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full disclosure burden. Only behavioral trait mentioned is the READY status prerequisite. Missing: error handling when not ready, whether output is returned as content or saved to disk (relevant given 'output_path' parameter), and side effects.
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?
Single sentence, front-loaded with action. Efficiently structured but arguably undersized given the complete lack of schema documentation and annotations—it sacrifices necessary detail for brevity.
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 3 undocumented parameters, no output schema, and no annotations, the description leaves critical gaps. While the READY state reference is helpful workflow context, the agent lacks guidance on parameter semantics, return format, and filesystem side effects.
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%, requiring heavy description compensation. The text implies 'id' refers to a task ID (via 'task status' reference) but fails to explain 'output_path' (filesystem write location?) or 'to_type' (format conversion options). Only minimal implicit guidance for one of three parameters.
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?
Clear verb ('Download') and resource ('translated file') with specific workflow context ('once the task status is READY'). The READY condition effectively distinguishes this from sibling upload/translate tools by implying it's the final retrieval step in a workflow sequence.
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?
Provides conditional guidance via 'once the task status is READY', implying prerequisites. However, it doesn't explicitly name the sibling status-checking tool (bluente_get_translation_status) or describe error behavior if called prematurely.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
bluente_get_supported_languagesA
List all language pairs currently supported by the Bluente translation platform.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It fails to disclose safety characteristics (read-only vs destructive), return format, pagination behavior, or what 'language pairs' specifically refers to (e.g., ISO codes vs full names). Only the scope 'all' is clarified.
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?
Single sentence of 10 words with no redundancy. Information is front-loaded and every word earns its place. Appropriate length for a parameterless discovery endpoint.
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?
Without an output schema, the description should ideally explain the return structure (e.g., array of language codes). While 'language pairs' gives a hint, the lack of format details or example values leaves a gap for a tool whose only purpose is to return data.
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?
Tool has zero parameters and schema coverage is 100% (vacuously true). Per scoring rules, 0 parameters establishes a baseline of 4. The description correctly implies no filtering is possible by stating 'List all'.
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?
Description provides specific verb 'List', clear resource 'language pairs', and scope 'Bluente translation platform'. It clearly distinguishes this discovery tool from operational siblings like upload_file or translate_document_workflow.
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?
No explicit guidance on when to use this tool versus alternatives, or prerequisites for calling it. While the purpose is clear, the description does not state that this should be called before translating to verify language availability.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
bluente_get_translation_statusA
Query a task status by id. Use this to poll progress after starting translation.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Task id returned by upload endpoint. | |
| entry | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. 'Poll progress' implies repeated safe reads, but description lacks explicit safety guarantees, rate limits, or return value structure. Adequate but minimal 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?
Two sentences, zero waste. Front-loaded with action ('Query') and immediate workflow context ('Use this to poll'). Every word 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?
Adequate for a simple 2-parameter polling tool, but gaps remain: the 'entry' parameter is unexplained, no output schema exists to document return values, and mutation safety is undescribed due to missing annotations.
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 50% (only 'id' is described; 'entry' lacks description). Description mentions 'by id' but fails to explain the undocumented 'entry' parameter (enum pdf/word), leaving its purpose and relationship to status querying unexplained.
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?
Clear verb ('Query') and resource ('task status') with specific scope ('by id'). The phrase 'after starting translation' effectively distinguishes this polling tool from siblings like bluente_translate_file and bluente_upload_file.
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?
Explicitly states when to use ('to poll progress after starting translation'), providing clear temporal workflow guidance. Lacks explicit 'when not to use' or named alternatives, but the context strongly implies it is not for initiating translations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
bluente_translate_document_workflowB
Run end-to-end translation: upload, start, poll until READY, and optionally download.
| Name | Required | Description | Default |
|---|---|---|---|
| file_path | Yes | ||
| from | Yes | ||
| to | Yes | ||
| to_type | No | docx | |
| engine | No | LLM | |
| glossary | No | ||
| custom_glossary | No | ||
| bilingual | No | line | |
| vertical_bilingual | No | ||
| scanned | No | ||
| namespace | No | ||
| metadata | No | ||
| poll_interval_ms | No | ||
| max_poll_attempts | No | ||
| auto_download | No | ||
| status_entry | No | ||
| output_path | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It successfully discloses the critical polling behavior ('poll until READY') and optional download, indicating this is a blocking, synchronous-feeling workflow. However, it omits error handling behavior (what happens if max_poll_attempts is reached), state cleanup, or side effects.
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 single sentence is front-loaded with information and contains no waste—every clause earns its place by describing the workflow stages. However, given the extreme complexity (17 parameters, 0% schema coverage), it may be inappropriately terse rather than ideally concise.
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 complex 17-parameter workflow tool with zero schema descriptions and no output schema, a single-sentence description is insufficient. It lacks explanation of required parameters (beyond the schema), polling configuration semantics, or return value structure.
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%, and the description fails to compensate by mentioning any of the 17 parameters. Critical parameters like namespace, status_entry, custom_glossary vs glossary, vertical_bilingual, and scanned are completely undocumented in both schema and description.
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 runs an 'end-to-end translation' workflow, specifying the exact composite actions (upload, start, poll, download) that distinguish it from atomic sibling tools like bluente_upload_file or bluente_translate_file.
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 'end-to-end' and the explicit step enumeration (upload, poll, download) imply this is the high-level orchestration tool, suggesting when to use it versus individual atomic steps. However, there is no explicit 'when to use vs alternatives' guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
bluente_translate_fileC
Start or cancel translation for an uploaded file.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | ||
| action | No | start | |
| from | No | ||
| to | No | ||
| engine | No | LLM | |
| glossary | No | ||
| custom_glossary | No | ||
| bilingual | No | line | |
| vertical_bilingual | No | ||
| scanned | No | ||
| namespace | No | ||
| metadata | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden of behavioral disclosure. Fails to indicate this is likely an asynchronous operation (evidenced by the status-checking sibling), doesn't explain side effects of 'cancel' (whether it stops processing or deletes results), or mention engine behavior differences (GTC vs LLM vs PPE).
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?
Single sentence is front-loaded and contains no wasted words. However, it is inappropriately concise given the high parameter complexity (12 params, nested objects, multiple enums) and lack of schema documentation.
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?
Inadequate for a complex 12-parameter tool with nested objects and no output schema. Missing explanation of engine options (GTC/LLM/PPE), bilingual formatting modes, glossary behavior, and return value structure. The presence of 'bluente_get_translation_status' as a sibling strongly implies async behavior that should be documented here.
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 has 0% description coverage across 12 parameters. The description only implicitly covers the 'action' parameter via 'Start or cancel', leaving 11 parameters (languages, engine selection, glossary flags, bilingual formatting, namespace, metadata) completely undocumented. Insufficient compensation for the schema documentation gap.
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 the core action (start/cancel) and resource (translation for uploaded file), but fails to differentiate from sibling 'bluente_translate_document_workflow'. The phrase 'uploaded file' implies prerequisite use of upload_file, but doesn't clarify why this tool exists alongside a workflow alternative.
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?
Provides no explicit guidance on when to use this versus 'bluente_translate_document_workflow', nor when to choose 'cancel' versus 'start'. Missing critical async workflow guidance (e.g., that 'bluente_get_translation_status' should be used to poll for completion), despite the existence of the status-checking sibling.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
bluente_upload_fileB
Upload a source document to Bluente and get a translation task id.
| Name | Required | Description | Default |
|---|---|---|---|
| file_path | Yes | Absolute or relative path to source file. | |
| engine | No | Translation engine option. | LLM |
| glossary | No | Enable glossary matching: 0 or 1. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses the return value (translation task id) which is critical since there's no output schema, and implies state mutation via 'upload'. However, it omits idempotency, side effects (e.g., storage persistence), error behaviors, or whether the translation starts automatically.
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?
Single, front-loaded sentence of 11 words with zero redundancy. Every word earns its place by stating the action, target, and return value immediately.
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 lack of output schema, the description adequately covers the return value (translation task id). With 100% schema parameter coverage and no complex nested objects, the description provides sufficient context for a 3-parameter upload tool, though it could mention this is the first step in an async workflow.
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?
Input schema has 100% description coverage, establishing a baseline of 3. The description doesn't add semantic context beyond the schema (e.g., doesn't explain what GTC/LLM/PPE engines mean, or when to enable glossary matching), but doesn't need to given the schema completeness.
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 (upload), resource (source document to Bluente), and specific outcome (get a translation task id). However, it doesn't explicitly differentiate from sibling 'bluente_translate_file' or clarify if this initiates an async workflow versus other translation methods.
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?
No guidance provided on when to use this tool versus alternatives like 'bluente_translate_file' or 'bluente_translate_document_workflow'. Doesn't indicate that the returned task id should be used with 'bluente_get_translation_status' or prerequisites like file format requirements.
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. Dates show when Glama detected each change.
6 tool updates
v0.2.0- First observed
bluente_download_file - First observed
bluente_get_supported_languages - First observed
bluente_get_translation_status - First observed
bluente_translate_document_workflow - First observed
bluente_translate_file - First observed
bluente_upload_file
TDQS
The tools have mostly distinct purposes with clear boundaries: upload, start/cancel translation, check status, download, list languages, and a workflow wrapper. The only potential overlap is between bluente_translate_document_workflow (end-to-end) and the individual upload/translate/status/download tools, but their descriptions clarify this as a convenience wrapper versus granular control.
All tools follow a consistent bluente_verb_noun pattern with snake_case throughout. The naming is predictable and aligned with the server's domain, making it easy for agents to understand the function of each tool at a glance.
With 6 tools, this server is well-scoped for document translation workflows. It covers the essential steps (upload, translate, status, download, languages) plus a workflow helper, avoiding bloat while providing complete coverage for the domain.
The toolset provides complete coverage for document translation: upload source, start/cancel translation, poll status, download result, list supported languages, and an end-to-end workflow. There are no obvious gaps; agents can handle both granular and automated translation tasks effectively.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
AI-powered translation for 48 languages with context-aware quality
Accurate, brand-controlled translation for text, code, images, and documents with terminology.
Translation that never breaks structure: .srt timings, i18n key trees, PDF layout.
File conversion: PDF, DOCX, STT, TTS, watermarking
Related MCP Servers
- -licenseNot gradedqualityNot gradedmaintenanceEnables conversion between multiple document formats including Markdown, HTML, TXT, PDF, and DOCX with automatic format detection. Supports high-fidelity document transformation while preserving content integrity.721-
- AlicenseAqualityDmaintenanceParses various document formats (PDF, Word, Excel, PowerPoint) into Markdown content using NiuTrans API, enabling extraction and reading of document text through natural language interactions.19MIT
- FlicenseAqualityFmaintenanceEnables document translation across multiple languages and AI-powered semantic search of PubMed literature. Supports various document formats including PDF, DOCX, PPTX with status tracking and customizable search parameters.431255-
- AlicenseNot gradedqualityCmaintenanceConverts documents between multiple formats (Markdown, HTML, DOCX, PDF, Text) enabling AI agents to easily transform documents.12MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Bluente/bluente-translate-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server