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

Konfigurera en fjärrstyrd SSE-server

Lektion 7 av 14 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Från lokal till fjärrstyrd
  2. Servern ändras knappt alls
  3. Hämta en offentlig URL med ngrok
  4. Ansluta en Python-klient
  5. Flera servrar på en enda värd
  6. Viktiga punkter

Uppdatering 2 november 2026 — Le Chat är nu Vibe. Från och med 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 kvar i läget Chat; i läget Work är agenter nu färdigheter (anropas med @), minnen fungerar som kunskapsbas och djup sökning är färdigheten Deep Research. Planerna heter nu Mistral Free, Pro, Team och Enterprise. Denna lektion använder namnet Vibe; vissa menyer som beskrivs här kan ha bytt namn eller plats. Tillägg 3 november: Resultat från run_async läses från result.output_as_text; mistralai SDK 3.7.0 har inget attribut output.

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: 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 lokal till fjärrstyrd

Hittills har din MCP-server funnits på din egen maskin och kommunicerat via STDIO. Detta läge är idealiskt för utveckling, men det isolerar ditt arbete: ingen annan kan använda det, och Mistral Vibe kan aldrig starta en process på din lokala maskin. För att överbrygga detta måste du exponera servern över HTTP.

Ändringen är mindre än du kanske tror. En fjärrstyrd MCP-server publicerar sina verktyg på en URL; klienten – Vibe, ett SDK eller en IDE – ansluter över nätverket istället för att starta en process. Själva verktygskoden förblir oförändrad.

Servern ändras knappt alls

MCPServer har inbyggt stöd för Streamable HTTP-transport. Filen nedan är skriven exakt som en lokal server: samma dekoratorer, samma docstrings, samma typade 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 enda ändringen är ett startblock som lagts till i slutet av filen: HTTP-transport, port och listan över värdnamn som servern accepterar.

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 lyssnar nu på http://localhost:8000/mcp. Listan allowed_hosts är ingen detalj: som standard accepterar SDK v2 endast förfrågningar riktade till localhost eller 127.0.0.1, ett skydd mot DNS-rebinding. Bakom en tunnel eller ett riktigt domännamn får alla andra förfrågningar felet 421 Invalid Host header, vilket klienten visar som ett generiskt transportfel; endast serverloggen avslöjar orsaken.

Hämta en offentlig URL med ngrok

För att testa din server från Vibe utan en fullständig distribution skapar ngrok en tunnel mellan en offentlig URL och din lokala port. Detta verktyg förkortar utvecklingscykeln mer än något annat: du modifierar ett verktyg, startar om, och den fjärrstyrda kontakten ser den nya versionen omedelbart.

# 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 tilldelar dig en adress som https://abc123.ngrok-free.app. Starta om servern och deklarera detta värdnamn (MCP_PUBLIC_HOST=abc123.ngrok-free.app python remote_server.py). Din MCP-slutpunkt blir då denna, helt enkelt genom att lägga till sökvägen /mcp:

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

Lägg till denna URL som den är i Mistral Vibe som en anpassad kontakt. Kom ihåg att den är tillfällig och exponerar din maskin: låt inte en tunnel vara öppen på en server som hanterar riktig data.

Ansluta en Python-klient

På klientsidan förblir kodstrukturen densamma som i lektionen om RunContext. Endast anslutningsklassen skiljer sig: MCPClientStreamableHTTP med StreamableHTTPServerParams ersätter STDIO-paret, och du anger en URL istället för ett 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())

Parametern timeout förtjänar en tanke. Över STDIO var anrop nästan omedelbara; över nätverket kan ett verktyg som frågar ett tredjeparts-API eller bearbetar ett stort dokument ta flera tiotals sekunder. En timeout som är för kort yttrar sig som intermittenta, svårreproducerbara fel, vanligtvis vid de mest användbara förfrågningarna.

När servern förväntar sig specifika rubriker – en API-token, en routningsnyckel, en CORS-begränsning – skickar 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",
        },
    )
)

Flera servrar på en enda värd

Lektion 3 rekommenderade fokuserade servrar snarare än en catch-all-katalog. Denna rekommendation dömer dig inte till att hyra en maskin per server: med FastAPI kan du montera flera MCP-servrar på distinkta rutter för samma värd.

# 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 två oberoende slutpunkter, https://mon-serveur.com/text/mcp för textanalysverktyg och https://mon-serveur.com/math/mcp för matematikverktyg, som du lägger till separat i Vibe. Den kritiska punkten är lifespan: varje MCP-server har en sessionshanterare som måste startas explicit. Om du monterar apparna utan att skicka denna lifespan till FastAPI svarar servern, men varje verktygsanrop misslyckas med ett fel om oinitierad uppgift. En användare som bara behöver beräkningar kommer inte att röra till sin kontext med textverktyg. Kommentaren om eval är inget skämt: på en offentlig slutpunkt kör denna rad vilken kod som helst som skickas av anroparen – det är ett pedagogiskt exempel, aldrig ett produktionsmönster.

En sista reflex: innan du lägger till din URL i en chatt, kör den genom Inspector igen. En fjärrstyrd slutpunkt lägger till felkällor som lokalen ignorerade – stängd tunnel, saknad rubrik, upptagen port – och det är bättre att upptäcka dem utanför en konversation.

Viktiga punkter

  • En fjärrstyrd MCP-server exponerar sina verktyg via HTTP på en /mcp-slutpunkt
  • ngrok låter dig hämta en offentlig URL för utveckling
  • MCPClientStreamableHTTP med StreamableHTTPServerParams ansluter klienten till den fjärrstyrda servern (MCPClientSSE är nu endast för äldre /sse-slutpunkter)
  • Parametern timeout är viktig för långsamma servrar
  • Du kan montera flera MCP-servrar på samma FastAPI-värd, förutsatt att du skickar deras lifespan
  • Testa alltid med Inspector innan du integrerar i en chatt