MCP Bridge Part 1: Why we built MCP Bridge

A few months ago, we sat down with a customer who wanted to give their internal AI agents access to about 70 APIs. The list looked like this:

- 38 REST services, OpenAPI specs of varying quality

- 9 GraphQL endpoints, two of them federated

- 14 SOAP services owned by a team that hadn't shipped since the merger

- 9 gRPC services inside the service mesh

A normal week of work for a normal enterprise. And a non-starter for every MCP integration path we tried.

The MCP gateway ecosystem in 2026 is genuinely impressive. Kong has shipped its AI MCP Proxy. Azure API Management integrates with Entra ID. Microsoft open-sourced a Kubernetes-native gateway. IBM's ContextForge federates MCP, A2A, and REST behind a single endpoint. Composio and Klavis offer slick hosted experiences. There are good options if your stack matches their assumptions.

The problem we kept hitting is that nobody's stack matches anyone's assumptions. Real enterprise API portfolios have at least three of the four major protocols, written over the span of fifteen years by teams that no longer work at the company. The wrappers and adapters that the existing MCP gateways assume, clean OpenAPI specs, modern auth, well-named operations, are exactly what's missing in the APIs that need exposure the most.

We tried wrapping the SOAP services ourselves. We tried writing custom MCP servers per protocol. We tried hosted gateways and hit the wall where customer security teams asked us to confirm that auth tokens for internal services would never leave the customer's network, and the answer was "no." We tried sticking everything behind an API gateway first and exposing the gateway as MCP, which works, until you realize you've now built two integration layers and the bottleneck has just moved.

So we built MCP Bridge. One layer. Rust core. Self-hosted. It speaks REST, GraphQL, SOAP, and gRPC natively, and turns each operation into an MCP tool that any client, Claude Desktop, Cursor, an in-house agent, can call.

That's the elevator pitch. The reason it took three months to build is the part that matters.

A protocol translator is the easy part. The hard parts are the ones that show up when you actually try to put 100+ tool definitions in front of an LLM. The model's context window fills up before the task starts. Tool selection accuracy drops as the catalog grows. Tool outputs return 30KB of JSON when the model needed three fields. Legacy SOAP operations are named getProcInfo3() and described as "see docs," which makes them invisible to any discovery mechanism. Auth has to work for OAuth2 and the SRP-flavored Cognito flow your legacy app still uses. Rate limiting has to respect six different downstream APIs each with their own quota. None of this is interesting work. All of it is the work.

This week we're shipping the version of MCP Bridge that handles all of it.

We're rolling it out one capability a day:

Tuesday: Code Mode. Three meta-tools replace the entire tool catalog when an API surface gets large. ~98% context window reduction in our benchmarks. We're not the first people to write about this pattern, Cloudflare and Anthropic have both published the idea, but we've built it into the gateway, so you don't have to choose between a slim agent and a comprehensive API surface.

Wednesday: Semantic tool discovery and AI Enrichment. Hybrid Postgres FTS + pgvector index. Optional LLM-driven rewrites for the legacy APIs that ship with bad names. We'll walk through a real SOAP API where this turned discovery accuracy around.

Thursday: Response Post-Processing. Declarative rules or a JS sandbox to shrink tool outputs before they hit the model. 80–95% response size reduction on real integrations. This is the day we go live on Product Hunt, and the feature that pays for the gateway in tokens.

Friday: Production-grade security and reliability. Auth, rate limiting, retries, observability. The boring stuff that determines whether your agent stack stays up at 3am.

If you've ever tried to wire an enterprise API portfolio to an LLM and bounced off the boring parts: context window math, legacy naming, auth, retry storms, this week is for you.

Early access opens Thursday. We'd love your feedback. Ask questions, tell us what breaks. That's what this week is for.