Kurze Antwort: Ein KI-Agent ist einfach ein Sprachmodell, das Ihren eigenen Code aufrufen kann. Sie beschreiben eine Reihe von Tools, das Modell entscheidet, wann es eines aufruft, Ihre Anwendung führt es aus und gibt das Ergebnis zurück, und das Modell macht von dort aus weiter — in einer Schleife, bis die Aufgabe erledigt ist. sgcWebSockets bietet Ihnen zwei Wege, dies in Delphi oder C++ Builder zu bauen: Provider-Function-Calling (das Modell bittet darum, eine Ihrer Funktionen über die OpenAI-, Anthropic- oder Gemini-Komponente aufzurufen) und MCP (das offene Model Context Protocol, bei dem Ihr Server Tools bereitstellt, die jeder MCP-fähige Client oder Agent entdecken und aufrufen kann). Beide nutzen dieselbe Idee; Sie wählen die, die zu dem Ort passt, an dem der Agent lebt.
Manche stellen sich einen „Agenten" als ein besonderes Modell vor. Das ist er nicht. Es ist ein gewöhnliches Chat-Modell plus eine kleine Steuerungsschleife in Ihrem Code, die es ihm erlaubt, über die Unterhaltung hinauszugreifen. Sobald das Modell eine Funktion aufrufen kann, die eine Datenbank abfragt, eine Datei liest oder eine interne API anspricht, hört es auf, ein Chatbot zu sein, und beginnt, handeln zu können. Die beiden untenstehenden Wege unterscheiden sich nur darin, wer die Tools hostet.
Die Agentenschleife
Jeder Agent, unabhängig vom Anbieter, folgt demselben Zyklus:
- Senden Sie die Nachricht des Benutzers zusammen mit einer Liste von Tool-Definitionen (Name, Beschreibung, Parameter).
- Das Modell antwortet entweder in Klartext oder erwidert „Rufe Tool X mit diesen Argumenten auf".
- Wenn es ein Tool anfordert, führt Ihr Code die eigentliche Arbeit aus und gibt das Ergebnis zurück.
- Das Modell liest das Ergebnis und ruft entweder ein weiteres Tool auf oder erzeugt die endgültige Antwort.
- Wiederholen, bis das Modell aufhört, nach Tools zu fragen.
Das Modell führt nie selbst etwas aus. Es schlägt nur Aufrufe vor; Ihr Delphi-Code behält die Kontrolle darüber, was tatsächlich läuft, und genau das macht das Muster sicher genug, um es vor echte Systeme zu stellen.
Weg 1: Provider-Function-Calling
Der direkteste Weg, einem einzelnen Modell Zugriff auf Ihren Code zu geben, ist die eigene Function-Calling-API des Anbieters. Sie deklarieren die verfügbaren Funktionen, das Modell wählt eine, wenn es sie braucht, und ein Ereignis wird in Ihrer Komponente ausgelöst, damit Sie das Ergebnis liefern können. Mit der OpenAI-Komponente definieren Sie die Tools einmal auf dem Assistenten und behandeln dann den Aufruf:
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"]}}}]';Wenn das Modell entscheidet, dass es einen Wert braucht, löst die Komponente OnFunctionCall aus. Sie prüfen aRequest._Function._Name, um zu wissen, welches Tool angefordert wurde, und schreiben die Antwort in aResponse.Output — dieses Ergebnis wird direkt an das Modell zurückgegeben, damit es seine Antwort abschließen kann:
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;Dieser Ereignis-Handler ist die Agentenschleife. Jedes Mal, wenn das Modell nach einem Tool fragt, führen Sie es aus und kehren zurück; die Komponente hält die Unterhaltung am Laufen, bis das Modell alles hat, was es braucht. Dieser Weg ist ideal, wenn der Agent in Ihrer eigenen Anwendung lebt und mit einem Anbieter spricht. Dieselbe Form ist auf den Anthropic- und Gemini-Komponenten verfügbar, sodass Sie nicht festgelegt sind. Siehe die Anleitung zum OpenAI-Function-Calling für das vollständige Beispiel.
Weg 2: MCP-Tools
Function Calling bindet Ihre Tools an ein Modell in einer App. Das Model Context Protocol macht aus derselben Idee einen wiederverwendbaren Dienst: Ihre Anwendung stellt eine Reihe von Tools über einen standardisierten JSON-RPC-Endpunkt bereit, und jeder MCP-fähige Client oder Agent — ein IDE-Assistent, eine Desktop-KI-App oder Ihre eigene Agentenschleife — kann sich verbinden, diese Tools entdecken und aufrufen. Sie schreiben das Tool einmal; jeder MCP-Host kann es nutzen.
In sgcWebSockets ist die Serverseite TsgcWSAPIServer_MCP. Sie hängen sie an einen sgcWebSockets-HTTP-Server an, registrieren Tools mit Tools.AddTool und behandeln den eingehenden Aufruf 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;Wenn ein verbundener Client das Tool aufruft, wird das Ereignis mit stark typisierten Anfrage- und Antwortobjekten ausgelöst. Sie lesen den Tool-Namen aus aRequest.Params.Name und seine Argumente aus aRequest.Params.Arguments und schreiben dann die Antwort mit 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;Der Handler erledigt dieselbe Aufgabe wie das Function-Calling-Ereignis, aber jetzt ist das Tool über das Netzwerk von jedem MCP-Host erreichbar. Da MCP ein veröffentlichter Standard ist, muss der Agent, der die Unterhaltung steuert, überhaupt nicht von Ihnen geschrieben sein. Mehr dazu in der MCP-Übersicht und auf der Seite zur MCP-Server-Komponente.
Welchen Weg sollten Sie wählen?
| Wenn Sie wollen… | Verwenden Sie | Komponente |
|---|---|---|
| Einen Agenten, der in Ihrer eigenen App lebt und mit einem Anbieter spricht | Provider-Function-Calling | TsgcAIOpenAIAssistant |
| Tools, die jeder MCP-fähige Client oder Agent entdecken und aufrufen kann | MCP-Server | TsgcWSAPIServer_MCP |
| Tools aufzurufen, die vom MCP-Server eines anderen gehostet werden | MCP-Client | TsgcWSAPIClient_MCP |
Die beiden schließen sich nicht gegenseitig aus. Ein gängiger Entwurf ist ein In-App-Agent, der Provider-Function-Calling für seine eigenen privaten Tools nutzt und sich gleichzeitig als MCP-Client mit gemeinsam genutzten Tool-Servern an anderer Stelle in Ihrer Organisation verbindet. Was auch immer Sie wählen, die Schleife, die Sie schreiben, sieht fast identisch aus, sodass ein späterer Wechsel zwischen ihnen günstig ist.
Erste Schritte
Beide Wege sind in sgcWebSockets enthalten (MCP-Server und -Client sind Enterprise-Komponenten). Holen Sie sich die kostenlose Testversion, fügen Sie TsgcAIOpenAIAssistant für Function Calling oder TsgcWSAPIServer_MCP für einen MCP-Dienst ein, verdrahten Sie das Tool-Ereignis, und Sie haben einen Agenten, der mit ein paar Zeilen auf Ihren eigenen Code reagieren kann. Durchsuchen Sie jeden KI-Baustein im Hub für KI- & LLM-Komponenten.
Fragen oder Hilfe beim Entwerfen Ihres Agenten gewünscht? Kontaktieren Sie uns — Sie erhalten eine Antwort von den Leuten, die den Code geschrieben haben.