Transport MCP stdio pour sgcWebSockets

1er juin 2026 · Composants

Les composants Model Context Protocol (MCP) de sgcWebSockets vous permettent déjà de créer des serveurs et des clients MCP en Delphi sur HTTP et Streamable HTTP. Cette version ajoute un troisième transport des deux côtés : stdio. Votre serveur MCP peut désormais fonctionner sur l'entrée et la sortie standard, et votre client MCP peut lancer un exécutable de serveur et dialoguer avec lui par-delà cette frontière de processus. Aucun écouteur HTTP, aucun port, aucune configuration TLS pour un usage local.

C'est important car stdio est la manière native dont les agents de codage IA modernes se connectent aux serveurs MCP. Des outils comme Claude Code, Cursor et d'autres clients MCP lancent un serveur en tant que processus enfant et échangent du JSON-RPC sur son stdin et son stdout. Avec ce transport, un serveur MCP Delphi s'intègre directement dans cet écosystème.

Qu'est-ce que le transport stdio

Dans le transport stdio, le processus serveur lit des messages JSON-RPC délimités par des sauts de ligne depuis stdin et écrit les réponses JSON-RPC sur stdout, un objet JSON compact par ligne, encodé en UTF-8. Le client maîtrise la relation : il démarre l'exécutable du serveur, écrit les requêtes dans le tube d'entrée de l'enfant et lit les réponses depuis son tube de sortie, en faisant correspondre chaque réponse à sa requête grâce à l'id JSON-RPC. Les notifications initiées par le serveur empruntent le même canal.

Comparé à HTTP, il n'y a aucun socket ni aucune surface réseau du tout. Tout se passe à travers des tubes hérités entre un processus parent et un processus enfant sur la même machine.

Faire fonctionner un serveur MCP sur stdio

Le nouvel hôte TsgcAI_MCP_Server_Stdio enveloppe le même cœur MCP que le serveur HTTP, vous enregistrez donc les outils, les invites et les ressources exactement comme avant. Compilez-le comme une application console, enregistrez vos outils, puis appelez Run pour commencer à acheminer les messages.

uses
  SysUtils, sgcAI_MCP_Server, sgcAI_MCP_Classes, sgcAI_MCP_Types;

type
  TServerHandler = class
    procedure OnRequestTool(Sender: TObject; const aSession: TsgcAI_MCP_Session;
      const aRequest: TsgcAI_MCP_Request_ToolsCall;
      const aResponse: TsgcAI_MCP_Response_ToolsCall);
  end;

procedure TServerHandler.OnRequestTool(Sender: TObject;
  const aSession: TsgcAI_MCP_Session;
  const aRequest: TsgcAI_MCP_Request_ToolsCall;
  const aResponse: TsgcAI_MCP_Response_ToolsCall);
var
  vA, vB: Double;
begin
  if aRequest.Params.Name = 'add' then
  begin
    vA := aRequest.Params.Arguments.Node['a'].Value;
    vB := aRequest.Params.Arguments.Node['b'].Value;
    aResponse.Result.Content.AddText(FloatToStr(vA + vB));
  end;
end;

var
  oServer: TsgcAI_MCP_Server_Stdio;
  oTool: TsgcAI_MCP_Tool;
  oHandler: TServerHandler;
begin
  oHandler := TServerHandler.Create;
  oServer := TsgcAI_MCP_Server_Stdio.Create(nil);
  try
    oServer.ServerInfo.Name := 'MyDelphiServer';
    oServer.ServerInfo.Version := '1.0';

    // register a tool, exactly like the HTTP server
    oTool := oServer.MCPServer.Tools.AddTool('add', 'Adds two numbers');
    oTool.InputSchema.Properties.AddProperty('a', True, aimcpjtNumber);
    oTool.InputSchema.Properties.AddProperty('b', True, aimcpjtNumber);

    oServer.MCPServer.OnMCPRequestTool := oHandler.OnRequestTool;

    // read JSON-RPC from stdin, write responses to stdout, blocks until EOF
    oServer.Run;
  finally
    oServer.Free;
    oHandler.Free;
  end;
end.

Une règle lors de la construction d'un serveur stdio : stdout est le canal du protocole, n'y écrivez donc jamais de bannières ni de journaux. Envoyez plutôt tout diagnostic vers stderr ou un fichier.

