How to Use the DottedSign MCP in LangChain

Q: Can a LangChain agent automatically select templates from DottedSign?

Yes, by using listtemplates. The LangChain agent inspects the available templates, matches the user's intent to the correct ID, and then executes createtaskfromtemplate in the next link of the chain.

Q: Can I use LangChain to manage webhooks with this MCP Server?

You can query your active webhooks using listwebhooks. This allows your agent to confirm that your external event listeners are properly configured to receive real-time updates when tasks change.

Run multi-step document workflows where your LangChain agents trigger and track DottedSign tasks dynamically.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect DottedSign MCP to LangChain

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

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Chain document signing with LangChain

The DottedSign MCP Server connects your LangChain agents directly to your document pipelines. By exposing these tools to your chain, your agent can inspect incoming files, decide which template fits, and trigger `create_task_from_template` without human intervention. The output of this signing request feeds directly into your next chain link. If a signer delays, your agent checks the status using `retrieve_task`. It then decides whether to ping them or execute `cancel_task` to clean up the queue. You get full observability over this entire sequence through LangSmith, tracking every tool input and latency spike.

Track legal compliance in your chains

This MCP Server delivers raw legal compliance data directly to your LangChain validation chains. Your agent fetches the raw signing history using `get_audit_trail` and passes it directly to a validation node. This setup ensures that every signature is verified and logged automatically. You do not need to guess if the agent is making the right calls. LangSmith logs the exact payload of `get_audit_trail` alongside your LLM prompts. This gives your legal engineering team a clear, step-by-step record of how each document reached completion.

Manage active signing queues dynamically

The DottedSign MCP Server lets your LangChain agents monitor active signing queues dynamically. Instead of writing brittle cron jobs to monitor your contracts, you can run periodic loops calling `list_tasks` to check on outstanding signatures. Based on the returned payload, the agent updates internal databases or alerts your sales team. If a contract needs a quick update before signing, the agent calls `update_task` to keep the details accurate. This keeps your document pipeline moving without manual dashboard work, all managed within a single, stateful LangChain session.

Setup guide

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

Vinkius manages the auth handshake for you, so you only need one endpoint token. You pass this token to the MultiServerMCPClient setup, which then exposes tools like `get_me` to your LangChain agents.

Yes, by using `list_templates`. The LangChain agent inspects the available templates, matches the user's intent to the correct ID, and then executes `create_task_from_template` in the next link of the chain.

Use LangSmith tracing to inspect the exact inputs and outputs of your MCP tools. If a call to `create_task` fails, LangSmith shows the raw API error payload, making it easy to fix schema mismatches in your agent's reasoning loop.

You can query your active webhooks using `list_webhooks`. This allows your agent to confirm that your external event listeners are properly configured to receive real-time updates when tasks change.

Your audit logs and signature tasks are processed inside Vinkius's zero-trust, ephemeral V8 isolates. The server never stores your document payloads or signer details, ensuring that sensitive legal records remain strictly between your agent and the secure API.

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