competitor · langchain tools

wmcp.sh vs LangChain tools.

LangChain tools are code-side — Python or TypeScript functions decorated with @tool, living inside your agent process. wmcp.sh is runtime-side — an MCP gateway that exposes any public URL or OpenAPI spec as tools your agent fetches over HTTP. They aren't competitors. They stack.

Most teams that adopt both use wmcp.sh for breadth (Stripe, GitHub, Shopify, OpenAPI ingest) and LangChain for orchestration (memory, planning, evaluation).

wmcp.sh is not affiliated with, endorsed by, or sponsored by LangChain, Inc. All comparative claims below are based on LangChain's public documentation.

The shape difference

One sentence each.

LangChain tools

An open-source agent framework where developers define tools as code — Python or TypeScript functions wrapped with the @tool decorator — and orchestrate LLM calls, memory, and multi-step plans (often via LangGraph) inside their own process.

wmcp.sh

A hosted MCP gateway: point it at a public URL, OpenAPI spec, or OAuth-gated upstream and it returns ready-to-call MCP tools. Your LangChain agent (or Claude.ai, Cursor, custom client) consumes those tools over the MCP wire protocol.

How they fit together

Use wmcp.sh tools INSIDE a LangChain agent.

LangChain ships first-party MCP client adapters (langchain-mcp-adapters in Python, @langchain/mcp-adapters in TypeScript). Wire them to wmcp.sh once and your agent gets hundreds of tools.

# Python — pull wmcp.sh tools into a LangGraph ReAct agent
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_anthropic import ChatAnthropic

client = MultiServerMCPClient({
  "stripe": {
    "url": "https://wmcp.sh/mcp/openapi?url=https://raw.githubusercontent.com/stripe/openapi/master/openapi/spec3.json&tag=customers",
    "transport": "streamable_http",
  },
  "shopify": {
    "url": "https://wmcp.sh/mcp/shopify?store=allbirds.com",
    "transport": "streamable_http",
  },
})

tools = await client.get_tools()
agent = create_react_agent(ChatAnthropic(model="claude-sonnet-4-5"), tools)
result = await agent.ainvoke({"messages": ["Find a customer named Acme and list their recent invoices"]})

LangChain handles plan + memory + tracing. wmcp.sh handles tool surface. Each does the part it's good at.

Side-by-side

The capability matrix.

CapabilityLangChain toolswmcp.sh
Layer Code-side agent framework (in-process) Runtime tool gateway (HTTP/MCP)
Tool definition @tool decorator on Python/TS functions you write Auto-generated from URL, OpenAPI spec, or upstream MCP server
Where tools execute In your agent process On wmcp.sh edge (Cloudflare Workers, 300+ POPs)
OpenAPI spec ingest Manual — wrap each endpoint as a tool Automatic — drop in a spec URL, get every endpoint as MCP tools
OAuth-proxy for upstream MCP Bring your own (write OAuth code yourself) wmcp.sh/mcp/<provider> proxies RFC 7591 / PKCE flows
Agent orchestration
memory, planning, tracing, evals		 ✅ Core competency (chains, LangGraph, LangSmith) ❌ Out of scope — use LangChain / LangGraph alongside
MCP-native Via adapter (langchain-mcp-adapters) Native — MCP is the wire format
Language Python, TypeScript Any client that speaks MCP (Claude, Cursor, LangChain, custom)
License (framework) MIT (open-source) MIT (worker + adapters public)
Pricing Framework free; LangSmith / LangGraph Platform paid — see LangChain site 100 reads/day free anonymous; managed setup from $499 one-time

Pricing and feature claims are subject to change. Check each vendor's site for current details.

Where each wins

When pure-LangChain wins. When you should add wmcp.sh.

LangChain alone wins when:

  • Your tools are bespoke business logic in your own codebase (internal DB queries, custom transforms, private microservices)
  • You need rich multi-step orchestration with conditional graphs (LangGraph)
  • You want LangSmith for observability + evaluation in one place
  • You're shipping a closed-loop agent where every tool is hand-written and tested
  • You don't need to call OAuth-gated public APIs or third-party MCP servers

