Skip to main content
Glama

bpmn-js-mcp — publicação na web

Servidor MCP que permite a assistentes de IA (Claude Code, Claude Desktop, VS Code/Copilot e outros clientes MCP) criar e editar diagramas BPMN 2.0 válidos, com layout automático, validação bpmnlint e exportação em XML, SVG e PNG. Usa o bpmn-js sem navegador, via jsdom. Fork de datakurre/bpmn-js-mcp; a documentação original das ferramentas está em docs/README-upstream.md.

O projeto original só funciona localmente (stdio: o cliente abre o servidor como processo filho). Este repositório acrescenta o modo HTTP (--http), que permite publicá-lo numa URL e usá-lo de qualquer máquina:

stdio (original)

--http (web)

Quem acessa

o próprio usuário, na máquina dele

qualquer cliente com token

Autenticação

não precisa

Authorization: Bearer <token> obrigatório

Diagramas

um conjunto por processo

isolados por sessão MCP — um usuário nunca vê o do outro

filePath (ler/gravar arquivo)

permitido

desligado (seria leitura/escrita arbitrária no servidor)

Exportação

xml, svg, png, gif, apng, mp4, webp, html

xml, svg, both, png (imagem no próprio resultado)

Persistência em disco

--persist-dir

não há: o diagrama vive enquanto a sessão durar; o agente exporta o XML ao final

Decisão de arquitetura: agents/adrs/ADR-033-http-transport.md.

Há duas formas de publicar:

Container (Docker + nginx)

Vercel (--stateless)

Onde

infra da FGV, qualquer host com Docker

Vercel Functions

Diagramas ficam

na memória da sessão MCP

no Upstash Redis, por 7 dias sem uso

Isolamento

por sessão MCP

por token

Cabeçalhos de segurança

nginx (deploy/nginx/nginx.conf)

vercel.json

Seção

Subir com Docker Compose

Publicar na Vercel

Decisão do modo Vercel: agents/adrs/ADR-034-stateless-http-vercel.md.

Arquitetura de deploy

cliente MCP ──HTTPS──▶ F5 / balanceador ──HTTP──▶ nginx :8080 ──▶ app :3000
                       (TLS da FGV)               cabeçalhos de      /mcp  /health
                                                  segurança, SSE
  • app (Dockerfile): Node 22, usuário não-root, sistema de arquivos somente-leitura. Porta 3000, só na rede interna do compose.

  • nginx (deploy/nginx/): nginx 1.30.5 (fora da lista vetada pela SI; a 1.27.5 é proibida). É a única fonte dos cabeçalhos de segurança exigidos pelo pentest do ESI — o app não os emite, para que cada um saia uma vez só. O F5 não deve injetar os mesmos cabeçalhos (CSP duplicada vira interseção; COOP duplicado é ignorado).

  • Sem banco de dados e sem volume.

Related MCP server: MCP-GLSP

Pré-requisitos

  • Docker 24+ com Docker Compose v2.

  • No build: acesso HTTPS a registry.npmjs.org. As duas dependências que só existem no GitHub (bpmn-auto-layout e bpmn-to-image) vêm pré-compiladas em vendor/, então o build não precisa de git nem do GitHub.

  • Em execução: nenhum acesso externo.

  • TLS terminado na frente (F5/balanceador). O nginx escuta HTTP puro em 8080.

Subir com Docker Compose

cp .env.docker.example .env.docker
# editar .env.docker e preencher MCP_AUTH_TOKENS (openssl rand -hex 32)
docker compose --env-file .env.docker up -d --build
curl -i http://localhost:8080/health

O arquivo chama-se .env.docker (e não .env) para o token nunca ir para o git por engano; ele já está no .gitignore.

Variáveis de ambiente

Variável

Obrigatória

Default

O que faz

MCP_AUTH_TOKENS

sim

—

Tokens aceitos, separados por vírgula, cada um com ≥ 32 caracteres. Vazio ou curto: o app recusa subir (de propósito). Um token por equipe/usuário facilita revogar.

