Skip to main content
Glama
appsmith-mcp
by t0knight

appsmith-mcp

An MCP server that lets an AI agent control Appsmith — building and editing apps (pages, widgets, queries, datasources, JS objects, themes) by driving the real editor in the browser. It attaches to a running Firefox over the WebDriver BiDi protocol and reads/dispatches the editor's Redux store, so an agent can operate Appsmith the same way a person would.

How it works

Appsmith has no public API for editing apps — the builder lives entirely in the browser. This server drives that builder in place: it attaches to a running Firefox over WebDriver BiDi, finds Appsmith's Redux store on the open editor page, and runs predefined JavaScript snippets against it.

Each tool is one such snippet. Reads pull straight from Redux state; writes dispatch the same actions the editor UI fires when you click — so creating a widget, wiring a query, or editing a custom widget's source is the programmatic equivalent of doing it by hand, and changes render live and save to the Appsmith backend.

The tools cover the full editor surface but lean toward custom widgets — self-contained HTML/CSS/JS components — since AI is generally better at building a UI as code than by arranging Appsmith's native widgets on a visual grid.

Related MCP server: browser-mcp

Prerequisites

  • Firefox — the server attaches to a running instance.

  • Python 3.10+ and uv or pip.

  • A reachable Appsmith instance you can log into.

Install

uv:

uv sync

pip:

python3 -m venv .venv
source .venv/bin/activate
pip install -e .

Launch Firefox with remote debugging

./launch.sh

This kills any running Firefox and reopens it with the BiDi port enabled (works on macOS, Linux, and Windows via Git Bash). Log into Appsmith and navigate to an app's editor page (.../edit) in that window. The server re-bootstraps on the next tool call after any navigation.

Register with Claude Code

claude mcp add --scope user appsmith /path/to/appsmith-mcp/.venv/bin/appsmith-mcp

After launching/relaunching Firefox, reconnect the server with /mcp so it re-attaches.

Tools

App & workspace

  • list_workspaces — List workspaces (id and name).

  • list_apps — List all applications across workspaces, with editor URLs.

  • create_app — Create a new application.

  • update_app — Update the current app's metadata and settings (name, navigation, theme, layout).

  • delete_app — Delete an application by id.

  • get_state_summary — Counts of widgets, datasources, and queries in the current app.

  • dump_state — Dump the current app's pages and widget tree (optionally full detail).

  • get_logs — Return log/error metadata (no message text).

Pages

  • list_pages — List the app's pages, flags, and which is active.

  • create_pages — Create one or more blank pages.

  • delete_pages — Delete one or more pages.

  • switch_page — Switch the editor to another page.

Custom widgets

  • create_custom_widget — Create a self-contained HTML/CSS/JS widget (the primary entrypoint).

  • get_custom_widget — Return a custom widget's source, model, events, name, and position.

  • update_custom_widget — Update its model, name, events, triggers, height mode, or position.

  • delete_custom_widget — Delete a custom widget by id.

  • patch_widget_code — Make targeted edits to a custom widget's source without rewriting it.

Widgets (native)

  • add_widgets — Add one or more native widgets.

  • update_widgets — Apply property updates to one or more widgets.

  • delete_widgets — Delete one or more widgets (cascades children).

  • set_widget_bounds — Move and/or resize widgets.

  • rename_widgets — Rename widgets.

  • reparent_widgets — Move widgets to a new parent canvas.

  • clear_canvas — Delete every widget on the page.

  • get_widget — Return a widget's full Redux record.

  • check_layout — Diagnose layout/overflow issues across the page.

  • list_widget_types — List widget types with a known property schema.

  • get_widget_schema — Return a widget type's property schema (controls, validation, defaults).

  • manage_table_columns — Add, remove, or reorder columns on a table widget.

  • manage_tabs — Add, remove, or reorder tabs on a tabs widget.

JS objects

  • list_js_objects — List JS objects with their declared function names.

  • get_js_objects — Return full source of JS objects (bodies, functions, variables).

  • create_js_objects — Create one or more JS objects.

  • update_js_objects — Replace the source of one or more JS objects.

  • delete_js_objects — Delete one or more JS objects.

  • patch_js_objects — Make targeted edits to JS object bodies without rewriting them.

  • execute_js_functions — Run JS object functions and return their results.

Queries

  • list_queries — List the app's queries (datasource actions).

  • create_queries — Create one or more queries bound to datasources.

  • update_queries — Update one or more queries.

  • delete_queries — Delete one or more queries.

  • execute_queries — Run queries by id and return their responses.

Datasources

  • list_datasources — List datasources in the current workspace.

  • create_datasources — Create one or more datasources.

  • update_datasources — Update one or more datasources.

  • delete_datasources — Delete one or more datasources.

  • list_plugins — List available plugins (REST, Postgres, MongoDB, etc.).

Themes

  • list_themes — List built-in and saved custom themes.

  • get_current_theme — Return the active theme and its color/font/radius/shadow values.

  • set_theme — Switch the app to a theme by id.

  • update_theme — Patch the current theme's properties.

  • save_custom_theme — Save the current theme as a named custom theme.

  • delete_custom_themes — Delete saved custom themes.