Connecter un client MCP sur stdio

Côté client, vous conservez la même API publique. Sélectionnez le transport stdio et indiquez au client quel exécutable lancer via les nouvelles StdioOptions. Le client lance le processus, effectue la poignée de main d'initialisation, puis expose les outils, les invites et les ressources tout comme le client HTTP.

uses
  sgcAI_MCP_Client, sgcAI_MCP_Types;

var
  oClient: TsgcWSAPI_Client_MCP;
begin
  oClient := TsgcWSAPI_Client_MCP.Create(nil);
  try
    // select the stdio transport and point it at the server executable
    oClient.MCPOptions.Transport := aimcptrStdio;
    oClient.MCPOptions.StdioOptions.Command := 'C:\MyServer\MyDelphiServer.exe';
    oClient.MCPOptions.StdioOptions.Arguments := '--stdio';
    oClient.MCPOptions.StdioOptions.WorkingDir := 'C:\MyServer';
    oClient.MCPOptions.StdioOptions.Timeout := 20000;

    // the client launches the server and runs the MCP handshake
    oClient.Initialize;

    // discover tools and call one, the result arrives in OnMCPResponseTool
    oClient.ListTools;
    oClient.RequestTool('add', BuildArguments(2, 3));
  finally
    oClient.Free;
  end;
end;

La réponse est délivrée via l'événement habituel OnMCPResponseTool, et les notifications du serveur arrivent via OnMCPLoggingMessage, OnMCPProgress et les autres événements de notification, à l'identique du transport HTTP. StdioOptions accepte également des entrées Environment lorsque le processus enfant a besoin de variables d'environnement spécifiques.

Utilisez-le avec Claude Code et d'autres agents IA

Comme le transport suit la convention MCP stdio, tout client MCP conforme peut lancer votre serveur Delphi. Pour l'enregistrer auprès de Claude Code, ajoutez une entrée à la configuration MCP qui pointe vers votre exécutable.

{
  "mcpServers": {
    "my-delphi-server": {
      "command": "C:\\MyServer\\MyDelphiServer.exe",
      "args": ["--stdio"]
    }
  }
}

L'agent lance le serveur à la demande, liste les outils que vous avez enregistrés et les appelle pendant qu'il travaille. Votre code Delphi devient un fournisseur d'outils de premier ordre pour les assistants IA, sans serveur web à déployer ni à sécuriser.

Avantages

Aucune surface réseau. Il n'y a aucun port à ouvrir, aucun écouteur HTTP et aucun TLS ni authentification à configurer pour un usage local. La communication se fait purement par stdin et stdout.
Le modèle local natif. Les outils de codage IA tels que Claude Code et Cursor lancent les serveurs MCP sur stdio, de sorte que votre serveur s'intègre sans adaptateur.
Cycle de vie propre et isolation. Le serveur vit et meurt avec le processus client. Un serveur par client, aucun état partagé et aucun écouteur résiduel.
Même API MCP. Les outils, les invites et les ressources s'enregistrent de la même manière que pour le serveur HTTP. Changer de transport côté client se résume à une seule propriété.
Idéal pour un usage bureautique et hors ligne. Lorsqu'exposer un point d'accès HTTP est inutile ou indésirable, stdio garde tout à l'intérieur de la machine locale.
Encadrement robuste. JSON-RPC délimité par des sauts de ligne sur UTF-8, avec une marque d'ordre des octets en tête tolérée sur les messages entrants pour une large compatibilité avec les clients.

Mise à niveau

Le transport stdio est un ajout prêt à l'emploi. Les serveurs et clients HTTP et Streamable HTTP existants sont inchangés, et le nouveau transport réutilise le même modèle d'outils, d'invites et de ressources, il n'y a donc rien à migrer. Pour l'adopter, compilez votre serveur comme une application console autour de TsgcAI_MCP_Server_Stdio, ou définissez Transport sur aimcptrStdio côté client. Vous pouvez télécharger la dernière version depuis la page de téléchargement de sgcWebSockets.

Des questions, des retours ou besoin d'aide pour la migration ? Contactez-nous, vous obtiendrez une réponse des personnes qui ont écrit le code.