Een MCP-server implementeren in productie
Op deze pagina
Update 2 november 2026 — Le Chat is nu Vibe. Sinds 28 mei 2026 is Le Chat omgedoopt tot Vibe (nog steeds op chat.mistral.ai): een enkele agent voor werk en code, die uw gesprekken, instellingen en abonnementen overneemt. De legacy Le Chat-ervaring blijft toegankelijk in de modus Chat; in de modus Werk zijn agents nu vaardigheden (aangeroepen met
@), vormen herinneringen de kennisbank en is diepgaand onderzoek de vaardigheid Deep Research. Abonnementen heten nu Mistral Free, Pro, Team en Enterprise. Deze les gebruikt de naam Vibe; sommige hier beschreven menu’s kunnen van naam of locatie zijn veranderd.
Update 2 november 2026 — MCP Python SDK v2. Deze cursus volgt nu versie 2 van de
mcpSDK (2.3.0 per 2 oktober 2026):MCPServervervangtFastMCP, transportinstellingen verhuizen naarrun()ofstreamable_http_app(), en een app die onder een echte hostnaam wordt blootgesteld, moet die hostnaam declareren (transport_security). Dit is ook de versie die vereist is door de Mistral SDK: demistralai[agents]extra vereistmcp>=2.2.0,<3.0. Bronnen: Wat is nieuw in v2 · Migratiegids · Implementeren & schalen.
Van prototype naar productieserver
Uw server draait lokaal en ngrok stelt deze slechts voor een demo bloot aan de wereld. Het probleem begint wanneer iemand anders deze moet gebruiken: u sluit uw terminal, de URL sterft af en elke connector die uw collega’s hebben geconfigureerd, werkt niet meer. Naar productie gaan betekent in wezen het verkrijgen van een stabiel adres, 24/7 beschikbaar, bediend via HTTPS. Vier opties brengen u daar, variërend van de snelste tot de meest gecontroleerde. Uw keuze hangt voornamelijk af van hoe gevoelig uw data is en hoeveel controle u over de infrastructuur wilt hebben.
Optie 1: Hugging Face Spaces
Hugging Face Spaces biedt gratis virtuele machines zonder GPU’s, wat meer dan voldoende is voor een MCP-server die API-aanroepen doorgeeft. Dit is de snelste weg naar een echte implementatie: drie bestanden en een git push.
mon-mcp-space/
├── app.py # FastAPI + MCP server
├── requirements.txt # Dependencies
└── README.md # Space metadata
Het bestand app.py volgt exact de structuur die u tot nu toe heeft gezien, behalve dat gevoelige waarden uit de omgeving worden gelezen—HF Secrets injecteren ze daar:
# app.py
"""MCP server deployed on Hugging Face Spaces."""
import os
from contextlib import asynccontextmanager
from fastapi import FastAPI
from mcp.server.mcpserver import MCPServer
from mcp.server.transport_security import TransportSecuritySettings
mcp = MCPServer("My Production Server")
@mcp.tool()
def hello(name: str) -> str:
"""Greet a person.
Args:
name: The person's first name
Returns:
Greeting message
"""
return f"Hello {name} from Hugging Face Spaces!"
@asynccontextmanager
async def lifespan(app: FastAPI):
async with mcp.session_manager.run():
yield
# Space hostname, in the form <user>-<space>.hf.space
SPACE_HOST = os.environ.get("MCP_PUBLIC_HOST", "localhost")
security = TransportSecuritySettings(allowed_hosts=[SPACE_HOST, f"{SPACE_HOST}:*"])
api = FastAPI(lifespan=lifespan)
api.mount("/mcp-endpoint", mcp.streamable_http_app(transport_security=security))
# For sensitive variables, use HF Secrets
API_KEY = os.environ.get("MY_API_KEY", "")
De eigenaardigheid van het platform zit in de README, waarvan de YAML-header de Space-build aanstuurt. Het veld app_port moet overeenkomen met de poort waarop uw server daadwerkelijk luistert; anders slaagt de implementatie wel, maar blijft deze ontoegankelijk:
---
title: My MCP Server
emoji: 🔧
colorFrom: blue
colorTo: green
sdk: docker
app_port: 7860
---
# Create a Space on huggingface.co
# Push the code
git push
# The Space deploys automatically
Uw eindpunt wordt dan https://your-username-mon-mcp-space.hf.space/mcp-endpoint/mcp, bediend via HTTPS. Er resteert nog één configuratiestap: declareer deze hostnaam, your-username-mon-mcp-space.hf.space, in de variabele MCP_PUBLIC_HOST in de Space-instellingen. Zonder dit wijst de SDK elk verzoek af met een 421 Invalid Host header-fout.
Optie 2: Docker
Zodra de server interne data aanraakt, wordt hosting op uw eigen infrastructuur de regel en is Docker het standaardformaat. Het Dockerfile vereist slechts enkele instructies, waarbij de installatie van afhankelijkheden vóór het kopiëren van de code wordt geplaatst om laag-caching tijdens herbouwen te benutten:
FROM python:3.12-slim
WORKDIR /app
# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Copy code
COPY . .
# Expose port
EXPOSE 8000
# Start server
CMD ["uvicorn", "server:api", "--host", "0.0.0.0", "--port", "8000"]
fastapi>=0.115.0
uvicorn>=0.30.0
mcp>=2.2,<3
httpx>=0.27.0 # only if your tools use it: SDK v2 no longer installs it
Bij het opstarten is de optie --restart unless-stopped wat een productie-implementatie onderscheidt van een simpele test: zonder dit haalt de eerste crash uw server offline totdat iemand het opmerkt.
# Build the image
docker build -t mon-mcp-server .
# Run the container
docker run -d \
--name mcp-server \
-p 8000:8000 \
-e MY_API_KEY="secret" \
-e DATABASE_URL="postgresql://..." \
--restart unless-stopped \
mon-mcp-server
Docker Compose maakt deze configuratie reproduceerbaar en voegt een health check toe, die de orchestrator gebruikt om een bevroren server te detecteren—een levend proces dat niet meer reageert is een scenario dat simpele automatische herstarts niet afdekken:
# docker-compose.yml
version: "3.8"
services:
mcp-server:
build: .
ports:
- "8000:8000"
environment:
- MY_API_KEY=${MY_API_KEY}
- DATABASE_URL=${DATABASE_URL}
restart: unless-stopped
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8000/"]
interval: 30s
retries: 3
Opties 3 en 4: Beheerde implementaties
Prefect Horizon (voorheen FastMCP Cloud), het platform van het team achter het onafhankelijke FastMCP-framework, verwijdert de infrastructuurstap: u logt in op horizon.prefect.io met uw GitHub-account, kiest de repository en het serverbestand, en het platform bouwt en publiceert een URL met ingebouwde authenticatie. Het richt zich op servers geschreven met dat framework (pip install fastmcp, from fastmcp import FastMCP), wat verschilt van de officiële SDK die in deze cursus wordt gebruikt; er bestaat een gratis tier voor persoonlijke projecten.
Cloudflare Workers richt zich op een ander gebruiksprofiel: serverless, met uitvoering zo dicht mogelijk bij de gebruiker en dus verminderde latentie. Een toegewijd sjabloon zet het project in gang:
# Use Cloudflare's MCP template
npm create cloudflare@latest -- remote-mcp-server-authless --template=cloudflare/ai/demos/remote-mcp-authless
Beide opties besparen u het beheer van certificaten en herstarts, ten koste van platformafhankelijkheid en uitvoeringsbeperkingen—een serverless Worker bijvoorbeeld, past niet goed bij een stateful server.
De implementatie beveiligen
HTTPS is niet onderhandelbaar: Vibe weigert platte tekst-eindpunten en een token dat over HTTP reist, is een gecompromitteerd token. Drie wegen leiden daarheen, afhankelijk van uw hosting. Een reverse proxy zoals Nginx of Caddy voor uw server, met een Let’s Encrypt-certificaat, dekt het geval van een dedicated server. Cloud-native platforms—Hugging Face, Cloudflare en de meeste PaaS-aanbieders—leveren HTTPS automatisch. Een tunnel, zoals Cloudflare Tunnel, stelt een server die op uw interne netwerk blijft bloot zonder poorten te openen.
Geen enkel geheim mag in de code verschijnen. Let op het onderscheid tussen de twee onderstaande syntaxen: os.environ["MCP_API_TOKEN"] zorgt ervoor dat het opstarten faalt als de variabele ontbreekt, wat precies het gewenste gedrag is voor een verplicht geheim, terwijl os.environ.get() afwezigheid tolereert voor optionele waarden.
import os
# Configuration via environment variables
API_TOKEN = os.environ["MCP_API_TOKEN"] # Mandatory
DATABASE_URL = os.environ.get("DATABASE_URL") # Optional
DEBUG = os.environ.get("DEBUG", "false") == "true"
Een openbare server zonder rate limiting raakt uiteindelijk verzadigd, vrijwillig of niet. Een IP-gebaseerde limiter volstaat in de meeste gevallen:
from fastapi import FastAPI, Request
from slowapi import Limiter, _rate_limit_exceeded_handler
limiter = Limiter(key_func=lambda request: request.client.host)
api = FastAPI()
api.state.limiter = limiter
@api.middleware("http")
async def rate_limit(request: Request, call_next):
# 100 requests per minute per IP
...
Zien wat er gebeurt
In productie heeft u uw terminal niet meer voor u staan en kan een tool die één op de tien keer faalt, alleen met traces worden gediagnosticeerd. Instrumenteer op zijn minst de input, output en duur van elke oproep:
import logging
import time
logger = logging.getLogger("mcp-server")
@mcp.tool()
async def my_tool(param: str) -> str:
"""My tool with logging."""
start = time.time()
logger.info(f"Tool called with param={param}")
try:
result = await process(param)
duration = time.time() - start
logger.info(f"Tool finished in {duration:.2f}s")
return result
except Exception as e:
logger.error(f"Error in tool: {e}")
raise
Het meten van de duur is geen luxe: een tool die twaalf seconden nodig heeft om te reageren, activeert client-side timeouts en wekt de indruk van een kapotte server terwijl deze eigenlijk werkt. Voordat u uw server aankondigt, bekijk de volgende zes configuratiepunten.
- HTTPS actief en geldig certificaat
- Omgevingsvariabelen voor alle geheimen
- Gestructureerde logging ingeschakeld
- Health check-eindpunt (
/of/health) - Automatische herstart bij crash
- Rate limiting geconfigureerd
Twee controles resteren, die mensen het vaakst overslaan maar die de echte problemen onthullen: een test met MCP Inspector gestart van buitenaf, gevolgd door een test vanuit Mistral Vibe. Een server die perfect reageert vanaf uw machine, kan geblokkeerd worden door een firewall of CORS-configuratie zodra deze vanaf elders wordt aangeroepen.
Belangrijkste punten
- Hugging Face Spaces: snelst, gratis, ideaal om mee te beginnen
- Docker: totale controle, geschikt voor dedicated servers en cloud
- Prefect Horizon (ex-FastMCP Cloud): implementatie vanuit GitHub, voor servers geschreven met het FastMCP-framework
- Cloudflare Workers: serverless, lage latentie, schaalbaar
- Beveilig met HTTPS, omgevingsvariabelen en rate limiting
- Voeg monitoring en logs toe voor debugging in productie