Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Distribuera en MCP-server till produktion

Lektion 12 av 14 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Från prototyp till produktionsserver
  2. Alternativ 1: Hugging Face Spaces
  3. Alternativ 2: Docker
  4. Alternativ 3 och 4: Hanterade distributioner
  5. Säkra distributionen
  6. Se vad som händer
  7. Viktiga punkter

Uppdatering 2 november 2026 — Le Chat är nu Vibe. Sedan den 28 maj 2026 har Le Chat bytt namn till Vibe (fortfarande på chat.mistral.ai): en enda agent för arbete och kod som behåller dina konversationer, inställningar och prenumerationer. Den äldre Le Chat-upplevelsen finns fortfarande tillgänglig i läget Chat; i läget Work är agenter nu färdigheter (anropas med @), minnen utgör kunskapsbasen och djup research är färdigheten Deep Research. Abonnemangen heter nu Mistral Free, Pro, Team och Enterprise. I denna lektion använder vi namnet Vibe; vissa menyer som beskrivs här kan ha bytt namn eller plats.

Uppdatering 2 november 2026 — MCP Python SDK v2. Denna kurs följer nu version 2 av mcp-SDK:t (2.3.0 per den 2 oktober 2026): MCPServer ersätter FastMCP, transportinställningar flyttas till run() eller streamable_http_app(), och en app som exponeras under ett riktigt värdnamn måste deklarera detta värdnamn (transport_security). Detta är också den version som krävs av Mistral SDK:t: tillägget mistralai[agents] kräver mcp>=2.2.0,<3.0. Källor: Vad är nytt i v2 · Migreringsguide · Distribuera och skala.

Från prototyp till produktionsserver

Din server körs lokalt och ngrok exponerar den för världen bara för en demo. Problemet uppstår när någon annan behöver använda den: du stänger din terminal, URL:en dör och varje koppling dina kollegor konfigurerat slutar fungera. Att gå till produktion innebär i grunden att skaffa en stabil adress, tillgänglig dygnet runt, serverad över HTTPS. Fyra alternativ tar dig dit, från det snabbaste till det mest kontrollerade. Ditt val beror främst på hur känslig din data är och hur mycket kontroll du vill ha över infrastrukturen.

Alternativ 1: Hugging Face Spaces

Hugging Face Spaces tillhandahåller gratis virtuella maskiner utan GPU:er, vilket är mer än tillräckligt för en MCP-server som vidarebefordrar API-anrop. Detta är den snabbaste vägen till en riktig distribution: tre filer och en git push.

mon-mcp-space/
├── app.py              # FastAPI + MCP-server
├── requirements.txt    # Beroenden
└── README.md           # Space-metadata

Filen app.py följer exakt samma struktur som du sett hittills, förutom att känsliga värden läses från miljön — HF Secrets injicerar dem där:

