main

by dev.lingo

Server Details

Lingo.dev MCP Server - World-class i18n implementation with ICU MessageFormat.

Status: Healthy
Last Tested: 2026-08-18 00:36
Transport: Streamable HTTP
URL

Glama MCP Gateway

Connect through Glama MCP Gateway for full control over tool access and complete visibility into every call.

MCP client

Glama

MCP server

Full call logging

Every tool call is logged with complete inputs and outputs, so you can debug issues and audit what your agents are doing.

Tool access control

Enable or disable individual tools per connector, so you decide what your agents can and cannot do.

Managed credentials

Glama handles OAuth flows, token storage, and automatic rotation, so credentials never expire on your clients.

Usage analytics

See which tools your agents call, how often, and when, so you can understand usage patterns and catch anomalies.

100% free. Your data is private.

Tool Definition Quality

A4.4/5.0

Tool DescriptionsA

Average 4.5/5 across 4 of 4 tools scored.

Server CoherenceA

Disambiguation5/5

Each tool has a clearly distinct purpose: i18n_checklist orchestrates the workflow, get_project_context detects project setup, get_framework_docs fetches framework docs, and get_i18n_library_docs fetches library docs. Even though the two doc tools share a similar interface, their targets are explicitly different (framework vs library), and the checklist directs which to use when.

Naming Consistency4/5

Three tools follow the get_<object>_docs/context pattern, and i18n_checklist is a noun-style name. All are lowercase snake_case and descriptive, so the minor deviation from a strict verb_noun pattern is not confusing. The i18n_ prefix on the checklist also ties it to the server's domain.

Tool Count5/5

Four tools is well-scoped for a focused i18n implementation workflow. The checklist is the central orchestrator, with three supporting tools that each serve a necessary sub-task (context detection, framework docs, library docs). No tool feels redundant or missing.

Completeness5/5

The tool surface fully covers the i18n implementation lifecycle: i18n_checklist provides the step-by-step process, get_project_context gathers the required initial context, and the two doc tools supply current reference material. The checklist's evidence submission and build validation handle verification, so there are no obvious gaps or dead ends.

Available Tools

4 tools

get_framework_docsAInspect

Retrieves authoritative documentation directly from the framework's official repository.

When to Use

Called during i18n_checklist Steps 1-13.

The checklist tool coordinates when you need framework documentation. Each step will tell you if you need to fetch docs and which sections to read.

If you're implementing i18n: Let the checklist guide you. Don't call this independently

Why This Matters

Your training data is a snapshot. Framework APIs evolve. The fetched documentation reflects the current state of the framework the user is actually running. Following official docs ensures you're working with the framework, not against it.

How to Use

Two-Phase Workflow:

Discovery - Call with action="index" to see available sections
Reading - Call with action="read" and section_id to get full content

Parameters:

framework: Use the exact value from get_project_context output
version: Use "latest" unless you need version-specific docs
action: "index" or "read"
section_id: Required for action="read", format "fileIndex:headingIndex" (from index)

Example Flow:

// See what's available
get_framework_docs(framework="nextjs-app-router", action="index")

// Read specific section
get_framework_docs(framework="nextjs-app-router", action="read", section_id="0:2")

What You Get

Index: Table of contents with section IDs
Read: Full section with explanations and code examples

Use these patterns directly in your implementation.

ParametersJSON Schema

Name	Required	Description	Default
`action`	No		index
`context`	Yes	Explain why you are calling this tool and how it fits into the user's overall goal. This parameter is used for analytics and user intent tracking. YOU MUST provide 15-25 words (count carefully). NEVER use first person ('I', 'we', 'you') - maintain third-person perspective. NEVER include sensitive information such as credentials, passwords, or personal data. Example (20 words): "Searching across the organization's repositories to find all open issues related to performance complaints and latency issues for team prioritization."
`version`	No		latest
`framework`	Yes
`section_id`	No	Required if action='read'. Format: 'fileIndex:headingIndex'

Tool Definition Quality

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full behavioral burden. It discloses the two-phase workflow (index then read), explains how actions behave, and mentions the return content ('Table of contents' vs. 'Full section'). It lacks error/edge-case detail but is notably more transparent than typical tools.

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?

Well-structured with clear headers and a code example, making a long description scannable. The 'Why This Matters' section is slightly motivational but adds context. Every section contributes to usability, though a bit verbose.

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?

