MCP-kiszolgáló éles környezetbe helyezése
Ezen az oldalon
Frissítés: 2026. november 2. — A Le Chat mostantól Vibe. 2026. május 28-tól a Le Chat márkaneve Vibe-ra változott (továbbra is a chat.mistral.ai címen érhető el): ez egyetlen ügynök munkához és kódoláshoz, amely megőrzi beszélgetéseidet, beállításaidat és előfizetéseidet. A régi Le Chat élmény továbbra is elérhető a Chat módban; a Work módban az ügynökök készségekké (skills) váltak (az
@jellel hívhatók meg), az emlékezet alkotja a tudásbázist, a mély kutatás pedig a Deep Research készség. A csomagok neve mostantól Mistral Free, Pro, Team és Enterprise. Ez a lecke a Vibe nevet használja; egyes itt leírt menük neve vagy helye megváltozhatott.
Frissítés: 2026. november 2. — MCP Python SDK v2. Ez a tanfolyam az
mcpSDK 2-es verzióját követi (2026. október 2-i állapot szerint 2.3.0): azMCPServerleváltja aFastMCP-t, a transzportbeállítások arun()vagy astreamable_http_app()függvényekbe kerültek, és egy valódi hosztnév alatt elérhető alkalmazásnak deklarálnia kell ezt a hosztnevet (transport_security). Ez az a verzió, amelyet a Mistral SDK is megkövetel: amistralai[agents]extra függőséghezmcp>=2.2.0,<3.0szükséges. Források: Újdonságok a v2-ben · Migrációs útmutató · Telepítés és skálázás.
Prototípustól az éles kiszolgálóig
A kiszolgálód helyben fut, és az ngrok csak demonstrációs céllal teszi elérhetővé a világ számára. A probléma akkor kezdődik, amikor másoknak is használniuk kell: bezárod a terminált, az URL megszűnik létezni, és minden kollégád által konfigurált csatlakozás megszakad. Az éles környezetbe helyezés lényegében azt jelenti, hogy stabil címet biztosítasz, amely 7/24-ben elérhető HTTPS-en keresztül. Négy lehetőség vezet el idáig, a leggyorsabbtól a leginkább kontrollálhatóig. A választás főként attól függ, mennyire érzékenyek az adataid, és mennyi kontrollt szeretnél az infrastruktúra felett.
1. lehetőség: Hugging Face Spaces
A Hugging Face Spaces ingyenes virtuális gépeket biztosít GPU nélkül, ami több mint elég egy MCP-kiszolgálónak, amely csak API-hívásokat továbbít. Ez a leggyorsabb út egy valódi telepítéshez: három fájl és egy git push.
mon-mcp-space/
├── app.py # FastAPI + MCP kiszolgáló
├── requirements.txt # Függőségek
└── README.md # Space metaadatok
Az app.py fájl pontosan azt a struktúrát követi, amit eddig láttál, kivéve, hogy az érzékeny értékeket a környezetből olvassa be – a HF Secrets injektálja őket oda:
# app.py
"""MCP-kiszolgáló telepítve Hugging Face Spaces-re."""
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:
"""Üdvözöl egy személyt.
Args:
name: A személy keresztneve
Returns:
Üdvözlő üzenet
"""
return f"Hello {name} from Hugging Face Spaces!"
@asynccontextmanager
async def lifespan(app: FastAPI):
async with mcp.session_manager.run():
yield
# Space hosztnév, <felhasználó>-<space>.hf.space formátumban
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))
# Érzékeny változókhoz használd a HF Secrets-et
API_KEY = os.environ.get("MY_API_KEY", "")
A platform sajátossága a README-ben rejlik, amelynek YAML fejléce vezérli a Space építését. Az app_port mezőnek meg kell egyeznie azzal a porttal, amelyen a kiszolgálód ténylegesen figyel; ellenkező esetben a telepítés sikeresnek tűnik, de elérhetetlen marad:
---
title: My MCP Server
emoji: 🔧
colorFrom: blue
colorTo: green
sdk: docker
app_port: 7860
---
# Space létrehozása a huggingface.co oldalon
# Kód feltöltése
git push
# A Space automatikusan települ
A végpontod ezután így néz ki: https://your-username-mon-mcp-space.hf.space/mcp-endpoint/mcp, HTTPS-en keresztül kiszolgálva. Még egy konfigurációs lépés hátra van: deklarálnod kell ezt a hosztnevet, a your-username-mon-mcp-space.hf.space értéket, az MCP_PUBLIC_HOST változóban a Space beállításaiban. Enélkül az SDK minden kérést elutasít egy 421 Invalid Host header hibával.
2. lehetőség: Docker
Amint a kiszolgáló belső adatokhoz fér hozzá, a saját infrastruktúrán történő üzemeltetés válik szabállyá, és a Docker a szabványos formátum. A Dockerfile csak néhány utasítást igényel, ahol a függőségek telepítése a kód másolása előtt történik, hogy kihasználjuk a réteg-gyorsítótárazást az újjáépítések során:
FROM python:3.12-slim
WORKDIR /app
# Függőségek telepítése
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Kód másolása
COPY . .
# Port megnyitása
EXPOSE 8000
# Kiszolgáló indítása
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 # csak ha az eszközeid használják: az SDK v2 már nem telepíti
Indításkor a --restart unless-stopped opció különbözteti meg az éles telepítést az egyszerű teszteléstől: enélkül az első összeomlás offline állapotba kényszeríti a kiszolgálót, amíg valaki észre nem veszi.
# Kép buildelése
docker build -t mon-mcp-server .
# Konténer futtatása
docker run -d \
--name mcp-server \
-p 8000:8000 \
-e MY_API_KEY="secret" \
-e DATABASE_URL="postgresql://..." \
--restart unless-stopped \
mon-mcp-server
A Docker Compose reprodukálhatóvá teszi ezt a konfigurációt, és hozzáad egy egészségellenőrzést (health check), amelyet az orchestrator használ egy befagyott kiszolgáló észlelésére – egy élő folyamat, amely már nem válaszol, olyan forgatókönyv, amelyet az egyszerű automatikus újraindítások nem fednek le:
# 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. és 4. lehetőség: Felhőalapú kezelések
A Prefect Horizon (korábban FastMCP Cloud), a független FastMCP keretrendszer mögött álló csapat platformja, megszünteti az infrastruktúra kezelésének lépését: bejelentkezel a horizon.prefect.io oldalon a GitHub-fiókoddal, kiválasztod a tárházat és a kiszolgáló fájlt, a platform pedig felépíti és közzéteszi az URL-t beépített hitelesítéssel. Azokkal a kiszolgálókkal célozza meg a piacot, amelyeket ezzel a keretrendszerrel írtak (pip install fastmcp, from fastmcp import FastMCP), ami eltér a tanfolyamon használt hivatalos SDK-tól; személyes projektekhez ingyenes csomag is elérhető.
A Cloudflare Workers egy másik használati profilt céloz meg: serverless megoldás, ahol a végrehajtás a felhasználóhoz legközelebb történik, így csökkentve a késleltetést. Egy dedikált sablon segít elindítani a projektet:
# Cloudflare MCP sablon használata
npm create cloudflare@latest -- remote-mcp-server-authless --template=cloudflare/ai/demos/remote-mcp-authless
Mindkét lehetőség megkímél a tanúsítványok kezelésétől és az újraindításoktól, cserébe platformfüggőséget és végrehajtási korlátokat vállalnod kell – egy serverless Worker például nem illik jól egy állapotot őrző (stateful) kiszolgálóhoz.
A telepítés biztosítása
A HTTPS nem tárgyalható: a Vibe elutasítja a titkosítatlan végpontokat, és egy HTTP-n utazó token kompromittálódott tokennek számít. Három út vezet idáig a hosztingodtól függően. Egy fordított proxy, mint például az Nginx vagy a Caddy, amelyet a kiszolgálód elé helyezel Let’s Encrypt tanúsítvánnyal, lefedi a dedikált szerver esetét. A felhőnatív platformok – Hugging Face, Cloudflare és a legtöbb PaaS szolgáltató – automatikusan biztosítják a HTTPS-t. Egy alagút, mint például a Cloudflare Tunnel, lehetővé teszi egy, a belső hálózaton maradó kiszolgáló elérhetővé tételét portok megnyitása nélkül.
Egy titok sem jelenhet meg a kódban. Figyeld meg a különbséget a két alábbi szintaxis között: az os.environ["MCP_API_TOKEN"] miatt az indítás meghiúsul, ha a változó hiányzik, ami pontosan a kívánt viselkedés egy kötelező titok esetén, míg az os.environ.get() tolerálja a hiányt az opcionális értékeknél.
import os
# Konfiguráció környezeti változókon keresztül
API_TOKEN = os.environ["MCP_API_TOKEN"] # Kötelező
DATABASE_URL = os.environ.get("DATABASE_URL") # Opcionális
DEBUG = os.environ.get("DEBUG", "false") == "true"
Egy nyilvános kiszolgáló sebességkorlátozás (rate limiting) nélkül előbb-utóbb telítődik, szándékosan vagy akaratlanul. Egy IP-alapú korlátozó a legtöbb esetben elegendő:
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 kérés percenként IP-címenként
...
Láthatóság biztosítása
Éles környezetben már nincs előtted a terminál, és egy eszköz, amely tízből egyszer meghibásodik, csak naplókkal (trace-ekkel) diagnosztizálható. Minimumként instrumentáld minden hívás bemenetét, kimenetét és időtartamát:
import logging
import time
logger = logging.getLogger("mcp-server")
@mcp.tool()
async def my_tool(param: str) -> str:
"""Naplózást tartalmazó eszközö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
Az időtartam mérése nem luxus: egy eszköz, amely tizenkét másodpercig válaszol, kliens oldali időtúllépést vált ki, és azt a benyomást kelti, hogy a kiszolgáló hibás, miközben valójában működik. Mielőtt bejelentenéd a kiszolgálódat, tekintsd át a következő hat konfigurációs pontot.
- HTTPS aktív és érvényes tanúsítvánnyal
- Környezeti változók minden titokhoz
- Strukturált naplózás engedélyezve
- Egészségellenőrző végpont (
/vagy/health) - Automatikus újraindítás összeomlás esetén
- Sebességkorlátozás konfigurálva
Két ellenőrzés maradt hátra, amelyeket az emberek leggyakrabban kihagynak, pedig ezek tárják fel a valódi problémákat: egy teszt az MCP Inspectorral kívülről indítva, majd egy teszt a Mistral Vibe-ból. Egy kiszolgáló, amely a saját gépedről tökéletesen válaszol, blokkolható tűzfal vagy CORS konfiguráció által, amint máshonnan hívják meg.
Főbb megállapítások
- Hugging Face Spaces: leggyorsabb, ingyenes, ideális a kezdéshez
- Docker: teljes kontroll, dedikált szerverekhez és felhőhöz illő
- Prefect Horizon (korábban FastMCP Cloud): telepítés GitHubról, a FastMCP keretrendszerrel írt kiszolgálókhoz
- Cloudflare Workers: serverless, alacsony késleltetés, skálázható
- Biztonság: HTTPS, környezeti változók és sebességkorlátozás
- Adj hozzá monitoringot és naplókat az éles hibakereséshez