Zo bouw je een MCP-server in 2026: een praktische gids voor developers

Een MCP-server is een klein programma dat jouw tools, data en prompts beschikbaar stelt aan een AI-model via het Model Context Protocol, de open standaard die Anthropic in november 2024 introduceerde en die inmiddels wordt ondersteund door Claude, ChatGPT, Cursor en de meeste agent-frameworks. Als je weet hoe je een MCP-server bouwt, koppel je elke API, database of intern script binnen ruim minder dan een uur aan een AI-agent. Deze gids loopt het hele traject door: het kiezen van een SDK, het definiëren van een tool, het kiezen van een transport, lokaal testen en de koppeling met een echte client, plus de beveiligingsfouten waardoor servers worden overgenomen.

Wij bouwen TechRiseUps met Claude Code, en juist deze research-run bereikt DataForSEO via een MCP-server. De workflow hieronder is dus degene die we daadwerkelijk draaien, geen theoretisch schetsje op een whiteboard.

Wat is een MCP-server, en moet je er zelf een bouwen?

Een MCP-server is een proces dat één JSON-RPC-protocol spreekt met elke MCP-compatibele client (de "host", zoals Claude Code of Claude Desktop). Hij adverteert drie soorten capaciteiten: tools (functies die het model kan aanroepen, met goedkeuring van de gebruiker), resources (alleen-lezen data die het model als context kan ophalen) en prompts (herbruikbare templates). De client ontdekt die via de verbinding, waardoor één server werkt op elke host zonder aangepaste lijmlaag.

Controleer, voordat je ook maar één regel code schrijft, of je eigenlijk wel een eigen server nodig hebt. Er zijn duizenden gepubliceerde servers voor GitHub, Postgres, Slack, bestandssystemen en meer; als er al een bestaat voor jouw systeem, installeer die dan in plaats van er zelf een te bouwen. Bouw je eigen server wanneer je een privé-API, een intern hulpmiddel of maatwerk-bedrijfslogica verpakt die geen enkele publieke server dekt. Dat is eerlijk gezegd het 80%-geval, en daar richt deze gids zich op.

Wat je nodig hebt voordat je begint

De vereisten zijn licht, en juist daarom verspreidde MCP zich zo snel. Je hebt een runtime nodig voor de SDK die je kiest, een MCP-compatibele client om tegenaan te testen, en het officiële SDK-pakket. Voor lokale ontwikkeling hoeft niets openbaar of gehost te zijn.

• Een runtime: Python 3.10+ (met uv aanbevolen) of Node.js 18+ voor TypeScript.
• Een client: Claude Desktop, Claude Code, Cursor of de losstaande MCP Inspector zijn allemaal prima.
• De SDK: mcp[cli] voor Python of @modelcontextprotocol/sdk voor TypeScript, beide onderhouden door het protocol-team.
• Een API of gegevensbron om beschikbaar te stellen. Een lokale stdio-server heeft geen domein, geen TLS en geen open poort nodig; hosting speelt pas een rol zodra je remote gaat (verderop behandeld).

Kies je SDK: Python (FastMCP) versus TypeScript

Beide officiële SDK's hebben dezelfde functionaliteit, dus kies op basis van waar je integratie al leeft. De FastMCP-laag van Python is het snelste pad van idee naar draaiende server; TypeScript is de logische keuze als je tooling al in Node draait.

	Python	TypeScript
Pakket	mcp[cli] (python-sdk)	@modelcontextprotocol/sdk (typescript-sdk)
Server-klasse	FastMCP	McpServer
Een tool definiëren	@mcp.tool-decorator	server.registerTool() / server.tool()
Validatie	type hints	Zod-schema
Beste voor	data-/ML-stacks, snelste start	JS/TS-codebases, webapps

Heb je geen bestaande stack om op aan te sluiten, begin dan met Python en FastMCP. Een tool is niet meer dan een gedecoreerde functie, dus als je een Python-functie kunt schrijven, kun je een server uitrollen.

Bouw een minimale server: definieer één tool

