What can you do with this server?

This MCP server lets you run AI-powered localization workflows for text, images, audio/video, and subtitles using Nativ’s TM, brand voice, style guides, and voices. * Translate single strings or batches with glossary, formality, character limits, and optional back-translation. * Search, add, and inspect translation memory entries and stats. * Read workspace languages, style guides, and brand voice settings. * Extract text from images, localize on-image text in place, and check cultural fit. * Transcribe audio/video, parse scripts, list/preview voices, synthesize dubbed audio, and remux videos. * Parse and localize subtitles from SRT/ITT files or video speech-to-text.

Which integrations are available for this server?

Supports the localization of Markdown documents and content, ensuring consistency with established style guides and translation memory.

How do I use nativ-mcp?

This server has a remotely hosted endpoint. Open its connector listing for connection details, authentication requirements, and setup instructions: * Nativ

nativ-mcp

Official

by Nativ-Technologies

Overview Schema Source Related Servers Discussions Admin

Python

Remote

Nativ MCP Server

mcp-name: io.github.Nativ-Technologies/nativ

AI-powered localization for any MCP-compatible tool — Claude Code, Cursor, Windsurf, and more.

Nativ is a localization platform that uses AI to translate content while respecting your brand voice, translation memory, glossaries, and style guides. This MCP server brings Nativ's full localization engine into your AI coding workflow.

Why use Nativ via MCP?

Translate in-context — localize strings, copy, and content directly from your editor without switching to a browser
Translation Memory aware — every translation checks your TM first, ensuring consistency across your project
Brand voice built-in — your team's tone, formality, and style guides are applied automatically
Review and approve — add approved translations to TM from your editor, building quality over time
Multi-format — JSON, CSV, Markdown, or freeform text — Nativ handles it all

Related MCP server: @langapi/mcp-server

Quick Start

For a remote Streamable HTTP connection, see Hosted MCP. Hosted calls use your API key in X-API-Key; the stdio setup below uses NATIV_API_KEY in the environment. JSON-only API clients can import the tools schema and call /tools/{tool_name} with HTTPS media URLs.

1. Get a Nativ API Key

Sign up at dashboard.usenativ.com, go to Settings → API Keys, and create a key. It looks like nativ_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.

2. Install

Add to your MCP configuration:

Claude Code / Claude Desktop (`~/.claude/claude_desktop_config.json`)

{
  "mcpServers": {
    "nativ": {
      "command": "npx",
      "args": ["-y", "nativ-mcp"],
      "env": {
        "NATIV_API_KEY": "nativ_your_api_key_here"
      }
    }
  }
}

Cursor (`.cursor/mcp.json` in your project or `~/.cursor/mcp.json` globally)

{
  "mcpServers": {
    "nativ": {
      "command": "npx",
      "args": ["-y", "nativ-mcp"],
      "env": {
        "NATIV_API_KEY": "nativ_your_api_key_here"
      }
    }
  }
}

Windsurf

{
  "mcpServers": {
    "nativ": {
      "command": "npx",
      "args": ["-y", "nativ-mcp"],
      "env": {
        "NATIV_API_KEY": "nativ_your_api_key_here"
      }
    }
  }
}

Note: npx auto-downloads the package on first run — no manual install needed. If uv isn't already on your machine, it will be installed automatically on first launch.
If you already have uv installed and prefer to skip the npm wrapper:
{
  "mcpServers": {
    "nativ": {
      "command": "uvx",
      "args": ["nativ-mcp"],
      "env": {
        "NATIV_API_KEY": "nativ_your_api_key_here"
      }
    }
  }
}
macOS tip: If you get spawn uvx ENOENT in Cursor or Claude Desktop, GUI apps don't inherit your shell PATH. Use the full path (e.g. "command": "/Users/you/.local/bin/uvx") or wrap in a login shell: "command": "/bin/sh", "args": ["-lc", "uvx nativ-mcp"].

3. Use it

Ask your AI assistant things like:

"Translate 'Welcome back!' to French and German"
"Check our translation memory for existing translations of 'Sign up'"
"What are our style guides for localization?"
"Localize these i18n strings to all configured languages"
"Review this German translation against our TM and brand voice"

Workflow reference

The full server has 51 tools in version 0.5.1. Use the complete capability reference for tool names and the usage and output guide for context, files, review and export. The table below is a selection, not the complete catalogue.

