[2026] ChatGPT MCP Calls Up 98x: Agent Tooling (Analysis)

MCP tool calls from ChatGPT users are up 98x across 2026, doubling in August alone, and LangChain answered with langchain.mcp: MCP support in the main package on FastMCP, elicitation via LangGraph interrupts, client-side catalog cache. I upgraded our Junagadh gateway in an afternoon — P95 780ms, 78% calls stay local.

Author: Deepak Bagada — AI Developer & Architect, Junagadh, Gujarat, India — Founder SaaS Next, builder of Curro. Connect linkedin.com/in/deepak-bagada · deepakbagada.in — Last reviewed 2026-09-17.

I run AI Development & Autonomous Agents where langchain.mcp is now the default adapter. Client work ships through Business Workflow Automation, the storefronts are Website Development & Laravel Architecture, and adapter audits start at get in touch.

The 98x number and what it forces

Two statistics from September 2026 reset every assumption about agent tooling. First, per LangChain's September 3 blog, MCP tool calls from ChatGPT users are up 98x across 2026, more than doubling in August alone. Second, per the official MCP blog, Tier 1 SDKs now pull close to half-a-billion downloads a month, with TypeScript and Python each crossing a billion total. Tool calling is no longer a feature — it is the workload. Every agent run starts by discovering what tools exist, which means a catalog round trip before the model sees anything, at planetary scale.

LangChain's response, shipped September 2026, moves MCP support into the main package as langchain.mcp (install with the mcp extra, Python first with langchain[mcp]>=1.4.0, TypeScript to follow) instead of the separate langchain-mcp-adapters install. It is built on FastMCP underneath — transports, auth, connection management and protocol negotiation come from the client layer, so servers on the old and new spec both work through per-connection negotiation. MultiServerMCPClient collapses into a single MCPAdapter class. The tools it returns are ordinary LangChain tools, so they drop into create_deep_agent, create_agent, or a hand-wired graph unchanged.

Two capabilities in the release map directly onto the 2026-07-28 spec. Elicitation — a tool pausing to ask the caller something, like confirming a delete — arrives via the interrupt primitive: the stateless spec turned mid-call elicitation into a retryable round, and LangChain surfaces it as a LangGraph interrupt where the run pauses, a human answers, and it resumes. Client-side caching arrives via the spec's ttlMs/cacheScope hints: with cache=True, the tool catalog serves from memory instead of re-fetching every run.

War story: the adapter migration that renamed every tool

Our gateway served 58 tools through the old langchain-mcp-adapters package with bare tool names. The afternoon I moved to langchain.mcp, 11 tools broke — not from the import change, which the migration guide maps cleanly, but from namespacing. The new adapter prefixes tool names with their server (billing_search, docs_search), so every prompt, every OPA policy and every ledger query referencing search silently matched nothing. No errors. Just an agent that forgot how to search the docs.

The fix was mechanical but the lesson was not: OPA policies must reference namespaced tool IDs, prompts must name the prefixed tool, and the 90-day ledger must record the server prefix in every span. I now treat tool names as versioned API surface — the adapter owns the prefix, I own the mapping table, and a CI check fails the build when a referenced tool has no mapping. Total migration cost: one afternoon, 11 renamed references, zero production impact because the ledger diff caught the renames before deploy. A metro agency would have called that a two-week "framework upgrade project" at ₹3L. It was an afternoon and a mapping file.

Second war story, about money. Before client-side caching, every agent run on our Rajkot RFQ inbox re-fetched the 58-tool catalog: ~4KB of JSON per run, 18K runs a week, roughly 72MB of pure overhead weekly — small in bytes, real in tokens once the model re-reads tool descriptions each run. With cache=True respecting server ttlMs, catalog fetches dropped 94%. Weekly token spend on the inbox fell 31%, about ₹4.6K/month at our volume, and P95 run latency dropped from 1.1s to 780ms because the first round trip vanished. The cache belongs to the client — one client per caller, so catalogs never cross tenants — and that single sentence in the docs prevented a data-leak class of bug before it existed.

Code: adapter, interrupts and cache

# langchain.mcp — MCPAdapter with elicitation interrupts + catalog cache
from langchain.mcp import MCPAdapter
from langgraph.prebuilt import create_deep_agent

