Delphi MCP Server

A Model Context Protocol (MCP) server implementation in Delphi, designed to integrate with Claude Code, Codex, and other MCP-compatible clients for AI-powered Delphi development workflows.

Table of Contents

• Features
• Requirements
• Installation
• Transport Modes
• Using as a Library
• Integration with Claude Code
• Integration with Codex
• Testing with MCP Inspector
• Available Example Tools
• Available Example Resources
• Configuration
• License
• Contributing
• About GDK Software
• Support

Features

• Full MCP Protocol Support: Implements MCP specification 2025-06-18 with Streamable HTTP and SSE
• Dual Transport Support: HTTP (Streamable HTTP with SSE) and STDIO (stdin/stdout)
• Dual Response Mode: Supports both JSON-RPC and Server-Sent Events in the same server
• Tool System: Extensible tool system with RTTI-based discovery and execution
• Resource Management: Modular resource system supporting various content types
• Security: Built-in security features including CORS configuration
• High Performance: Native implementation using Indy HTTP Server with keep-alive support
• Optional Parameters: Support for optional tool parameters using custom attributes
• Cross-Platform: Supports Windows (Win32/Win64) and Linux (x64)

Requirements

• Delphi 12 Athens or later
• Windows (Win32/Win64) or Linux (x64)
• No external dependencies (all required libraries included)

Installation

For Standalone Usage

1. Clone the repository:

git clone https://github.com/GDKsoftware/delphi-mcp-server.git
cd delphi-mcp-server

2. Build the project:

Windows Build

build.bat

Or specify configuration and platform:

build.bat Debug Win32
build.bat Release Win64

Linux Build

Prerequisites:

• Delphi Enterprise with Linux platform support
• PAServer running on Linux target machine
• Linux SDK configured in RAD Studio

From the batch file:

build.bat Release Linux64

Or from RAD Studio IDE:

1. Open MCPServer.dproj
2. Select Linux64 platform
3. Build

Transport Modes

The server supports two transport modes:

HTTP Transport (Default)

Start the server without arguments for HTTP transport with Server-Sent Events (SSE):

Win32\Debug\MCPServer.exe

The server will listen on http://localhost:3000/mcp by default (configurable via settings.ini).

Use HTTP transport for:

• Claude Code (SSE support)
• MCP Inspector
• Web-based clients
• Remote connections

STDIO Transport

Start the server with --stdio flag for stdin/stdout communication:

Win32\Debug\MCPServer.exe --stdio

The server will:

• Read JSON-RPC requests from stdin (one per line)
• Write JSON-RPC responses to stdout (one per line)
• Log diagnostic messages to stderr

Use STDIO transport for:

• Codex (OpenAI)
• Local MCP clients that use process spawning
• Automated testing and scripting

Supported flag variants: --stdio, -stdio, /stdio

Using as a Library

The Delphi MCP Server is designed to be used both as a standalone application and as a library for your own MCP server implementations. This section covers how to integrate it into your existing Delphi projects.

Project Setup for Library Usage

Option 1: Git Submodule (Recommended)

# Add MCPServer as a submodule to your project
git submodule add https://github.com/GDKsoftware/delphi-mcp-server.git lib/mcpserver
git submodule update --init --recursive

Option 2: Direct Source Inclusion

Copy the src folder from MCPServer into your project and add the units to your uses clauses.

Delphi Project Configuration

1. Search Paths: Add the MCPServer source directories to your project search path:

   • lib\mcpserver\src\Core
   • lib\mcpserver\src\Managers
   • lib\mcpserver\src\Protocol
   • lib\mcpserver\src\Server
   • lib\mcpserver\src\Tools
   • lib\mcpserver\src\Resources

2. Required Units: Include these core units in your project:

   MCPServer.Types,
   MCPServer.Settings,
   MCPServer.Registration,
   MCPServer.ManagerRegistry,
   MCPServer.IdHTTPServer,      // For HTTP transport
   MCPServer.StdioTransport,    // For STDIO transport
   MCPServer.JsonRpcProcessor   // Shared JSON-RPC processing
   

Library Integration

Once you have the project setup complete, the simplest way to add MCP capabilities to your application:

program YourMCPServer;

{$APPTYPE CONSOLE}

uses
  System.SysUtils,
  MCPServer.Types in 'lib\mcpserver\src\Protocol\MCPServer.Types.pas',
  MCPServer.IdHTTPServer in 'lib\mcpserver\src\Server\MCPServer.IdHTTPServer.pas',
  MCPServer.Settings in 'lib\mcpserver\src\Core\MCPServer.Settings.pas',
  MCPServer.ManagerRegistry in 'lib\mcpserver\src\Core\MCPServer.ManagerRegistry.pas',
  MCPServer.CoreManager in 'lib\mcpserver\src\Managers\MCPServer.CoreManager.pas',
  MCPServer.ToolsManager in 'lib\mcpserver\src\Managers\MCPServer.ToolsManager.pas',
  MCPServer.ResourcesManager in 'lib\mcpserver\src\Managers\MCPServer.ResourcesManager.pas';

