Become a member!

Não apenas MCP. Um agente de IA real, incorporado na sua aplicação Delphi.

· 12 min read
🌐
Este artigo também está disponível em outros idiomas:
🇮🇹 Italiano  •  🇬🇧 English  •  🇪🇸 Español  •  🇩🇪 Deutsch

São 8h30. O diretor comercial abre o ERP Agêntico. Na lista de e-mails recebidos já há uma solicitação de Rossi:

“Olá, gostaria de fazer um pedido urgente: 5 laptops e 3 webcams, com o desconto habitual. Podem confirmar ainda hoje? Obrigado, Rossi.”

Sem sair do ERP, ele abre o chat do agente e escreve: “Trate a solicitação.”

Em menos de trinta segundos, o agente de IA fez tudo:

  • Leu o e-mail diretamente do ERP
  • Identificou o cliente pelo endereço de e-mail
  • Consultou os quatro pedidos anteriores no histórico
  • Entendeu que “o desconto habitual” é 5% (nunca explicitado em nenhum campo do banco de dados, deduzido apenas pela leitura do histórico)
  • Criou o pedido como rascunho, com os produtos corretos e o desconto correto
  • Escreveu o rascunho do e-mail de confirmação, pronto para envio

O agente de IA não enviou nada por conta própria. Preparou tudo e parou para aguardar. O diretor comercial lê o resumo: cliente correto, produtos corretos, desconto de 5% com a justificativa (“histórico de pedidos: sempre 5%”), rascunho do e-mail de confirmação já escrito. Tudo correto. Clica em “Aprovar e enviar”. Somente então o e-mail é enviado e o pedido é confirmado no sistema.

O mesmo fluxo feito manualmente exige mudar para o cliente de e-mail, abrir o registro do cliente no ERP, navegar pelo histórico de pedidos em várias telas para encontrar o desconto não especificado, abrir o formulário de pedido, adicionar os produtos um a um, aplicar o desconto, voltar ao cliente de e-mail e escrever a confirmação. Uns dez minutos em condições ideais, com atenção total e zero interrupções. O agente de IA levou trinta segundos.

Ele disse uma frase ao seu ERP. E o ERP entendeu. E agiu.

mcp-server-delphi é uma biblioteca open source para Delphi (Apache 2.0) para construir aplicações agênticas com o Model Context Protocol (MCP). Inclui um loop agêntico incorporado escrito inteiramente em Delphi, um servidor MCP (transporte stdio e Streamable HTTP) e um cliente MCP. Integra-se nativamente com o DMVCFramework e suporta a API da OpenAI como motor de raciocínio.

Do servidor ao agente: o salto qualitativo

No artigo anterior vimos como expor as ferramentas do seu ERP ao protocolo MCP: a forma como Claude, Gemini e outros assistentes de IA se conectam ao software externo. Um servidor MCP já é poderoso: permite que um assistente externo consulte seu banco de dados, crie pedidos, leia o status dos clientes.

O projeto mcp-server-delphi não é apenas uma biblioteca para construir servidores MCP. É uma plataforma para construir agentes de IA incorporados na sua aplicação Delphi.

A diferença é substancial:

Servidor MCP (passivo) Agente incorporado (ativo)
Um cliente de IA externo se conecta e chama tools O loop de IA roda dentro do seu app Delphi
A inteligência está no cliente (Claude, Gemini…) A inteligência orquestra seus tools por dentro
O usuário trabalha fora do ERP O usuário fala com o ERP
Os dados passam por um serviço externo Os tools rodam dentro do app: controle total sobre o que expor ao modelo

Uma aplicação que incorpora este loop não é simplesmente um software que “suporta MCP”: é uma aplicação agêntica. A inteligência não está hospedada em outro lugar e não depende de um cliente externo: raciocina sobre seus dados, usa seus tools, respeita suas regras.

Ao mesmo tempo, sua aplicação também expõe um servidor MCP: assim o Claude Desktop, o Gemini CLI ou qualquer outro cliente de IA compatível ainda pode se conectar de fora. Não é uma coisa ou outra: são as duas coisas juntas.

