# architecture-pattern-mcp [Health: Active]

**Category:** 💻 Developer Tools  
**Repository:** https://github.com/olk/architecture-pattern-mcp  
**GitHub Stars:** 1  
**npm Downloads (last month):** 195  
**Views:** 1  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/architecture-pattern-mcp

## Description
MCP server that provides architecture design expertise to AI coding agents

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "architecture-pattern-mcp": {
    "command": "npx",
    "args": ["-y","fallback"],
    "env": {
      "GENERATOR_API_KEY": "",
      "GENERATOR_PROVIDER": ""
    }
  }
}
```

**Requires environment variables:** `GENERATOR_API_KEY`, `GENERATOR_PROVIDER` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What architecture-pattern-mcp does

The architecture-pattern-mcp MCP server turns a requirements description and domain into an architecture proposal. It considers 40 built-in patterns, then can generate a design containing components, relationships, API contracts, data models, and event contracts. The server also evaluates designs against maintainability, scalability, reliability, security, and performance.

It is intended for AI coding agents that need help deciding how a system should be structured. Example domains include data processing, microservices, and e-commerce. A request can describe a concrete workload, such as an event pipeline with Kafka, Redis, InfluxDB, and S3, and the resulting design can include quality scores and recommendations.

## How it works

The architecture-pattern-mcp MCP server accepts free-text `requirements` and a `domain` for its design-oriented tools. `analyze_architecture` examines the problem and identifies matching patterns. `generate_architecture` creates a design from the requirements and optionally supplied `selected_patterns`. `evaluate_architecture` accepts an architecture design and criteria such as scalability or reliability.

For a complete workflow, `design_architecture` combines the design process and evaluation. Long-running work can use `submit_architecture_design_job`, which returns a job ID, followed by repeated calls to `get_architecture_design_status`. Status values include pending, running, completed, failed, and cancelled; a completed job contains the design result.

The server supports streamable HTTP at `/mcp` and can also run as a stdio subprocess. The repository includes guidance for Claude Code, OpenCode, and Codex CLI. Its OMP skill adds workflow and timeout guidance, but the tool schemas are client-agnostic.

## Tools and capabilities

The architecture-pattern-mcp MCP server provides tools to:

- Analyze requirements and identify relevant architecture patterns.
- Generate a concrete architecture from requirements and selected patterns.
- Evaluate an existing design against chosen quality criteria.
- Run a complete design workflow with `design_architecture`.
- Submit asynchronous design jobs and poll their status.
- List all patterns or filter them by category.
- Retrieve the full definition of a named pattern with `get_architecture_pattern`.

The pattern catalog can be queried with filters such as `messaging`. Design results expose structured data rather than only prose, making them suitable for an agent workflow that needs to inspect components, scores, and recommendations.

## Setup and configuration

The documented quickstart clones the repository, sets `GENERATOR_API_KEY`, and starts the Docker Compose configuration. The development Compose setup serves MCP at `http://localhost:8060/mcp`; the systemd setup uses port 8050. Local installation uses Python 3.12 or newer and can run the module directly or install the package with `uv`.

For stdio clients, run `architecture-pattern-mcp --transport stdio` and pass the generator credentials through the client configuration. HTTP clients connect to the running `/mcp` endpoint. OpenCode reads the API key from the server configuration file at `~/.config/architecture-pattern-mcp/config.json`, rather than from OpenCode's environment.

## Limitations and notes

The design workflow can exceed short MCP request deadlines. The repository reports measured durations of about 66 seconds for analysis alone and 197 seconds for evaluation in one OMP-related workflow. Clients with short timeouts should use the asynchronous job tools, while the one-shot workflow may require a higher server timeout.

The generator requires an API key, and the provider is configured through `GENERATOR_PROVIDER` in the documented client examples. Pattern selection and evaluation quality depend on the requirements, domain, supplied architecture, and criteria passed to the tools. The repository's OMP skill is specifically written for Oh My Pi and should not be treated as a requirement for other MCP clients.

_Full upstream README: https://allmcps.com/mcp/architecture-pattern-mcp/readme_