Return counts of widgets, datasources, and queries in the current Appsmith app.

List workspaces (id and name only).

List all applications across all workspaces with their editor URLs. Fetches via Appsmith's HTTP API, so it works from any page (dashboard or editor).

Create a new Appsmith application. Uses the first workspace if workspace_id is omitted. On success Appsmith navigates to the new app's editor, so the Redux binding is reset.

Update the current application's surface metadata and settings. name/icon/color rename or restyle. navigation patches applicationDetail.navigationSetting (e.g. {"showNavbar": true, "orientation": "side", "navStyle": "sidebar", "colorStyle": "light", "showSignIn": true}). theme_settings patches the app-wide sizing/density overrides (e.g. {"sizing": 1.0, "density": 1.0, "appMaxWidth": "LARGE"}). positioning patches the layout system (e.g. {"type": "FIXED"}). app_id defaults to the currently open application.

Delete an application by id. The user is then redirected away from the editor.

Return log/error metadata only — severity, category, timestamp, source name/type. Message text and payloads are intentionally excluded to avoid leaking confidential data.

Add multiple widgets in one tool call. Each entry is the same shape as add_widget's args: {widget_type, parent_id?, left?, top?, columns?, rows?, props?, name?, new_id?}. columns and rows default to each widget type's own getDefaults() values. Returns a list of {widgetId, widgetName, type, parent} per widget, in the same order.

Apply property updates to one or more widgets. Each entry is {"widget_id": <id>, "props": {<prop>: <value>, ...}}.

Dict values are deep-merged with existing state — so to change just one sub-key you
can pass `{"srcDoc": {"css": "..."}}` without resending html/js. Non-dict values are
replaced.

Bindings and triggers are wired automatically:
  - properties whose name starts with `on` (e.g. `onClick`) are registered as triggers.
  - string values containing `{{...}}` are registered as dynamic bindings.
  - any other value is a literal and is removed from the dynamic path lists.

Composite widgets (Statbox) and Modal show/hide are delegated automatically.
Returns a list of per-widget results.

Delete multiple widgets in one tool call. Cascades children, disallowUndo is set.

Move and/or resize multiple widgets in one tool call. Each entry is {"widget_id": <id>, "left": <int>, "top": <int>, "columns": <int>, "rows": <int>} — left/top set the top-left, columns/rows set the size; any omitted field is preserved per widget. When rows is given, auto-height widgets are switched to FIXED so the resize sticks (reported as heightModeOverridden).

