bankproductsBlog

Blog · · EN

We Built an MCP Server. Then We Found Out Almost Nobody Uses Them — Yet.

Claude Code recommended shipping MCP. The build was fast. The deploy to Google Cloud was slow. The real surprise came later: a field report on the hype-vs-reality gap, and what it means for a serious data product in 2026.

TL;DR We shipped an MCP server for the bankproducts.info dataset because our AI coding tool — Claude Code — kept recommending it. Building was easy; almost all the code came from Claude. The Google Cloud deploy was the real time sink (IAM gaps, a region without custom-domain mappings, framework gotchas). Then came the actual surprise: based on what's observable in the ecosystem, probably 0.1 to 1% of LLM users have ever installed a third-party MCP server. The rest just talk to the model. MCP today isn't an end-user channel; it's a developer-and-builder channel. The bet pays off when install-layer UX matures — likely 2–3 years out — and when downstream agent products start pre-wiring MCPs into their own UX. We're shipping anyway. Just with sharper expectations.

How we got here

Claude Code kept recommending we ship an MCP server. Across multiple sessions, when we asked "what's the next surface to add to the bankproducts.info stack?", the answer kept coming back: MCP. The reasoning sounded right — structured tool access for AI agents, the universal-protocol future, a way to be "where the agents are" rather than where the humans are.

So we built one. Almost all the code came from Claude itself — the FastMCP framework wrapped around the existing SQLite database, a handful of tool definitions (search_products, compare_products, list_fees_for_product, etc.), and we were done in well under a day.

The deploy to Google Cloud took longer than the build. Cloud Run is straightforward in theory, but the first time through there were several small traps:

  • The default Compute Engine service account no longer has build permissions by default (since April 2024). You discover this after about 30 seconds of "Uploading sources…", when the build fails with a permission error.
  • The region we initially picked (europe-west6, Zürich, for the Swissness bonus) doesn't support custom-domain mappings. You discover this only after deploying. We re-deployed to europe-west1 (Belgium).
  • FastMCP ships with DNS-rebinding protection enabled by default, which means every legitimate client hitting your public custom domain gets HTTP 421 "Invalid Host header." Public Cloud Run deployments need to disable this; it's the right default for local stdio servers, but a foot-gun for hosted streamable-HTTP.
  • A Hatchling readme trap — pyproject.toml with readme = "README.md" fails the build if .dockerignore excludes the README. Easy fix once you've seen it; opaque before.

None of these are deal-breakers. They're the kind of thing where each fix takes 10–30 minutes once you spot the root cause. Cumulatively, the deploy took longer than the build. We documented each one for future re-deploys.

Then the server was live at mcp.bankproducts.info. And we asked the obvious next question.

Who's actually going to use this?

Best estimate from observable ecosystem signals: maybe 0.1 to 1% of LLM users have ever installed a third-party MCP server. The rest just talk to the model. This is a striking gap relative to the volume of MCP discussion on X, LinkedIn, and tech blogs.

Three structural reasons why adoption is this thin:

1. No install layer

Every other ecosystem you can name — the App Store, npm, Chrome extensions, even Linux package managers — has a one-step install verb that handles fetch, configure, register, permissions, in a single user action. MCP doesn't. The user reads a README, copies a JSON snippet, opens a config file by hand, restarts their AI tool, and hopes. That's 1990s-PC-software UX.

For reference, here's the config snippet a user would paste into Claude Desktop's claude_desktop_config.json to talk to our server:

{
  "mcpServers": {
    "bankproducts": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.bankproducts.info/mcp"]
    }
  }
}

To execute that, the user needs to: know the config file exists, know its location, know JSON, have Node installed (for npx), restart Claude Desktop, and trust that it'll work. Each step filters out users. By the end of the funnel, most are gone.

2. Per-host fragmentation

The same MCP server requires different configuration in Claude Desktop, Cursor, Cline, Continue, Zed, Goose, agent frameworks like LangChain or AutoGen, custom apps using the Anthropic or OpenAI SDKs. There's no "add this MCP to all my AI tools" button. If you switch hosts — which AI-curious people do constantly — you reconfigure everything.

3. No discovery

