# MCP Servers: Connecting AI Agents to Systems the Standard Way

> An MCP server exposes a system's data and functions as standard tools that any MCP-compatible AI agent can discover and call. In a company it usually runs remotely over Streamable HTTP, protected by OAuth 2.1, narrowly scoped permissions and human approval for write actions.

Canonical URL: https://www.ruebstudio.de/en/guides/ai-agent-integrations/mcp-servers-connect-ai-agents  
Author: Dr.-Ing. Marcus Rüb, CEO  
Published: 2026-10-23

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](https://modelcontextprotocol.io/specification/latest) 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](https://www.ruebstudio.de/en/ai-agents). For a short definition of the protocol itself, the glossary entry on [Model Context Protocol (MCP)](https://www.ruebstudio.de/en/glossary/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](https://modelcontextprotocol.io/specification/latest), servers can offer three kinds of capability:

| Building block | Who drives it | Enterprise example |
|---|---|---|
| Tools | the language model | `create_ticket`, `read_query`, `update_record` |
| Resources | the user or the model | product manual, config file, record |
| Prompts | the 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](https://www.ruebstudio.de/en/glossary/tool-use-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](https://modelcontextprotocol.io/specification/2026-07-28/server/tools)). 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](https://modelcontextprotocol.io/specification/2026-07-28/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](https://modelcontextprotocol.io/specification/latest/basic/transports) defines stdio as newline-delimited JSON-RPC over the standard streams of a client-launched process. With [Streamable HTTP](https://modelcontextprotocol.io/specification/2026-07-28/basic/transports/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.

| Criterion | stdio | Streamable HTTP |
|---|---|---|
| Deployment | local process per user | central service |
| Credentials | read from the environment | OAuth 2.1 per the spec |
| Typical use | development, single desk | departments, many agents |
| Updates | on every machine | once, centrally |

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

```http
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](https://modelcontextprotocol.io/specification/latest/basic/authorization) 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](https://architecture.learning.sap.com/docs/ref-arch/137800): 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](https://learn.microsoft.com/en-us/power-apps/maker/data-platform/data-platform-mcp) 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](https://architecture.learning.sap.com/docs/ref-arch/137800) 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](https://github.com/forcedotcom/mcp-hosted), 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](https://developers.hubspot.com/docs/build-with-ai/remote-mcp-server) 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](https://modelcontextprotocol.io/registry/about) 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](https://modelcontextprotocol.io/docs/sdk) 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](https://www.ruebstudio.de/en/ai-agents/sales) and [AI agents for knowledge management](https://www.ruebstudio.de/en/ai-agents/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](https://www.ruebstudio.de/en/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](https://www.ruebstudio.de/en/glossary/human-in-the-loop) principle. The [tools specification](https://modelcontextprotocol.io/specification/2026-07-28/server/tools) 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](https://modelcontextprotocol.io/specification/latest) and the [security best practices](https://modelcontextprotocol.io/docs/tutorials/security/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](https://www.ruebstudio.de/en/ai-agents/quotation) or [technical service agents](https://www.ruebstudio.de/en/ai-agents/technical-service), start with the [AI agents overview](https://www.ruebstudio.de/en/ai-agents).

## 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

- [Model Context Protocol – Specification (Revision 2026-07-28)](https://modelcontextprotocol.io/specification/latest)
- [MCP Specification 2026-07-28 – Key Changes](https://modelcontextprotocol.io/specification/2026-07-28/changelog)
- [MCP Specification – Transports](https://modelcontextprotocol.io/specification/latest/basic/transports)
- [MCP Specification – Streamable HTTP](https://modelcontextprotocol.io/specification/2026-07-28/basic/transports/streamable-http)
- [MCP Specification – Authorization](https://modelcontextprotocol.io/specification/latest/basic/authorization)
- [MCP Specification – Tools](https://modelcontextprotocol.io/specification/2026-07-28/server/tools)
- [MCP – Security Best Practices](https://modelcontextprotocol.io/docs/tutorials/security/security_best_practices)
- [MCP – Official SDKs](https://modelcontextprotocol.io/docs/sdk)
- [The MCP Registry](https://modelcontextprotocol.io/registry/about)
- [Microsoft Learn – Connect to Dataverse with model context protocol (MCP)](https://learn.microsoft.com/en-us/power-apps/maker/data-platform/data-platform-mcp)
- [SAP Architecture Center – Third-Party MCP Server Access to SAP Solutions on BTP](https://architecture.learning.sap.com/docs/ref-arch/137800)
- [Salesforce Hosted MCP Servers (GitHub)](https://github.com/forcedotcom/mcp-hosted)
- [HubSpot Developers – Remote MCP server](https://developers.hubspot.com/docs/build-with-ai/remote-mcp-server)