For a read-only docs tool with no output schema, the description explains workflow, parameters, and expected return values sufficiently. It ties into sibling tools (i18n_checklist, get_project_context) and provides an executable example. Missing edge-case behavior, but appropriate for the tool's simplicity.

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?

Description adds meaning beyond schema for action (via workflow), section_id (format and dependency on action), framework (exact value source), and version ('latest' default). It omits the context parameter, but the schema already covers that well. With only 40% schema coverage, description compensates substantially.

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 opens with a specific verb+resource: 'Retrieves authoritative documentation directly from the framework's official repository.' It clearly distinguishes itself from sibling tools by focusing on framework docs (vs. i18n library docs) and is unambiguous about its scope.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states when to use ('Called during i18n_checklist Steps 1-13'), when not to use ('Don't call this independently'), and references the coordinating checklist tool. Also directs users to get_project_context for the exact framework value, providing an alternative context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_i18n_library_docsAInspect

Retrieves authoritative documentation for i18n libraries (currently react-intl).

When to Use

Called during i18n_checklist Steps 7-10.

The checklist tool will tell you when you need i18n library documentation. Typically used when setting up providers, translation APIs, and UI components.

If you're implementing i18n: Let the checklist guide you. It will tell you when to fetch library docs

Why This Matters

Different i18n libraries have different APIs and patterns. Official docs ensure correct API usage, proper initialization, and best practices for the installed version.

How to Use

Two-Phase Workflow:

Discovery - Call with action="index"
Reading - Call with action="read" and section_id

Parameters:

library: Currently only "react-intl" supported
version: Use "latest"
action: "index" or "read"
section_id: Required for action="read"

Example:

get_i18n_library_docs(library="react-intl", action="index")
get_i18n_library_docs(library="react-intl", action="read", section_id="0:3")

What You Get

Index: Available documentation sections
Read: Full API references and usage examples

ParametersJSON Schema

Name	Required	Description	Default
`action`	No		index
`context`	Yes	Explain why you are calling this tool and how it fits into the user's overall goal. This parameter is used for analytics and user intent tracking. YOU MUST provide 15-25 words (count carefully). NEVER use first person ('I', 'we', 'you') - maintain third-person perspective. NEVER include sensitive information such as credentials, passwords, or personal data. Example (20 words): "Searching across the organization's repositories to find all open issues related to performance complaints and latency issues for team prioritization."
`library`	Yes
`version`	No		latest
`section_id`	No

Tool Definition Quality

A4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of disclosing behavior. It clearly describes a read-only retrieval pattern with a two-phase workflow (index then read), actions, and expected outputs ('Index: Available documentation sections; Read: Full API references and usage examples'). It does not explicitly say there are no side effects, but the terminology strongly implies a safe read operation.

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 description is well-structured with clear section headers (When to Use, How to Use, What You Get) and code examples. It is longer than average but each section adds value. Minor redundancy exists in the 'Why This Matters' section, which could be trimmed, but overall it is focused and front-loaded.

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?

Given there is no output schema and no annotations, the description provides a reasonable overall picture of a documentation-retrieval tool. It explains the workflow and results at a high level. However, the invalid examples omitting the required 'context' parameter, combined with the lack of details about the format of section_id or response structure, leave gaps for an agent using the tool on its own.

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?

The description meaningfully explains action, section_id, library, and version semantics beyond the schema, which has only 20% schema_description_coverage. However, it omits the required 'context' parameter from the parameter list and provides examples that omit it, making the example calls technically invalid. This is a notable gap, though it partially compensates for low schema coverage.

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 opens with a specific verb+resource: 'Retrieves authoritative documentation for i18n libraries (currently react-intl).' This immediately distinguishes it from sibling tools like get_framework_docs and get_project_context by focusing on i18n-specific library documentation. The title is null, but the description fully compensates with a clear action and resource.

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?

The 'When to Use' section explicitly anchors usage to i18n_checklist Steps 7-10 and says the checklist will guide the agent. However, it does not explicitly mention when not to use alternatives (e.g., get_framework_docs), nor does it contrast with those alternatives. The guidance is contextually strong but lacks an explicit exclusion statement.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_project_contextAInspect

Captures the user's project architecture to inform i18n implementation strategy.

When to Use

Called during i18n_checklist Step 1.

The checklist tool will tell you when to call this. If you're implementing i18n:

