Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Nasadenie MCP servera do produkcie

Lekcia 12 z 14 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Od prototypu k produkčnému serveru
  2. Možnosť 1: Hugging Face Spaces
  3. Možnosť 2: Docker
  4. Možnosti 3 a 4: Spravované nasadenia
  5. Zabezpečenie nasadenia
  6. Pohľad do vnútra diania
  7. Kľúčové poznatky

Aktualizácia 2. novembra 2026 — Le Chat je teraz Vibe. Od 28. mája 2026 prešiel Le Chat rebrandingom na Vibe (stále na chat.mistral.ai): ide o jediného agenta pre prácu aj kód, ktorý si zachováva tvoje konverzácie, nastavenia a predplatné. Pôvodné prostredie Le Chat zostáva dostupné v režime Chat; v režime Work sú agenti teraz zručnosti (vyvolávané pomocou @), spomienky tvoria znalostnú bázu a hĺbkový výskum je zručnosť Deep Research. Plány sa teraz nazývajú Mistral Free, Pro, Team a Enterprise. Táto lekcia používa názov Vibe; niektoré tu opísané ponuky mohli zmeniť názvy alebo umiestnenie.

Aktualizácia 2. novembra 2026 — MCP Python SDK v2. Tento kurz teraz nasleduje verziu 2 SDK mcp (2.3.0 k 2. októbru 2026): MCPServer nahrádza FastMCP, nastavenia transportu sa presúvajú do run() alebo streamable_http_app() a aplikácia vystavená pod skutočným hostname musí tento hostname deklarovať (transport_security). Toto je tiež verzia požadovaná Mistral SDK: extra balík mistralai[agents] vyžaduje mcp>=2.2.0,<3.0. Zdroje: Čo je nové vo v2 · Sprievodca migráciou · Nasadenie a škálovanie.

Od prototypu k produkčnému serveru

Tvoj server beží lokálne a ngrok ho sprístupňuje svetu len na účely dema. Problém nastane, keď ho potrebuje používať niekto iný: zavrieš terminál, URL adresa prestane fungovať a každé prepojenie, ktoré tvoji kolegovia nakonfigurovali, sa pokazí. Prechod do produkcie v podstate znamená získať stabilnú adresu, dostupnú 24/7, obsluhovanú cez HTTPS. Štyri možnosti ťa tam dostanú, od najrýchlejšej po najviac kontrolovanú. Tvoja voľba závisí hlavne od toho, aké citlivé sú tvoje údaje a koľko kontroly chceš mať nad infraštruktúrou.

Možnosť 1: Hugging Face Spaces

Hugging Face Spaces poskytuje bezplatné virtuálne stroje bez GPU, čo je viac než dosť pre MCP server, ktorý len prepája volania API. Toto je najrýchlejšia cesta k skutočnému nasadeniu: tri súbory a git push.

mon-mcp-space/
├── app.py              # FastAPI + MCP server
├── requirements.txt    # Závislosti
└── README.md           # Metadáta Space

Súbor app.py nasleduje presne tú istú štruktúru, akú si doteraz videl, až na to, že citlivé hodnoty sa čítajú z prostredia – HF Secrets ich tam vstrekne:

# app.py
"""MCP server nasadený 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: Krstné meno osoby

    Returns:
        Pozdravná správa
    """
    return f"Hello {name} from Hugging Face Spaces!"

@asynccontextmanager
async def lifespan(app: FastAPI):
    async with mcp.session_manager.run():
        yield

# Hostname Space, vo 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))

# Pre citlivé premenné použij HF Secrets
API_KEY = os.environ.get("MY_API_KEY", "")

Zvláštnosťou platformy je súbor README, ktorého hlavička YAML riadi zostavenie Space. Pole app_port sa musí zhodovať s portom, na ktorom server skutočne počúva; inak sa nasadenie síce úspešne dokončí, ale zostane nedostupné:

---
title: My MCP Server
emoji: 🔧
colorFrom: blue
colorTo: green
sdk: docker
app_port: 7860
---
# Vytvor Space na huggingface.co
# Odošli kód
git push
# Space sa nasadí automaticky

Tvoj koncový bod sa potom stane https://your-username-mon-mcp-space.hf.space/mcp-endpoint/mcp, obsluhovaný cez HTTPS. Zostáva ešte jeden konfiguračný krok: deklaruj tento hostname, your-username-mon-mcp-space.hf.space, v premennej MCP_PUBLIC_HOST v nastaveniach Space. Bez toho SDK odmietne každú požiadavku s chybou 421 Invalid Host header.

Možnosť 2: Docker

Akonáhle server príde do styku s internými údajmi, hostovanie na vlastnej infraštruktúre sa stáva pravidlom a Docker je štandardným formátom. Dockerfile zaberie len niekoľko inštrukcií, pričom inštalácia závislostí je umiestnená pred kopírovaním kódu, aby sa využilo ukladanie vrstiev do medzipamäte počas opätovných zostavení:

FROM python:3.12-slim

WORKDIR /app

# Inštalácia závislostí
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Kopírovanie kódu
COPY . .

# Exponovanie portu
EXPOSE 8000

# Spustenie servera
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   # len ak ho tvoje nástroje používajú: SDK v2 ho už neinštaluje