Como funciona o loop agêntico

Quando o usuário digita uma mensagem no chat do ERP, não acontece uma simples chamada de API. O loop agêntico (escrito inteiramente em Delphi) faz o seguinte:

  1. Envia a mensagem ao modelo de IA (API da OpenAI) junto com a lista de todos os tools disponíveis
  2. O modelo responde com uma ou mais tool calls: solicita a execução de funções reais no ERP
  3. O loop executa os tools e coleta os resultados
  4. Reenvia tudo ao modelo, que pode chamar mais tools ou responder ao usuário
  5. Repete até que o modelo tenha uma resposta completa

Uma mensagem como “Processe este e-mail e crie o pedido” pode gerar 10-15 tool calls em sequência: busca de cliente, verificação do limite de crédito, análise do histórico de descontos, criação do pedido, adição de itens, envio do e-mail de confirmação. O agente de IA executa cada etapa respeitando as regras de negócio já presentes no código, sem sair da aplicação.

O modelo não “sabe” como funciona seu ERP. Ele sabe ler as descrições dos tools que você expõe. O restante é feito pelo seu código Delphi. Este é o núcleo da abordagem agêntica: não um chatbot que responde perguntas, mas um agente de IA que planeja, age e conclui tarefas complexas de forma autônoma, pedindo confirmação humana somente quando necessário.

Aqui está um exemplo concreto: uma solicitação real enviada ao chat do agente do ERP Agêntico. O screenshot está em italiano, mas a solicitação traduzida abaixo deixa claro exatamente o que foi pedido ao agente de IA.

“Crie um pedido para Verdi Distribuzione: 3 projetores e 2 tablets Android. Aplique desconto de 8% em tudo, confirme o pedido e agende a entrega em 7 dias às 10:00.”

O ERP Agêntico em ação: o usuário pede para criar um pedido para Verdi Distribuzione (3 projetores e 2 tablets Android), aplicar desconto de 8%, confirmar o pedido e agendar a entrega em 7 dias. O agente de IA processa toda a sequência de forma autônoma e apresenta o resumo aguardando aprovação.

O agente de IA processou toda a solicitação de forma autônoma: buscou o cliente Verdi Distribuzione, criou o pedido com os produtos solicitados, verificou o estoque no armazém, aplicou o desconto de 8%, confirmou o pedido e agendou o compromisso de entrega. Cada etapa se baseia na lógica de negócio já presente na aplicação, exposta ao agente de IA através dos tools do servidor MCP. Nenhum dado saiu da infraestrutura da empresa.

O momento mais importante: quando a IA para

Nas demos ao vivo sempre mostro este cenário: o agente de IA está processando um pedido complexo, já encontrou o cliente, verificou o limite de crédito, selecionou os produtos. Então, em vez de continuar sozinho, abre um popup modal Delphi com uma pergunta:

“Encontrei três variantes do produto solicitado. Qual você prefere? (A) Standard, (B) Pro, (C) Premium”

A thread de IA está suspensa. O loop aguarda. O usuário responde. O agente de IA retoma.

Este é o tool ask_user: uma função que a IA pode chamar sempre que precisar de uma escolha humana. Não é uma limitação, é o ponto forte do sistema.

Na realidade empresarial, nem todos os processos são definidos de forma rígida. Há exceções, contextos particulares, relações comerciais que um algoritmo não pode conhecer. O diretor comercial sabe que aquele cliente precisa ser tratado de forma diferente esta semana. Sabe que aquele desconto não se aplica neste contexto. Sabe que o pedido é urgente por uma razão que não está escrita em lugar nenhum. Essa discricionariedade não é um defeito no processo, é valor humano insubstituível.

Com ask_user, o agente de IA não tenta substituir esse julgamento: ele para, apresenta as opções e aguarda. A IA traz velocidade. O humano traz contexto. O resultado é um processo que não perde flexibilidade em relação a antes, mas ganha uma velocidade que antes era inimaginável.

