Configurer un serveur SSE distant
Šiame puslapyje
Mise à jour du 2 novembre 2026 — Le Chat devient Vibe. Depuis le 28 mai 2026, Le Chat a été rebaptisé Vibe (toujours sur chat.mistral.ai) : un agent unique pour le travail et le code, conservant vos conversations, paramètres et abonnements. L’expérience historique de Le Chat reste disponible en mode Chat ; en mode Work, les agents sont désormais des compétences (invoquées avec
@), les mémoires servent de base de connaissances et la recherche approfondie est la compétence Deep Research. Les formules s’appellent désormais Mistral Free, Pro, Team et Enterprise. Cette leçon utilise le nom Vibe ; certains menus décrits ici peuvent avoir changé de nom ou d’emplacement. Addendum du 3 novembre : les résultats derun_asyncse lisent viaresult.output_as_text; le SDKmistralai3.7.0 ne possède pas d’attributoutput.
Mise à jour du 2 novembre 2026 — MCP Python SDK v2. Ce cours suit désormais la version 2 du SDK
mcp(2.3.0 au 2 octobre 2026) :MCPServerremplaceFastMCP, les paramètres de transport migrent versrun()oustreamable_http_app(), et une application exposée sous un vrai nom d’hôte doit le déclarer (transport_security). C’est aussi la version requise par le SDK Mistral : l’extramistralai[agents]exigemcp>=2.2.0,<3.0. Sources : Nouveautés de la v2 · Guide de migration · Déploiement et mise à l’échelle.
Du local au distant
Jusqu’à présent, ton serveur MCP tournait sur ta machine, communiquant via STDIO. Ce mode est idéal pour le développement, mais il isole ton travail : personne d’autre ne peut l’utiliser, et Vibe de Mistral ne peut jamais lancer de processus sur ta machine locale. Pour franchir cette frontière, tu dois exposer le serveur via HTTP.
Le changement est plus léger qu’il n’y paraît. Un serveur MCP distant publie ses outils à une URL ; le client — Vibe, un SDK ou un IDE — se connecte via le réseau au lieu de lancer un processus. Ton code d’outil reste inchangé.
Le serveur change à peine
MCPServer prend nativement en charge le transport HTTP streamable. Le fichier ci-dessous s’écrit exactement comme un serveur local : mêmes décorateurs, mêmes docstrings, mêmes signatures typées.
# 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."
La seule modification est un bloc de lancement ajouté à la fin du fichier : transport HTTP, port et liste des noms d’hôte acceptés par le serveur.
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
Ton serveur écoute désormais sur http://localhost:8000/mcp. La liste allowed_hosts n’est pas un détail : par défaut, le SDK v2 n’accepte que les requêtes adressées à localhost ou 127.0.0.1, une protection contre le DNS rebinding. Derrière un tunnel ou un vrai nom de domaine, toute autre requête reçoit une erreur 421 Invalid Host header, que le client affiche comme une erreur de transport générique ; seul le journal du serveur révèle la raison.
Obtenir une URL publique avec ngrok
Pour tester ton serveur depuis Vibe sans déploiement complet, ngrok crée un tunnel entre une URL publique et ton port local. Cet outil raccourcit la boucle de développement plus que tout autre : tu modifies un outil, redémarres, et le connecteur distant voit immédiatement la nouvelle version.
# 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 t’assigne une adresse comme https://abc123.ngrok-free.app. Redémarre le serveur en déclarant ce nom d’hôte (MCP_PUBLIC_HOST=abc123.ngrok-free.app python remote_server.py). Ton point de terminaison MCP devient simplement ceci, en ajoutant le chemin /mcp :
https://abc123.ngrok-free.app/mcp
Ajoute cette URL telle quelle à Mistral Vibe en tant que connecteur personnalisé. Rappelle-toi qu’elle est temporaire et expose ta machine : ne laisse pas un tunnel ouvert sur un serveur touchant à de vraies données.
Connecter un client Python
Côté client, la structure du code reste la même que dans la leçon sur RunContext. Seule la classe de connexion diffère : MCPClientStreamableHTTP avec StreamableHTTPServerParams remplace la paire STDIO, et tu fournis une URL plutôt qu’une commande.
# 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())
Le paramètre timeout mérite réflexion. En STDIO, les appels étaient quasi instantanés ; sur le réseau, un outil interrogeant une API tierce ou traitant un gros document peut prendre plusieurs dizaines de secondes. Un timeout trop court se manifeste par des erreurs intermittentes, difficiles à reproduire, souvent sur les requêtes les plus utiles.
Lorsque le serveur attend des en-têtes spécifiques — un jeton API, une clé de routage, une contrainte CORS — tu les passes dans 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",
},
)
)
Plusieurs serveurs sur un seul hôte
La leçon 3 recommandait des serveurs focalisés plutôt qu’un catalogue fourre-tout. Cette recommandation ne te condamne pas à louer une machine par serveur : avec FastAPI, tu peux monter plusieurs serveurs MCP sur des routes distinctes du même hôte.
# 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)
Tu obtiens deux points de terminaison indépendants, https://mon-serveur.com/text/mcp pour les outils d’analyse de texte et https://mon-serveur.com/math/mcp pour les outils mathématiques, que tu ajoutes séparément dans Vibe. Le point critique est le lifespan : chaque serveur MCP possède un gestionnaire de session qui doit être démarré explicitement. Si tu montes les applications sans passer ce lifespan à FastAPI, le serveur répond, mais chaque appel d’outil échoue avec une erreur de tâche non initialisée. Un utilisateur n’ayant besoin que de calculs n’encombrera pas son contexte avec des outils de texte. Le commentaire sur eval n’est pas une blague : sur un point de terminaison public, cette ligne exécute tout code envoyé par l’appelant — c’est un exemple pédagogique, jamais un motif de production.
Un dernier réflexe : avant d’ajouter ton URL à un chat, passe-la à nouveau dans l’Inspector. Un point de terminaison distant ajoute des sources d’échec que le local ignorait — tunnel fermé, en-tête manquant, port occupé — et il vaut mieux les découvrir en dehors d’une conversation.
Svarbiausi punktai
- Un serveur MCP distant expose ses outils via HTTP sur un point de terminaison
/mcp - ngrok permet d’obtenir une URL publique pour le développement
MCPClientStreamableHTTPavecStreamableHTTPServerParamsconnecte le client au serveur distant (MCPClientSSEest désormais réservé aux anciens points de terminaison/sse)- Le paramètre timeout est crucial pour les serveurs lents
- Tu peux monter plusieurs serveurs MCP sur le même hôte FastAPI, à condition de passer leur lifespan
- Teste toujours avec l’Inspector avant d’intégrer dans un chat