Pri spustení je to možnosť --restart unless-stopped, čo odlišuje produkčné nasadenie od jednoduchého testu: bez nej ťa prvý pád vyradí z prevádzky, kým si to niekto nevšimne.

# Zostav obraz
docker build -t mon-mcp-server .

# Spusti kontajner
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 robí túto konfiguráciu reprodukovateľnou a pridáva kontrolu stavu (health check), ktorú orchestrátor používa na detekciu zamrznutého servera – živý proces, ktorý už neodpovedá, je scenár, ktorý jednoduché automatické reštarty nepokrývajú:

# 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é nasadenia

Prefect Horizon (predtým FastMCP Cloud), platforma od tímu stojaceho za nezávislým frameworkom FastMCP, odstraňuje krok s infraštruktúrou: prihlásiš sa na horizon.prefect.io pomocou svojho GitHub účtu, vyberieš repozitár a súbor servera a platforma zostaví a publikuje URL so vstavanou autentifikáciou. Cieľi na servery napísané v tomto frameworku (pip install fastmcp, from fastmcp import FastMCP), čo je odlišné od oficiálneho SDK použitého v tomto kurze; pre osobné projekty existuje bezplatná úroveň.

Cloudflare Workers cielia na odlišný profil použitia: serverless, s vykonávaním čo najbližšie k používateľovi, a teda so zníženou latenciou. Špecializovaná šablóna nakopne projekt:

# Použi šablónu MCP od Cloudflare
npm create cloudflare@latest -- remote-mcp-server-authless --template=cloudflare/ai/demos/remote-mcp-authless

Obe možnosti ťa zbavia starosti s certifikátmi a reštartmi, za cenu závislosti na platforme a obmedzení vykonávania – serverless Worker sa napríklad nehodí so stavovým serverom.

Zabezpečenie nasadenia

HTTPS je neprijateľné vynechať: Vibe odmieta plaintextové koncové body a token cestujúci cez HTTP je kompromitovaný token. Tri cesty tam vedú v závislosti od tvojho hostingu. Reverzná proxy ako Nginx alebo Caddy umiestnená pred tvojím serverom s certifikátom Let’s Encrypt pokrýva prípad vyhradeného servera. Cloud-native platformy – Hugging Face, Cloudflare a väčšina poskytovateľov PaaS – poskytujú HTTPS automaticky. Tunel, ako je Cloudflare Tunnel, vystaví server zostávajúci v tvojej internej sieti bez otvárania portov.

Žiadne tajomstvo sa nesmie objaviť v kóde. Všimni si rozdiel medzi dvoma syntaxami nižšie: os.environ["MCP_API_TOKEN"] spôsobí zlyhanie štartu, ak premenná chýba, čo je presne želané správanie pre povinné tajomstvo, zatiaľ čo os.environ.get() toleruje neprítomnosť pre voliteľné hodnoty.

import os

# Konfigurácia cez premenné prostredia
API_TOKEN = os.environ["MCP_API_TOKEN"]       # Povinné
DATABASE_URL = os.environ.get("DATABASE_URL")  # Voliteľné
DEBUG = os.environ.get("DEBUG", "false") == "true"

Verejný server bez obmedzenia rýchlosti (rate limiting) sa časom nasýti, či už úmyselne alebo nie. V väčšine prípadov stačí obmedzovač 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žiadaviek za minútu na IP
    ...

Pohľad do vnútra diania

V produkcii už nemáš pred sebou svoj terminál a nástroj, ktorý zlyhá jedenkrát z desiatich, sa dá diagnostikovať len pomocou stôp. Minimálne inštrumentuj vstup, výstup a trvanie každého volania:

import logging
import time

logger = logging.getLogger("mcp-server")

@mcp.tool()
async def my_tool(param: str) -> str:
    """Môj nástroj s logovaní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

Meranie trvania nie je luxus: nástroj, ktorý odpovedá dvanásť sekúnd, spúšťa časové limity na strane klienta a vytvára dojem nefunkčného servera, hoci v skutočnosti pracuje. Pred oznámením svojho servera si prejdite nasledujúcich šesť konfiguračných bodov.

  • HTTPS aktívne a platný certifikát
  • Premenné prostredia pre všetky tajomstvá
  • Povolené štruktúrované logovanie
  • Koncový bod kontroly stavu (/ alebo /health)
  • Automatický reštart pri páde
  • Nakonfigurované obmedzenie rýchlosti (rate limiting)

Zostávajú dve kontroly, tie, ktoré ľudia najčastejšie vynechajú, no ktoré odhalia skutočné problémy: test s MCP Inspector spusteným zvonku a potom test z Mistral Vibe. Server, ktorý perfektne odpovedá z tvojho stroja, môže byť blokovaný firewallom alebo konfiguráciou CORS, akonáhle je volaný odinakiaľ.

Kľúčové poznatky

  • Hugging Face Spaces: najrýchlejšie, zadarmo, ideálne na začiatok
  • Docker: úplná kontrola, vhodné pre vyhradené servery a cloud
  • Prefect Horizon (ex-FastMCP Cloud): nasadenie z GitHubu, pre servery napísané vo frameworku FastMCP
  • Cloudflare Workers: serverless, nízka latencia, škálovateľné
  • Zabezpečenie pomocou HTTPS, premenných prostredia a obmedzenia rýchlosti
  • Pridaj monitoring a logy pre ladenie v produkcii