Réponse rapide : un agent IA n'est qu'un modèle de langage capable d'appeler votre propre code. Vous décrivez un ensemble d'outils, le modèle décide quand en invoquer un, votre application l'exécute et renvoie le résultat, puis le modèle poursuit à partir de là — en boucle jusqu'à ce que la tâche soit terminée. sgcWebSockets vous offre deux façons de construire cela en Delphi ou C++ Builder : l'appel de fonctions du fournisseur (le modèle demande à appeler l'une de vos fonctions via le composant OpenAI, Anthropic ou Gemini) et MCP (le Model Context Protocol ouvert, où votre serveur expose des outils que n'importe quel client ou agent compatible MCP peut découvrir et appeler). Les deux reposent sur la même idée ; vous choisissez celle qui correspond à l'endroit où vit l'agent.
On imagine parfois un « agent » comme un modèle spécial. Ce n'en est pas un. C'est un modèle de discussion ordinaire plus une petite boucle de contrôle dans votre code qui lui permet d'aller au-delà de la conversation. Dès que le modèle peut appeler une fonction qui interroge une base de données, lit un fichier ou sollicite une API interne, il cesse d'être un chatbot et commence à pouvoir agir. Les deux approches ci-dessous ne diffèrent que par qui héberge les outils.
La boucle de l'agent
Tout agent, quel que soit le fournisseur, suit le même cycle :
- Envoyer le message de l'utilisateur accompagné d'une liste de définitions d'outils (nom, description, paramètres).
- Le modèle répond soit en texte clair, soit par « appeler l'outil X avec ces arguments ».
- S'il demande un outil, votre code exécute le vrai travail et renvoie le résultat.
- Le modèle lit le résultat et appelle un autre outil ou produit la réponse finale.
- Répéter jusqu'à ce que le modèle cesse de demander des outils.
Le modèle n'exécute jamais rien lui-même. Il ne fait que proposer des appels ; votre code Delphi garde le contrôle de ce qui s'exécute réellement, ce qui rend ce schéma sûr à placer devant de vrais systèmes.
Approche 1 : appel de fonctions du fournisseur
La façon la plus directe de donner à un seul modèle l'accès à votre code est l'API d'appel de fonctions propre au fournisseur. Vous déclarez les fonctions disponibles, le modèle en choisit une lorsqu'il en a besoin, et un événement se déclenche dans votre composant pour que vous puissiez fournir le résultat. Avec le composant OpenAI, vous définissez les outils une seule fois sur l'assistant, puis vous traitez l'appel :
Assistant := TsgcAIOpenAIAssistant.Create(nil);
Assistant.OpenAIOptions.ApiKey := 'sk-...';
Assistant.AssistantOptions.Name := 'Delphi Weather Bot';
Assistant.AssistantOptions.Instructions.Text :=
'You are a weather bot. Use the provided functions to answer questions.';
Assistant.AssistantOptions.Model := 'gpt-4o';
// Describe the callable functions as JSON tool definitions
Assistant.AssistantOptions.Tools.Functions.Functions.Text :=
'[{"type":"function","function":{"name":"get_current_temperature",' +
'"description":"Get the current temperature for a specific location",' +
'"parameters":{"type":"object","properties":{"location":{"type":"string"}},' +
'"required":["location"]}}}]';Lorsque le modèle décide qu'il a besoin d'une valeur, le composant déclenche OnFunctionCall. Vous inspectez aRequest._Function._Name pour savoir quel outil a été demandé et vous écrivez la réponse dans aResponse.Output — ce résultat est renvoyé directement au modèle pour qu'il puisse terminer sa réponse :
procedure TForm1.AssistantFunctionCall(Sender: TObject;
const aRequest: TsgcOpenAIClass_ToolCall;
const aResponse: TsgcHTTPOpenAI_ToolCall_Response);
begin
if aRequest._Function._Name = 'get_current_temperature' then
aResponse.Output := 30
else if aRequest._Function._Name = 'get_rain_probability' then
aResponse.Output := 10;
end;Ce gestionnaire d'événement est la boucle de l'agent. Chaque fois que le modèle demande un outil, vous l'exécutez et vous renvoyez le résultat ; le composant maintient la conversation jusqu'à ce que le modèle dispose de tout ce dont il a besoin. Cette approche est idéale lorsque l'agent vit à l'intérieur de votre propre application et dialogue avec un seul fournisseur. La même forme est disponible sur les composants Anthropic et Gemini, vous n'êtes donc pas enfermé. Consultez le guide de l'appel de fonctions OpenAI pour l'exemple complet.
Approche 2 : outils MCP
L'appel de fonctions lie vos outils à un seul modèle dans une seule application. Le Model Context Protocol transforme la même idée en un service réutilisable : votre application expose un ensemble d'outils via un point de terminaison JSON-RPC standard, et n'importe quel client ou agent compatible MCP — un assistant d'IDE, une application IA de bureau, ou votre propre boucle d'agent — peut se connecter, découvrir ces outils et les appeler. Vous écrivez l'outil une fois ; chaque hôte MCP peut l'utiliser.
Dans sgcWebSockets, le côté serveur est TsgcWSAPIServer_MCP. Vous l'attachez à un serveur HTTP sgcWebSockets, vous enregistrez les outils avec Tools.AddTool, et vous traitez l'appel entrant dans OnMCPRequestTool :
uses
sgcWebSocket_Server, sgcAI, sgcAI_MCP_Classes, sgcAI_MCP_Server;
procedure TForm1.SetupMCPServer;
begin
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;Lorsqu'un client connecté appelle l'outil, l'événement se déclenche avec des objets de requête et de réponse fortement typés. Vous lisez le nom de l'outil dans aRequest.Params.Name et ses arguments dans aRequest.Params.Arguments, puis vous écrivez la réponse avec aResponse.Result.Content.AddText :
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;Le gestionnaire fait le même travail que l'événement d'appel de fonctions, mais désormais l'outil est joignable par n'importe quel hôte MCP sur le réseau. Comme MCP est un standard publié, l'agent qui pilote la conversation n'a pas à être écrit par vous du tout. En savoir plus sur la présentation de MCP et la page du composant Serveur MCP.
Quelle approche choisir ?
| Si vous voulez… | Utilisez | Composant |
|---|---|---|
| Un agent qui vit dans votre propre application et dialogue avec un seul fournisseur | Appel de fonctions du fournisseur | TsgcAIOpenAIAssistant |
| Des outils que n'importe quel client ou agent compatible MCP peut découvrir et appeler | Serveur MCP | TsgcWSAPIServer_MCP |
| Appeler des outils hébergés sur le serveur MCP de quelqu'un d'autre | Client MCP | TsgcWSAPIClient_MCP |
Les deux ne s'excluent pas mutuellement. Une conception courante est un agent intégré à l'application qui utilise l'appel de fonctions du fournisseur pour ses propres outils privés, tout en se connectant aussi comme client MCP à des serveurs d'outils partagés ailleurs dans votre organisation. Quel que soit votre choix, la boucle que vous écrivez se ressemble presque, donc passer de l'une à l'autre plus tard ne coûte pas cher.
Pour commencer
Les deux approches sont fournies avec sgcWebSockets (le serveur et le client MCP sont des composants Enterprise). Récupérez la version d'essai gratuite, déposez TsgcAIOpenAIAssistant pour l'appel de fonctions ou TsgcWSAPIServer_MCP pour un service MCP, raccordez l'événement d'outil, et vous obtenez un agent capable d'agir sur votre propre code en quelques lignes. Parcourez chaque brique d'IA sur le hub des composants IA et LLM.
Des questions ou besoin d'aide pour concevoir votre agent ? Contactez-nous — vous recevrez une réponse des personnes qui ont écrit le code.