Het kernwerk is het registreren van een tool: een naam, een input-schema en een async-functie die iets doet en tekst teruggeeft. Hier is een complete Python-server die één enkele get_weather-tool beschikbaar stelt.

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("weather")

@mcp.tool()
async def get_weather(city: str) -> str:
    """Return the current weather for a city."""
    # call your real API here
    return f"It's 21C and clear in {city}."

if __name__ == "__main__":
    mcp.run(transport="stdio")

De TypeScript-vorm is hetzelfde idee met een Zod-schema voor de input, een McpServer-instantie en server.registerTool() die een content-array van { type: "text", text } teruggeeft. In beide SDK's is de docstring/beschrijving datgene wat het model leest om te beslissen wanneer het de tool aanroept, dus schrijf hem als een prompt, niet als een code-commentaar. Vage beschrijvingen zijn de nummer-éénreden waarom een werkende tool nooit wordt aangeroepen.

Kies een transport: stdio versus Streamable HTTP

MCP definieert twee transporten, en die keuze bepaalt waar je server kan draaien. Zorg dat je dit vroeg goed doet, want het bepaalt de deployment.

• stdio start de server als een lokaal subproces en communiceert via stdin/stdout. Het is de standaard, heeft geen netwerk nodig en is de juiste keuze voor alles wat lokale bestanden, lokale databases of de eigen machine van een developer raakt. Elke quickstart gebruikt het.
• Streamable HTTP (dat in de spec-revisie van 2025 het oudere HTTP+SSE-transport verving) draait de server als een webservice die andere machines kunnen bereiken. Gebruik het voor een gedeelde teamserver of een gehoste integratie. Dit is het enige geval waarin "hosting-vereisten" van toepassing zijn: een publieke URL, TLS en authenticatie.

Vuistregel: bouw en test op stdio, en stap pas over op Streamable HTTP zodra meer dan één persoon of machine de server nodig heeft.

Test met MCP Inspector voordat je een client koppelt

Debug een nieuwe server niet via een chatvenster. De MCP Inspector is een browsertool die rechtstreeks met je server verbindt, de tools en resources opsomt en je elke tool met willekeurige invoer laat aanroepen, zodat je de ruwe respons ziet in plaats van de parafrase van een model.

npx @modelcontextprotocol/inspector
# opens a local UI (default http://localhost:6274)

Wijs hem naar je commando (voor een stdio-server is dat de interpreter plus je script), bevestig dat elke tool verschijnt met het schema dat je verwacht, en roep hem aan. Als een tool hier een fout geeft, doet hij dat ook binnen Claude, alleen met minder duidelijkheid. Deze ene gewoonte haalt het grootste deel van de frustratie "mijn server werkt niet" weg.

Koppel hem aan Claude Code, Claude Desktop of Cursor

Zodra de Inspector tevreden is, registreer je de server bij een client via een kleine JSON-config. Elke host leest zijn eigen bestand, maar de vorm is identiek: een commando, de bijbehorende argumenten en eventuele secrets als omgevingsvariabelen.

{
  "mcpServers": {
    "weather": {
      "command": "uv",
      "args": ["run", "python", "/full/path/to/server.py"],
      "env": { "WEATHER_API_KEY": "..." }
    }
  }
}

Claude Code leest .mcp.json in je project (of claude mcp add), Claude Desktop leest claude_desktop_config.json, en Cursor gebruikt zijn Tools & Integrations-paneel. Herstart de host, en de tool verschijnt klaar om aan te roepen. Ben je nieuw in het hele model, dan behandelt onze begrijpelijke gids voor MCP-servers de concepten die deze how-to als bekend veronderstelt.

Een remote MCP-server uitrollen op een VPS

Om een server met een team te delen of te koppelen aan een cloud-agent, draai je hem als een Streamable HTTP-service op een kleine VPS. De servercode verandert nauwelijks; je vervangt het stdio-transport door HTTP en zet hem achter een reverse proxy. Wat wel verandert, is de operationele checklist: een domein, een TLS-certificaat, een procesbeheerder zodat hij herstart bij een reboot, en, cruciaal, authenticatie, want een publiek MCP-endpoint is een publieke toegangspoort tot alles wat het verpakt.

