Lara Translate MCP Server

What is Lara Translate MCP Server about?

Enables AI applications to perform professional‑grade translations by connecting to Lara Translate's API through a standardized Model Context Protocol interface. It supports direct text translation, language detection, context‑driven improvements, and full translation‑memory operations.

How to use Lara Translate MCP Server?

1. Choose a transport – HTTP (remote endpoint) or STDIO (local process).
2. Configure credentials – set LARA_ACCESS_KEY_ID and LARA_ACCESS_KEY_SECRET (or the corresponding header values) with your Lara API keys.
3. Add the server to your MCP client using the JSON snippets provided in the README (either url/headers for HTTP or command/args/env for STDIO).
4. Restart the client; the translation tools become available for prompts such as: Translate with Lara "Hello world" to Spanish.

Key Features

• translate – batch translation with optional source language, target language, context, and custom instructions.
• list_memories / create_memory / update_memory / delete_memory – complete CRUD for translation memories.
• add_translation / delete_translation – manage individual translation units within memories.
• import_tmx / check_import_status – import TMX files (including gzip) and monitor import progress.
• Supports both HTTP (remote URL) and STDIO (local executable) deployment models.
• Official Docker image (translatednet/lara-mcp) and npm package (@translated/lara-mcp).

Use Cases

• Integrating high‑quality, domain‑specific translations into LLM‑driven agents without embedding API calls directly.
• Maintaining and reusing translation memories for consistent terminology across projects.
• Bulk translating documentation, UI strings, or marketing copy with context‑aware adjustments.
• Providing on‑the‑fly language detection and translation in chat‑based assistants.

FAQ

