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
- Transports: stdio and Streamable HTTP
- Specification 2026-07-28: what has changed
- Authorization: OAuth 2.1 and identity providers
- MCP with local models and Open WebUI
- Risks: tool poisoning, stdio and tokens
- Permissions and approvals in operation
- When MCP makes sense and when an API is enough
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.