Text: inspect workspace guidance, search memory, translate, then save approved pairs separately.
Images: extract wording, review replacements, render a candidate image. The output remains raster artwork.
Audio/video: inspect capabilities and voices, transcribe, translate related turns, review, then synthesize. Dubbing does not automatically translate the visible picture.
Saved subtitles: read review rows, save edits and regenerate the final export. A QC workbook is a different deliverable.
Custom integrations: use local/hosted MCP or the JSON adapter; the REST API and SDKs have their own request contracts.

ChatGPT is a separate connection

The full https://mcp.usenativ.com/mcp endpoint uses a Nativ API key and the 51-tool catalogue. The focused https://mcp.usenativ.com/chatgpt/mcp endpoint uses OAuth and seven copy/image/context/memory tools. It does not accept a manually supplied Nativ API key or expose the full audio, subtitle and administration catalogue. A working endpoint is not evidence of public plugin-directory approval. The existing custom GPT is another distinct surface. See authentication boundaries.

Tools

Tool	Description
`translate`	Translate text using the full localization engine (TM, style guides, brand voice, glossary)
`translate_batch`	Translate multiple texts to a target language in one call
`search_translation_memory`	Fuzzy-search the translation memory for existing translations
`add_translation_memory_entry`	Add an approved translation to TM for future reuse
`get_languages`	List all configured languages with formality and style settings
`get_translation_memory_stats`	Get TM statistics — total entries, sources, and breakdown
`get_style_guides`	List all style guides with their content and status
`get_brand_voice`	Get the brand voice prompt that shapes all translations
`extract_image_text`	Extract on-image text segments (OCR) in reading order
`localize_image`	Replace on-image text with translations in place, keeping layout and graphics intact
`check_image_cultural_fit`	Flag cultural-sensitivity issues in an image across target markets
`transcribe_audio`	Speech-to-text for a local audio or video file (draft; billed on synthesize)
`parse_audio_script`	Parse a script (.txt/.docx/.pdf/.srt) instead of running STT
`list_voices`	List TTS voices for dubbing
`preview_voice`	Save a short TTS preview WAV to disk
`get_voice_consent_script`	Consent copy required for voice cloning
`synthesize_audio`	Generate billed localized TTS (and optional dubbed MP4) and save to disk
`register_video`	Store a source video for later remux
`remux_video`	Mux a WAV onto a registered video
`parse_subtitle`	Parse a local SRT/ITT into timed cues
`localize_subtitles`	Localize subtitles in-memory from SRT/ITT and/or video STT

All 51 tools are shared by local and hosted MCP. Existing tools retain their arguments and results. Voice cloning uses the existing API and requires the user’s ownership/permission confirmation. See the workflow coverage audit for original-voice dubbing and saved-subtitle examples.

Resources

URI	Description
`nativ://languages`	Configured languages (JSON)
`nativ://style-guides`	All style guides (JSON)
`nativ://brand-prompt`	Brand voice prompt (JSON)
`nativ://tm/stats`	Translation memory statistics (JSON)

Prompts

Prompt	Description
`localize-content`	Guided workflow to localize content into target languages
`review-translation`	Review a translation against TM, style guides, and brand voice
`batch-localize-strings`	Batch-localize i18n strings with structured output

Examples

Translate a marketing headline

You: Translate "The future of luxury, delivered" to French and Japanese

AI: [calls translate tool for each language]

Translation (French): "L'avenir du luxe, livré chez vous"
  TM Match: 0% — new translation, no prior TM entries
  Rationale: "Livré chez vous" adds a personal touch absent from the literal
  "livré", aligning with the brand's premium yet approachable voice.

Translation (Japanese): "ラグジュアリーの未来を、あなたの元へ"
  TM Match: 45% partial — similar pattern found in TM from brand_voice source

Check existing translations

You: Do we have translations for "Add to cart" in our TM?

AI: [calls search_translation_memory]

TM Search Results for "Add to cart" (3 matches):
- 95% [strong] "Add to cart" → "Ajouter au panier" (source: approved)
- 95% [strong] "Add to cart" → "In den Warenkorb" (source: brand_voice)
- 72% [partial] "Add items to cart" → "Ajouter des articles" (source: phrase_tm)

Batch localize i18n strings

You: Localize these to French:
  - "Sign up"
  - "Log in"
  - "Forgot password?"
  - "Continue with Google"

AI: [calls translate_batch]

Batch translation to French (4 items):
1. "Sign up" → "S'inscrire" (TM 100%)
2. "Log in" → "Se connecter" (TM 100%)
3. "Forgot password?" → "Mot de passe oublié ?" (TM 92%)
4. "Continue with Google" → "Continuer avec Google" (TM 85%)

Configuration

