Skip to main content
Glama

Bluente Translate MCP Server

AI-powered. Format-preserving. Built for professional document translation workflows.

CI Node.js >=20 License: MIT MCP

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.

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/data and 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 APIs

Project 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.js

Supported Bluente APIs

  • GET /blu_translate/supported_languages

  • POST /blu_translate/upload

  • GET /blu_translate/check

  • POST /blu_translate/translate

  • GET /blu_translate/download

Reference: Bluente API Docs

MCP Tools

  • bluente_get_supported_languages

  • bluente_upload_file

  • bluente_get_translation_status

  • bluente_translate_file

  • bluente_download_file

  • bluente_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_workflow is a two-call flow. The first call uploads the file and returns page_count plus a confirmation card for the user; nothing starts and no credits are deducted. Call again with the returned task_id, confirmed=true, and explicit to, to_type, and bilingual values to actually start. bluente_translate_file has no gate and starts immediately.

  • File sources: file_path (a file on this machine), file_url (a public link), or file_content_base64 (under 2MB).

  • bluente_translate_file: from and to are required when action="start" and optional when action="cancel".

  • to_type: pdf, word, or pptx. 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) or get_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; call bluente_get_supported_languages for the full list.

  • bilingual: on keeps the original text alongside the translation; off (default) produces a clean translated document. When on, set bilingual_layout to left-right (side by side) or top-down (stacked) — these are the only two layouts Bluente supports. The numeric vertical_bilingual flag 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), or image (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 numeric scanned 0–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_glossary arguments are deprecated and ignored. On the raw bluente_translate_file tool the backend applies the glossary only when both glossary and custom_glossary are 1.

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 via npx -y @bluente/translate-mcp-server (stdio), and it needs the environment variable BLUENTE_API_KEY set in the server config's env block. Use YOUR_KEY_HERE as the key. After configuring, verify the installation by calling the bluente_get_supported_languages tool 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

  1. Open Settings → Developer → Edit Config (opens claude_desktop_config.json).

  2. Add this block (merge into mcpServers if 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"
          }
        }
      }
    }
  3. 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-server

Cursor — 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

BLUENTE_API_KEY

(required)

Your Bluente API key

BLUENTE_API_BASE_URL

https://api.bluente.com/api/20250924

API base URL

BLUENTE_API_TIMEOUT_MS

90000

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 tests

To 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_status until READY, then call bluente_download_file.

  • auto_download=true instead 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_attempts is 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.com by 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_path lets the model read any file your user account can read and upload it to Bluente, and output_path lets 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 Authorization header to the configured Bluente API base URL. It is never logged or included in tool responses.

Security

  • Do not commit API keys or .env files.

  • 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

About Bluente

Bluente builds AI translation and business communication solutions for professional teams.

License

MIT

Available Tools

6 tools
bluente_download_fileC

Download the translated file once the task status is READY.

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes
to_typeNodocx
output_pathNo

TDQS

C2.9/5.0
Behavior2/5

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.

Conciseness4/5

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.

Completeness2/5

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.

Parameters2/5

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.

Purpose4/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

A3.5/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines2/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
idYesTask id returned by upload endpoint.
entryNopdf

TDQS

A3.8/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters2/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
file_pathYes
fromYes
toYes
to_typeNodocx
engineNoLLM
glossaryNo
custom_glossaryNo
bilingualNoline
vertical_bilingualNo
scannedNo
namespaceNo
metadataNo
poll_interval_msNo
max_poll_attemptsNo
auto_downloadNo
status_entryNopdf
output_pathNo

TDQS

B3.2/5.0
Behavior3/5

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.

Conciseness4/5

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.

Completeness2/5

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.

Parameters1/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes
actionNostart
fromNo
toNo
engineNoLLM
glossaryNo
custom_glossaryNo
bilingualNoline
vertical_bilingualNo
scannedNo
namespaceNo
metadataNo

TDQS

C2.4/5.0
Behavior2/5

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.

Conciseness4/5

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.

Completeness2/5

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.

Parameters2/5

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.

Purpose3/5

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.

Usage Guidelines2/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
file_pathYesAbsolute or relative path to source file.
engineNoTranslation engine option.LLM
glossaryNoEnable glossary matching: 0 or 1.

TDQS

B3.4/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines2/5

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.

  1. 6 tool updatesv0.2.0
    • First observedbluente_download_file
    • First observedbluente_get_supported_languages
    • First observedbluente_get_translation_status
    • First observedbluente_translate_document_workflow
    • First observedbluente_translate_file
    • First observedbluente_upload_file

TDQS

A3.5/5.0
Disambiguation4/5

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.

Naming Consistency5/5

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.

Tool Count5/5

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.

Completeness5/5

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

ActivityMaintained
ResponsivenessUnresponsive

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

Related MCP Servers

Latest Blog Posts

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