Configurer un serveur SSE distant
Op deze pagina
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 héritée de Le Chat reste disponible en mode Chat ; en mode Work, les agents sont désormais des compétences (appelé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_asyncsont lus 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 sont déplacés versrun()oustreamable_http_app(), et une application exposée sous un nom d’hôte réel doit déclarer ce nom d’hôte (transport_security). C’est également la version requise par le SDK Mistral : l’extramistralai[agents]nécessitemcp>=2.2.0,<3.0. Sources : Nouveautés de la v2 · Guide de migration · Déploiement et mise à l’échelle.
Passer du local au distant
Jusqu’à présent, votre serveur MCP résidait sur votre machine et communiquait via STDIO. Ce mode est idéal pour le développement, mais il isole votre travail : personne d’autre ne peut l’utiliser et Vibe de Mistral ne peut jamais lancer de processus sur votre machine locale. Pour franchir cette limite, vous devez 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. Votre code d’outil lui-même reste inchangé.
Le serveur change à peine
MCPServer prend en charge nativement le transport HTTP Streamable. Le fichier ci-dessous est é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 consiste à ajouter un bloc de lancement à la fin du fichier : transport HTTP, port et liste des noms d’hôte que le serveur accepte.
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
Votre 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 votre serveur depuis Vibe sans déploiement complet, ngrok crée un tunnel entre une URL publique et votre port local. Cet outil raccourcit la boucle de développement plus que tout autre : vous modifiez un outil, redémarrez, 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 vous attribue une adresse telle que https://abc123.ngrok-free.app. Redémarrez le serveur en déclarant ce nom d’hôte (MCP_PUBLIC_HOST=abc123.ngrok-free.app python remote_server.py). Votre point de terminaison MCP devient simplement ceci, en ajoutant le chemin /mcp :
https://abc123.ngrok-free.app/mcp
Ajoutez cette URL telle quelle à Mistral Vibe en tant que connecteur personnalisé. N’oubliez pas qu’elle est temporaire et expose votre machine : ne laissez pas un tunnel ouvert sur un serveur touchant à des données réelles.
Connecter un client Python
Côté client, la structure du code reste la même que dans la leçon RunContext. Seule la classe de connexion diffère : MCPClientStreamableHTTP avec StreamableHTTPServerParams remplace la paire STDIO, et vous fournissez 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 document volumineux peut prendre plusieurs dizaines de secondes. Un délai d’attente trop court se manifeste par des erreurs intermittentes, difficiles à reproduire, généralement 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), vous les transmettez 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 spécialisés plutôt qu’un catalogue fourre-tout. Cette recommandation ne vous condamne pas à louer une machine par serveur : avec FastAPI, vous pouvez 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)
Vous obtenez 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 vous ajoutez 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 vous montez 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 qui n’a besoin que de calculs n’encombrera pas son contexte avec des outils de texte. Le commentaire sur eval n’est pas une plaisanterie : sur un point de terminaison public, cette ligne exécute tout code envoyé par l’appelant ; c’est un exemple pédagogique, jamais un modèle de production.
Un dernier réflexe : avant d’ajouter votre URL à une conversation, testez-la à nouveau avec 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.
Belangrijkste punten
- Un serveur MCP distant expose ses outils via HTTP sur un point de terminaison
/mcp - ngrok vous 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 important pour les serveurs lents
- Vous pouvez monter plusieurs serveurs MCP sur le même hôte FastAPI, à condition de passer leur lifespan
- Testez toujours avec l’Inspector avant d’intégrer dans une conversation