MCP serveri tootmisse viimine
Sellel lehel
Uuendus 2. november 2026 — Le Chat on nüüd Vibe. Alates 28. maist 2026 on Le Chat ümber bränditud nimele Vibe (aadressil chat.mistral.ai): üks agent tööks ja kodeerimiseks, kandes üle sinu vestlused, seaded ja tellimused. Vana Le Chati kasutajakogemus on endiselt kättesaadav Chat režiimis; Work režiimis on agentidest saanud oskused (kutsutakse välja sümboliga
@), mälud moodustavad teadmistebaasi ja põhjalik uurimistöö on Deep Research oskus. Plaanid kannavad nüüd nimesid Mistral Free, Pro, Team ja Enterprise. Selles õppetükis kasutame nime Vibe; mõned siin kirjeldatud menüüd võivad olla muutnud nime või asukohta.
Uuendus 2. november 2026 — MCP Python SDK v2. See kursus järgib nüüd
mcpSDK versiooni 2 (6. oktoobri 2026 seisuga versioon 2.3.0):MCPServerasendabFastMCP-i, transpordi seaded liiguvad meetoditesserun()võistreamable_http_app()ja reaalse hostinime all avaldatud rakendus peab selle hostinime deklareerima (transport_security). See on ka versioon, mida nõuab Mistral SDK: lisapakettmistralai[agents]eeldabmcp>=2.2.0,<3.0. Allikad: Mis on uut v2-s · Migreerimisjuhend · Kasutuselevõtt ja skaleerimine.
Prototüübist tootmisserverini
Sinu server töötab lokaalselt ja ngrok paljastab selle maailmale vaid demo jaoks. Probleem algab siis, kui keegi teine peab seda kasutama: sa sulged terminali, URL sureb ja kõik ühendused, mida su kolleegid seadistasid, lakkavad töötamast. Tootmisse minek tähendab sisuliselt stabiilse aadressi hankimist, mis on saadaval 24/7 ja teenindab päringuid üle HTTPS-i. Sinuni viib neli võimalust, alates kiireimast kuni kõige kontrollitumani. Sinu valik sõltub peamiselt sellest, kui tundlikud on sinu andmed ja kui palju kontrolli soovid taristu üle omada.
Variant 1: Hugging Face Spaces
Hugging Face Spaces pakub tasuta virtuaalmasinaid ilma GPU-ta, mis on MCP serverile, mis edastab API kutseid, enam kui piisav. See on kiireim tee reaalse kasutuselevõtuni: kolm faili ja üks git push.
mon-mcp-space/
├── app.py # FastAPI + MCP server
├── requirements.txt # Sõltuvused
└── README.md # Space'i metaandmed
Fail app.py järgib täpselt seni nähtud struktuuri, välja arvatud see, et tundlikud väärtused loetakse keskkonnast – HF Secrets süstib need sinna:
# app.py
"""MCP server, mis on paigutatud Hugging Face Spaces'i."""
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:
"""Tervita inimest.
Args:
name: Isiku eesnimi
Returns:
Tervitussõnum
"""
return f"Hello {name} from Hugging Face Spaces!"
@asynccontextmanager
async def lifespan(app: FastAPI):
async with mcp.session_manager.run():
yield
# Space'i hostinimi kujul <kasutaja>-<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))
# Tundlike muutujate jaoks kasuta HF Secrets
API_KEY = os.environ.get("MY_API_KEY", "")
Platvormi eripära peitub failis README, mille YAML-päis juhendab Space’i buildi. Väli app_port peab vastama pordile, mida sinu server tegelikult kuulab; vastasel juhul õnnestub kasutuselevõtt küll, kuid server jääb kättesaamatuks:
---
title: My MCP Server
emoji: 🔧
colorFrom: blue
colorTo: green
sdk: docker
app_port: 7860
---
# Loo Space aadressil huggingface.co
# Lükka kood üles
git push
# Space võetakse automaatselt kasutusele
Sinu lõpp-punktiks saab seejärel https://your-username-mon-mcp-space.hf.space/mcp-endpoint/mcp, mida teenindatakse üle HTTPS-i. Järele on jäänud üks konfiguratsioonisamm: deklareeri see hostinimi, your-username-mon-mcp-space.hf.space, muutujas MCP_PUBLIC_HOST Space’i seadetes. Ilma selleta lükkab SDK iga päringu tagasi veaga 421 Invalid Host header.
Variant 2: Docker
Niipea kui server puutub kokku sisemiste andmetega, muutub reegliks hostimine oma taristus ja Docker on selle standardformaadiks. Dockerfile vajab vaid mõnda juhendit, kusjuures sõltuvuste installimine asetatakse enne koodi kopeerimist, et ära kasutada kihtide vahemällu salvestamist ümberbuildimisel:
FROM python:3.12-slim
WORKDIR /app
# Installi sõltuvused
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Kopeeri kood
COPY . .
# Ava port
EXPOSE 8000
# Käivita server
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 # ainult kui sinu tööriistad seda kasutavad: SDK v2 ei installi seda enam
Käivitamisel eristab tootmispaigaldust lihtsast testist valik --restart unless-stopped: ilma selleta viib esimene kokkujooksmine serveri offline’i, kuni keegi seda märkab.
# Eita image
docker build -t mon-mcp-server .
# Käivita konteiner
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 muudab selle konfiguratsiooni reprodutseeritavaks ja lisab tervisekontrolli (health check), mida orkestraator kasutab külmutatud serveri tuvastamiseks – elus protsess, mis enam ei vasta, on stsenaarium, mida lihtne automaatne taaskäivitamine ei kata:
# 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
Variandid 3 ja 4: Hallatud paigaldused
Prefect Horizon (varem FastMCP Cloud), platvorm sõltumatu FastMCP raamistiku loojatelt, eemaldab taristu sammu: logid sisse aadressil horizon.prefect.io oma GitHubi kontoga, valid repositooriumi ja serverifaili ning platvorm buildib ja avaldab URL-i sisseehitatud autentimisega. See on suunatud serveritele, mis on kirjutatud selle raamistikuga (pip install fastmcp, from fastmcp import FastMCP), mis erineb selles kursuses kasutatavast ametlikust SDK-st; isiklike projektide jaoks on olemas tasuta tase.
Cloudflare Workers sihib teistsugust kasutusprofiili: serverita (serverless), täitmine kasutajale kõige lähemal ja seega väiksem latentsus. Spetsiaalne mall aitab projekti käima lükata:
# Kasuta Cloudflare'i MCP malli
npm create cloudflare@latest -- remote-mcp-server-authless --template=cloudflare/ai/demos/remote-mcp-authless
Mõlemad variandid säästavad sind sertifikaatide haldamisest ja taaskäivitustest, kuid hinna eest on platvormist sõltuvus ja täitmise piirangud – näiteks serverita Worker ei sobi hästi olekulise (stateful) serveriga.
Paigalduse turvamine
HTTPS on tingimatu: Vibe keeldub lihtteksti lõpp-punktidest ja token, mis liigub üle HTTP-i, on kompromiteeritud token. Sinuni viib kolm teed sõltuvalt sinu hostimisest. Pöördproksi nagu Nginx või Caddy, mis asetatakse sinu serveri ette koos Let’s Encrypti sertifikaadiga, katab pühendatud serveri juhu. Pilvepõhised platvormid – Hugging Face, Cloudflare ja enamik PaaS-pakkujaid – pakuvad HTTPS-i automaatselt. Tunnel, nagu Cloudflare Tunnel, paljastab serveri, mis jääb sinu sisemisse võrku, ilma porte avamata.
Ükski saladus ei tohi koodis ilmuda. Pane tähele erinevust kahe allpool oleva süntaksi vahel: os.environ["MCP_API_TOKEN"] põhjustab käivitumise ebaõnnestumise, kui muutuja puudub, mis on kohustusliku saladuse puhul täpselt soovitud käitumine, samas os.environ.get() talub puudumist valikuliste väärtuste puhul.
import os
# Konfiguratsioon keskkonnamuutujate kaudu
API_TOKEN = os.environ["MCP_API_TOKEN"] # Kohustuslik
DATABASE_URL = os.environ.get("DATABASE_URL") # Valikuline
DEBUG = os.environ.get("DEBUG", "false") == "true"
Avalik server ilma kiiruse piiramiseta küllastub varem või hiljem, kas tahtlikult või tahtmatult. Enamikul juhtudel piisab IP-põhisest piirajast:
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 päringut minutis IP kohta
...
Toimuva jälgimine
Tootmises ei ole sul terminali enam ees ja tööriista, mis iga kümnes kord ebaõnnestub, saab diagnoosida vaid jälgede abil. Minimumina instrumendi iga kutse sisendi, väljundi ja kestuse:
import logging
import time
logger = logging.getLogger("mcp-server")
@mcp.tool()
async def my_tool(param: str) -> str:
"""Minu tööriist logimisega."""
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
Kestuse mõõtmine ei ole luks: tööriist, mis vastab kaheteistkümne sekundiga, käivitab kliendipoolsed ajalõpud ja jätab mulje katkisest serverist, kuigi tegelikult see töötab. Enne serveri avalikustamist vaata üle järgmised kuus konfiguratsioonipunkti.
- HTTPS on aktiivne ja sertifikaat kehtiv
- Keskkonnamuutujad kõigi saladuste jaoks
- Struktureeritud logimine lubatud
- Tervisekontrolli lõpp-punkt (
/või/health) - Automaatne taaskäivitamine kokkujooksmisel
- Kiiruse piiramine konfigureeritud
Järele on jäänud kaks kontrolli, mida inimesed kõige sagedamini vahele jätavad, kuid mis paljastavad tegelikud probleemid: test MCP Inspectoriga, mis on käivitatud väljastpoolt, ja seejärel test Mistral Vibest. Server, mis vastab sinu masinalt täiuslikult, võib olla tulemüüri või CORS-i konfiguratsiooni tõttu blokeeritud niipea, kui seda kutsutakse mujalt.
Peamised punktid
- Hugging Face Spaces: kiireim, tasuta, ideaalne alustamiseks
- Docker: täielik kontroll, sobib pühendatud serveritele ja pilvele
- Prefect Horizon (endine FastMCP Cloud): kasutuselevõtt GitHubist, serveritele, mis on kirjutatud FastMCP raamistikuga
- Cloudflare Workers: serverita, väike latentsus, skaleeritav
- Turva HTTPS-i, keskkonnamuutujate ja kiiruse piiramisega
- Lisa monitooring ja logid tootmise silumiseks