Load the LetSign MCP tools into your LangGraph agent and it drafts the proposal, the pricing options and the contract inside the workflow you already run - then stages everything for your review. Your client opens one link, picks a plan, signs and pays into your own Stripe.
Your graph does the thinking, LetSign does the contracting, Stripe does the collecting. You stay in the loop exactly once - at send time.
No custom integration, no webhooks. One pip install, one client object, one instruction.
Install the adapter package with pip install langchain-mcp-adapters langgraph, then point a MultiServerMCPClient at your LetSign MCP endpoint (get the URL from app.letsign.ai) with the streamable HTTP transport:
from langchain_mcp_adapters.client import MultiServerMCPClient
client = MultiServerMCPClient({
"letsign": {
"url": "YOUR_LETSIGN_MCP_URL",
"transport": "streamable_http",
}
})
tools = await client.get_tools()The LetSign tools load as regular LangChain tools and drop straight into any LangGraph agent, for example create_react_agent(model, tools).
In the LetSign app, connect your own Stripe account once. From then on every payment - one-off, subscription, or save-card-on-file - is collected through your Stripe and lands in your account. LetSign never holds your money.
Bake the sales flow into the agent's system prompt so every run behaves the same way. One proven instruction:
"You are our sales assistant. When a discovery call wraps up, use the LetSign tools to draft a retainer proposal from the call notes: three tiers, the middle tier at the number agreed on the call, with conditional pricing so the client picks a plan. Always stage the proposal for human review. Never send it yourself."
Your agent stages the proposal; nothing sends itself. You read it, tweak anything you like (a discount, net-60 terms, a different tier), and press send. The human send-gate is a feature, not a limitation.
Your client opens one public link, chooses between the plans you offered (conditional pricing built in), verifies their email, signs a binding e-signature and pays through your Stripe - in a single sitting. Remember: the sender never signs. The client does.
Prefer a crew over a graph? The same stack runs in CrewAI and in Goose. Living in the terminal? There is a Claude Code playbook too.
Your agent drafts the whole proposal with up to several plans your client can choose from - three tiers, optional add-ons, the works - straight from call notes or CRM data flowing through your graph.
"Has Meridian signed yet?" Your agent checks proposal status through the MCP tools: opened, plan picked, signed, paid - from any node of your graph, without you opening a dashboard.
Client asks for net-60 or a 10% discount? One instruction, and the agent updates the terms and restages the proposal for your review.
One-off invoices, subscriptions, or save-card-on-file - collected through your own Stripe account at signature time, not weeks later.
And everything the agent does here, you can also do by hand. Every proposal, template and setting is fully editable in the LetSign app - full parity with the MCP. That two-way door is the essence of an agent-native contract: your agent and you work on the same object, and neither is a second-class citizen.
Through the langchain-mcp-adapters package. You create a MultiServerMCPClient with your LetSign endpoint URL and "transport": "streamable_http", call get_tools(), and the LetSign tools load as regular LangChain tools you can pass to any LangGraph agent, including create_react_agent.
A little, and that is the point. LangGraph is a developer framework, so the setup is a pip install and a few lines of Python to load the tools. After that the contract work is prompts and tool calls, and if you ever prefer to work by hand, every proposal and template is fully editable in the LetSign app.
The Free plan is $0 with a 0.20% fee on payments collected through it. The launch plan is $19 per month until October 1, 2026, and that price is locked until October 1, 2028; after launch the standard price is $49 per month. Paid plans pay 0% on payments up to $20,000 per month, then 0.05% above that.
You do. Your LangGraph agent drafts and stages the proposal, but nothing sends itself: a human reviews and presses send. And the sender never signs. Your client opens the link, picks a plan, verifies their email, signs a binding e-signature and pays through your Stripe.
Load the tools, connect Stripe, and let your agent stage the next proposal for your review.
START LETSIGN FREE