Skip to content

MCP Servers: Connecting AI Agents to Systems the Standard Way

An AI agent that cannot reach your ERP, CRM, document store or ticketing system is a chatbot with good manners. Until recently, connecting one meant a custom integration for every pairing of agent and system. The Model Context Protocol (MCP) swaps those one-off integrations for a shared standard. This guide is for IT leads who need to decide how to run MCP servers properly: architecture, transports, authentication, security and the vendor servers that already exist. It reflects the specification revision of 28 July 2026, checked in October 2026.

What is an MCP server and what is it used for?

An MCP server is a service that publishes a system's functions and data as standard tools, resources and prompts. Any MCP-compatible agent can use it without knowing that system's native API. Companies deploy MCP servers to give agents controlled, auditable access to ERP, CRM, databases and documents.

The specification describes MCP as an open protocol for connecting LLM applications to external data sources and tools, and compares itself to the Language Server Protocol, which lets one editor support many programming languages through a single interface. MCP aims to do the same for AI applications and business systems.

Typical enterprise uses:

  • Look things up: an agent retrieves customer master data, open orders or stock levels to answer a question or draft a quotation.
  • Create records: it opens a support ticket, adds a contact to the CRM or appends a note to a sales order.
  • Work with documents: inspection reports, service manuals or delivery notes are exposed as resources the model can read.
  • Encode procedures: prompts carry vetted workflows, such as "log a customer complaint" with mandatory fields.

The value is decoupling. Once a system speaks MCP, any compatible client can use it: a desktop assistant, a coding tool or an agent you built yourself. For the bigger picture of what agents can and cannot do in a business, see our overview of AI agents for business. For a short definition of the protocol itself, the glossary entry on Model Context Protocol (MCP) is the quicker read; this guide focuses on running it in production.

How does MCP work? The building blocks

MCP has three roles: the host (the AI application), the client (the connector inside the host) and the server (the service offering capabilities). Messages use JSON-RPC 2.0. Servers expose tools, resources and prompts, and the language model decides which tool to call and when.

According to the specification, servers can offer three kinds of capability:

Building blockWho drives itEnterprise example
Toolsthe language modelcreate_ticket, read_query, update_record
Resourcesthe user or the modelproduct manual, config file, record
Promptsthe user"Log a complaint", "Review a quote"

Tools do the heavy lifting in business settings; under the hood they rely on the model's tool use or function calling capability. Each has a name, a description and an input schema in JSON Schema, plus an optional output schema that structured results must conform to (tools specification). The client lists tools with tools/list and invokes them with tools/call. Errors the model can act on, such as "delivery date must be in the future", come back as a tool result flagged isError: true so the agent can correct itself and retry.

What the 2026-07-28 revision changed

The July 2026 revision made MCP stateless. The changelog removes the initialize handshake and protocol-level sessions; every request now carries its protocol version and client capabilities in _meta. Servers must implement a new server/discover method so clients can check versions and capabilities up front.

What this means for enterprise architecture:

  • Easier scaling: without session affinity, remote servers can sit behind an ordinary load balancer.
  • Explicit state only: if a workflow needs state across calls, the server returns its own handle (an order draft ID, for instance) and the agent passes it back as a normal argument.
  • Asking the user: when a server needs input from the user, it returns an interim result with the question, and the client retries the original request with the answer (multi round-trip requests).
  • Deprecations: sampling, roots and logging are deprecated, as is Dynamic Client Registration in favour of Client ID Metadata Documents. Long-running work moved into an official "tasks" extension.

Older counterparts still work: clients can detect a server that expects the earlier handshake and fall back. When you buy or build a server, ask which protocol versions it supports.

Transports: local stdio or remote Streamable HTTP?

The specification defines two standard transports. With stdio, the client launches the server as a local subprocess, which suits developer tools and single users. Streamable HTTP is for centrally hosted servers shared by many users and agents. In most companies, Streamable HTTP is the one that matters.