HTTP_PORT

não

8080

Porta do host onde o nginx é publicado (no container é 8080).

MCP_ALLOWED_ORIGINS

não

vazio

Origens de navegador autorizadas a chamar /mcp. Clientes de desktop/CLI não mandam Origin e funcionam com o default.

MCP_MAX_SESSIONS

não

50

Sessões MCP abertas ao mesmo tempo. Acima disso: 503.

MCP_SESSION_IDLE_MINUTES

não

30

Inatividade até a sessão (e seus diagramas) ser descartada.

MCP_MAX_BODY_BYTES

não

4194304

Corpo máximo da requisição (4 MB). Acompanha client_max_body_size do nginx.

MCP_MAX_CONCURRENT_REQUESTS

não

8

Chamadas processadas em paralelo (trabalho de CPU). Acima disso: 503 com Retry-After.

BPMN_MCP_MAX_DIAGRAMS

não

20

Diagramas por sessão; ao estourar, descarta o mais antigo.

BPMN_MCP_TOOLS

não

full

core expõe só as 10 ferramentas mais usadas.

IMAGE_TAG

não

latest

Tag das imagens geradas pelo compose.

Build e docker run manuais

docker build -t bpmn-js-mcp:1.0.0 .
docker build -t bpmn-js-mcp-nginx:1.0.0 -f deploy/nginx/Dockerfile .
docker network create bpmn-mcp
docker run -d --name app --network bpmn-mcp --read-only --tmpfs /tmp \
  -e MCP_AUTH_TOKENS="<token de 64 hex>" bpmn-js-mcp:1.0.0
docker run -d --name nginx --network bpmn-mcp --read-only --tmpfs /tmp \
  -p 8080:8080 bpmn-js-mcp-nginx:1.0.0

O container do nginx procura o app pelo nome app (deploy/nginx/nginx.conf, bloco upstream); com outro nome, ajustar ali. Conferir a versão do nginx na imagem construída: docker run --rm --entrypoint nginx bpmn-js-mcp-nginx:1.0.0 -v.

Publicar na Vercel

Na Vercel cada chamada pode cair numa instância diferente, então o servidor roda sem sessão e guarda os diagramas num Redis (Upstash, pelo Marketplace da Vercel). Antes de cada chamada recarrega o diagrama citado se outra instância o alterou; depois, grava de volta o que mudou — antes de responder.

Arquivos: vercel.json (build, região gru1/São Paulo, rotas e cabeçalhos), api/mcp.js (a função; o código vem de dist/vercel/vercel.js, um bundle autocontido — ver esbuild.config.mjs), public/ (a página de apresentação em / — servida também pelo nginx no modo Docker — e o robots.txt; ter essa pasta como saída impede a Vercel de servir o repositório como site estático) e .vercelignore. Variáveis comentadas em .env.vercel.example.

  1. Login e vínculo do projeto (uma vez, na raiz do repositório):

    npx vercel login
    npx vercel link
  2. Redis: no painel da Vercel, Storage → Create Database → Upstash for Redis, região São Paulo (sa-east-1), e conecte ao projeto. A integração cria KV_REST_API_URL e KV_REST_API_TOKEN sozinha.

  3. Token de acesso (gere com openssl rand -hex 32 e guarde num cofre):

    npx vercel env add MCP_AUTH_TOKENS production
  4. Deploy de produção (as URLs de preview ficam atrás do login da Vercel e clientes MCP não passam por ele):

    npx vercel deploy --prod
  5. Conferir: curl -i https://<projeto>.vercel.app/health deve dar 200 com os cabeçalhos de segurança; /mcp sem token, 401. Se /health der 500, falta token ou Redis — o log da função diz qual.

Limites e diferenças em relação ao modo container:

  • Diagramas isolados por token: quem usa o mesmo token vê os mesmos diagramas.

  • Corpo até 4,5 MB e cada chamada até 120 s (maxDuration no vercel.json).

  • Duas instâncias alterando o mesmo diagrama ao mesmo tempo: vale a última gravação.

  • O desfazer/refazer recomeça quando o diagrama é recarregado por outra instância.

  • Sem notificações de progresso (respostas JSON simples).

