Skip to main content
Glama
Basti-Fantasti

Delphi Build MCP Server

by Basti-Fantasti
OverviewSchemaRelated ServersScoreDiscussions
Python
Local

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:

Platform

Config File

Win32

delphi_config_win32.toml

Win64

delphi_config_win64.toml

Win64x

delphi_config_win64x.toml

Linux64

delphi_config_linux64.toml

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:

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

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

Acknowledgments

Install Server
A
security – no known vulnerabilities
A
license - permissive license
A
quality - confirmed to work

How are these scores calculated?

Resources

Tools

New MCP Servers

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Basti-Fantasti/delphi-build-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server