bpmn-js-mcp
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@bpmn-js-mcp create a BPMN diagram for a customer onboarding process"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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) |
| |
Quem acessa | o próprio usuário, na máquina dele | qualquer cliente com token |
Autenticação | não precisa |
|
Diagramas | um conjunto por processo | isolados por sessão MCP — um usuário nunca vê o do outro |
| 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 |
| 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 ( | |
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 ( |
|
Seção |
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, SSEapp (
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-layoutebpmn-to-image) vêm pré-compiladas emvendor/, 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/healthO 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 |
| 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. |
| não |
| Porta do host onde o nginx é publicado (no container é 8080). |
| não | vazio | Origens de navegador autorizadas a chamar |
| não |
| Sessões MCP abertas ao mesmo tempo. Acima disso: |
| não |
| Inatividade até a sessão (e seus diagramas) ser descartada. |
| não |
| Corpo máximo da requisição (4 MB). Acompanha |
| não |
| Chamadas processadas em paralelo (trabalho de CPU). Acima disso: |
| não |
| Diagramas por sessão; ao estourar, descarta o mais antigo. |
| não |
|
|
| não |
| 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.0O 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.
Login e vínculo do projeto (uma vez, na raiz do repositório):
npx vercel login npx vercel linkRedis: 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_URLeKV_REST_API_TOKENsozinha.Token de acesso (gere com
openssl rand -hex 32e guarde num cofre):npx vercel env add MCP_AUTH_TOKENS productionDeploy 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 --prodConferir:
curl -i https://<projeto>.vercel.app/healthdeve dar200com os cabeçalhos de segurança;/mcpsem token,401. Se/healthder500, 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 (
maxDurationnovercel.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 :3000Os 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 |
| modo |
Réplica / homologação | a definir | mesmo compose, token próprio |
Desenvolvimento |
|
|
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-PolicyeCache-Control: no-storeem 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;
Originde navegador validada.filePathdesligado: 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
docs/README-upstream.md — ferramentas, recursos e prompts do MCP (original)
docs/architecture.md — arquitetura interna
docs/modeling-best-practices.md — boas práticas de modelagem BPMN
docs/common-workflows.md — fluxos de uso
AGENTS.md e agents/adrs/ — decisões de arquitetura
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 ADRsLicença
MIT (ver LICENSE).
Available Tools
20 toolsadd_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_elementsAIdempotent
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_lanesARead-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_diagramBDestructiveIdempotent
Remove a diagram from the in-memory store.
Inputs: diagramId (required).
delete_bpmn_elementADestructiveIdempotent
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_bpmnARead-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_diagramAIdempotent
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_diagramsARead-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_elementsARead-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_variablesARead-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_elementsAIdempotent
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_elementAIdempotent
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_propertiesAIdempotent
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_diagramARead-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
Scored across 20 tools
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.
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.
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.
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
Related MCP Connectors
Create workflow, sequence, architecture, and mind map diagrams via AI assistants.
Build, validate, deploy — HTTP APIs, cron jobs, webhooks and MCP tools — from your AI client.
Free BPMN 2.0 validator: send BPMN XML, get errors and warnings. Anonymous, nothing stored.
Create and edit architecture diagrams from your AI agent; get an SVG and a live editable canvas.
Related MCP Servers
- AlicenseBqualityDmaintenanceEnables AI agents to create, manipulate, and manage BPMN 2.0 diagrams programmatically, with support for Mermaid conversion, auto-layout, and file persistence.2418MIT
- AlicenseNot gradedqualityFmaintenanceEnables AI-driven graphical diagram creation and manipulation using natural language, with support for BPMN workflows, analysis, and manual editing via the Model Context Protocol.1MIT
- AlicenseBqualityBmaintenanceEnables AI assistants to create and manage one BPMN 2.0 diagram at a time, including Mermaid conversion, validation, layout, persistence, and XML or SVG export.27760 npmMIT
- AlicenseBqualityCmaintenanceEnables 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.11MIT