How to Use the LibreTranslate API MCP in LangChain

Q: Can LangChain trace LibreTranslate API tool calls?

Yes, every call to detectlanguage or translatetext is automatically traced if you have LangSmith enabled. You will see the exact inputs, outputs, and execution latency of the MCP tools inside your LangSmith dashboard.

Q: How does the LibreTranslate API handle unsupported languages in LangChain?

Your agent can call listsupportedlanguages to get an active list of supported language codes. You can write a short chain that checks the output of detectlanguage against this list before calling translatetext.

Translate and detect text instantly inside your LangChain chains using the LibreTranslate API MCP Server.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect LibreTranslate API MCP to LangChain

Create your Vinkius account to connect LibreTranslate API to LangChain and route execution through our secure gateway. The platform manages server hosting, runtime updates, and security layers. Configuration requires no manual server provisioning.

GDPR Free for Subscribers

Setup LibreTranslate API with LangChain

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Chain language detection into your LangChain runs

The `detect_language` tool lets you inject language identification directly into your LangChain runnables. Your agent calls `detect_language` to inspect incoming user text before routing it to the next step of your chain. This prevents your LLMs from receiving text they cannot process, saving run time and API budget. By passing the output directly to other tools, you build self-correcting pipelines. If the confidence score is too low, your chain can automatically query `list_supported_languages` to verify if the source tongue is supported before attempting a translation.

Translate text dynamically during agent execution

The `translate_text` tool integrates directly into LangChain's ReAct agent loops to handle multilingual inputs on the fly. Your agent evaluates the user's intent, determines if translation is required, and fires the tool without hardcoded routing rules. You get clean, translated strings passed to your downstream tools or vector stores in real time. Every translation step is fully visible inside LangSmith. You can trace the input string, the execution latency of `translate_text`, and the output payload to debug translation errors or latency bottlenecks instantly.

Monitor translation server health inside your pipelines

The `check_api_status` tool lets your LangChain application monitor the state of your translation backend before executing heavy batch jobs. Your initialization chain calls this tool to verify the local or remote LibreTranslate instance is online. If the server is down, your chain can gracefully fail or switch to a fallback endpoint. This proactive health check keeps your multi-step agents from hanging on dead connections. You don't waste LLM tokens on runs that will ultimately fail due to an unreachable translation backend.

Setup guide

Set up LibreTranslate API MCP in LangChain

Prerequisites

Python 3.10+ installed
langchain-mcp-adapters + langgraph packages
Active Vinkius subscription with a valid endpoint token

1

Install dependencies
Run pip install langchain-mcp-adapters langgraph langchain-openai. The MCP adapters package converts MCP tools into native LangChain BaseTool objects.
2

Connect via HTTP transport
Use MultiServerMCPClient with "transport": "http" pointing to your Vinkius endpoint. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.
3

Create a ReAct agent
Pass the discovered tools to create_react_agent() from LangGraph. The agent automatically routes LibreTranslate API tool calls through the MCP protocol.
4

Run with any LLM
Swap ChatOpenAI for ChatAnthropic, ChatGoogleGenerativeAI, or any LangChain-compatible model. The MCP tools work identically across all providers.

agent.py

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

async with MultiServerMCPClient({
    "libretranslate-api-mcp": {
        "transport": "http",
        "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp",
    }
}) as client:
    tools = client.get_tools()

    agent = create_react_agent(
        ChatOpenAI(model="gpt-4o"),
        tools,
    )
    result = await agent.ainvoke({
        "messages": "List recent LibreTranslate API transactions"
    })
    print(result["messages"][-1].content)

Get your connection token →

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by LibreTranslate. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

Why Choose Vinkius

Vinkius connects your tools to AI with real-time monitoring and automatic cost savings — all from one dashboard.

Connect LibreTranslate API now

Real-time monitoring

Live

visibility into every interaction

Connect your favorite tools to your AI and see exactly what's happening — every request, every response, in real time.

Built-in savings

60%

lower AI costs

Vinkius compresses data between your apps and your AI automatically. Lower bills every month — no configuration required.

Single dashboard

One

place for every integration

Every tool your AI connects to, managed from a single screen. One account, complete control.

Common questions about LibreTranslate API MCP in LangChain

You initialize the MultiServerMCPClient with the Vinkius endpoint and call get_tools to fetch the tools. Then, pass these tools—including `translate_text`—directly into your LangChain agent constructor.

Yes, every call to `detect_language` or `translate_text` is automatically traced if you have LangSmith enabled. You will see the exact inputs, outputs, and execution latency of the MCP tools inside your LangSmith dashboard.

Your agent can call `list_supported_languages` to get an active list of supported language codes. You can write a short chain that checks the output of `detect_language` against this list before calling `translate_text`.

Yes, you configure the server URL in your Vinkius dashboard to point to your self-hosted instance. LangChain connects to the secure Vinkius endpoint, which handles the connection to your local server.

No, this MCP Server only processes your raw text strings in memory to perform the translation. Your text payloads are never logged or stored by Vinkius, and they are sent directly to your configured LibreTranslate instance.

Use it with your favorite AI tools

Connect this server to Cursor, Claude, VS Code, and more.

OpenAI Agents SDK sdk-python

Google ADK sdk-python

Pydantic AI sdk-python

Vercel AI SDK sdk-typescript