How to Use the Mitto MCP in LangChain

Q: How do I handle Mitto 2FA timeouts inside a LangChain sequence?

Use the cancel2fa tool within a conditional LangChain branch when a session expires. Your agent checks the status and triggers a clean cancellation before initiating a new attempt.

Q: Can my LangChain agent send bulk marketing campaigns using Mitto?

Yes, the agent calls sendbulksms to distribute messages to large recipient lists. You pass structured data from a database chain directly into this tool's payload.

Q: Can I set rate limits on SMS dispatch dynamically?

You run set2falimits directly from your agent to control dispatch velocity. This prevents your chains from spamming users or draining your API balance during testing.

Chain Mitto SMS dispatch and 2FA verification steps directly inside your LangChain reasoning loops with this dedicated 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 Mitto MCP to LangChain

Create your Vinkius account to connect Mitto 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 Mitto with LangChain

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Chain SMS lookups and dispatch in LangChain

The `lookup_number` tool identifies carrier details and formatting errors before your agent fires off a message. LangChain runs this check first, passing the validated phone records directly to `send_sms` in the next link of the chain. This sequence stops wasted spend on invalid numbers before they hit the carrier network. You track the outcome by feeding results into `track_sms_conversion` within the same execution path. LangSmith traces every step, showing you the exact latency of the number lookup and the subsequent SMS dispatch.

Multi-step LangChain 2FA verification flows

The `send_2fa` tool initiates user authentication by dispatching a one-time passcode to a mobile device. Your LangChain agent handles the setup by configuring logic with `set_2fa_workflows` and then monitoring the verification lifecycle. This MCP integration gives your agent the autonomy to decide when to trigger a retry or flag a failure. When the user submits their code, the agent calls `verify_2fa` to confirm the match. Because LangChain manages the state across these steps, you build self-correcting auth pipelines that handle timeouts without manual code.

Manage number masking with this LangChain MCP Server

The `create_masking_application` tool sets up anonymous communication channels to protect user identities during active sessions. Your agent builds the entire session context on the fly using `create_masking_context` and handles participant assignment with `add_masking_participant`. This setup isolates buyer and seller phone numbers completely. Once the interaction ends, the agent cleans up the temporary routing by executing `delete_masking_context` to free up your pool of active numbers.

Setup guide

Set up Mitto 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 Mitto 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({
    "mitto-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 Mitto 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 Mitto. 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 Mitto 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 Mitto MCP in LangChain

Use the `cancel_2fa` tool within a conditional LangChain branch when a session expires. Your agent checks the status and triggers a clean cancellation before initiating a new attempt.

Yes, the agent calls `send_bulk_sms` to distribute messages to large recipient lists. You pass structured data from a database chain directly into this tool's payload.

LangSmith logs the exact inputs and outputs for operations like `lookup_number` and `send_sms`. You see the payload size, carrier response times, and execution errors in a visual timeline.

You run `set_2fa_limits` directly from your agent to control dispatch velocity. This prevents your chains from spamming users or draining your API balance during testing.

This MCP Server processes phone numbers and SMS content inside an ephemeral V8 sandbox that deletes all execution state immediately after the tool call completes. No message payloads or recipient details are stored on the Vinkius hosting infrastructure.

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