Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Configurer un serveur MCP local (STDIO)

Les 4 van 14 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Votre premier serveur MCP local
  2. Écriture du serveur
  3. Configuration du client STDIO
  4. Tester avant d’intégrer
  5. Belangrijkste punten

Mis à jour le 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) : MCPServer remplace FastMCP, les paramètres de transport sont déplacés vers run() ou streamable_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’extra mistralai[agents] nécessite mcp>=2.2.0,<3.0. Sources : Quoi de neuf dans la v2 · Guide de migration · Déploiement et mise à l’échelle.

Votre premier serveur MCP local

Le mode STDIO constitue le point de départ naturel pour développer et tester un serveur MCP : tout s’exécute sur votre machine, sans déploiement, sans URL publique ni gestion de certificats. Vous modifiez un fichier, redémarrez et observez le résultat. Dans cette leçon, vous allez écrire un serveur MCP local en Python, puis le connecter à un client.

Concernant les prérequis, vous avez besoin de Python 3.10 ou supérieur, d’une version à jour de pip, et de préférence d’un environnement virtuel dédié. Ce dernier point n’est pas cosmétique : les paquets MCP évoluent rapidement, et un environnement virtuel (venv) séparé par projet vous évite de casser un serveur fonctionnel lors de l’installation d’une dépendance pour un autre.

# Créer un environnement virtuel
python -m venv mcp-env
source mcp-env/bin/activate  # Linux/Mac
# mcp-env\Scripts\activate   # Windows

# SDK MCP officiel (v2) et SDK Mistral avec son extra agents
pip install "mcp[cli]>=2.2,<3" "mistralai[agents]"

Écriture du serveur

Avec MCPServer, la classe de haut niveau du SDK officiel (anciennement FastMCP), un serveur local ne nécessite que quelques lignes. Vous instanciez une application en lui donnant un nom descriptif, puis vous décorez vos fonctions Python avec @app.tool() pour les exposer.

# serveur_local.py
from mcp.server.mcpserver import MCPServer

# Initialiser le serveur avec un nom descriptif
app = MCPServer("Local Demo Server")

@app.tool()
def greet(name: str) -> str:
    """Greets a person by name.

    Args:
        name: The first name of the person to greet

    Returns:
        A personalized greeting message
    """
    return f"Hello {name}! Welcome to the world of MCP."

@app.tool()
def calculate(operation: str, a: float, b: float) -> str:
    """Performs a simple mathematical calculation.

    Args:
        operation: The operation to perform (add, sub, mul, div)
        a: First number
        b: Second number

    Returns:
        The result of the calculation
    """
    ops = {
        "add": a + b,
        "sub": a - b,
        "mul": a * b,
        "div": a / b if b != 0 else "Error: division by zero"
    }
    result = ops.get(operation, "Unknown operation")
    return f"{a} {operation} {b} = {result}"

Ce fichier expose deux outils. Notez le rôle des docstrings : elles ne servent pas uniquement à documenter votre code pour un collègue ; elles deviennent littéralement la description que le modèle lit pour décider s’il doit appeler calculate plutôt que greet. Une docstring négligée ici entraînera des appels erratiques par la suite.

Configuration du client STDIO

Côté client, vous ne vous connectez pas à une adresse ; vous expliquez comment démarrer le serveur. C’est le rôle de StdioServerParameters.

# client_stdio.py
from mcp import StdioServerParameters
from mistralai.extra.mcp.stdio import MCPClientSTDIO
from pathlib import Path

# Chemin vers votre serveur
path_to_server = Path("serveur_local.py")

# Configuration du serveur STDIO
server_params = StdioServerParameters(
    command="python",           # La commande pour lancer le serveur
    args=[str(path_to_server)], # Les arguments (le fichier Python)
    env=None,                   # Variables d'environnement (optionnel)
)

# Créer le client MCP
mcp_client = MCPClientSTDIO(stdio_params=server_params)

Trois paramètres méritent une explication détaillée.

command

Il s’agit de la commande système qui lance le processus serveur : "python" pour un serveur Python, "node" pour un serveur JavaScript, ou le chemin direct vers un binaire si votre serveur est compilé.

# Python
command="python"

# Node.js
command="node"

# Un exécutable compilé
command="./mon_serveur_mcp"

args

C’est la liste des arguments passés à cette commande. Pour un script Python, il s’agit au minimum du chemin du fichier, mais rien ne vous empêche d’y passer les options de votre serveur.

# Script simple
args=["serveur_local.py"]

# Avec des arguments supplémentaires
args=["serveur_local.py", "--port", "8080", "--verbose"]

env

Il s’agit du dictionnaire de variables d’environnement transmises au processus serveur : le canal par lequel vous lui fournissez une clé API, une URL de base de données ou un indicateur de débogage.

import os

server_params = StdioServerParameters(
    command="python",
    args=["serveur_local.py"],
    env={
        **os.environ,  # Hériter de l'environnement actuel
        "API_KEY": "your_api_key",
        "DATABASE_URL": "postgresql://...",
        "DEBUG": "true",
    },
)

Le comportement de ce paramètre surprend souvent. Avec env=None, le serveur hérite de l’intégralité de l’environnement du processus parent ; avec un dictionnaire, il ne voit strictement que les variables listées. Si vous fournissez un dictionnaire sans y inclure os.environ, ne soyez pas surpris si votre serveur ne trouve plus son PATH ou votre clé API : le comportement est parfaitement logique, simplement radical.

Tester avant d’intégrer

Avant de brancher votre serveur sur un agent, testez-le de manière isolée avec l’MCP Inspector. Le raisonnement est simple : si un appel échoue une fois le serveur connecté à un modèle, vous ne saurez pas si le problème vient de votre code ou de la décision du modèle. L’Inspector lève cette ambiguïté.

npx @modelcontextprotocol/inspector python serveur_local.py

La commande ouvre une interface web locale où vous pouvez lister les outils exposés, inspecter la description et les paramètres que le modèle recevra, déclencher un appel manuel avec des arguments de votre choix et vérifier le format exact de la valeur de retour. Prenez l’habitude de l’utiliser systématiquement : ce sont cinq minutes qui vous font gagner une heure.

Enfin, voici une organisation de fichiers qui vieillit bien, avec le serveur, le client, les dépendances, les secrets gardés hors du dépôt et des tests unitaires pour vos outils :

mon-projet-mcp/
├── serveur_local.py     # Le serveur MCP
├── client_stdio.py      # Le script client
├── requirements.txt     # Dépendances
├── .env                 # Variables d'environnement (jamais commitées)
└── tests/
    └── test_tools.py    # Tests unitaires pour les outils

Belangrijkste punten

  • Un serveur STDIO se lance en tant que processus local
  • StdioServerParameters configure la commande, les arguments et les variables d’environnement
  • Les docstrings de vos outils servent de description pour le modèle
  • L’MCP Inspector (npx @modelcontextprotocol/inspector) est essentiel pour les tests
  • env=None hérite de tout l’environnement ; un dictionnaire explicite limite les variables