var
  Server: TMCPIdHTTPServer;
  Settings: TMCPSettings;
  ManagerRegistry: IMCPManagerRegistry;
  
begin
  Settings := TMCPSettings.Create;
  try
    ManagerRegistry := TMCPManagerRegistry.Create;
    ManagerRegistry.RegisterManager(TMCPCoreManager.Create(Settings));
    ManagerRegistry.RegisterManager(TMCPToolsManager.Create);
    ManagerRegistry.RegisterManager(TMCPResourcesManager.Create);
    
    Server := TMCPIdHTTPServer.Create(nil);
    try
      Server.Settings := Settings;
      Server.ManagerRegistry := ManagerRegistry;
      Server.Start;
      
      Writeln('MCP Server running on port ', Settings.Port);
      Readln; // Keep running
      
      Server.Stop;
    finally
      Server.Free;
    end;
  finally
    Settings.Free;
  end;
end.

Creating Custom Tools

unit YourProject.Tool.Custom;

interface

uses
  MCPServer.Tool.Base,
  MCPServer.Types,
  MCPServer.Registration;

type
  TCustomToolParams = class
  private
    FInput: string;
    FCount: Integer;
  public
    [SchemaDescription('Text input to process')]
    property Input: string read FInput write FInput;
    
    [Optional]
    [SchemaDescription('Number of times to repeat (default: 1)')]
    property Count: Integer read FCount write FCount;
  end;

  TCustomTool = class(TMCPToolBase<TCustomToolParams>)
  protected
    function ExecuteWithParams(const AParams: TCustomToolParams): string; override;
  public
    constructor Create; override;
  end;

implementation

constructor TCustomTool.Create;
begin
  inherited;
  FName := 'custom_tool';
  FDescription := 'A custom tool that processes input';
end;

function TCustomTool.ExecuteWithParams(const AParams: TCustomToolParams): string;
var
  I: Integer;
  Output: string;
begin
  Output := '';
  for I := 1 to AParams.Count do
    Output := Output + AParams.Input + #13#10;
  Result := 'Processed: ' + Output;
end;

initialization
  TMCPRegistry.RegisterTool('custom_tool',
    function: IMCPTool
    begin
      Result := TCustomTool.Create;
    end
  );

end.

Creating Custom Resources

unit YourProject.Resource.Custom;

interface

uses
  System.SysUtils,
  MCPServer.Resource.Base,
  MCPServer.Registration;

type
  TCustomData = class
  private
    FMessage: string;
    FTimestamp: TDateTime;
  public
    property Message: string read FMessage write FMessage;
    property Timestamp: TDateTime read FTimestamp write FTimestamp;
  end;

  TCustomResource = class(TMCPResourceBase<TCustomData>)
  protected
    function GetResourceData: TCustomData; override;
  public
    constructor Create; override;
  end;

implementation

constructor TCustomResource.Create;
begin
  inherited;
  FURI := 'custom://data';
  FName := 'Custom Data';
  FDescription := 'Custom resource data';
  FMimeType := 'application/json';
end;

function TCustomResource.GetResourceData: TCustomData;
begin
  Result := TCustomData.Create;
  Result.Message := 'Hello from custom resource';
  Result.Timestamp := Now;
end;

initialization
  TMCPRegistry.RegisterResource('custom://data',
    function: IMCPResource
    begin
      Result := TCustomResource.Create;
    end
  );

end.

Integration with Claude Code

Configure using the Streamable HTTP transport:

# Basic configuration
claude mcp add --transport http delphi-mcp-server http://localhost:3000/mcp

# With authentication (if configured)
claude mcp add --transport http delphi-mcp-server http://localhost:3000/mcp --header "Authorization: Bearer your-token"

Make sure the server is running before connecting Claude Code.

Integration with Codex

Configure Codex to use the STDIO transport. Edit your Codex configuration file (~/.codex/config.toml):

[mcp_servers.delphi-mcp-server]
command = 'C:\path\to\MCPServer.exe'
args = ["--stdio"]

Or on Linux/macOS:

[mcp_servers.delphi-mcp-server]
command = '/path/to/MCPServer'
args = ["--stdio"]

Important: The server must be compiled and the executable path must be absolute.

After configuration:

1. Restart Codex
2. Use /mcp command to verify the server is connected
3. Available tools will appear in the Codex interface

HTTPS/SSL Configuration

The server supports HTTPS connections when configured with SSL certificates:

1. Generate SSL Certificates:

   # Genera