---
title: "Connect LILT to Claude: Manage Global Projects & Document Assets"
slug: connect-lilt-to-claude-manage-global-projects-document-assets
date: 2026-06-19
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "A definitive engineering guide to connecting LILT to Claude via MCP. Automate document translations, project management, and translation memory updates."
tldr: "Learn how to connect LILT to Claude using a managed MCP server. This guide covers LILT API quirks, secure server generation, and automated translation workflows using natural language."
canonical: https://truto.one/blog/connect-lilt-to-claude-manage-global-projects-document-assets/
---

# Connect LILT to Claude: Manage Global Projects & Document Assets


If your global localization team needs to connect LILT to Claude to automate document translation pipelines, manage translation memory assets, or coordinate global projects, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This infrastructure layer acts as the bridge between Claude's natural language tool calls and LILT's specialized translation REST APIs. If your team uses ChatGPT instead, check out our companion guide on [connecting LILT to ChatGPT](https://truto.one/connect-lilt-to-chatgpt-automate-translation-ai-content-creation/), or explore our broader architectural overview on [connecting LILT to AI Agents](https://truto.one/connect-lilt-to-ai-agents-sync-translation-memory-job-workflows/).

Giving a Large Language Model (LLM) read and write access to an enterprise localization platform is an engineering challenge. You have to handle OAuth token lifecycles, map massive translation JSON schemas to MCP tool definitions, and handle LILT's unique quirks around binary file streaming and asynchronous translation jobs. Every time LILT updates an endpoint, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, [managed MCP server](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) for LILT, connect it natively to Claude, and execute complex translation workflows using natural language.

## The Engineering Reality of the LILT API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against LILT's API requires dealing with domain-specific localization complexities. If you decide to build a custom MCP server for LILT, here are the specific challenges you will face:

**Opaque Binary Streams and File Encodings**
Unlike standard SaaS APIs that traffic entirely in JSON, LILT deals heavily in files. When you request a translated document (`get_single_lilt_document_by_id`), the API does not return a JSON object. It returns a raw binary file stream, defaulting to XLIFF 1.2 format unless specifically flagged with `is_xliff=false`. Your MCP server must be capable of handling binary buffers and writing them directly to disk. Furthermore, when uploading documents, LILT requires that file names contain only US-ASCII characters. Your integration layer must implement URI-encoding or transliteration for any non-ASCII characters before the request hits LILT.

**Asynchronous Language Detection and S3 Uploads**
When you upload a file via `create_a_lilt_file`, the language detection process runs asynchronously. The API returns an initial ID, but you must poll the `GET /v2/files` endpoint to monitor the `detected_lang_confidence` results. For large files, LILT utilizes a complex multipart S3 upload flow requiring you to request presigned S3 URLs, chunk the file, PUT the chunks directly to Amazon S3, and finally call a completion endpoint with ETags. Hand-coding this logic into an MCP tool definition is notoriously error-prone.

**Rate Limits and Standardized Headers**
LILT enforces rate limits on its API to ensure platform stability. A critical engineering reality to understand when using Truto as your MCP layer is how these limits are handled: **Truto does not retry, throttle, or apply backoff on rate limit errors.** When the LILT API returns an HTTP 429 Too Many Requests error, Truto passes that error directly through to the caller. 

However, Truto heavily normalizes the upstream rate limit information into standardized headers per the IETF specification (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). This means your agent framework or the Claude client knows exactly when it is safe to try again. The caller is strictly responsible for implementing its own retry logic and exponential backoff based on these headers.

## How to Generate a LILT MCP Server with Truto

Truto dynamically generates MCP tools from LILT's API documentation and your integration's configuration. The resulting MCP server is scoped to a specific LILT tenant (an "integrated account"), and authenticated via a secure token. 

You can generate this server via the Truto UI or programmatically via the API.

### Method 1: Via the Truto UI

For ad-hoc agent setups or internal IT tooling, the UI is the fastest path:

1. Log in to the Truto dashboard and navigate to the **Integrated Accounts** page for your LILT connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Configure the server. You can restrict the agent to read-only access by filtering methods, or scope it to specific tags (e.g., limiting the agent to only access "documents" and "projects").
5. Copy the generated MCP Server URL (e.g., `https://api.truto.one/mcp/abc123def456...`).

### Method 2: Via the Truto API

If you are building an AI product and need to programmatically provision LILT access for your customers, use the API. This endpoint creates the server, stores the hashed token in high-availability KV storage, and returns the endpoint.

**Request:**
```bash
curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer <YOUR_TRUTO_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Claude LILT Translation Server",
    "config": {
      "methods": ["read", "write"],
      "tags": ["projects", "documents", "memories"]
    },
    "expires_at": null
  }'
```

**Response:**
```json
{
  "id": "mcp_srv_8f92b...",
  "name": "Claude LILT Translation Server",
  "config": {
    "methods": ["read", "write"],
    "tags": ["projects", "documents", "memories"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/abc123def456..."
}
```

## Connecting the LILT MCP Server to Claude

Once you have your Truto MCP URL, connecting it to Claude requires zero additional code. The URL itself acts as the transport layer and the authentication vector.

### Method A: Via the Claude UI (or ChatGPT Web)

If you are using Anthropic's hosted Claude interfaces or ChatGPT:

1. In Claude, navigate to **Settings -> Integrations**. (In ChatGPT, this is under **Settings -> Apps -> Advanced Settings -> Developer Mode**).
2. Click **Add MCP Server** or **Add Custom Connector**.
3. Paste the Truto MCP URL.
4. Click **Add**. 

Claude will immediately hit the JSON-RPC `initialize` and `tools/list` endpoints, automatically discovering all permitted LILT tools.

### Method B: Via Manual Config File (Claude Desktop)

For local AI agents running via Claude Desktop, you modify the MCP configuration JSON file directly.

Open your `claude_desktop_config.json` file. On macOS, this is located at `~/Library/Application Support/Claude/claude_desktop_config.json`. On Windows, it resides in `%APPDATA%\Claude\claude_desktop_config.json`.

Add the LILT server using the `npx @modelcontextprotocol/server-sse` command to handle the Server-Sent Events transport:

```json
{
  "mcpServers": {
    "lilt-localization": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/abc123def456..."
      ]
    }
  }
}
```
Restart Claude Desktop. The LILT integration will now appear in your available tools.

## High-Leverage LILT Tools for AI Agents

Truto normalizes the sprawling LILT API into clean, descriptive MCP tools. Here are the core hero tools that unlock powerful localization workflows for your AI agents.

### 1. Create a LILT Project
`create_a_lilt_project`

Projects in LILT act as containers for documents, and are strictly associated with exactly one Translation Memory. Agents use this tool to initialize new translation workflows targeting specific language pairs.

> "Initialize a new LILT project for our Q4 Marketing rollout using the Spanish-to-English translation memory ID 54321."

### 2. Upload a LILT Document
`create_a_lilt_document`

This tool allows the agent to upload files directly into LILT to create a new Document. Note that LILT requires file names to be strictly US-ASCII. Truto exposes the `project_id` and `name` properties securely.

> "Upload the file 'Q4_campaign_draft.docx' to the LILT project we just created. Ensure the document status is tracked."

### 3. Generate a Translation via Memory
`create_a_lilt_translation`

This is the core translation operation. The agent sends a source string, and LILT returns an array of translation candidates. TM fuzzy matches are ranked first, followed by raw machine translation results, along with confidence scores and word alignments.

> "Translate the string 'User authentication has failed. Please reset your password.' Check the translation candidates and return the one with the highest confidence score."

### 4. Search LILT Memory
`lilt_memories_search`

Before executing blind translations, agents can query a specific Translation Memory for existing segments matching a source string. Segments scoring below 75 are automatically discarded by the API, ensuring high-quality context retrieval.

> "Query our main product Translation Memory for the phrase 'Dashboard analytics'. Do we already have an established localized string for this?"

### 5. Create a LILT Job
`create_a_lilt_job`

Jobs in LILT group multiple projects together when targeting multiple language pairs for a single source asset. This allows an AI agent to orchestrate large-scale localization across five or ten regions simultaneously.

> "Create a new LILT job named 'Global Privacy Policy Update'. Set the due date for next Friday, the source language to English, and target language pairs for French, German, and Japanese."

### 6. Download Translated Document
`get_single_lilt_document_by_id`

Once translation is complete, this tool retrieves the finalized document. By default, it requests the XLIFF 1.2 format, but agents can set `is_xliff=false` to retrieve the original uploaded format. The agent will need backend capabilities to stream and save the resulting binary data.

> "The privacy policy translation is finished. Download the finalized document for ID 98765 in its original DOCX format, not XLIFF."

To view the complete inventory of LILT resources, pagination schemas, and required properties, visit the [LILT integration page](https://truto.one/integrations/detail/lilt).

## Workflows in Action

With LILT exposed as MCP tools, Claude transitions from a passive conversational assistant into an active localization project manager. Here is how complex workflows execute in practice.

### Scenario 1: Automated Multi-Region Localization Pipeline

Your product team drops a new set of English release notes. They need it translated into Spanish and German, utilizing existing company terminology.

**User Prompt:**
> "We just finalized the v2.4 Release Notes. Create a new LILT Job for this targeting Spanish and German. Once the job is created, initialize the underlying projects using our standard EU Translation Memory, and upload the 'v2.4_notes.txt' file for translation processing."

**Execution Steps:**
1. **`create_a_lilt_job`**: Claude calls this tool to establish the overarching job container, specifying `srcLang` as English and `languagePairs` for ES and DE.
2. **`list_all_lilt_memories`**: The agent queries available memories to locate the ID for the "Standard EU Translation Memory" to ensure brand terminology is respected.
3. **`create_a_lilt_project`**: Claude provisions two distinct projects inside the job (one for Spanish, one for German), linking them to the retrieved Memory ID.
4. **`create_a_lilt_document`**: Finally, the agent uploads the text file to the respective projects, setting the stage for human reviewers or automatic translation.

**Outcome:** The user receives confirmation that the localization pipeline has been fully staged in LILT, saving a project manager 20 minutes of manual clicking in the LILT dashboard.

```mermaid
sequenceDiagram
    participant User
    participant Agent as "Claude"
    participant Truto as "Truto MCP Server"
    participant Lilt as "LILT API"

    User->>Agent: "Create localization pipeline for v2.4..."
    Agent->>Truto: call_tool("create_a_lilt_job")
    Truto->>Lilt: POST /v2/jobs
    Lilt-->>Truto: job_id: 1045
    Truto-->>Agent: Result: Success
    Agent->>Truto: call_tool("create_a_lilt_project")
    Truto->>Lilt: POST /v2/projects
    Lilt-->>Truto: project_id: 8821
    Truto-->>Agent: Result: Success
    Agent->>User: "Pipeline created. Job 1045 is ready for review."
```

### Scenario 2: Translation Memory Enrichment

Your support team notices a recurring user issue and wants to ensure the localized response is permanently added to the machine translation engine.

**User Prompt:**
> "Check our Support Translation Memory for the phrase 'Clear your browser cache and restart the application'. If it isn't there, generate an optimized machine translation for Spanish, verify the confidence score is above 85, and add it as a new segment to the memory."

**Execution Steps:**
1. **`lilt_memories_search`**: Claude queries the TM. Because LILT automatically discards scores below 75, the agent receives an empty response indicating no high-quality match exists.
2. **`create_a_lilt_translation`**: The agent requests a fresh translation of the source string from LILT's MT engine.
3. **Analysis**: Claude evaluates the returned payload. It checks the `score` attribute of the best candidate to ensure it exceeds the requested 85 threshold.
4. **`create_a_lilt_segment`**: Upon verifying the score, Claude creates a new Segment, passing the English source and the Spanish target, permanently updating the Translation Memory for all future use.

**Outcome:** The organizational translation memory is enriched autonomously, ensuring future support tickets are translated with verified, high-quality phrasing.

## Security and Access Control

Giving AI agents write access to enterprise translation assets requires strict governance. Truto's MCP architecture enforces security at the protocol level:

*   **Method Filtering**: You can configure the MCP token to restrict the server to `read` operations only (e.g., searching memories, downloading files) preventing the agent from creating or deleting jobs.
*   **Tag Filtering**: Scope the MCP server to specific LILT domains by filtering tags. For example, you can expose only `documents` and `memories`, hiding administrative endpoints.
*   **Conditional Authentication (`require_api_token_auth`)**: If enabled, possession of the MCP URL is not enough. The Claude client must also pass a valid Truto API token in the Authorization header to verify caller identity.
*   **Ephemeral Servers (`expires_at`)**: Generate short-lived MCP servers for contractor agents or temporary automation tasks. Once the ISO datetime is reached, the server self-destructs at the KV storage level, immediately revoking API access.
*   **Zero Data Retention**: Truto operates entirely as a pass-through proxy. Your proprietary LILT documents, translation memories, and XLIFF files are [never stored or cached on Truto's infrastructure](https://truto.one/zero-data-retention-mcp-servers-building-soc-2-gdpr-compliant-ai-agents/).

## Final Thoughts on LILT Integration

Building a custom LILT integration for an AI agent means committing to a perpetual maintenance cycle. You own the OAuth refreshes, the S3 multipart upload logic, and the binary stream handling. When LILT deprecates an endpoint or changes a pagination schema, your AI pipelines break.

By leveraging Truto's dynamically generated MCP servers, you offload the infrastructure boilerplate entirely. You get a secure, standardized JSON-RPC 2.0 endpoint that natively understands LILT's nuances - allowing your engineering team to focus on building intelligent localization workflows instead of managing API connections.

> Want to give your AI agents secure, read/write access to LILT and 100+ other enterprise APIs? Get started with Truto's managed MCP infrastructure today.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)