Configurer un Serveur SSE Distant

Passer du local au distant

Jusqu’ici, votre serveur MCP tournait en local via STDIO. C’est parfait pour le développement, mais pour l’utiliser depuis Le Chat de Mistral ou le partager avec d’autres, vous devez le rendre accessible via HTTP.

Un serveur MCP distant expose ses tools sur une URL publique. Le client (Le Chat, un SDK, un IDE) s’y connecte via HTTP au lieu de lancer un processus local.

Créer un serveur HTTP avec FastMCP

FastMCP supporte nativement le transport Streamable HTTP. Votre serveur local peut être adapté avec un minimum de changements :

# serveur_distant.py
"""Serveur MCP distant avec transport HTTP."""

from mcp.server.fastmcp import FastMCP

# Le serveur est le même qu en local
app = FastMCP("Serveur Distant Démo")

@app.tool()
def analyze_text(text: str, language: str = "fr") -> str:
    """Analyse un texte et retourne des statistiques.

    Args:
        text: Le texte à analyser
        language: Code langue (fr, en, es). Défaut : fr

    Returns:
        Statistiques du texte : nombre de mots, caractères, phrases
    """
    words = len(text.split())
    chars = len(text)
    sentences = text.count(".") + text.count("!") + text.count("?")
    return (
        f"Langue : {language}\n"
        f"Mots : {words}\n"
        f"Caractères : {chars}\n"
        f"Phrases : {sentences}"
    )

@app.tool()
def summarize_key_points(text: str, max_points: int = 5) -> str:
    """Extrait les points clés d un texte (version simplifiée).

    Args:
        text: Le texte source
        max_points: Nombre maximum de points à extraire (1-10)

    Returns:
        Liste des points clés identifiés
    """
    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 "Aucun point clé identifié."

Lancer le serveur en local avec HTTP

Pour exposer votre serveur en HTTP localement :

# Lancer le serveur FastMCP en mode HTTP
fastmcp run serveur_distant.py --transport streamable-http --port 8000

Le serveur est maintenant accessible sur http://localhost:8000/mcp.

Exposer avec ngrok pour le développement

Pendant le développement, ngrok vous permet d’obtenir une URL publique temporaire pointant vers votre serveur local :

# Installer ngrok (une seule fois)
pip install ngrok
# ou via le site officiel : https://ngrok.com/download

# Exposer le port 8000
ngrok http 8000

ngrok vous fournit une URL publique du type https://abc123.ngrok-free.app. Votre endpoint MCP sera donc :

https://abc123.ngrok-free.app/mcp

Cette URL peut être directement ajoutée dans Le Chat de Mistral comme connecteur custom.

Connecter un client SSE au serveur distant

Côté client Python, la configuration est similaire à STDIO, mais avec MCPClientSSE :

# client_distant.py
import asyncio
from mistralai import Mistral
from mistralai.extra.run.context import RunContext
from mistralai.extra.mcp.sse import MCPClientSSE, SSEServerParams

async def main():
    client = Mistral(api_key="VOTRE_CLE_API")

    agent = client.beta.agents.create(
        model="mistral-medium-latest",
        name="assistant-distant",
        instructions="Vous utilisez des outils distants pour analyser du texte.",
    )

    # Connexion au serveur distant
    server_url = "https://abc123.ngrok-free.app/mcp"
    mcp_client = MCPClientSSE(
        sse_params=SSEServerParams(
            url=server_url,
            timeout=100,  # Timeout en secondes
        )
    )

    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="Analyse ce texte : Le MCP est un protocole ouvert.",
        )
        print(result.output)

asyncio.run(main())

Configurer les headers HTTP

Pour les serveurs qui nécessitent des headers personnalisés (CORS, authentification basique, etc.) :

mcp_client = MCPClientSSE(
    sse_params=SSEServerParams(
        url="https://mon-serveur.example.com/mcp",
        timeout=100,
        headers={
            "Authorization": "Bearer mon_token_api",
            "X-Custom-Header": "valeur",
        },
    )
)

Monter plusieurs serveurs MCP sur un même hôte

Avec FastAPI, vous pouvez monter plusieurs serveurs MCP sur différentes routes d’un même serveur HTTP :

# server.py — Plusieurs serveurs MCP sur un seul hôte
from fastapi import FastAPI
from mcp.server.fastmcp import FastMCP

# Serveur principal FastAPI
api = FastAPI()

# Serveur MCP pour l analyse de texte
text_mcp = FastMCP("Text Analysis")

@text_mcp.tool()
def analyze(text: str) -> str:
    """Analyse un texte."""
    return f"Mots: {len(text.split())}"

# Serveur MCP pour les calculs
math_mcp = FastMCP("Math Tools")

@math_mcp.tool()
def calculate(expression: str) -> str:
    """Évalue une expression mathématique."""
    return str(eval(expression))  # Attention : eval en prod !

# Monter les deux serveurs sur des routes différentes
text_mcp.mount(api, path="/text")
math_mcp.mount(api, path="/math")

Les endpoints seront :

• https://mon-serveur.com/text/mcp — Outils d’analyse de texte
• https://mon-serveur.com/math/mcp — Outils mathématiques

Chaque endpoint est un serveur MCP indépendant, ajouté séparément dans Le Chat.

Points clés à retenir

• Un serveur MCP distant expose ses tools via HTTP sur un endpoint /mcp
• ngrok permet d’obtenir une URL publique pour le développement
• MCPClientSSE avec SSEServerParams connecte le client au serveur distant
• Le paramètre timeout est important pour les serveurs lents
• Vous pouvez monter plusieurs serveurs MCP sur un même hôte FastAPI
• Testez toujours avec l’Inspector avant d’intégrer dans un chat