DeepL MCP

CALL ANY TOOL

Translation through DeepL's MCP server: translate and rephrase text, translate documents, and manage glossaries and writing styles.

deeplmcp_correct_text

Correct text

Correct one or more texts for typos, grammar and punctuation errors using DeepL.

Parameters

Name

Type

Required

Description

text

array

Required

One or more texts to correct.

targetLang

string

Optional

Optional target language code. DeepL Write supports: DE, EN-GB, EN-US, ES, FR, IT, JA, KO, PT-BR, PT-PT, ZH-HANS.

deeplmcp_download_document

Download document

deeplmcp_get_document_status

Get document status

deeplmcp_get_source_languages

Get source languages

deeplmcp_get_target_languages

Get target languages

deeplmcp_rephrase_text

Rephrase text

deeplmcp_translate_text

Translate text

deeplmcp_upload_document

Upload document

Translate a whole file or document, preserving its original layout and formatting. Use this: not translate-text: whenever the user wants to translate a file or document (rather than text typed into the conversation), even if its contents are already visible to you; translate-text would strip the formatting. For plain text pasted into the conversation, use translate-text instead. Supported file types: Word (.docx, .doc), PowerPoint (.pptx, .ppt), Excel (.xlsx, .xls), PDF, HTML (.html, .htm), plain text (.txt), subtitles (.srt), and XLIFF (.xlf, .xliff). This call starts the translation and returns 'sessionId', 'uploadUrl', and 'uploadPageUrl'. Select 'agent_http' only when you can read the referenced file and perform an HTTP PUT. In that mode, pass 'filename' with a supported extension and send the raw file bytes to 'uploadUrl' with 'Content-Type: application/octet-stream'. Select 'inline_ui' otherwise. In 'inline_ui', the MCP App collects the file; when no MCP App renders, give the user 'uploadPageUrl' to select it in a browser. Then poll get-document-status with the sessionId until it reports 'done', and call download-document. The file bytes never pass through this conversation. An administrator may assign a language system (style profile) to the account, whose glossaries and style rule set can replace the glossaryId and styleId passed here; 'appliedCustomizations' in the result says so when it happened.

Parameters

Name

Type

Required

Description

targetLang

string

Required

Target language code, e.g. 'EN-US' or 'DE'. Use get-target-languages to discover supported codes.

customInstructions

array

Optional

Free-text instructions that steer the translation (e.g. 'Use a friendly tone'). Requires a DeepL Pro plan.

filename

string

Optional

Original file name including its extension (e.g. 'report.docx'). Required for 'agent_http'; the inline_ui picker supplies it when the user selects a file.

formality

string

Optional

Controls formality: 'less', 'more', or 'default'. Only some target languages support this. Requires a DeepL Pro plan.

glossaryId

string

Optional

Id of a glossary to apply. Requires sourceLang; the glossary must have a dictionary for the source/target pair. Use list-glossaries to discover ids. Requires a DeepL Pro plan.

sourceLang

string

Optional

Source language code, e.g. 'EN'. Omit to let DeepL auto-detect. Required when using a glossary.

styleId

string

Optional

Style rule set id from list-style-rule-sets. Its own custom instructions are applied with it, so do not repeat them below. Requires a DeepL Pro plan.

uploadMode

string

Optional

Select 'inline_ui' for the widget or 'agent_http' when you can HTTP PUT the referenced file. Defaults to 'inline_ui'.

Build your Agent

Drop the toolkit in, point it at the user, and your localization agent can use DeepL from the first run.

import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// DeepL MCP tools, scoped to the signed-in user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["deeplmcp"], toolNames: [
    "deeplmcp_correct_text",
    "deeplmcp_download_document",
    "deeplmcp_get_document_status"
  ] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "Translate the release notes into German and French." }] });

import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// DeepL MCP tools, scoped to the signed-in user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["deeplmcp"], toolNames: [
    "deeplmcp_correct_text",
    "deeplmcp_download_document",
    "deeplmcp_get_document_status"
  ] },
  pageSize: 100,
});

const openai = new OpenAI();
const res = await openai.responses.create({
  model: "gpt-5",
  tools: tools.map((t) => t.openai),
  input: "Translate the release notes into German and French.",
});

import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// DeepL MCP tools, scoped to the signed-in user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["deeplmcp"], toolNames: [
    "deeplmcp_correct_text",
    "deeplmcp_download_document",
    "deeplmcp_get_document_status"
  ] },
  pageSize: 100,
});

const anthropic = new Anthropic();
const msg = await anthropic.messages.create({
  model: "claude-opus-4-6",
  max_tokens: 1024,
  tools: tools.map((t) => t.anthropic),
  messages: [{ role: "user", content: "Translate the release notes into German and French." }],
});

import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// DeepL MCP tools, scoped to the signed-in user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["deeplmcp"], toolNames: [
    "deeplmcp_correct_text",
    "deeplmcp_download_document",
    "deeplmcp_get_document_status"
  ] },
  pageSize: 100,
});