Environment Variable	Required	Description
`NATIV_API_KEY`	Yes	Your Nativ API key (`nativ_xxx...`)
`NATIV_API_URL`	No	API base URL (defaults to `https://api.usenativ.com`)

How It Works

This MCP server acts as a bridge between your AI coding assistant and the Nativ API:

┌─────────────────────┐     ┌──────────────┐     ┌─────────────────┐
│  Claude / Cursor /   │────▶│  Nativ MCP   │────▶│   Nativ API     │
│  Windsurf / etc.     │◀────│  Server      │◀────│ (Translation,   │
│                      │     │  (stdio)     │     │  TM, Styles)    │
└─────────────────────┘     └──────────────┘     └─────────────────┘

The MCP server runs locally via stdio. It authenticates with your API key and calls the Nativ REST API on your behalf. Your AI assistant sees Nativ's tools, resources, and prompts as native capabilities.

Development

# Clone the repo
git clone https://github.com/Nativ-Technologies/nativ-mcp.git
cd nativ-mcp

# Set up environment
uv venv
source .venv/bin/activate
uv pip install -e .

# Run the server (for testing)
NATIV_API_KEY=nativ_xxx nativ-mcp

# Run with MCP Inspector
NATIV_API_KEY=nativ_xxx npx @modelcontextprotocol/inspector uv run nativ-mcp

License

MIT — see LICENSE.

Available Tools

21 tools

add_translation_memory_entryAInspect

Add a new entry to the translation memory.

Use this to store approved translations so they are reused in future localizations.

Args: source_text: The original text. target_text: The approved translation. source_language_code: Source language code (e.g. "en"). target_language_code: Target language code (e.g. "fr-FR"). name: Optional label for this entry (e.g. "homepage hero copy").

Inputs: source_text (required), target_text (required), source_language_code (required), target_language_code (required), +1 more. Returns: result

check_image_cultural_fitAInspect

Analyze an image for cultural-sensitivity issues across markets before launch.

Returns a SAFE / NOT SAFE verdict and, where relevant, the specific countries affected with the issue and a concrete fix.

Args: image_path: Path to a local PNG, JPEG, or WebP image. countries: Optional comma-separated list of countries to check against (e.g. "Saudi Arabia, Japan, France"). Defaults to the top markets by GDP.

Inputs: image_path (required), countries. Returns: result

extract_image_textAInspect

Extract text segments from an image, in reading order (OCR).

Use this as the first step when localizing an image: pull out the on-image source strings, translate each with translate (so TM, style guides, and brand voice apply), then re-render with localize_image.

Args: image_path: Path to a local PNG, JPEG, or WebP image file.

Inputs: image_path (required). Returns: result

get_brand_voiceAInspect

Get the brand voice prompt — the core localization personality.

This is the master prompt that shapes all translations. It captures the brand's tone, personality, terminology, and localization guidelines.

Inputs: no named parameters. Returns: result

get_languagesAInspect

Get all languages configured for the Nativ workspace.

Returns language names, codes, formality settings, and custom style directives for each language.

Inputs: no named parameters. Returns: result

get_style_guidesAInspect

Get all style guides configured for the workspace.

Returns the titles, content, and enabled status of each style guide.

Inputs: no named parameters. Returns: result

get_translation_memory_statsBInspect

Get statistics about the translation memory.

Shows total entries, enabled/disabled counts, and breakdown by source type.

Inputs: no named parameters. Returns: result

get_voice_consent_scriptBInspect

Get the spoken consent script required for voice cloning.

Inputs: language_code. Returns: result

list_voicesAInspect

List TTS voices available for dubbing.

Args: language_code: Optional filter (e.g. "fr", "ja-JP").

Inputs: language_code. Returns: result

localize_imageAInspect

Localize an image in place by replacing its on-image text with translations.

Keeps every non-text element (layout, colours, graphics) intact and re-renders the original text with the provided translations. Pair with extract_image_text (to get the source strings) and translate (to translate them with TM and brand voice) for a full image localization flow.

The localized image is saved to disk and the file path is returned — the raw image bytes are not sent back to the model.

Args: image_path: Path to a local PNG, JPEG, or WebP image to localize. replacements: JSON array of {"original": "...", "translated": "..."} pairs, e.g. '[{"original": "Buy now", "translated": "Achetez maintenant"}]'. target_language_code: Target language code (e.g. "fr-FR"), used for labelling output. output_path: Optional path to write the localized image to. Defaults to ".." next to the source image. num_images: Number of variants to generate (1-5, default 1). output_format: Output format — png, jpeg, or webp (default png).

Inputs: image_path (required), replacements (required), target_language_code (required), num_images, +2 more. Returns: result

