This MCP server provides text translation capabilities using the Lingvanex Translator API. It offers:
Text translation between languages - Use the translate_text tool to convert text from one language to another using 2-letter language codes (e.g., "en", "fr", "ru")
Claude Desktop integration - Works as a local MCP server via stdio transport, enabling translations through natural language requests in Claude conversations
HTTP transport mode - Run as a standalone HTTP server for testing with curl, browsers, or MCP Inspector
Real-time translation - Processes requests synchronously and returns translated text immediately
Free trial available - Access Lingvanex's translation API without payment card during trial period
Click on "Install 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., "@Lingvanex Translate MCP Server translate 'Good morning' from English to French"
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.
This project implements an MCP (Model Context Protocol) server for text translation. The server supports two transports:
stdio – for integration with Claude Desktop
http (streamable) – for testing and working via HTTP + SSE
Node.js >= 18
Yarn or npm
Installed Claude Desktop (for stdio integration)
Lingvanex Translator account for text translation
Related MCP server: ClickUp MCP Server
To use the Lingvanex Translator you'll need a Lingvanex account.
If you don't have one, sign up for free
Go to the Cloud API tab: Cloud API
Fill out the Billing Address data
Click Continue to payment
To get a free trial, it is not necessary to add your payment card
Your API key will be generated and visible in the Cloud API tab: API key
Now you are ready to start using the translation API. Below is a video tutorial of the overall process (if available on Lingvanex site).
# Clone the repository
git clone https://github.com/lingvanex-mt/MCP-Lingvanex-Translate.git
cd mcp-prototypeyarn installstdio mode is used by Claude Desktop to connect to local MCP servers.
TRANSPORT=stdio
yarn build
yarn startMCP stdio transport running
Translate MCP Server readyhttp mode runs a local HTTP server with HTTP transport.
Useful for browser testing or with curl.
TRANSPORT=http
HTTP_PORT=3000yarn build
yarn startcurl http://127.0.0.1:3000/pingExpected response:
{ "status": "ok", "transport": "http" }npx @modelcontextprotocol/inspectorIn the MCP Inspector UI, select Transport Type - Streamable HTTP; URL - http://localhost:3000/mcp. Click Connect.
Claude Desktop discovers local MCP servers via config file:
Windows: %APPDATA%\Claude\claude_desktop_config.json
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json
Open (or create) claude_desktop_config.json and add:
{
"mcpServers": {
"translate": {
"command": "node",
"args": [
"C:\\Users\\path\\to\\project\\dist\\index.js"
]
}
}
}⚠️ Make sure to update the path to your local
dist/index.jsafter build!
Launch Claude Desktop.
Enter a request like:
"Use the MCP tool translate_text to translate 'Hello world' into Russian."
If everything is configured correctly, Claude will call your MCP server and return the translation.
translate_textTranslate text from one language into another.
Arguments:
text – the text to translate
sourceLang – source language code (e.g. "en")
targetLang – target language code (e.g. "ru")
Example request:
{
"tool": "translate_text",
"args": {
"text": "Good morning",
"sourceLang": "en",
"targetLang": "fr"
}
}Example response:
{
"content": [
{ "type": "text", "text": "Bonjour" }
]
}Translate text from one language to another
| Name | Required | Description | Default |
|---|---|---|---|
| sourceLang | Yes | Source language code | |
| targetLang | Yes | Target language code | |
| text | Yes | Text to translate |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'translate' implies a read-only operation, it doesn't specify whether this requires authentication, has rate limits, what happens with invalid language codes, or any error handling. The description provides minimal behavioral context beyond the basic function.
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 extremely concise - a single sentence that directly states the tool's function with zero wasted words. It's front-loaded with the essential information and doesn't contain any unnecessary elaboration.
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 translation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what the output looks like (translated text format), doesn't mention language code standards (ISO 639-1 implied but not stated), and provides no behavioral context about limitations or requirements.
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 100% schema description coverage, all parameters are documented in the schema. The description doesn't add any parameter-specific information beyond what's already in the schema descriptions (e.g., format details, language code standards, text length limits). This meets the baseline for high schema coverage.
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's purpose: 'Translate text from one language to another' - a specific verb ('translate') with the resource ('text') and scope ('from one language to another'). However, with no sibling tools mentioned, there's no opportunity to distinguish from alternatives, preventing a perfect score.
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 no guidance on when to use this tool versus alternatives, prerequisites, or constraints. It simply states what the tool does without any contextual usage information, leaving the agent to infer appropriate scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
With only one tool, there is no possibility of confusion or overlap between tools. The tool's purpose is clearly defined as translating text between languages, making it perfectly distinct by default.
The single tool name 'translate_text' follows a clear verb_noun pattern, which is consistent and predictable. Since there is only one tool, naming consistency is inherently perfect.
A single tool is too few for a translation server's apparent scope, which typically involves operations like language detection, batch translation, or language list retrieval. This minimal set feels thin and limits functionality.
The server is severely incomplete for a translation domain, lacking essential operations such as detecting languages, listing supported languages, or handling batch translations. This gap will likely cause agent failures in real-world scenarios.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Translate text or HTML, detect languages, and list supported languages with Langbly.
Translate MCP — wraps LibreTranslate API (https://libretranslate.com/)
AI-powered translation for 48 languages with context-aware quality
DeepL translation: translate, usage, source/target languages. Free 500k chars/mo.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/lingvanex-mt/MCP-Lingvanex-Translate'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
