enterprise-architect-mcp

# Enterprise Architect MCP Server

[![npm version](https://img.shields.io/npm/v/enterprise-architect-mcp.svg)](https://www.npmjs.com/package/enterprise-architect-mcp)
[![Node.js](https://img.shields.io/node/v/enterprise-architect-mcp.svg)](https://nodejs.org)
[![License: EUPL-1.2](https://img.shields.io/badge/license-EUPL--1.2-blue.svg)](LICENSE)
[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install_server-0098FF?logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect?url=vscode%3Amcp%2Finstall%3F%257B%2522name%2522%253A%2522enterprise-architect%2522%252C%2522command%2522%253A%2522npx%2522%252C%2522args%2522%253A%255B%2522-y%2522%252C%2522enterprise-architect-mcp%2522%255D%257D)
[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install_server-24bfa5?logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect?url=vscode-insiders%3Amcp%2Finstall%3F%257B%2522name%2522%253A%2522enterprise-architect%2522%252C%2522command%2522%253A%2522npx%2522%252C%2522args%2522%253A%255B%2522-y%2522%252C%2522enterprise-architect-mcp%2522%255D%257D)

A read-only [Model Context Protocol](https://modelcontextprotocol.io) (MCP) server for Sparx Enterprise Architect `.qea` exports. Gives AI agents access to EA analysis models — search elements, navigate packages, read use case scenarios, and traverse connectors — without a running EA instance.

Works with any MCP client (VS Code / GitHub Copilot, Claude Desktop, Cursor, Windsurf). Reads the `.qea` SQLite export directly, never writes to it, and every response carries completeness metadata so an agent can tell a truncated answer from a complete one.

**Keywords:** MCP server · Sparx Enterprise Architect · `.qea` · UML · use case scenarios · package tree · connectors · diagrams · model search · AI agent tooling

## Prerequisites

- **Node.js 22+** (uses the built-in `node:sqlite` module)
- A `.qea` file exported from Sparx Enterprise Architect

## Installation

### VS Code / GitHub Copilot

The quickest route is the **Install in VS Code** badge at the top of this page. There is nothing to
fill in: the server asks for your `.qea` path the first time an agent queries the model, and
remembers the answer for next time.

To register it from a terminal instead, which is handier for scripting or a shared setup, use one
CLI call:

```powershell
code --add-mcp '{\"name\":\"enterprise-architect\",\"command\":\"npx\",\"args\":[\"-y\",\"enterprise-architect-mcp\"]}'
```

The `\"` sequences are for the `code` shim, which re-parses the argument after PowerShell has
already handed it over — escaping with PowerShell's own backtick, or using `--%`, still arrives with
the quotes stripped. The single quotes stop PowerShell from touching the string. On bash or zsh the
plain form works instead:

```bash
code --add-mcp '{"name":"enterprise-architect","command":"npx","args":["-y","enterprise-architect-mcp"]}'
```

To configure it by hand instead, add to your project's `.vscode/mcp.json`:

```json
{
  "servers": {
    "enterprise-architect": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "enterprise-architect-mcp"]
    }
  }
}
```

Nothing personal is in that file, so it can be committed as-is and each developer answers the prompt
once on their own machine. If you would rather not be asked at all, name the path up front — as a
trailing argument, in an `env` block, or in a gitignored `.env` in your workspace root:

```ini
EA_QEA_PATH=C:\EA\exports\model.qea
```

### Claude Desktop

The same path-less configuration goes in `claude_desktop_config.json` (`%APPDATA%\Claude\` on
Windows, `~/Library/Application Support/Claude/` on macOS):

```json
{
  "mcpServers": {
    "enterprise-architect": {
      "command": "npx",
      "args": ["-y", "enterprise-architect-mcp"]
    }
  }
}
```

Claude Desktop does not run the server from a workspace folder, so a `.env` there is not reliable.
If the client cannot show the path prompt at all, the server says so instead of failing silently, and
you can name the path in an `env` block:

```json
"env": { "EA_QEA_PATH": "C:\\EA\\exports\\model.qea" }
```

To run straight from source instead of npm, use `"args": ["-y", "github:mm6502/enterprise-architect-mcp"]`.

## Configuration

The server does not need a path to start. It looks for one when an agent first queries the model, and
takes the first source that actually opens:

1. **CLI argument** — `mcp-server-ea C:\path\to\model.qea`
2. **Environment variable** — `EA_QEA_PATH` (set in an `env` block or system env)
3. **`.env` file** — `EA_QEA_PATH=...` in a `.env` file in the working directory
4. **A remembered answer** — whatever you last told the prompt
5. **The prompt** — the client asks, and a working answer is remembered for next time

A source naming a path that cannot be opened is **skipped** rather than fatal, so the next source gets
its turn. The reason goes to the server log, and once some later source opens, `ea_get_model_info`
lists it under `skipped`. That is deliberate — a sample value left in an `env` block would otherwise
outrank every answer you could give, and answering the prompt would never help. The cost is that a
genuine typo is demoted quietly, so check `ea_get_model_info` if the server opens a different model
than you expected.

Skipping is only worth it when an answer can take the skipped source's place, so two cases stay
fatal: a path you passed **on the command line** (that is this run's explicit instruction, not a
stale default), and any broken source in a client that **cannot show a prompt** — falling through
there would quietly open some other model instead of telling you.

Answers are remembered per machine, in `%APPDATA%\enterprise-architect-mcp\` on Windows,
`~/Library/Application Support/enterprise-architect-mcp/` on macOS, and `$XDG_CONFIG_HOME` (or
`~/.config`) elsewhere; set `EA_MCP_CONFIG_DIR` to keep that file somewhere else. A path that does
not open is never remembered, so asking again is enough to correct a mistyped answer.

If the path points to a **directory**, the server automatically picks the newest `.qea` file by
modification time. Pointing at your export folder means new exports are picked up without
reconfiguring anything.

### Name ordering

Matching is locale-independent — search folds case and diacritics across European Latin alphabets,
so `Straße`, `Łódź` and `Győr` are found however they are typed or entity-encoded.

The enumeration tools — `ea_search`, `ea_list_elements`, `ea_list_diagrams` — do not order by name
at all. They order by the model's internal identity: stable and repeatable, but artificial, so
nothing should be read into which row follows which. That is a deliberate trade. Alphabetical
ordering under SQLite's binary collation sorts every accented initial after `Z`, and since these
tools return a window rather than the whole set, it does not merely reorder the list — it pushes
accented names out of the window entirely. Measured on a real export, names with an accented
initial filled 1.3% of visible slots under binary ordering against 3.0% under identity order, in a
model where they make up 3.9% of all names.

Only `ea_get_scenarios` still orders names by locale, where the whole set is always returned and no
name can be cut off. `EA_LOCALE` pins that ordering to a BCP 47 tag (`sk`, `pl`, `hu`, `de`, …) in
an `env` block or system env; unset, the host default applies. It does not affect matching.

### Paging and narrowing

The enumeration tools return a window, not a sample. Each response carries `totalMatched`,
`returned`, `offset` and `truncated`, and when rows remain, a `continuation` naming the next call —
following it repeatedly visits every match once and terminates. Raising `limit` is not the way to
read a large set; advancing `offset` is.

When far more rows match than one window could hold, the response also carries a `breakdown` of how
they distribute. Its keys are parameter names and its values are argument values, so a breakdown is
a prompt to narrow — by `objectType`, `stereotype`, `diagramType`, or, for `ea_search` when the
result isn't already scoped, by `packageScope` (reported as the matching package's id, which the
next call can pass straight back) — rather than to page through thousands of rows.

### Naming the path up front

If you would rather never see the prompt — a CI job, a shared image, or simply a preference — put
the path in a gitignored `.env` in the working directory. Copy the template:

```powershell
Copy-Item .env.example .env
```

Then set your local path in `.env`:

```ini
EA_QEA_PATH=C:\EA\exports\model.qea
```

A directory works too — the newest `.qea` file in it is used:

```ini
EA_QEA_PATH=C:\EA\exports\
```

The `.env` file is gitignored — each developer sets their own path without affecting the shared
config. It is also never committed, which is why it is the one route every new user has to set up by
hand; answering the prompt once is what makes that unnecessary.

## Available Tools

| Tool | Description |
|------|-------------|
| `ea_search` | Full-text search across elements, attributes, operations, and constraints. Case- and diacritic-insensitive across European Latin alphabets, decodes entity-encoded text. Each result carries the evidence for its match — the field, the attribute or operation it came from, and a snippet of the author's own text. Accepts a `packageScope` (package id or name) to restrict results to a package and its descendants, and reports a package breakdown axis when unscoped. |
| `ea_get_element` | Full element detail — attributes, operations, diagrams it appears on, constraints (pre/post/invariant/process). Flags whether attribute multiplicity is contrastive. |
| `ea_list_elements` | List elements in a package, optionally filtered by type. Windowed: reports the total and pages with `offset`. |
| `ea_get_connectors` | Relationships for an element — includes feature-link resolution (which attribute/operation