Déployer un serveur MCP en production
Pe această pagină
Mise à jour du 2 novembre 2026 — Le Chat devient Vibe. Depuis le 28 mai 2026, Le Chat a été rebaptisé Vibe (toujours sur chat.mistral.ai) : un agent unique pour le travail et le code, conservant vos conversations, paramètres et abonnements. L’expérience historique Le Chat reste accessible en mode Chat ; en mode Work, les agents sont désormais des compétences (appelées avec
@), les mémoires constituent la base de connaissances et la recherche approfondie est la compétence Deep Research. Les formules s’appellent désormais Mistral Free, Pro, Team et Enterprise. Cette leçon utilise le nom Vibe ; certains menus décrits ici peuvent avoir changé de nom ou d’emplacement.
Mise à jour du 2 novembre 2026 — MCP Python SDK v2. Ce cours suit désormais la version 2 du SDK
mcp(2.3.0 au 2 octobre 2026) :MCPServerremplaceFastMCP, les paramètres de transport sont déplacés versrun()oustreamable_http_app(), et une application exposée sous un nom d’hôte réel doit déclarer ce nom d’hôte (transport_security). C’est également la version requise par le SDK Mistral : l’extramistralai[agents]nécessitemcp>=2.2.0,<3.0. Sources : Nouveautés de la v2 · Guide de migration · Déploiement et mise à l’échelle.
Du prototype au serveur de production
Votre serveur fonctionne en local et ngrok l’expose au monde entier uniquement pour une démonstration. Le problème survient lorsqu’une autre personne doit l’utiliser : vous fermez votre terminal, l’URL disparaît et chaque connecteur configuré par vos collègues cesse de fonctionner. Passer en production signifie essentiellement obtenir une adresse stable, disponible 24h/24 et 7j/7, servie via HTTPS. Quatre options vous y mènent, de la plus rapide à la plus contrôlée. Votre choix dépend principalement de la sensibilité de vos données et du niveau de contrôle que vous souhaitez exercer sur l’infrastructure.
Option 1 : Hugging Face Spaces
Hugging Face Spaces fournit des machines virtuelles gratuites sans GPU, largement suffisantes pour un serveur MCP qui relaie des appels API. C’est le chemin le plus rapide vers un déploiement réel : trois fichiers et un git push.
mon-mcp-space/
├── app.py # FastAPI + serveur MCP
├── requirements.txt # Dépendances
└── README.md # Métadonnées du Space
Le fichier app.py suit exactement la structure que vous avez vue jusqu’à présent, sauf que les valeurs sensibles sont lues depuis l’environnement — les secrets HF les y injectent :
# app.py
"""Serveur MCP déployé sur 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("Mon Serveur de Production")
@mcp.tool()
def hello(name: str) -> str:
"""Saluer une personne.
Args:
name: Le prénom de la personne
Returns:
Message de salutation
"""
return f"Bonjour {name} depuis Hugging Face Spaces !"
@asynccontextmanager
async def lifespan(app: FastAPI):
async with mcp.session_manager.run():
yield
# Nom d'hôte du Space, sous la forme <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))
# Pour les variables sensibles, utilisez les secrets HF
API_KEY = os.environ.get("MY_API_KEY", "")
La particularité de la plateforme réside dans le README, dont l’en-tête YAML pilote la construction du Space. Le champ app_port doit correspondre au port sur lequel votre serveur écoute réellement ; sinon, le déploiement réussit mais reste inaccessible :
---
title: Mon Serveur MCP
emoji: 🔧
colorFrom: blue
colorTo: green
sdk: docker
app_port: 7860
---
# Créer un Space sur huggingface.co
# Pousser le code
git push
# Le Space se déploie automatiquement
Votre point de terminaison devient alors https://your-username-mon-mcp-space.hf.space/mcp-endpoint/mcp, servi via HTTPS. Une étape de configuration reste nécessaire : déclarer ce nom d’hôte, your-username-mon-mcp-space.hf.space, dans la variable MCP_PUBLIC_HOST des paramètres du Space. Sans cela, le SDK rejette chaque requête avec une erreur 421 Invalid Host header.
Option 2 : Docker
Dès que le serveur touche des données internes, l’hébergement sur votre propre infrastructure devient la règle, et Docker est le format standard. Le Dockerfile ne nécessite que quelques instructions, l’installation des dépendances étant placée avant la copie du code pour tirer parti de la mise en cache des couches lors des reconstructions :
FROM python:3.12-slim
WORKDIR /app
# Installer les dépendances
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Copier le code
COPY . .
# Exposer le port
EXPOSE 8000
# Démarrer le serveur
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 # uniquement si vos outils l'utilisent : le SDK v2 ne l'installe plus
Au lancement, l’option --restart unless-stopped est ce qui distingue un déploiement de production d’un simple test : sans elle, le premier plantage met votre serveur hors ligne jusqu’à ce que quelqu’un s’en aperçoive.
# Construire l'image
docker build -t mon-mcp-server .
# Lancer le conteneur
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 rend cette configuration reproductible et ajoute une vérification d’état de santé (health check), que l’orchestrateur utilise pour détecter un serveur figé — un processus actif qui ne répond plus est un scénario que les redémarrages automatiques simples ne couvrent pas :
# 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
Options 3 et 4 : Déploiements managés
Prefect Horizon (anciennement FastMCP Cloud), la plateforme de l’équipe derrière le framework indépendant FastMCP, supprime l’étape d’infrastructure : vous vous connectez sur horizon.prefect.io avec votre compte GitHub, choisissez le dépôt et le fichier serveur, et la plateforme construit et publie une URL avec authentification intégrée. Elle cible les serveurs écrits avec ce framework (pip install fastmcp, from fastmcp import FastMCP), qui est distinct du SDK officiel utilisé dans ce cours ; une offre gratuite existe pour les projets personnels.
Cloudflare Workers vise un profil d’utilisation différent : serverless, avec une exécution au plus près de l’utilisateur et donc une latence réduite. Un modèle dédié lance le projet :
# Utiliser le modèle MCP de Cloudflare
npm create cloudflare@latest -- remote-mcp-server-authless --template=cloudflare/ai/demos/remote-mcp-authless
Ces deux options vous épargnent la gestion des certificats et des redémarrages, au prix d’une dépendance à la plateforme et de contraintes d’exécution — un Worker serverless, par exemple, ne s’accorde pas bien avec un serveur avec état.
Sécuriser le déploiement
HTTPS est non négociable : Vibe refuse les points de terminaison en clair, et un jeton voyageant en HTTP est un jeton compromis. Trois voies y mènent selon votre hébergement. Un proxy inverse comme Nginx ou Caddy placé devant votre serveur, avec un certificat Let’s Encrypt, couvre le cas du serveur dédié. Les plateformes cloud-natives — Hugging Face, Cloudflare et la plupart des fournisseurs PaaS — fournissent HTTPS automatiquement. Un tunnel, tel que Cloudflare Tunnel, expose un serveur restant sur votre réseau interne sans ouvrir de ports.
Aucun secret ne doit apparaître dans le code. Notez la distinction entre les deux syntaxes ci-dessous : os.environ["MCP_API_TOKEN"] fait échouer le démarrage si la variable est manquante, ce qui est exactement le comportement souhaité pour un secret obligatoire, tandis que os.environ.get() tolère l’absence pour les valeurs optionnelles.
import os
# Configuration via variables d'environnement
API_TOKEN = os.environ["MCP_API_TOKEN"] # Obligatoire
DATABASE_URL = os.environ.get("DATABASE_URL") # Optionnel
DEBUG = os.environ.get("DEBUG", "false") == "true"
Un serveur public sans limitation de débit finit par être saturé, volontairement ou non. Un limiteur basé sur l’IP suffit dans la plupart des cas :
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 requêtes par minute par IP
...
Observer ce qui se passe
En production, vous n’avez plus votre terminal devant vous, et un outil qui échoue une fois sur dix ne peut être diagnostiqué qu’avec des traces. Au minimum, instrumentez l’entrée, la sortie et la durée de chaque appel :
import logging
import time
logger = logging.getLogger("mcp-server")
@mcp.tool()
async def my_tool(param: str) -> str:
"""Mon outil avec journalisation."""
start = time.time()
logger.info(f"Outil appelé avec param={param}")
try:
result = await process(param)
duration = time.time() - start
logger.info(f"Outil terminé en {duration:.2f}s")
return result
except Exception as e:
logger.error(f"Erreur dans l'outil : {e}")
raise
Mesurer la durée n’est pas un luxe : un outil qui met douze secondes à répondre déclenche des délais d’attente côté client et donne l’impression d’un serveur cassé alors qu’il fonctionne réellement. Avant d’annoncer votre serveur, passez en revue les six points de configuration suivants.
- HTTPS actif et certificat valide
- Variables d’environnement pour tous les secrets
- Journalisation structurée activée
- Point de terminaison de vérification d’état de santé (
/ou/health) - Redémarrage automatique en cas de plantage
- Limitation de débit configurée
Deux vérifications restent, celles que les gens omettent le plus souvent mais qui révèlent les vrais problèmes : un test avec MCP Inspector lancé depuis l’extérieur, puis un test depuis Mistral Vibe. Un serveur qui répond parfaitement depuis votre machine peut être bloqué par un pare-feu ou une configuration CORS dès qu’il est appelé depuis ailleurs.
Puncte cheie
- Hugging Face Spaces : le plus rapide, gratuit, idéal pour débuter
- Docker : contrôle total, adapté aux serveurs dédiés et au cloud
- Prefect Horizon (ex-FastMCP Cloud) : déploiement depuis GitHub, pour les serveurs écrits avec le framework FastMCP
- Cloudflare Workers : serverless, faible latence, évolutif
- Sécurisez avec HTTPS, les variables d’environnement et la limitation de débit
- Ajoutez de la surveillance et des journaux pour le débogage en production