Q: Do I need to run a local server? A: No. You can use the hosted HTTP endpoint (https://mcp.laratranslate.com/v1) or run the server locally via STDIO or Docker.

Q: Which environment variables are required? A: LARA_ACCESS_KEY_ID and LARA_ACCESS_KEY_SECRET must be set with your Lara Translate credentials.

Q: Can I use the server with clients that only support URL configuration? A: Yes. Provide the url and headers fields in the client’s MCP configuration.

Q: How do I import an existing TMX translation memory? A: Call the import_tmx tool with id of the target memory, the TMX content string, and set gzip to true if the file is compressed. Monitor with check_import_status.

Q: Is there a Docker‑free way to run the server? A: Use npx @translated/lara-mcp@latest (STDIO) after installing Node.js, or build from source with pnpm.

Lara Translate MCP Server

A Model Context Protocol (MCP) Server for Lara Translate API, enabling powerful translation capabilities with support for language detection, context-aware translations and translation memories.

📚 Table of Contents

• 📖 Introduction
• 🛠 Available Tools
• 🚀 Getting Started
  • 📋 HTTP Server
  • 🔌 STDIO Server
• 🧪 Verify Installation
• 💻 Popular Clients that supports MCPs
• 🆘 Support

📖 Introduction

Model 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.

Lara Translate MCP Server enables AI applications to access Lara Translate's powerful translation capabilities through this standardized protocol.

More info about Model Context Protocol on: https://modelcontextprotocol.io/

Lara Translate MCP Server implements the Model Context Protocol to provide seamless translation capabilities to AI applications. The integration follows this flow:

1. Connection Establishment: When an MCP-compatible AI application starts, it connects to configured MCP servers, including the Lara Translate MCP Server
2. Tool & Resource Discovery: The AI application discovers available translation tools and resources provided by the Lara Translate MCP Server
3. Request Processing: When translation needs are identified:
   • The AI application formats a structured request with text to translate, language pairs, and optional context
   • The MCP server validates the request and transforms it into Lara Translate API calls
   • The request is securely sent to Lara Translate's API using your credentials
4. Translation & Response: Lara Translate processes the translation using advanced AI models
5. Result Integration: The translation results are returned to the AI application, which can then incorporate them into its response

This 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.

Integrating Lara with LLMs creates a powerful synergy that significantly enhances translation quality for non-English languages.

Why General LLMs Fall Short in Translation

While 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.

Lara’s Domain-Specific Advantage

Lara 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.

Designed for Non-English Strength

Lara 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.

Faster, Smarter Multilingual Performance

By 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.

Cost-Efficient Translation at Scale

Lara 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.

🛠 Available Tools

Translation Tools

Inputs:

• text (array): An array of text blocks to translate, each with:
  • text (string): The text content
  • translatable (boolean): Whether this block should be translated
• source (optional string): Source language code (e.g., 'en-EN')
• target (string): Target language code (e.g., 'it-IT')
• context (optional string): Additional context to improve translation quality
• instructions (optional string[]): Instructions to adjust translation behavior
• source_hint (optional string): Guidance for language detection

Returns: Translated text blocks maintaining the original structure

Translation Memories Tools

Returns: Array of memories and their details

Inputs:

• name (string): Name of the new memory
• external_id (optional string): ID of the memory to import from MyMemory (e.g., 'ext_my_[MyMemory ID]')

Returns: Created memory data

Inputs:

• id (string): ID of the memory to update
• name (string): The new name for the memory

Returns: Updated memory data

Inputs:

• id (string): ID of the memory to delete

Returns: Deleted memory data

Inputs:

• id (string | string[]): ID or IDs of memories where to add the translation unit
• source (string): Source language code
• target (string): Target language code
• sentence (string): The source sentence
• translation (string): The translated sentence
• tuid (optional string): Translation Unit unique identifier
• sentence_before (optional string): Context sentence before
• sentence_after (optional string): Context sentence after

Returns: Added translation details

Inputs:

• id (string): ID of the memory
• source (string): Source language code
• target (string): Target language code
• sentence (string): The source sentence
• translation (string): The translated sentence
• tuid (optional string): Translation Unit unique identifier
• sentence_before (optional string): Context sentence before
• sentence_after (optional string): Context sentence after

Returns: Removed translation details

Inputs:

• id (string): ID of the memory to update
• tmx_content (string): The content of the tmx file to upload
• gzip (boolean): Indicates if the file is compressed (.gz)

Returns: Import details

Inputs:

• id (string): The ID of the import job

Returns: Import details

🚀 Getting Started

Lara 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.

You'll find setup instructions for both protocols in the sections below.

HTTP Server 🌐

This 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.

If you're unsure how to configure an MCP with your client, please refer to your MCP client's official documentation.

---

1. Open your client's MCP configuration JSON file with a text editor, then copy and paste the following snippet:

{
  "mcpServers": {
    "lara": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.laratranslate.com/v1",
        "--header",
        "x-lara-access-key-id: ${X_LARA_ACCESS_KEY_ID}",
        "--header",
        "x-lara-access-key-secret: ${X_LARA_ACCESS_KEY_SECRET}"
      ],
      "env": {
        "X_LARA_ACCESS_KEY_ID": "<YOUR_ACCESS_KEY_ID>",
        "X_LARA_ACCESS_KEY_SECRET": "<YOUR_ACCESS_KEY_SECRET>"
      }
    }
  }
}

2. Replace <YOUR_ACCESS_KEY_ID> and <YOUR_ACCESS_KEY_SECRET> with your Lara Translate API credentials. Refer to the Official Documentation for details.

3. Restart your MCP client.

This 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.

Some examples of supported clients include Cursor, Continue, OpenDevin, and Aider.

If you're unsure how to configure an MCP with your client, please refer to your MCP client's official documentation.

---

1. Open your client's MCP configuration JSON file with a text editor, then copy and paste the following snippet:

{
  "mcpServers": {
    "lara": {
      "url": "https://mcp.laratranslate.com/v1",
      "headers": {
        "x-lara-access-key-id": "<YOUR_ACCESS_KEY_ID>",
        "x-lara-access-key-secret": "<YOUR_ACCESS_KEY_SECRET>"
      }
    }
  }
}

2. Replace <YOUR_ACCESS_KEY_ID> and <YOUR_ACCESS_KEY_SECRET> with your Lara Translate API credentials. Refer to the Official Documentation for details.

3. Restart your MCP client.

---

STDIO Server 🖥️

