WZ-IT Logo

MCP in the enterprise: Model Context Protocol, specification 2026-07-28 and security

Timo WevelsiepTimo Wevelsiep•Updated: 30.09.2026

Editorial note: Versions, commands and prices may change. Please verify critical steps independently before production use. This guide does not replace individual consulting.

Connecting AI agents to your ticket system, wiki or ERP, with clear permissions? WZ-IT builds agents and internal assistants on your own infrastructure: a tool catalogue instead of full access, delegated identities, approvals for critical steps and logging of every run. Explore AI agents · Internal AI assistants · Book a call

The Model Context Protocol (MCP) is an open standard through which AI applications access tools and data sources. An MCP server built once for a ticket system works in every client that speaks MCP and survives a change of language model. For companies, MCP is therefore an integration layer, and like every integration layer it raises questions of identity, permissions and attack surface. This article explains the architecture and transports, summarises the 2026-07-28 specification, covers authorization and describes risks and operation with local models. As of October 2026.

Table of contents

What MCP is: host, client, server

MCP is an open protocol based on JSON-RPC 2.0. The specification names the Language Server Protocol as its model: just as LSP connects programming languages to editors in a uniform way, MCP connects tools and context to AI applications (MCP specification 2026-07-28). Anthropic released the protocol on 25 November 2024 and contributed it on 9 December 2025 as a founding project to the Linux Foundation's Agentic AI Foundation.

Role Task Example
Host AI application that establishes connections and controls the model Chat frontend, agent, code editor
Client Connection inside the host, one per server Connector in Open WebUI or LibreChat
Server Service that provides capabilities MCP server for a ticket system, wiki, database

A server offers three kinds of capabilities:

Primitive Controlled by Purpose
Tools Model Functions the model calls: create a ticket, search a record
Resources Application or user Context and data, such as a file or a record
Prompts User Templates for messages and workflows

The benefit is decoupling. Without a standard, every combination of AI application and target system needs its own integration. With MCP you write the server once, and every MCP-capable host can use it. The language model itself does not speak MCP: the host translates the tool list into the model's tool-calling interface and executes the calls.

Transports: stdio and Streamable HTTP

The specification defines two standard transports (MCP, Transports). The choice determines the operating model and the attack surface.

Property stdio Streamable HTTP
Mechanism Client launches the server as a subprocess, messages over standard input and output Server runs independently, every message is an HTTP POST to one endpoint
Typical use Local tools on a workstation or in the same container Central servers for several users and applications
Authorization No OAuth specification; credentials come from the environment The specification's OAuth 2.1 profile (optional, but intended)
Privileges Privileges of the launching process Privileges of the server's service account plus token scopes
Operation One process per client Scalable behind reverse proxy and load balancer

For Streamable HTTP, the specification requires servers to validate the Origin header and respond with 403 to an invalid value, to prevent DNS rebinding. Locally running servers should bind only to 127.0.0.1, not to all interfaces (MCP, Streamable HTTP). The older HTTP+SSE transport from version 2024-11-05 is deprecated and should be migrated.

In a company, Streamable HTTP is the normal case for shared servers: one service, one identity, central logging. stdio suits developer tools on one's own machine.

Specification 2026-07-28: what has changed

Revision 2026-07-28 was released on 28 July 2026 and replaces 2025-11-25 (announcement, changelog). It turns MCP from a stateful into a stateless request/response protocol.

Change Content Operational impact
No sessions (SEP-2567) Mcp-Session-Id removed; state via explicit handles passed as tool arguments Servers can run behind round-robin load balancers
No handshake (SEP-2575) initialize removed; version and client capabilities in the _meta of every request; new server/discover Every request can be checked on its own
Routing headers (SEP-2243) Mcp-Method and Mcp-Name mandatory on Streamable HTTP Gateways can route, limit and log tool calls without parsing the body
Multi Round-Trip Requests (SEP-2322) Server requests missing input via input_required, client retries the request No more server-initiated requests over open streams
Cacheable lists (SEP-2549) ttlMs and cacheScope on tools/list and related results Fewer requests, more stable tool lists
Tasks as an extension (SEP-2663) Long-running operations via io.modelcontextprotocol/tasks with polling Optional, negotiated by both sides
Issuer validation (SEP-2468) Authorization servers should send iss per RFC 9207, clients must validate it Protection against mix-up attacks
Credentials per issuer (SEP-2352) Client credentials bound to the issuing authorization server No reuse across servers
Deprecated (SEP-2577 and others) Roots, Sampling, Logging; HTTP+SSE; Dynamic Client Registration Usable for at least twelve more months, new implementations should not adopt them

