MCP-stdio-Transport für sgcWebSockets

1. Juni 2026 · Komponenten

Mit den Model-Context-Protocol-(MCP-)Komponenten von sgcWebSockets können Sie bereits MCP-Server und -Clients in Delphi über HTTP und Streamable HTTP erstellen. Diese Version fügt beiden Seiten einen dritten Transport hinzu: stdio. Ihr MCP-Server kann jetzt über Standard-Eingabe und -Ausgabe laufen, und Ihr MCP-Client kann eine Server-Executable starten und über diese Prozessgrenze hinweg mit ihr kommunizieren. Kein HTTP-Listener, kein Port, keine TLS-Konfiguration für die lokale Nutzung.

Das ist wichtig, weil stdio die native Art ist, mit der moderne KI-Coding-Agenten sich mit MCP-Servern verbinden. Tools wie Claude Code, Cursor und andere MCP-Clients starten einen Server als Kindprozess und tauschen JSON-RPC über dessen stdin und stdout aus. Mit diesem Transport fügt sich ein Delphi-MCP-Server direkt in dieses Ökosystem ein.

Was der stdio-Transport ist

Beim stdio-Transport liest der Serverprozess durch Zeilenumbrüche getrennte JSON-RPC-Nachrichten von stdin und schreibt JSON-RPC-Antworten nach stdout, ein kompaktes JSON-Objekt pro Zeile, kodiert als UTF-8. Der Client besitzt die Beziehung: Er startet die Server-Executable, schreibt Anfragen in die Eingabe-Pipe des Kindprozesses und liest Antworten aus dessen Ausgabe-Pipe, wobei er jede Antwort über die JSON-RPC-id ihrer Anfrage zuordnet. Vom Server initiierte Benachrichtigungen laufen über denselben Kanal.

Im Vergleich zu HTTP gibt es überhaupt keinen Socket und keine Netzwerkangriffsfläche. Alles geschieht über vererbte Pipes zwischen einem Eltern- und einem Kindprozess auf derselben Maschine.

Einen MCP-Server über stdio betreiben

Der neue Host TsgcAI_MCP_Server_Stdio kapselt denselben MCP-Kern, der auch vom HTTP-Server verwendet wird, sodass Sie Tools, Prompts und Ressourcen genau wie zuvor registrieren. Bauen Sie ihn als Konsolenanwendung, registrieren Sie Ihre Tools und rufen Sie dann Run auf, um mit dem Verarbeiten der Nachrichten zu beginnen.

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.

Eine Regel beim Bau eines stdio-Servers: stdout ist der Protokollkanal, schreiben Sie also niemals Banner oder Logs dorthin. Senden Sie jegliche Diagnoseausgaben stattdessen an stderr oder in eine Datei.

Einen MCP-Client über stdio verbinden

Auf der Client-Seite behalten Sie dieselbe öffentliche API. Wählen Sie den stdio-Transport und teilen Sie dem Client über die neuen StdioOptions mit, welche Executable gestartet werden soll. Der Client startet den Prozess, führt den Initialisierungs-Handshake durch und stellt dann Tools, Prompts und Ressourcen genau wie der HTTP-Client bereit.

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;

Die Antwort wird über das übliche Ereignis OnMCPResponseTool geliefert, und Server-Benachrichtigungen treffen über OnMCPLoggingMessage, OnMCPProgress und die anderen Benachrichtigungsereignisse ein, identisch zum HTTP-Transport. StdioOptions akzeptiert auch Environment-Einträge, wenn der Kindprozess bestimmte Umgebungsvariablen benötigt.

Verwenden Sie es mit Claude Code und anderen KI-Agenten

Da der Transport der MCP-stdio-Konvention folgt, kann jeder konforme MCP-Client Ihren Delphi-Server starten. Um ihn bei Claude Code zu registrieren, fügen Sie der MCP-Konfiguration einen Eintrag hinzu, der auf Ihre Executable zeigt.

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

Der Agent startet den Server bei Bedarf, listet die von Ihnen registrierten Tools auf und ruft sie während seiner Arbeit auf. Ihr Delphi-Code wird so zum vollwertigen Tool-Anbieter für KI-Assistenten, ganz ohne Webserver, der bereitgestellt oder abgesichert werden müsste.

Vorteile

Keine Netzwerkangriffsfläche. Es gibt keinen Port zu öffnen, keinen HTTP-Listener und kein TLS oder keine Authentifizierung, die für die lokale Nutzung konfiguriert werden müssten. Die Kommunikation läuft rein über stdin und stdout.
Das native lokale Muster. KI-Coding-Tools wie Claude Code und Cursor starten MCP-Server über stdio, sodass sich Ihr Server ohne Adapter integriert.
Sauberer Lebenszyklus und Isolation. Der Server lebt und stirbt mit dem Client-Prozess. Ein Server pro Client, kein gemeinsamer Zustand und keine zurückgebliebenen Listener.
Dieselbe MCP-API. Tools, Prompts und Ressourcen werden auf die gleiche Weise wie beim HTTP-Server registriert. Den Transport auf dem Client zu wechseln, ist eine einzige Eigenschaft.
Ideal für Desktop- und Offline-Nutzung. Wenn das Bereitstellen eines HTTP-Endpunkts unnötig oder unerwünscht ist, hält stdio alles innerhalb der lokalen Maschine.
Robustes Framing. Durch Zeilenumbrüche getrenntes JSON-RPC über UTF-8, wobei eine vorangestellte Byte-Order-Mark bei eingehenden Nachrichten für eine breite Client-Kompatibilität toleriert wird.

Aktualisieren

Der stdio-Transport ist eine nahtlose Ergänzung. Bestehende HTTP- und Streamable-HTTP-Server und -Clients bleiben unverändert, und der neue Transport verwendet dasselbe Tool-, Prompt- und Ressourcenmodell wieder, sodass es nichts zu migrieren gibt. Um ihn zu übernehmen, bauen Sie Ihren Server als Konsolenanwendung rund um TsgcAI_MCP_Server_Stdio oder setzen Sie Transport auf dem Client auf aimcptrStdio. Sie können die neueste Version von der sgcWebSockets-Downloadseite herunterladen.

Fragen, Feedback oder Hilfe bei der Migration? Nehmen Sie Kontakt auf, Sie erhalten eine Antwort von den Menschen, die den Code geschrieben haben.