Você não está automatizando as decisões. Está automatizando todo o trabalho de preparação ao redor delas.

O ERP agêntico em ação: mais cenários

E-mail complexo: 2 e-mails + 1 pedido

Um único e-mail com duas solicitações distintas: “Me envie um resumo das faturas em aberto e também adicione um pedido rascunho para a linha de vestuário.”

O agente de IA analisa o e-mail, lista explicitamente as duas solicitações e as executa em sequência: 12-15 tool calls, dois e-mails de resposta escritos e salvos, um pedido rascunho criado. Tudo visível no log de tools no chat, tudo rastreável, tudo dentro do ERP. Um operador que gerencia o mesmo e-mail manualmente (abrir as faturas, escrever o resumo, criar o pedido, escrever dois e-mails separados) facilmente gasta vinte ou trinta minutos. Aqui estamos em menos de dois minutos.

Cobrança com raciocínio

“Para os clientes com faturas vencidas há mais de 30 dias, calcule um índice de urgência e agende os compromissos de cobrança.”

O índice de urgência (valor x dias de atraso, com um fator diferente para clientes históricos) não existe no banco de dados. A IA o calcula, ordena os clientes por prioridade e cria compromissos com títulos diferenciados conforme o perfil de risco. Feito em poucos segundos para todos os clientes inadimplentes. Manualmente, extrair a lista, calcular o índice para cada um, abrir a agenda e agendar cada compromisso requer pelo menos meia hora, e raramente é feito exatamente por isso.

DMVCFramework: a vantagem estrutural

Definir um tool: anotação, implementação, registro

Definir um tool se resume a anotar a assinatura da função:

type
  TMyTools = class(TMCPToolProvider)
  public
    [MCPTool('reverse_string', 'Reverses a string')]
    function ReverseString(
      [MCPParam('The string to reverse')] const Value: string
    ): TMCPToolResult;

    [MCPTool('concat_strings', 'Concatenates two strings with a separator')]
    function ConcatStrings(
      [MCPParam('First string')] const A: string;
      [MCPParam('Second string')] const B: string
    ): TMCPToolResult;
  end;

O framework descobre tudo via RTTI, gera o esquema JSON, registra os tools no servidor MCP e os disponibiliza tanto para o agente de IA incorporado quanto para qualquer cliente externo. Nenhum arquivo de configuração, nenhum XML, nenhum registro manual.

Para um ERP real o padrão é idêntico, apenas os nomes e a lógica de negócio mudam:

[MCPTool('create_order', 'Creates a new order for the specified customer')]
function CreateOrder(
  [MCPParam('Customer ID')] const CustomerID: Integer;
  [MCPParam('Discount percentage (0-100)')] const Discount: Double
): TMCPToolResult;

Você não precisa aprender um novo framework. Não precisa reescrever a lógica de negócio. Só precisa decidir quais funcionalidades tornar acessíveis à IA e anotá-las.

A bridge: de REST para MCP sem tocar uma linha

Se você já tem uma aplicação DMVCFramework com controllers REST em produção, há um caminho ainda mais direto: a bridge MCP, inspirada no mecanismo análogo do FastMCP. Você tem um controller assim:

[MVCPath('/api/books')]
TBooksController = class(TMVCController)
public
  [MVCPath]
  [MVCHTTPMethod([httpGET])]
  [MVCDoc('Returns the list of all books')]
  procedure GetBooks;

  [MVCPath('/search')]
  [MVCHTTPMethod([httpGET])]
  [MVCDoc('Searches books by title keyword. Use limit to cap results (default 10)')]
  procedure SearchBooks(
    const [MVCFromQueryString('q')] q: string;
    const [MVCFromQueryString('limit', '10')] limit: Integer
  );
end;

Para expor tudo como servidor MCP basta uma chamada no Web Module:

TMCPServer.Instance.RegisterFromEngine(Engine, 'http://localhost:8080');

Zero alterações no controller. Zero código de wrapping. Suas APIs se tornam tools do agente de IA no tempo que leva para adicionar uma linha.