This option requires Node.js to be installed on your system.

1. Add the following to your MCP configuration file:

{
  "mcpServers": {
    "lara-translate": {
      "command": "npx",
      "args": ["-y", "@translated/lara-mcp@latest"],
      "env": {
        "LARA_ACCESS_KEY_ID": "<YOUR_ACCESS_KEY_ID>",
        "LARA_ACCESS_KEY_SECRET": "<YOUR_ACCESS_KEY_SECRET>"
      }
    }
  }
}

2. Replace <YOUR_ACCESS_KEY_ID> and <YOUR_ACCESS_KEY_SECRET> with your actual Lara API credentials.

This option requires Docker to be installed on your system.

1. Add the following to your MCP configuration file:

{
  "mcpServers": {
    "lara-translate": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "LARA_ACCESS_KEY_ID",
        "-e",
        "LARA_ACCESS_KEY_SECRET",
        "translatednet/lara-mcp:latest"
      ],
      "env": {
        "LARA_ACCESS_KEY_ID": "<YOUR_ACCESS_KEY_ID>",
        "LARA_ACCESS_KEY_SECRET": "<YOUR_ACCESS_KEY_SECRET>"
      }
    }
  }
}

2. Replace <YOUR_ACCESS_KEY_ID> and <YOUR_ACCESS_KEY_SECRET> with your actual Lara API credentials.

Using Node.js

1. Clone the repository:

git clone https://github.com/translated/lara-mcp.git
cd lara-mcp

2. Install dependencies and build:

# Install dependencies
pnpm install

# Build
pnpm run build

3. Add the following to your MCP configuration file:

{
  "mcpServers": {
    "lara-translate": {
      "command": "node",
      "args": ["<FULL_PATH_TO_PROJECT_FOLDER>/dist/index.js"],
      "env": {
        "LARA_ACCESS_KEY_ID": "<YOUR_ACCESS_KEY_ID>",
        "LARA_ACCESS_KEY_SECRET": "<YOUR_ACCESS_KEY_SECRET>"
      }
    }
  }
}

4. Replace:
   • <FULL_PATH_TO_PROJECT_FOLDER> with the absolute path to your project folder
   • <YOUR_ACCESS_KEY_ID> and <YOUR_ACCESS_KEY_SECRET> with your actual Lara API credentials.

Building a Docker Image

1. Clone the repository:

git clone https://github.com/translated/lara-mcp.git
cd lara-mcp

2. Build the Docker image:

docker build -t lara-mcp .

3. Add the following to your MCP configuration file:

{
  "mcpServers": {
    "lara-translate": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "LARA_ACCESS_KEY_ID",
        "-e",
        "LARA_ACCESS_KEY_SECRET",
        "lara-mcp"
      ],
      "env": {
        "LARA_ACCESS_KEY_ID": "<YOUR_ACCESS_KEY_ID>",
        "LARA_ACCESS_KEY_SECRET": "<YOUR_ACCESS_KEY_SECRET>"
      }
    }
  }
}

4. Replace <YOUR_ACCESS_KEY_ID> and <YOUR_ACCESS_KEY_SECRET> with your actual credentials.

🧪 Verify Installation

After restarting your MCP client, you should see Lara Translate MCP in the list of available MCPs.

The method for viewing installed MCPs varies by client. Please consult your MCP client's documentation.

To verify that Lara Translate MCP is working correctly, try translating with a simple prompt:

Translate with Lara "Hello world" to Spanish

Your 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.

💻 Popular Clients that supports MCPs

For a complete list of MCP clients and their feature support, visit the official MCP clients page.

Client	Description
Claude Desktop	Desktop application for Claude AI
Aixplain	Production-ready AI Agents
Cursor	AI-first code editor
Cline for VS Code	VS Code extension for AI assistance
GitHub Copilot MCP	VS Code extension for GitHub Copilot MCP integration
Windsurf	AI-powered code editor and development environment

🆘 Support

• For issues with Lara Translate API: Visit Lara Translate API and Integrations Support
• For issues with this MCP Server: Open an issue on GitHub