# Localazy MCP

> Localazy (AI Translation & Localization API) manages your entire localization workflow through natural language commands. Use your agent to list projects, create new content keys, import translation files, and maintain glossary consistency without leaving your IDE.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** i18n, l10n, translation-api, software-localization, continuous-localization

## Description

You're running a massive localization pipeline? Connect your **Localazy API MCP Server** to your agent and manage every detail of your translation workflow without leaving your IDE. You don't need to switch screens or jump through web forms; you just talk to your AI client, and it handles the heavy lifting.

### Project Oversight & Setup

You can get a full picture of what you’re working on by calling `list_projects`, which hands you an inventory of every project associated with your token, even language coverage stats. Need to start from scratch? Use `create_project` to initialize and build a brand new localization project in the account.

For security and configuration, you'll need to manage webhooks. You can list all existing webhooks linked to the current project using `list_webhooks`, or modify them entirely with `update_webhooks`. If you require the secret for secure HMAC verification checks, `get_webhook_secret` retrieves it for you.

### Content Import and Asset Management

Getting content into the system is straightforward. You upload supported file formats using `import_content`, which makes them ready to go in the project's translation pool. Want to see what files are already attached? Run `list_files` for a full inventory.

Once you have the source material, your agent can pull specific data points. Use `list_file_content` to get all keys and their current translations for any language in a file. If you need the raw content of an asset, `download_file` retrieves it for any specified language or version.

To keep track of published material, `list_cdn_metadata` returns metadata URLs associated with specific content release tags (CDN). You can also manage visual context by uploading new screenshots—encoded in Base64 format via `upload_screenshot`—to provide your translators with necessary visuals. Check out existing images using `list_screenshots`, or update the metadata, like link phrases or tags, for an already uploaded image with `update_screenshot`. If a screenshot is wrong, you can delete it with `delete_screenshot`.

### Terminology and Key Control

Consistency is everything. To enforce specific terminology across your entire product line, you manage the glossary. You'll use `list_glossary_terms` to see every term currently defined in the project’s glossary. To mandate a new word or phrase, call `create_glossary_term`. If that term changes its meaning or usage rules, `update_glossary_term` lets you modify it; if it's outdated, `delete_glossary_term` removes it entirely.

When managing source keys (the actual content placeholders), your agent handles the heavy lifting. You can perform batch operations to apply descriptive tags to up to 1,000 keys using `set_key_tags`. Alternatively, if you need to assign specific importance levels to multiple source keys at once, use `set_key_priority`.

You can also adjust individual key properties with `update_source_key`, remove a key from the project's source pool via `delete_source_key`, or list all available source keys using `list_source_key`.

### Workflow Summary

In short, you use this server to manage everything: You can run `list_projects` and check out status reports. You upload files with `import_content`. You control terminology by creating and updating glossary entries. You download translated assets using `download_file`, and you keep track of key changes or bulk-update priorities with the source key tools.

## Tools

### create_glossary_term
Adds a new, mandatory term to the project's glossary.

### create_project
Initializes and creates a brand new localization project within your account.

### delete_glossary_term
Removes an existing term from the glossary, stopping its use in translations.

### delete_screenshot
Deletes a previously uploaded visual context screenshot.

### delete_source_key
Removes a specific key from the project's source pool of content.

### download_file
Retrieves the actual raw file content for a specified language and version.

### get_webhook_secret
Fetches the secret used by webhooks, required for secure HMAC verification checks.

### import_content
Uploads supported file formats, making them available in the project for translation work.

### list_cdn_metadata
Lists metadata URLs associated with published content release tags (CDN).

### list_file_content
Returns all keys and their current translations for a specific language in a given file.

### list_files
Provides an inventory listing of all content files currently attached to the project.

### list_glossary_terms
Fetches and lists every term that is currently defined in the project's glossary.

### list_import_formats
Shows a list of supported file types and their required parameters for importing content.

### list_projects
Retrieves all projects accessible by the token, optionally including language statistics or organization info.

### list_screenshots
Lists all uploaded visual context screenshots for a specific project.

### list_webhooks
Shows the list of webhooks configured and linked to the current project.

### set_key_priority
Performs a batch operation that assigns priority levels to multiple source keys at once.

### set_key_tags
Applies descriptive tags to up to 1,000 source keys in a single batch action.

### update_glossary_term
Modifies the definition or usage rules of an existing glossary term.

### update_screenshot
Updates metadata (like link phrases or tags) for a screenshot already uploaded to the project.

### update_source_key
Changes specific properties associated with an existing source key.

### update_webhooks
Modifies or reconfigures the webhook settings for a project.

### upload_screenshot
Uploads a new screenshot image, encoded in Base64 format, to provide visual context.

## Prompt Examples

**Prompt:** 
```
List all my Localazy projects and include language statistics.
```

**Response:** 
```
I've retrieved your projects. You have 'Mobile App' (ID: 123) with 95% completion in 5 languages, and 'Web Dashboard' (ID: 456) with 80% completion in 3 languages.
```

**Prompt:** 
```
Show me the content of file 'strings.json' (ID: f789) for the French (fr) language in project 'p123'.
```

**Response:** 
```
Fetching content for 'strings.json' in French... I found 10 keys. For example, 'login_button' is translated as 'Se connecter' and 'welcome_msg' as 'Bienvenue'.
```