⚠️ Nota sobre a bridge

Isso vale também no mundo FastMCP: a bridge é uma ferramenta de bootstrap, não uma solução definitiva para produção. Os modelos de IA obtêm resultados significativamente melhores com tools projetados e curados especificamente para eles: descrições pensadas para guiar o raciocínio do modelo, parâmetros reduzidos ao essencial, nomes que refletem a intenção e não a estrutura HTTP. A bridge permite que você comece imediatamente e avalie as possibilidades em minutos; o próximo passo é refinar os tools com intenção.

Man-in-the-loop: não uma limitação, uma escolha

Há uma conversa que ouço frequentemente quando apresento essas demos:

“Mas se a IA pode criar pedidos, modificar o banco de dados, enviar e-mails: quem controla que ela não faça algo errado?”

A resposta é: você, by design.

Cada tool que você expõe é seu próprio código Delphi. Você pode fazer com que create_order sempre crie o pedido como rascunho, exigindo confirmação explícita antes de finalizar. Pode usar ask_user sempre que a IA precisar escolher entre alternativas. Pode aplicar todas as mesmas regras de autorização que já tem no ERP, porque o tool é executado no contexto da sessão do usuário atual.

A IA não contorna suas regras de negócio. Ela as executa. A diferença é que agora você pode orquestrá-las em linguagem natural.

🎤 ITDevCon 2026 Spring Edition, 8 de maio - Roma

Tudo que você leu neste artigo (as demos, o código, a arquitetura) será mostrado ao vivo na próxima ITDevCon 2026 Spring Edition, presencialmente no dia 8 de maio de 2026 em Roma. A Spring Edition, ao contrário da edição principal de outono, é realizada somente em italiano.

Veremos juntos:

  • O loop agêntico em ação: do e-mail ao pedido em tempo real
  • Como projetar tools MCP que a IA usa bem (descrições, parâmetros, resultados)
  • O tool ask_user e o padrão man-in-the-loop na prática
  • Como adicionar o agente de IA a uma aplicação DMVCFramework existente
  • Arquitetura dual-mode: agente incorporado + servidor MCP para clientes externos
  • Demos ao vivo com código-fonte aberto

Se você está pensando em levar IA ao seu ERP Delphi, esta sessão é o ponto de partida mais direto que você pode encontrar. Registre-se em itdevcon.it.

📚 Curso dedicado em breve: MCP e Agentic AI com Delphi

Para quem quiser se aprofundar com um percurso estruturado, estou preparando um curso dedicado sobre MCP e Agentic AI com Delphi. Estará disponível em breve na bit Time Professionals.

O curso abrangerá:

  • Fundamentos do protocolo MCP e do loop agêntico
  • Desenvolvimento de tool providers eficazes para sistemas de gestão reais
  • Gestão do man-in-the-loop: quando a IA deve parar e perguntar
  • Implantação, segurança e performance em ambientes de produção
  • Cenários avançados: orquestração multi-tool, tratamento de erros, logging

Além da formação, a bit Time Professionals oferece também consultoria especializada para ajudar empresas a integrar a IA de forma concreta nos seus sistemas. Já estamos trabalhando com empresas de todo o mundo para levar capacidades agênticas às suas aplicações existentes (Delphi, Python, C# e mais), desde a identificação de oportunidades até a implementação em produção. Se você tem um projeto específico em mente, entre em contato.

Fique atento: os detalhes do curso serão anunciados nas próximas semanas.

Adicione um agente de IA ao seu ERP Delphi: comece hoje

O projeto é open source, licença Apache 2.0.

Página do projeto e documentação

Seu ERP Delphi já tem todo o valor. Os dados estão lá. A lógica de negócio está lá. As regras estão lá.

Faltava apenas um agente de IA que vivesse dentro dele: capaz de entender linguagem natural, orquestrar tools, respeitar regras de negócio e parar para perguntar quando necessário. Não um servidor MCP passivo aguardando instruções de fora. Uma aplicação genuinamente agêntica.

Agora existe.

Comments

comments powered by Disqus