Skip to main content
Glama

Frappe MCP

A Model Context Protocol server for Frappe developers. Point Claude Code or Claude Desktop at a development site and let it create and change DocTypes, customize ERPNext forms, keep the site and your app's files in sync, and set up workflows, reports, and Workspaces. Every change is previewed before it happens.

It runs as a local stdio process and talks to the site only through Frappe's REST API. You don't install it as a Frappe app, add it to a Bench, or migrate anything. Frappe's own permissions and validation apply to every call, and there is no SQL, Python eval, or arbitrary method call.

What you can ask

  • "Create a submittable DocType Lab Sample in lab_app, module Lab, with a title, a customer link, a status select, and a child table of readings."

  • "Add a required Priority field after the title on Lab Sample, show it in the list view, and drop the old legacy_code field."

  • "On the ERPNext Customer form, add a Custom Field Account Manager linked to User, make Territory mandatory, then export the customizations to lab_app."

  • "Has anything drifted between the site and lab_app? Show me what bench migrate would change for Lab Sample."

  • "I prototyped Lab Equipment as a custom DocType on the site. Move it into lab_app so it ships with the app."

  • "Add an approval workflow to Lab Sample: Draft → Pending → Approved, approved by Lab Manager."

  • "Send a System Notification to Lab Managers when a Lab Sample is submitted."

  • "Build a Lab Workspace with shortcuts to Lab Sample and an Open Samples report."

  • "Create three test Lab Samples, submit one, and check the controller set its status."

The server answers by reading the schema first, returning a preview (fields added, moved, and removed; files Frappe will write; records affected), and acting only after you confirm.

Related MCP server: Frappe MCP Server

Install

uvx mcp-frappe --version

Until the first PyPI release, run it from GitHub: uvx --from git+https://github.com/DannyFiallo030503/mcp-frappe mcp-frappe. You need Python 3.10+ and an MCP host that runs local stdio servers.

Configure

Create an API key for a user on your development site, export the settings, and check them:

export FRAPPE_URL=http://127.0.0.1:8000 FRAPPE_SITE=site1.localhost
export FRAPPE_API_KEY=... FRAPPE_API_SECRET=...
export FRAPPE_APPS_PATH=/absolute/path/to/frappe-bench/apps   # for standard DocTypes and exports
uvx mcp-frappe check

check logs in and prints the user, app versions, toolsets, and whether FRAPPE_APPS_PATH holds the site's apps. It never prints a secret. HTTPS is required except for loopback and .localhost hosts.

Then add the server to your host. Claude Code:

claude mcp add frappe \
  -e FRAPPE_URL=http://127.0.0.1:8000 -e FRAPPE_SITE=site1.localhost \
  -e FRAPPE_API_KEY="$FRAPPE_API_KEY" -e FRAPPE_API_SECRET="$FRAPPE_API_SECRET" \
  -e FRAPPE_APPS_PATH=/absolute/path/to/frappe-bench/apps \
  -- uvx mcp-frappe

Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "frappe": {
      "command": "uvx",
      "args": ["mcp-frappe"],
      "env": {
        "FRAPPE_URL": "http://127.0.0.1:8000",
        "FRAPPE_SITE": "site1.localhost",
        "FRAPPE_API_KEY": "<api key>",
        "FRAPPE_API_SECRET": "<api secret>"
      }
    }
  }
}

Other hosts: a stdio server with command uvx and arguments ["mcp-frappe"]. Password login, shared .mcp.json files, containers, and every setting are covered in installation and configuration.

Standard DocTypes, DocType edits, and file exports need developer mode on the site and FRAPPE_APPS_PATH pointing at the site's Bench apps folder. Site-custom DocTypes, Custom Fields, and records need neither.

Toolsets

Toolset

What it does

read

Site info, DocTypes and schemas, records, counts, search, reports, drift checks, workflows, notifications, Workspaces

data

Create, update, delete, submit, and cancel records

customize

Custom Fields, Property Setters, role permissions, export to app files, rollback

developer

Create, edit, delete, and promote DocTypes; Workflows, Notifications, Report Builder reports, Workspaces

All four are on by default. FRAPPE_MCP_TOOLSETS=read,customize narrows them, and FRAPPE_MCP_READ_ONLY=YES exposes only read. Every tool carries MCP annotations, so a host can run reads freely and ask before writes.

Safety

  • Writes return a preview first. Updates and deletes are bound to the record's modified timestamp, and exports to a hash of the preview, so nothing changes if the site moved in between.

  • File writes stay inside the configured app, refuse frappe and erpnext, back up what they overwrite, and can be rolled back.

  • Fields Frappe evaluates as code (Python conditions, Query and Script Reports, custom HTML blocks) are refused.

  • The server never runs bench migrate, restarts Bench, or deploys. Review and commit the generated files yourself.

