Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Nasazení MCP serveru do produkce

Lekce 12 z 14 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Od prototypu k produkčnímu serveru
  2. Možnost 1: Hugging Face Spaces
  3. Možnost 2: Docker
  4. Možnosti 3 a 4: Spravovaná nasazení
  5. Zabezpečení nasazení
  6. Pohled dovnitř dění
  7. Klíčové poznatky

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): MCPServer nahrazuje FastMCP, nastavení transportu se přesouvá do run() nebo streamable_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íček mistralai[agents] vyžaduje mcp>=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