Add wmcp.sh when:

  • You want Stripe's full surface area or GitHub's full surface area as tools without hand-writing each one
  • Your agent needs to act on systems your user doesn't own (shopper-side Shopify, DefiLlama, CoinGecko)
  • You need an OAuth-proxy MCP server (so your agent doesn't drive PKCE flows itself)
  • You want tool execution at the edge instead of in your Python process
  • You want to expose your own LangChain agent as an MCP tool (wrap in HTTP + OpenAPI, feed to wmcp.sh)
Architecture (text)

Where wmcp.sh sits in a LangChain stack.

┌──────────────────────────────────────────────────────────┐
│  Your app / API                                          │
│                                                          │
│  ┌────────────────────────────────────────────────────┐  │
│  │  LangGraph / LangChain agent                       │  │
│  │    • memory, planning, retries, tracing            │  │
│  │    • chooses which tool to call                    │  │
│  └────────────────────────────────────────────────────┘  │
│                       │                                  │
│                       ▼ tool call                        │
│  ┌────────────────────────────────────────────────────┐  │
│  │  langchain-mcp-adapters (MCP client)               │  │
│  └────────────────────────────────────────────────────┘  │
└──────────────────────│───────────────────────────────────┘
                       │ MCP (Streamable HTTP)
                       ▼
┌──────────────────────────────────────────────────────────┐
│  wmcp.sh edge worker (Cloudflare, 300+ POPs)             │
│    • OpenAPI ingest (Stripe, GitHub, your spec)          │
│    • shopper-side adapters (Shopify, etc.)               │
│    • OAuth proxy for upstream MCP servers                │
│    • price-data / oracle adapters                        │
└──────────────────────────────────────────────────────────┘
FAQ

Common questions from people comparing these.

Are LangChain tools and wmcp.sh competitors?
No — they sit at different layers. LangChain is an agent framework (in-process, code-defined tools). wmcp.sh is a runtime gateway (out-of-process, MCP-served tools). The natural pattern is to use wmcp.sh as a tool source inside a LangChain agent.
Do I still need LangChain if I use wmcp.sh?
Yes — if you need orchestration, memory, planning, tracing. wmcp.sh doesn't replace the agent framework; it expands the tool surface.
How do I wire wmcp.sh into a LangChain agent?
Use langchain-mcp-adapters (Python) or @langchain/mcp-adapters (TypeScript). Point at https://wmcp.sh/mcp/openapi?url=... or any other wmcp.sh MCP endpoint, and the adapter pulls tool schemas into LangChain Tool objects.
When does pure LangChain (no wmcp.sh) win?
When tools are bespoke business logic in your own codebase. Wrapping internal-DB queries in @tool functions is faster than putting them behind an MCP gateway. wmcp.sh shines for public surface — partner OpenAPI specs, OAuth-gated MCP servers, shopper-side adapters.
Is everything open source?
LangChain framework: MIT. wmcp.sh worker + adapters: MIT (public repo). LangSmith and LangGraph Platform are LangChain's paid hosted products — see their site for current pricing.
Can wmcp.sh call my LangChain agent?
Yes — wrap your agent behind an HTTP endpoint (FastAPI / Express), publish an OpenAPI spec, feed the spec to wmcp.sh. Now any MCP client (Claude.ai, Cursor, other agents) can call your LangChain agent as a tool.
Is wmcp.sh affiliated with LangChain?
No. wmcp.sh is independent and not affiliated with, endorsed by, or sponsored by LangChain, Inc.
Need this picked / built for you?

We'll wire wmcp.sh into your LangChain stack.

Custom MCP adapter for your APIs + hosted endpoint at mcp.yourbrand.com + LangChain integration tested end-to-end. From $499 one-time setup; Managed Retainer $999/mo; Enterprise $4,999+/mo.

See /managed → Submit (free)