adapter = MCPAdapter(
    {"billing": "https://mcp.junagadh-lab.in/billing",
     "docs": "https://mcp.junagadh-lab.in/docs"},
    cache=True,  # respects server ttlMs/cacheScope — catalog served from memory
)
tools = await adapter.tools()  # namespaced: billing_search, docs_search, ...

agent = create_deep_agent(model="omniroute-45k", tools=tools)

async for chunk in agent.astream({"messages": ["refund order #4812"]}):
    if interrupt := chunk.get("__interrupt__"):  # elicitation: tool asks back
        answer = await human_review(interrupt)    # approve / decline / supply arg
        chunk = await agent.ainvoke(Command(resume=answer))

// OPA policy MUST reference namespaced tool IDs after migration
async function opaAllow(tenant: string, tool: string, amount = 0) {
  const namespaced = tool.includes("_") ? tool : `billing_${tool}`; // mapping table
  if (amount > 15000 && namespaced.endsWith("create_link")) return "hitl";
  return policy.check({ tenant_id: tenant, tool: namespaced });
}

The elicitation flow deserves attention: declining a question, supplying a missing parameter, confirming a delete — all arrive as interrupts, all resume with full context, none hold a connection open. That is MRTR at the framework layer, and it is why our approval HITL cards survived the migration untouched.

When NOT to switch to langchain.mcp

If your agent uses one model, one toolset and OpenAI function calling directly, the adapter buys you nothing — a direct client is fewer layers and fewer renames. If your tool catalog mutates every minute (live inventory with per-second price changes), set cache=False or shrink TTLs; a cached catalog serving stale prices will misquote customers the way our empty-catalog bug mis-synced SKUs. And the namespace is beta — langchain[mcp]>=1.4.0 may still change API shape, so pin the version and read the migration guide on every bump, exactly as the Tasks migration taught us.

What the 98x means for Gujarat builders

Demand of that shape means two things. First, catalog efficiency is now a cost center — at 98x growth, re-fetching tool lists every run is a budget line, and cache=True is the cheapest optimization you will ship this year. Second, dual-era negotiation (new protocol first, handshake fallback) means your gateway serves both 2025 and 2026 clients during transition with zero code branches — FastMCP handles it per connection. Our Junagadh gateway serves a Surat D2C, a Rajkot foundry and a Mumbai SaaS from one ₹6K VPS through this exact setup: 78% of calls stay local on a 14B at 44 tokens per second, 22% route to cloud via the OmniRoute gateway, and the 90-day ledger proves every one.

Frequently Asked Questions

What is langchain.mcp in the September 2026 LangChain release?

langchain.mcp moves MCP support into the main LangChain package on FastMCP, replacing langchain-mcp-adapters with a single MCPAdapter class, plus elicitation via LangGraph interrupts and client-side catalog caching. Tools are ordinary LangChain tools, namespaced per server, working with create_deep_agent, create_agent or custom graphs.

How does elicitation via interrupts work for human-in-the-loop?

A tool that cannot finish without asking the caller something pauses the run as an interrupt; a reviewer answers, declines or supplies the argument, and the run resumes with full context. The stateless spec made elicitation a retryable round instead of a held-open stream, so approvals survive power cuts and instance loss.

How much does catalog caching save in production in 2026?

Our Rajkot inbox cut catalog fetches 94%, weekly token spend 31% (~₹4.6K/month), and P95 run latency 1.1s to 780ms with cache=True. At 98x industry call growth, the catalog round trip is a budget line — cache it with one client per caller so tenants never cross.

Can a Gujarat SME adopt langchain.mcp without a metro agency in 2026?

Yes — our two-person Junagadh lab migrated 58 tools in one afternoon: import swap per the migration guide, a namespaced tool-mapping table, OPA policy updates and a ledger diff before deploy. Pin langchain[mcp]>=1.4.0, keep the mapping table in CI, and the risk window is an afternoon, not a project.

Bottom Line: At 98x call growth, the adapter is the cost control — namespaced tools, interrupt elicitation and a cached catalog in one afternoon's migration. Map the renames, pin the version, cache the catalog, and let the ledger prove it.

From Junagadh — where 58 tools migrated in an afternoon and the ledger caught every rename.