Delphi Build MCP Server

A Model Context Protocol (MCP) server that enables AI coding agents like Claude Code to compile Delphi projects programmatically.

Features

• IDE-Identical Windows Builds: Windows targets (Win32/Win64/Win64x) compile via MSBuild, producing byte-identical output to the Delphi IDE — including icons, manifests, and DPI awareness
• Hybrid Compilation: MSBuild for Windows targets, direct dcc for cross-compilation (Linux64/Android/Android64)
• Minimal Configuration: Windows targets need only the Delphi installation path — MSBuild reads everything else from the .dproj
• Automatic Configuration: Generate config from IDE build logs with multi-line parsing
• Multi-Config Support: Generate unified config from multiple build logs (Debug/Release × Win32/Win64/Win64x/Linux64)
• Extend Configuration: Add new platforms or libraries to existing config without regenerating
• Smart Compilation: Reads .dproj files for build settings and compiler flags
• Package Support: Compiles both application (.dpr) and package (.dpk) projects with correct output (.exe/.bpl)
• Filtered Output: Returns only errors, filters out warnings and hints
• Multi-Language Support: Parses both English and German compiler output
• Response File Support: Handles command lines >8000 characters automatically
• Cross-Platform: Supports Win32, Win64, Win64x (LLVM), Linux64, Android, and Android64
• Environment Variables: Auto-expands ${USERNAME} in paths
• MCP Compatible: Works with Claude Code, Cline, and other MCP clients
• Network Transport: Streamable HTTP support for remote access (e.g., WSL-Ubuntu to Windows host)
• WSL Interop: Use from WSL-Ubuntu via stdio through Windows Python or via Streamable HTTP

Quick Start

1. Install

# Install UV if you haven't already
# Windows: powershell -c "irm https://astral.sh/uv/install.ps1 | iex"
# macOS/Linux: curl -LsSf https://astral.sh/uv/install.sh | sh
# Or: pip install uv

cd delphi-build-mcp-server
uv venv
uv pip install -e .

2. Generate Configuration

In Delphi IDE:

1. Tools > Options > Building > Show compiler progress > "Verbose"
2. Build your project
3. View > Messages > Right-click > Copy All
4. Save to build.log

Then generate config:

Single Build Log (simple projects):

# Platform-specific config is generated by default (e.g., delphi_config_win64.toml)
uv run python -m src.config_generator build.log

# Generate generic delphi_config.toml instead
uv run python -m src.config_generator build.log --generic

Multiple Build Logs (multi-platform projects):

For projects targeting multiple platforms (Win32/Win64/Linux64), create build logs for each configuration:

1. Build in IDE with each Platform/Config combination
2. Save each build log separately (e.g., build_debug_win32.log, build_release_linux64.log)
3. Generate config from all logs:

# Separate platform-specific config files (default)
uv run python -m src.multi_config_generator build_win32.log build_win64.log
# Creates: delphi_config_win32.toml, delphi_config_win64.toml

# Custom output directory for platform-specific files
uv run python -m src.multi_config_generator *.log -d ./configs/

# Single unified config instead of separate files
uv run python -m src.multi_config_generator build_win32.log build_win64.log --unified -o my_config.toml

# Disable environment variable substitution
uv run python -m src.multi_config_generator *.log --no-env-vars

Configuration Strategy:

Windows targets (Win32/Win64/Win64x) use MSBuild, which reads all compiler settings from the .dproj file. Only a minimal delphi_config.toml with the Delphi installation path is needed. Cross-compilation targets (Linux64/Android/Android64) still need full platform-specific config files.

Platform	Config File	Content
Win32/Win64/Win64x	delphi_config.toml	Minimal (only [delphi] section)
Linux64	delphi_config_linux64.toml	Full (paths, flags, SDK)
Android	delphi_config_android.toml	Full (paths, flags, NDK)
Android64	delphi_config_android64.toml	Full (paths, flags, NDK)

Config search order:

1. DELPHI_CONFIG environment variable (explicit override)
2. delphi_config_{platform}.toml (platform-specific)
3. delphi_config.toml (generic fallback — Windows targets only)

Or use the Python API:

