Connectez vos applications Delphi à l'écosystème IA via le Model Context Protocol : TsgcWSAPIServer_MCP expose les outils, prompts et ressources de votre application aux modèles IA, et TsgcWSAPIClient_MCP consomme n'importe quel serveur compatible MCP. La même bibliothèque livre des clients d'API IA pour OpenAI, Anthropic Claude et Google Gemini.
MCP est le standard émergent pour connecter les grands modèles de langage à des outils et données externes. Au lieu d'une intégration sur mesure par fournisseur IA, vous implémentez un seul protocole.
Le Model Context Protocol en Delphi signifie que votre application VCL ou FMX existante peut devenir un service accessible aux IA. Le protocole est basé sur JSON-RPC et définit trois primitives : les outils (fonctions appelables avec paramètres typés), les prompts (modèles réutilisables avec arguments) et les ressources (données exposées par adressage URI). Un serveur MCP les publie ; un client MCP (Claude Desktop, Cursor ou votre propre application Delphi) les découvre et les appelle.
Le composant serveur s'attache à un serveur HTTP sgcWebSockets et supporte les transports stdio et HTTP, le même code sert donc un assistant IA de bureau qui le lance comme sous-processus et un agent distant qui l'appelle par le réseau. Le composant client parle JSON-RPC sur HTTP ou HTTP Streamable et couvre toute la surface du catalogue : initialize, lister et appeler les outils, récupérer les prompts, lire les ressources, plus le sampling et l'elicitation pour les workflows IA interactifs.
TsgcWSAPIServer_MCP : outils, prompts, ressources, transports stdio et HTTP
TsgcWSAPIClient_MCP : découvrez et appelez n'importe quel serveur compatible MCP
TsgcHTTP_API_OpenAI, TsgcHTTP_API_Anthropic, TsgcHTTP_API_Gemini
De Delphi 7 à RAD Studio 13, C++Builder 10.1 Berlin à 13, Lazarus 4.4.0
Serveur, client et les clients de fournisseurs IA qui consomment ce que MCP expose.
Tools.AddTool enregistre une fonction appelable et ses propriétés InputSchema ; les appels arrivent dans l'événement OnMCPRequestTool avec les arguments parsés et un objet de réponse structuré.
Modèles de prompts réutilisables avec arguments et ressources adressées par URI, servis via OnMCPRequestPrompt et OnMCPRequestResource.
Initialize, ListTools, ListPrompts, ListResources, ListResourceTemplates, puis RequestTool / RequestPrompt / RequestResource avec réponses événementielles.
Le client supporte le sampling MCP (interaction avec le modèle IA demandée par le serveur) et l'elicitation (collecte d'une saisie utilisateur en cours de workflow), les deux extensions interactives du protocole.
Les options d'authentification côté client incluent les clés API via AuthenticationOptions.ApiKey ; voir le blog pour les serveurs MCP protégés par OAuth2.
Stdio pour les serveurs lancés en sous-processus (le modèle Claude Desktop) et HTTP pour les déploiements réseau. Un composant, les deux canaux.
Parlez aussi directement aux modèles : chat, streaming et function calling contre OpenAI, Anthropic Claude et Google Gemini, plus DeepSeek, Grok, Mistral et Ollama dans la même famille IA.
Windows 32/64, Linux 64, macOS (Intel et ARM), iOS et Android. VCL et FireMonkey, avec composants design-time.
Le serveur MCP, le client MCP et les clients d'API IA sont des fonctionnalités de l'édition Enterprise de sgcWebSockets.
Enregistrez un outil avec un argument typé côté serveur ; découvrez-le et appelez-le depuis le client.
uses
sgcWebSocket_Server, sgcAI, sgcAI_MCP_Classes, sgcAI_MCP_Server;
procedure TForm1.SetupMCPServer;
begin
// Attach the MCP API component to a sgcWebSockets HTTP server
MCPServer.Server := Server;
MCPServer.EndpointOptions.Endpoint := '/mcp';
MCPServer.MCPOptions.ServerInfo.Name := 'sgc-mcp-server';
MCPServer.MCPOptions.ServerInfo.Version := '1.0.0';
// Register a callable tool with a typed argument
with MCPServer.Tools.AddTool('GetTemperature',
'Get the actual temperature in a city.') do
InputSchema.Properties.AddProperty('city', True);
MCPServer.OnMCPRequestTool := MCPRequestTool;
Server.Port := 8080;
Server.Active := True;
end;
procedure TForm1.MCPRequestTool(Sender: TObject;
const aSession: TsgcAI_MCP_Session;
const aRequest: TsgcAI_MCP_Request_ToolsCall;
const aResponse: TsgcAI_MCP_Response_ToolsCall);
begin
if aRequest.Params.Name = 'GetTemperature' then
aResponse.Result.Content.AddText('The current temperature in ' +
aRequest.Params.Arguments.Item[0].Value + ' is 22 Celsius');
end;uses
sgcAI_MCP_Client, sgcAI_MCP_Classes;
var
MCP: TsgcWSAPIClient_MCP;
begin
MCP := TsgcWSAPIClient_MCP.Create(nil);
MCP.MCPOptions.HttpOptions.URL := 'https://mcp.example.com/';
MCP.MCPOptions.ClientInfo.Name := 'sgc-mcp-client';
MCP.MCPOptions.ClientInfo.Title := 'sgc MCP demo';
MCP.MCPOptions.ClientInfo.Version := '1.0.0';
MCP.MCPOptions.AuthenticationOptions.ApiKey.Enabled := True;
MCP.MCPOptions.AuthenticationOptions.ApiKey.Value := 'sk-mcp-...';
MCP.OnMCPInitialize := MCPInit;
MCP.OnMCPListPrompts := MCPListPrompts;
MCP.OnMCPListTools := MCPListTools;
MCP.OnMCPResponseTool := MCPToolResponse;
MCP.Initialize;
MCP.ListPrompts;
MCP.ListResources;
MCP.ListTools;
MCP.RequestTool('GetTemperature', '{"city":"Madrid"}');
end;Laissez un modèle IA interroger les données de votre application via des outils contrôlés et typés. Lecture seule ou lecture-écriture, votre handler décide à chaque appel.
Exposez des opérations CRM, ERP ou de ticketing comme outils MCP pour que des instructions en langage naturel pilotent la logique métier Delphi existante.
Donnez aux assistants comme Claude Desktop l'accès aux fonctionnalités d'une application héritée en l'enveloppant dans un serveur MCP stdio.
Chaînez outils et ressources pour la récupération, le traitement et l'action dans un seul pipeline piloté par l'IA, orchestré côté Delphi.
Ce qu'est le Model Context Protocol et comment les composants serveur et client se répartissent le travail.
Référence complète pour TsgcWSAPIServer_MCP : propriétés, méthodes, événements.
Référence complète pour TsgcWSAPIClient_MCP : méthodes de catalogue et événements de réponse.
Pas à pas d'un serveur MCP Delphi opérationnel.
Connecter un client Delphi à des serveurs MCP et appeler leurs outils.
Sécuriser les endpoints MCP : clés API et flux authentifiés depuis Delphi.