The transport overview defines stdio as newline-delimited JSON-RPC over the standard streams of a client-launched process. With Streamable HTTP, every message is an HTTP POST to a single endpoint, and the server replies with either one JSON object or a Server-Sent Events stream scoped to that request. The older HTTP+SSE transport has been deprecated since protocol version 2025-03-26.

CriterionstdioStreamable HTTP
Deploymentlocal process per usercentral service
Credentialsread from the environmentOAuth 2.1 per the spec
Typical usedevelopment, single deskdepartments, many agents
Updateson every machineonce, centrally

A simplified Streamable HTTP call, taken from the specification with _meta trimmed:

POST /mcp HTTP/1.1
Content-Type: application/json
MCP-Protocol-Version: 2026-07-28
Mcp-Method: tools/call
Mcp-Name: get_weather

{"jsonrpc": "2.0", "id": 1, "method": "tools/call",
 "params": {"name": "get_weather", "arguments": {"location": "Seattle, WA"}}}

The Mcp-Method and Mcp-Name headers mirror values from the body. Operations teams will like this: gateways, web application firewalls and monitoring can route, filter and log by tool without parsing JSON. The server must reject requests where headers and body disagree.

The specification also sets three baseline protections: validate the Origin header to block DNS rebinding, bind local servers to 127.0.0.1 rather than every network interface, and authenticate all connections.

Authentication and permissions: how does an agent sign in?

For HTTP-based servers, the specification builds on OAuth 2.1. The MCP server is a resource server; the client obtains an access token from an authorization server, typically your existing identity provider. Tokens must be issued specifically for that MCP server, and passing through tokens meant for something else is forbidden.

The authorization specification makes authorization optional overall but prescribes how it works when you implement it:

  • Discovery: MCP servers must publish OAuth 2.0 Protected Resource Metadata (RFC 9728), which tells clients which authorization server to use.
  • Audience binding: clients must use Resource Indicators (RFC 8707) to name the MCP server a token is for, and servers must check that the token was issued to them.
  • No token passthrough: servers must not accept or forward tokens issued for other resources. To reach the backend system, the server needs its own, appropriately scoped credentials.
  • Client registration: Client ID Metadata Documents are the recommended route; Dynamic Client Registration remains only for backward compatibility.
  • Step-up permissions: if a token lacks a scope, the server answers 403 and names the scopes it needs, so the client can request more rights only when a task calls for them.
  • stdio: local servers skip this flow and take credentials from the environment.

SAP states the same rule bluntly in its reference architecture for third-party MCP access to SAP solutions: an MCP server must never proxy the caller's token directly to a downstream API. SAP recommends an RFC 8693 token exchange that produces a new credential carrying the agent's identity and the user context, limited to what the specific tool needs. It also rules out plain HTTP for MCP endpoints and requires TLS 1.2 or later.

In practice, settle permissions before you write a line of code. An agent preparing quotations needs to read products and customers but should never be able to change pricing terms. Enforce that split through scopes and through how you cut the tools, not through instructions in a prompt.

Which MCP servers exist for SAP, Microsoft and CRM systems?

Several large vendors now ship MCP servers or tooling to generate them. Maturity, tool coverage and pricing vary a lot, and tool names and licence terms are changing quickly. Treat the summary below as a starting point and confirm the details in each vendor's current documentation.

Microsoft Dataverse and Dynamics 365. Microsoft Learn documents Dataverse as an MCP server at https://{dataverseOrgName}.crm.dynamics.com/api/mcp. Alongside Copilot Studio, Microsoft explicitly lists non-Microsoft clients such as Claude Desktop and Claude Code. Tools include search_data, read_query for Dataverse SQL SELECT statements, create_record and update_record; deleting rows or tables happens only after explicit user approval. Budget for usage: since 15 December 2025, Dataverse MCP tools are charged when agents built outside Copilot Studio call them, with exemptions Microsoft lists for certain Dynamics 365 Premium and Microsoft 365 Copilot licences. Microsoft also renamed several tools recently, so any allow or deny lists keyed by tool name need reviewing.