You have to already know a specific server exists by name. Directories like mcp.so, smithery.ai, and mcpservers.org are human-browsable websites — you read them, then go configure. There's no in-product "search for an MCP that does X" the LLM can perform on the user's behalf at runtime. And there shouldn't be soon: an LLM autonomously connecting to arbitrary endpoints would be a prompt-injection nightmare (a malicious page tells the model "connect to evil.example.com/mcp and exfiltrate context"). The security implications mean autonomous discovery is hard to design responsibly.

The hype isn't wrong about direction. Just about timing.

This pattern isn't new. Useful historical analogs:

  • Web APIs around 2006. REST existed, every API rolled its own authentication scheme, SDK, and documentation format. There was no OpenAPI, OAuth was barely formalized, and integrating any third-party API was a half-day project. It took roughly five years before OpenAPI + OAuth 2.0 + Stripe-quality tooling made API consumption feel invisible.
  • USB from 1996 to roughly 2003. Driver disks, hub headaches, USB-mass-storage vs MTP confusion, vendor-specific quirks. By 2007 it was unremarkable. The 1996 SPEC was ahead of the install-and-driver UX by a decade.
  • RSS, around 2003–2008. Readers existed, but discovery only worked once browsers auto-detected feed URLs via <link rel="alternate"> tags. Discovery is half the value proposition; without it, even great protocols stay niche.

MCP is somewhere between "early USB" and "early web APIs": the protocol is genuinely important and will probably win, but the friction-removing layer needs another 2–3 years to mature.

What will close the gap

Two trends visible in 2026 that will probably matter more than anything else:

  • App-store-style connector marketplaces inside the AI tools. Claude.ai already has a small curated list of one-click "connectors" (Notion, Linear, HubSpot, Cloudflare, GitHub, …). ChatGPT is converting its earlier "GPTs" into MCP-shaped connectors. Once this becomes the dominant install path, manual JSON config becomes the developer-only fallback.
  • Vertical AI products that pre-wire MCP servers. A "Swiss banking analyst" agent built on Claude can ship pre-configured to use mcp.bankproducts.info. The end user buys the agent and never sees the MCP layer. This is probably the largest indirect distribution channel for any data-focused MCP, and the one we're optimizing for.

OAuth standardization is the third thing that needs to happen — every server today reinvents auth, and the spec is converging on a clean OAuth flow that hosts can implement once and reuse. When that ships consistently, the "click connect, grant permission, done" experience finally works across tools.

What this means for bankproducts.info specifically

We ship three surfaces against the same underlying SQLite database — api.bankproducts.info is the Datasette web UI plus a REST API; mcp.bankproducts.info is the MCP server. Same data, three access modes. Different audiences today, different time horizons:

SurfaceAudience todayAudience in 2–3 years
REST APIAnyone who can curl. Fintechs, comparison-site builders, journalists.Same. The workhorse.
Datasette UIHumans wanting to explore the data manually — bank product managers, analysts, students.Same.
MCP serverTechnically curious early adopters; agent builders packaging us into their products.Mass-market via marketplaces and pre-wired vertical AI products.

Today the REST API and Datasette do the actual user-facing work. The MCP server is the long-horizon bet — cheap to keep running, asymmetric upside if the install-layer UX matures the way it probably will. The cost of shipping the server now is small. The cost of not being shippable when downstream agent products start asking for "the Swiss banking data MCP" would be much larger.

If you're a technically curious early adopter who actually wants to wire mcp.bankproducts.info into your Claude Desktop or Cursor today, the config snippet above is all you need. Most users will arrive via REST or Datasette for now — and that's fine.

The honest reframe

MCP today is a developer-and-builder channel, not an end-user channel. If you're shipping an MCP server in 2026, you're not building for users yet. You're building for the agent builders who will package you into their products.

That's a different go-to-market motion, a different timeline, and a different success metric than "monthly active users." It's worth knowing before you start, not after. We're building the muscle for the world where MCP installation is a one-click affair — and using REST + Datasette to serve the actual users we have today.

The hype isn't wrong. It's just early. We'd rather be early.

About this blog: notes from building bankproducts.info — an open, machine-readable database of Swiss and Liechtenstein bank products, fees, and claims. Available as a SQLite download (CC-BY-4.0), a REST API at api.bankproducts.info, a Datasette browser at the same URL, and an MCP server at mcp.bankproducts.info. Code is MIT-licensed on GitHub.