Configurarea unui server SSE la distanță
Pe această pagină
Actualizare 2 noiembrie 2026 — Le Chat devine Vibe. Începând cu 28 mai 2026, Le Chat a fost rebotezat Vibe (rămâne la chat.mistral.ai): un singur agent pentru muncă și cod, care preia conversațiile, setările și abonamentele dumneavoastră. Experiența legacy Le Chat rămâne disponibilă în modul Chat; în modul Work, agenții sunt acum competențe (invocate cu
@'), memoriile servesc drept bază de cunoștințe, iar căutarea aprofundată este competența Deep Research. Planurile se numesc acum Mistral Free, Pro, Team și Enterprise. Această lecție folosește denumirea Vibe; unele meniuri descrise aici își pot fi schimbat numele sau locația. *Adendument 3 noiembrie: rezultatelerun_asyncse citesc dinresult.output_as_text; SDK-ulmistralaiversiunea 3.7.0 nu are un atributoutput`.*
Actualizare 2 noiembrie 2026 — MCP Python SDK v2. Acest curs urmează acum versiunea 2 a SDK-ului
mcp(2.3.0 la data de 2 octombrie 2026):MCPServerînlocuieșteFastMCP, setările de transport se mută înrun()saustreamable_http_app(), iar o aplicație expusă sub un nume de gazdă real trebuie să declare acel nume de gazdă (transport_security). Aceasta este, de asemenea, versiunea cerută de Mistral SDK: extra-ulmistralai[agents]necesitămcp>=2.2.0,<3.0. Surse: Ce este nou în v2 · Ghid de migrare · Deploy & scale.
Trecerea de la local la distanță
Până acum, serverul dumneavoastră MCP a rulat pe mașina locală, comunicând prin STDIO. Acest mod este ideal pentru dezvoltare, dar izolează munca: nimeni altcineva nu îl poate utiliza, iar Vibe de la Mistral nu poate lansa niciodată un proces pe mașina dumneavoastră locală. Pentru a trece această barieră, trebuie să expuneți serverul prin HTTP.
Schimbarea este mai ușoară decât ați putea crede. Un server MCP la distanță își publică instrumentele la o adresă URL; clientul — Vibe, un SDK sau un IDE — se conectează prin rețea în loc să lanseze un proces. Codul instrumentelor dumneavoastră rămâne neschimbat.
Serverul se schimbă abia deloc
MCPServer suportă nativ transportul Streamable HTTP. Fișierul de mai jos este scris exact ca un server local: aceiași decoratori, aceleași docstring-uri, aceleași semnături tipizate.
# 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."
Singura modificare este un bloc de lansare adăugat la sfârșitul fișierului: transport HTTP, port și lista de nume de gazdă pe care serverul le acceptă.
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
Serverul dumneavoastră ascultă acum pe http://localhost:8000/mcp. Lista allowed_hosts nu este un detaliu: implicit, SDK-ul v2 acceptă doar cererile adresate lui localhost sau 127.0.0.1, o protecție împotriva DNS rebinding. În spatele unui tunel sau al unui nume de domeniu real, orice altă cerere primește o eroare 421 Invalid Host header, pe care clientul o afișează ca o eroare generică de transport; doar jurnalul serverului dezvăluie motivul.
Obținerea unei adrese URL publice cu ngrok
Pentru a testa serverul din Vibe fără o implementare completă, ngrok creează un tunel între o adresă URL publică și portul dumneavoastră local. Acest instrument scurtează bucla de dezvoltare mai mult decât orice altceva: modificați un instrument, reporniți, iar conectorul la distanță vede imediat noua versiune.
# 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ă atribuie o adresă precum https://abc123.ngrok-free.app. Reporniți serverul declarând acest nume de gazdă (MCP_PUBLIC_HOST=abc123.ngrok-free.app python remote_server.py). Punctul dumneavoastră final MCP devine acesta, simplu prin adăugarea căii /mcp:
https://abc123.ngrok-free.app/mcp
Adăugați această adresă URL ca atare în Mistral Vibe ca un conector personalizat. Rețineți că este temporară și expune mașina dumneavoastră: nu lăsați un tunel deschis pe un server care atinge date reale.
Conectarea unui client Python
În partea clientului, structura codului rămâne aceeași ca în lecția RunContext. Doar clasa de conexiune diferă: MCPClientStreamableHTTP cu StreamableHTTPServerParams înlocuiește perechea STDIO, iar dumneavoastră furnizați o adresă URL în loc de o comandă.
# 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())
Parametrul timeout merită o clipă de reflecție. Prin STDIO, apelurile erau aproape instantanee; prin rețea, un instrument care interoghează un API terț sau procesează un document mare poate dura câteva zeci de secunde. Un timeout prea scurt se manifestă prin erori intermitente, greu de reprodus, de obicei la cele mai utile cereri.
Când serverul așteaptă anteturi specifice — un token API, o cheie de rutare, o constrângere CORS — le transmiteți în 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",
},
)
)
Multiple servere pe o singură gazdă
Lecția 3 a recomandat servere focalizate în loc de un catalog generalist. Această recomandare nu vă condamnă să închiriați o mașină per server: cu FastAPI, puteți monta multiple servere MCP pe rute distincte ale aceleiași gazde.
# 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)
Obțineți două puncte finale independente, https://mon-serveur.com/text/mcp pentru instrumentele de analiză a textului și https://mon-serveur.com/math/mcp pentru instrumentele matematice, pe care le adăugați separat în Vibe. Punctul critic este lifespan: fiecare server MCP are un manager de sesiune care trebuie pornit explicit. Dacă montați aplicațiile fără a trece acest lifespan către FastAPI, serverul răspunde, dar fiecare apel de instrument eșuează cu o eroare de sarcină neinițializată. Un utilizator care are nevoie doar de calcul nu își va aglomera contextul cu instrumente de text. Comentariul despre eval nu este o glumă: pe un punct final public, această linie execută orice cod trimis de apelant — este un exemplu pedagogic, niciodată un model de producție.
Un ultim reflex: înainte de a adăuga adresa URL într-un chat, rulați-o din nou prin Inspector. Un punct final la distanță adaugă surse de eșec pe care cele locale le ignorau — tunel închis, antet lipsă, port ocupat — și este mai bine să le descoperiți în afara unei conversații.
Puncte cheie
- Un server MCP la distanță își expune instrumentele prin HTTP pe un punct final
/mcp - ngrok vă permite să obțineți o adresă URL publică pentru dezvoltare
MCPClientStreamableHTTPcuStreamableHTTPServerParamsconectează clientul la serverul la distanță (MCPClientSSEeste acum doar pentru punctele finale legacy/sse)- Parametrul timeout este important pentru serverele lente
- Puteți monta multiple servere MCP pe aceeași gazdă FastAPI, cu condiția să le transmiteți lifespan-ul lor
- Testați întotdeauna cu Inspectorul înainte de a integra într-un chat