Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Konfigurér en fjern SSE-server

Lektion 7 af 14 Opdateret 3. november 2026 Udvikler
På denne side
  1. Fra lokal til fjern
  2. Serveren ændrer sig næsten ikke
  3. Få en offentlig URL med ngrok
  4. Forbind en Python-klient
  5. Flere servere på én enkelt vært
  6. Vigtige pointer

Opdatering 2. november 2026 — Le Chat er nu Vibe. Fra den 28. maj 2026 er Le Chat blevet omdøbt til Vibe (stadig på chat.mistral.ai): en enkelt agent til arbejde og kode, der viderefører dine samtaler, indstillinger og abonnementer. Den ældre Le Chat-oplevelse er stadig tilgængelig i Chat-tilstand; i Work-tilstand er agenter nu færdigheder (kaldes med @), hukommelser fungerer som vidensbase, og dyb søgning er færdigheden Deep Research. Abonnementerne hedder nu Mistral Free, Pro, Team og Enterprise. Denne lektion bruger navnet Vibe; nogle menuer beskrevet her kan have ændret navn eller placering. Tillæg 3. november: run_async-resultater læses fra result.output_as_text; mistralai SDK 3.7.0 har ikke et output-attribut.

Opdatering 2. november 2026 — MCP Python SDK v2. Dette kursus følger nu version 2 af mcp-SDK’et (2.3.0 pr. 2. oktober 2026): MCPServer erstatter FastMCP, transportindstillinger flyttes til run() eller streamable_http_app(), og en app, der eksponeres under et rigtigt værtsnavn, skal deklarere dette værtsnavn (transport_security). Dette er også den version, der kræves af Mistral SDK: mistralai[agents]-ekstraniveauet kræver mcp>=2.2.0,<3.0. Kilder: Hvad er nyt i v2 · Migrationsguide · Deploy & scale.

Fra lokal til fjern

Indtil nu har din MCP-server levet på din maskine og kommunikeret via STDIO. Denne tilstand er ideel til udvikling, men den isolerer dit arbejde: ingen andre kan bruge det, og Mistrals Vibe kan aldrig starte en proces på din lokale maskine. For at krydse denne grænse skal du eksponere serveren over HTTP.

Ændringen er mindre, end du måske tror. En fjern MCP-server publicerer sine værktøjer på en URL; klienten – Vibe, et SDK eller en IDE – forbinder over netværket i stedet for at starte en proces. Selve din værktøjskode forbliver uændret.

Serveren ændrer sig næsten ikke

MCPServer understøtter Streamable HTTP-transport nativt. Filen nedenfor er skrevet præcis som en lokal server: samme decorators, samme docstrings, samme typede signaturer.

# remote_server.py
"""Remote MCP server with HTTP transport."""

from mcp.server.mcpserver import MCPServer

# The server is the same as local
app = MCPServer("Remote Demo Server")

@app.tool()
def analyze_text(text: str, language: str = "fr") -> str:
    """Analyze text and return statistics.

    Args:
        text: The text to analyze
        language: Language code (fr, en, es). Default: fr

    Returns:
        Text statistics: word count, character count, sentence count
    """
    words = len(text.split())
    chars = len(text)
    sentences = text.count(".") + text.count("!") + text.count("?")
    return (
        f"Language: {language}\n"
        f"Words: {words}\n"
        f"Characters: {chars}\n"
        f"Sentences: {sentences}"
    )

@app.tool()
def summarize_key_points(text: str, max_points: int = 5) -> str:
    """Extract key points from text (simplified version).

    Args:
        text: The source text
        max_points: Maximum number of points to extract (1-10)

    Returns:
        List of identified key points
    """
    sentences = [s.strip() for s in text.split(".") if len(s.strip()) > 20]
    points = sentences[:max_points]
    return "\n".join(f"- {p}" for p in points) if points else "No key points identified."

