Bouw een AI-agent in Delphi: function calling en MCP-tool use

Snel antwoord: een AI-agent is gewoon een taalmodel dat je eigen code kan aanroepen. Je beschrijft een set tools, het model beslist wanneer het er een aanroept, je applicatie voert hem uit en geeft het resultaat terug, en het model gaat van daaruit verder — in een lus totdat de taak klaar is. sgcWebSockets geeft je twee manieren om dit in Delphi of C++ Builder te bouwen: provider function calling (het model vraagt om een van je functies aan te roepen via het OpenAI-, Anthropic- of Gemini-component) en MCP (het open Model Context Protocol, waarbij je server tools blootstelt die elke MCP-capabele client of agent kan ontdekken en aanroepen). Beide gebruiken hetzelfde idee; je kiest degene die past bij waar de agent leeft.

Mensen stellen zich een "agent" soms voor als een speciaal model. Dat is het niet. Het is een gewoon chatmodel plus een kleine besturingslus in je code waarmee het buiten het gesprek kan reiken. Zodra het model een functie kan aanroepen die een database doorzoekt, een bestand leest of een interne API aanspreekt, houdt het op een chatbot te zijn en begint het te kunnen handelen. De twee paden hieronder verschillen alleen in wie de tools host.

De agentlus

Elke agent, ongeacht de provider, volgt dezelfde cyclus:

1. Stuur het bericht van de gebruiker samen met een lijst tooldefinities (naam, beschrijving, parameters).
2. Het model antwoordt ofwel in platte tekst, of antwoordt "roep tool X aan met deze argumenten".
3. Als het om een tool vraagt, voert je code het echte werk uit en geeft het resultaat terug.
4. Het model leest het resultaat en roept ofwel een andere tool aan of produceert het uiteindelijke antwoord.
5. Herhaal totdat het model niet meer om tools vraagt.

Het model voert nooit zelf iets uit. Het stelt alleen aanroepen voor; je Delphi-code houdt de controle over wat er daadwerkelijk draait, en dat is wat het patroon veilig maakt om voor echte systemen te zetten.

Pad 1: Provider function calling

De meest directe manier om één model toegang tot je code te geven, is de eigen function-calling-API van de provider. Je declareert de beschikbare functies, het model kiest er een wanneer het die nodig heeft, en een gebeurtenis vuurt af in je component zodat je het resultaat kunt leveren. Met het OpenAI-component definieer je de tools één keer op de assistent en handel je daarna de aanroep af:

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"]}}}]';

Wanneer het model besluit dat het een waarde nodig heeft, triggert het component OnFunctionCall. Je inspecteert aRequest._Function._Name om te weten welke tool werd aangevraagd en schrijft het antwoord in aResponse.Output — dat resultaat wordt rechtstreeks terug aan het model gevoerd zodat het zijn antwoord kan afmaken:

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;

Die event-handler is de agentlus. Telkens wanneer het model om een tool vraagt, voer je hem uit en keer je terug; het component houdt het gesprek gaande totdat het model alles heeft wat het nodig heeft. Dit pad is ideaal wanneer de agent binnen je eigen applicatie leeft en met één provider praat. Dezelfde vorm is beschikbaar op de Anthropic- en Gemini-componenten, dus je zit nergens aan vast. Zie de walkthrough van OpenAI function calling voor het volledige voorbeeld.

Pad 2: MCP-tools

Function calling bindt je tools aan één model in één app. Het Model Context Protocol maakt van hetzelfde idee een herbruikbare service: je applicatie stelt een set tools beschikbaar via een standaard JSON-RPC-endpoint, en elke MCP-capabele client of agent — een IDE-assistent, een desktop-AI-app of je eigen agentlus — kan verbinding maken, die tools ontdekken en aanroepen. Je schrijft de tool één keer; elke MCP-host kan hem gebruiken.

In sgcWebSockets is de serverkant TsgcWSAPIServer_MCP. Je koppelt het aan een sgcWebSockets HTTP-server, registreert tools met Tools.AddTool, en handelt de inkomende aanroep af in 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;

Wanneer een verbonden client de tool aanroept, vuurt de gebeurtenis af met sterk getypeerde aanvraag- en antwoordobjecten. Je leest de toolnaam uit aRequest.Params.Name en zijn argumenten uit aRequest.Params.Arguments, en schrijft daarna het antwoord met 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;

De handler doet hetzelfde werk als de function-calling-gebeurtenis, maar nu is de tool bereikbaar door elke MCP-host over het netwerk. Omdat MCP een gepubliceerde standaard is, hoeft de agent die het gesprek aanstuurt helemaal niet door jou te zijn geschreven. Lees meer in het MCP-overzicht en op de pagina van het MCP Server-component.

Welk pad moet je gebruiken?

Als je wilt…	Gebruik	Component
Een agent die binnen je eigen app leeft en met één provider praat	Provider function calling	TsgcAIOpenAIAssistant
Tools die elke MCP-capabele client of agent kan ontdekken en aanroepen	MCP-server	TsgcWSAPIServer_MCP
Tools aanroepen die door iemand anders' MCP-server worden gehost	MCP-client	TsgcWSAPIClient_MCP

De twee sluiten elkaar niet uit. Een veelvoorkomend ontwerp is een in-app-agent die provider function calling gebruikt voor zijn eigen private tools, en die tegelijk als MCP-client verbinding maakt met gedeelde toolservers elders in je organisatie. Wat je ook kiest, de lus die je schrijft ziet er bijna identiek uit, dus later wisselen ertussen is goedkoop.

Aan de slag

Beide paden zitten in sgcWebSockets (de MCP-server en -client zijn Enterprise-componenten). Pak de gratis proefversie, voeg TsgcAIOpenAIAssistant toe voor function calling of TsgcWSAPIServer_MCP voor een MCP-service, koppel de tool-gebeurtenis, en je hebt een agent die op je eigen code kan handelen in een paar regels. Bekijk elke AI-bouwsteen op de hub met AI & LLM-componenten.

Vragen of hulp nodig bij het ontwerpen van je agent? Neem contact op — je krijgt antwoord van de mensen die de code geschreven hebben.

Gerelateerd

• Alle AI & LLM-componenten voor Delphi
• Een MCP-server bouwen in Delphi
• OpenAI function calling in Delphi
• OpenAI vs Anthropic vs Gemini in Delphi