Browser & navigation

  • get_url — Return the URL loaded in the attached Firefox tab.

  • navigate — Navigate the tab to a URL.

  • refresh_page — Reload the tab and wait for it to finish.

  • run_command — Evaluate arbitrary JS in the tab and return the result.

⚠️ run_command evaluates arbitrary JavaScript in the attached browser tab with full access to the Redux store and the page — it can read or modify anything in the live session, bypassing the safety constraints of the other tools. It's an escape hatch for exploring state and discovering action shapes; use it deliberately.

License

MIT

Available Tools

57 tools
add_widgetsA

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.

Inputs: widgets (required).

check_layoutA

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.

Inputs: no named parameters.

clear_canvasA

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

Inputs: no named parameters.

create_appB

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.

Inputs: name (required), icon, color, workspace_id.

create_custom_widgetA

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}`.

Inputs: js, css, html, name, +1 more.

create_datasourcesA

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.

Inputs: datasources (required).

create_js_objectsA

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.

Inputs: objects (required).

create_pagesC

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

Inputs: names (required).

create_queriesA

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.

Inputs: queries (required).

delete_appC

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

Inputs: app_id (required).

delete_custom_themesA

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.

Inputs: themes (required).

delete_custom_widgetC

Delete a Custom Widget by id.

Inputs: widget_id (required).

delete_datasourcesB

Delete multiple datasources in one tool call.

Inputs: datasource_ids (required).

delete_js_objectsA

Delete multiple JS objects in one tool call.

Inputs: js_object_ids (required).

delete_pagesC

Delete multiple pages in one tool call.

Inputs: page_ids (required).

delete_queriesB

Delete multiple queries in one tool call.

Inputs: query_ids (required).

delete_widgetsA

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

Inputs: widget_ids (required).

dump_stateA

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.

Inputs: verbose.

execute_js_functionsA

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).

Inputs: executions (required).

execute_queriesA

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

Inputs: query_ids (required).

get_current_themeA

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

Inputs: no named parameters.

get_custom_widgetA

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.

Inputs: widget_id (required).

get_js_objectsA

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.

Inputs: js_object_ids.

get_logsA

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

Inputs: limit.

get_state_summaryA

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

Inputs: no named parameters.

get_urlA

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.

Inputs: no named parameters.

get_widgetA

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

Inputs: widget_id (required).

get_widget_schemaA

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.

Inputs: widget_type (required), property_name.

list_appsA

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).

Inputs: no named parameters.

list_datasourcesA

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

Inputs: no named parameters.

list_js_objectsB

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

Inputs: no named parameters.

list_pagesA

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

Inputs: no named parameters.

list_pluginsA

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).

Inputs: no named parameters.

list_queriesA

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

Inputs: no named parameters.

list_themesA

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

Inputs: no named parameters.

list_widget_typesA

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

Inputs: no named parameters.

list_workspacesA

List workspaces (id and name only).

Inputs: no named parameters.

manage_table_columnsA

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.

Inputs: widget_id (required), add, remove, reorder.

manage_tabsA

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.

Inputs: widget_id (required), add, remove, reorder.

patch_js_objectsA

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).

Inputs: edits (required).

patch_widget_codeA

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`.

Inputs: edits (required).

refresh_pageA

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.

Inputs: no named parameters.

rename_widgetsA

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.

Inputs: updates (required).

reparent_widgetsA

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.

Inputs: updates (required).

run_commandA

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.

Inputs: snippet (required).

save_custom_themeB

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.

Inputs: name (required).

set_themeA

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

Inputs: theme_id (required).

set_widget_boundsA

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).

Inputs: updates (required).

switch_pageC

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

Inputs: page_id (required).

update_appB

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.

Inputs: icon, name, color, app_id, +3 more.

update_custom_widgetA

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.

Inputs: widget_id (required), top, left, name, +6 more.

update_datasourcesA

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.

Inputs: updates (required).

update_js_objectsA

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.

Inputs: updates (required).

update_queriesA

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.

Inputs: updates (required).

update_themeA

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"}}.

Inputs: properties (required).

update_widgetsA

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.

Inputs: updates (required).

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 57 tools

    Disambiguation4/5

    Most tools have clearly distinct purposes, with batch and individual versions (e.g., create_datasources vs create_custom_widget). However, some overlap exists between patch_js_objects and update_js_objects, and between patch_widget_code and update_custom_widget, though they target different aspects (targeted edits vs full replacement). Overall, ambiguity is low.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern using snake_case (e.g., create_app, list_queries, update_widgets). The naming is predictable and easy to understand, with no mixing of conventions or unclear verbs.

    Tool Count2/5

    With 57 tools, the server is excessively large. Many tools are batch versions (e.g., create_datasources, delete_queries) that could be combined with optional parameters, and there are numerous delete tools for each resource type. The count feels inflated relative to the domain's core operations.

    Completeness4/5

    The tool surface covers CRUD operations for all major resources (widgets, datasources, queries, JS objects, pages, apps, themes) and includes execution, navigation, and diagnostics. Minor gaps exist, such as the lack of individual creation tools for datasources/queries/JS objects (only batch versions), but these are workable.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers