Architectural Development Framework (ADF) MCP Server

A Model Context Protocol server implementing a rigorous, multi-stage development pipeline tailored for Artificial Intelligence feature creation and maintenance.

Core Objective

This ADF server streamlines the engineering of AI capabilities by enforcing organizational rigor, ensuring systematic requirement capture, formal specification generation, phased deployment planning, and meticulous oversight of development milestones.

Capabilities

• Systematic elicitation of feature specifications through guided interrogatories.
• Automatic drafting of Product Requirements Documents (PRDs) and comprehensive implementation blueprints.
• Structuring development into sequential epochs with defined task dependencies and tracking.
• Continuous status assessment and high-level progress reporting.
• Robust mechanism for persistent storage and on-demand retrieval of all generated artifacts.

Available Procedures (Tools)

• initiate_specification_capture - Commence the initial requirement definition dialogue.
• submit_clarification_response - Input findings or answers pertaining to feature constraints.
• produce_technical_spec - Output the formal PRD alongside the corresponding execution roadmap.
• establish_development_epoch - Define a new, distinct phase within the overall project lifecycle.
• append_work_item - Introduce discrete, actionable units of work into a defined epoch.
• recalibrate_epoch_state - Modify the current operational status of a development epoch.
• finalize_work_item - Mark an individual task as completed or update its fulfillment status.
• request_next_directive - Obtain procedural guidance on the optimal subsequent development action.
• query_artifact_location - Retrieve the file system path for any persisted output.
• persist_artifact - Write generated content to a specified storage location.

Template Catalogs (Prompts)

• feature-blueprinting - Primary prompt set utilized for structuring the initial feature definition and planning.

Artifact Persistence Layer

The server employs a dual-mode storage configuration:

1. All formalized outputs (PRDs, plans) are automatically committed to local storage.
2. An active, in-memory cache ensures rapid access to the latest versions.
3. Interfaces allow external agents to query paths or mandate storage to alternative directories.

Standard Repository Structure

Artifacts reside in artifacts/{featureIdentifier}/ by default:

• artifacts/{featureIdentifier}/requirements.md - The finalized Product Requirements Document.
• artifacts/{featureIdentifier}/execution-roadmap.md - The detailed implementation blueprint.

Custom Archival

Leverage persist_artifact to redirect output:

{
  "featureId": "project-456",
  "documentType": "prd",
  "targetPath": "/external/archives/project-456-req.md"
}

Path Resolution

Utilize query_artifact_location to locate saved assets:

{
  "featureId": "project-456",
  "documentType": "prd"
}

This returns the canonical path and confirmation of disk serialization.

Deployment

Dependency installation:

npm install

Building the production executable:

npm run build

For continuous integration development:

npm run watch

Integration

To connect with compatible client environments (e.g., desktop agents):

On MacOS: ~/Library/Application Support/Claude/claude_desktop_config.json On Windows: %APPDATA%/Claude/claude_desktop_config.json

Register the server endpoint:

{
  "mcpServers": {
    "adf-engine": {
      "command": "/path/to/architect-suite/build/mcp-server.js"
    }
  }
}

Diagnostic Mode

Given the stdio communication channel, debugging can be opaque. We strongly advocate for the use of the official MCP Inspector, accessible via an integrated package script:

npm run inspector

This will yield a URL to launch comprehensive debugging diagnostics in a web browser.

Architectural Foundation

This server instance is constructed utilizing the high-level McpServer abstraction provided by the Model Context Protocol TypeScript SDK, which significantly abstracts the complexities of defining resources, tooling interfaces, and prompt configurations.

import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

// Instantiate the ADF server core
const server = new McpServer({
  name: "Architectural Development Framework",
  version: "1.1.0"
});

// Register a foundational data endpoint
server.resource(
  "project-manifests",
  "architecture://manifests/list",
  async (uri) => ({ /* ... */ })
);

// Define a functional interface (tool)
server.tool(
  "initiate_specification_capture",
  { /* schema definition */ },
  async (parameters) => ({ /* execution logic */ })
);

// Register a processing template
server.prompt(
  "feature-blueprinting",
  { /* input schema */ },
  (parameters) => ({ /* template output */ })
);

// Activate the server listener
const transport = new StdioServerTransport();
await server.connect(transport);

Development Lifecycle Flow

The ADF MCP server mandates a structured progression for model feature realization:

1. Specification Inception: Initiate the capture of high-level needs, defining scope, target users, and operational constraints.
2. Artifact Formalization: Generate the authoritative PRD and the granular execution roadmap based on consensus requirements.
3. Epoch Sequencing: Decompose the implementation into discrete, manageable developmental stages, each with clear objectives.
4. Milestone Oversight: Track completion rates of tasks and epochs to maintain alignment with the projected timeline.
5. Final Validation: Confirm all established requirements have been demonstrably met, signifying feature readiness for deployment.