For operators, the removal of sessions has the most consequences. An MCP server that tied state to a session must now model it with handles. The security best practices state that possessing a handle must never count as authentication and that handles should be bound server-side to the authenticated user. According to the announcement, the official SDKs for TypeScript, Python, Go and C# support the new version, the Rust SDK as a beta. Clients that need to keep supporting older servers can detect the counterpart's generation and fall back to the previous handshake.

Authorization: OAuth 2.1 and identity providers

Authorization is optional in MCP. Where an HTTP-based server implements it, it follows an OAuth 2.1 profile (MCP, Authorization). The MCP server acts as resource server, the host as OAuth client, and the token is issued by an authorization server, in a company typically the existing identity provider such as Keycloak.

Building block Requirement in the specification
Protected Resource Metadata (RFC 9728) Servers must provide it; clients use it to find the authorization server
Discovery OAuth Authorization Server Metadata (RFC 8414) or OpenID Connect Discovery; clients must support both
PKCE Part of the authorization flow, as provided for in OAuth 2.1
Resource Indicators (RFC 8707) Clients must name the target server in the resource parameter
Token audience Servers must verify that the token was issued for them
Token passthrough Forbidden: servers must not accept or forward foreign tokens
Issuer validation (RFC 9207) Servers should send iss; clients must check a present value before redeeming the code
Client registration Client ID Metadata Documents preferred, pre-registration possible, Dynamic Client Registration deprecated
stdio Should not follow this specification; credentials come from the environment

Issuer validation is deliberately graded: if an authorization server advertises iss in its metadata and the value is missing from the response, the client must reject it. The specification announces a future upgrade from SHOULD to MUST for servers (RFC 9207).

Three points follow for enterprise operation. First, scopes should be narrow: the security best practices explicitly list wildcard scopes and publishing every scope in scopes_supported as mistakes and recommend incremental elevation via step-up. Second, pre-registration in your own identity provider is often more controlled than open registration paths, because only known clients receive tokens. Third, an MCP server that calls a third-party system on behalf of the user needs its own token for that system. Forwarding the user's MCP token is exactly the forbidden token passthrough.

MCP with local models and Open WebUI

MCP is not tied to a model vendor. The prerequisites are a model that handles tool calling reliably and an inference server that exposes the tool interface. Open WebUI states the limit clearly: MCP connects the interface to tools, it does not improve the model's ability to use them (Open WebUI, MCP).

Component MCP support (as of October 2026) Source
Open WebUI Native since v0.6.31, Streamable HTTP only; auth via bearer, session, OAuth or OAuth 2.1; registration by administrators only Open WebUI docs
mcpo Proxy that exposes stdio or SSE servers as OpenAPI endpoints GitHub open-webui/mcpo
LiteLLM MCP gateway with a fixed endpoint; Streamable HTTP, SSE and stdio; access per key, team and organisation LiteLLM docs

A typical setup with local models: the model runs in vLLM or Ollama, LiteLLM bundles model access and MCP servers, Open WebUI is the interface and the identity provider supplies the user identity. MCP servers run as separate containers with Streamable HTTP on the internal network. Which models are suitable for tool calling on your own hardware is covered in Which LLM to self-host?, how LiteLLM works as a gateway in What is LiteLLM?.

A gateway centralises access, and with it the risk. Whoever takes over the gateway reaches every connected server. The LiteLLM vulnerability GHSA-7hp6-4w63-5g45 (published 30 September 2026, CVSS 9.9) allows an ordinary user to escalate to proxy admin and from there to execute commands via the MCP stdio endpoint. Affected versions and hardening are described in LiteLLM vulnerability: hardening the gateway.

Risks: tool poisoning, stdio and tokens