Call i18n_checklist(step_number=1, done=false) FIRST
The checklist will instruct you to call THIS tool
Then use the results for subsequent steps

Do NOT call this before calling the checklist tool

Why This Matters

Frameworks handle i18n through completely different mechanisms. The same outcome (locale-aware routing) requires different code for Next.js vs TanStack Start vs React Router. Without accurate detection, you'll implement patterns that don't work.

How to Use

Examine the user's project files (package.json, directories, config files)
Identify framework markers and version
Construct a detectionResults object matching the schema
Call this tool with your findings
Store the returned framework identifier for get_framework_docs calls

The schema requires:

framework: Exact variant (nextjs-app-router, nextjs-pages-router, tanstack-start, react-router)
majorVersion: Specific version number (13-16 for Next.js, 1 for TanStack Start, 7 for React Router)
sourceDirectory, hasTypeScript, packageManager
Any detected locale configuration
Any detected i18n library (currently only react-intl supported)

What You Get

Returns the framework identifier needed for documentation fetching. The 'framework' field in the response is the exact string you'll use with get_framework_docs.

ParametersJSON Schema

Name	Required	Description	Default
`context`	Yes	Explain why you are calling this tool and how it fits into the user's overall goal. This parameter is used for analytics and user intent tracking. YOU MUST provide 15-25 words (count carefully). NEVER use first person ('I', 'we', 'you') - maintain third-person perspective. NEVER include sensitive information such as credentials, passwords, or personal data. Example (20 words): "Searching across the organization's repositories to find all open issues related to performance complaints and latency issues for team prioritization."
`detectionResults`	Yes

Tool Definition Quality

A4.6/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses that the tool expects a pre-constructed detectionResults object, examines project files, and returns the framework identifier. It also notes the limitation that 'currently only react-intl supported.' It does not mention side effects, but this is a read-only analysis tool, so the behavior is adequately transparent.

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 description is longer than ideal but well-structured with clear headers and bullet points. Every section (When to Use, Why, How) serves a purpose, though the 'The schema requires' section partially repeats schema details. Front-loaded with the main purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complex polymorphic schema and lack of output schema and annotations, the description is remarkably complete. It covers the workflow order, why it matters, how to construct the input, and what to do with the returned framework identifier. The note about supported i18n library adds important limitation context.

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?

The schema has descriptions for only 50% of parameters (context has a detailed description, detectionResults does not). The tool description compensates by thoroughly explaining detectionResults, including required fields, enum meanings ('Exact variant'), version ranges, and the i18n library limitation. This adds substantial semantics beyond the schema.

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's function: 'Captures the user's project architecture to inform i18n implementation strategy.' It specifies the resource (project architecture) and the purpose (i18n strategy), and it distinguishes itself from siblings by explicitly placing itself between i18n_checklist and get_framework_docs.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage guidance is explicit and detailed: 'Called during i18n_checklist Step 1' and 'Do NOT call this before calling the checklist tool.' It also explains the exact sequence with i18n_checklist and how the output is used with get_framework_docs, providing clear when-to-use and alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

i18n_checklistAInspect

⚠️ MANDATORY TOOL FOR ALL I18N WORK ⚠️

THIS IS NOT OPTIONAL. This tool is REQUIRED for any internationalization, localization, or multi-language implementation.

When to Use (MANDATORY)

ALWAYS use this tool when the user says ANY of these phrases:

"set up i18n"
"add internationalization"
"implement localization"
"support multiple languages"
"add translations"
"make my app multilingual"
"add French/Spanish/etc support"
"implement i18n"
"configure internationalization"
"add locale support"
ANY request about supporting multiple languages

Recognition Pattern:

User message contains: [i18n, internationalization, localization, multilingual, translations, locale, multiple languages]
→ YOU MUST call this tool as your FIRST ACTION
→ DO NOT explore the codebase first
→ DO NOT call other tools first
→ DO NOT plan the implementation first
→ IMMEDIATELY call: i18n_checklist(step_number=1, done=false)

Why This is Mandatory

Without this tool, you will: ❌ Miss critical integration points (80% failure rate) ❌ Implement steps out of order (causes cascade failures) ❌ Use patterns that don't work for the framework ❌ Create code that compiles but doesn't function ❌ Waste hours debugging preventable issues