SAP. The SAP reference architecture describes two patterns: a third-party MCP server calling SAP APIs from outside SAP BTP, and a custom server running on BTP (Cloud Foundry, Kyma or a container workload). It names the MCP Gateway in SAP Integration Suite for creating, managing and exposing MCP servers, and Joule Studio, which can generate MCP servers for SAP business capabilities. SAP also cautions that hosting on BTP does not automatically give you governance.

Salesforce. According to the official repository, Salesforce's hosted MCP servers are generally available. They let MCP-compatible assistants connect securely to Salesforce logic and assets, and administrators can enable servers, create custom ones and attach APIs and Flows in Setup.

HubSpot. HubSpot's developer documentation describes a publicly hosted remote server at https://mcp.hubspot.com. It uses OAuth and lets an agent read, create and update CRM records such as contacts, companies, deals and tickets.

Directories. The official MCP Registry collects metadata for publicly reachable servers and is still in preview. It verifies who publishes under a namespace (a domain or GitHub account) but leaves code security scanning to package registries and downstream marketplaces. It does not accept private servers; the project suggests running your own internal registry for those.

For systems without a vendor server, such as an industry-specific ERP, a document management system or an in-house database, you build your own. Official SDKs are rated Tier 1 for TypeScript, Python, C#, Go, Rust and Ruby, Tier 2 for Java and Tier 3 for Swift, PHP and Kotlin. To see how such connections feed business-specific agents, look at AI agents for sales and AI agents for knowledge management.

Prerequisites: what do you need in place?

You need a target system with a documented API, an identity provider that supports OAuth 2.1, an MCP-capable client and a clearly scoped business use case. No agent should touch production data until permissions are settled and someone owns the server.

In more detail:

  • An API to wrap: the MCP server translates tool calls into API calls. If a legacy in-house application has no API, create one first, for example via a database view or an integration platform.
  • Identity and access: an identity provider that issues audience-bound tokens, and a role model defining which agent may do what on whose behalf.
  • Data quality: an agent can only find what is well maintained. Duplicate customer records or inconsistent product names will not be fixed by MCP; they will just become more visible.
  • Operations: hosting (own data centre, cloud or vendor-hosted), logging of every tool call, monitoring and a named owner.
  • Governance: bring in your data protection and information security leads early, and staff representatives where your jurisdiction requires it. An MCP deployment can be operated in line with the GDPR when data flows, storage locations and model providers are documented; that is orientation, not legal advice.

If data must stay in-house, the model matters as much as the server. A locally hosted MCP server achieves little if results are then sent to an arbitrary cloud model. Our page on sovereign AI covers that side.

Step by step: from use case to production server

Start with one narrow use case and a handful of mostly read-only tools. Check whether the vendor already offers a server. Build permissions, logging and approvals in from day one, test with real cases, and add write tools only once read access runs reliably.

  1. Pick the use case. For example: "the agent answers delivery status questions from the sales order and delivery note." That defines which data you need and which you do not.
  2. Check for existing servers. Read vendor documentation and directories. A vendor server saves build effort but brings its own tool design, licence model and release cycle.
  3. Design the tools. A few business-named tools (get_delivery_status) beat a generic pass-through to the whole API. Keep input schemas tight and define output schemas.
  4. Choose transport and sign-in. For shared use, Streamable HTTP with OAuth 2.1 and audience binding, plus a token exchange to the backend instead of passthrough.
  5. Add approvals. Write and delete actions only after a human confirms, following the human-in-the-loop principle. The tools specification says there should always be a human in the loop able to deny tool invocations.
  6. Log and test. Record user, tool, parameters and result for every call. Test with real cases, including messy and incorrect ones.
  7. Extend gradually. Add write tools only once read-only operation is stable, each behind its own scope.

Limits and risks: what can go wrong?

MCP standardises the connection, not the security. The main risks are over-broad permissions, tool descriptions or returned data that steer the model into unintended actions, and poorly isolated local servers. The specification itself says it cannot enforce its security principles at the protocol level.