# app.py
"""MCP-server distribuerad på 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("Min produktionsserver")

@mcp.tool()
def hello(name: str) -> str:
    """Hälsa på en person.

    Args:
        name: Personens förnamn

    Returns:
        Hälsningsmeddelande
    """
    return f"Hej {name} från Hugging Face Spaces!"

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

# Space-värdnamn, i formatet <användare>-<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))

# För känsliga variabler, använd HF Secrets
API_KEY = os.environ.get("MY_API_KEY", "")

Plattformens egenhet ligger i README-filen, vars YAML-huvud styr bygget av Space. Fältet app_port måste matcha den port som din server faktiskt lyssnar på; annars lyckas distributionen men förblir oåtkomlig:

---
title: Min MCP-server
emoji: 🔧
colorFrom: blue
colorTo: green
sdk: docker
app_port: 7860
---
# Skapa ett Space på huggingface.co
# Pusha koden
git push
# Space distribueras automatiskt

Din slutpunkt blir då https://your-username-mon-mcp-space.hf.space/mcp-endpoint/mcp, serverad över HTTPS. Ett konfigurationssteg återstår: deklarera detta värdnamn, ditt-användarnamn-mon-mcp-space.hf.space, i variabeln MCP_PUBLIC_HOST i Space-inställningarna. Utan detta avvisar SDK:t varje begäran med felet 421 Invalid Host header.

Alternativ 2: Docker

Så snart servern hanterar intern data blir hosting på egen infrastruktur regeln, och Docker är standardformatet. Dockerfilen kräver bara några få instruktioner, där installationssteget för beroenden placeras innan koden kopieras för att utnyttja lagercachelagring vid ombyggnationer:

FROM python:3.12-slim

WORKDIR /app

# Installera beroenden
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Kopiera kod
COPY . .

# Exponera port
EXPOSE 8000

# Starta 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   # bara om dina verktyg använder det: SDK v2 installerar det inte längre

Vid start är det alternativet --restart unless-stopped som skiljer en produktionsdistribution från ett enkelt test: utan det tar den första kraschen ner din server tills någon märker det.

# Bygg avbildningen
docker build -t mon-mcp-server .

# Kör containern
docker run -d \
  --name mcp-server \
  -p 8000:8000 \
  -e MY_API_KEY="hemlig" \
  -e DATABASE_URL="postgresql://..." \
  --restart unless-stopped \
  mon-mcp-server

Docker Compose gör denna konfiguration reproducerbar och lägger till en hälsokontroll, som orchestratorn använder för att upptäcka en frusen server — en levande process som inte längre svarar är ett scenario som enkla automatiska omstarter inte täcker:

# 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

Alternativ 3 och 4: Hanterade distributioner

Prefect Horizon (tidigare FastMCP Cloud), plattformen från teamet bakom det fristående FastMCP-ramverket, tar bort infrastrukturesteget: du loggar in på horizon.prefect.io med ditt GitHub-konto, väljer arkiv och serverfil, så bygger och publicerar plattformen en URL med inbyggd autentisering. Den riktar sig till servrar skrivna med det ramverket (pip install fastmcp, from fastmcp import FastMCP), vilket skiljer sig från det officiella SDK som används i denna kurs; en gratisnivå finns för personliga projekt.

Cloudflare Workers riktar sig till en annan användningsprofil: serverlös, med exekvering så nära användaren som möjligt och därmed reducerad latens. En dedikerad mall kickstartar projektet:

# Använd Cloudflares MCP-mall
npm create cloudflare@latest -- remote-mcp-server-authless --template=cloudflare/ai/demos/remote-mcp-authless

Båda alternativen sparar dig från att hantera certifikat och omstarter, till priset av plattformsberoende och exekveringsbegränsningar — en serverlös Worker passar exempelvis inte bra ihop med en tillståndsbaserad (stateful) server.

Säkra distributionen

HTTPS är icke-förhandlingsbart: Vibe vägrar plaintext-slutpunkter, och en token som färdas över HTTP är en komprometterad token. Tre vägar leder dit beroende på ditt hostingval. En reverse proxy som Nginx eller Caddy placerad framför din server, med ett Let’s Encrypt-certifikat, täcker fallet med dedikerad server. Molnnativa plattformar — Hugging Face, Cloudflare och de flesta PaaS-leverantörer — tillhandahåller HTTPS automatiskt. En tunnel, som Cloudflare Tunnel, exponerar en server som stannar på ditt interna nätverk utan att öppna portar.

Ingen hemlighet ska förekomma i koden. Notera skillnaden mellan de två syntaxerna nedan: os.environ["MCP_API_TOKEN"] får starten att misslyckas om variabeln saknas, vilket är exakt det önskade beteendet för en obligatorisk hemlighet, medan os.environ.get() tolererar frånvaro för valfria värden.

import os

# Konfiguration via miljövariabler
API_TOKEN = os.environ["MCP_API_TOKEN"]       # Obligatorisk
DATABASE_URL = os.environ.get("DATABASE_URL")  # Valfri
DEBUG = os.environ.get("DEBUG", "false") == "true"

En offentlig server utan hastighetsbegränsning blir så småningom överbelastad, avsiktligt eller ej. En IP-baserad begränsare räcker i de flesta fall:

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 begäranden per minut per IP
    ...

Se vad som händer

I produktion har du inte längre din terminal framför dig, och ett verktyg som misslyckas en gång av tio kan bara diagnostiseras med spårning. Som minimum bör du instrumentera inmatning, utmatning och varaktighet för varje anrop:

import logging
import time

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

@mcp.tool()
async def my_tool(param: str) -> str:
    """Mitt verktyg med loggning."""
    start = time.time()
    logger.info(f"Verktyg anropat med param={param}")

    try:
        result = await process(param)
        duration = time.time() - start
        logger.info(f"Verktyg avslutat på {duration:.2f}s")
        return result
    except Exception as e:
        logger.error(f"Fel i verktyg: {e}")
        raise

Att mäta varaktighet är ingen lyx: ett verktyg som tar tolv sekunder på sig att svara utlöser tidsgränser på klientsidan och ger intrycket av en trasig server när den egentligen fungerar. Innan du lanserar din server bör du granska följande sex konfigurationspunkter.

  • HTTPS aktivt och giltigt certifikat
  • Miljövariabler för alla hemligheter
  • Strukturerad loggning aktiverad
  • Slutpunkt för hälsokontroll (/ eller /health)
  • Automatisk omstart vid krasch
  • Hastighetsbegränsning konfigurerad

Två kontroller återstår, de som folk oftast hoppar över men som avslöjar de verkliga problemen: ett test med MCP Inspector startat utifrån, följt av ett test från Mistral Vibe. En server som svarar perfekt från din maskin kan blockeras av en brandvägg eller CORS-konfiguration så snart den anropas från någon annanstans.

Viktiga punkter

  • Hugging Face Spaces: snabbast, gratis, idealiskt för att komma igång
  • Docker: total kontroll, lämpat för dedikerade servrar och molnet
  • Prefect Horizon (fd FastMCP Cloud): distribution från GitHub, för servrar skrivna med FastMCP-ramverket
  • Cloudflare Workers: serverlös, låg latens, skalbar
  • Säkra med HTTPS, miljövariabler och hastighetsbegränsning
  • Lägg till övervakning och loggar för felsökning i produktion