from src.config_generator import ConfigGenerator
from src.multi_config_generator import MultiConfigGenerator
from pathlib import Path

# Single build log
generator = ConfigGenerator()
result = generator.generate_from_build_log(
    build_log_path=Path("build.log"),
    output_path=Path("delphi_config.toml")
)

# Multiple build logs (recommended for multi-platform)
multi_gen = MultiConfigGenerator()
result = multi_gen.generate_from_build_logs(
    build_log_paths=["build_debug_win32.log", "build_release_win64.log", "build_debug_linux64.log"],
    output_path=Path("delphi_config.toml")
)
print(result.message)

3. Configure Claude Code

Edit %APPDATA%\Claude\claude_desktop_config.json:

{
  "mcpServers": {
    "delphi-build": {
      "command": "uv",
      "args": [
        "run",
        "--directory",
        "C:\\path\\to\\delphi-build-mcp-server",
        "main.py"
      ],
      "env": {
        "DELPHI_CONFIG": "C:\\path\\to\\delphi-build-mcp-server\\delphi_config.toml"
      }
    }
  }
}

Server Options

The server supports two transport modes:

Flag	Default	Description
--transport	stdio	Transport type: stdio or streamable-http
--host	0.0.0.0	Bind address (streamable-http only)
--port	8080	Listen port (streamable-http only)

Local (stdio, default):

uv run main.py

Network (Streamable HTTP):

uv run main.py --transport streamable-http
# Server listens on http://0.0.0.0:8080/mcp

Configure Claude Code in WSL-Ubuntu

Two options for using the Delphi MCP server from WSL-Ubuntu:

Option 1: stdio via WSL Interop (Simplest)

WSL can execute Windows binaries directly. This uses stdio transport through the Windows Python -- no HTTP server needed, no manual start. Claude Code manages the server lifecycle automatically.

Edit ~/.claude.json (or project-level .mcp.json) in WSL:

{
  "mcpServers": {
    "delphi-build": {
      "command": "/mnt/c/Users/<username>/path/to/delphi-build-mcp-server/.venv/Scripts/python.exe",
      "args": [
        "/mnt/c/Users/<username>/path/to/delphi-build-mcp-server/main.py"
      ],
      "env": {
        "DELPHI_CONFIG": "C:\\Users\\<username>\\path\\to\\delphi_config.toml"
      }
    }
  }
}

Note: The DELPHI_CONFIG path must use Windows-style paths since the server runs as a Windows process.

Option 2: Streamable HTTP (Network Transport)

Run the MCP server as a persistent HTTP service on Windows and connect from WSL over the network.

1. Start the MCP server on Windows:

cd C:\path\to\delphi-build-mcp-server
uv run main.py --transport streamable-http

To start the server automatically at logon, place start_mcp_server.bat (included in this repository) in your Windows Startup folder (Win+R → shell:startup).

2. Find your Windows host IP from WSL:

# Method 1: WSL gateway IP
cat /etc/resolv.conf | grep nameserver | awk '{print $2}'

# Method 2: Windows hostname
hostname -I  # run on Windows side

3. Configure Claude Code in WSL:

Edit ~/.claude.json (or project-level .mcp.json):

{
  "mcpServers": {
    "delphi-build": {
      "url": "http://<windows-host-ip>:8080/mcp"
    }
  }
}

Note: If the connection is refused, you may need to allow port 8080 through Windows Firewall:

netsh advfirewall firewall add rule name="Delphi MCP Server" dir=in action=allow protocol=TCP localport=8080

4. Use in Claude Code

Please compile my Delphi project at X:\MyProject\MyApp.dproj

Tools

compile_delphi_project

Compile a Delphi project and return parsed results.

Parameters:

• project_path (required): Path to .dpr or .dproj file
• force_build_all: Force rebuild all units
• override_config: Override build config (Debug/Release)
• override_platform: Override platform (Win32/Win64/Win64x/Linux64)
• additional_search_paths: Extra search paths
• additional_flags: Additional compiler flags

Returns:

• success: Whether compilation succeeded
• errors: List of compilation errors (warnings/hints filtered)
• compilation_time_seconds: Time taken
• output_executable: Path to compiled EXE
• statistics: Compilation statistics

