feat: integrate MCP directly into Architect Engine with dynamic plugin-aware tools

[Copilot]

Implements Model Context Protocol (MCP) support directly within the Architect Engine, enabling AI agents to interact with Architect capabilities through dynamically generated, plugin-aware tools.

Implementation

MCP as Engine Component (not standalone server)

• Kotlin/Micronaut implementation integrated into architect-engine/engine/src/main/kotlin/.../mcp/
• MCP protocol definitions: McpProtocol.kt
• Dynamic tool service: McpToolService.kt
• HTTP API controller: McpApiController.kt at /api/mcp
• Stdio launcher: McpStdioLauncher.kt for Claude Desktop integration

Dynamic & Plugin-Aware Tool Generation

• Tools are generated dynamically based on registered projects and their tasks
• Automatically reflects all plugin tasks in real-time
• Each project gets its own set of tools
• Each task becomes an executable tool
• Format: architect_{project}_{task}

Static Tools:

• architect_list_projects - List all registered projects
• architect_register_project - Register new projects

Dynamic Tools (per registered project):

• architect_{project}_list_tasks - List tasks for a specific project
• architect_{project}_{task} - Execute specific tasks with optional arguments

Example: Project "myapp" with tasks "build" and "test" generates:

• architect_myapp_list_tasks
• architect_myapp_build
• architect_myapp_test

Two Integration Modes:

1. HTTP API Mode: Available at /api/mcp when engine runs normally

curl -X POST http://localhost:9292/api/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'

2. Stdio Mode: For Claude Desktop integration

{
  "mcpServers": {
    "architect": {
      "command": "sh",
      "args": [
        "-c",
        "cd /path/to/architect/architect-engine/engine && ./gradlew runMcpStdio"
      ]
    }
  }
}

Benefits

• No Separate Server: MCP functionality is part of the engine
• Always Synchronized: Tools reflect current engine state
• Plugin-Aware: Automatically exposes all plugin tasks
• Dual-Mode Support: HTTP API + stdio communication

Files Added/Modified

• architect-engine/engine/src/main/kotlin/.../mcp/protocol/McpProtocol.kt - MCP protocol data classes
• architect-engine/engine/src/main/kotlin/.../mcp/service/McpToolService.kt - Dynamic tool generation (240 LOC)
• architect-engine/engine/src/main/kotlin/.../mcp/interfaces/McpApiController.kt - HTTP endpoint
• architect-engine/engine/src/main/kotlin/.../mcp/McpStdioLauncher.kt - Stdio mode launcher (140 LOC)
• architect-engine/engine/MCP.md - Comprehensive documentation
• architect-engine/engine/build.gradle.kts - Added runMcpStdio task
• Root README.md - Updated with MCP integration details
• architect-engine/README.md - Added MCP component reference

Custom agent used: archite-coding-agent
coding agent with settings and default for adopted way of working in the architect project

Original prompt

Create an MCP server to integrate architect commands into Agent workflow exposing its capabilities

Custom agent used: archite-coding-agent
coding agent with settings and default for adopted way of working in the architect project

---

💬 We'd love your input! Share your thoughts on Copilot coding agent in our 2 minute survey.

[alemazzo]

@copilot can u write it in kotlin with micronaut? Also the api should be dynamic based on the project on which the mcp is working cause every project have different plugins that enable new tasks

[Copilot]

@copilot can u write it in kotlin with micronaut? Also the api should be dynamic based on the project on which the mcp is working cause every project have different plugins that enable new tasks

Done! I've rewritten the MCP server in Kotlin with Micronaut and integrated it directly into the Architect Engine as a core component (commit 89eb22e).

Key changes:

• MCP is now part of the engine, not a separate server
• Tools are dynamically generated based on registered projects and their tasks
• Fully plugin-aware - automatically exposes tasks from all active plugins
• Two modes: HTTP API at /api/mcp and stdio mode via ./gradlew runMcpStdio

Dynamic tool structure:

• Each registered project gets its own tools
• Each task in a project becomes an executable tool
• Example: project "myapp" with tasks "build", "test" creates:
  • architect_myapp_list_tasks
  • architect_myapp_build
  • architect_myapp_test

See architect-engine/engine/MCP.md for full documentation.