**Prompt:** 
```
Add a new glossary term 'Workspace' with the description 'The primary area for user collaboration' to project 'p456'.
```

**Response:** 
```
The glossary term 'Workspace' has been successfully created in project 'p456' with the provided description to help your translators.
```

## Capabilities

### Check Project Statuses
Run `list_projects` to get a list of all accessible projects, including language coverage statistics.

### Manage Translation Glossary Terms
Use tools like `create_glossary_term` or `update_glossary_term` to enforce specific terminology across an entire product line.

### Sync and Import Content Files
Run `import_content` to upload supported file formats, making them ready for translation into your project's content pool.

### Download Translated Assets
Retrieve the raw content of a translated file using `download_file` in any specified language.

### Track Key Changes and Keys
Manage source keys with tools like `list_source_key`, or set key priorities for translation teams via batch operations (`set_key_priority`).

## Use Cases

### A new feature needs 10 languages added.
The PM knows 'Web Dashboard' is missing German (de). They ask their agent: 'What projects are ready for language addition?' The agent runs `list_projects` and identifies the gap. Next, they use `create_project` to spin up the new locale, ensuring the whole process stays in chat.

### The glossary needs updating.
A marketing team changes how 'Client' is referred to. Instead of manually finding every instance, they run: 'Update the term 'Client' to use 'Customer.''. The agent calls `update_glossary_term` and immediately fixes consistency everywhere.

### Syncing files in a CI/CD pipeline.
A developer needs to verify that all strings are present before deployment. They ask the agent: 'Show me keys for `strings.json` (ID: f789) in French.' The agent runs `list_file_content`, giving them a clean, structured JSON output they can paste right into their terminal.

### Checking translation progress before a deadline.
The Product Owner needs an overview. They ask: 'What are the completion stats for all projects?' The agent runs `list_projects`, providing a clear, summarized view of language coverage percentages and IDs in one go.

## Benefits

- Project status checks are instant. Instead of navigating to the dashboard, run `list_projects` through your agent and immediately see if 'Mobile App' is 95% complete in five languages.
- Maintain absolute consistency across all translated text. Use `create_glossary_term` or `update_glossary_term` so that agents enforce specific terminology before translators even start.
- Never lose source files again. The agent can run `list_file_content` to pull keys and translations for a file, giving you the exact data set you need without manual exports.
- Visual context is always available. You upload screenshots using `upload_screenshot` and then track them via `list_screenshots`, ensuring translators have exactly what they need in one place.
- Automate asset pipelines by managing metadata. Use `list_cdn_metadata` to verify which content versions are published, linking your translation effort directly to the release tag.

## How It Works

The bottom line is that you talk to your AI client, not the API. Your agent handles all the necessary calls—like fetching project IDs or listing files—and gives you a clean answer.

1. Subscribe to the server and provide your Localazy Personal Access Token.
2. Prompt your agent with a localization task, like 'List all my projects and check language completion.'
3. The agent uses `list_projects` (or another tool) to fetch data, which it then presents directly in plain English.

## Frequently Asked Questions

**How do I check which projects are available using list_projects?**
You simply ask your agent to run `list_projects`. The tool returns a structured list of all accessible projects, giving you their IDs and current language metrics right away.

**Can I use create_glossary_term to enforce a specific phrase?**
Yes. You pass the desired term and its description to `create_glossary_term`. This immediately adds it to the project's glossary, forcing translators to follow that exact wording.

**What is the best way to download a translated file? Do I use list_file_content?**
No. Use `list_file_content` if you want to *see* what keys and translations exist. To actually get the raw, usable content of a specific language, run `download_file`.

**How do I manage visual context for my translators?**
You use screenshot tools. First, upload images with `upload_screenshot`, then list them using `list_screenshots`. You can also update the metadata on existing visuals with `update_screenshot`.

**How do I secure my webhooks and verify incoming data using `get_webhook_secret`?**
You retrieve the secret key via `get_webhook_secret`. Your system uses this token to perform HMAC verification on all incoming webhook payloads. This ensures that only authorized sources can send updates to your project.

**Before I run `import_content`, how do I verify compatible file types using `list_import_formats`?**
`list_import_formats` shows all supported file formats and their specific parameters. This lets you confirm the correct structure before importing, preventing data loss or import failure.

**What should I do if `list_files` returns an empty list for a project?**
An empty result from `list_files` means no files are currently attached to the project. You'll need to use `import_content` first, or check if another user cleared out the file directory.

**How do I manage and audit my external connections using `list_webhooks`?**
`list_webhooks` provides a list of all configured webhooks for your project. You can review their URLs and ensure they point to the correct endpoints before updating them.

**How can I check which file formats are supported for import?**
You can use the `list_import_formats` tool. It will return a comprehensive list of all supported file types and their specific parameters for the Localazy API.

**Can I update the context or character limit for a specific translation key?**
Yes! Use the `update_source_key` tool. You can modify properties like the character limit, context comments, and even mark keys as hidden or deprecated.

**How do I retrieve the translations for a specific file in a target language?**
Use the `list_file_content` tool by providing the Project ID, File ID, and the target language code. It will return the keys and their corresponding translations.