Delphi Build MCP Server

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

Features

• 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), and Linux64 cross-compilation

• 80+ Library Paths: Successfully handles projects with extensive dependencies

• 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

Platform-Specific Config Files:

The server supports platform-specific configuration files with automatic fallback:

Search order:

1. DELPHI_CONFIG environment variable (explicit override)

2. delphi_config_{platform}.toml (platform-specific)

3. delphi_config.toml (generic fallback)

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:

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 compiler output
|   |-- 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               # Compiler orchestration
|-- 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. MCP Server loads delphi_config.toml
   - Delphi installation paths
   - Library search paths
   |
   v
3. Parse .dproj file
   - Active configuration (Debug/Release)
   - Compiler flags and defines
   - Project-specific search paths
   |
   v
4. Build compiler command
   - Merge config file + .dproj settings
   - Add search paths, namespaces, aliases
   |
   v
5. Execute dcc32.exe/dcc64.exe/dcclinux64.exe
   |
   v
6. Parse output
   - Extract errors (E####, F####)
   - Filter warnings (W####) and hints (H####)
   |
   v
7. 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