localize_subtitlesAInspect

Localize subtitles in-memory. Provide an SRT/ITT and/or a video (STT).

Args: target_language_codes: Comma-separated codes (e.g. "fr,de,ja"). subtitle_path: Optional local subtitle file. video_path: Optional video used when no subtitle file is given. glossary_path: Optional glossary text file. source_language_code: Source language code. context: Optional localization context. formality: Optional formality override. output_dir: If set, write one .srt per language there.

Inputs: target_language_codes (required), context, formality, output_dir, +4 more. Returns: result

parse_audio_scriptAInspect

Parse a script file (.txt, .docx, .pdf, .srt, .itt) instead of STT.

Inputs: file_path (required). Returns: result

parse_subtitleAInspect

Parse a local SRT/ITT file into timed cues (no storage).

Inputs: file_path (required). Returns: result

preview_voiceBInspect

Generate a short TTS preview and save it to disk.

Args: voice_id: Voice id from list_voices. output_path: Where to write the WAV file. language_code: Optional locale. text: Optional preview line (max 200 chars).

Inputs: voice_id (required), output_path (required), text, language_code. Returns: result

register_videoBInspect

Upload a source video for later remuxing. Returns video_id.

Inputs: file_path (required). Returns: result

remux_videoAInspect

Mux a WAV file onto a previously registered video.

Args: video_id: Id from register_video or transcribe_audio. audio_path: Local WAV (or other) file to encode as base64. output_path: Where to write the MP4.

Inputs: video_id (required), audio_path (required), output_path (required). Returns: result

search_translation_memoryAInspect

Search the translation memory for existing translations.

Use this to check if translations already exist before creating new ones, or to find reference translations for consistency.

Args: query: Text to search for in the translation memory. source_language_code: Source language code (default: "en"). target_language_code: Optional target language code to filter results. min_score: Minimum fuzzy match score (0-100). Default 0 returns all. limit: Maximum number of results (default 10).

Inputs: query (required), limit, min_score, source_language_code, +1 more. Returns: result

synthesize_audioAInspect

Generate billed localized TTS (and optional dubbed video).

Args: language: Target language name (e.g. "French"). language_code: Target language code (e.g. "fr"). voice_id: Voice id from list_voices. segments: JSON array of {text, start_ms, end_ms, original?} objects. output_path: Path to write the WAV audio. keep_same_length: Stretch/compress speech to source timings. keep_background_music: Mix transcribed music bed when stem_id is set. stem_id: Optional bed stem from transcribe_audio. source_duration_ms: Original duration. source_transcript: Optional original transcript. video_id: Optional id from transcribe/register to mux MP4. video_output_path: Optional path for dubbed MP4 when video_id is set.

Inputs: language (required), segments (required), voice_id (required), output_path (required), +8 more. Returns: result

transcribe_audioAInspect

Transcribe speech from a local audio or video file (unbilled draft).

Use the returned segments with translate (origin via text) then synthesize_audio to produce a dubbed track. Video uploads also return a video_id for muxing.

Args: file_path: Path to audio (mp3, wav, m4a, …) or video (mp4, mov, …). source_language_code: Optional source language hint (e.g. "en"). keep_background_music: If true, split a music bed for later remix.

Inputs: file_path (required), source_language_code, keep_background_music. Returns: result

translateAInspect

Translate text using Nativ's AI localization engine.

Uses the team's translation memory, style guides, and brand voice automatically. Returns the translation along with TM match info and rationale.

Args: text: The text to translate. target_language: Full target language name (e.g. "French", "German", "Japanese"). target_language_code: Optional ISO language code (e.g. "fr", "de", "ja"). source_language: Source language name. Defaults to English. source_language_code: Source language code. Defaults to "en". context: Optional context to guide the translation (e.g. "marketing headline for Gen Z audience"). glossary: Optional inline glossary as CSV (e.g. "term,translation\nbrand,marque"). formality: Tone override — one of: very_informal, informal, neutral, formal, very_formal. max_characters: Optional strict character limit for the translation output. backtranslate: If true, also returns a back-translation to verify intent.

Inputs: text (required), target_language (required), context, glossary, +6 more. Returns: result

translate_batchAInspect

Translate multiple texts to a single target language.

Useful for localizing lists of strings, UI labels, or i18n files. Each text is translated individually using the team's TM and style guides.

Args: texts: List of texts to translate. target_language: Full target language name (e.g. "French"). target_language_code: Optional ISO language code. source_language: Source language name. Defaults to English. source_language_code: Source language code. Defaults to "en". context: Optional context to guide all translations. formality: Tone override for all translations.