Rename multiple widgets in one tool call. Each entry is {"widget_id": <id>, "new_name": <str>}. New names must be valid Appsmith identifiers (alphanumeric, can't start with a digit, no spaces) — Appsmith may reject conflicts.

List all pages in the current application with id, name, default/hidden flags, and which is currently active.

Reparent multiple widgets in one tool call. Each entry is {"widget_id": <id>, "new_parent_id": <id>}. The new parent must accept children (a CANVAS_WIDGET). Position is preserved verbatim — call set_widget_bounds afterwards if the new parent's snap dimensions differ.

Delete every widget directly under MainContainer. Cascades to nested children.

Return the full Redux record for a widget — every property currently set, including position, type-specific config, and dynamic binding paths.

Diagnose layout issues across every widget on the current page. For each widget returns its grid box, actual rendered pixel dimensions, and whether content overflows its container. For widgets with same-origin iframes (Custom, Iframe) also reports the inner body's scrollHeight so you can size to fit. Use to spot squashed or oversized widgets, then call resize_widget.

Create multiple blank pages in the current application in one tool call.

Delete multiple pages in one tool call.

Switch the editor to a different page in the current application.

List Appsmith plugins available to the current workspace (id, name, packageName, type). Use to find a pluginId for create_datasource — common ones: "REST API" (type: API), "PostgreSQL", "MongoDB", "MySQL" (type: DB).

List datasources in the current workspace (id, name, pluginId, workspaceId). Use the id with create_query.

List queries (a.k.a. actions) for the currently open application.

Create multiple datasources in one tool call via Appsmith's REST API. Each entry is {"name", "plugin_id", "url"?, "datasource_config"?, "workspace_id"?}. If datasource_config is omitted, a per-plugin template is filled in (REST/GraphQL, Postgres/MySQL/Mongo) per entry's pluginPackageName. For REST you can pass just url. DB templates have empty host/port/credentials — populate them via datasource_config for a working connection. workspace_id defaults to the currently selected workspace. The Redux list is refetched once at the end.

Create multiple queries bound to datasources in one tool call via Appsmith's REST API. Each entry is {"name", "datasource_id", "action_config"?, "page_id"?}. If action_config is omitted, a per-plugin default is used: REST → GET / with empty headers/params; SQL DBs → SELECT 1;; Mongo → FIND with {} and limit 10. page_id defaults to the currently open page. The Redux action list is refetched once at the end.

Update multiple queries in one tool call. Each entry is {"query_id", "action_config"?, "name"?, "run_behaviour"?}. action_config is shallow-merged into the existing actionConfiguration per entry, so you can change just httpMethod or body without re-sending the rest. The Redux action list is refetched once at the end.

Run multiple queries by id and return their responses. Equivalent to clicking the Run button on each. Each result includes {ok, statusCode, isExecutionSuccess, body}.

Delete multiple queries in one tool call.

Update multiple datasources in one tool call. Each entry is {"datasource_id", "name"?, "datasource_config"?}. datasource_config is shallow-merged into the current datasourceConfiguration across every environment storage per entry, so you can change just url or authentication.password without re-sending the whole config. The Redux datasource list is refetched once at the end.

Delete multiple datasources in one tool call.

Return the state of the currently open Appsmith application.

Always returns `url`, `application`, `pages`, and `widgets` (the canvas as a
nested tree of id/name/type/parent/position/children starting at MainContainer).
With `verbose=False` (default) that lightweight shape is all you get.

Pass `verbose=True` to also carry every property set on each widget node, plus
top-level `datasources` (with connection storage), `queries` (with their
actionConfiguration), `jsObjects` (with their bodies), and a derived
`connections` list mapping widget property/trigger paths to the queries/JS
objects/datasources they bind to by name. This can be large for non-trivial
apps.

List the themes available to the current application — built-in plus any saved custom themes. Each entry has id, name, displayName, and isSystemTheme.

Return the currently selected theme for the open application, including its properties.{colors, fontFamily, borderRadius, boxShadow} — the values widgets bind to via {{appsmith.theme.*}}.

Switch the application to a different theme by id. Use list_themes to find ids.

Save the current theme (with any local edits) as a named custom theme. The new theme appears in list_themes for future set_theme calls.

Delete multiple saved custom themes in one tool call. Each entry is {"theme_id", "name"?}. name is looked up from the themes list per entry if omitted.

Patch the current theme's properties. Pass a dict keyed by section (colors, fontFamily, borderRadius, boxShadow) whose values are dicts of keys to override. Example: {"colors": {"primaryColor": "#1a73e8"}, "fontFamily": {"appFont": "Inter"}}.

List every widget type for which a property schema is available.

Return the full property schema for a widget — defaults, meta properties, and every configurable property with its label, controlType, validation, options, and section. Use property_name to drill into a single property. Use the property names with update_widget.

Add, remove, or reorder columns on a TABLE_WIDGET_V2. Each add entry is {"id": "<column_id>", "label"?: str, "columnType"?: "text"|"number"|"date"|"image"|..., "isDerived"?: bool} — defaults match Appsmith's "+" button. remove is a list of column ids. reorder is the desired full list of column ids in order; ids not in the list keep their relative order at the end.

Add, remove, or reorder tabs on a TABS_WIDGET. Each add entry is {"label"?: str} — Appsmith generates the tab id and creates the child Canvas; if label is given it overrides the auto-generated "Tab N". remove is a list of tab ids. reorder is the desired full list of tab ids in order.

List JS objects (collections) in the current application — id, name, pageId, and the function ids/names declared in each.

Return the full source of JS objects — each object's body, every function's body, and declared variables, plus id/name/pageId. Pass a list of ids to filter; omit it (or pass an empty list) to return them all.

Make targeted string replacements in JS object bodies without rewriting them.

Each edit is `{"target_id", "old", "new", "replace_all"?}` where `target_id`
is a JS object id. `old` is matched literally; if it occurs more than once the
edit fails unless `replace_all` is true (then every occurrence is replaced).

Per-edit result reports `replacements` (count) or an `error` (target not
found / `old` not found / ambiguous match).

Make targeted string replacements in a Custom Widget's code without rewriting it.

Each edit is `{"widget_id", "field", "old", "new", "replace_all"?}` where
`field` is one of `html`, `css`, or `js`. `old` is matched literally; if it
occurs more than once the edit fails unless `replace_all` is true (then every
occurrence is replaced).

Per-edit result reports `replacements` (count) or an `error` (widget not
found / wrong type / bad field / `old` not found / ambiguous match). The change is
written to both `srcDoc` and `uncompiledSrcDoc` so a reload can't revert it;
successful edits report `synced: true`.

Create a single Custom Widget — the primary entrypoint of this MCP.

The widget is auto-sized to fill the main canvas: full width (all columns) and a
height measured from the canvas's available pixel height. Size and position are not
configurable. `html`/`css`/`js` seed its source; any omitted field falls back to
Appsmith's starter template. `default_model` seeds the data the widget reads via
`appsmith.model` (dict or JSON string). Seeded source is written to both `srcDoc` and
`uncompiledSrcDoc` so a reload can't revert it (`synced: true`).
Returns `{widgetId, widgetName, type, parent, columns, rows, measuredHeightPx, synced}`.

Return a Custom Widget's full source (srcDoc html/css/js), defaultModel, events, name, and grid position. Errors if the id is not a CUSTOM_WIDGET.

Update a Custom Widget's model, name, events, triggers, height mode, and/or position.

`default_model` replaces the model the widget reads via `appsmith.model` (dict or JSON
string). `name` renames it. `events` registers the event names the widget can emit
(e.g. `["onRefresh"]`). `triggers` binds those events to expressions, keyed by event
name (e.g. `{"onRefresh": "{{ bootstrap.load() }}"}`) — each is wired into the widget's
dynamicTriggerPathList automatically. `dynamic_height` is `"AUTO_HEIGHT"` or `"FIXED"`.
`left`/`top`/`columns`/`rows` move/resize it. Source code (html/css/js) is not editable
here — use patch_widget_code for targeted in-place source edits.

Delete a Custom Widget by id.

Create multiple JS objects in one tool call. Each entry is {"name", "body", "function_names"?, "page_id"?}. body is the full source (e.g. export default { foo: () => 1, bar: () => 2 }). If function_names is omitted, the top-level function names in body are parsed automatically per entry. page_id defaults to the currently open page.

Delete multiple JS objects in one tool call.

Replace the source of multiple JS objects in one tool call. Each entry is {"js_object_id", "body"}. Function names are re-parsed by Appsmith from each body.

Execute multiple JS functions in one tool call. Each entry is {"js_object_id", "function_name"}. Returns each result if the eval tree captured it; otherwise reports that the dispatch fired but no value surfaced (function may still have run for its side effects).

Evaluate an arbitrary JS snippet in the attached Firefox tab and return the result. The snippet runs in page context with access to window.__store. Use for exploring Redux state and discovering action shapes. Result must be JSON-serializable. Use sparingly and only with explicit user permission — this is an escape hatch that can dispatch any action and read any state, bypassing the safety constraints of the other tools.

Return the URL currently loaded in the attached Firefox tab — e.g. the dashboard /applications, an app editor /app/<slug>/page1-<id>/edit, or elsewhere.

Navigate the attached Firefox tab to a URL. Resets the Redux store binding.

Reload the attached Firefox tab (same URL) and wait for it to finish loading. Resets the Redux store binding, so the next tool call re-bootstraps it.