mcp-transport-mechanisms

---
title: "Mécanismes de Transport MCP"
description: "Découvrez les deux principaux mécanismes de transport pour la communication entre les serveurs Careti et MCP : Standard Input/Output (STDIO) et Server-Sent Events (SSE). Chacun a des caractéristiques, des avantages et des cas d’utilisation distincts."
---

Model Context Protocol (MCP) prend en charge deux principaux mécanismes de transport pour la communication entre les serveurs Careti et MCP : Standard Input/Output (STDIO) et Server-Sent Events (SSE). Chacun a des caractéristiques, des avantages et des cas d’utilisation distincts.

## Transport STDIO

Le transport STDIO s’exécute localement sur votre machine et communique via les flux d’entrée/sortie standard.

### Fonctionnement du transport STDIO

1. Le client (Careti) génère un serveur MCP en tant que processus enfant
2. La communication se fait via les flux de processus : le client écrit dans le STDIN du serveur, le serveur répond au STDOUT
3. Chaque message est délimité par un caractère de saut de ligne
4. Les messages sont formatés en JSON-RPC 2.0

```plaintext
Client                    Server
  |                         |
  |<---- JSON message ----->| (via STDIN)
  |                         | (processes request)
  |<---- JSON message ------| (via STDOUT)
  |                         |

Caractéristiques de STDIO

• Localité : s’exécute sur la même machine que Careti
• Performance : très faible latence et surcharge (aucune pile réseau impliquée)
• Simplicité : communication directe entre les processus sans configuration réseau
• Relation : relation un-à-un entre le client et le serveur
• Sécurité : intrinsèquement plus sûr car aucune exposition au réseau

Quand utiliser STDIO

Le transport STDIO est idéal pour :

• Les intégrations locales et les outils s’exécutant sur la même machine
• Les opérations sensibles à la sécurité
• Les exigences de faible latence
• Les scénarios à client unique (une instance Careti par serveur)
• Les outils de ligne de commande ou les extensions IDE

Exemple d’implémentation de STDIO

import { Server } from "@modelcontextprotocol/sdk/server/index.js"
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"

const server = new Server({ name: "local-server", version: "1.0.0" })
// Register tools...

// Use STDIO transport
const transport = new StdioServerTransport(server)
transport.listen()

Transport SSE

Le transport Server-Sent Events (SSE) s’exécute sur un serveur distant et communique via HTTP/HTTPS.

Fonctionnement du transport SSE

1. Le client (Careti) se connecte au point de terminaison SSE du serveur via une requête HTTP GET
2. Cela établit une connexion persistante où le serveur peut envoyer des événements au client
3. Pour la communication client-serveur, le client effectue des requêtes HTTP POST vers un point de terminaison distinct
4. La communication se fait sur deux canaux :
   • Flux d’événements (GET) : mises à jour du serveur vers le client
   • Point de terminaison de message (POST) : requêtes du client vers le serveur

Client                             Server
  |                                  |
  |---- HTTP GET /events ----------->| (establish SSE connection)
  |<---- SSE event stream -----------| (persistent connection)
  |                                  |
  |---- HTTP POST /message --------->| (client request)
  |<---- SSE event with response ----| (server response)
  |                                  |

Caractéristiques de SSE

• Accès à distance : peut être hébergé sur une machine différente de votre instance Careti
• Scalabilité : peut gérer plusieurs connexions client simultanément
• Protocole : fonctionne sur HTTP standard (aucun protocole spécial n’est nécessaire)
• Persistance : maintient une connexion persistante pour les messages du serveur vers le client
• Authentification : peut utiliser les mécanismes d’authentification HTTP standard

Quand utiliser SSE

Le transport SSE est préférable pour :

• L’accès à distance à travers les réseaux
• Les scénarios multi-clients
• Les services publics
• Les outils centralisés auxquels de nombreux utilisateurs doivent accéder
• L’intégration avec les services Web

Exemple d’implémentation de SSE

import { Server } from "@modelcontextprotocol/sdk/server/index.js"
import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js"
import express from "express"

const app = express()
const server = new Server({ name: "remote-server", version: "1.0.0" })
// Register tools...

// Use SSE transport
const transport = new SSEServerTransport(server)
app.use("/mcp", transport.requestHandler())
app.listen(3000, () => {
	console.log("MCP server listening on port 3000")
})

Local vs. Hébergé : aspects du déploiement

Le choix entre les transports STDIO et SSE a un impact direct sur la façon dont vous déployez et gérez vos serveurs MCP.

STDIO : modèle de déploiement local

Les serveurs STDIO s’exécutent localement sur la même machine que Careti, ce qui a plusieurs implications importantes :

• Installation : l’exécutable du serveur doit être installé sur la machine de chaque utilisateur
• Distribution : vous devez fournir des packages d’installation pour différents systèmes d’exploitation
• Mises à jour : chaque instance doit être mise à jour séparément
• Ressources : utilise le CPU, la mémoire et le disque de la machine locale
• Contrôle d’accès : repose sur les autorisations du système de fichiers de la machine locale
• Intégration : intégration facile avec les ressources du système local (fichiers, processus)
• Exécution : démarre et s’arrête avec Careti (cycle de vie du processus enfant)
• Dépendances : toutes les dépendances doivent être installées sur la machine de l’utilisateur

Exemple pratique

Un outil de recherche de fichiers local utilisant STDIO :

• S’exécuterait sur la machine de l’utilisateur
• Avoir un accès direct au système de fichiers local
• Démarrerait lorsque Careti en a besoin
• Ne nécessiterait pas de configuration réseau
• Devrait être installé avec Careti ou via un gestionnaire de packages

SSE : modèle de déploiement hébergé

Les serveurs SSE peuvent être déployés sur des serveurs distants et accessibles via le réseau :

• Installation : installé une fois sur un serveur, accessible par de nombreux utilisateurs
• Distribution : un seul déploiement dessert plusieurs clients
• Mises à jour : les mises à jour centralisées affectent immédiatement tous les utilisateurs
• Ressources : utilise les ressources du serveur, pas les ressources de la machine locale
• Contrôle d’accès : géré via des systèmes d’authentification et d’autorisation
• Intégration : intégration plus complexe avec les ressources spécifiques à l’utilisateur
• Exécution : s’exécute en tant que service indépendant (souvent en continu)
• Dépendances : gérées sur le serveur, pas sur les machines utilisateur

Exemple pratique

Un outil de requête de base de données utilisant SSE :

• S’exécuterait sur un serveur central
• Se connecterait aux bases de données avec des informations d’identification côté serveur
• Serait disponible en continu pour plusieurs utilisateurs
• Nécessiterait une configuration de sécurité réseau appropriée
• Serait déployé à l’aide de technologies de conteneur ou de cloud

Approches hybrides

Certains scénarios bénéficient d’une approche hybride :

1. STDIO avec accès réseau : un serveur STDIO local qui agit comme un proxy vers des services distants
2. SSE avec commandes locales : un serveur SSE distant qui peut déclencher des opérations sur la machine cliente via des rappels
3. Modèle de passerelle : serveurs STDIO pour les opérations locales qui se connectent aux serveurs SSE pour les fonctions spécialisées

Choisir entre STDIO et SSE

Élément à prendre en compte	STDIO	SSE
Emplacement	Machine locale uniquement	Locale ou distante
Clients	Client unique	Plusieurs clients
Performance	Latence inférieure	Latence plus élevée (surcharge réseau)
Complexité de la configuration	Plus simple	Plus complexe (nécessite un serveur HTTP)
Sécurité	Intrinsèquement sécurisé	Nécessite des mesures de sécurité explicites
Accès au réseau	Non nécessaire	Nécessaire
Scalabilité	Limité à la machine locale	Peut distribuer sur le réseau
Déploiement	Installation par utilisateur	Installation centralisée
Mises à jour	Mises à jour distribuées	Mises à jour centralisées
Utilisation des ressources	Utilise les ressources du client	Utilise les ressources du serveur
Dépendances	Dépendances côté client	Dépendances côté serveur

Configuration des transports dans Careti

Pour obtenir des informations détaillées sur la configuration des transports STDIO et SSE dans Careti, y compris des exemples, consultez Configuration des serveurs MCP.