Een instance van €4–5/maand is ruim voldoende voor de meeste interne servers; wij draaien onze eigen infrastructuur op WaseerHost voor precies dit soort altijd-actieve nevenservices. De werking van de machine, firewall en TLS is dezelfde als bij elke kleine deployment, en onze veilige eerste uur-VPS-setup loopt dat gedeelte van begin tot eind door. Stel een remote server nooit bloot zonder een auth-laag ervoor.

Beveiliging: de fouten waardoor MCP-servers worden overgenomen

MCP geeft een taalmodel de mogelijkheid om jouw code uit te voeren, dus behandel elke tool als een aanvalsoppervlak. De faalpatronen zijn saai consistent:

• Geen input-validatie. Zod-schema's en Python type hints zijn geen versiering. Een tool die model-output rechtstreeks doorgeeft aan een shell-commando of SQL-string is een pipeline van prompt-injectie naar RCE.
• Te brede tools. Één enkele run_command-tool is handig én gevaarlijk. Stel smalle, specifieke capaciteiten beschikbaar, geen algemene ontsnappingsroute.
• Secrets in de config. Bewaar API-sleutels in omgevingsvariabelen, nooit hardcoded, en beperk ze tot het minimum dat de tool nodig heeft.
• Niet-geauthenticeerde remote servers. Een publiek Streamable HTTP-endpoint zonder auth is een open deur; vereis een token en beperk de rate.

Prompt-injectie maakt dit scherper dan een normale API: de "gebruiker" die je tool aanroept kan een model zijn dat werd gemanipuleerd door niet-vertrouwde content. Die dreiging behandelden we diepgaand in AI-agentbeveiliging en de prompt-injectiecrisis. Ga ervan uit dat tool-input vijandig is, en je ontloopt het ergste ervan.

Veelgestelde vragen

Kan ik zelf een MCP-server bouwen?

Ja, en het is bewust makkelijk gemaakt. Met de officiële Python- of TypeScript-SDK is een werkende server die één tool beschikbaar stelt een kwestie van een paar dozijn regels en draait hij lokaal zonder hosting. Bouw er een wanneer je een privé-API of intern hulpmiddel moet blootstellen dat geen enkele publieke server al dekt.

Wat zijn de vereisten om een MCP-server te hosten?

Voor lokaal gebruik (stdio-transport) zijn er geen, afgezien van de runtime; de server verlaat je machine nooit. Hosting speelt alleen een rol bij een remote Streamable HTTP-server, die een publieke URL, een TLS-certificaat, een procesbeheerder en authenticatie nodig heeft. Een kleine VPS handelt dat comfortabel af.

Wat is het populairste type MCP-server?

Lokale stdio-servers domineren het dagelijkse developer-gebruik omdat ze de standaard zijn en geen infrastructuur nodig hebben. Tools zijn veruit de meestgebruikte capaciteit, vóór resources en prompts, aangezien het model actie laten ondernemen de belangrijkste aantrekkingskracht is.

Hoe lang duurt het om er een te bouwen?

Een minimale server met één tool is een klus van 15–30 minuten met beide SDK's. De meeste echte tijd gaat op aan de onderliggende integratie (de API of database die je verpakt) en aan het schrijven van heldere tool-beschrijvingen, niet aan MCP zelf.

Sources

• Model Context Protocol — Build an MCP server (officiële tutorial): kernconcepten, de quickstart met de weer-server en transport-opties.
• modelcontextprotocol/python-sdk (GitHub): de officiële Python-SDK en de FastMCP-API.
• modelcontextprotocol/typescript-sdk (GitHub): de officiële TypeScript-SDK, McpServer en tool-registratie.
• freeCodeCamp — How to build a custom MCP server with TypeScript: een volledige TypeScript-doorloop met Zod-validatie en client-config.
• The Pragmatic Engineer — Building MCP servers in the real world: praktische lessen en afwegingen uit MCP-werk in productie.
• MCP Inspector (GitHub): de browsergebaseerde tool om servers te testen voordat je een client koppelt.