> **Building with AI coding agents?** Install the authstack plugin with one command. This equips your agent with accurate Scalekit implementation patterns.
>
> **Recommended** (the `-y` flags skip prompts, so the command runs without an interactive terminal):
> ```bash
> npx -y @scalekit-inc/cli setup -y
> ```
>
> Global:
> ```bash
> npm install -g @scalekit-inc/cli
> scalekit setup -y
> ```
>
> Supports Claude Code, Cursor, GitHub Copilot, Codex + skills for other Agent Skills-compatible agents in `~/.agents/skills`.
> Skills: integrate-agentkit, implement-saaskit, add-mcp-oauth, implement-sso, implement-scim.
> [Full setup guide](https://docs.scalekit.com/dev-kit/build-with-ai/)

---

# Connect AI agents to the Phrase MCP server

The Phrase MCP connector routes your AI agent's tool calls to Phrase's own MCP server through Scalekit. Each user signs in to Phrase once, and Scalekit stores and refreshes their tokens, so your agent never handles credentials. It comes with 38 tools.

**Authentication:** OAuth 2.1/DCR
**Categories:** AI, Productivity
**Tools:** 38: 28 read, 1 write, 9 destructive
**Users sign in with:** OAuth
**OAuth app:** Your own Phrase MCP server app
**Built by:** Vendor MCP
**Try it:** [Playground in the Scalekit dashboard](https://app.scalekit.com/ws/signup?sk_intent=playground&provider=PHRASEMCP)

## Setup

1. ### Install the SDK

   **Node.js**

   ```bash
   npm install @scalekit-sdk/node dotenv
   ```

   **Python**

   ```bash
   pip install scalekit-sdk-python python-dotenv
   ```

2. ### Set your credentials

   Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**.

   ```sh title=".env"
   SCALEKIT_ENVIRONMENT_URL=<your-environment-url>
   SCALEKIT_CLIENT_ID=<your-client-id>
   SCALEKIT_CLIENT_SECRET=<your-client-secret>
   ```

3. ### Create the Phrase MCP connection

   In **AgentKit > Connections**, create a Phrase MCP connection and copy its redirect URI. The name you give it is the `connection_name` your code passes. See [Configure connections](/agentkit/connections/).

4. ### Register an OAuth app

   Phrase MCP server connections use your own OAuth app. Register one with Phrase MCP server and add the redirect URI you copied.

   Then enter the app's Client ID and Client Secret on the Phrase MCP connection.

5. ### Authorize a user and make your first call

   **Node.js** (`quickstart.mts`)

   ```typescript
   import { ScalekitClient } from '@scalekit-sdk/node'
   import 'dotenv/config'
   import { createInterface } from 'node:readline/promises'

   const scalekit = new ScalekitClient(
     process.env.SCALEKIT_ENVIRONMENT_URL,
     process.env.SCALEKIT_CLIENT_ID,
     process.env.SCALEKIT_CLIENT_SECRET,
   )
   const actions = scalekit.actions

   const connector = 'phrasemcp'
   const identifier = 'user_123'

   // Generate an authorization link for the user
   const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier })
   console.log('Authorize Phrase MCP:', link)
   const rl = createInterface({ input: process.stdin, output: process.stdout })
   await rl.question('Press Enter after authorizing...')
   rl.close()

   // Make your first call
   const result = await actions.executeTool({
     connector,
     identifier,
     toolName: 'phrasemcp_list_phrase_guides',
     toolInput: {},
   })
   console.log(result)
   ```

   ```bash
   npx tsx quickstart.mts
   ```

   **Python** (`quickstart.py`)

   ```python
   import os
   from scalekit import ScalekitClient
   from dotenv import load_dotenv
   load_dotenv()

   scalekit_client = ScalekitClient(
       env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"),
       client_id=os.getenv("SCALEKIT_CLIENT_ID"),
       client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"),
   )
   actions = scalekit_client.actions

   connection_name = "phrasemcp"
   identifier = "user_123"

   # Generate an authorization link for the user
   link_response = actions.get_authorization_link(
       connection_name=connection_name,
       identifier=identifier,
   )
   print("Authorize Phrase MCP:", link_response.link)
   input("Press Enter after authorizing...")

   # Make your first call
   result = actions.execute_tool(
       tool_input={},
       tool_name="phrasemcp_list_phrase_guides",
       connection_name=connection_name,
       identifier=identifier,
   )
   print(result)
   ```

   ```bash
   python quickstart.py
   ```

   Each user signs in once. See [Authorize a user](/agentkit/tools/authorize/) for the full flow and statuses.

## Tools

Pass the exact name to `execute_tool`, with an input like each tool's example. To ask for a tool that's missing, use the [request form](https://scalekitsupport.portal.usepylon.com/forms/request-a-connector-tool).

**Node.js**

```typescript
const result = await actions.executeTool({
  toolName: 'phrasemcp_connectors_read_api',
  toolInput: {
    method: '<method>',
    path: '<path>',
  },
  connector: 'phrasemcp',
  identifier: 'user_123',
})
```

**Python**

```python
result = actions.execute_tool(
    tool_name="phrasemcp_connectors_read_api",
    tool_input={
        "method": "<method>",
        "path": "<path>",
    },
    connection_name="phrasemcp",
    identifier="user_123",
)
```

`result.data` is the app's response as JSON, and `result.execution_id` (`executionId` in Node.js) is the ID of the call.

### `phrasemcp_connectors_read_api`

Connectors Read Api · Read-only

Forward a read-only Connectors API request. Use connectors_search_api to find the right operation, then supply the exact method and path from a search result. Only read-classified operations are accepted: GET/HEAD/OPTIONS requests, plus specific POST paths that the Connectors API models as reads (search, count, preview, and similar). For write or destructive operations (create, update, delete, import) use connectors_write_api instead.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

### `phrasemcp_connectors_search_api`

Connectors Search Api · Read-only

Search the standalone Phrase Connectors API docs — enterprise CMS integrations (Braze, Contentful, GitHub, Google Drive, Optimizely, Tridion Docs) that transfer file content through an already-configured connector. Use before connectors_read_api or connectors_write_api. show_full=true only when full requestBody schema needed. Connector lifecycle (create/list/get/patch/delete a connector) is a TMS operation — search tms_search_api instead.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `query` (`string`, required): Keywords describing the operation you need, e.g. 'list projects', 'create translation job', 'export target file'.
- `limit` (`integer`, optional): Maximum number of operations to return. The output reports how many ranked matches were withheld by this limit. Default: `10`.
- `show_full` (`boolean`, optional): Return full request-body schemas instead of truncated ones. Use only when you need the full schema to build a request body. Default: `false`.

Example input: `{"query":"list projects"}`

### `phrasemcp_control_hub_read_api`

Control Hub Read Api · Read-only

Forward a read-only Control Hub API request. Use control_hub_search_api to find the right operation, then supply the exact method and path from a search result. Only read-classified operations are accepted: GET/HEAD/OPTIONS requests, plus specific POST paths that the Control Hub API models as reads (search, count, preview, and similar). For write or destructive operations (create, update, delete, import) use control_hub_write_api instead.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

### `phrasemcp_control_hub_search_api`

Control Hub Search Api · Read-only

Search Control Hub API docs. Use before control_hub_read_api or control_hub_write_api. Currently covers content groups — an organisation-scoped coordination layer that links a TMS project to shared Style Guides, Style Rules, and Quality Evaluation checks (Rules themselves are created and edited in the Style Guides product, not here). show_full=true only when full requestBody schema needed.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `query` (`string`, required): Keywords describing the operation you need, e.g. 'list projects', 'create translation job', 'export target file'.
- `limit` (`integer`, optional): Maximum number of operations to return. The output reports how many ranked matches were withheld by this limit. Default: `10`.
- `show_full` (`boolean`, optional): Return full request-body schemas instead of truncated ones. Use only when you need the full schema to build a request body. Default: `false`.

Example input: `{"query":"list projects"}`

### `phrasemcp_kb_lookup`

Kb Lookup · Read-only

Look up a specific Help Center section by title, or by the id kb_search shows for a shared title — returns its summary, key concepts, tasks, and related topics. Use after kb_search when you know the section name.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `title` (`string`, required): Exact or partial title of the documentation section to look up. The search is case-insensitive. Examples: 'Jobs overview', 'Translation memories', 'User management'. When a search result shows an id (its title is shared by several sections), pass the id.

Example input: `{"title":"<title>"}`

### `phrasemcp_kb_page`

Kb Page · Read-only

Retrieve the full content of a Help Center page (procedures, code samples), optionally including subsections. Use when you need complete documentation, not just a summary. When a kb_search result shows an id (its title is shared by several sections), pass that id. Never call this tool twice with the same title in one turn — a repeat call with no new argument returns identical content and wastes a round.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `title` (`string`, required): Title or section ID of the documentation page to retrieve. Case-insensitive title matching is used. When a search result shows an id (its title is shared by several sections), pass that id so you get that section rather than another one with the same title.
- `depth` (`integer`, optional): Maximum depth for recursive retrieval when recursive=true. 1 = children only, 2 = children and grandchildren (default). Higher values retrieve deeper nested content. Default: `2`.
- `include_metadata` (`boolean`, optional): Whether to include metadata header (product, parent, features) at the top of the output. Set to false for raw content only. Default: `true`.
- `recursive` (`boolean`, optional): Whether to include child sections (subsections) in the output. Set to true (default) for comprehensive documentation including all subsections. Set to false to retrieve only the main section. Default: `true`.

Example input: `{"title":"<title>"}`

### `phrasemcp_kb_search`

Kb Search · Read-only

Search the Phrase Help Center knowledge base for documentation sections matching a query. Returns ranked sections with titles, products, and summaries. Drill into a result with kb_lookup or kb_page. The KB is organised into sub-pages — a broad search on a parent topic will not reliably surface details specific to a sub-topic. Issue a targeted search for each specific aspect rather than reusing results from a broader search. Results are numbered; the result numbered 1 is the answer — open only that one, not a lower-ranked result whose title reuses more of the query's own wording, and do not also retrieve other results from the same search unless result 1, once retrieved, does not answer the question. This holds across multiple searches in the same turn: an earlier strong, on-topic top hit is not overridden by a later reformulated search's weaker result. A high score or perfect-looking title/summary match is a reason to open the page, not confirmation by itself. Never name a specific tool or feature to the user unless that name appears in a page you actually retrieved with kb_lookup or kb_page — not from a search snippet, not carried over from an unrelated retrieved page, and not from a *_search_api operation's summary (API endpoint names are not the same as documented customer-facing feature names).

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `query` (`string`, required): Search query to find relevant documentation sections. Can include keywords, concepts, or task descriptions. Examples: 'create translation job', 'API authentication', 'import XLIFF files', 'workflow templates'.
- `limit` (`integer`, optional): Maximum number of results to return (1-50). Default is 10. Default: `10`.
- `product` (`string`, optional): Filter results by Phrase product. Use 'strings' for Phrase Strings (string localization), 'tms' for Phrase TMS (translation management), 'studio' for Phrase Studio (dubbing/voice), 'orchestrator' for Phrase Orchestrator (workflow automation), 'platform' for platform-wide features, 'devhub' for developer docs, or 'website' for phrase.com pages. Leave empty to search all products.

Example input: `{"query":"list projects"}`

### `phrasemcp_language_ai_read_api`

Language Ai Read Api · Read-only

Forward a read-only Language AI API request. Use language_ai_search_api to find the right operation, then supply the exact method and path from a search result. Only read-classified operations are accepted: GET/HEAD/OPTIONS requests, plus specific POST paths that the Language AI API models as reads (search, count, preview, and similar). For write or destructive operations (create, update, delete, import) use language_ai_write_api instead.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

### `phrasemcp_language_ai_search_api`

Language Ai Search Api · Read-only

Search Language AI API docs. Use before language_ai_read_api or language_ai_write_api. Results truncate requestBody by default — use show_full=true only when full schema needed to build request body.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `query` (`string`, required): Keywords describing the operation you need, e.g. 'list projects', 'create translation job', 'export target file'.
- `limit` (`integer`, optional): Maximum number of operations to return. The output reports how many ranked matches were withheld by this limit. Default: `10`.
- `show_full` (`boolean`, optional): Return full request-body schemas instead of truncated ones. Use only when you need the full schema to build a request body. Default: `false`.

Example input: `{"query":"list projects"}`

### `phrasemcp_list_phrase_guides`

List Phrase Guides · Read-only

List the available Phrase guides — short, on-demand playbooks for how to carry out common Phrase tasks over this gateway (e.g. the file upload/download handshake, analytics org-scoping, polling long-running TMS jobs). Returns a catalogue of `<guide_id>: <when-to-load>` lines; pass a matching guide_id to `load_phrase_guide` to read the full guide. Optionally pass a `query` to fuzzy-filter the catalogue by task keywords; omit it to see every guide. Consult this before driving product tools for an unfamiliar task — the guide often contains the exact multi-step sequence to follow.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `query` (`string`, optional): Optional task keywords to fuzzy-filter the catalogue (e.g. 'upload file', 'analytics', 'async job'). Omit to list all guides.

Example input: `{}`

### `phrasemcp_load_phrase_guide`

Load Phrase Guide · Read-only

Load the full text of one Phrase guide by its id (as listed by `list_phrase_guides`). Returns the guide body — a step-by-step playbook for the task. Call `list_phrase_guides` first to find the right guide_id.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `guide_id` (`string`, required): Guide id from list_phrase_guides, e.g. 'files_01'.

Example input: `{"guide_id":"files_01"}`

### `phrasemcp_orchestrator_search_api`

Orchestrator Search Api · Read-only

Search Phrase Orchestrator API docs. Use before orchestrator_read_api or orchestrator_write_api. Orchestrator builds localization workflows from trigger and action blocks. show_full=true only when full requestBody schema needed.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `query` (`string`, required): Keywords describing the operation you need, e.g. 'list projects', 'create translation job', 'export target file'.
- `limit` (`integer`, optional): Maximum number of operations to return. The output reports how many ranked matches were withheld by this limit. Default: `10`.
- `show_full` (`boolean`, optional): Return full request-body schemas instead of truncated ones. Use only when you need the full schema to build a request body. Default: `false`.

Example input: `{"query":"list projects"}`

### `phrasemcp_ping`

Ping · Read-only

Liveness/handshake check. Returns the gateway name, the products it can
reach, and the calling token's effective capability — its scopes, whether
write/destructive operations are available (and why), and which products
your platform token is entitled to. Use this to confirm the MCP connection
is established and to learn upfront why a *_write_api or *_read_api tool may
be missing from the catalogue.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs: none.

Example input: `{}`

### `phrasemcp_portal_read_api`

Portal Read Api · Read-only

Forward a read-only Portal API request. Use portal_search_api to find the right operation, then supply the exact method and path from a search result. Only read-classified operations are accepted: GET/HEAD/OPTIONS requests, plus specific POST paths that the Portal API models as reads (search, count, preview, and similar). For write or destructive operations (create, update, delete, import) use portal_write_api instead.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

### `phrasemcp_portal_search_api`

Portal Search Api · Read-only

Search Portal API docs. Use before portal_read_api or portal_write_api. Results truncate requestBody by default — use show_full=true only when full schema needed to build request body.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `query` (`string`, required): Keywords describing the operation you need, e.g. 'list projects', 'create translation job', 'export target file'.
- `limit` (`integer`, optional): Maximum number of operations to return. The output reports how many ranked matches were withheld by this limit. Default: `10`.
- `show_full` (`boolean`, optional): Return full request-body schemas instead of truncated ones. Use only when you need the full schema to build a request body. Default: `false`.

Example input: `{"query":"list projects"}`

### `phrasemcp_quality_evaluator_read_api`

Quality Evaluator Read Api · Read-only

Forward a read-only Quality Evaluator API request. Use quality_evaluator_search_api to find the right operation, then supply the exact method and path from a search result. Only read-classified operations are accepted: GET/HEAD/OPTIONS requests, plus specific POST paths that the Quality Evaluator API models as reads (search, count, preview, and similar). For write or destructive operations (create, update, delete, import) use quality_evaluator_write_api instead.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

### `phrasemcp_quality_evaluator_search_api`

Quality Evaluator Search Api · Read-only

Search Quality Evaluator API docs. Use before quality_evaluator_read_api or quality_evaluator_write_api. show_full=true only when full requestBody schema needed. QE evaluates raw segments against a Content Group's AI checks (POST /v3/evaluation) and reads that group's Quality Profile. TMS jobs/WF steps: search TMS API, POST /api2/v1/projects/{projectUid}/jobs/evaluateQuality (job UIDs, no file download). AI checks are Style Guides Rules (aiCheckEnabled: true): search style_guides_search_api to create or edit them.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `query` (`string`, required): Keywords describing the operation you need, e.g. 'list projects', 'create translation job', 'export target file'.
- `limit` (`integer`, optional): Maximum number of operations to return. The output reports how many ranked matches were withheld by this limit. Default: `10`.
- `show_full` (`boolean`, optional): Return full request-body schemas instead of truncated ones. Use only when you need the full schema to build a request body. Default: `false`.

Example input: `{"query":"list projects"}`

### `phrasemcp_strings_read_api`

Strings Read Api · Read-only

Forward a read-only Strings API request. Use strings_search_api to find the right operation, then supply the exact method and path from a search result. Only read-classified operations are accepted: GET/HEAD/OPTIONS requests, plus specific POST paths that the Strings API models as reads (search, count, preview, and similar). For write or destructive operations (create, update, delete, import) use strings_write_api instead.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

### `phrasemcp_strings_search_api`

Strings Search Api · Read-only

Search the Phrase Strings API documentation by keyword. Use this to discover which Strings endpoint to call before using strings_read_api or strings_write_api. Phrase Strings is the key-based localization product (projects, keys, translations, locales, jobs). Results truncate requestBody by default — use show_full=true only when full schema needed to build request body.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `query` (`string`, required): Keywords describing the operation you need, e.g. 'list projects', 'create translation job', 'export target file'.
- `limit` (`integer`, optional): Maximum number of operations to return. The output reports how many ranked matches were withheld by this limit. Default: `10`.
- `show_full` (`boolean`, optional): Return full request-body schemas instead of truncated ones. Use only when you need the full schema to build a request body. Default: `false`.

Example input: `{"query":"list projects"}`

### `phrasemcp_studio_read_api`

Studio Read Api · Read-only

Forward a read-only Studio API request. Use studio_search_api to find the right operation, then supply the exact method and path from a search result. Only read-classified operations are accepted: GET/HEAD/OPTIONS requests, plus specific POST paths that the Studio API models as reads (search, count, preview, and similar). For write or destructive operations (create, update, delete, import) use studio_write_api instead.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

### `phrasemcp_studio_search_api`

Studio Search Api · Read-only

Search Phrase Studio API docs. Use before studio_read_api or studio_write_api. Studio is the AI-powered media localization product: transcription, translation, dubbing, and subtitle editing for audio/video projects. show_full=true only when full requestBody schema needed.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `query` (`string`, required): Keywords describing the operation you need, e.g. 'list projects', 'create translation job', 'export target file'.
- `limit` (`integer`, optional): Maximum number of operations to return. The output reports how many ranked matches were withheld by this limit. Default: `10`.
- `show_full` (`boolean`, optional): Return full request-body schemas instead of truncated ones. Use only when you need the full schema to build a request body. Default: `false`.

Example input: `{"query":"list projects"}`

### `phrasemcp_studio_wait_recording_status`

Studio Wait Recording Status · Read-only

Wait for a Studio translate/dubbing/transcription job to finish.

Call after triggering transcription (upload), translate or dubbing instead of
re-issuing GET /v1/recordings/{id}/status through studio_read_api in a loop.
Returns the recording's overall status once it is COMPLETED or FAILED, or a
resumable ``{"status": "pending", "recordingId": ...}`` when the short wait
elapses — normal for any job longer than a few seconds, not a failure. Call
again with the same recording_id to keep waiting; the job continues
server-side. See guide 'studio_02'.

Studio-specific, so registered unconditionally rather than in the per-product
loop. Genuinely read-only — it only GETs the status endpoint — so it is
permitted even when the gateway is read-only.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `recording_id` (`string`, required): Recording ID from the Studio project.
- `language` (`string`, optional): Optional language code (e.g. 'it') to attach that language's per-step breakdown once the recording reaches a terminal status.
- `poll_interval_s` (`integer`, optional): Seconds between internal status polls. Default: `10`.
- `timeout_s` (`integer`, optional): Seconds to wait before returning a resumable 'pending' result. Kept short so the connection is never held open long; re-invoke with the same recording_id on a 'pending' result to keep waiting. Default: `20`.

Example input: `{"recording_id":"<recording_id>"}`

### `phrasemcp_style_guides_read_api`

Style Guides Read Api · Read-only

Forward a read-only Style Guides API request. Use style_guides_search_api to find the right operation, then supply the exact method and path from a search result. Only read-classified operations are accepted: GET/HEAD/OPTIONS requests, plus specific POST paths that the Style Guides API models as reads (search, count, preview, and similar). For write or destructive operations (create, update, delete, import) use style_guides_write_api instead.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

### `phrasemcp_style_guides_search_api`

Style Guides Search Api · Read-only

Search Style Guides API docs: style guide documents and style Rules (/api/v1/rules, create/search/get/update/delete). Use before style_guides_read_api or style_guides_write_api. show_full=true only when full requestBody schema needed.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `query` (`string`, required): Keywords describing the operation you need, e.g. 'list projects', 'create translation job', 'export target file'.
- `limit` (`integer`, optional): Maximum number of operations to return. The output reports how many ranked matches were withheld by this limit. Default: `10`.
- `show_full` (`boolean`, optional): Return full request-body schemas instead of truncated ones. Use only when you need the full schema to build a request body. Default: `false`.

Example input: `{"query":"list projects"}`

### `phrasemcp_tms_preview_segmentation`

Tms Preview Segmentation · Read-only

Show how Phrase TMS splits text into segments, using TMS's own segmentation engine and SRX rules. Use before and after proposing a segmentation rule change rather than asserting what a rule will do. Uses the locale's live TMS default rules unless you pass an existing rule's uid or an inline SRX document to test. To test a change, call once with include_rules=true, amend the SRX it returns, then pass that back as srx — don't write an SRX from scratch. Read-only: it never creates or edits a rule.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `locale` (`string`, required): Source language code of the text, e.g. 'en', 'de', 'ja', 'pt_br'.
- `text` (`string`, required): The source text to segment.
- `include_rules` (`boolean`, optional): Set true to also return the SRX document that was used, so you can amend it and pass the amended copy back as srx. Use this instead of writing an SRX document from scratch when testing a rule change. Default: `false`.
- `segmentation_rule_uid` (`string`, optional): Optional uid of an existing TMS segmentation rule to segment with (from tms_search_api/tms_read_api GET /api2/v1/segmentationRules). Ignored when srx is given.
- `srx` (`string`, optional): Optional SRX 2.0 document to segment with — use this to test a rule change before uploading it, passing raw XML (real < and >, not HTML-escaped). Omit to use the locale's current TMS default rules.

Example input: `{"locale":"en","text":"<text>"}`

### `phrasemcp_tms_read_api`

Tms Read Api · Read-only

Forward a read-only TMS API request. Use tms_search_api to find the right operation, then supply the exact method and path from a search result. Only read-classified operations are accepted: GET/HEAD/OPTIONS requests, plus specific POST paths that the TMS API models as reads (search, count, preview, and similar). For write or destructive operations (create, update, delete, import) use tms_write_api instead.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

### `phrasemcp_tms_search_api`

Tms Search Api · Read-only

Search the Phrase TMS API documentation by keyword. Use this to discover which TMS endpoint to call before using tms_read_api or tms_write_api. Results truncate requestBody by default — use show_full=true only when full schema needed to build request body. Create/patch connector results (POST /api2/v1/connectors, PATCH .../{connectorId}) also carry a perTypeFields map — each connector type's own extra fields beyond the common ones in requestBody (e.g. CONTENTSTACK's contentStackRegion, SALESFORCE's salesforcePublishStrategyType, GOOGLE's oauthClientId) — dropped by default like requestBody, use show_full=true and look up the specific type key rather than guessing a type's extra fields. For update ops: search both PUT and PATCH on same resource. Use show_full=true to inspect both schemas, prefer PATCH if all target fields in requestBody — avoids unintended overwrites, no pre-fetch needed. Fall back to PUT only when PATCH missing required fields. For 'my'/'mine' job queries (e.g. 'my active jobs'): call whoAmI first for your own userUid, then search a short phrase like 'assigned jobs' — not a full sentence — to find the per-user jobs endpoint; a longer query dilutes the literal term match this search uses and can bury the per-user endpoint behind the per-project jobs endpoint. 'Active' job status means NEW, ACCEPTED, or EMAILED only — DELIVERED is a finished state like COMPLETED, not in-progress. TMS has its own native connector feature (list/create/get/patch/delete, connector async task status) under /api2/v1/connectors — separate from the standalone Phrase Connectors product, which only handles file transfer through an already-configured connector. When a request about a project/job mentions a 'connector', search here before concluding via the standalone product that none exists. Automated Project Creation (APC) is likewise native TMS, under /api2/v1/automatedProjects and /api2/v3/automatedProjects — not a capability gap. Load the 'TMS Connector Basics' context block before disambiguating between the two products or setting up an APC — it covers when clarifying is actually needed and when it isn't.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `query` (`string`, required): Keywords describing the operation you need, e.g. 'list projects', 'create translation job', 'export target file'.
- `limit` (`integer`, optional): Maximum number of operations to return. The output reports how many ranked matches were withheld by this limit. Default: `10`.
- `show_full` (`boolean`, optional): Return full request-body schemas instead of truncated ones. Use only when you need the full schema to build a request body. Default: `false`.

Example input: `{"query":"list projects"}`

### `phrasemcp_tms_wait_async`

Tms Wait Async · Read-only

Wait for a TMS async job to complete.

Call after any TMS operation that returns an asyncRequestId (pre-translate,
export, import, analysis). Polls the async-status endpoint internally for a
short bounded interval and returns the job envelope once it is populated.

This intentionally returns quickly rather than blocking for the whole job:
if the job is still running when the short wait elapses, it returns
``{"status": "pending", "asyncRequestId": ...}``. That is the normal,
expected outcome for any job longer than a few seconds — not a failure.
Call this tool again with the same async_request_id to keep waiting (the job
continues server-side); loop until you get the populated envelope. The short
wait keeps the connection from being held open across proxies. A 4xx still
returns a JSON error.

TMS-specific (only TMS models operations as ``/api2/v1/async``), so it is
registered unconditionally rather than in the per-product loop. Genuinely
read-only — it only GETs the status endpoint — so it is permitted even when
the gateway is read-only, even though the job it waits on was a write.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `async_request_id` (`integer`, required): Numeric asyncRequestId returned by a TMS async operation.
- `poll_interval_s` (`integer`, optional): Seconds between internal status polls. Default: `10`.
- `timeout_s` (`integer`, optional): Seconds to wait before returning a resumable 'pending' result. Kept short so the connection is never held open long; re-invoke with the same async_request_id on a 'pending' result to keep waiting. Default: `20`.

Example input: `{"async_request_id":1}`

### `phrasemcp_request_upload_url`

Request Upload Url · Write

Request a signed upload URL for sending a file to Phrase out-of-band. Returns an upload_url (PUT your file bytes there with the correct Content-Type header) and instructions. The PUT response body contains a file_handle token to pass as the file_handle argument to subsequent *_write_api invocations that accept file inputs (e.g. import/translate operations). Use this before any *_write_api that requires a file input — never send file bytes inline in tool arguments. The upload_url expires ~5 minutes after this call and is single-use: PUT to it promptly, and if it fails request a fresh one rather than retrying the same URL.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `content_type` (`string`, required): MIME type of the file, e.g. 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'.
- `filename` (`string`, required): Original filename including extension, e.g. 'document.docx'.
- `workspace` (`string`, optional): Optional workspace label to group related files across calls.

Example input: `{"content_type":"application/vnd.openxmlformats-officedocument.wordprocessingml.document","filename":"document.docx"}`

### `phrasemcp_connectors_write_api`

Connectors Write Api · Destructive

Call the Connectors API. Search first with connectors_search_api and pass its exact method and path — never construct, infer, or version-substitute it. Resolve any name the user gives to the identifier the API uses via a search or list endpoint first — never invent identifier values from REST conventions like 'me' or 'self'. Write bodies follow the endpoint's requestBody schema (use show_full=true on connectors_search_api to read it), not the shape a GET returns — never copy fields from a GET response into a write body. Mirror the schema's nesting exactly — a flattened field is a different, unrecognized key, and endpoints often accept unknown keys silently and fall back to defaults, so it can look successful while quietly not applying the setting. Never emit a write and a write that depends on it as parallel tool calls in the same turn — issue the dependent write only in a later turn, after the prerequisite write's result has come back and confirmed success. A write depends on an earlier one whenever it assumes the earlier one's effect is already in place (e.g. creating a resource inside a container you are still configuring, or enabling a setting that assumes a just-attached resource exists). Sequencing costs one extra turn; getting it wrong silently produces a resource built without the thing you just attached. Two flavours per operation: /async returns a jobId immediately — check the operation's asyncPattern field for the follow-up polling call; /sync blocks until complete. Prefer /sync for small payloads. POST /files/v1/{sync,async}/upload-file requires a file — use the file_handle param, sent as multipart/form-data; never send file bytes inline in body. Other operations that push file content to a connector (upload-raw-file, upload-xliff-file) instead reference an already-uploaded file by storageId in body. To create/configure/list/delete a connector itself, use tms_write_api / tms_read_api against /api2/v1/connectors — that lifecycle is a TMS operation, not part of this product. Automated Project Creation is likewise a TMS operation (/api2/v1/automatedProjects, /api2/v3/automatedProjects), not part of this product.

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

### `phrasemcp_control_hub_write_api`

Control Hub Write Api · Destructive

Call the Control Hub API. Search first with control_hub_search_api and pass its exact method and path — never construct, infer, or version-substitute it. Resolve any name the user gives to the identifier the API uses via a search or list endpoint first — never invent identifier values from REST conventions like 'me' or 'self'. Write bodies follow the endpoint's requestBody schema (use show_full=true on control_hub_search_api to read it), not the shape a GET returns — never copy fields from a GET response into a write body. Mirror the schema's nesting exactly — a flattened field is a different, unrecognized key, and endpoints often accept unknown keys silently and fall back to defaults, so it can look successful while quietly not applying the setting. Never emit a write and a write that depends on it as parallel tool calls in the same turn — issue the dependent write only in a later turn, after the prerequisite write's result has come back and confirmed success. A write depends on an earlier one whenever it assumes the earlier one's effect is already in place (e.g. creating a resource inside a container you are still configuring, or enabling a setting that assumes a just-attached resource exists). Sequencing costs one extra turn; getting it wrong silently produces a resource built without the thing you just attached. PUT replaces the whole resource: GET the current state, merge your change in, and send the complete body — a partial PUT body silently clears omitted fields and drops omitted array/collection elements at any array size (sending 1 of 2 items deletes the other 1 just as surely as 3 of 40 deletes the other 37). Verify the outgoing element count matches what you read before sending, regardless of how small the array is; build large or structured bodies programmatically from the GET result. This applies to scalar fields too, including nested reference objects (e.g. an owner or client field) that can look like read-only metadata — diff every outgoing scalar against the GET baseline, not just array counts, and if you correct one dropped field mid-turn, re-diff the entire resulting state before reporting success. Prefer PATCH when it covers the fields you need. Currently covers content groups — an organisation-scoped coordination layer linking a TMS project to shared Style Guides, Style Rules, and Quality Evaluation checks (Rules themselves are managed in the Style Guides product). Content group `id` is returned by the API — never fabricate it. References are filtered by objectType (TMS_PROJECT, PLATFORM_STYLE_GUIDE, PLATFORM_STYLE_RULE, PLATFORM_QA_CHECK).

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

### `phrasemcp_language_ai_write_api`

Language Ai Write Api · Destructive

Call the Language AI API. Search first with language_ai_search_api and pass its exact method and path — never construct, infer, or version-substitute it. Resolve any name the user gives to the identifier the API uses via a search or list endpoint first — never invent identifier values from REST conventions like 'me' or 'self'. Write bodies follow the endpoint's requestBody schema (use show_full=true on language_ai_search_api to read it), not the shape a GET returns — never copy fields from a GET response into a write body. Mirror the schema's nesting exactly — a flattened field is a different, unrecognized key, and endpoints often accept unknown keys silently and fall back to defaults, so it can look successful while quietly not applying the setting. Never emit a write and a write that depends on it as parallel tool calls in the same turn — issue the dependent write only in a later turn, after the prerequisite write's result has come back and confirmed success. A write depends on an earlier one whenever it assumes the earlier one's effect is already in place (e.g. creating a resource inside a container you are still configuring, or enabling a setting that assumes a just-attached resource exists). Sequencing costs one extra turn; getting it wrong silently produces a resource built without the thing you just attached. File upload: use the file_handle param; put the metadata (sourceLang, targetLangs, actionTypes) in body — sent as the multipart `metadata` form part. Never send file bytes inline in the body. For translation use actionTypes [CONVERTER_IMPORT, MT_GENERIC_PRETRANSLATE] — both are required. Async — poll GET /v1/fileTranslations/{uid} until ALL actions report status OK.

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

### `phrasemcp_portal_write_api`

Portal Write Api · Destructive

Call the Portal API. Search first with portal_search_api and pass its exact method and path — never construct, infer, or version-substitute it. Resolve any name the user gives to the identifier the API uses via a search or list endpoint first — never invent identifier values from REST conventions like 'me' or 'self'. Write bodies follow the endpoint's requestBody schema (use show_full=true on portal_search_api to read it), not the shape a GET returns — never copy fields from a GET response into a write body. Mirror the schema's nesting exactly — a flattened field is a different, unrecognized key, and endpoints often accept unknown keys silently and fall back to defaults, so it can look successful while quietly not applying the setting. Never emit a write and a write that depends on it as parallel tool calls in the same turn — issue the dependent write only in a later turn, after the prerequisite write's result has come back and confirmed success. A write depends on an earlier one whenever it assumes the earlier one's effect is already in place (e.g. creating a resource inside a container you are still configuring, or enabling a setting that assumes a just-attached resource exists). Sequencing costs one extra turn; getting it wrong silently produces a resource built without the thing you just attached. PUT replaces the whole resource: GET the current state, merge your change in, and send the complete body — a partial PUT body silently clears omitted fields and drops omitted array/collection elements at any array size (sending 1 of 2 items deletes the other 1 just as surely as 3 of 40 deletes the other 37). Verify the outgoing element count matches what you read before sending, regardless of how small the array is; build large or structured bodies programmatically from the GET result. This applies to scalar fields too, including nested reference objects (e.g. an owner or client field) that can look like read-only metadata — diff every outgoing scalar against the GET baseline, not just array counts, and if you correct one dropped field mid-turn, re-diff the entire resulting state before reporting success. Prefer PATCH when it covers the fields you need. File upload (e.g. PUT /admin-app/portals/{portalId}/logo): use the file_handle param, not body.

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

### `phrasemcp_quality_evaluator_write_api`

Quality Evaluator Write Api · Destructive

Call the Quality Evaluator API. Search first with quality_evaluator_search_api and pass its exact method and path — never construct, infer, or version-substitute it. Resolve any name the user gives to the identifier the API uses via a search or list endpoint first — never invent identifier values from REST conventions like 'me' or 'self'. Write bodies follow the endpoint's requestBody schema (use show_full=true on quality_evaluator_search_api to read it), not the shape a GET returns — never copy fields from a GET response into a write body. Mirror the schema's nesting exactly — a flattened field is a different, unrecognized key, and endpoints often accept unknown keys silently and fall back to defaults, so it can look successful while quietly not applying the setting. Never emit a write and a write that depends on it as parallel tool calls in the same turn — issue the dependent write only in a later turn, after the prerequisite write's result has come back and confirmed success. A write depends on an earlier one whenever it assumes the earlier one's effect is already in place (e.g. creating a resource inside a container you are still configuring, or enabling a setting that assumes a just-attached resource exists). Sequencing costs one extra turn; getting it wrong silently produces a resource built without the thing you just attached. PUT replaces the whole resource: GET the current state, merge your change in, and send the complete body — a partial PUT body silently clears omitted fields and drops omitted array/collection elements at any array size (sending 1 of 2 items deletes the other 1 just as surely as 3 of 40 deletes the other 37). Verify the outgoing element count matches what you read before sending, regardless of how small the array is; build large or structured bodies programmatically from the GET result. This applies to scalar fields too, including nested reference objects (e.g. an owner or client field) that can look like read-only metadata — diff every outgoing scalar against the GET baseline, not just array counts, and if you correct one dropped field mid-turn, re-diff the entire resulting state before reporting success. Prefer PATCH when it covers the fields you need. POST /v3/evaluation is synchronous (no polling): raw segments; checks come from the Content Group (contentGroupId). GET /v3/qualityProfiles/{contentGroupId} is read-only. For TMS jobs/workflow steps use the TMS API's POST /api2/v1/projects/{projectUid}/jobs/evaluateQuality (job UIDs, no file download). AI checks are Style Guides Rules (POST /api/v1/rules, aiCheckEnabled: true) attached to a Content Group — search style_guides_search_api first.

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

### `phrasemcp_strings_write_api`

Strings Write Api · Destructive

Call the Phrase Strings API (Bearer platform token). Search first with strings_search_api and pass its exact method and path (path parameters filled in, e.g. /projects/xAbCdEfG/keys — do NOT prepend /v2, the base URL already includes it). The path must come from a search result — never construct, infer, or version-substitute it. Identifiers are opaque string UIDs (e.g. 'xAbCdEfG'), never the numeric IDs shown in the UI and never REST conventions like 'me' or 'self'. When the user names an entity by name or number, resolve it to its UID first via a search or list endpoint, then use that UID. Applies to every entity type — projects, keys, translations, locales, jobs. Write bodies follow the endpoint's requestBody schema (use show_full=true on strings_search_api to read it), not the shape a GET returns — never copy fields from a GET response into a write body. Mirror the schema's nesting exactly — a flattened field is a different, unrecognized key and can silently fall back to a default instead of erroring. PUT replaces the whole resource: GET the current state, merge your change into it, and send the complete body — a partial PUT body silently clears every field you omit and drops every array element you omit, at any array size. Verify the outgoing element count matches what you read regardless of size; build large bodies from the GET result. This applies to scalar fields too, including nested reference objects that can look like read-only metadata — diff every outgoing scalar against the GET baseline, not just array counts, and if you correct one dropped field mid-turn, re-diff the entire resulting state before reporting success. Prefer PATCH when it covers the fields you need. Never emit a write and a write that depends on it as parallel tool calls in the same turn — issue the dependent write only in a later turn, after the prerequisite write's result has come back and confirmed success. A write depends on an earlier one whenever it assumes the earlier one's effect is already in place. Sequencing costs one extra turn; getting it wrong silently produces a resource built without the thing you just attached. Before writing to an item found by a filtered lookup, confirm its own identifying fields (e.g. locale, key) match the target, and do not take result [0] when the count is unexpected for the filters. File upload (POST /projects/{project_id}/uploads): use the file_handle param; required fields file_format and locale_id (plus any optional fields) go in body — each is sent as its own multipart form field, not a nested JSON body. Never send file bytes inline in body.

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

### `phrasemcp_studio_write_api`

Studio Write Api · Destructive

Call the Phrase Studio API. Search first with studio_search_api and pass its exact method and path — never construct, infer, or version-substitute it. Resolve any name the user gives to the identifier the API uses via a search or list endpoint first — never invent identifier values from REST conventions like 'me' or 'self'. Write bodies follow the endpoint's requestBody schema (use show_full=true on studio_search_api to read it), not the shape a GET returns — never copy fields from a GET response into a write body. Mirror the schema's nesting exactly — a flattened field is a different, unrecognized key, and endpoints often accept unknown keys silently and fall back to defaults, so it can look successful while quietly not applying the setting. Never emit a write and a write that depends on it as parallel tool calls in the same turn — issue the dependent write only in a later turn, after the prerequisite write's result has come back and confirmed success. A write depends on an earlier one whenever it assumes the earlier one's effect is already in place (e.g. creating a resource inside a container you are still configuring, or enabling a setting that assumes a just-attached resource exists). Sequencing costs one extra turn; getting it wrong silently produces a resource built without the thing you just attached. Studio manages AI-powered media localization projects (transcription, translation, dubbing, subtitles). Project `id` is returned by the API — never fabricate it. PATCH updates project settings; PUT /v1/projects/{projectId}/recordings/{recordingId}/subtitles replaces all subtitle data — any segment you omit is deleted from the track. GET the current subtitles first, merge your changes into the full segment array, and send every segment. Build the body from the GET result (not by hand) and verify the outgoing segment count matches what you read before sending — a body with fewer segments deletes the difference. File upload (POST /v1/projects): use the file_handle param; put project settings (sourceLanguage, subtitleProfiles, etc.) in body — each is sent as its own multipart form field, not a nested JSON body. This call transparently follows Studio's upload-service redirect — do not treat a successful result as needing a second call. Always pass a `title` query param on this call, derived from the uploaded filename (strip the extension) or the user's stated localization intent if no filename is available — title has no default worth keeping: omitting it silently names the project 'Untitled Project'. Required: sourceLanguage, subtitleProfiles (fetch ids via GET /v1/subtitle-profiles first). Does NOT accept translationLanguages/dubbingLanguages — always creates a transcription-only project. Add translation/dubbing afterward with POST .../recordings/{recordingId}/translate (after transcription completes) and .../dubbing (after that language's translation completes). See guide 'studio_01' for the exact form-field shape. After triggering translate/dubbing/transcription, use studio_wait_recording_status instead of re-polling GET .../status in a loop — see guide 'studio_02'.

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

### `phrasemcp_style_guides_write_api`

Style Guides Write Api · Destructive

Call the Style Guides API (style guides and style Rules, /api/v1/rules*). Search first with style_guides_search_api and pass its exact method and path — never construct, infer, or version-substitute it. Resolve any name the user gives to the identifier the API uses via a search or list endpoint first — never invent identifier values from REST conventions like 'me' or 'self'. Write bodies follow the endpoint's requestBody schema (use show_full=true on style_guides_search_api to read it), not the shape a GET returns — never copy fields from a GET response into a write body. Mirror the schema's nesting exactly — a flattened field is a different, unrecognized key, and endpoints often accept unknown keys silently and fall back to defaults, so it can look successful while quietly not applying the setting. Never emit a write and a write that depends on it as parallel tool calls in the same turn — issue the dependent write only in a later turn, after the prerequisite write's result has come back and confirmed success. A write depends on an earlier one whenever it assumes the earlier one's effect is already in place (e.g. creating a resource inside a container you are still configuring, or enabling a setting that assumes a just-attached resource exists). Sequencing costs one extra turn; getting it wrong silently produces a resource built without the thing you just attached. PUT replaces the whole resource: GET the current state, merge your change in, and send the complete body — a partial PUT body silently clears omitted fields and drops omitted array/collection elements at any array size (sending 1 of 2 items deletes the other 1 just as surely as 3 of 40 deletes the other 37). Verify the outgoing element count matches what you read before sending, regardless of how small the array is; build large or structured bodies programmatically from the GET result. This applies to scalar fields too, including nested reference objects (e.g. an owner or client field) that can look like read-only metadata — diff every outgoing scalar against the GET baseline, not just array counts, and if you correct one dropped field mid-turn, re-diff the entire resulting state before reporting success. Prefer PATCH when it covers the fields you need. Create with POST /api/v2/styleguides and update with PUT /api/v2/styleguides/{id} — both require a contentGroupId query param; these are the primary create/update paths. POST /api/v1/styleguides and PUT /api/v1/styleguides/{id} are deprecated and scheduled for removal — do not use for new integrations. POST always requires a file (use the file_handle param; never send file bytes inline in the body) and returns 202 with a jobId. PUT's file is optional: include it to upload a new version (202 with a jobId), or omit it for a metadata-only update (200 with the updated Style Guide). Poll GET /api/v1/styleguides/async/create-jobs/{jobId} or /async/update-jobs/{jobId} until status=COMPLETED, then read result.id. The `language` must be the exact target locale of the TMS project the guide serves, hyphenated (TMS de_at -> de-AT): AI Checks match it exactly, with no language/regional-variant fallback, so a mismatch silently disables them. Use a regional locale unless the user explicitly asks for a bare language code.

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

### `phrasemcp_tms_write_api`

Tms Write Api · Destructive

Call the Phrase TMS API (Bearer platform token). Search first with tms_search_api and pass its exact method and path. The path must come from a search result — never construct, infer, or version-substitute it. Identifiers are opaque string UIDs (e.g. 'xAbCdEfG'), never the numeric IDs shown in the UI (e.g. '#46130') and never REST conventions like 'me' or 'self'. When the user names an entity by number or name, resolve it to its UID first via a search or list endpoint, then use that UID. Applies to every entity type — projects, jobs, translation memories, term bases, users. When a path template like '/transMemories/{transMemoryUid}/...' comes from a search result and you already have the real UID (e.g. from a create call's response earlier this turn), substitute it into the placeholder — never send the literal '{transMemoryUid}'/'{termBaseUid}'-style token itself; the API rejects it with a 404. For 'my'/'mine' queries (e.g. 'my active jobs'): call whoAmI for your own userUid, then search a short phrase matching likely endpoint naming (e.g. 'assigned jobs', not a full sentence — search matches literal terms against the endpoint summary, and a long query dilutes the match). Only enumerate every parent resource (e.g. every project) and filter client-side if no per-user endpoint exists after trying a couple of short phrasings. Write bodies follow the endpoint's requestBody schema (use show_full=true on tms_search_api to read it), not the shape a GET returns — never copy fields from a GET response into a write body. Mirror the schema's nesting exactly — a flattened field is a different, unrecognized key, and TMS often accepts unknown keys silently and falls back to defaults, so it can look successful while quietly not applying the setting. A format-specific sub-block of import settings (multilingual Excel/CSV/XML mappings) is applied only when fileFormat selects the matching format, never auto-detect — see the 'multilingual import settings' guide. PUT replaces the whole resource: GET the current state, merge your change into it, and send the complete body — a partial PUT body silently clears every field you omit and drops every array element you omit (e.g. a project TM or term-base list), at any array size — dropping 1 of 2 entries is just as destructive as dropping 3 of 40. Verify the outgoing element count matches what you read, regardless of size; build large bodies from the GET result. This applies to scalar fields too, including nested reference objects like owner or client. Check the requestBody schema by field name, not by how audit-trail-shaped the GET value looks: owner and createdBy/modifiedBy all return the identical person-record shape (firstName/email/id/uid), but only owner is schema-writable — createdBy/modifiedBy are not, so the shared shape cannot tell you which to keep; the schema decides, not the value's resemblance to a read-only audit field. Diff every outgoing scalar against the GET baseline, not just array counts, and if you correct one dropped field mid-turn, re-diff the entire resulting state before reporting success. Prefer PATCH when it covers the fields you need. Never emit a write and a write that depends on it as parallel tool calls in the same turn — issue the dependent write only in a later turn, after the prerequisite write's result has come back and confirmed success. A write depends on an earlier one whenever it assumes the earlier one's effect is already in place: creating a job in a project you are attaching a TM or term base to (a job created before the attach lands will not pick those resources up), or enabling a setting that assumes a just-attached resource exists. Sequencing costs one extra turn; getting it wrong silently produces a resource built without the thing you just attached. Creating a project never applies a chosen MT engine — the org default applies. If a specific engine was requested or planned, assign it after creation (PUT /api2/v1/projects/{projectUid}/mtSettings, engine `id` from GET /api2/v1/machineTranslateSettings), read it back, and report the engine actually applied; see guide 'tms_17' via load_phrase_guide. To copy/clone an entity, prefer its dedicated clone endpoint (search for it) — it replicates the full source config in one call. If you must copy manually, first call each structural sub-resource endpoint on the source (e.g. workflow steps) before creating the new entity; never infer a sub-resource is empty from the parent GET, and never create from the parent read alone. Some operations start a background job and return asyncResponse: null (the search result is tagged asyncPattern); treat that as in-progress, and call tms_wait_async with the returned asyncRequestId before any dependent call. It waits a short bounded interval and returns the populated job envelope if ready. For any job longer than a few seconds it will instead return {"status": "pending"} — this is expected, not a failure: call tms_wait_async again with the same asyncRequestId, and keep looping until you get the populated envelope. For job file uploads (e.g. job creation, update source/target): use the file_handle param; include a Memsource header with job metadata (e.g. {"Memsource": "{\"targetLangs\":[\"de\"]}"}). Never send file bytes inline in the body. Connector lifecycle (list, create, get, patch/configure, delete a connector; connector async task status) is a TMS operation under /api2/v1/connectors — search and call it here, not via the separate 'Connectors' product, which only handles file transfer through an already-configured connector. When creating a connector with no real credential given, never ask the caller whether to use a placeholder or wait — immediately send a clearly-marked, non-empty placeholder string (e.g. 'REPLACE_ME') for the secret field(s); never omit the field or send null/''. Automated Project Creation (APC — a connector automatically creating projects, e.g. watching a folder for new files) is likewise a native TMS operation under /api2/v1/automatedProjects and /api2/v3/automatedProjects — not a capability gap. For OAuth flow mechanics, per-connector-type creation quirks, and APC field/lifecycle detail, load the relevant 'TMS Connector *' guide via load_phrase_guide ('tms_02' through 'tms_12' — see list_phrase_guides) rather than guessing or asking the caller.

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `method` (`string`, required): HTTP method, e.g. GET, POST, PUT, PATCH, DELETE.
- `path` (`string`, required): API path exactly as returned by the matching <product>_search_api tool, with path parameters filled in. Must come from a prior search result — never invented or version-substituted.
- `allow_dropping_keys` (`string`, optional): Escape hatch for a PUT that intentionally clears/omits some top-level fields the API last returned for this same resource (a full-replace PUT with no PATCH semantics resets any omitted field). Only needed if a PUT was blocked with `dropped_keys` in the response — pass those exact key names here to confirm the omission is deliberate.
- `body` (`string`, optional): Optional JSON request body for POST/PUT/PATCH. For a multipart file-upload operation (a file_handle is supplied and the product uploads multipart, e.g. Language AI), the body object is sent as the `metadata` form part alongside the file — e.g. {"sourceLang":{"code":"en"},"targetLangs":[{"code":"cs"}],"actionTypes":[...]}.
- `file_handle` (`string`, optional): Optional file_handle token returned by PUT /mcp/uploads/{ticket}. Provide when the operation requires a file input (e.g. import/translate). Obtain it by calling request_upload_url first, then PUT the file bytes.
- `headers` (`string`, optional): Optional extra HTTP request headers as key-value pairs. Use when the API requires metadata in a header rather than the body — for example, the TMS job-import endpoint requires a Memsource header containing JSON job parameters: {"Memsource": "{\"targetLangs\":[\"de\"]}"}.
- `query_params` (`string`, optional): Optional query-string parameters as key-value pairs.

Example input: `{"method":"<method>","path":"<path>"}`

## Related

Other AI connectors ([all 216](/agentkit/connectors/?category=ai)):

- [Chorus](/agentkit/connectors/chorus/): Scalekit connector, Username and password, 9 tools
- [Gong](/agentkit/connectors/gong/): Scalekit connector, OAuth, 69 tools
- [Jiminny](/agentkit/connectors/jiminny/): Scalekit connector, Access token, 27 tools


---

## More Scalekit documentation

| Resource | What it contains | When to use it |
|----------|-----------------|----------------|
| [/llms.txt](/llms.txt) | Structured index with routing hints per product area | Start here — find which documentation set covers your topic before loading full content |
| [/llms-full.txt](/llms-full.txt) | Complete documentation for all Scalekit products in one file | Use when you need exhaustive context across multiple products or when the topic spans several areas |
| [sitemap-0.xml](https://docs.scalekit.com/sitemap-0.xml) | Full URL list of every documentation page | Use to discover specific page URLs you can fetch for targeted, page-level answers |