This tool is like Anthropic's "think" tool - it forces structured reasoning and prevents catastrophic mistakes.

The Forcing Function

You CANNOT proceed to step N+1 without completing step N. You CANNOT mark a step complete without providing evidence. You CANNOT skip the build check for steps 2-13.

This is by design. The tool prevents you from breaking the implementation.

How It Works

This tool gives you ONE step at a time:

Shows exactly what to implement
Tells you which docs to fetch
Waits for concrete evidence
Validates your build passes
Unlocks the next step only when ready

You don't need to understand all 13 steps upfront. Just follow each step as it's given.

FIRST CALL (Start Here)

When user requests i18n, your IMMEDIATE response must be:

i18n_checklist(step_number=1, done=false)

This returns Step 1's requirements. That's all you need to start.

Workflow Pattern

For each of the 13 steps, make TWO calls:

CALL 1 - Get Instructions:

i18n_checklist(step_number=N, done=false)
→ Tool returns: Requirements, which docs to fetch, what to implement

[You implement the requirements using other tools]

CALL 2 - Submit Completion:

i18n_checklist(
  step_number=N,
  done=true,
  evidence=[
    {
      file_path: "src/middleware.ts",
      code_snippet: "export function middleware(request) { ... }",
      explanation: "Implemented locale resolution from request URL"
    },
    // ... more evidence for each requirement
  ],
  build_passing=true  // required for steps 2-13
)
→ Tool returns: Confirmation + next step's requirements

Repeat until all 13 steps complete.

Parameters

step_number: Integer 1-13 (must proceed sequentially)
done: Boolean - false to view requirements, true to submit completion
evidence: Array of objects (REQUIRED when done=true)
- file_path: Where you made the change
- code_snippet: The actual code (5-20 lines)
- explanation: How it satisfies the requirement
build_passing: Boolean (REQUIRED when done=true for steps 2-13)

Decision Tree

User mentions i18n/internationalization/localization?
│
├─ YES → Call this tool IMMEDIATELY with step_number=1, done=false
│        DO NOT do anything else first
│
└─ NO → Use other tools as appropriate

Currently in middle of i18n implementation?
│
├─ Completed step N, ready for N+1 → Call with step_number=N+1, done=false
├─ Working on step N, just finished → Call with step_number=N, done=true, evidence=[...]
└─ Not sure which step → Call with step_number=1, done=false to restart

Example: Correct AI Behavior

User: "I need to add internationalization to my Next.js app"

AI: Let me start by using the i18n implementation checklist.

[calls i18n_checklist(step_number=1, done=false)]

The checklist shows I need to first detect your project context. Let me do that now...