Den eneste ændring er en startblok, der er tilføjet til slutningen af filen: HTTP-transport, port og listen over værtsnavne, som serveren accepterer.

import os
from mcp.server.transport_security import TransportSecuritySettings

if __name__ == "__main__":
    # Public hostname, e.g., the one ngrok assigns you (without https://)
    public_host = os.environ.get("MCP_PUBLIC_HOST")
    hosts = ["localhost:*", "127.0.0.1:*"]
    if public_host:
        hosts += [public_host, f"{public_host}:*"]
    app.run(
        transport="streamable-http",
        port=8000,
        transport_security=TransportSecuritySettings(allowed_hosts=hosts),
    )
python remote_server.py

Din server lytter nu på http://localhost:8000/mcp. Listen allowed_hosts er ikke en detalje: Som standard accepterer SDK v2 kun anmodninger adresseret til localhost eller 127.0.0.1, hvilket er en beskyttelse mod DNS-rebinding. Bag en tunnel eller et rigtigt domænenavn vil enhver anden anmodning modtage en fejl 421 Invalid Host header, som klienten viser som en generisk transportfejl; kun serverloggen afslører årsagen.

Få en offentlig URL med ngrok

For at teste din server fra Vibe uden en fuld implementering skaber ngrok en tunnel mellem en offentlig URL og din lokale port. Dette værktøj forkorter udviklingscyklussen mere end noget andet: du modificerer et værktøj, genstarter, og den fjerne connector ser straks den nye version.

# Install the ngrok agent from https://ngrok.com/download, then authenticate (once)
ngrok config add-authtoken YOUR_NGROK_TOKEN

# Expose port 8000
ngrok http 8000

ngrok tildeler dig en adresse som https://abc123.ngrok-free.app. Genstart serveren og deklarer dette værtsnavn (MCP_PUBLIC_HOST=abc123.ngrok-free.app python remote_server.py). Dit MCP-endepunkt bliver dette, blot ved at tilføje stien /mcp:

https://abc123.ngrok-free.app/mcp

Tilføj denne URL, som den er, til Mistral Vibe som en brugerdefineret connector. Husk, at den er midlertidig og eksponerer din maskine: lad ikke en tunnel stå åben på en server, der rører ved rigtige data.

Forbind en Python-klient

På klientsiden forbliver kodestrukturen den samme som i lektionen om RunContext. Kun forbindelsesklassen er anderledes: MCPClientStreamableHTTP med StreamableHTTPServerParams erstatter STDIO-parret, og du angiver en URL i stedet for en kommando.

# remote_client.py
import asyncio
from mistralai.client import Mistral
from mistralai.extra.run.context import RunContext
from mistralai.extra.mcp.streamable_http import (
    MCPClientStreamableHTTP,
    StreamableHTTPServerParams,
)

async def main():
    client = Mistral(api_key="YOUR_API_KEY")

    agent = client.beta.agents.create(
        model="mistral-medium-latest",
        name="remote-assistant",
        instructions="You use remote tools to analyze text.",
    )

    # Connect to the remote server
    server_url = "https://abc123.ngrok-free.app/mcp"
    mcp_client = MCPClientStreamableHTTP(
        params=StreamableHTTPServerParams(
            url=server_url,
            timeout=100,  # Timeout in seconds
        )
    )

    async with RunContext(
        agent_id=agent.id,
        continue_on_fn_error=True,
    ) as run_ctx:
        await run_ctx.register_mcp_client(mcp_client=mcp_client)

        result = await client.beta.conversations.run_async(
            run_ctx=run_ctx,
            inputs="Analyze this text: MCP is an open protocol.",
        )
        print(result.output_as_text)

asyncio.run(main())

Parameteren timeout fortjener et øjebliks overvejelse. Over STDIO var kald næsten øjeblikkelige; over netværket kan et værktøj, der spørger en tredjeparts-API eller behandler et stort dokument, tage flere titals sekunder. En timeout, der er for kort, manifesterer sig som间歇vise, svære at reproducere fejl, normalt ved de mest nyttige anmodninger.

