miragon-ai (v0.1.0)

Fetch a leasing customer + last submitted application by customerId (= the process instance's businessKey).

List the well-known seeded customers. Useful for picking a customerId in demos.

Returns the upstream-hosted module manifest this server contributes to a toolkit host.

Manage which CIB Seven / Camunda 7 engine this MCP session talks to. action="list" returns the engines available to this profile, the current sticky selection, and the profile's default engine (if set; a hint for the cockpit's landing engine, not a selection); action="select" (requires engineId) makes that engine the sticky default for all subsequent operations tool calls in this session until selected again; action="current" reports the sticky selection (or null). With more than one engine configured, list then select before calling operations tools — or pass the per-call `engine` parameter to override the sticky selection for a single call.

List deployed process definitions with optional filters. Returns key, name, version, and deployment info.

Get the BPMN 2.0 XML of a process definition by ID. Returns the raw BPMN XML string.

Start a new process instance by process definition key. Optionally set a business key and initial variables.

List running process instances with optional filters. Returns one page as { items, totalCount, hasMore, nextOffset? }. If hasMore is true, call again with firstResult = nextOffset.

Get details of a single process instance by ID.

Get the activity instance tree of a running process instance. Shows which activities are currently active.

Delete (cancel) a running process instance by ID. This action is irreversible.

Modify a running process instance by moving tokens. Supports cancel, startBeforeActivity, startAfterActivity, and startTransition instructions.

Get all variables of a process instance.

Set a single variable on a process instance.

Set the suspension state of a process instance. suspended=true suspends it (jobs, timers, and message correlations are frozen); suspended=false activates (unsuspends) it again.

List user tasks with optional filters. Each task carries ID, name, assignee, process info, and timestamps. Returns one page as { items, totalCount, hasMore, nextOffset? }. If hasMore is true, call again with firstResult = nextOffset.

Get details of a single user task by ID.

Claim a user task for a specific user.

Unclaim (release) a user task, removing the current assignee.

Complete a user task by ID. Optionally set variables when completing.

Set the assignee of a user task.

Get all variables of a user task.

Load the form schema for a user task from its embedded BPMN form definition (`<camunda:formData>`). Returns form fields with current variable values pre-filled. Fields marked readonly are for context only and will not be submitted. Returns an empty fields array when no form is defined on the task.

Fetch and lock external tasks for a given worker. Returns tasks that match the specified topic(s) and locks them for processing.

Complete an external task that was previously fetched and locked. Optionally set variables.

Report a failure for an external task. Sets the error message, remaining retries, and retry timeout.

Correlate a message to trigger a message catch event or start a message start event.

Throw a signal to trigger all matching signal catch events and signal start events.

Get a deployment by ID — returns deployment timestamp + source, used for pre/post deployment correlation (commit-hash → deployment-ID → timestamp).

List deployments with optional filters.

Deploy BPMN process definitions and other resources to the engine. Supports duplicate filtering and deploy-changed-only.

List incidents (errors) in the engine: failed jobs, external task failures, etc. Returns one page as { items, totalCount, hasMore, nextOffset? }. If hasMore is true, call again with firstResult = nextOffset.

Resolve an incident by ID.

List jobs (timers, async continuations) with optional filters. Returns one page as { items, totalCount, hasMore, nextOffset? }. If hasMore is true, call again with firstResult = nextOffset.

Set the number of retries for a failed job. Setting retries > 0 will re-execute the job.

Create a batch job to set retries on multiple jobs at once. Returns the batch id; progress and failures are tracked on the batch, not inline.

Query historic process instances (completed and running) with filters. Returns one page as { items, totalCount, hasMore, nextOffset? }. If hasMore is true, call again with firstResult = nextOffset.

Query historic activity instances, i.e. which BPMN activities were executed in a process instance. Returns one page as { items, totalCount, hasMore, nextOffset? }. If hasMore is true, call again with firstResult = nextOffset.

Query historic task instances (completed and open user tasks). Returns one page as { items, totalCount, hasMore, nextOffset? }. If hasMore is true, call again with firstResult = nextOffset.

Query historic variable instances, i.e. variable values from process history. Returns one page as { items, totalCount, hasMore, nextOffset? }. If hasMore is true, call again with firstResult = nextOffset.

Generate a migration plan from a source process definition to a target process definition. The plan contains activity-id mappings for activities that exist in both versions; pass it verbatim to camunda7_migrate_process_instances_async.

Execute a migration plan asynchronously (as a batch) over multiple process instances. Returns the batch id; per-instance progress and failures are tracked on the batch.