The specification itself states that tools represent arbitrary code execution and that descriptions from untrusted servers must be treated as untrusted (MCP specification, Security and Trust & Safety). The main attack paths:

Risk Mechanism Countermeasure
Tool poisoning Hidden instructions in tool descriptions that the model follows (Invariant Labs) Vetted servers only, read and version the descriptions
Rug pull Server changes descriptions after approval Pin tool definitions, detect changes and re-approve
Shadowing One server manipulates behaviour towards other servers Separate servers by trust level, do not mix all of them in one context
stdio commands A configuration entry launches any process with client privileges Consent dialog with the full command, sandbox, restricted privileges
Token passthrough Server accepts or forwards foreign tokens Validate audience, separate tokens for third-party systems
Confused deputy Proxy server with a static client ID skips consent Per-client consent, exact redirect URI matching
SSRF Malicious server points OAuth discovery at internal addresses Enforce HTTPS, block private address ranges, egress proxy
Prompt injection via data Tool results or documents contain instructions Treat data as data, approvals for critical actions

In operation, one more point comes in: the concentration of credentials. An MCP server for five systems holds five sets of credentials. The security best practices describe the knock-on risk for tokens accepted by several services: whoever compromises one service reaches the others too. An MCP server therefore belongs in the same protection class as the most sensitive system it can reach.

How indirect prompt injection through documents, emails and tool results can be contained architecturally is described in Protection against prompt injection.

Permissions and approvals in operation

MCP standardises the access path, not the authorization. Who may use which tools is decided by the catalogue, the identity provider and the target system. The specification explicitly recommends a human in the loop who can deny tool invocations, as well as confirmation prompts for sensitive operations (MCP, Tools). For enterprise use this results in a checklist:

Area Measure
Server selection Self-built or vetted servers only; document source, version and tool descriptions
Network MCP servers in the internal segment, not publicly reachable; validate Origin; local servers on 127.0.0.1 only
Identity Pass the user identity through where the target system supports it; one service account per task instead of a general account
Scopes Minimal initial scope, elevation via step-up, no wildcards
Tool catalogue Approved tools per user group; write tools separated from read tools
Approvals Confirmation for write and irreversible actions
stdio Only where needed, in a container or sandbox, without access to home directories and keys
Gateway Keep admin access narrow, pin the version, follow security advisories, disable MCP features when unused
Logging Trigger, identity, tool, parameters and result per call, on your own infrastructure

The fundamentals, meaning which identity an agent uses in the target system and which steps require approval, are covered in AI agents: permissions and approvals. Where RAG and tools access the same data, the same rules apply as for RAG with permissions: permissions are checked before access, not filtered afterwards.

When MCP makes sense and when an API is enough

MCP is an additional layer. It pays off when several applications use the same tools or when the integration should outlast a change of model or frontend.

Situation Recommendation
Several AI applications should use the same system (chat, agent, editor) MCP server, built once and operated centrally
Agent should handle unstructured requests with changing tools MCP with tool catalogue and approvals
Fixed process with always the same steps Direct API call in a workflow, for example with n8n
Vendor-provided MCP server for a SaaS product Review it like any third-party software: permissions, data flows, operator
No API access in the target system Create an interface first, then consider MCP

When an agent makes sense at all instead of a fixed workflow is discussed in AI agents and automation. A comparison of frameworks from an operator's perspective, including MCP support, is in AI agent frameworks compared.

What this means for your project

MCP has become a widely used interface between AI applications and company systems, and with revision 2026-07-28 it is also more mature operationally: stateless, routable via headers, with stricter OAuth requirements. The security questions remain those of any integration, only concentrated: who may do what, under which identity, and who can see it afterwards.

WZ-IT connects approved MCP servers and existing APIs with limited permissions and documented data flows to AI agents and internal assistants. The foundation is Open WebUI, LiteLLM, Langfuse and the existing identity provider. Models run locally on the AI Cube or on WZ-IT managed GPU servers with NVIDIA RTX PRO 4000 Blackwell (24 GB) or RTX PRO 6000 Blackwell Max-Q (96 GB). Support, consulting and implementation by WZ-IT.

How the rest of the stack is built is shown in Open-source LLM stack. How local AI services can be made securely reachable from outside is described in Provide secure remote access to local AI.