Inputs: texts (required), target_language (required), context, formality, +3 more. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

Deploy Server

Claude Code, inside the Godot 4 editorFlockbay puts an AI agent in the real Godot 4 editor: it writes GDScript, runs your game and fixes what breaks. Free, or bring your own Claude Code or Codex.flockbay.comAd

TDQS

A3.7/5.0

Scored 2026-09-22 10:20 across 21 tools

Disambiguation4/5

Most tools target clearly distinct resources and actions, such as translate vs translate_batch or extract_image_text vs localize_image. Slight overlap exists between parse_subtitle and parse_audio_script, since both can handle .srt/.itt inputs, but their descriptions clarify the intended source type.

Naming Consistency5/5

Tool names follow a consistent snake_case verb_noun pattern throughout, e.g. list_voices, preview_voice, register_video, and translate_batch. There are no mixed conventions or vague action verbs.

Tool Count4/5

At 21 tools, the server is above the ideal 3-15 range, but the count is justified by the breadth of the localization domain: text translation, translation memory, style/brand config, subtitles, images, and audio/video dubbing. The tools do not feel redundant, though the set is on the heavier side.

Completeness4/5

Core localization workflows are well covered: text translation, batch translation, subtitle localization, image localization, transcription, TTS dubbing, and cultural checks. Minor gaps exist, such as no update/delete/disable for translation memory entries and no style guide or brand voice management beyond read-only access.

Maintenance

ActivityMaintained

ResponsivenessNo recent community issues

Resources

Related MCP Connectors

Glossa
dev.getglossa
AI-native translation management: push translation files, translate, review and audit strings.
Language Translation Developer Tools
1
https://getglossa.dev/api/mcp
Phrase MCP
io.github.phrase
Phrase MCP server: language intelligence platform for translation, terminology, and quality.
Language Translation AI & Machine Learning
1
https://mcp.us.phrase.com
Localize.io
io.localize
AI localization for agents: translation, TMS sync, translation memories, glossaries, post-editing.
Language Translation AI & Machine Learning
2
https://hub.localize.io/mcp/
mcp
ai.zine
Your memory, everywhere AI goes. Build knowledge once, access it via MCP anywhere.
Knowledge & Memory RAG Systems Autonomous Agents
2
https://www.zine.ai/mcp

Related MCP Servers

i1n
Developer Tools Language Translation AI & Machine Learning
Pakvothe
A
license
Not graded
quality
C
maintenance
Localization as code — push, pull, translate, and extract strings from code with AI. 7 MCP tools for type-safe i18n across 182 languages.
Updated a month ago (2026-10-09 20:51 UTC)
199 npm
2
MIT
@langapi/mcp-server
Language Translation Developer Tools
TedyHub
A
license
A
quality
D
maintenance
MCP server for AI-powered translation management in i18n projects, enabling automated locale detection, translation status checks, and sync via LangAPI.
Updated 3 months ago (2026-08-21 13:15 UTC)
4
26 npm
1
MIT
translation-ai-mcp
Language Translation AI & Machine Learning
CSOAI-ORG
A
license
Not graded
quality
C
maintenance
AI-powered translation MCP server with EU AI Act compliance, enabling automated translation workflows via the MCP protocol.
Updated a month ago (2026-10-08 04:34 UTC)
1 npm
20 PyPI
MIT
Lara Translate MCP Server
Language Translation AI & Machine Learning
ACRT-EVAL
A
license
B
quality
D
maintenance
Enables AI applications to perform multi-language translations with automatic language detection, contextual hints, and custom instructions through an MCP-compatible interface.
Updated 17 days ago (2026-10-24 22:45 UTC)
1
838 npm
MIT

Nativ MCP Server

Why use Nativ via MCP?

Quick Start

1. Get a Nativ API Key

2. Install

Claude Code / Claude Desktop (~/.claude/claude_desktop_config.json)

Cursor (.cursor/mcp.json in your project or ~/.cursor/mcp.json globally)

Windsurf

3. Use it

Workflow reference

ChatGPT is a separate connection

Tools

Resources

Prompts

Examples

Translate a marketing headline

Check existing translations

Batch localize i18n strings

Configuration

How It Works

Development

License

Links

Available Tools

Tool Schema Changelog

TDQS

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

i1n

@langapi/mcp-server

translation-ai-mcp

Lara Translate MCP Server

Claude Code / Claude Desktop (`~/.claude/claude_desktop_config.json`)

Cursor (`.cursor/mcp.json` in your project or `~/.cursor/mcp.json` globally)