Para reproduzir o modo Vercel localmente, com Redis e o emulador da API REST do Upstash: docker compose --env-file .env.docker --profile vercel-dev up -d --build e use http://127.0.0.1:8081/mcp.

Conectar um cliente

A página na raiz do serviço (https://<host-publicado>/) é o guia para quem vai usar: instalação local em 1 prompt (o Claude clona este repositório e registra o servidor via stdio, sem token), cadastro manual no Claude Code/Desktop, os 7 usos com prompts prontos, as ferramentas e “Deu erro?”. O uso pela nuvem, com token, fica num bloco à parte. Fontes Inter e Instrument Serif em public/assets/fonts (licença OFL).

Claude Code:

claude mcp add --transport http bpmn https://<host-publicado>/mcp --header "Authorization: Bearer <token>"

VS Code (.vscode/mcp.json):

{
  "servers": {
    "bpmn": {
      "type": "http",
      "url": "https://<host-publicado>/mcp",
      "headers": { "Authorization": "Bearer ${input:bpmn-token}" }
    }
  },
  "inputs": [
    {
      "id": "bpmn-token",
      "type": "promptString",
      "password": true,
      "description": "Token do bpmn-js-mcp"
    }
  ]
}

Clientes que só aceitam conector remoto com OAuth (por exemplo, conectores adicionados pela interface web do claude.ai) não funcionam com token fixo; para eles seria preciso uma camada OAuth (ex.: SSO da FGV) na frente.

Desenvolvimento sem Docker

Node.js 22+.

npm ci                 # também compila (script prepare)
npm test               # vitest (~1600 testes)
npm run lint && npm run typecheck && npm run format:check
node dist/index.js     # modo stdio, como no projeto original
MCP_AUTH_TOKENS=$(openssl rand -hex 32) node dist/index.js --http   # modo HTTP em :3000

Os testes do modo HTTP estão em test/http-server.test.ts (sessões) e test/stateless-http.test.ts (modo Vercel, com duas instâncias alternadas).

Ambientes

Ambiente

URL

Observação

Produção

a definir com a infra

atrás do F5, com TLS

Teste na Vercel

https://<projeto>.vercel.app/mcp

modo --stateless, token próprio

Réplica / homologação

a definir

mesmo compose, token próprio

Desenvolvimento

http://localhost:8080/mcp

docker compose --env-file .env.docker up

Use tokens diferentes em cada ambiente.

Segurança (checklist do pentest ESI/FGV)

Conferido em container real (curl -I em /health, numa rota inexistente, em /mcp sem token, em 413 e em 502):

  • Strict-Transport-Security, X-Content-Type-Options, Referrer-Policy, X-Frame-Options, Cross-Origin-Opener-Policy, Content-Security-Policy e Cache-Control: no-store em todas as respostas, uma vez cada, inclusive nos erros gerados pelo próprio nginx.

  • Não há página HTML, então a CSP é a base mínima, sem exceções.

  • Autenticação por token com comparação em tempo constante; sessão presa ao token que a abriu; Origin de navegador validada.

  • filePath desligado: sem leitura nem escrita de arquivos do servidor.

  • Limites de corpo, de sessões, de chamadas simultâneas e de diagramas.

  • Dependências de produção sem vulnerabilidades conhecidas (npm audit --omit=dev).

  • Não se aplicam (não há usuários com senha): política de senha e limite de tentativas de login. Os tokens têm ≥ 256 bits de entropia, o que torna tentativa por força bruta inviável; por isso não há bloqueio por IP, que atrás do F5 viraria um bloqueio global.

Documentação

Estrutura de pastas

src/
  index.ts             entrada: escolhe stdio, --http ou --http --stateless
  vercel.ts            função da Vercel (vira dist/vercel/vercel.js)
  server.ts            monta o servidor MCP (uma instância por sessão no HTTP)
  http-server.ts       transporte HTTP com sessões (Docker): limites, /health
  stateless-http.ts    transporte HTTP sem sessão (Vercel): sincroniza com o Redis
  diagram-store.ts     armazenamento dos diagramas (Upstash Redis ou memória)
  http-common.ts       token, leitura do corpo, respostas de erro
  session-scope.ts     isolamento do estado por sessão (AsyncLocalStorage)
  filesystem-policy.ts desliga filePath no modo HTTP
  handlers/            uma pasta por domínio de ferramenta
test/                  vitest (inclui http-server.test.ts)
deploy/nginx/          imagem e configuração do nginx de borda
api/mcp.js             função da Vercel
vercel.json            configuração da Vercel (rotas, cabeçalhos, região)
public/                guia em / (HTML, CSS, JS e fontes locais; nada inline, por causa da CSP)
Dockerfile             imagem do app
docker-compose.yml     app + nginx; perfil vercel-dev = modo Vercel local
.env.docker.example    variáveis do compose, comentadas
.env.vercel.example    variáveis da Vercel, comentadas
docs/, agents/adrs/    documentação e ADRs

Licença

MIT (ver LICENSE).

Available Tools

20 tools
add_bpmn_elementsA

Add one or more elements (tasks, gateways, events, etc.) to a BPMN diagram; a single element is an array of one. With connect "chain" (default) each element is connected to the previous one by a sequence flow (afterElementId attaches the first one after an existing element) and the diagram is laid out; with connect "none" they are only added, each placed right of the previous one. Chains containing a gateway are not auto-connected past it — wire branches with connect_bpmn_elements. An entry that sets its own anchor or position (hostElementId, flowId, fromElementId + toLaneId, copyFrom, afterElementId, x/y) is placed there instead of being chained, and then auto-layout is off unless autoLayout is true. Supports boundary events via hostElementId, inserting into a flow via flowId, and cross-lane handoff via fromElementId + toLaneId. Subprocesses are expanded by default (isExpanded=false for collapsed). Generates descriptive element IDs when a name is provided (e.g. UserTask_EnterName). See bpmn://guides/modeling-elements for naming conventions, integration patterns, and event subprocess guidance.

Inputs: elements (required), diagramId (required), laneId, connect, +3 more.

align_bpmn_elementsA
Idempotent

Align or distribute selected elements. Supports two operations: (1) align — align elements along an axis (left, center, right, top, middle, bottom), requires at least 2 elements. Use compact=true to also redistribute with ~50px gaps. (2) distribute — evenly distribute elements horizontally or vertically using edge-to-edge spacing, requires at least 3 elements. Use gap for exact pixel spacing (recommended: 50). ⚠️ Warning: alignment: middle on a process with parallel branches collapses all branches onto a single Y row, causing horizontal overlaps. Use layout_bpmn_diagram instead to re-arrange the full diagram while preserving branch separation. If you must use alignment: middle, pass compact: true to detect and spread overlapping elements on the X axis afterwards.

Inputs: diagramId (required), elementIds (required), gap, compact, +2 more.

analyze_bpmn_lanesA
Read-only

Analyze lane organization in a BPMN diagram. Three modes: 'suggest' — analyze tasks and suggest optimal lane assignments based on roles (camunda:assignee/candidateGroups) or element types (human vs automated). Returns structured suggestions with lane names, coherence score, and reasoning. 'validate' — check if current lane assignment makes semantic sense by analyzing cross-lane flow frequency, zigzag patterns, single-element lanes, and overall coherence. Returns structured issues with fix suggestions. 'pool-vs-lanes' — evaluate whether a collaboration should use separate pools (different organizations/systems) or lanes (role separation within one organization). Returns recommendation with confidence and reasoning. Read-only; to assign or redistribute elements use create_bpmn_lanes.

Inputs: mode (required), diagramId (required), participantId.

batch_bpmn_operationsA

Execute multiple BPMN operations in a single call, reducing round-trips. Operations run sequentially. By default, execution stops on first error (set stopOnError: false to continue). When stopOnError is true (default), all changes are rolled back on failure using the bpmn-js command stack. Nested batch calls are not allowed.

Inputs: operations (required), stopOnError.

bpmn_historyA

Undo or redo changes on a BPMN diagram. Uses the bpmn-js command stack to reverse or re-apply operations. Supports multiple steps. Note: layout operations (layout_bpmn_diagram) bypass the command stack for boundary event repositioning and the normaliseOrigin fallback — these specific changes cannot be undone.

Inputs: action (required), diagramId (required), steps.

connect_bpmn_elementsA

Connect BPMN elements. Supports pair mode (sourceElementId + targetElementId), chain mode (elementIds array for sequential connections), or batch mode (connections array for arbitrary source/target pairs, e.g. a gateway's branches with per-branch conditions). Auto-detects connection type: SequenceFlow for normal flow, MessageFlow for cross-pool, Association for text annotations, and DataAssociation for data objects/stores. Supports optional condition expressions for gateway branches and isDefault flag for gateway default flows. To modify an existing connection's label or condition after creation, use set_bpmn_element_properties with the connection's ID. Also supports waypoint mode: provide connectionId + waypoints to set custom routing on an existing connection.

Inputs: diagramId (required), label, isDefault, waypoints, +8 more.

create_bpmn_diagramA

Create a new BPMN diagram: blank, cloned from an existing diagram (cloneFrom), or imported from existing BPMN XML (xml or filePath). Returns a diagram ID that can be used with other tools. For an xml/filePath import, if the XML lacks diagram coordinates (DI), auto-layout is applied; use autoLayout to force or skip it. Warning: Forcing autoLayout: true on diagrams that already have DI coordinates may reposition elements and can affect boundary event placement — for diagrams with boundary events, subprocesses, or complex structures, prefer autoLayout: false (or omit it to use auto-detection). An xml/filePath import creates a fresh modeler with an empty undo/redo history; combine with export_bpmn filePath to implement an open→edit→save workflow. Use draftMode: true to suppress lint feedback during incremental construction.

Inputs: xml, name, filePath, cloneFrom, +5 more.

create_bpmn_lanesA

Create lanes (swimlanes) within a participant pool. Creates a bpmn:LaneSet with the specified lanes, dividing the pool height evenly (or using explicit heights). Lanes represent roles or departments within a single organization/process. Use lanes for role separation within one pool; use separate pools (participants) for separate organizations with message flows. Requires at least 2 lanes when defined manually. Alternatively, use distributeStrategy to auto-generate lanes: "by-type" groups elements into Human Tasks vs Automated Tasks lanes; "manual" uses elementIds in each lane definition to assign elements explicitly. Use assignments ([{ laneId, elementIds }]) to assign existing elements to existing lanes, or strategy (role-based | balance | minimize-crossings, with dryRun/validate) to redistribute elements across existing lanes. These forms are mutually exclusive. Use mergeFrom to convert a multi-pool collaboration into a single pool with lanes (elements are moved, message flows become sequence flows).

Inputs: diagramId (required), lanes, dryRun, layout, +8 more.

create_bpmn_participantA

Create participant(s) (pools) in a BPMN diagram. Single pool: pass name. Wrap existing process: set wrapExisting=true. Multi-pool collaboration: pass participants array (min 2). Camunda 7: only one pool is executable; additional pools must be collapsed. For role separation within one organization, use lanes inside one pool — not multiple expanded pools.

Inputs: diagramId (required), x, y, name, +9 more.

delete_bpmn_diagramB
DestructiveIdempotent

Remove a diagram from the in-memory store.

Inputs: diagramId (required).

delete_bpmn_elementA
DestructiveIdempotent

Remove one or more elements or connections from a BPMN diagram. Supports single deletion via elementId or bulk deletion via elementIds array.

Inputs: diagramId (required), elementId, elementIds.

export_bpmnA
Read-only

Export a BPMN diagram as XML, SVG, PNG, an animated GIF/APNG/MP4/WebP, or a standalone interactive HTML embed, and write it to a file. By default, runs bpmnlint and blocks export if there are error-level lint issues. Set skipLint to true to bypass validation. Optionally scope to a subprocess or participant via elementId (xml/svg/both only). Use format 'both' to get XML and SVG in a single call. PNG/animated/HTML formats always write to filePath (required for those formats) rather than inlining. Animated formats render token-simulation driven by an optional TOML scenario (see the executable-Camunda-7 guide resource); omit scenario to use the diagram's own default. gif/apng/mp4/webp/html require optional dependencies (gifenc or ffmpeg for encoding, smol-toml for scenario parsing) — errors name the missing one. The exported text content is also returned in the response, unless it is large — beyond a size threshold, xml/svg/both return a bpmn://diagram/{id}/xml or /svg resource_link plus a short summary instead of the full text; pass inline: true to force full text regardless of size. Binary/HTML formats return a confirmation only.

Inputs: format (required), filePath (required), diagramId (required), fps, +8 more.

layout_bpmn_diagramA
Idempotent

Automatically arrange elements in a BPMN diagram using bpmn-auto-layout, producing a clean left-to-right layout with orthogonal connections and placed labels. Handles parallel branches, reconverging gateways, loops, boundary events, subprocesses, pools, lanes, message flows, and artifacts. Use this after structural changes (adding gateways, splitting flows) to automatically clean up the layout. The whole layout is a single undo step in bpmn_history. Use dryRun to preview changes before applying them. Use labelsOnly: true to only adjust label positions without moving elements. Partial layout: pass scopeElementId to re-layout only one participant/subprocess, or elementIds to re-layout only a set of sibling elements (e.g. a newly added branch); the rest of the diagram is left unchanged and connections crossing the boundary are re-routed. Elements positioned with move_bpmn_element are pinned and keep their position until the next full layout.

Inputs: diagramId (required), dryRun, verbose, gridSnap, +7 more.

list_bpmn_diagramsA
Read-only

List all diagrams or get a detailed summary of one. When called without diagramId, lists all diagrams in memory with their IDs, names, and element counts. When diagramId is provided, returns a lightweight summary: process name, element counts by type, participant/lane names, named elements, and connectivity stats. When both diagramId and compareWith are provided, returns a structured diff between the two diagrams (additions, removals, and changes).

Inputs: diagramId, compareWith. Returns: success

list_bpmn_elementsA
Read-only

List elements in a BPMN diagram with their types, names, positions, connections, and properties. Supports optional filters to search by name pattern, element type, or property value. When no filters are given, returns all elements — unless the diagram is large, in which case an unfiltered call returns a type-count summary plus a bpmn://diagram/{id}/elements resource_link instead (pass inline: true to force the full list). Pass elementIds to inspect specific elements in full detail (all properties, extension elements, connections, event definitions) instead — ignores the other filters, one or several elements per call.

Inputs: diagramId (required), inline, property, elementIds, +2 more. Returns: count, success

list_bpmn_process_variablesA
Read-only

List all process variables referenced in a BPMN diagram. Extracts variables from form fields, input/output parameter mappings, condition expressions, script result variables, loop characteristics, call activity variable mappings, and Camunda properties (assignee, candidateGroups, etc.). Returns each variable with its read/write access pattern and the elements that reference it — unless the diagram references a lot of variables, in which case it returns just the names plus a bpmn://diagram/{id}/variables resource_link (pass inline: true to force the full list).

Inputs: diagramId (required), inline. Returns: success, variableCount

manage_bpmn_root_elementsA
Idempotent

Create or update shared root-level bpmn:Message and bpmn:Signal definitions. These shared definitions can be referenced from multiple event definitions across the diagram via messageRef/signalRef in set_bpmn_element_properties's eventDefinition sub-object.

Inputs: diagramId (required), signals, messages.

move_bpmn_elementA
Idempotent

Move, resize, or reassign an element to a lane. Any combination of x/y (absolute move), width/height (resize, top-left preserved), and laneId (auto-centered) — at least one required. For several elements at once, pass moves: [{ elementId, x?, y?, width?, height?, laneId? }] instead — validated up front, applied as one undo step.

Inputs: diagramId (required), x, y, moves, +4 more.

set_bpmn_element_propertiesA
Idempotent

Set BPMN or Camunda extension properties on an element. Supports standard properties (name, isExecutable, documentation, default, conditionExpression) and Camunda extensions with camunda: prefix (e.g. camunda:assignee, camunda:class, camunda:type, camunda:topic). Also handles: scriptFormat/script on ScriptTask, camunda:connector, camunda:field, camunda:properties, camunda:retryTimeCycle, isExpanded on SubProcess, and cancelActivity on BoundaryEvent (false = non-interrupting). See bpmn://guides/element-properties for the full property catalog by element type. Supports optional elementType to replace the element type (e.g. bpmn:Task → bpmn:UserTask). Also accepts optional sub-objects for other concerns, settable together with properties in one call: inputOutput, formData, listeners, callActivityVariables, loop, eventDefinition. To update several elements in one call — e.g. setting camunda:assignee on every task in an executable process — pass updates: [{ elementId, properties, ... }] instead of the single-element elementId/properties/etc. fields. Every item is validated before any element is changed, and the whole batch applies as one undo step.

Inputs: diagramId (required), loop, updates, formData, +7 more.

validate_bpmn_diagramA
Read-only

Validate a BPMN diagram using bpmnlint rules. Returns structured issues with rule names, severities, element IDs, documentation URLs, and fix suggestions (concrete MCP tool calls to resolve each issue). Uses bpmnlint:recommended by default with tuning for AI-generated diagrams. Supports custom config overrides.

Inputs: diagramId (required), config, lintMinSeverity. Returns: valid, success

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4/5.0

    Scored across 20 tools

    Disambiguation4/5

    Most tools have clearly distinct resource+action targets (create/add/delete/move/connect elements, manage diagrams/pools/lanes, validate/export). Some potential overlap exists between add_bpmn_elements (which can chain-connect) and connect_bpmn_elements, and between align_bpmn_elements and layout_bpmn_diagram, but the descriptions explicitly clarify boundaries.

    Naming Consistency4/5

    Names follow a consistent verb_bpmn_noun pattern (e.g., create_bpmn_diagram, add_bpmn_elements, set_bpmn_element_properties). Exceptions like bpmn_history (no verb, reversed order) and export_bpmn (no noun) are minor and remain readable.

    Tool Count4/5

    20 tools is on the heavy side, but the domain—full BPMN modeling, layout, validation, export, and analysis—justifies the breadth. Each tool covers a distinct, non-trivial capability, though a few read-only analyzers could theoretically be folded into list or validate tools.

    Completeness4/5

    The surface covers create/read/update/delete for diagrams, elements, connections, pools, lanes, and properties, plus validation, export, history, and batch operations. Minor gaps include no explicit tool to rename/update diagram metadata or delete shared root elements, but agents can work around these.

    Maintenance

    ActivitySlowing
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      D
      maintenance
      Enables AI agents to create, manipulate, and manage BPMN 2.0 diagrams programmatically, with support for Mermaid conversion, auto-layout, and file persistence.
      24
      18
      MIT
    • A
      license
      Not graded
      quality
      F
      maintenance
      Enables AI-driven graphical diagram creation and manipulation using natural language, with support for BPMN workflows, analysis, and manual editing via the Model Context Protocol.
      1
      MIT
    • A
      license
      B
      quality
      C
      maintenance
      Enables AI assistants and other tools to create, edit, import, and export BPMN 2.0 workflow diagrams, including through a local browser-based live modeler with explicit save back to the session.
      11
      MIT