Delphi Build MCP Server

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

Why Use This Server?

Calling the Delphi compiler directly from Claude Code works, but this MCP server provides significant advantages:

Key Benefits:

1. Reduced Token Usage - Filters out warnings, hints, and verbose output, keeping Claude's context focused and reducing API costs
2. No Command Line Limits - Automatically handles projects with 80+ library paths using response files
3. Zero Configuration Per-Call - All paths and settings loaded from a one-time generated config file
4. Precise Error Locations - Structured results enable Claude to navigate directly to the error location

Features

• Automatic Configuration: Generate config from IDE build logs with multi-line parsing
• Smart Compilation: Reads .dproj files for build settings and compiler flags
• 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
• Multi-Platform: Supports Win32 and Win64 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

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 sync

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:

uv run python -m src.config_generator build.log

Or use the Python API:

from src.config_generator import ConfigGenerator
from pathlib import Path

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

3. Configure Claude Code

Edit %APPDATA%\Claude\claude_desktop_config.json:

Using UV (Recommended):

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

Or use direct Python path:

{
  "mcpServers": {
    "delphi-build": {
      "command": "X:\\path\\to\\delphi-build-mcp-server\\.venv\\Scripts\\python.exe",
      "args": ["X:\\path\\to\\delphi-build-mcp-server\\main.py"],
      "env": {
        "DELPHI_CONFIG": "X:\\path\\to\\delphi_config.toml"
      }
    }
  }
}

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)
• 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 an IDE build log.

Parameters:

• build_log_path (required): Path to build log file
• output_config_path: Output file path (default: delphi_config.toml)
• 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

Documentation

• QUICKSTART.md - 5-minute setup guide
• DOCUMENTATION.md - Complete reference
• PRD.md - Product requirements and specifications

Project Structure

delphi-build-mcp-server/
├── main.py                       # MCP server entry point
├── 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
│   └── compiler.py               # Compiler orchestration
├── delphi_config.toml.template   # Configuration template
├── pyproject.toml                # Python project config
├── QUICKSTART.md                 # Quick start guide
├── DOCUMENTATION.md              # Complete documentation
└── PRD.md                        # Product requirements

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
   |
   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"Compilation successful: {result.output_executable}")
else:
    print(f"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"{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']}")

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

Apache-2.0 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