---
description: "MCP architecture explained: hosts, clients, servers, primitives, transports, and authorization, plus the gateway layer the specification leaves to each team."
title: "MCP Architecture: Components and the Missing Gateway Layer"
image: https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w1200/2026/11/mcp-architecture-components-and-the-missing-gateway-layer-bifrost-1920x1080.png
---

Try Bifrost Enterprise free for 14 days. [Request access](https://www.getmaxim.ai/#enterprise-trial)

**TL;DR**

- MCP architecture has three participants (host, client, server) and two protocol layers: a JSON-RPC 2.0 data layer and a transport layer.
- Servers expose tools, resources, and prompts; clients can offer elicitation back to servers so a tool can ask the user for input.
- Two transports are standard: stdio for local servers and Streamable HTTP for remote servers, with OAuth 2.1 authorization for HTTP.
- The specification defines how one client talks to one server, but not how an organization applies policy, brokers credentials, or audits calls across many servers.
- An MCP gateway such as Bifrost fills that layer by sitting between every host and every server.

MCP architecture is the set of components the Model Context Protocol defines for connecting AI applications to external tools and data: hosts that run the model, clients that hold connections, servers that expose capabilities, and the data and transport layers that carry messages between them. [Bifrost](https://www.getmaxim.ai/), the [open-source MCP gateway](https://github.com/maximhq/bifrost) built by Maxim AI, adds the gateway layer that the specification leaves to each deployment. This guide covers every component of an MCP system and explains why production teams add that layer.

## What Is MCP Architecture?

MCP architecture is a client-server design in which an AI application, the host, creates one MCP client per MCP server, and each client exchanges JSON-RPC 2.0 messages with its server over a transport. Servers expose capabilities as primitives; clients discover and invoke them. The design separates what is said (the data layer) from how it travels (the transport layer).

The [MCP architecture overview](https://modelcontextprotocol.io/docs/learn/architecture) describes these pieces, and the current revision of the protocol, released on July 28, 2026, made the core stateless: each request carries its protocol version and client capabilities, so any server instance behind a load balancer can handle it. Figure 1 maps the full system, including the authorization server and registry that sit beside the core protocol.

![](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/2026/11/mcp-architecture-without-with-gateway.png)

*Figure 1: The specification defines hosts, clients, servers, and the two protocol layers; policy across them is left to the deployment.*

For background on why MCP became the standard way to connect models to tools, see the [complete Model Context Protocol guide](https://www.getmaxim.ai/articles/what-is-model-context-protocol-mcp-a-2026-guide/).

## The Core Components of an MCP System

An MCP system has six components: the host, the client, the server, the data layer, the transport layer, and, for remote servers, an authorization server. A registry is an optional seventh that helps hosts find servers. Each component has a narrow job, and most production problems come from assuming one component handles a job that belongs to another.

| Component | Role | Defined by the MCP spec? |
| --- | --- | --- |
| Host | AI application that runs the model and manages clients | Yes |
| Client | Connection to one server; discovers and invokes capabilities | Yes |
| Server | Program exposing tools, resources, and prompts | Yes |
| Data layer | JSON-RPC 2.0 messages: discovery, primitives, notifications | Yes |
| Transport layer | stdio or Streamable HTTP, plus authorization for HTTP | Yes |
| Authorization server | Issues OAuth 2.1 tokens for remote servers | Interface only |
| Registry | Catalog of server metadata for discovery | Separate project |
| Gateway | Central policy, credentials, and audit across servers | No |

The host, client, and server roles are covered in more detail in the [MCP connectors explainer](https://www.getmaxim.ai/articles/mcp-connectors/), which also explains how products package servers for end users.

## How MCP Works: The Data Layer

The MCP data layer is a JSON-RPC 2.0 protocol that defines discovery, the primitives servers and clients exchange, and notifications. A client can call `server/discover` to learn a server's supported versions and capabilities, list its primitives with `tools/list` and similar methods, and invoke a tool with `tools/call`. Every request is self-contained.

### Server primitives: tools, resources, and prompts

Servers expose three primitives. **Tools** are functions the model can call, such as `create_issue` or `run_query`. **Resources** are data the application can read, such as a file or a database schema. **Prompts** are reusable templates a user can select.

Each primitive has list and get methods, and tools add a call method. A tool definition carries a name, description, and JSON Schema for its inputs, which is what the model reads when deciding how to call it.

### Client primitives: elicitation

Clients can offer capabilities back to servers. The main one is **elicitation**, which lets a server ask the user for more information or confirmation before completing a tool call, delivered through the multi round-trip request pattern. As of the 2026-07-28 revision, sampling, roots, and logging are deprecated; servers that need a model should call a provider directly, and servers that need logging should use stderr or OpenTelemetry. Bifrost passes elicitation through to the connected client using [multi round-trip requests](https://docs.getbifrost.ai/mcp/multi-round-trip-requests).

Notifications complete the data layer. A client can open a subscription stream and receive events such as `notifications/tools/list_changed` when a server's tools change, then re-list them.

## MCP Transports: stdio and Streamable HTTP

MCP defines two standard transports. stdio runs the server as a subprocess of the host and exchanges messages over standard input and output, which suits local tools. Streamable HTTP runs the server as a web service that receives HTTP POST requests and can stream responses, which suits remote and shared servers. The older HTTP with Server-Sent Events transport is deprecated.

The transport choice decides most of a server's operational profile:

- **stdio servers** inherit the user's environment and credentials, serve one client, and run with the user's privileges, so the risk is arbitrary local code execution
- **Streamable HTTP servers** serve many clients, need real authentication, and can scale horizontally now that the protocol core is stateless
- **Both** carry identical JSON-RPC messages, so the data layer does not change between them

Most organizations run a mix of local, internal, and vendor-hosted servers. The [MCP gateway architecture guide](https://www.getmaxim.ai/articles/mcp-gateway-architecture/) covers how each connection type behaves when a gateway sits in front.

## Authorization and the MCP Registry

MCP authorization is optional and applies to HTTP transports. When used, a protected MCP server acts as an OAuth 2.1 resource server, publishes Protected Resource Metadata that points to its authorization server, and must accept only tokens issued for itself. Clients request audience-bound tokens with resource indicators and send them on every request.

The [MCP authorization specification](https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization) is explicit that servers must not accept or transit any other tokens, which rules out passing a user's upstream token straight through. That rule protects the system but leaves each deployment to solve credential handling for dozens of servers, each with its own authorization server and scopes.

The registry solves a different problem: discovery. The official MCP Registry stores server metadata in a standard `server.json` format so hosts and sub-registries can find servers and their install details. A registry tells you which servers exist; it does not decide which ones a given team may use. The [comparison of an MCP gateway and an MCP registry](https://www.getmaxim.ai/articles/mcp-gateway-vs-mcp-registry/) explains why organizations usually need both.

## The Missing Layer: Why MCP Architecture Needs a Gateway

MCP architecture specifies how one client talks to one server, but it does not specify how an organization governs many hosts talking to many servers. Without a shared layer, every host carries its own server list, credentials, and approval rules, so policy is duplicated, credentials spread across laptops, and no single record shows which tools ran for whom.

Figure 2 shows the arithmetic. Three hosts connected directly to three servers make nine connections, each configured separately. With a gateway, each host connects once and the gateway holds one connection per server.

![](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/2026/11/mcp-architecture-gateway-layer.png)

*Figure 2: Direct wiring multiplies credentials and policy by every host; a gateway keeps one copy of each.*

The gaps that appear at scale are consistent across teams:

- **No central access policy.** Each host decides which tools to expose, so a server added to one developer's config is available to their agent with no review.
- **Scattered credentials.** API keys and OAuth tokens live in host configuration files on individual machines.
- **No cross-server audit trail.** Each host logs differently, if at all, and nothing correlates tool calls across servers.
- **Tool sprawl and token cost.** Every connected tool's definition is sent to the model on each turn.
- **No content controls.** Tool arguments and results flow between model and server without inspection.

These are the problems covered in [why production MCP deployments need an MCP gateway](https://www.getmaxim.ai/articles/why-production-mcp-deployments-need-an-mcp-gateway/) and in the comparison of an [MCP gateway versus direct connections](https://www.getmaxim.ai/articles/mcp-gateway-vs-direct-connections/).

## What an MCP Gateway Adds

An MCP gateway is a control layer that sits between MCP hosts and MCP servers, acting as a single MCP server to every client and as the MCP client to every upstream server. Because all traffic passes through it, the gateway is where access policy, credential brokering, guardrails, logging, and cost controls can be applied once for the whole organization.

| Gap in direct MCP architecture | Gateway control | Bifrost capability |
| --- | --- | --- |
| No central access policy | Per-caller tool allow-lists | Deny-by-default [MCP tool filtering on virtual keys](https://docs.getbifrost.ai/features/governance/mcp-tools) |
| Scattered credentials | Credentials held at the gateway | Shared headers, OAuth, per-user OAuth, token exchange |
| No audit trail | One log for every tool call | MCP logs alongside LLM logs |
| Tool sprawl and token cost | On-demand tool loading | Code Mode with four meta-tools |
| No content controls | Inspect arguments and results | MCP guardrails before and after execution |
| Many endpoints to configure | One endpoint per team or agent | Virtual MCPs at `/mcp/<slug>` |

The [MCP gateway as a control plane for MCP servers](https://www.getmaxim.ai/articles/mcp-gateway-the-control-plane-for-mcp-servers/) explains the pattern in depth, and the [MCP gateway product overview](https://www.getmaxim.ai/mcp-gateway) shows how it fits with model routing.

## How Bifrost Fills the Gateway Layer

[The Bifrost AI gateway](https://www.getmaxim.ai/) fills the MCP gateway layer by connecting to upstream servers as their client and exposing them to hosts through one governed endpoint. Policy, credentials, guardrails, and logs live in Bifrost, so hosts carry only a gateway URL and a credential, and the same rules cover MCP tool calls and model calls.

Figure 3 groups the four responsibilities Bifrost holds for an MCP architecture.

![](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/2026/11/mcp-architecture-components.png)

*Figure 3: Four responsibilities the MCP specification leaves to each deployment sit together in the gateway layer.*

How each responsibility works in Bifrost:

- **Access.** Hosts connect to the [/mcp endpoint](https://docs.getbifrost.ai/mcp/overview) with a virtual key header or a browser-based OAuth 2.1 flow, and `tools/list` returns only the tools that credential allows. [Virtual MCPs](https://docs.getbifrost.ai/mcp/virtual-mcps) bundle selected tools for a specific team.
- **Credentials.** Bifrost supports [upstream authentication types](https://docs.getbifrost.ai/mcp/auth/overview) from static headers to per-user OAuth and, in Bifrost Enterprise, token exchange, where each caller's identity-provider token is exchanged for a short-lived upstream token that is never stored.
- **Guardrails.** In Bifrost Enterprise, [guardrail rules on the MCP target](https://docs.getbifrost.ai/enterprise/guardrails) inspect or redact tool arguments before execution and tool results after it, scoped by MCP client and tool.
- **Logs and cost.** Every tool call is logged with its arguments and result, and [Code Mode](https://docs.getbifrost.ai/mcp/code-mode) reduces input tokens by up to 92.8% in large deployments; the [MCP gateway resource page](https://www.getmaxim.ai/resources/mcp-gateway) summarizes the benchmark.

Bifrost also keeps upstream connections healthy: it health-checks each server, retries transient connection failures with exponential backoff, and reconnects in the background, as described in [MCP connections and lifecycles](https://docs.getbifrost.ai/mcp/connections). For tool execution, calls the model proposes are suggestions by default, and [Agent Mode](https://docs.getbifrost.ai/mcp/agent-mode) auto-executes only the tools you list.

Bifrost deploys inside your own infrastructure, in-VPC or on-prem, so tool arguments and results stay there. The [Bifrost enterprise deployment page](https://www.getmaxim.ai/enterprise) covers clustering and identity-provider integration, and the [MCP gateway cost and access governance writeup](https://www.getmaxim.ai/bifrost/blog/bifrost-mcp-gateway-access-control-cost-governance-and-92-lower-token-costs-at-scale) has full benchmark results.

## Frequently Asked Questions

### What are the main components of MCP architecture?

MCP architecture has three participants and two layers. The participants are the host (the AI application), the client (a connection to one server inside the host), and the server (a program exposing tools, resources, and prompts). The layers are the JSON-RPC 2.0 data layer and the transport layer, which is stdio or Streamable HTTP. Remote servers also rely on an OAuth 2.1 authorization server.

### How does MCP work?

MCP works by having a host create one client per server. The client discovers the server's tools, the host passes those tool definitions to the model, and when the model requests a tool, the client sends `tools/call` to the server and returns the result. The host feeds that result back to the model. The [Model Context Protocol guide](https://www.getmaxim.ai/articles/what-is-model-context-protocol-mcp-a-2026-guide/) walks through a full exchange.

### What is an MCP gateway?

An MCP gateway is a control layer between MCP hosts and MCP servers. It presents itself to hosts as one MCP server and connects to upstream servers as their client, which lets it apply access policy, hold credentials, inspect tool traffic, and log every call in one place. Bifrost is an open-source MCP gateway that also routes LLM traffic; [MCP: the protocol, the plumbing, and the gateway](https://www.getmaxim.ai/bifrost/blog/mcp-the-protocol-the-plumbing-and-the-gateway) covers the design.

### What transports does MCP support?

MCP supports two standard transports. stdio runs a local server as a subprocess and exchanges messages over standard input and output. Streamable HTTP runs a remote server as a web service that accepts HTTP POST requests and can stream responses. The older HTTP with Server-Sent Events transport is deprecated in the current specification.

### What is the difference between an MCP gateway and an MCP registry?

An MCP registry is a catalog of server metadata that helps hosts discover which servers exist and how to install them. An MCP gateway is a runtime control point that decides which servers and tools each caller may use and records every call. A registry answers "what is available"; a gateway answers "what is allowed."

## Getting Started with Bifrost

MCP architecture gives teams a clean standard for connecting models to tools, and the gateway layer gives them the controls to run it across an organization. Bifrost provides that layer with access policy, credential brokering, guardrails, and logs in one place. To see how Bifrost fits your MCP architecture, [book a demo](https://www.getmaxim.ai/book-a-demo) with the Bifrost team.

## Read next

[![Atlassian MCP Server: Setup, Permissions, and Security for Jira and Confluence](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/11/atlassian-mcp-server-setup-permissions-and-security-for-jira-bifrost-1920x1080.png) The Atlassian MCP server lets Claude, Cursor, and other AI agents read and update Jira and Confluence. This guide covers setup, authentication, permission groups, admin controls, and how to add tool filtering, guardrails, and audit logs with an MCP gateway.](https://www.getmaxim.ai/articles/atlassian-mcp-server/)

[![10 Best AWS MCP Servers, and How to Govern Them Through One Gateway](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/11/10-best-aws-mcp-servers-and-how-to-govern-them-through-one-g-bifrost-1920x1080@2x.png) AWS MCP servers are MCP servers that AWS maintains so AI agents can read AWS docs and call AWS APIs. This guide ranks 10 of them, from the managed AWS MCP Server to the EKS, CloudWatch, and Billing servers, and shows how Bifrost governs them through one gateway.](https://www.getmaxim.ai/articles/aws-mcp-servers/)

[![MCP Server Best Practices for Reliability and Security](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/11/mcp-server-best-practices-for-reliability-and-security-bifrost-1920x1080.png) MCP server best practices cover how to design tools a model can call correctly, keep servers reliable under retries and timeouts, and secure them with scoped authorization. This guide covers what to build into each server and what to centralize in an MCP gateway.](https://www.getmaxim.ai/articles/mcp-server-best-practices/)

## More in MCP Gateway

[![MCP Client vs Server: Connectors, Hosts, and Servers](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/11/mcp-client-vs-server-connectors-hosts-and-servers-bifrost-1920x1080.png) MCP client vs server is the core split in the Model Context Protocol: the client lives inside an AI application and the server exposes tools and data. This guide traces a request from connector to client to server and shows what changes when a gateway sits between them.](https://www.getmaxim.ai/articles/mcp-client-vs-server/)

[![Tool Discovery for AI Agents: How Agents Find the Right MCP Tools at Scale](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/11/tool-discovery-for-ai-agents-how-agents-find-the-right-mcp-t-bifrost-1920x1080.png) Tool discovery for AI agents decides which tools an agent sees out of hundreds. This guide covers why large tool catalogs break agents, the four discovery patterns from tools/list to tool search and code-based discovery, and how to govern discovery at an MCP gateway.](https://www.getmaxim.ai/articles/tool-discovery-for-ai-agents/)

```json
{
    "@context": "https://schema.org",
    "@type": "Article",
    "publisher": {
        "@type": "Organization",
        "name": "Maxim Articles",
        "url": "https://www.getmaxim.ai/articles/",
        "logo": {
            "@type": "ImageObject",
            "url": "https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w256h256/2025/08/thumbnail.png",
            "width": 60,
            "height": 60
        }
    },
    "author": {
        "@type": "Person",
        "name": "Kamya Shah",
        "image": {
            "@type": "ImageObject",
            "url": "https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/2025/09/WhatsApp-Image-2025-08-29-at-17.40.40-1.jpeg",
            "width": 1200,
            "height": 1600
        },
        "url": "https://www.getmaxim.ai/articles/author/kamya/",
        "sameAs": []
    },
    "headline": "MCP Architecture: Components and the Missing Gateway Layer",
    "url": "https://www.getmaxim.ai/articles/mcp-architecture/",
    "datePublished": "2026-11-17T03:01:00.000Z",
    "dateModified": "2026-11-21T03:03:40.000Z",
    "image": {
        "@type": "ImageObject",
        "url": "https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w1200/2026/11/mcp-architecture-components-and-the-missing-gateway-layer-bifrost-1920x1080.png",
        "width": 1200,
        "height": 675
    },
    "keywords": "MCP Gateway",
    "description": "MCP architecture defines how AI applications connect to tools through hosts, clients, servers, a JSON-RPC data layer, and a transport layer. This guide walks through each component of an MCP system and explains the gateway layer production deployments add on top.",
    "mainEntityOfPage": "https://www.getmaxim.ai/articles/mcp-architecture/"
}
```