Build a structured, tracker-agnostic ticket draft (title, markdown body, labels) from a Camunda 7 / CIB Seven incident. Does NOT file anything — present the draft in the chat for review and reuse; the user decides where it goes (their issue tracker via whatever integration is available, the optional prefilled GitHub URL, or copy-paste).

Analyze process performance from metrics: throughput, P50/P95 duration, incident-based failure rate, and per-activity breakdown over a rolling window.

Compare process execution metrics between two time periods (before/after deployment, regression analysis). Uses PromQL historical windows — both periods must fall within Prometheus retention.

List currently-open incident patterns from process metrics, grouped by incident type and process definition (point-in-time — what is failing right now). For the actual failed instances (ids, messages), drill in with camunda7_list_incidents / camunda7_query_historic_process_instances.

Rank activities by execution-time contribution and incident rate over a rolling window, from process metrics. Activities with fewer than `minBucketSize` executions are suppressed. Note: queue/wait time is not available from metrics.

Pre/Post deployment correlation from metrics. Given a deployment timestamp and windows before/after, compute instance KPIs + per-element incident rate and the delta, using PromQL historical windows. Results are flagged `suppressed` if either window has fewer than minBucketSize instances. Typical flow: commit-hash → camunda7_get_deployment → deployment.timestamp → this tool.

Compare KPIs and per-element incident rate between two deployed process definition versions of the same processDefinitionKey over a shared rolling window, from metrics. Versions are an exact metric label, so the partition is precise. Returns instance counts, completion/failure ratios, durations (avg, p95), and incident rate per version, plus a delta. Flagged `suppressed` when either version has fewer than minBucketSize instances. Pair with camunda7_list_process_definitions to discover versions.

Compare KPIs across two CIB Seven engines over a shared rolling window, from metrics. The engine is an exact metric label (engine_id) and all engines feed one Prometheus, so the partition is precise — the fleet/cluster comparison (e.g. prod-a vs prod-b) the metric path is built for. Returns instance counts, completion/failure ratios, durations (avg, p95) and incident rate per engine, plus a delta. Optionally scope to one processDefinitionKey. Flagged `suppressed` when either engine has fewer than minBucketSize instances. Discover engine ids with the camunda7_engine tool (action "list").

Live operational health of the CIB Seven engine(s), from Prometheus state gauges: running WIP, open incidents by type, dead jobs (retries exhausted), executable/suspended job backlog, open/unassigned user tasks, external-task backlog, deployed definitions, and which alert rules are firing/pending. A one-call ops snapshot with an overall status (healthy/degraded/critical). Optional engine filter.

