--- title: "MCP Gateway vs. Single MCP Server: When Do You Need One?" url: "https://atlan.com/know/ai-agent/mcp-gateway-vs-single-mcp-server/" description: "MCP gateway vs. single MCP server: the spec-grounded thresholds for team count, tool count, and compliance that tell you when a gateway earns its overhead." author: "Emily Winks" author_role: "Data Governance Expert" published: "2026-09-25" updated: "2026-09-25T00:00:00.000Z" --- --- A single MCP server, one client connecting directly to one server, is what [the protocol itself defines by default](https://modelcontextprotocol.io/docs/learn/architecture) (modelcontextprotocol.io, 2026), and it stays enough for most teams longer than "when do you need a gateway" content on the topic tends to suggest. The threshold isn't a feeling. According to the spec's own [Client Best Practices page](https://modelcontextprotocol.io/docs/develop/clients/client-best-practices) (modelcontextprotocol.io, 2026), a host connecting to dozens or thousands of tools can see tool definitions alone consume the majority of the context window before the model reads the user's message, and the spec recommends switching to progressive tool discovery once those definitions cross roughly 1-5% of that budget. Among the pages ranking for "MCP gateway vs. single MCP server," none ground the "when" in that number, or in the spec's guidance at all; most assert the need for a gateway as received wisdom. Grounding the decision in what the protocol's own documentation already says, alongside real gateway implementations and the honest counter-argument that a gateway augments governance rather than replacing it, gets closer to an answer a reader can actually apply. ### Do You Need an MCP Gateway Give it your server count, client count, and who owns them. It returns whether a gateway is warranted and which pattern fits. [Read the skill](/skills/mcp-gateway-need-check.md). *Paste into a new chat* ``` Use the skill at https://atlan.com/skills/mcp-gateway-need-check.md to work out whether we need an MCP gateway and which pattern fits. Ask me for whatever it needs. ``` *Run once in a terminal* ``` curl -fsSL --create-dirs \ -o ~/.agents/skills/mcp-gateway-need-check/SKILL.md \ https://atlan.com/skills/mcp-gateway-need-check.md ``` *For an agent* ``` curl -fsSL https://atlan.com/skills/mcp-gateway-need-check.md ``` Human Agent ClaudeChatGPTGeminiCursorOther Copy .skp{margin:1.75rem 0;padding:1rem 1.125rem 1.125rem} .skp h3{margin:0 0 .375rem!important;font-size:20px!important;line-height:24px!important; font-family:var(--font-funnel-display)!important;font-weight:600!important;color:#2B2B39!important} .skp > p{margin:0 0 .875rem!important;font-size:14px!important;line-height:22px!important;color:#555572!important} .skp > p a{color:#2026D2;text-decoration:underline} .skp-box{margin-bottom:.75rem} .skp-p em{display:block;font-size:10px;font-weight:700;letter-spacing:.06em;text-transform:uppercase; color:#F34D77;font-style:normal;margin-bottom:.25rem} .skp-p > p{margin:0!important} #seo-layout article .skp .skp-p pre{margin:0!important;overflow-x:auto} #seo-layout article .skp .skp-p pre code{color:#2B2B39!important;font-size:12px!important;line-height:19px; white-space:pre-wrap;overflow-wrap:anywhere;background:none;padding:0; font-family:ui-monospace,SFMono-Regular,Menlo,monospace} .skp-p + .skp-p{margin-top:.625rem} .skp-cs{display:flex;flex-wrap:wrap;align-items:center;gap:.375rem} .skp-seg{display:inline-flex;flex:0 0 auto;border:1px solid #DDDDE3;border-radius:999px;overflow:hidden;background:#fff} .skp-m{min-height:32px;padding:.25rem .75rem;border:0;background:transparent;font-family:inherit;color:#77778E;cursor:pointer} .skp-m:hover{color:#2026D2} .skp-m.on{background:#2026D2;color:#fff} .skp-sep{flex:0 0 auto;width:1px;height:20px;background:#DDDDE3;margin:0 .25rem} .skp-tools{display:inline-flex;flex-wrap:wrap;gap:.375rem;min-width:0} .skp-cp{margin-left:auto;min-height:32px;padding:.25rem .75rem;border-radius:999px;background:#fff; font-family:inherit;color:#555572;cursor:pointer} .skp-cp:hover{border-color:#2026D2!important;color:#2026D2} .skp-cs .skp-c{display:inline-flex!important;width:auto;flex:0 0 auto;align-items:center;gap:.375rem; min-height:32px;padding:.25rem .625rem;border-radius:999px;background:#fff;font-family:inherit; color:#555572;cursor:pointer} .skp-cs .skp-c img{display:block!important;width:14px!important;height:14px!important; max-width:14px!important;flex:0 0 auto;opacity:.55;margin:0} .skp-c:hover img,.skp-c.on img{opacity:1} .skp-cs .skp-c:hover{border-color:#797DE4!important;color:#2026D2} .skp-cs .skp-c.on{border-color:#2026D2!important;background:#F4F4FD;color:#2026D2} .skp-agent .skp-tools,.skp-agent .skp-sep{display:none} (function(){ var p=document.querySelector('.skp[data-skill="mcp-gateway-need-check"]');if(!p)return; var panes=p.querySelectorAll('.skp-p'); function show(id){panes.forEach(function(x){x.hidden=x.dataset.skp!==id;});} function cur(){var a=p.querySelector('.skp-p:not([hidden]) pre code');return a?a.textContent:'';} show('prompt'); p.querySelectorAll('.skp-p em').forEach(function(e){ var par=e.parentElement; ((par.tagName==='P'&&par.textContent.trim()===e.textContent.trim())?par:e).hidden=true; }); p.querySelectorAll('.skp-c').forEach(function(b){ b.addEventListener('click',function(){ p.querySelectorAll('.skp-c').forEach(function(x){var on=x===b;x.classList.toggle('on',on);x.setAttribute('aria-pressed',on);}); show(b.dataset.skp); }); }); p.querySelectorAll('.skp-m').forEach(function(m){ m.addEventListener('click',function(){ var agent=m.dataset.skpMode==='agent'; p.classList.toggle('skp-agent',agent); p.querySelectorAll('.skp-m').forEach(function(x){var on=x===m;x.classList.toggle('on',on);x.setAttribute('aria-pressed',on);}); if(agent){show('agent');}else{var s=p.querySelector('.skp-c.on');show(s?s.dataset.skp:'prompt');} }); }); var c=p.querySelector('[data-skp-copy]'); c.addEventListener('click',function(){ navigator.clipboard.writeText(cur()).then(function(){ c.textContent='Copied';setTimeout(function(){c.textContent='Copy';},1600); }); }); })(); --- | Dimension | Single MCP server | MCP gateway | |---|---|---| | What it is | One server, one client connection, one scope of tools | A layer in front of multiple MCP servers | | What it does | Exposes a defined set of tools and resources directly | Routes, authenticates, and audits calls across many servers | | Who typically owns it | The team that built or connected the tool | Platform, infrastructure, or security team | | Auth model | The server enforces its own auth per the spec's design | Centralized policy, still depends on backend enforcement | | Typical adoption trigger | 1-3 tools, one team, local or dev use | Multiple teams, compliance need, tool-count pressure | | Failure mode if skipped | Not applicable, this is the default starting point | No single audit trail, namespace collisions, inconsistent policy | | Ops overhead | Low, a direct connection | Higher, an additional component to run, secure, and observe | | Discovery | Client connects to a known server directly | [Official MCP Registry](https://registry.modelcontextprotocol.io/) can sit alongside it as the discovery layer | --- ## MCP gateway vs. single MCP server: what's the difference? A single MCP server is what [the MCP spec defines as the default relationship](https://modelcontextprotocol.io/docs/learn/architecture) (modelcontextprotocol.io, 2026): one client, one server, a direct connection where the server exposes its own tools and resources and enforces its own permissions. A gateway is not a spec-defined role at all. It's an operational pattern that sits in front of multiple servers to centralize routing, authentication, rate limiting, and audit, and it is distinct from a plain proxy. A [detailed practitioner writeup on r/mcp](https://www.reddit.com/r/mcp/comments/1uye015/mcp_proxy_server_vs_mcp_gateway_we_spent_a_week/) (Reddit, 2026) draws the line precisely: "A proxy server typically forwards traffic... it lacks awareness of who is making the requests or what permissions they have," while a gateway "operates at a higher level," applying access control, rate limiting, usage tracking, and audit logging on top of the traffic it forwards. The boundary is worth holding onto whenever a reader compares [MCP against function calling](https://atlan.com/know/mcp-vs-function-calling/) too, since the same "who's actually enforcing this" question resurfaces there. ### Gateway vs. proxy, not the same thing The distinction matters because vendors use both terms loosely. A proxy relays a call from point A to point B without inspecting who sent it or what they're allowed to do. A gateway inspects each call, applies identity- and task-aware policy, and records what every agent did, the difference between a hop and a control point. ### Why the spec never defines a "gateway" role The protocol's silence here is deliberate, not an oversight. MCP standardizes the client-host-server relationship and leaves everything above that, how an organization manages dozens of those relationships at once, to the ecosystem. That's exactly why gateway implementations diverge in scope and opinion: nothing in the spec constrains what one has to do. The distinction that matters for a reader deciding between architectures is not vendor feature lists. It's whether the operational pattern being added solves a problem that already exists, team count, audit requirements, or context-window pressure, or whether it's complexity borrowed against a scale not yet reached. --- ## How do a single MCP server and an MCP gateway actually work? Both patterns build on the same base protocol; they differ in how many of those connections exist and who manages them. A single server handles one relationship end to end. A gateway multiplies that relationship and adds a management layer on top of the multiplication. ### A single MCP server A single MCP server is a direct, [1:1 client-to-server connection](https://modelcontextprotocol.io/docs/learn/architecture) (modelcontextprotocol.io, 2026) that exposes its own tools and resources and enforces its own permissions on every call. There's no intermediary; the client connects, discovers what the server offers, and calls it directly, the mechanism [MCP architecture deep dive](https://atlan.com/know/ai-agent/mcp-architecture-deep-dive/) covers in full. [Atlan's MCP server for Salesforce](https://atlan.com/know/ai-agent/mcp-server-for-salesforce/) is a concrete production example: one governed server, one defined scope of tools, no gateway required. Teams building their own can start from [how to build MCP servers for enterprise data](https://atlan.com/know/ai-agent/how-to-build-mcp-servers-for-enterprise-data/); teams still deciding whether MCP is the right integration path should read [when to use MCP vs. API](https://atlan.com/know/when-to-use-mcp-vs-api/) first. ### An MCP gateway A gateway aggregates multiple servers behind one endpoint, applies identity- and task-aware policy to each call, and produces a single audit trail across all of them. [Docker's MCP Gateway documentation](https://docs.docker.com/ai/mcp-gateway/) (docs.docker.com, 2026) frames the single-server pain point directly: "MCP servers are just programs that need to run somewhere. Running them directly on your machine means dealing with installation, dependencies, updates, and security risks." [IBM's ContextForge](https://github.com/IBM/mcp-context-forge) (GitHub, IBM, 2026) is a real, named implementation, describing itself as "an open source registry and proxy that federates tools, agents, and APIs into one clean endpoint for your AI clients," with JWT and OAuth auth, rate limiting, and multi-cluster Kubernetes federation built in. A gateway doesn't change what MCP is; it changes who's responsible for managing many instances of it at once, the tradeoff the next two sections weigh. The same tradeoff shows up one layer up the stack in [agent skills vs. MCP](https://atlan.com/know/ai-agent/ai-agent-skills/agent-skills-vs-mcp/) and [MCP vs. OpenAI function calling](https://atlan.com/know/ai-agent/mcp-vs-openai-function-calling-design-philosophy/): more moving parts buy more control, and the question is always whether the scale justifies it yet. --- ## When is a single MCP server enough? A direct connection stays the right call under a specific, recognizable set of conditions: one team or client, a handful of tools, no cross-team audit requirement, and a local or single-environment deployment. The spec's own [Client Best Practices page](https://modelcontextprotocol.io/docs/develop/clients/client-best-practices) (modelcontextprotocol.io, 2026) describes "dynamic server management," connecting to a server only when needed and disconnecting when it isn't, as the closest thing the protocol offers to guidance on when a direct connection stops being sufficient. Below that threshold, client-side connection management covers what a single team actually needs; it doesn't do a gateway's cross-team audit or centralized-policy job, but nothing at this scale is asking it to. Picture a small data team wiring one internal agent directly to one governed MCP server for a single system: no second team touching it, no external audit requirement, no tool-count pressure. Adding a gateway here buys nothing. It adds a component to run, secure, and monitor in exchange for governance the team doesn't yet need, complexity borrowed against a problem that hasn't arrived. A single governed MCP server, like Atlan's hosted Remote MCP server delivering [governed business context](https://atlan.com/know/mcp-delivers-business-context/) directly to the agent, is a complete answer at this scale on its own. What that server hands back still has to be trustworthy, which is why [data quality for AI agent harnesses](https://atlan.com/know/data-quality-ai-agent-harnesses/) matters just as much at one server as it will at fifty. Teams that reach for a gateway before crossing any of these thresholds usually end up maintaining infrastructure instead of shipping the agent it was meant to support. --- ## When do you need an MCP gateway? Three convergent signals, not one, tell you a gateway has started earning its complexity: context-window pressure from tool count, multiple teams sharing the same servers, and a compliance or audit requirement no single server can satisfy alone. According to [the spec's Client Best Practices page](https://modelcontextprotocol.io/docs/develop/clients/client-best-practices) (modelcontextprotocol.io, 2026), the trigger for progressive tool discovery is tool definitions consuming roughly 1-5% of the available context window, the same pressure that makes centralizing many servers behind one discovery point worth the overhead. The protocol's [2026-07-28 revision moved MCP's core to a stateless design](https://modelcontextprotocol.io/docs/learn/architecture) (modelcontextprotocol.io, 2026): any request can land on any server instance behind a standard load balancer. That change doesn't create the need for a gateway on its own, but it removes a real obstacle to running one, without it, a gateway aggregating stateful servers would need sticky sessions or its own workarounds to avoid breaking connections mid-task. Community evidence converges on the same triggers. The r/mcp writeup cited above states a gateway becomes important once "multiple teams are interacting with the same servers," the system is "customer-facing or regulated," or the team needs a record of "every instance this tool was accessed and by whom." A separate [r/mcp thread on production gateway choices](https://www.reddit.com/r/mcp/comments/1u12f3w/) (Reddit, 2026) shows governance requirements typically surfacing only after a security review, the same moment [AI agent governance](https://atlan.com/know/ai-agent-governance/) programs usually get funded. Tool-name collisions show up repeatedly too: an [HN discussion of a zero-trust MCP gateway](https://news.ycombinator.com/item?id=47704652) (Hacker News, 2026) describes aggregating backends into "a single connection with a unified, namespaced tool registry," solving the problem of two servers both exposing a tool called `search` with no way to tell them apart. The registry itself is a distinct decision from the gateway; see [agent registry vs. MCP registry](https://atlan.com/know/ai-agent/agent-registry-vs-mcp-registry/) for the catalog-versus-protocol boundary, and [MCP connected data catalog](https://atlan.com/know/mcp-connected-data-catalog/) for how governance decides what an agent is allowed to see once it's routed there. | Dimension | Single MCP server | MCP gateway | |---|---|---| | Server count | One | Many, aggregated behind one endpoint | | Team or client count | One | Multiple, sharing infrastructure | | Auth complexity | Server-level only | Centralized policy layered on server-level auth | | Compliance or audit need | Minimal or none | A single audit trail across every call | | Tool-count or context-window pressure | Low, well under the spec's 1-5% threshold | High, tool definitions crowding the budget | | Namespace collisions | Not applicable at one server | Real risk without a unified, namespaced registry | | Deployment model | Local or single environment | Multi-environment, often multi-cluster, often [event-driven](https://atlan.com/know/event-driven-architecture-for-ai-agents/) | | Real implementations | A direct connection to a governed server | [IBM ContextForge](https://github.com/IBM/mcp-context-forge), [Docker MCP Gateway](https://docs.docker.com/ai/mcp-gateway/) | The same pressures show up wherever [multiple agents need to coordinate](https://atlan.com/know/multi-agent-coordination-patterns/) at all. None of this argues for adding a gateway preemptively, only for recognizing the specific, spec-grounded point where its overhead starts costing less than the risk of doing without one. --- ## Does an MCP gateway replace server-level security? No, and the strongest evidence against that assumption comes from inside the MCP community itself. An [HN discussion titled "MCP was always a bad idea?"](https://news.ycombinator.com/item?id=49779329) (Hacker News, 2026) makes the case directly: relying on an intermediary for access control is dangerous if the backend service doesn't enforce its own permissions, since a gateway in front of an unsecured server can create a false sense of security rather than remove the risk. A related thread, ["Damn Vulnerable MCP Server"](https://news.ycombinator.com/item?id=43707021) (Hacker News, 2026), notes the spec expects servers to run in environments implicitly trusted for any client that can reach them, and compares a gateway's rate-limiting and auth to what an API gateway already does elsewhere: useful, not a substitute for the backend enforcing its own authorization. The same trust boundary is what makes [prompt injection attacks on AI agents](https://atlan.com/know/prompt-injection-attacks-ai-agents/) dangerous behind a gateway that checks identity but not intent. Treat a gateway as additive governance layered on top of servers that must still secure themselves, never as a replacement decision. A compliance team that adds a gateway and stops there, without auditing what each backend server actually permits, has added a management layer, not security. Broader [AI agent risks and guardrails](https://atlan.com/know/ai-agent-risks-guardrails/) apply at every layer of this stack, not only the routing layer a gateway sits on. --- ## How do a gateway and single servers work together? A gateway doesn't eliminate the need to reason about each server behind it; it sits in front of servers that keep their own responsibilities, adding coordination, not replacing enforcement. ### Aggregating existing servers behind one endpoint A real-world example from the community: an [HN Show HN post for "MCP Mesh"](https://news.ycombinator.com/item?id=46435078) (Hacker News, 2026) describes exactly this pattern, one endpoint aggregating multiple backend servers with RBAC, policies, audit trails, OpenTelemetry observability, and a token vault handling OAuth so secrets never get sprayed into every client. That's the shape a mature gateway deployment takes: many purpose-built servers with one coordinated front door, not a single monolith pretending to be simple. The same shared-infrastructure problem drives [multi-agent memory silos](https://atlan.com/know/multi-agent-memory-silos/) and [context management in multi-agent systems](https://atlan.com/know/context-management-multi-agent-systems/): aggregation without shared context still leaves every agent reasoning from a different picture. ### The official MCP Registry as the discovery layer Aggregation solves routing. Discovery is a separate problem with its own protocol-native answer. The [official MCP Registry](https://registry.modelcontextprotocol.io/) and its [GitHub documentation](https://github.com/modelcontextprotocol/registry) (GitHub, modelcontextprotocol/registry, 2026) describe it as functioning "like an app store for MCP servers," maintained by the Registry Working Group. A registry answers "what servers exist and where"; a gateway answers "how do calls to them get routed, authenticated, and audited." Both can sit in front of the same servers without competing for the same job; see [what is an MCP registry](https://atlan.com/know/ai-agent/what-is-an-mcp-registry/), [public vs. private MCP server registry](https://atlan.com/know/ai-agent/public-vs-private-mcp-server-registry/), and [MCP registry vs. ad hoc MCP usage](https://atlan.com/know/ai-agent/mcp-registry-vs-ad-hoc-mcp-usage/) for the discovery side of this same threshold question. Keeping every agent's picture of "what's available and permitted" consistent is the same persistence problem [AI agent memory governance](https://atlan.com/know/ai-agent-memory-governance/) covers at the memory layer. The compact version: one team, few tools, no compliance need, connect directly. Multiple servers but still one team and no cross-team policy need, still no gateway required. Multiple teams, servers, policies, or an audit requirement, add a gateway or registry for discovery, routing, and permissioning. It's a threshold decision, not a default, the same one the spec's guidance on context-window pressure and dynamic server management already points to. --- ## How does Atlan fit into this decision? A gateway solves tool-management complexity: routing, auth, rate limits, and observability across many servers. Atlan solves a different problem, context complexity, making sure every tool and agent gets the same governed, cross-system business meaning, on either side of a gateway decision. That's a complementary layer, not a third option competing with the two compared above; see [MCP gateway vs. context layer](https://atlan.com/know/ai-agent/mcp-gateway-vs-context-layer/) for the fuller boundary. Atlan ships a hosted, per-tenant Remote MCP server (`mcp.atlan.com/mcp`, OAuth or API-key auth, Atlan's own permissions applied per call) that delivers governed definitions, lineage, ownership, quality, and classifications to AI tools at inference time, a concrete instance of the [agent context layer](https://atlan.com/know/agent-context-layer/) and [enterprise context layer](https://atlan.com/know/what-is-the-enterprise-context-layer/). It connects directly for a team that hasn't crossed the thresholds above, or registers behind a customer's own gateway once server count, team count, or compliance needs justify one, the same decision applied to one specific governed server. Pairing it with an existing gateway rather than starting over is covered in [how to implement an enterprise context layer for AI](https://atlan.com/know/how-to-implement-enterprise-context-layer-for-ai/). "Atlan captures Workday's shared language to be leveraged by AI via its MCP server. As part of Atlan's AI labs, we're co-building the semantic layer that AI needs." — Joe DosSantos, VP, Enterprise Data and Analytics, Workday Watch Now → Workday's own read on its MCP server illustrates the point: governance doesn't disappear because of an architecture choice. Whether an MCP server sits behind a gateway or gets called directly, the context it hands an agent still needs to be true, current, and scoped to who's asking, a governance question, not a routing one. That holds for every use case built on top of it, from [AI agent use cases in data engineering](https://atlan.com/know/ai-agent-use-cases-data-engineering/) to a full [AI agent harness](https://atlan.com/know/how-to-build-ai-agent-harness/), which is why [context engineering](https://atlan.com/know/what-is-context-engineering/) and the [context graph](https://atlan.com/know/what-is-a-context-graph/) underneath both sit one layer below this decision: get that right, and gateway-vs-server becomes a routing question, not a trust question. --- ## So, gateway or single server, what should you do? Start with a direct connection to a single, governed MCP server. Add a gateway when the evidence, not the anxiety, tells you to: a second team reaching for the same servers, a compliance review asking for one audit trail instead of five, or tool definitions eating into the context budget the spec itself warns you about. The overhead a gateway adds is real, an additional component to run, secure, and observe, and the governance gain it buys is also real. Neither cancels the other out. What it isn't is a default, and treating it like one trades a problem not yet present for infrastructure that will need maintaining regardless. Left unaddressed, that same gap shows up downstream as [context drift](https://atlan.com/know/context-drift-ai-agents/) and the broader [context infrastructure](https://atlan.com/know/context-infrastructure-for-ai-agents/) gaps that no amount of routing sophistication fixes on its own. --- ## FAQs about MCP gateway vs. single MCP server ### 1. Do I need an MCP gateway? Not by default. If one team connects to a handful of tools with no cross-team audit requirement, a direct connection to a single MCP server is a complete answer. A gateway earns its overhead once multiple teams share the same servers, a compliance or audit record is required, or tool-count growth starts pressuring the context window. ### 2. What is the difference between an MCP gateway and an MCP proxy? A proxy forwards traffic without awareness of who is calling or what they are allowed to do. A gateway operates at a higher level: it applies identity- and task-aware policy, enforces access control, and records who did what, producing a single audit trail instead of just relaying requests. ### 3. Can one MCP server connect to multiple data sources? Yes. A single server can expose multiple tools and resources drawing from different underlying systems. That alone does not require a gateway. The trigger for a gateway is multiple teams or clients needing centralized policy and audit, not the number of data sources one server reaches into. ### 4. What is the difference between an MCP gateway and an API gateway? Both centralize authentication, rate limiting, and observability in front of many backends. An MCP gateway is scoped specifically to MCP's tool and resource model, aggregating MCP servers into one namespaced endpoint rather than generic REST or GraphQL APIs. ### 5. Does the official MCP spec require a gateway? No. The spec defines a direct client-host-server model and never mandates a gateway role. A gateway is an operational pattern the ecosystem converged on for scale, not a requirement written into the protocol itself. ### 6. How many MCP servers is too many to connect directly? There is no fixed number. The spec's own signal is when tool definitions start consuming a meaningful share of the context window, roughly 1-5% by its own guidance, alongside team-count growth and compliance requirements. Any one of the three is reason enough to evaluate a gateway. ### 7. Can a gateway replace the need for each MCP server to enforce its own security? No. A gateway adds centralized policy and a single audit trail, but community and spec-adjacent evidence agree it is additive governance, not a substitute for backend authorization. A server that does not enforce its own permissions stays vulnerable even behind a gateway. --- ## Sources 1. [MCP Architecture overview, official MCP spec](https://modelcontextprotocol.io/docs/learn/architecture) (modelcontextprotocol.io, 2026) 2. [MCP Client Best Practices, official MCP spec](https://modelcontextprotocol.io/docs/develop/clients/client-best-practices) (modelcontextprotocol.io, 2026) 3. [Official MCP Registry](https://registry.modelcontextprotocol.io/) (Registry Working Group, 2026) 4. [MCP Registry GitHub, Registry Working Group](https://github.com/modelcontextprotocol/registry) (GitHub, 2026) 5. [IBM ContextForge (mcp-context-forge)](https://github.com/IBM/mcp-context-forge) (GitHub, IBM, 2026) 6. [Docker MCP Gateway documentation](https://docs.docker.com/ai/mcp-gateway/) (docs.docker.com, 2026) 7. [Reddit r/mcp, MCP proxy server vs MCP gateway](https://www.reddit.com/r/mcp/comments/1uye015/mcp_proxy_server_vs_mcp_gateway_we_spent_a_week/) (Reddit, 2026) 8. [Reddit r/mcp, open source gateway for enterprise production](https://www.reddit.com/r/mcp/comments/1u12f3w/) (Reddit, 2026) 9. [Hacker News, MCP Gateway: Zero-Trust Access to MCP Tool Servers](https://news.ycombinator.com/item?id=47704652) (Hacker News, 2026) 10. [Hacker News, Show HN: MCP Mesh](https://news.ycombinator.com/item?id=46435078) (Hacker News, 2026) 11. [Hacker News, Damn Vulnerable MCP Server](https://news.ycombinator.com/item?id=43707021) (Hacker News, 2026) 12. [Hacker News, MCP was always a bad idea?](https://news.ycombinator.com/item?id=49779329) (Hacker News, 2026)