Uvedba strežnika MCP v proizvodno okolje
Na tej strani
Posodobitev 2. november 2026 — Le Chat je zdaj Vibe. Od 28. maja 2026 dalje je bil Le Chat preimenovan v Vibe (še vedno na chat.mistral.ai): en sam agent za delo in kodo, ki ohranja tvoja pogovora, nastavitve in naročnine. Stara izkušnja Le Chat ostaja dostopna v načinu Chat; v načinu Work so agenti zdaj veščine (priklicane z
@), spomini tvorijo bazo znanja, poglobljeno raziskovanje pa je veščina Deep Research. Načrti se zdaj imenujejo Mistral Free, Pro, Team in Enterprise. Ta lekcija uporablja ime Vibe; nekateri meniji, opisani tukaj, so morda spremenili imena ali lokacije.
Posodobitev 2. november 2026 — MCP Python SDK v2. Ta tečaj zdaj sledi različici 2 paketa SDK
mcp(2.3.0 z dne 2. oktober 2026):MCPServernadomeščaFastMCP, nastavitve prenosa se premaknejo vrun()alistreamable_http_app(), aplikacija, izpostavljena pod pravim gostiteljskim imenom, pa mora to ime deklarirati (transport_security). To je tudi različica, ki jo zahteva Mistral SDK: dodatekmistralai[agents]zahtevamcp>=2.2.0,<3.0. Viri: Kaj je novega v v2 · Vodnik za selitev · Uvedba in skaliranje.
Od prototipa do proizvodnega strežnika
Tvoj strežnik deluje lokalno, ngrok pa ga razkrije svetu le za namene demonstracije. Težava se začne, ko ga mora uporabiti nekdo drug: zapreš terminal, URL preneha delovati in vsak povezovalni element, ki so ga konfigurirali tvoji sodelavci, odpove. Prehod v proizvodno okolje v bistvu pomeni pridobitev stabilnega naslova, ki je na voljo 24/7 in se streže prek HTTPS. Do tega te pripeljejo štiri možnosti, od najhitrejše do najbolj nadzorovane. Tvoja izbira je odvisna predvsem od občutljivosti tvojih podatkov in od tega, koliko nadzora želiš imeti nad infrastrukturo.
1. možnost: Hugging Face Spaces
Hugging Face Spaces ponuja brezplačne navidezne stroje brez GPU-jev, kar je več kot dovolj za strežnik MCP, ki posreduje klice API-jev. To je najhitrejša pot do prave uvedbe: tri datoteke in ukaz git push.
mon-mcp-space/
├── app.py # FastAPI + strežnik MCP
├── requirements.txt # Odvisnosti
└── README.md # Metapodatki prostora
Datoteka app.py sledi točno isti strukturi, kot si jo videl doslej, razen da se občutljive vrednosti berejo iz okolja – HF Secrets jih tam vbrizga:
# app.py
"""Strežnik MCP, uveden 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:
"""Pozdravi osebo.
Args:
name: Ime osebe
Returns:
Pozdravno sporočilo
"""
return f"Hello {name} from Hugging Face Spaces!"
@asynccontextmanager
async def lifespan(app: FastAPI):
async with mcp.session_manager.run():
yield
# Gostiteljsko ime prostora v obliki <uporabnik>-<prostor>.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))
# Za občutljive spremenljivke uporabi HF Secrets
API_KEY = os.environ.get("MY_API_KEY", "")
Posebnost platforme je v datoteki README, katere glava YAML določa gradnjo prostora. Polje app_port se mora ujemati z vratom, na katerih dejansko posluša tvoj strežnik; v nasprotnem primeru je uvedba sicer uspešna, a nedostopna:
---
title: My MCP Server
emoji: 🔧
colorFrom: blue
colorTo: green
sdk: docker
app_port: 7860
---
# Ustvari prostor na huggingface.co
# Potisni kodo
git push
# Prostor se samodejno uvede
Tvoja končna točka nato postane https://your-username-mon-mcp-space.hf.space/mcp-endpoint/mcp, strežena prek HTTPS. Ostane še en korak konfiguracije: v nastavitvah prostora moraš v spremenljivki MCP_PUBLIC_HOST deklarirati to gostiteljsko ime, your-username-mon-mcp-space.hf.space. Brez tega bo SDK vsako zahtevo zavrnil z napako 421 Invalid Host header.
2. možnost: Docker
Takoj ko strežnik pride v stik z internimi podatki, postane gostovanje na lastni infrastrukturi pravilo, Docker pa je standardni format. Datoteka Dockerfile zahteva le nekaj ukazov, pri čemer je namestitev odvisnosti postavljena pred kopiranje kode, da se ob ponovnih gradnjah izkoristi predpomnenje plasti:
FROM python:3.12-slim
WORKDIR /app
# Namesti odvisnosti
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Kopiraj kodo
COPY . .
# Odpri vrata
EXPOSE 8000
# Zaženi strežnik
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 # le če ga uporabljajo tvoja orodja: SDK v2 ga ne namesti več samodejno
Ob zagonu je možnost --restart unless-stopped tista, ki loči proizvodno uvedbo od preprostega testa: brez nje bo prvi zroj spravil tvoj strežnik izven delovanja, dokler ga nekdo ne opazi.
# Izgradi sliko
docker build -t mon-mcp-server .
# Zaženi vsebnik
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 omogoča reproducibilnost te konfiguracije in doda preverjanje zdravja (health check), ki ga orkestrator uporabi za zaznavanje zamrznjenega strežnika – živ proces, ki ne odgovarja več, je scenarij, ki ga preprosti samodejni ponovni zagoni ne pokrijejo:
# 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
3. in 4. možnost: Upravljane uvedbe
Prefect Horizon (prej FastMCP Cloud), platforma ekipe, ki stoji za neodvisnim ogrodjem FastMCP, odstrani korak upravljanja infrastrukture: prijaviš se na horizon.prefect.io s svojim računom GitHub, izbereš skladišče in datoteko strežnika, platforma pa izgradi in objavi URL z vgrajeno avtentikacijo. Cilja na strežnike, napisane s tem ogrodjem (pip install fastmcp, from fastmcp import FastMCP), ki je ločeno od uradnega SDK-ja, uporabljenega v tem tečaju; za osebne projekte obstaja brezplačna raven.
Cloudflare Workers cilja na drugačen profil uporabe: brez strežnika (serverless), z izvajanjem čim bližje uporabniku in s tem zmanjšano zakasnitvijo. Namenski predloga zažene projekt:
# Uporabi predlogo MCP za Cloudflare
npm create cloudflare@latest -- remote-mcp-server-authless --template=cloudflare/ai/demos/remote-mcp-authless
Obe možnosti te rešita upravljanja potrdil in ponovnih zagonov, vendar po ceni odvisnosti od platforme in omejitev izvajanja – brezstrežni Worker se na primer ne obnese dobro s strežnikom, ki ohranja stanje (stateful).
Zavarovanje uvedbe
HTTPS ni pogajalski: Vibe zavrača končne točke v navadnem besedilu, žeton, ki potuje prek HTTP-ja, pa je ogrožen žeton. Tri poti vodijo tja, odvisno od tvojega gostovanja. Obratni posrednik (reverse proxy), kot sta Nginx ali Caddy, postavljen pred tvoj strežnik s potrdilom Let’s Encrypt, pokriva primer namenskega strežnika. Platforme, rojene v oblaku – Hugging Face, Cloudflare in večina ponudnikov PaaS – zagotavljajo HTTPS samodejno. Tunel, kot je Cloudflare Tunnel, razkrije strežnik, ki ostaja v tvojem internem omrežju, ne da bi odpiral vrata.
Nobena skrivnost se ne sme pojaviti v kodi. Upoštevaj razliko med spodnjima dvema sintaksama: os.environ["MCP_API_TOKEN"] povzroči neuspeh zagona, če spremenljivka manjka, kar je točno želeno vedenje za obvezno skrivnost, medtem ko os.environ.get() dopušča odsotnost za izbirne vrednosti.
import os
# Konfiguracija prek spremenljivk okolja
API_TOKEN = os.environ["MCP_API_TOKEN"] # Obvezno
DATABASE_URL = os.environ.get("DATABASE_URL") # Izbirno
DEBUG = os.environ.get("DEBUG", "false") == "true"
Javni strežnik brez omejevanja hitrosti (rate limiting) bo sčasoma zasičen, bodisi prostovoljno ali ne. Omejitev na podlagi IP-ja v večini primerov zadostuje:
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 zahtev na minuto na IP
...
Spremljanje dogajanja
V proizvodnem okolju nimaš več terminala pred seboj in orodje, ki odpove enkrat od desetih, je mogoče diagnosticirati le s sledmi. Kot minimum instrumentiraj vhod, izhod in trajanje vsakega klica:
import logging
import time
logger = logging.getLogger("mcp-server")
@mcp.tool()
async def my_tool(param: str) -> str:
"""Moje orodje z beleženjem."""
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
Merjenje trajanja ni razkošje: orodje, ki za odgovor potrebuje dvanajst sekund, sproži časovne omejitve na strani odjemalca in ustvari vtis pokvarjenega strežnika, čeprav ta dejansko deluje. Preden napoveš svoj strežnik, pregledaj naslednjih šest konfiguracijskih točk.
- HTTPS je aktiven in potrdilo veljavno
- Spremenljivke okolja za vse skrivnosti
- Omogočeno strukturirano beleženje (logging)
- Končna točka za preverjanje zdravja (
/ali/health) - Samodejni ponovni zagon ob zroju
- Konfigurirano omejevanje hitrosti (rate limiting)
Ostaneta še dva preverjanja, ki ju ljudje najpogosteje preskočijo, a ravno ta razkrijejo prave težave: test z MCP Inspectorjem, zagnanim od zunaj, nato pa test iz Mistral Vibe. Strežnik, ki popolnoma odgovarja z tvojega stroja, je lahko blokiran s požarnim zidom ali konfiguracijo CORS, takoj ko ga pokličejo od drugod.
Ključne ugotovitve
- Hugging Face Spaces: najhitreje, brezplačno, idealno za začetek
- Docker: popoln nadzor, primeren za namenske strežnike in oblak
- Prefect Horizon (prej FastMCP Cloud): uvedba iz GitHuba, za strežnike, napisane z ogrodjem FastMCP
- Cloudflare Workers: brez strežnika, nizka zakasnitev, skalabilnost
- Zavaruj s HTTPS, spremenljivkami okolja in omejevanjem hitrosti
- Dodaj nadzor in dnevnike za razhroščevanje v proizvodnji