Resposta rápida: um agente de IA é apenas um modelo de linguagem que pode chamar o seu próprio código. Você descreve um conjunto de ferramentas, o modelo decide quando invocar uma delas, o seu aplicativo a executa e retorna o resultado, e o modelo continua a partir daí — em um laço, até a tarefa estar concluída. O sgcWebSockets oferece duas formas de construir isso no Delphi ou no C++ Builder: function calling do provedor (o modelo pede para chamar uma das suas funções por meio do componente OpenAI, Anthropic ou Gemini) e MCP (o padrão aberto Model Context Protocol, em que o seu servidor expõe ferramentas que qualquer cliente ou agente compatível com MCP pode descobrir e chamar). Ambos usam a mesma ideia; você escolhe a que se encaixa em onde o agente vive.
As pessoas às vezes imaginam um "agente" como um modelo especial. Não é. É um modelo de chat comum mais um pequeno laço de controle no seu código que permite a ele alcançar fora da conversa. Uma vez que o modelo pode chamar uma função que consulta um banco de dados, lê um arquivo ou acessa uma API interna, ele deixa de ser um chatbot e passa a poder agir. Os dois caminhos abaixo diferem apenas em quem hospeda as ferramentas.
O laço do agente
Todo agente, independentemente do provedor, segue o mesmo ciclo:
- Envia a mensagem do usuário junto com uma lista de definições de ferramentas (nome, descrição, parâmetros).
- O modelo ou responde em texto simples, ou responde "chame a ferramenta X com estes argumentos".
- Se ele pedir uma ferramenta, o seu código executa o trabalho real e devolve o resultado.
- O modelo lê o resultado e ou chama outra ferramenta ou produz a resposta final.
- Repete até o modelo parar de pedir ferramentas.
O modelo nunca executa nada por conta própria. Ele apenas propõe chamadas; o seu código Delphi mantém o controle do que de fato é executado, o que é o que torna o padrão seguro para colocar diante de sistemas reais.
Caminho 1: function calling do provedor
A forma mais direta de dar a um único modelo acesso ao seu código é a API de function calling do próprio provedor. Você declara as funções disponíveis, o modelo escolhe uma quando precisa dela, e um evento dispara no seu componente para que você possa fornecer o resultado. Com o componente OpenAI, você define as ferramentas uma vez no assistant e depois trata a chamada:
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"]}}}]';Quando o modelo decide que precisa de um valor, o componente dispara OnFunctionCall. Você inspeciona aRequest._Function._Name para saber qual ferramenta foi solicitada e escreve a resposta em aResponse.Output — esse resultado é devolvido diretamente ao modelo para que ele possa terminar a sua resposta:
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;Esse handler de evento é o laço do agente. Cada vez que o modelo pede uma ferramenta, você a executa e retorna; o componente mantém a conversa andando até o modelo ter tudo de que precisa. Esse caminho é ideal quando o agente vive dentro do seu próprio aplicativo e fala com um único provedor. O mesmo formato está disponível nos componentes Anthropic e Gemini, então você não fica preso. Veja o passo a passo de function calling da OpenAI para o exemplo completo.
Caminho 2: ferramentas MCP
O function calling vincula as suas ferramentas a um modelo em um aplicativo. O Model Context Protocol transforma a mesma ideia em um serviço reutilizável: o seu aplicativo expõe um conjunto de ferramentas por um endpoint JSON-RPC padrão, e qualquer cliente ou agente compatível com MCP — um assistente de IDE, um aplicativo de IA desktop ou o seu próprio laço de agente — pode se conectar, descobrir essas ferramentas e chamá-las. Você escreve a ferramenta uma vez; todo host MCP pode usá-la.
No sgcWebSockets, o lado do servidor é o TsgcWSAPIServer_MCP. Você o anexa a um servidor HTTP do sgcWebSockets, registra ferramentas com Tools.AddTool e trata a chamada recebida em 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;Quando um cliente conectado chama a ferramenta, o evento dispara com objetos de requisição e resposta fortemente tipados. Você lê o nome da ferramenta em aRequest.Params.Name e os seus argumentos em aRequest.Params.Arguments, e depois escreve a resposta com 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;O handler faz o mesmo trabalho que o evento de function calling, mas agora a ferramenta é acessível por qualquer host MCP pela rede. Como o MCP é um padrão publicado, o agente que conduz a conversa não precisa ser escrito por você. Leia mais na visão geral do MCP e na página do componente MCP Server.
Qual caminho você deve usar?
| Se você quer… | Use | Componente |
|---|---|---|
| Um agente que vive dentro do seu próprio aplicativo e fala com um único provedor | Function calling do provedor | TsgcAIOpenAIAssistant |
| Ferramentas que qualquer cliente ou agente compatível com MCP pode descobrir e chamar | Servidor MCP | TsgcWSAPIServer_MCP |
| Chamar ferramentas hospedadas no servidor MCP de outra pessoa | Cliente MCP | TsgcWSAPIClient_MCP |
Os dois não são mutuamente exclusivos. Um design comum é um agente dentro do aplicativo que usa function calling do provedor para as suas próprias ferramentas privadas, ao mesmo tempo em que também se conecta como um cliente MCP a servidores de ferramentas compartilhadas em outras partes da sua organização. Qualquer que seja a sua escolha, o laço que você escreve fica quase idêntico, então mudar entre eles mais tarde é barato.
Primeiros passos
Ambos os caminhos vêm no sgcWebSockets (o servidor e o cliente MCP são componentes Enterprise). Baixe a versão de avaliação gratuita, adicione TsgcAIOpenAIAssistant para function calling ou TsgcWSAPIServer_MCP para um serviço MCP, conecte o evento da ferramenta e você terá um agente que pode agir sobre o seu próprio código em poucas linhas. Explore todos os blocos de construção de IA no hub de componentes de IA & LLM.
Dúvidas ou quer ajuda para projetar o seu agente? Entre em contato — você receberá uma resposta das pessoas que escreveram o código.