Konfigurácia vzdialeného servera SSE
Na tejto strane
Aktualizácia 2. novembra 2026 — Le Chat je teraz Vibe. Od 28. mája 2026 bol Le Chat premenovaný na Vibe (stále na chat.mistral.ai): jediný agent pre prácu a kód, ktorý si zachováva tvoje konverzácie, nastavenia a predplatné. Pôvodné prostredie Le Chat zostáva dostupné v režime Chat; v režime Work sú agenti teraz zručnosti (vyvolávané pomocou
@), pamäte slúžia ako znalostná báza a hľadávanie do hĺbky je zručnosť Deep Research. Plány sa teraz nazývajú Mistral Free, Pro, Team a Enterprise. Táto lekcia používa názov Vibe; niektoré tu opísané ponuky mohli zmeniť názvy alebo umiestnenie. Dodatok 3. novembra: výsledkyrun_asyncsa čítajú zresult.output_as_text; SDKmistralaiverzie 3.7.0 nemá atribútoutput.
Aktualizácia 2. novembra 2026 — MCP Python SDK v2. Tento kurz teraz nasleduje verziu 2 SDK
mcp(2.3.0 k 2. októbru 2026):MCPServernahrádzaFastMCP, nastavenia transportu sa presúvajú dorun()alebostreamable_http_app()a aplikácia vystavená pod skutočným názvom hostiteľa musí tento názov hostiteľa deklarárovať (transport_security). Toto je tiež verzia požadovaná Mistral SDK: extra balíkmistralai[agents]vyžadujemcp>=2.2.0,<3.0. Zdroje: Čo je nové vo v2 · Sprievodca migráciou · Nasadenie a škálovanie.
Prechod z lokálneho na vzdialené
Doteraz tvoj MCP server bežal na tvojom stroji a komunikoval cez STDIO. Tento režim je ideálny pre vývoj, ale izoluje tvoju prácu: nikto iný ho nemôže používať a Vibe od Mistralu nikdy nespustí proces na tvojom lokálnom stroji. Aby si prekročil túto hranicu, musíš server vystaviť cez HTTP.
Zmena je ľahšia, než si možno myslíš. Vzdialený MCP server publikuje svoje nástroje na URL adrese; klient – či už Vibe, SDK alebo IDE – sa pripojí cez sieť namiesto spúšťania procesu. Tvoj kód nástrojov zostáva nezmenený.
Server sa takmer nemení
MCPServer natívne podporuje transport Streamable HTTP. Nižšie uvedený súbor je napísaný presne ako lokálny server: rovnaké dekorátory, rovnaké docstringy, rovnaké typované signatúry.
# 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 zmenou je blok spustenia pridaný na koniec súboru: transport HTTP, port a zoznam názvov hostiteľov, ktoré server prijíma.
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
Tvoj server teraz počúva na http://localhost:8000/mcp. Zoznam allowed_hosts nie je detail: SDK v2 predvolene prijíma iba požiadavky adresované na localhost alebo 127.0.0.1, čo je ochrana proti DNS rebindingu. Za tunelom alebo skutočným doménovým menom akákoľvek iná požiadavka dostane chybu 421 Invalid Host header, ktorú klient zobrazí ako všeobecnú chybu transportu; dôvod odhalí až log servera.
Získanie verejnej URL adresy pomocou ngrok
Ak chceš otestovať svoj server z Vibe bez plného nasadenia, ngrok vytvorí tunel medzi verejnou URL adresou a tvojím lokálnym portom. Tento nástroj skracuje vývojový cyklus viac než čokoľvek iné: upravíš nástroj, reštartuješ ho a vzdialený konektor okamžite vidí novú verziu.
# 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 ti pridelí adresu ako https://abc123.ngrok-free.app. Reštartuj server s deklaráciou tohto názvu hostiteľa (MCP_PUBLIC_HOST=abc123.ngrok-free.app python remote_server.py). Tvoj koncový bod MCP sa stane týmto, jednoducho pripojením cesty /mcp:
https://abc123.ngrok-free.app/mcp
Pridaj túto URL adresu tak, ako je, do Mistral Vibe ako vlastný konektor. Pamätaj, že je dočasná a vystavuje tvoj stroj: nenechávaj tunel otvorený na serveri, ktorý pracuje so skutočnými dátami.
Pripojenie klienta v Pythone
Na strane klienta zostáva štruktúra kódu rovnaká ako v lekcii RunContext. Líši sa iba trieda pripojenia: MCPClientStreamableHTTP s StreamableHTTPServerParams nahrádza pár STDIO a poskytuješ URL adresu namiesto prí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())
Parameter timeout si zaslúži chvíľu zamyslenia. Pri STDIO boli volania takmer okamžité; cez sieť môže nástroj queryujúci API tretej strany alebo spracovávajúci veľký dokument trvať niekoľko desiatok sekúnd. Príliš krátky timeout sa prejaví ako občasné, ťažko reprodukovateľné chyby, zvyčajne pri najužitočnejších požiadavkách.
Keď server očakáva špecifické hlavičky – API token, smerovací kľúč, obmedzenie CORS – odovzdáš ich 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",
},
)
)
Viacero serverov na jednom hostiteľovi
Lekcia 3 odporúčala cielené servery namiesto katalógu „pre všetko“. Toto odporúčanie ťa neodsudzuje na prenájom stroja pre každý server: pomocou FastAPI môžeš namontovať viacero MCP serverov na rôzne trasy toho istého hostiteľa.
# 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ískaš dva nezávislé koncové body, https://mon-serveur.com/text/mcp pre nástroje na analýzu textu a https://mon-serveur.com/math/mcp pre matematické nástroje, ktoré pridáš do Vibe samostatne. Kritickým bodom je lifespan: každý MCP server má správcu relácie, ktorý sa musí explicitne spustiť. Ak namontuješ aplikácie bez odovzdania tohto lifespan do FastAPI, server odpovie, ale každé volanie nástroja zlyhá s chybou neinicializovanej úlohy. Používateľ, ktorý potrebuje iba výpočty, si nezaplní kontext nástrojmi na text. Poznámka pri eval nie je vtip: na verejnom koncovom bode tento riadok vykoná akýkoľvek kód odoslaný volajúcim – je to pedagogický príklad, nikdy vzor pre produkciu.
Ešte jedna posledná reflexia: pred pridaním svojej URL adresy do chatu ju znova spusti cez Inspector. Vzdialený koncový bod pridáva zdroje zlyhaní, ktoré lokálne ignorované – uzavretý tunel, chýbajúca hlavička, obsadený port – a je lepšie objaviť ich mimo konverzácie.
Kľúčové poznatky
- Vzdialený MCP server vystavuje svoje nástroje cez HTTP na koncovom bode
/mcp - ngrok ti umožňuje získať verejnú URL adresu pre vývoj
MCPClientStreamableHTTPsStreamableHTTPServerParamspripája klienta k vzdialenému serveru (MCPClientSSEje teraz určený iba pre staršie koncové body/sse)- Parameter timeout je dôležitý pre pomalé servery
- Na rovnakom hostiteľovi FastAPI môžeš namontovať viacero MCP serverov, za predpokladu, že im odovzdáš ich lifespan
- Pred integráciou do chatu vždy otestuj pomocou Inspector