Returns all active apps, available pipeline steps, widgets, and their key contracts. Call this first to discover which step-ids and widget-ids exist — and which `props` each widget accepts (see each widget's `propsSchema`) — before building a view.

Builds a UI from pipeline steps and widgets. IMPORTANT: call get-framework-manifest first to learn which step-ids and widget-ids are available — only use ids listed there. Each widget entry's optional `propsSchema` (JSON Schema) describes the per-instance `props` you can set on a layout cell to scope or configure that widget (e.g. one tab per `processDefinitionKey`).

Open the consolidated CIB Seven operations cockpit — a single app that navigates client-side (no extra tool calls) across the process landscape: overview, per-definition running instances, instance detail, plus quick access to human tasks, jobs and deployments. The Support entry point.

Show deployed process definitions as a card grid view.

Show detailed view of a single process instance with activity tree, variables, and incidents.

List the running process instances of a process definition as a filterable table (business key, version, suspended/incident state). Drill-in target from the cockpit definitions table and process-detail; each row opens camunda7_show_instance_detail.

Overview of open incidents across all process definitions: KPIs, filter, per-process group cards with activity summaries. From a card the operator can drill into the per-process detail view.

Per-process incident detail: header, KPIs, BPMN diagram with incident overlays, and activity-grouped incident table with per-incident actions (resolve, jump to Cockpit).

Detail view for a single incident: failure stacktrace, BPMN with the failing activity highlighted, instance variables and activity tree, and a history timeline. Drill-in target from camunda7_show_process_incidents.

Detail view for a single process definition: tinted header, boxed KPI grid, BPMN flow with incident overlays. Drill-in target from cockpit-dashboard rows; can hand off to camunda7_show_process_incidents for the per-incident table.

Show activity timeline for a process instance.

Show the AI-first engine overview: a deterministic health verdict (ok / degraded / critical) with running-instance and incident KPIs and the top incident clusters, grouped cross-process by failing activity + incident type. The home base for triaging what is wrong on a CIB Seven / Camunda 7 engine — each cluster drills in or hands off to AI for root cause + remediation.

Drill into ONE failure cluster: the affected process instances (business keys first), the full sample failure message, and the time profile (new in last hour / 24h) for an activity failing with a given incident type. The middle layer between the engine health overview and a single incident's detail.

Show an interactive BPMN diagram. Pass `processInstanceId` to overlay active activities, incidents, and failed-job counts for a running instance, or pass `processDefinitionKey` (with optional `version`) to view the diagram of a process definition without instance overlays.

Show jobs with a focus on failed jobs (no retries left). Displays error messages and retry status.

Internal JSON feed (no UI) for the cockpit overview — per-definition stats. Prefer camunda7_open_cockpit.

Internal JSON feed (no UI) for the engine health verdict + incident clusters. Prefer camunda7_show_engine_health / camunda7_open_cockpit.

Internal JSON feed (no UI) for one failure cluster's detail. Prefer camunda7_show_cluster_detail.

Internal JSON feed (no UI) for a process definition's detail. Prefer camunda7_show_process_detail.

Internal JSON feed (no UI) for a definition's running instances. Prefer camunda7_show_process_instances.

Internal JSON feed (no UI) for a single process instance. Prefer camunda7_show_instance_detail.

Internal JSON feed (no UI) for jobs. Prefer camunda7_show_job_panel.

Internal JSON feed (no UI) for the incidents dashboard — open incidents grouped by process. Prefer camunda7_show_incidents_dashboard.

Internal JSON feed (no UI) for a single definition's incidents — header, KPIs, BPMN overlays, activity-grouped incidents. Prefer camunda7_show_process_incidents.

Internal JSON feed (no UI) for a single incident — stacktrace, BPMN with the failing activity, variables, activity tree, history. Prefer camunda7_show_incident_detail.

Open the user profile & settings panel for this MiragonAI session: language, theme, which engines are available + the default engine, dashboard preferences, and analytics defaults.

Internal JSON feed (no UI) for the current session's user profile + the configured engine list. Prefer camunda7_show_user_profile.

Update the current session's user profile. Only the provided fields change; omitted fields keep their value. Use this to honor requests like "switch the UI to German" (language: "de") or "only let me pick the prod engines" (allowedEngineIds). Engine availability is curation, not access control.

Show aggregated process metrics and KPIs from Prometheus with per-activity bottleneck breakdown.

Show current incident/failure state from Prometheus, grouped by incident type, activity, and process definition (point-in-time — what is failing right now).

Visualize before/after KPI deltas around a deployment timestamp. Results are flagged `suppressed` when either window has fewer than minBucketSize instances.

Visualize KPI deltas between two deployed versions of the same processDefinitionKey within a shared time window. Results are flagged `suppressed` when either version has fewer than minBucketSize instances.

Visualize KPI deltas between two CIB Seven engines (e.g. prod-a vs prod-b) over a shared time window. Optionally scope to one processDefinitionKey. Results are flagged `suppressed` when either engine has fewer than minBucketSize instances.

Render a process definition's BPMN diagram with a per-element heat overlay from metrics, with a Frequency↔Duration toggle (traversal count vs average duration per element). Node-level only — sequence-flow/edge heat is not available from metrics — and rendered on the latest deployed version's diagram (activity metrics carry no version label). Needs the camunda7 client to fetch the BPMN XML; otherwise the widget shows a fallback.

Internal JSON feed (no UI) for the BPMN heatmap — per-element execution frequency + average duration over a window, plus the latest BPMN XML. Lets another widget (e.g. the CIB Seven cockpit) render the heatmap inline. Prefer analytics_show_bpmn_heatmap for a standalone view.

Re-runs the pipeline with the stored parameters.

App-only tool. Returns the JS source of an upstream-hosted widget bundle so the browser-side loader can evaluate it. Pass the widget id declared in the manifest.

App-only. Returns the live pipeline context plus the reachable / unreachable widgets, available steps and key catalogue for the current keys + steps. Used by the in-iframe LayoutBuilder.

Persists a dashboard (render-view input bundle + name). Pass an existing `id` to update, omit to create. The builder UI's Save button invokes this tool.

Returns the dashboards visible to the caller (scoped by userId when auth is enabled). Metadata only — fetch a full record via `load-dashboard`.

Returns the full dashboard bundle. The returned `{ keys, steps, layout, title }` fields can be handed straight to `render-view`.

Permanently removes a dashboard by id.

Draft a structured ticket from a Camunda 7 / CIB Seven engine incident and present it in the chat for review. Tracker-agnostic: the user decides where to file it (their issue tracker via any available integration, a prefilled GitHub link, or copy-paste) — filing only happens on explicit request.