Når serveren forventer specifikke headere – et API-token, en routing-nøgle, en CORS-begrænsning – sender du dem i headers:

mcp_client = MCPClientStreamableHTTP(
    params=StreamableHTTPServerParams(
        url="https://my-server.example.com/mcp",
        timeout=100,
        headers={
            "Authorization": "Bearer my_api_token",
            "X-Custom-Header": "value",
        },
    )
)

Flere servere på én enkelt vært

Lektion 3 anbefalede fokuserede servere frem for en catch-all-katalog. Denne anbefaling dømmer dig ikke til at leje en maskine pr. server: med FastAPI kan du montere flere MCP-servere på forskellige ruter på samme vært.

# server.py — Multiple MCP servers on a single host
from contextlib import asynccontextmanager

from fastapi import FastAPI
from mcp.server.mcpserver import MCPServer
from mcp.server.transport_security import TransportSecuritySettings

# MCP server for text analysis
text_mcp = MCPServer("Text Analysis")

@text_mcp.tool()
def analyze(text: str) -> str:
    """Analyze text."""
    return f"Words: {len(text.split())}"

# MCP server for calculations
math_mcp = MCPServer("Math Tools")

@math_mcp.tool()
def calculate(expression: str) -> str:
    """Evaluate a mathematical expression."""
    return str(eval(expression))  # Warning: eval in production!

# Each MCP server produces a standalone ASGI app,
# which must know the hostname under which it is served
security = TransportSecuritySettings(allowed_hosts=["mon-serveur.com", "mon-serveur.com:*"])
text_app = text_mcp.streamable_http_app(transport_security=security)
math_app = math_mcp.streamable_http_app(transport_security=security)

# Combined lifespan: each server must start its session manager
@asynccontextmanager
async def lifespan(app: FastAPI):
    async with text_mcp.session_manager.run(), math_mcp.session_manager.run():
        yield

api = FastAPI(lifespan=lifespan)
api.mount("/text", text_app)
api.mount("/math", math_app)

Du får to uafhængige endepunkter, https://mon-serveur.com/text/mcp til tekstanalyseværktøjer og https://mon-serveur.com/math/mcp til matematikværktøjer, som du tilføjer separat i Vibe. Det kritiske punkt er lifespan: Hver MCP-server har en sessionshåndtering, der skal startes eksplicit. Hvis du monterer apps uden at sende denne lifespan til FastAPI, svarer serveren, men ethvert værktøjskald fejler med en fejl om en ikke-initialiseret opgave. En bruger, der kun har brug for beregning, vil ikke rode deres kontekst til med tekstværktøjer. Kommentaren om eval er ingen spøg: På et offentligt endepunkt udfører denne linje enhver kode, der sendes af kaldende – det er et pædagogisk eksempel, aldrig et produktionsmønster.

Én sidste refleks: Før du tilføjer din URL til en chat, så kør den gennem Inspektøren igen. Et fjernt endepunkt tilføjer fejlkilder, som lokal udvikling ignorerede – lukket tunnel, manglende header, optaget port – og det er bedre at opdage dem uden for en samtale.

Vigtige pointer

  • En fjern MCP-server eksponerer sine værktøjer via HTTP på et /mcp-endepunkt
  • ngrok giver dig mulighed for at få en offentlig URL til udvikling
  • MCPClientStreamableHTTP med StreamableHTTPServerParams forbinder klienten til den fjerne server (MCPClientSSE er nu kun til ældre /sse-endepunkter)
  • Parameteren timeout er vigtig for langsomme servere
  • Du kan montere flere MCP-servere på samme FastAPI-vært, forudsat at du sender deres lifespan
  • Test altid med Inspektøren, før du integrerer i en chat