MCP-servers uitgelegd: het protocol dat AI met alles verbindt

Imagine if every AI tool had to build a custom integration for every service it wanted to interact with. Connecting to GitHub would be one integration, Slack another, your database a third, and your internal APIs yet another. That fragmentation was the reality of AI tooling until Anthropic introduced the Model Context Protocol, or MCP. Now, MCP is rapidly becoming the universal standard for connecting AI agents to external systems, and it is changing how we think about AI capabilities.

What Is MCP?

MCP, the Model Context Protocol, is an open standard that defines how AI models communicate with external tools and data sources. Think of it like USB-C for AI: a single, standardized connection that works with everything. Instead of each AI tool building bespoke integrations, MCP provides a common protocol that any tool can use to connect to any service that runs an MCP server.

The architecture is straightforward. An MCP server is a lightweight program that exposes specific capabilities, like reading files from a GitHub repository, querying a PostgreSQL database, or sending messages in Slack, through a standardized interface. An MCP client, which is the AI tool like Claude Code, Cursor, or any compatible application, connects to these servers and uses their capabilities as part of its workflow. The protocol handles the communication, authentication, and capability discovery automatically.

Wil je deze tool zelf uitproberen? Try Claude Code

How MCP Servers Work

An MCP server exposes three types of primitives to AI clients. Tools are functions the AI can call, like "create a GitHub issue" or "run a SQL query." Resources are data the AI can read, like a file listing or database schema. Prompts are reusable templates that help the AI interact with the service more effectively. When an AI client connects to an MCP server, it first discovers what capabilities are available, then uses them as needed during its workflow.

The communication happens over standard transport mechanisms. For local development, MCP typically uses stdio, where the AI tool launches the MCP server as a subprocess and communicates through standard input and output. For remote servers, it uses server-sent events over HTTP, allowing MCP servers to run on remote machines or in the cloud. This flexibility means you can run MCP servers locally for development and deploy them to a server for production use.

Real-World MCP Server Examples

The MCP ecosystem has grown rapidly, with servers available for dozens of popular services. Here are some of the most useful ones.

Setting Up Your First MCP Server

Getting started with MCP is simpler than you might expect. Here is how to set up the GitHub MCP server with Claude Code as an example.

First, you need to configure Claude Code to know about the MCP server. This is done through a configuration file that specifies which MCP servers to connect to and how to launch them. You add an entry that tells Claude Code to run the GitHub MCP server using npx, and you pass your GitHub personal access token as an environment variable.

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token-here"
      }
    }
  }
}

Once configured, Claude Code automatically launches the GitHub MCP server when it starts. Now you can say things like "look at the open issues in my project repo and create a branch for issue #42" and Claude Code will use the MCP server to interact with GitHub directly. No copying and pasting URLs, no switching to the browser, no manual git commands.

Building Your Own MCP Server

One of MCP's strengths is how easy it is to build custom servers for your own tools and services. Anthropic provides SDKs in TypeScript and Python that handle the protocol layer, so you only need to define the tools, resources, and prompts your server exposes. A basic MCP server in TypeScript might be only 50 to 100 lines of code.

Common use cases for custom MCP servers include connecting AI tools to your company's internal APIs, exposing a proprietary database with semantic search capabilities, integrating with your CI/CD pipeline to let AI trigger deployments, and building bridges to legacy systems that your team interacts with frequently. The investment in building a custom server pays off quickly because every AI tool that supports MCP can immediately use it.

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({
  name: "my-custom-server",
  version: "1.0.0",
});

server.tool(
  "get-user",
  "Look up a user by email address",
  { email: z.string().email() },
  async ({ email }) => {
    const user = await db.users.findByEmail(email);
    return {
      content: [
        { type: "text", text: JSON.stringify(user, null, 2) },
      ],
    };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

The MCP Ecosystem in 2025

The MCP ecosystem is maturing quickly. Anthropic maintains the core specification and reference servers, but the community has built hundreds of additional servers covering everything from Jira and Linear to AWS services and Kubernetes clusters. Several companies have started offering hosted MCP servers as a service, handling authentication and scaling so teams do not need to manage the infrastructure themselves.

On the client side, support has expanded well beyond Claude Code. Cursor supports MCP servers natively, letting you use the same servers from within the IDE. Windsurf, Cline, and several other AI coding tools have added MCP support. Even non-coding AI tools are adopting the protocol, making it useful for writing assistants, data analysis tools, and business automation platforms.

Why MCP Matters for the Future of AI

MCP matters because it solves the N-times-M integration problem. Without a standard protocol, every AI tool needs to build custom integrations for every service, which does not scale. With MCP, a service builds one server and every compatible AI tool can use it. An AI tool supports MCP once and gains access to every server in the ecosystem. This network effect is powerful: the more servers that exist, the more valuable MCP-compatible tools become, which drives more tool makers to support MCP, which incentivizes more server development.

For developers and teams, MCP unlocks a future where your AI tools are not isolated assistants but connected agents that can interact with your entire toolchain. Code in your editor, issues in your project tracker, data in your database, messages in your team chat, and deployments in your infrastructure, all accessible through a single AI interface. That future is not theoretical. It is available today for anyone willing to set up a few MCP servers.