Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Konfigurace vzdáleného SSE serveru

Lekce 7 z 14 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Přechod z lokálního na vzdálené
  2. Server se téměř nemění
  3. Získání veřejné URL pomocí ngrok
  4. Připojení Python klienta
  5. Více serverů na jednom hostiteli
  6. Klíčové poznatky

Aktualizace 2. listopadu 2026 — Le Chat je nyní Vibe. Od 28. května 2026 byl Le Chat přejmenován na Vibe (stále na chat.mistral.ai): jediný agent pro práci i kód, který si ponechává vaše konverzace, nastavení a předplatná. Původní prostředí Le Chat zůstává dostupné v režimu Chat; v režimu Work jsou agenti nyní dovednosti (vyvolávané pomocí @), paměti slouží jako znalostní báze a hluboké vyhledávání je dovednost Deep Research. Plány se nyní nazývají Mistral Free, Pro, Team a Enterprise. Tato lekce používá název Vibe; některá zde popsaná menu mohla změnit názvy nebo umístění. Dodatek 3. listopadu: výsledky run_async se čtou z result.output_as_text; SDK mistralai verze 3.7.0 nemá atribut output.

Aktualizace 2. listopadu 2026 — MCP Python SDK v2. Tento kurz nyní následuje verzi 2 SDK mcp (2.3.0 k 2. říjnu 2026): MCPServer nahrazuje FastMCP, nastavení transportu se přesouvá do run() nebo streamable_http_app() a aplikace vystavená pod skutečným hostname musí tento hostname deklarovat (transport_security). Toto je také verze požadovaná Mistral SDK: extra balíček mistralai[agents] vyžaduje mcp>=2.2.0,<3.0. Zdroje: Co je nového ve v2 · Průvodce migrací · Nasazení a škálování.

Přechod z lokálního na vzdálené

Až doposud běžel váš MCP server na vašem stroji a komunikoval přes STDIO. Tento režim je ideální pro vývoj, ale izoluje vaši práci: nikdo jiný jej nemůže použít a Mistral Vibe nikdy nemůže spustit proces na vašem lokálním stroji. Chcete-li tuto hranici překročit, musíte server zpřístupnit přes HTTP.

Změna je lehčí, než si možná myslíte. Vzdálený MCP server publikuje své nástroje na URL; klient – ať už Vibe, SDK nebo IDE – se připojí přes síť místo spouštění procesu. Kód vašeho nástroje samotný zůstává nezměněn.

Server se téměř nemění

MCPServer nativně podporuje transport Streamable HTTP. Níže uvedený soubor je napsán přesně jako lokální server: stejné dekorátory, stejné docstringy, stejné typované signatury.

# 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."

Jedinou změnou je blok spuštění přidaný na konec souboru: transport HTTP, port a seznam hostname, které server přijímá.

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

Váš server nyní naslouchá na http://localhost:8000/mcp. Seznam allowed_hosts není detail: ve výchozím nastavení SDK v2 přijímá pouze požadavky adresované na localhost nebo 127.0.0.1, což je ochrana proti DNS rebindingu. Za tunelem nebo skutečným doménovým jménem jakýkoli jiný požadavek obdrží chybu 421 Invalid Host header, kterou klient zobrazí jako obecnou chybu transportu; důvod odhalí pouze log serveru.

Získání veřejné URL pomocí ngrok

Chcete-li svůj server testovat z Vibe bez plného nasazení, ngrok vytvoří tunel mezi veřejnou URL a vaším lokálním portem. Tento nástroj zkracuje vývojový cyklus více než cokoli jiného: upravíte nástroj, restartujete jej a vzdálený konektor okamžitě vidí novou verzi.

# 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 vám přidělí adresu jako https://abc123.ngrok-free.app. Restartujte server s deklarací tohoto hostname (MCP_PUBLIC_HOST=abc123.ngrok-free.app python remote_server.py). Váš koncový bod MCP se stane tímto, jednoduše připojením cesty /mcp:

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

Přidejte tuto URL tak, jak je, do Mistral Vibe jako vlastní konektor. Pamatujte, že je dočasná a vystavuje váš stroj: nenechávejte tunel otevřený na serveru, který pracuje se skutečnými daty.

Připojení Python klienta

Na straně klienta zůstává struktura kódu stejná jako v lekci RunContext. Liší se pouze třída připojení: MCPClientStreamableHTTP s StreamableHTTPServerParams nahrazuje pár STDIO a poskytujete URL místo příkazu.

# 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())

Parametr timeout si zaslouží chvíli zamyšlení. Přes STDIO byly volání téměř okamžitá; přes síť může nástroj dotazující externí API nebo zpracovávající velký dokument trvat několik desítek sekund. Příliš krátký timeout se projeví jako přerušované, těžko reprodukovatelné chyby, obvykle u nejužitečnějších požadavků.

Když server očekává specifické hlavičky – API token, směrovací klíč, omezení CORS – předáte je v 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",
        },
    )
)

Více serverů na jednom hostiteli

Lekce 3 doporučovala zaměřené servery místo univerzálního katalogu. Toto doporučení vás neodsuzuje k pronájmu stroje pro každý server: s FastAPI můžete namontovat více MCP serverů na různé trasy stejného hostitele.

# 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)

Získáte dva nezávislé koncové body, https://mon-serveur.com/text/mcp pro nástroje analýzy textu a https://mon-serveur.com/math/mcp pro matematické nástroje, které přidáte do Vibe samostatně. Klíčovým bodem je lifespan: každý MCP server má správce relace, který musí být explicitně spuštěn. Pokud namontujete aplikace bez předání tohoto lifespan do FastAPI, server odpoví, ale každé volání nástroje selže s chybou neinicializované úlohy. Uživatel, který potřebuje pouze výpočty, si nebude znečišťovat kontext textovými nástroji. Komentář u eval není vtip: na veřejném koncovém bodě tento řádek spustí jakýkoli kód odeslaný volajícím – jde o pedagogický příklad, nikdy o produkční vzor.

Ještě jedna poslední reflexe: než přidáte svou URL do chatu, spusťte ji znovu přes Inspector. Vzdálený koncový bod přidává zdroje selhání, které lokální ignoroval – uzavřený tunel, chybějící hlavička, obsazený port – a je lepší je objevit mimo konverzaci.

Klíčové poznatky

  • Vzdálený MCP server vystavuje své nástroje přes HTTP na koncovém bodu /mcp
  • ngrok vám umožní získat veřejnou URL pro vývoj
  • MCPClientStreamableHTTP s StreamableHTTPServerParams připojuje klienta ke vzdálenému serveru (MCPClientSSE je nyní pouze pro zastaralé koncové body /sse)
  • Parametr timeout je důležitý pro pomalé servery
  • Na stejném hostiteli FastAPI můžete namontovat více MCP serverů, pokud jim předáte jejich lifespan
  • Před integrací do chatu vždy testujte pomocí Inspectoru