Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Einen MCP-Server in die Produktion bringen

Lektion 12 von 14 Aktualisiert am 2. November 2026 Entwickler
Auf dieser Seite
  1. Vom Prototyp zum Produktionsserver
  2. Option 1: Hugging Face Spaces
  3. Option 2: Docker
  4. Optionen 3 und 4: Verwaltete Bereitstellungen
  5. Absichern der Bereitstellung
  6. Beobachten, was passiert
  7. Wichtige Erkenntnisse

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): MCPServer ersetzt FastMCP, Transport-Einstellungen werden in run() oder streamable_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: Das mistralai[agents]-Extra benötigt mcp>=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