Rather have it operated?

You'd rather not run Local AI for Business yourself? WZ-IT handles setup, operations and maintenance - privacy-focused from Germany.

Enquiry

Assess local AI for your use case

Start with the AI Cube or have us assess a custom AI platform, knowledge connection, or integration.

How should we get back to you?

Frequently Asked Questions

Answers to the most important questions

MCP is an open protocol through which AI applications access tools, data and prompt templates in a uniform way. A host application such as a chat frontend or an agent contains MCP clients that connect to MCP servers. Each server exposes tools, resources or prompts. Messages are JSON-RPC 2.0. Anthropic released MCP on 25 November 2024; since December 2025 it has been part of the Linux Foundation's Agentic AI Foundation.

As of October 2026 it is revision 2026-07-28, released on 28 July 2026. The previous version is 2025-11-25. The most important change: MCP has become stateless. Protocol sessions, the Mcp-Session-Id header and the initialize handshake are gone; every request carries its protocol version and client capabilities itself.

No. Authorization is explicitly optional in the specification. If an HTTP-based server implements it, it should follow the specification's OAuth 2.1 profile. A server without authentication on the internal network is reachable by anyone who can reach that network. Securing it is an operational decision, not a protocol feature.

Only partly. MCP standardises the access path and, through OAuth scopes, which rights a token carries. Which users see which servers and tools is decided by the host, the gateway and the target system. The specification explicitly allows tools/list to return different tools depending on the authorization presented.

No. With stdio the client starts the server as a separate process with the client's privileges. An MCP server entry in the configuration is therefore a command that gets executed. The MCP security best practices require a consent dialog showing the full command before launch and recommend sandboxing. The LiteLLM vulnerability GHSA-7hp6-4w63-5g45 shows the path: whoever gains admin rights can execute arbitrary commands via the MCP stdio endpoint.

In tool poisoning, a tool description contains instructions that the model reads but the user does not see. The model follows them, for example by reading files and sending them along as parameters. Variants are the rug pull, where a server changes its descriptions after approval, and shadowing, where one server manipulates behaviour towards other, trusted servers. The specification therefore treats tool descriptions from untrusted servers as untrusted.

Yes. MCP is model-agnostic; what matters is that the model handles tool calling. Open WebUI has supported MCP natively since version 0.6.31, but only over Streamable HTTP. stdio or SSE servers are connected through the mcpo proxy. In Open WebUI only administrators can register MCP servers.

RFC 9207 protects against mix-up attacks, in which an authorization code ends up at the wrong authorization server. Since 2026-07-28, authorization servers should send the iss parameter in the response. MCP clients must check a present iss value against the issuer recorded beforehand, before redeeming the code. If iss is missing although the server advertises it, the client must reject the response.

Only for backwards compatibility. With 2026-07-28, OAuth Dynamic Client Registration (RFC 7591) is deprecated as a registration mechanism. Client ID Metadata Documents are preferred, where the client ID is an HTTPS URL pointing to metadata. Pre-registration remains possible and, in companies with their own identity provider, is usually the most controlled option.

Not necessarily. MCP pays off when the same integration is to be used by several AI applications or across a model change. For a fixed process with a single caller, a direct API call, for example in an n8n workflow, is often the shorter path and easier to audit.

More on Local AI for Business

Contact

Let's Talk About Your Idea

Whether a specific IT challenge or just an idea - we look forward to the exchange. In a brief conversation, we'll evaluate together if and how your project fits with WZ-IT.

Arrange a callback

Callback

Arrange a callback

Leave your number and we will call back — at the latest on the next business day.

For a longer conversation you can book an appointment instead.

Companies worldwide trust WZ-IT

  • ml&s
  • Rekorder
  • Keymate
  • Führerscheinmacher
  • SolidProof
  • ARGE
  • Boese VA
  • nextGYM
  • SweetConnect GmbH
  • Golem.de
  • Millenium
  • Paritel
  • Yonju
  • EVADXB
  • Mr. Clipart
  • Aphy AG
  • Negosh
  • ABCO Water Systems
1/3 - Topic Selection33%

What is your inquiry about?

First select the service area that best matches your project.