generate_config_from_build_log

Generate delphi_config.toml from a single IDE build log.

Parameters:

• build_log_path (required): Path to build log file
• output_config_path: Output file path (overrides default platform-specific naming)
• use_platform_specific_name: Generate platform-specific filename (e.g., delphi_config_win64.toml) based on detected platform (default: true)
• use_env_vars: Replace paths with ${USERNAME} (default: true)

Returns:

• success: Whether generation succeeded
• config_file_path: Path to generated config
• statistics: Paths found and processed
• detected_info: Delphi version, platform, build config

generate_config_from_multiple_build_logs

Generate configuration from multiple IDE build logs for different configurations and platforms. By default, creates separate platform-specific files (e.g., delphi_config_win32.toml, delphi_config_win64.toml).

Parameters:

• build_log_paths (required): Array of paths to IDE build log files (e.g., Debug-Win32, Release-Win64, Debug-Linux64)
• output_config_path: Output file path for unified config (only used when generate_separate_files=false)
• generate_separate_files: Generate separate platform-specific config files (default: true). Set to false for a single unified config.
• output_dir: Output directory for generated files (default: current directory)
• use_env_vars: Replace paths with ${USERNAME} (default: true)

Returns:

• success: Whether generation succeeded
• config_file_path: Path to generated config(s)
• build_logs_processed: Details of each processed log (path, config, platform, auto_detected)
• statistics: Configs found, platforms found, total library paths, files generated

extend_config_from_build_log

Extend an existing delphi_config.toml with settings from a new IDE build log. Useful for adding support for new platforms (e.g., Win64x) or libraries without regenerating the entire configuration.

Parameters:

• existing_config_path (required): Path to existing delphi_config.toml
• build_log_path (required): Path to IDE build log file
• output_config_path: Output path (default: overwrites existing)
• use_env_vars: Replace paths with ${USERNAME} (default: true)

Returns:

• success: Whether extension succeeded
• config_file_path: Path to extended config
• paths_added: Number of new paths added
• paths_skipped: Number of duplicates skipped
• platforms_added: List of new platforms (e.g., ["Win64x"])
• settings_updated: Count of settings updated per section

Documentation

• QUICKSTART.md - 5-minute setup guide
• DOCUMENTATION.md - Complete reference

Project Structure

delphi-build-mcp-server/
|-- main.py                       # MCP server entry point (stdio + streamable-http)
|-- src/
|   |-- models.py                 # Pydantic data models
|   |-- buildlog_parser.py        # Parse IDE build logs
|   |-- dproj_parser.py           # Parse .dproj files
|   |-- config.py                 # Load TOML configuration
|   |-- output_parser.py          # Parse dcc compiler output
|   |-- msbuild_output_parser.py  # Parse MSBuild output (extracts _PasCoreCompile)
|   |-- msbuild_compiler.py       # MSBuild compilation for Windows targets
|   |-- rsvars_parser.py          # Parse rsvars.bat for MSBuild environment
|   |-- config_generator.py       # Generate TOML configs (single log)
|   |-- multi_config_generator.py # Generate TOML configs (multi-log)
|   |-- config_extender.py        # Extend existing TOML configs
|   +-- compiler.py               # Direct dcc compilation for cross-compilation
|-- tests/                        # Unit tests
|-- start_mcp_server.bat          # Auto-start script for Windows (shell:startup)
|-- test_stdio_wsl.sh             # Test stdio transport from WSL
|-- test_http_transport.sh        # Test Streamable HTTP transport (bash)
|-- test_http_transport.bat       # Test Streamable HTTP transport (Windows)
|-- delphi_config.toml.template   # Configuration template
|-- pyproject.toml                # Python project config
|-- QUICKSTART.md                 # Quick start guide
+-- DOCUMENTATION.md              # Complete documentation

Requirements

• Python 3.10+
• Delphi 11, 12, or 13
• MCP-compatible client (Claude Code, Cline, etc.)

How It Works

Note: The server automatically handles response files for projects with 80+ library paths (command lines >8000 chars) and parses both English and German compiler output.

1. AI Agent calls compile_delphi_project
   |
   v
2. Parse .dproj file to determine platform
   |
   v
