Seadista kaug-SSE server
Sellel lehel
Uuendus 2. november 2026 — Le Chat on nüüd Vibe. Alates 28. maist 2026 on Le Chat ümber bränditud nimele Vibe (aadressil chat.mistral.ai): üks agent tööks ja kodeerimiseks, säilitades sinu vestlused, seaded ja tellimused. Pärandunud Le Chat’i kasutajakogemus on endiselt saadaval režiimis Chat; režiimis Work on agendid nüüd oskused (kutsutakse esile sümboliga
@), mälud toimivad teadmiste baasina ja sügav otsing on oskus Deep Research. Plaanid kannavad nüüd nimesid Mistral Free, Pro, Team ja Enterprise. Selles õppetükis kasutame nime Vibe; mõned siin kirjeldatud menüüd võivad olla muutnud nime või asukohta. Lisand 3. november:run_asynctulemused loetakse väljaltresult.output_as_text;mistralaiSDK versioonil 3.7.0 puudub atribuutoutput.
Uuendus 2. november 2026 — MCP Python SDK v2. See kursus järgib nüüd
mcpSDK versiooni 2 (2.3.0 seisuga 2. oktoober 2026):MCPServerasendabFastMCP-i, transpordi seaded liiguvad meetoditesserun()võistreamable_http_app()ja reaalse hostinime all avaldatud rakendus peab selle hostinime deklareerima (transport_security). See on ka versioon, mida nõuab Mistral SDK: lisamistralai[agents]eeldabmcp>=2.2.0,<3.0. Allikad: Mis on uut v2-s · Migreerimisjuhend · Kasutuselevõtt ja skaleerimine.
Liikumine lokaalselt kaugserverisse
Seni on sinu MCP server asunud sinu masinas ja suhelnud STDIO kaudu. See režiim on arenduseks ideaalne, kuid isoleerib sinu töö: keegi teine ei saa seda kasutada ja Mistrali Vibe ei saa kunagi käivitada protsessi sinu lokaalses masinas. Selle piiri ületamiseks pead serveri avalikustama HTTP kaudu.
Muutus on kergem, kui võiksid arvata. Kauge MCP server avaldab oma tööriistad URL-il; klient – olgu selleks Vibe, SDK või IDE – ühendub võrgu kaudu, selle asemel et protsessi käivitada. Sinu tööriistakood ise jääb muutumatuks.
Server muutub vaevalt
MCPServer toetab Streamable HTTP transporti loomupäraselt. Allpool olev fail on kirjutatud täpselt nagu lokaalne server: samad dekoratorid, samad dokumendistringid, samad tüübitud signatuurid.
# 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."
Ainus muutus on faili lõppu lisatud käivitusplokk: HTTP transport, port ja hostinimede loend, mida server aktsepteerib.
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
Sinu server kuulab nüüd aadressil http://localhost:8000/mcp. Loend allowed_hosts ei ole tühiasi: vaikimisi aktsepteerib SDK v2 ainult päringuid, mis on adresseeritud localhost-ile või 127.0.0.1-le, mis on kaitse DNS-i ümbersuunamise (DNS rebinding) eest. Tunneli või reaalse domeeninime taga tagastatakse igale muule päringule viga 421 Invalid Host header, mille klient kuvab üldise transpordiveana; põhjuse paljastab ainult serveri logi.
Avaliku URL-i hankimine ngrokiga
Et testida oma serverit Vibes ilma täieliku kasutuselevõtuta, loob ngrok tunneli avaliku URL-i ja sinu lokaalse pordi vahel. See tööriist lühendab arendustsüklit rohkem kui ükski teine: muudad tööriista, taaskäivitad ja kaugühendus näeb uut versiooni koheselt.
# 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 määrab sulle aadressi kujul https://abc123.ngrok-free.app. Taaskäivita server, deklareerides selle hostinime (MCP_PUBLIC_HOST=abc123.ngrok-free.app python remote_server.py). Sinu MCP lõpp-punktiks saab see, lihtsalt lisades tee /mcp:
https://abc123.ngrok-free.app/mcp
Lisa see URL muutumatul kujul Mistral Vibe’i kohandatud ühendusena. Pea meeles, et see on ajutine ja paljastab sinu masina: ära jäta tunnelit lahti serverile, mis puutub kokku reaalsete andmetega.
Pythoni kliendi ühendamine
Kliendi poolel jääb koodi struktuur samaks, mis oli tunnis RunContext. Erineb ainult ühenduse klass: MCPClientStreamableHTTP koos StreamableHTTPServerParams-ga asendab STDIO paari ja sa annad URL-i, mitte käsu.
# 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())
Parameeter timeout väärib mõtlemist. STDIO kaudu olid väljakutsed peaaegu hetkelised; võrgu kaudu võib tööriist, mis pärib kolmanda osapoole API-t või töötleb suurt dokumenti, võtta mitukümmend sekundit. Liiga lühike aegumine avaldub katkendlike, raskesti reprodutseeritavate vigadena, tavaliselt kõige kasulikumate päringute puhul.
Kui server eeldab spetsiifilisi päiseid – API tokenit, marsruutimisvõtit, CORS-i piirangut – edastad need parameetris 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",
},
)
)
Mitu serverit ühel hostil
Tund 3 soovitas keskendunud servereid üldise kataloogi asemel. See soovitus ei mõista sind hukka rentima masinat iga serveri jaoks: FastAPI abil saad paigaldada mitu MCP serverit sama hosti erinevatele teedele.
# 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)
Saad kaks sõltumatut lõpp-punkti: https://mon-serveur.com/text/mcp tekstianalüüsi tööriistade jaoks ja https://mon-serveur.com/math/mcp matemaatikate tööriistade jaoks, mille lisad Vibes eraldi. Kriitiline punkt on lifespan: igal MCP serveril on seansihaldur, mis tuleb sõnaselgelt käivitada. Kui paigaldad rakendused ilma seda lifespan-i FastAPI-le edastamata, vastab server küll, kuid iga tööriista väljakutse ebaõnnestub initialiseerimata ülesande veaga. Kasutaja, kes vajab ainult arvutusi, ei koorma oma konteksti teksti tööriistadega. Märkus eval-i kohta ei ole nali: avalikus lõpp-punktis käivitab see rida koodi, mille saatja on saatnud – see on pedagoogiline näide, mitte kunagi tootmismuster.
Viimane refleks: enne URL-i vestlusesse lisamist käivita see uuesti Inspektoris. Kauge lõpp-punkt lisab tõrkeallikaid, mida lokaalne keskkond eiras – suletud tunnel, puuduv päis, hõivatud port – ja parem on need avastada väljaspool vestlust.
Peamised punktid
- Kauge MCP server avaldab oma tööriistad HTTP kaudu lõpp-punktis
/mcp - ngrok võimaldab arenduseks hankida avaliku URL-i
MCPClientStreamableHTTPkoosStreamableHTTPServerParams-ga ühendab kliendi kaugserveriga (MCPClientSSEon nüüd mõeldud ainult pärandunud lõpp-punktidele/sse)- Parameeter timeout on oluline aeglaste serverite jaoks
- Saad paigaldada mitu MCP serverit samale FastAPI hostile, tingimusel et edastad nende lifespan
- Testi alati Inspektoriga enne vestlusse integreerimist