Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

MCP-kiszolgáló éles környezetbe helyezése

12. lecke 14 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Prototípustól az éles kiszolgálóig
  2. 1. lehetőség: Hugging Face Spaces
  3. 2. lehetőség: Docker
  4. 3. és 4. lehetőség: Felhőalapú kezelések
  5. A telepítés biztosítása
  6. Láthatóság biztosítása
  7. Főbb megállapítások

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 mcp SDK 2-es verzióját követi (2026. október 2-i állapot szerint 2.3.0): az MCPServer leváltja a FastMCP-t, a transzportbeállítások a run() vagy a streamable_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: a mistralai[agents] extra függőséghez mcp>=2.2.0,<3.0 szü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