Einen MCP-Server in die Produktion bringen
Auf dieser Seite
Update vom 2. November 2026 — Le Chat ist jetzt Vibe. Ab dem 28. Mai 2026 wurde Le Chat in Vibe umbenannt (nach wie vor unter chat.mistral.ai): ein einzelner Agent für Arbeit und Code, der Ihre Gespräche, Einstellungen und Abonnements übernimmt. Die klassische Le Chat-Erfahrung bleibt im Chat-Modus zugänglich; im Work-Modus sind Agenten nun Fähigkeiten (über
@aufgerufen), Erinnerungen bilden die Wissensbasis und die tiefe Recherche ist die Fähigkeit Deep Research. Pläne werden nun Mistral Free, Pro, Team und Enterprise genannt. Diese Lektion verwendet den Namen Vibe; einige hier beschriebene Menüs können andere Namen oder Standorte haben.
Update vom 2. November 2026 — MCP Python SDK v2. Dieser Kurs folgt nun Version 2 des
mcp-SDKs (Stand 2.3.0 vom 2. Oktober 2026):MCPServerersetztFastMCP, Transport-Einstellungen werden inrun()oderstreamable_http_app()verlegt, und eine App, die unter einem echten Hostnamen ausgegeben wird, muss diesen Hostnamen deklarieren (transport_security). Dies ist auch die vom Mistral SDK erforderliche Version: Dasmistralai[agents]-Extra benötigtmcp>=2.2.0,<3.0. Quellen: Was ist neu in v2 · Migrationsanleitung · Bereitstellen und skalieren.
Vom Prototyp zum Produktionsserver
Ihr Server läuft lokal, und ngrok stellt ihn der Welt nur für eine Demo zur Verfügung. Das Problem beginnt, wenn jemand anderes ihn nutzen muss: Sie schließen Ihren Terminal, die URL stirbt, und jeder Connector, den Ihre Kollegen konfiguriert haben, bricht. Die Verlagerung in die Produktion bedeutet im Wesentlichen, eine stabile Adresse zu erhalten, die rund um die Uhr verfügbar ist und über HTTPS bereitgestellt wird. Vier Optionen führen dorthin, von der schnellsten bis zur am meisten kontrollierten. Ihre Wahl hängt hauptsächlich davon ab, wie sensibel Ihre Daten sind und wie viel Kontrolle Sie über die Infrastruktur wünschen.
Option 1: Hugging Face Spaces
Hugging Face Spaces bietet kostenlose virtuelle Maschinen ohne GPUs, die für einen MCP-Server, der API-Aufrufe weiterleitet, mehr als ausreichend sind. Dies ist der schnellste Weg zu einer echten Bereitstellung: drei Dateien und ein git push.
mon-mcp-space/
├── app.py # FastAPI + MCP-Server
├── requirements.txt # Abhängigkeiten
└── README.md # Space-Metadaten
Die Datei app.py folgt exakt der Struktur, die Sie bisher gesehen haben, mit dem Unterschied, dass sensible Werte aus der Umgebung gelesen werden – HF Secrets injizieren diese dort:
# app.py
"""MCP-Server, der auf Hugging Face Spaces bereitgestellt wird."""
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("Mein Produktionsserver")
@mcp.tool()
def hello(name: str) -> str:
"""Begrüßt eine Person.
Args:
name: Der Vorname der Person
Returns:
Begrüßungsmitteilung
"""
return f"Hallo {name} von Hugging Face Spaces!"
@asynccontextmanager
async def lifespan(app: FastAPI):
async with mcp.session_manager.run():
yield
# Space-Hostname, im Format <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))
# Für sensible Variablen HF Secrets verwenden
API_KEY = os.environ.get("MY_API_KEY", "")
Die Besonderheit der Plattform liegt im README, dessen YAML-Header den Space-Bau steuert. Das Feld app_port muss dem Port entsprechen, auf dem Ihr Server tatsächlich lauscht; andernfalls wird die Bereitstellung erfolgreich abgeschlossen, bleibt aber unzugänglich:
---
title: Mein MCP-Server
emoji: 🔧
colorFrom: blue
colorTo: green
sdk: docker
app_port: 7860
---
# Einen Space auf huggingface.co erstellen
# Code hochladen
git push
# Der Space wird automatisch bereitgestellt
Ihr Endpunkt wird dann zu https://your-username-mon-mcp-space.hf.space/mcp-endpoint/mcp, bereitgestellt über HTTPS. Ein Konfigurationsschritt bleibt: Geben Sie diesen Hostnamen, your-username-mon-mcp-space.hf.space, in der Variablen MCP_PUBLIC_HOST in den Space-Einstellungen an. Ohne diese lehnt das SDK jede Anfrage mit dem Fehler 421 Invalid Host header ab.
Option 2: Docker
Sobald der Server interne Daten berührt, wird das Hosting auf Ihrer eigenen Infrastruktur zur Regel, und Docker ist das Standardformat. Der Dockerfile benötigt nur wenige Anweisungen, wobei die Installation der Abhängigkeiten vor dem Kopieren des Codes erfolgt, um Layer-Caching bei Neubauten zu nutzen:
FROM python:3.12-slim
WORKDIR /app
# Abhängigkeiten installieren
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Code kopieren
COPY . .
# Port freigeben
EXPOSE 8000
# Server starten
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 # nur, wenn Ihre Tools dies nutzen: SDK v2 installiert es nicht mehr
Beim Start ist die Option --restart unless-stopped das, was eine Produktionsbereitstellung von einem einfachen Test unterscheidet: Ohne sie nimmt der erste Absturz Ihren Server offline, bis jemand bemerkt, dass er ausgefallen ist.
# Bild bauen
docker build -t mon-mcp-server .
# Container ausführen
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 macht diese Konfiguration reproduzierbar und fügt einen Gesundheitscheck hinzu, den der Orchestrator verwendet, um einen eingefrorenen Server zu erkennen – ein lebender Prozess, der nicht mehr antwortet, ist ein Szenario, das einfache automatische Neustarts nicht abdecken:
# 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
Optionen 3 und 4: Verwaltete Bereitstellungen
Prefect Horizon (ehemals FastMCP Cloud), die Plattform des Teams hinter dem unabhängigen FastMCP-Framework, entfernt den Infrastrukturschritt: Sie melden sich bei horizon.prefect.io mit Ihrem GitHub-Konto an, wählen das Repository und die Serverdatei aus, und die Plattform baut und veröffentlicht eine URL mit integrierter Authentifizierung. Sie richtet sich an Server, die mit diesem Framework geschrieben wurden (pip install fastmcp, from fastmcp import FastMCP), was sich vom offiziellen SDK unterscheidet, das in diesem Kurs verwendet wird; ein kostenloser Tarif existiert für private Projekte.
Cloudflare Workers zielen auf ein anderes Nutzungsprofil ab: serverlos, mit Ausführung am nächsten am Benutzer und damit reduzierter Latenz. Eine dedizierte Vorlage startet das Projekt:
# Cloudflare MCP-Vorlage verwenden
npm create cloudflare@latest -- remote-mcp-server-authless --template=cloudflare/ai/demos/remote-mcp-authless
Beide Optionen sparen Ihnen das Management von Zertifikaten und Neustarts, zum Preis der Abhängigkeit von der Plattform und Ausführungseinschränkungen – ein serverloser Worker passt beispielsweise nicht gut zu einem zustandsbehafteten Server.
Absichern der Bereitstellung
HTTPS ist unverhandelbar: Vibe lehnt Endpunkte im Klartext ab, und ein Token, das über HTTP reist, ist ein kompromittiertes Token. Drei Wege führen dorthin, abhängig von Ihrem Hosting. Ein Reverse Proxy wie Nginx oder Caddy, der vor Ihrem Server platziert ist, mit einem Let’s Encrypt-Zertifikat, deckt den Fall des dedizierten Servers ab. Cloud-native Plattformen – Hugging Face, Cloudflare und die meisten PaaS-Anbieter – bieten HTTPS automatisch an. Ein Tunnel, wie Cloudflare Tunnel, stellt einen Server dar, der im internen Netzwerk verbleibt, ohne Ports zu öffnen.
Kein Geheimnis sollte im Code erscheinen. Beachten Sie den Unterschied zwischen den beiden Syntaxen unten: os.environ["MCP_API_TOKEN"] führt zum Scheitern des Starts, wenn die Variable fehlt, was genau das gewünschte Verhalten für ein obligatorisches Geheimnis ist, während os.environ.get() das Fehlen für optionale Werte toleriert.
import os
# Konfiguration über Umgebungsvariablen
API_TOKEN = os.environ["MCP_API_TOKEN"] # Obligatorisch
DATABASE_URL = os.environ.get("DATABASE_URL") # Optional
DEBUG = os.environ.get("DEBUG", "false") == "true"
Ein öffentlicher Server ohne Rate-Limiting wird schließlich gesättigt, freiwillig oder unfreiwillig. Ein IP-basiertes Limit reicht in den meisten Fällen aus:
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 Anfragen pro Minute pro IP
...
Beobachten, was passiert
In der Produktion haben Sie Ihren Terminal nicht mehr vor Ihnen, und ein Werkzeug, das bei einem von zehn Aufrufen versagt, kann nur mit Traces diagnostiziert werden. Mindestens müssen Sie Eingabe, Ausgabe und Dauer jedes Aufrufs instrumentieren:
import logging
import time
logger = logging.getLogger("mcp-server")
@mcp.tool()
async def my_tool(param: str) -> str:
"""Mein Werkzeug mit Protokollierung."""
start = time.time()
logger.info(f"Werkzeug aufgerufen mit param={param}")
try:
result = await process(param)
duration = time.time() - start
logger.info(f"Werkzeug in {duration:.2f}s abgeschlossen")
return result
except Exception as e:
logger.error(f"Fehler im Werkzeug: {e}")
raise
Die Messung der Dauer ist kein Luxus: Ein Werkzeug, das zwölf Sekunden zum Antworten benötigt, löst Client-seitige Timeouts aus und lässt den Eindruck eines defekten Servers entstehen, obwohl es eigentlich funktioniert. Bevor Sie Ihren Server ankündigen, überprüfen Sie die folgenden sechs Konfigurationspunkte.
- HTTPS aktiv und gültiges Zertifikat
- Umgebungsvariablen für alle Geheimnisse
- Strukturierte Protokollierung aktiviert
- Gesundheitscheck-Endpunkt (
/oder/health) - Automatischer Neustart bei Absturz
- Rate-Limiting konfiguriert
Zwei Prüfungen bleiben, die die Menschen am häufigsten überspringen, die jedoch die echten Probleme aufdecken: ein Test mit MCP Inspector, der von außen gestartet wird, und ein Test von Mistral Vibe. Ein Server, der von Ihrem Computer aus perfekt antwortet, kann blockiert werden, sobald er von anderer Stelle aus aufgerufen wird, durch eine Firewall oder eine CORS-Konfiguration.
Wichtige Erkenntnisse
- Hugging Face Spaces: schnellste, kostenlos, ideal zum Einstieg
- Docker: volle Kontrolle, geeignet für dedizierte Server und Cloud
- Prefect Horizon (ehemals FastMCP Cloud): Bereitstellung aus GitHub, für Server, die mit dem FastMCP-Framework geschrieben wurden
- Cloudflare Workers: serverlos, geringe Latenz, skalierbar
- Absichern mit HTTPS, Umgebungsvariablen und Rate-Limiting
- Überwachung und Protokolle für die Fehlersuche in der Produktion hinzufügen