3. Route based on platform:
   |
   +---> Windows (Win32/Win64/Win64x):
   |     - Load minimal config (delphi.root_path only)
   |     - Set up MSBuild environment from rsvars.bat
   |     - Execute msbuild.exe (IDE-identical output)
   |     - Parse _PasCoreCompile section for errors
   |
   +---> Cross-compilation (Linux64/Android/Android64):
         - Load full platform-specific config
         - Build dcc compiler command
         - Execute dcc32/dcc64/dcclinux64/dccaarm64
         - Parse compiler output for errors
   |
   v
4. Return structured result to AI

Example Usage

Compile a Project

from src.compiler import DelphiCompiler
from pathlib import Path

compiler = DelphiCompiler()
result = compiler.compile_project(
    project_path=Path("X:/MyProject/MyApp.dproj")
)

if result.success:
    print(f"[OK] Compilation successful: {result.output_executable}")
else:
    print(f"[FAIL] Compilation failed with {len(result.errors)} errors:")
    for error in result.errors:
        print(f"  {error.file}({error.line},{error.column}): {error.message}")

Generate Config from Build Log

from src.config_generator import ConfigGenerator
from pathlib import Path

generator = ConfigGenerator(use_env_vars=True)
result = generator.generate_from_build_log(
    build_log_path=Path("build.log"),
    output_path=Path("delphi_config.toml")
)

print(f"[OK] {result.message}")
print(f"  Detected: Delphi {result.detected_info.delphi_version}")
print(f"  Platform: {result.detected_info.platform}")
print(f"  Paths found: {result.statistics['unique_paths']}")

Generate Multi-Platform Config from Multiple Build Logs

from src.multi_config_generator import MultiConfigGenerator
from pathlib import Path

generator = MultiConfigGenerator(use_env_vars=True)
result = generator.generate_from_build_logs(
    build_log_paths=[
        "build_debug_win32.log",
        "build_release_win32.log",
        "build_debug_linux64.log",
        "build_release_linux64.log"
    ],
    output_path=Path("delphi_config.toml")
)

print(f"[OK] {result.message}")
print(f"  Configs: {result.statistics['configs_found']}")
print(f"  Platforms: {result.statistics['platforms_found']}")
print(f"  Total paths: {result.statistics['total_library_paths']}")

Extend Existing Config with New Platform

from src.config_extender import ConfigExtender
from pathlib import Path

# Extend existing config with Win64x platform support
extender = ConfigExtender(use_env_vars=True)
result = extender.extend_from_build_log(
    existing_config_path=Path("delphi_config.toml"),
    build_log_path=Path("build_win64x.log")
)

print(f"[OK] {result.message}")
print(f"  New platforms: {result.platforms_added}")
print(f"  Paths added: {result.paths_added}")
print(f"  Paths skipped (duplicates): {result.paths_skipped}")

Or via CLI:

uv run python -m src.config_extender delphi_config.toml build_win64x.log
uv run python -m src.config_extender delphi_config.toml build_win64x.log -o extended_config.toml

Troubleshooting

"Configuration file not found"

Generate it from a build log:

uv run python -m src.config_generator build.log

"Unit not found"

Regenerate config from a fresh IDE build log that includes all dependencies.

"Compiler not found"

Verify delphi.root_path in delphi_config.toml points to your Delphi installation.

Development

Install Development Dependencies

uv pip install -e ".[dev]"

Run Tests

uv run pytest

Test Sample Projects

Two sample projects are included for testing:

# Test successful compilation
uv run python test_compile_samples.py

• sample/working/Working.dproj - Compiles successfully
• sample/broken/Broken.dproj - Intentionally has errors for testing error parsing

Code Formatting

uv run black src/
uv run ruff check src/

Contributing

Contributions are welcome! Please see CONTRIBUTING.md for guidelines.

License

MIT License - see LICENSE file for details.

Support

• Documentation: DOCUMENTATION.md
• Quick Start: QUICKSTART.md
• Issues: https://github.com/basti-fantasti/delphi-build-mcp-server/issues

Acknowledgments

• Built with Model Context Protocol
• Designed for Claude Code
• Supports Embarcadero Delphi