Lara Translate MCP Server

1# Lara Translate MCP Server
2 
3A Model Context Protocol (MCP) Server for [Lara Translate](https://laratranslate.com/translate) API, enabling powerful translation capabilities with support for language detection, context-aware translations and translation memories.
4 
5[![License](https://img.shields.io/github/license/translated/lara-mcp.svg)](https://github.com/translated/lara-mcp/blob/main/LICENSE)
6[![Docker Pulls](https://img.shields.io/docker/pulls/translatednet/lara-mcp.svg)](https://hub.docker.com/r/translatednet/lara-mcp)
7[![npm downloads](https://img.shields.io/npm/dm/@translated/lara-mcp.svg)](https://www.npmjs.com/package/@translated/lara-mcp)
8 
9## 📚 Table of Contents
10- 📖 [Introduction](#-introduction)
11- 🛠 [Available Tools](#-available-tools)
12- 🚀 [Getting Started](#-getting-started)
13  - 📋 [HTTP Server](#http-server-)
14  - 🔌 [STDIO Server](#stdio-server-%EF%B8%8F)
15- 🧪 [Verify Installation](#-verify-installation)
16- 💻 [Popular Clients that supports MCPs](#-popular-clients-that-supports-mcps)
17- 🆘 [Support](#-support)
18 
19## 📖 Introduction
20 
21<details>
22<summary><strong>What is MCP?</strong></summary>
23 
24Model Context Protocol (MCP) is an open standardized communication protocol that enables AI applications to connect with external tools, data sources, and services. Think of MCP like a USB-C port for AI applications - just as USB-C provides a standardized way to connect devices to various peripherals, MCP provides a standardized way to connect AI models to different data sources and tools.
25 
26Lara Translate MCP Server enables AI applications to access Lara Translate's powerful translation capabilities through this standardized protocol.
27 
28> More info about Model Context Protocol on: https://modelcontextprotocol.io/
29</details>
30 
31<details>
32<summary><strong>How Lara Translate MCP Works</strong></summary>
33 
34Lara Translate MCP Server implements the Model Context Protocol to provide seamless translation capabilities to AI applications. The integration follows this flow:
35 
361. **Connection Establishment**: When an MCP-compatible AI application starts, it connects to configured MCP servers, including the Lara Translate MCP Server
372. **Tool & Resource Discovery**: The AI application discovers available translation tools and resources provided by the Lara Translate MCP Server
383. **Request Processing**: When translation needs are identified:
39   - The AI application formats a structured request with text to translate, language pairs, and optional context
40   - The MCP server validates the request and transforms it into Lara Translate API calls
41   - The request is securely sent to Lara Translate's API using your credentials
424. **Translation & Response**: Lara Translate processes the translation using advanced AI models
435. **Result Integration**: The translation results are returned to the AI application, which can then incorporate them into its response
44 
45This integration architecture allows AI applications to access professional-grade translations without implementing the API directly, while maintaining the security of your API credentials and offering flexibility to adjust translation parameters through natural language instructions.
46</details>
47 
48<details>
49<summary><strong>Why to use Lara inside an LLM</strong></summary>
50 
51Integrating Lara with LLMs creates a powerful synergy that significantly enhances translation quality for non-English languages.
52 
53#### Why General LLMs Fall Short in Translation
54While large language models possess broad linguistic capabilities, they often lack the specialized expertise and up-to-date terminology required for accurate translations in specific domains and languages.
55 
56#### Lara’s Domain-Specific Advantage
57Lara overcomes this limitation by leveraging Translation Language Models (T-LMs) trained on billions of professionally translated segments. These models provide domain-specific machine translation that captures cultural nuances and industry terminology that generic LLMs may miss. The result: translations that are contextually accurate and sound natural to native speakers.
58 
59#### Designed for Non-English Strength
60Lara has a strong focus on non-English languages, addressing the performance gap found in models such as GPT-4. The dominance of English in datasets such as Common Crawl and Wikipedia results in lower quality output in other languages. Lara helps close this gap by providing higher quality understanding, generation, and restructuring in a multilingual context.
61 
62#### Faster, Smarter Multilingual Performance
63By offloading complex translation tasks to specialized T-LMs, Lara reduces computational overhead and minimizes latency—a common issue for LLMs handling non-English input. Its architecture processes translations in parallel with the LLM, enabling for real-time, high-quality output without compromising speed or efficiency.
64 
65#### Cost-Efficient Translation at Scale
66Lara also lowers the cost of using models like GPT-4 in non-English workflows. Since tokenization (and pricing) is optimized for English, using Lara allows translation to take place before hitting the LLM, meaning that only the translated English content is processed. This improves cost efficiency and supports competitive scalability for global enterprises.
67</details>
68 
69## 🛠 Available Tools
70 
71### Translation Tools
72 
73<details>
74<summary><strong>translate</strong> - Translate text between languages</summary>
75 
76**Inputs**:
77- `text` (array): An array of text blocks to translate, each with:
78    - `text` (string): The text content
79    - `translatable` (boolean): Whether this block should be translated
80- `source` (optional string): Source language code (e.g., 'en-EN')
81- `target` (string): Target language code (e.g., 'it-IT')
82- `context` (optional string): Additional context to improve translation quality
83- `instructions` (optional string[]): Instructions to adjust translation behavior
84- `source_hint` (optional string): Guidance for language detection
85- `glossaries` (optional string[]): Array of glossary IDs to enforce terminology (e.g., ['gls_xyz123'])
86- `no_trace` (optional boolean): Privacy flag - if true, request won't be traced/logged
87- `priority` (optional string): Translation priority - 'normal' or 'background'
88- `timeout_in_millis` (optional number): Custom timeout in milliseconds
89 
90**Returns**: Translated text blocks maintaining the original structure
91</details>
92 
93### Glossaries Tools
94 
95<details>
96<summary><strong>list_glossaries</strong> - List all glossaries</summary>
97 
98**Inputs**: None
99 
100**Returns**: Array of glossaries with their details (id, name, createdAt, updatedAt, ownerId)
101</details>
102 
103<details>
104<summary><strong>get_glossary</strong> - Get a specific glossary by ID</summary>
105 
106**Inputs**:
107- `id` (string): The glossary ID (e.g., 'gls_xyz123')
108 
109**Returns**: Glossary object or null if not found
110</details>
111 
112### Translation Memories Tools
113 
114<details>
115 
116<summary><strong>list_memories</strong> - List saved translation memories</summary>
117 
118**Returns**: Array of memories and their details
119</details>
120 
121<details>
122<summary><strong>create_memory</strong> - Create a new translation memory</summary>
123 
124**Inputs**:
125- `name` (string): Name of the new memory
126- `external_id` (optional string): ID of the memory to import from MyMemory (e.g., 'ext_my_[MyMemory ID]')
127 
128**Returns**: Created memory data
129</details>
130 
131<details>
132<summary><strong>update_memory</strong> - Update translation memory name</summary>
133 
134**Inputs**:
135- `id` (string): ID of the memory to update
136- `name` (string): The new name for the memory
137 
138**Returns**: Updated memory data
139</details>
140 
141<details>
142<summary><strong>delete_memory</strong> - Delete a translation memory</summary>
143 
144**Inputs**:
145- `id` (string): ID of the memory to delete
146 
147**Returns**: Deleted memory data
148</details>
149 
150<details>
151<summary><strong>add_translation</strong> - Add a translation unit to memory</summary>
152 
153**Inputs**:
154- `id` (string | string[]): ID or IDs of memories where to add the translation unit
155- `source` (string): Source language code
156- `target` (string): Target language code
157- `sentence` (string): The source sentence
158- `translation` (string): The translated sentence
159- `tuid` (optional string): Translation Unit unique identifier
160- `sentence_before` (optional string): Context sentence before
161- `sentence_after` (optional string): Context sentence after
162 
163**Returns**: Added translation details
164</details>
165 
166<details>
167<summary><strong>delete_translation</strong> - Delete a translation unit from memory</summary>
168 
169**Inputs**:
170- `id` (string): ID of the memory
171- `source` (string): Source language code
172- `target` (string): Target language code
173- `sentence` (string): The source sentence
174- `translation` (string): The translated sentence
175- `tuid` (optional string): Translation Unit unique identifier
176- `sentence_before` (optional string): Context sentence before
177- `sentence_after` (optional string): Context sentence after
178 
179**Returns**: Removed translation details
180</details>
181 
182<details>
183<summary><strong>import_tmx</strong> - Import a TMX file into a memory</summary>
184 
185**Inputs**:
186- `id` (string): ID of the memory to update
187- `tmx_content` (string): The content of the tmx file to upload
188- `gzip` (boolean): Indicates if the file is compressed (.gz)
189 
190**Returns**: Import details
191</details>
192 
193<details>
194<summary><strong>check_import_status</strong> - Checks the status of a TMX file import</summary>
195 
196**Inputs**:
197- `id` (string): The ID of the import job
198 
199**Returns**: Import details
200</details>
201 
202## 🚀 Getting Started
203Lara supports both the STDIO and streamable HTTP protocols. For a hassle-free setup, we recommend using the HTTP protocol. If you prefer to use STDIO, it must be installed locally on your machine.
204 
205You'll find setup instructions for both protocols in the sections below.
206 
207## ⚠️ Security Note
208 
209**Important:** When running your own HTTP server instance (not using the remote `https://mcp.laratranslate.com/v1`), all connected clients share the same Lara API credentials configured via `LARA_ACCESS_KEY_ID` and `LARA_ACCESS_KEY_SECRET` environment variables.
210 
211This server is designed for:
212- ✅ Single-user deployments
213- ✅ Trusted-environment deployments (e.g., internal tools)
214 
215For multi-tenant scenarios, either:
216- Use the remote server at `https://mcp.laratranslate.com/v1` where each client provides their own credentials via headers
217- Deploy separate MCP server instances per user with isolated credentials
218 
219### HTTP Server 🌐
220<details>
221<summary><strong>❌ Clients NOT supporting <code>url</code> configuration (e.g., Claude, OpenAI)</strong></summary>
222 
223This installation guide is intended for clients that do NOT support the url-based configuration. This option requires Node.js to be installed on your system.
224 
225> If you're unsure how to configure an MCP with your client, please refer to your MCP client's official documentation.
226 
227---
228 
2291. Open your client's MCP configuration JSON file with a text editor, then copy and paste the following snippet:
230 
231```json
232{
233  "mcpServers": {
234    "lara": {
235      "command": "npx",
236      "args": [
237        "mcp-remote",
238        "https://mcp.laratranslate.com/v1",
239        "--header",
240        "x-lara-access-key-id: ${X_LARA_ACCESS_KEY_ID}",
241        "--header",
242        "x-lara-access-key-secret: ${X_LARA_ACCESS_KEY_SECRET}"
243      ],
244      "env": {
245        "X_LARA_ACCESS_KEY_ID": "<YOUR_ACCESS_KEY_ID>",
246        "X_LARA_ACCESS_KEY_SECRET": "<YOUR_ACCESS_KEY_SECRET>"
247      }
248    }
249  }
250}
251```
252 
2532. Replace `<YOUR_ACCESS_KEY_ID>` and `<YOUR_ACCESS_KEY_SECRET>` with your Lara Translate API credentials. Refer to the [Official Documentation](https://developers.laratranslate.com/docs/getting-started#step-3---configure-your-credentials) for details.
254 
2553. Restart your MCP client.
256 
257</details>
258 
259<details>
260<summary><strong>✅ Clients supporting <code>url</code> configuration (e.g., Cursor, Continue)</strong></summary>
261 
262This installation guide is intended for clients that support the url-based configuration. These clients can connect to Lara through a remote HTTP endpoint by specifying a simple configuration object.
263 
264Some examples of supported clients include Cursor, Continue, OpenDevin, and Aider.
265> If you're unsure how to configure an MCP with your client, please refer to your MCP client's official documentation.
266 
267---
268 
2691. Open your client's MCP configuration JSON file with a text editor, then copy and paste the following snippet:
270 
271```json
272{
273  "mcpServers": {
274    "lara": {
275      "url": "https://mcp.laratranslate.com/v1",
276      "headers": {
277        "x-lara-access-key-id": "<YOUR_ACCESS_KEY_ID>",
278        "x-lara-access-key-secret": "<YOUR_ACCESS_KEY_SECRET>"
279      }
280    }
281  }
282}
283```
284 
2852. Replace `<YOUR_ACCESS_KEY_ID>` and `<YOUR_ACCESS_KEY_SECRET>` with your Lara Translate API credentials. Refer to the [Official Documentation](https://developers.laratranslate.com/docs/getting-started#step-3---configure-your-credentials) for details.
286 
2873. Restart your MCP client.
288 
289</details>
290 
291---
292 
293### STDIO Server 🖥️
294<details>
295<summary><strong>Using NPX</strong></summary>
296 
297This option requires Node.js to be installed on your system.
298 
2991. Add the following to your MCP configuration file:
300```json
301{
302  "mcpServers": {
303    "lara-translate": {
304      "command": "npx",
305      "args": ["-y", "@translated/lara-mcp@latest"],
306      "env": {
307        "LARA_ACCESS_KEY_ID": "<YOUR_ACCESS_KEY_ID>",
308        "LARA_ACCESS_KEY_SECRET": "<YOUR_ACCESS_KEY_SECRET>"
309      }
310    }
311  }
312}
313```
314 
3152. Replace `<YOUR_ACCESS_KEY_ID>` and `<YOUR_ACCESS_KEY_SECRET>` with your actual Lara API credentials.
316</details>
317 
318<details>
319<summary><strong>Using Docker</strong></summary>
320 
321This option requires Docker to be installed on your system.
322 
3231. Add the following to your MCP configuration file:
324```json
325{
326  "mcpServers": {
327    "lara-translate": {
328      "command": "docker",
329      "args": [
330        "run",
331        "-i",
332        "--rm",
333        "-e",
334        "LARA_ACCESS_KEY_ID",
335        "-e",
336        "LARA_ACCESS_KEY_SECRET",
337        "translatednet/lara-mcp:latest"
338      ],
339      "env": {
340        "LARA_ACCESS_KEY_ID": "<YOUR_ACCESS_KEY_ID>",
341        "LARA_ACCESS_KEY_SECRET": "<YOUR_ACCESS_KEY_SECRET>"
342      }
343    }
344  }
345}
346```
347 
3482. Replace `<YOUR_ACCESS_KEY_ID>` and `<YOUR_ACCESS_KEY_SECRET>` with your actual Lara API credentials.
349</details>
350 
351<details>
352<summary><strong>Building from Source</strong></summary>
353 
354#### Using Node.js
355 
3561. Clone the repository:
357```bash
358git clone https://github.com/translated/lara-mcp.git
359cd lara-mcp
360```
361 
3622. Install dependencies and build:
363```bash
364# Install dependencies
365pnpm install
366 
367# Build
368pnpm run build
369```
370 
3713. Add the following to your MCP configuration file:
372```json
373{
374  "mcpServers": {
375    "lara-translate": {
376      "command": "node",
377      "args": ["<FULL_PATH_TO_PROJECT_FOLDER>/dist/index.js"],
378      "env": {
379        "LARA_ACCESS_KEY_ID": "<YOUR_ACCESS_KEY_ID>",
380        "LARA_ACCESS_KEY_SECRET": "<YOUR_ACCESS_KEY_SECRET>"
381      }
382    }
383  }
384}
385```
3864. Replace:
387   - `<FULL_PATH_TO_PROJECT_FOLDER>` with the absolute path to your project folder
388   - `<YOUR_ACCESS_KEY_ID>` and `<YOUR_ACCESS_KEY_SECRET>` with your actual Lara API credentials.
389 
390#### Building a Docker Image
391 
3921. Clone the repository:
393```bash
394git clone https://github.com/translated/lara-mcp.git
395cd lara-mcp
396```
397 
3982. Build the Docker image:
399```bash
400docker build -t lara-mcp .
401```
402 
4033. Add the following to your MCP configuration file:
404```json
405{
406  "mcpServers": {
407    "lara-translate": {
408      "command": "docker",
409      "args": [
410        "run",
411        "-i",
412        "--rm",
413        "-e",
414        "LARA_ACCESS_KEY_ID",
415        "-e",
416        "LARA_ACCESS_KEY_SECRET",
417        "lara-mcp"
418      ],
419      "env": {
420        "LARA_ACCESS_KEY_ID": "<YOUR_ACCESS_KEY_ID>",
421        "LARA_ACCESS_KEY_SECRET": "<YOUR_ACCESS_KEY_SECRET>"
422      }
423    }
424  }
425}
426```
427 
4284. Replace `<YOUR_ACCESS_KEY_ID>` and `<YOUR_ACCESS_KEY_SECRET>` with your actual credentials.
429</details>
430 
431## 🧪 Verify Installation
432 
433After restarting your MCP client, you should see Lara Translate MCP in the list of available MCPs.
434> The method for viewing installed MCPs varies by client. Please consult your MCP client's documentation.
435 
436To verify that Lara Translate MCP is working correctly, try translating with a simple prompt:
437```text
438Translate with Lara "Hello world" to Spanish
439```
440 
441Your MCP client will begin generating a response. If Lara Translate MCP is properly installed and configured, your client will either request approval for the action or display a notification that Lara Translate is being used.
442 
443## 💻 Popular Clients that supports MCPs 
444 
445> For a complete list of MCP clients and their feature support, visit the [official MCP clients page](https://modelcontextprotocol.io/clients).
446 
447| Client                                                            | Description                                          |
448|-------------------------------------------------------------------|------------------------------------------------------|
449| [Claude Desktop](https://claude.ai/download)                      | Desktop application for Claude AI                    |
450| [Aixplain](https://aixplain.com/)                                 | Production-ready AI Agents                           |
451| [Cursor](https://www.cursor.com/)                                 | AI-first code editor                                 |
452| [Cline for VS Code](https://github.com/cline/cline)               | VS Code extension for AI assistance                  |
453| [GitHub Copilot MCP](https://github.com/VikashLoomba/copilot-mcp) | VS Code extension for GitHub Copilot MCP integration |
454| [Windsurf](https://windsurf.com/editor)                           | AI-powered code editor and development environment   |
455 
456## 🆘 Support
457 
458- For issues with Lara Translate API: Visit [Lara Translate API and Integrations Support](https://support.laratranslate.com)
459- For issues with this MCP Server: Open an issue on [GitHub](https://github.com/translated/lara-mcp/issues)
460