Nasazení MCP serveru do produkce
Na této stránce
Aktualizace 2. listopadu 2026 — Le Chat je nyní Vibe. Od 28. května 2026 byl Le Chat přejmenován na Vibe (stále na chat.mistral.ai): jediný agent pro práci i kód, který si nese vaše konverzace, nastavení a předplatná. Původní prostředí Le Chat zůstává dostupné v režimu Chat; v režimu Work jsou agenti nyní dovednosti (vyvolávané pomocí
@), vzpomínky tvoří znalostní bázi a hloubkový výzkum je dovednost Deep Research. Plány se nyní jmenují Mistral Free, Pro, Team a Enterprise. Tato lekce používá název Vibe; některá zde popsaná menu mohla změnit názvy nebo umístění.
Aktualizace 2. listopadu 2026 — MCP Python SDK v2. Tento kurz nyní sleduje verzi 2 SDK
mcp(2.3.0 k 2. říjnu 2026):MCPServernahrazujeFastMCP, nastavení transportu se přesouvá dorun()nebostreamable_http_app()a aplikace vystavená pod skutečným hostname musí tento hostname deklarovat (transport_security). Toto je také verze požadovaná Mistral SDK: extra balíčekmistralai[agents]vyžadujemcp>=2.2.0,<3.0. Zdroje: Co je nového ve v2 · Průvodce migrací · Nasazení a škálování.
Od prototypu k produkčnímu serveru
Váš server běží lokálně a ngrok jej zpřístupňuje světu pouze pro účely dema. Problém nastane, když ho potřebuje používat někdo jiný: zavřete terminál, URL přestane fungovat a každé propojení, které vaši kolegové nakonfigurovali, se rozbije. Přechod do produkce v podstatě znamená získat stabilní adresu, dostupnou 24/7, obsluhovanou přes HTTPS. Čtyři možnosti vás tam dostanou, od nejrychlejší po tu nejvíce kontrolovanou. Vaše volba závisí především na citlivosti vašich dat a na tom, kolik kontroly chcete nad infrastrukturou mít.
Možnost 1: Hugging Face Spaces
Hugging Face Spaces poskytuje zdarma virtuální stroje bez GPU, což pro MCP server, který pouze přeposílá volání API, více než stačí. Toto je nejrychlejší cesta k reálnému nasazení: tři soubory a git push.
mon-mcp-space/
├── app.py # FastAPI + MCP server
├── requirements.txt # Závislosti
└── README.md # Metadata Space
Soubor app.py následuje přesně stejnou strukturu, jakou jste zatím viděli, s tím rozdílem, že citlivé hodnoty se čtou z prostředí – HF Secrets je tam injektují:
# app.py
"""MCP server nasazený na 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:
"""Pozdraví osobu.
Args:
name: Křestní jméno osoby
Returns:
Pozdravná zpráva
"""
return f"Hello {name} from Hugging Face Spaces!"
@asynccontextmanager
async def lifespan(app: FastAPI):
async with mcp.session_manager.run():
yield
# Hostname Space ve tvaru <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))
# Pro citlivé proměnné použijte HF Secrets
API_KEY = os.environ.get("MY_API_KEY", "")
Zvláštností platformy je soubor README, jehož hlavička YAML řídí build Space. Pole app_port musí odpovídat portu, na kterém váš server skutečně naslouchá; jinak se nasazení sice povede, ale zůstane nedostupné:
---
title: My MCP Server
emoji: 🔧
colorFrom: blue
colorTo: green
sdk: docker
app_port: 7860
---
# Vytvořte Space na huggingface.co
# Nahrajte kód
git push
# Space se nasadí automaticky
Váš koncový bod pak bude https://your-username-mon-mcp-space.hf.space/mcp-endpoint/mcp, obsluhovaný přes HTTPS. Zbývá jeden konfigurační krok: deklarujte tento hostname, your-username-mon-mcp-space.hf.space, v proměnné MCP_PUBLIC_HOST v nastavení Space. Bez toho SDK každé požadavky odmítne s chybou 421 Invalid Host header.
Možnost 2: Docker
Jakmile server přijde do styku s interními daty, hosting na vlastní infrastruktuře se stává pravidlem a Docker je standardním formátem. Dockerfile zabere jen několik instrukcí, přičemž instalace závislostí probíhá před kopírováním kódu, aby se při přestavbách využilo ukládání do mezipaměti ve vrstvách:
FROM python:3.12-slim
WORKDIR /app
# Instalace závislostí
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Kopírování kódu
COPY . .
# Otevření portu
EXPOSE 8000
# Spuštění serveru
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 # pouze pokud vaše nástroje používají: SDK v2 jej již neinstaluje
Při spuštění je to volba --restart unless-stopped, která odlišuje produkční nasazení od prostého testu: bez ní vás první pád serveru odstřihne, dokud si toho někdo nevšimne.
# Sestavení obrazu
docker build -t mon-mcp-server .
# Spuštění kontejneru
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 činí tuto konfiguraci reprodukovatelnou a přidává kontrolu zdraví (health check), kterou orchestrátor využívá k detekci zamrzlého serveru – živý proces, který již neodpovídá, je scénář, který jednoduché automatické restarty nepokryjí:
# 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
Možnosti 3 a 4: Spravovaná nasazení
Prefect Horizon (dříve FastMCP Cloud), platforma od týmu stojícího za nezávislým frameworkem FastMCP, odstraňuje krok s infrastrukturou: přihlásíte se na horizon.prefect.io pomocí svého GitHub účtu, vyberete repozitář a soubor serveru a platforma sestaví a publikuje URL s vestavěnou autentizací. Cílí na servery napsané v tomto frameworku (pip install fastmcp, from fastmcp import FastMCP), který je odlišný od oficiálního SDK používaného v tomto kurzu; pro osobní projekty existuje bezplatná úroveň.
Cloudflare Workers cílí na jiný profil použití: serverless, s prováděním co nejblíže uživateli, a tedy se sníženou latencí. Vyhrazená šablona projekt nastartuje:
# Použijte šablonu MCP od Cloudflare
npm create cloudflare@latest -- remote-mcp-server-authless --template=cloudflare/ai/demos/remote-mcp-authless
Obě možnosti vás zbavují starostí s certifikáty a restarty, za cenu závislosti na platformě a omezení provádění – serverless Worker se například nesnáší dobře se stavovým (stateful) serverem.
Zabezpečení nasazení
HTTPS není vyjednatelné: Vibe odmítá plaintextové koncové body a token putující přes HTTP je kompromitovaný token. Tři cesty tam vedou v závislosti na vašem hostingu. Reverzní proxy jako Nginx nebo Caddy umístěné před váš server s certifikátem Let’s Encrypt pokryje případ dedikovaného serveru. Cloud-native platformy – Hugging Face, Cloudflare a většina poskytovatelů PaaS – poskytují HTTPS automaticky. Tunel, jako je Cloudflare Tunnel, zpřístupní server zůstávající ve vaší interní síti bez otevírání portů.
Žádné tajemství se nesmí objevit v kódu. Všimněte si rozdílu mezi dvěma syntaxemi níže: os.environ["MCP_API_TOKEN"] způsobí selhání startu, pokud proměnná chybí, což je přesně žádoucí chování pro povinné tajemství, zatímco os.environ.get() toleruje nepřítomnost pro volitelné hodnoty.
import os
# Konfigurace přes proměnné prostředí
API_TOKEN = os.environ["MCP_API_TOKEN"] # Povinné
DATABASE_URL = os.environ.get("DATABASE_URL") # Volitelné
DEBUG = os.environ.get("DEBUG", "false") == "true"
Veřejný server bez omezování rychlosti (rate limiting) se dříve či později nasytí, ať už úmyslně, nebo ne. Většině případů postačí omezovač založený na IP adrese:
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 požadavků za minutu na IP
...
Pohled dovnitř dění
V produkci již nemáte před sebou terminál a nástroj, který selže jedenkrát z deseti, lze diagnostikovat pouze pomocí stop (traces). Jako minimum instrumentujte vstup, výstup a dobu trvání každého volání:
import logging
import time
logger = logging.getLogger("mcp-server")
@mcp.tool()
async def my_tool(param: str) -> str:
"""Můj nástroj s logováním."""
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
Měření doby trvání není luxus: nástroj, který odpovídá dvanáct sekund, spustí na straně klienta časové limity a vytvoří dojem nefunkčního serveru, přestože ve skutečnosti pracuje. Než svůj server oznámíte, zkontrolujte následujících šest konfiguračních bodů.
- HTTPS aktivní a platný certifikát
- Proměnné prostředí pro všechna tajemství
- Povoleno strukturované logování
- Koncový bod kontroly zdraví (
/nebo/health) - Automatický restart při pádu
- Nakonfigurované omezování rychlosti (rate limiting)
Zbývají dvě kontroly, ty, které lidé nejčastěji přeskočí, a přitom odhalují skutečné problémy: test s MCP Inspector spuštěným zvenčí a následně test z Mistral Vibe. Server, který perfektně odpovídá z vašeho stroje, může být blokován firewallem nebo konfigurací CORS, jakmile je volán odjinud.
Klíčové poznatky
- Hugging Face Spaces: nejrychlejší, zdarma, ideální pro začátek
- Docker: totální kontrola, vhodné pro dedikované servery a cloud
- Prefect Horizon (ex-FastMCP Cloud): nasazení z GitHubu, pro servery napsané ve frameworku FastMCP
- Cloudflare Workers: serverless, nízká latence, škálovatelnost
- Zabezpečte pomocí HTTPS, proměnných prostředí a omezování rychlosti
- Přidejte monitoring a logy pro ladění v produkci