Use an Administrator key only on a development site. See the security model.

Docs

License

MIT. The archived code under legacy/ keeps its upstream notices; see UPSTREAM.md and the third-party notices.

Available Tools

15 tools
create_custom_fieldC

Preview or create a Custom Field through the standard Frappe REST API.

Inputs: app (required), field (required), module (required), doctype (required), +1 more. Returns: object

create_doctypeB

Preview or create a standard or site-custom DocType through Frappe.

fields accepts the native DocField properties and field types. properties carries supported DocType-level settings such as autoname, tracking, sorting, and search configuration. Standard DocTypes require a local app/module checkout and Developer Mode so Frappe can write JSON, Python, JavaScript, and test files. Site-custom DocTypes are stored in site metadata and do not generate app files.

Inputs: app (required), name (required), fields (required), module (required), +8 more. Returns: object

create_documentC

Preview or create a document via the native REST resource API.

Inputs: values (required), doctype (required), confirm. Returns: object

delete_documentC

Preview or delete a record; confirmation requires the preview's modified token.

Inputs: name (required), doctype (required), confirm, expected_modified. Returns: object

export_customizationsC

Preview or export DocType JSON and customization fixtures into an app, with rollback.

Inputs: app (required), module (required), doctypes (required), confirm, +1 more. Returns: object

get_doctype_schemaB

Read the DocType schema and field metadata visible through Frappe's API.

Inputs: doctype (required). Returns: object

get_documentA

Read one document, selecting fields and bounding any returned child-table rows.

Inputs: name (required), doctype (required), fields, child_row_limit. Returns: object

list_doctypesC

List DocTypes on the site, optionally filtered by app/module.

Inputs: app, limit, module, include_child_tables. Returns: result

list_documentsC

List permission-filtered records and fields through the standard Frappe REST API.

Inputs: doctype (required), limit, fields, filters. Returns: result

list_installed_appsA

Discover apps and modules represented by the target site's Module Def records.

Inputs: no named parameters. Returns: result

rollback_exportC

Preview or restore files from an export manifest without overwriting later edits.

Inputs: app (required), module (required), rollback_id (required), confirm, +1 more. Returns: object

run_reportC

Run an enabled report using Frappe's permission-checked query-report API.

Inputs: report_name (required), limit, filters. Returns: object

set_field_propertyC

Preview or save a Customize Form value as a Property Setter.

Inputs: app (required), value (required), module (required), doctype (required), +4 more. Returns: object

set_role_permissionsC

Preview or set DocType role permissions through Frappe's native manager.

Inputs: role (required), doctype (required), permissions (required), confirm, +1 more. Returns: object

update_documentB

Preview or update a record; confirmation requires the preview's modified token.

Inputs: name (required), values (required), doctype (required), confirm, +1 more. Returns: object

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    B3.2/5.0

    Scored across 15 tools

    Disambiguation5/5

    Each tool targets a clearly distinct resource and action: document CRUD, DocType schema/creation/listing, reports, permissions, custom fields, property setters, exports, and app/module discovery. Similar-sounding tools like create_custom_field versus set_field_property are separated by descriptions and scope.

    Naming Consistency5/5

    All tools use snake_case with a predictable verb_noun pattern, such as list_documents, create_document, run_report, and export_customizations. Minor variations like get_doctype_schema still fit the convention.

    Tool Count5/5

    Fifteen tools is well-scoped for a Frappe MCP covering document operations, schema management, reports, permissions, customization, and export/rollback. Each tool appears to earn its place without excessive surface area.

    Completeness4/5

    The surface covers core CRUD for documents plus important Frappe metadata and customization workflows. Some gaps remain, such as first-class readback/discovery for role permissions and reports, and no explicit update/delete DocType tool, though generic document operations may provide workarounds.

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Enables interaction with Frappe Framework sites through comprehensive document operations, schema introspection, report generation, and method execution. Provides secure API-based access to create, read, update, and delete Frappe documents while supporting financial reporting and DocType management.
      24
      17
      ISC
    • A
      license
      Not graded
      quality
      D
      maintenance
      Allows AI assistants to interact with Frappe applications through the official REST API, enabling document CRUD operations, schema handling, and detailed API instructions.
      271 npm
      2
      ISC
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI models to securely interact with Frappe Framework/ERPNext instances, supporting document CRUD, RPC methods, file management, workflows, reporting, and more via the Model Context Protocol.
      271 npm
      ISC
    • A
      license
      Not graded
      quality
      D
      maintenance
      Integrates with ERPNext/Frappe API to enable AI assistants to interact with ERPNext data and create custom applications including DocTypes, workflows, scripts, and more.
      MIT