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
• 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

MIT License - see LICENSE file for details.

Support

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

Acknowledgments

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