The specification and the security best practices highlight:

  • Tools are code execution. Tool descriptions and annotations must be treated as untrusted unless they come from a trusted server. A third-party server can describe itself as more harmless than it is.
  • Results flow into the model. Whatever a tool returns becomes context for the model. Clients should validate results before passing them on, show tool inputs to the user before calling and log tool usage.
  • Confused deputy. MCP servers acting as proxies to third-party APIs can be abused to redirect authorization codes to an attacker unless they collect per-client consent and match redirect URIs exactly.
  • Token passthrough. Forwarding unchecked tokens bypasses downstream controls and destroys the audit trail of who did what.
  • Local servers. A locally launched server runs with the user's privileges. The guidance names malicious startup commands and unprotected servers on localhost as concrete attack paths.
  • Broad scopes. A stolen token with full access exposes every connected function. Start with a minimal scope set and elevate on demand.
  • Moving target. The specification changed substantially in 2026, and vendor servers rename tools and adjust billing. Plan for maintenance.

When MCP is the wrong tool: a fixed, repeatable sync between two systems is simpler and easier to audit as a conventional integration. MCP earns its keep when an agent has to decide, case by case, which information or action it needs.

How do I get started?

Pick a process with real lookup effort and mostly read access, such as order status queries or searching technical documentation. Check whether your system already has a vendor MCP server, then run a pilot with a few tools, clear permissions and complete logging.

A practical sequence for the first weeks:

  • Inventory: which systems have an API, which already have an MCP server, and which identity provider you run.
  • Pilot on a vendor server: where one exists, for example Dataverse, Salesforce or HubSpot, start there. You learn sign-in, approvals and costs before building anything.
  • Own server for the core system: for ERP or line-of-business applications without a vendor offering, build a narrow server with an official SDK.
  • Write the rules down: which tools may run without confirmation, which need approval, and who reviews the logs.

To see which business agents build on connections like these, such as quotation agents or technical service agents, start with the AI agents overview.

Frequently asked questions

Do I need a separate MCP server for every system?

Usually yes: one server wraps one system or business domain. An agent can use several servers at once, and gateways can put many servers behind a single endpoint.

Does MCP replace our REST APIs?

No. An MCP server normally calls those APIs behind the scenes. MCP only standardises how an agent discovers the available tools, calls them and receives the results.

Which languages can I build an MCP server in?

Official SDKs exist for TypeScript, Python, C#, Go, Rust, Ruby and Java, among others. Check first whether your vendor already ships a server.

What changed in the 28 July 2026 specification?

MCP became stateless: the initialize handshake and protocol-level sessions are gone, and every request carries its own version and capabilities. Clients can still fall back to older servers.

Can MCP run entirely on our own infrastructure?

Yes. Locally over stdio or in your own data centre over Streamable HTTP. Where the connected system and the language model run matters just as much as where the server runs.

Sources

  1. Model Context Protocol – Specification (Revision 2026-07-28) modelcontextprotocol.io
  2. MCP Specification 2026-07-28 – Key Changes modelcontextprotocol.io
  3. MCP Specification – Transports modelcontextprotocol.io
  4. MCP Specification – Streamable HTTP modelcontextprotocol.io
  5. MCP Specification – Authorization modelcontextprotocol.io
  6. MCP Specification – Tools modelcontextprotocol.io
  7. MCP – Security Best Practices modelcontextprotocol.io
  8. MCP – Official SDKs modelcontextprotocol.io
  9. The MCP Registry modelcontextprotocol.io
  10. Microsoft Learn – Connect to Dataverse with model context protocol (MCP) learn.microsoft.com
  11. SAP Architecture Center – Third-Party MCP Server Access to SAP Solutions on BTP architecture.learning.sap.com
  12. Salesforce Hosted MCP Servers (GitHub) github.com
  13. HubSpot Developers – Remote MCP server developers.hubspot.com