How to Use the MRPLN MCP in LangChain

Q: How do I build a customer follow-up sequence in LangChain with MRPLN tools?

You create a chain of calls. Start with getcustomer to fetch their data, then use an LLM to decide the next step, like sending a message with sendemailmessage or updating their record with updatecustomer.

Q: Can my LangChain agent choose between SMS and email in MRPLN?

Yes. Your agent can call getcustomer to check for a phone number or email, then use its logic to invoke either the sendsmsmessage or sendemailmessage tool. It's a classic use case for a ReAct agent.

Q: What's the best way to get MRPLN tactic performance using LangChain?

Use the gettacticperformance tool within a loop that iterates over the output of listtactics. You can then feed the performance data into another part of your chain to make decisions.

Build automated production and customer communication chains for MRPLN with your LangChain agent.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect MRPLN MCP to LangChain

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

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Chain Customer Creation to Outreach

This MCP server gives your agent the tools to build a full customer onboarding sequence. It's not just about one-off actions. Your agent can create a chain that starts with `create_customer` the moment a new lead comes in. From there, the chain can immediately call `list_waba_templates` to find the right welcome message, then fire `send_whatsapp_message` to start the conversation. The agent decides the path, connecting these tools in a logical sequence that runs automatically.

Build Self-Correcting Campaigns

Stop guessing if your outreach is working. You can build a LangChain agent that creates a performance feedback loop. The agent calls `list_tactics` to get all your current campaigns, then iterates through them using `get_tactic_performance` to see what's actually effective. Based on those numbers, the agent can make its own decisions. If a tactic is failing, it can stop it. If one is succeeding, it can find similar contacts with `list_customers` and expand the campaign. It's an autonomous loop, not a static script.

Send Production Alerts via this MCP Server

Use your agent to send smart notifications, not just blast messages. When a production delay happens, your agent can use `get_customer` to check that specific client's contact preferences and history. This lets the agent decide the best channel for the alert. It'll pick between `send_email_message` for a formal notice or `send_sms_message` for something urgent. That's the point of using an agent—it makes a judgment call based on the data from the MRPLN tools.

Setup guide

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

You create a chain of calls. Start with `get_customer` to fetch their data, then use an LLM to decide the next step, like sending a message with `send_email_message` or updating their record with `update_customer`.

Yes. Your agent can call `get_customer` to check for a phone number or email, then use its logic to invoke either the `send_sms_message` or `send_email_message` tool. It's a classic use case for a ReAct agent.

Use the `get_tactic_performance` tool within a loop that iterates over the output of `list_tactics`. You can then feed the performance data into another part of your chain to make decisions.

Yes, it does. Since you're calling the tools through the LangChain adapter, every `get_customer` or `send_sms_message` call will appear in your LangSmith traces. You get full visibility into the inputs, outputs, and latency for each tool.

The server only processes the customer contact info and message content needed for a specific tool call. Vinkius runs each MCP server session in an ephemeral, zero-trust sandbox. All data is encrypted in transit and nothing is stored after your agent's session ends.

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