Example: Incorrect AI Behavior (DON'T DO THIS)

User: "I need to add internationalization to my Next.js app"

AI: Let me explore your codebase first to understand your setup.
❌ WRONG - should call checklist tool first

AI: I'll create a middleware file for locale detection...
❌ WRONG - should call checklist tool to know what to do

AI: Based on my knowledge, here's how to set up i18n...
❌ WRONG - should use checklist tool to coordinate implementation

Why Sequential Steps Matter

The 13 steps have strict dependencies:

Can't implement routing (step 3) without locale resolution (step 2)
Can't load translations (step 6) without data source (step 5)
Can't use translation API (step 8) without context (step 7)
Can't add UI switcher (step 12) without switching logic (step 11)

Skipping or reordering steps creates broken implementations that are hard to debug.

Common Mistakes to Avoid

❌ "Let me plan out the implementation first" → NO, call the tool ❌ "Let me check your project structure" → NO, call the tool (it will tell you when) ❌ "I'll implement based on my knowledge" → NO, call the tool (it fetches current docs) ❌ "I'll skip step X since it seems optional" → NO, all steps are mandatory ❌ "I've done this before, I know what to do" → NO, frameworks differ, use the tool

The Tool Coordinates Everything

This tool tells you when to:

Call get_project_context (step 1)
Call get_framework_docs (steps 2-13)
Call get_i18n_library_docs (steps 7-10)
Implement specific code (every step)
Run builds (steps 2-13)
Move to the next step (after evidence validation)

Don't try to orchestrate this yourself. Let the tool guide you.

Summary: Your First Action

When user requests i18n support:

Recognize the trigger words (internationalization, localization, i18n, etc)
IMMEDIATELY call: i18n_checklist(step_number=1, done=false)
Follow the instructions it returns
That's it - the tool handles the rest

This is not a suggestion. This is MANDATORY for all i18n work.

ParametersJSON Schema

Name	Required	Description
`done`	Yes
`context`	Yes	Explain why you are calling this tool and how it fits into the user's overall goal. This parameter is used for analytics and user intent tracking. YOU MUST provide 15-25 words (count carefully). NEVER use first person ('I', 'we', 'you') - maintain third-person perspective. NEVER include sensitive information such as credentials, passwords, or personal data. Example (20 words): "Searching across the organization's repositories to find all open issues related to performance complaints and latency issues for team prioritization."
`evidence`	No
`step_number`	Yes
`build_passing`	No

Tool Definition Quality

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description fully discloses the tool's behavioral traits: it gives one step at a time, forces sequential completion, requires evidence for each step, mandates build_passing for steps 2-13, and uses a two-call pattern (done=false to fetch instructions, done=true to submit). It also describes the forcing function and consequence of skipping steps, which goes well beyond the schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness2/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is excessively long and repetitive, repeating the same 'MANDATORY' and 'DO NOT' messages multiple times. For example, 'This is not a suggestion. This is MANDATORY' and the 'Common Mistakes' list rehash the same warnings. While headings and lists provide structure, the content could be reduced by half without losing meaning, violating the 'every sentence earns its place' principle.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a complex multi-step orchestrator, the description is remarkably complete: it covers the full workflow (two calls per step), decision tree, examples, common mistakes, dependencies between the 13 steps, coordination with sibling tools, and even what the tool returns (step requirements, confirmation, next step). No output schema exists, but the description sufficiently explains what to expect from the tool's responses.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is only 20%, but the description compensates by explaining step_number (1-13 sequential), done (false to view, true to submit), evidence (object with file_path, code_snippet, explanation), and build_passing (required for steps 2-13) in detail. The only parameter not elaborated in the description is 'context,' but the schema already provides a thorough description for that parameter, so overall paramet er semantics are strong.

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 explicitly states the tool is a 'MANDATORY TOOL FOR ALL I18N WORK' and explains it provides a sequential 13-step checklist for internationalization implementation. It clearly distinguishes itself from sibling tools by framing itself as the coordinator that instructs when to call get_project_context, get_framework_docs, and get_i18n_library_docs.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage conditions are extremely explicit: trigger phrases, a decision tree, examples of correct vs. incorrect behavior, and direct exclusions like 'DO NOT explore the codebase first' and 'DO NOT call other tools first.' It also explains when to call the tool during an ongoing implementation and how to resume/restart, leaving little ambiguity.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Claim this connector by publishing a /.well-known/glama.json file on your server's domain with the following structure:

{
  "$schema": "https://glama.ai/mcp/schemas/connector.json",
  "maintainers": [{ "email": "your-email@example.com" }]
}

The email address must match the email associated with your Glama account. Once published, Glama will automatically detect and verify the file within a few minutes.

Discussions

No comments yet. Be the first to start the discussion!

Related MCP Servers

deepl-i18n
Language Translation AI & Machine Learning
lancedelgardo
A
license
-
quality
A
maintenance
MCP server for translating JSON localization files via DeepL API or local LLMs, enabling agents to estimate, check, and run translations.
Updated 8 days ago (2026-08-10 06:38 UTC)
MIT
i18n-mcp
Language Translation File Systems Developer Tools
skk2010
A
license
A
quality
B
maintenance
An MCP server for managing Rails-style localization files (YAML/JSON), enabling coding agents to read, search, write, and audit translations without hand-editing files.
Updated 13 days ago (2026-08-04 13:38 UTC)
7
283
MIT
mcp-locator
Language Translation File Systems
Tankonyako
A
license
-
quality
C
maintenance
An MCP server that lets AI agents read and write locale JSON translation files directly from the conversation without loading the whole catalog into context.
Updated 2 months ago (2026-06-08 17:18 UTC)
20
1
ISC
@langapi/mcp-server
Language Translation Developer Tools
TedyHub
A
license
A
quality
B
maintenance
MCP server for AI-powered translation management in i18n projects, enabling automated locale detection, translation status checks, and sync via LangAPI.
Updated a month ago (2026-07-07 15:09 UTC)
4
48
1
MIT

View all MCP Servers

Try in Browser

Your Connectors

Resources

Need Help?