const agent = new Agent({
  name: "deeplmcp_agent",
  model: "gemini-2.5-pro",
  instruction: "Act as the localization agent for the signed-in user.",
  tools,
});
await agent.run("Translate the release notes into German and French.");

Try these prompts

Paste any prompt into your agent to start using DeepL.

Translation

Copy the prompt

Copied

Translate the release notes into German and French.

Copy the prompt

Copied

Translate this support reply into the customer's language.

Copy the prompt

Copied

Translate the attached PDF into Japanese.

Tone and clarity

Copy the prompt

Copied

Rephrase this paragraph to sound more direct.

Copy the prompt

Copied

Fix the grammar in this changelog entry.

Copy the prompt

Copied

Rewrite this onboarding email in a formal register.

Glossary control

Copy the prompt

Copied

List the terms in the product glossary.

Copy the prompt

Copied

Add Agent Auth to the glossary as do-not-translate.

Copy the prompt

Copied

Which writing styles are available on this account?

SEE HOW AUTH WORKS

Users authorize DeepL once. Their credentials stay vaulted, every call is checked, and every action is logged.

1

Authorize

Your user connects

DeepL MCP

once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access

Who:

user ‘A’

when:

Once per user

access:

Limited to user

2

Store

Their

DeepL MCP

token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection

vault:

encrypted

scope:

per-user

tokens:

auto-refreshed

3

Resolve

When your agent calls a

DeepL MCP

tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs

speed:

~40ms

check:

before every call

seen by:

nobody

4

Audit

Every

DeepL MCP

tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it

history:

90 days

export:

SIEM-ready

logged:

every call

Test other agents

Same per-user auth pattern across other agents and MCP connectors. Working code, live demos, fork what fits.

Engineering Teams

Auto release notes agent

Reads merged GitHub PRs, groups them into structured release notes, publishes the page to Notion, and announces the release in Slack. Every call runs on the engineer's own delegated OAuth.

Support and Ops Teams

Support ticket automation agent

Fetches new Zendesk tickets, drafts a reply from Notion knowledge base articles, digests what it cannot answer to Slack, and archives the rest, acting as the support agent rather than a shared API key.

Support and Ops Teams

Support triage agent

Fetches new Zendesk tickets, classifies them by type and urgency, searches the Notion knowledge base for an answer, and routes what it cannot resolve to Slack. Every call runs on the support agent's own delegated OAuth.

Engineering Teams

Slack triage

Polls Slack for new messages, classifies bugs and support requests with a LangGraph router, files GitHub issues or Zendesk tickets, and confirms in the thread.

Test other agents

Same per-user auth pattern across other agents and MCP connectors. Working code, live demos, fork what fits.

SUPPORT

Support ticket automation (Google ADK)

Fetch, annotate, and archive Zendesk tickets with Notion context, digesting anything it cannot answer to Slack.

SUPPORT

Support triage agent

Classify new Zendesk tickets, search the Notion knowledge base for an answer, and route what it cannot resolve to Slack.

ENGINEERING

Auto-release notes agent

Group merged GitHub PRs into structured release notes, publish the page to Notion, and announce the release in Slack.

ENGINEERING

Slack triage agent

Classify new Slack messages as bugs or support requests, file the GitHub issue or Zendesk ticket, and reply in the thread.

Why Scalekit

Secure your agent's access. Connectors ship in minutes

01.

Shared tokens break per-user analytics

A shared token looks fine in a demo. In production every call looks like a service account. Scalekit resolves the real user credential so attribution, audit, and scope stay accurate.

// shared token
audit → bot_service_account
user_filter → broken

// scalekit
audit → user_abc
scope → enforced ✓

02.

Authentication is not authorization

03.

Multi-tenancy is architectural

04.

DeepL today. Others tomorrow.

“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”

Venu Madhav Kattagoni

Head of Engineering / Von

FAQs

Frequently Asked Questions

Does the agent access DeepL as the user or as a shared key?

As the user. Each member authorizes once and Scalekit resolves their credential at request time. Audit logs attribute every action to that user, not a shared service account.

Where is the DeepL oauth 2.1 credential stored?

In Scalekit's managed AES-256 token vault, namespaced per tenant. Refresh is automatic. Revocation is a single dashboard action. Credentials never appear in prompts, logs, or LLM context.

Can I limit what the agent is allowed to do in DeepL?

Yes. Pass a tool name filter to listScopedTools so the localization agent only sees the subset you authorize. Pre-API-call scope checks block out-of-policy actions before the request reaches DeepL.

What happens when a user revokes DeepL access?

The connection is invalidated on the next tool call. Subsequent requests for that user fail closed with a clear error. Other users in the tenant remain unaffected. The event is logged for audit.

Does text sent for translation get used for training?

That is governed by your DeepL plan, not by Scalekit. What Scalekit guarantees is the path: the call runs on the authorizing user's credential, the token never enters LLM context, and every translation request is logged for audit.

Tools your localization agent reaches for on DeepL MCP, scoped per user.