Dev MCP Server

This page explains how to install, set up, and use the Dev MCP. The Dev MCP is for building Appian applications from a third-party IDE. If you want to query data, start processes, or call AI agents from an external AI application, see Appian MCP Server.

What is Appian Dev MCP?

Dev MCP is a community-supported App Market plug-in that gives AI coding assistants a safe, structured way to interact with your Appian environment. With Dev MCP, you can describe what you want in natural language from your IDE and let your AI assistant create and update Appian objects on your behalf.

Dev MCP connects any MCP-compatible AI client (such as Claude Code, Codex, Cursor, or Kiro) to your Appian site. Because the server runs locally and acts as the signed-in developer, all work stays within your site and your existing permission boundaries.

Dev MCP capabilities

With Dev MCP, you can:

• Create and manage design objects from your IDE. List, read, create, update, and delete applications and design objects, such as record types (with database tables, fields, relationships, views, and actions), expression rules, interfaces, and process models.
• Test what you build without leaving your IDE. Your AI assistant can interact with sites, process forms, and record actions the same way an end user would.
• Authenticate with your existing credentials. Sign in through browser-based single sign-on (SSO) by default, without storing credentials in plain text. Username and password authentication is also supported.
• Work within your existing permissions. Access is limited to Designer and Administrator roles, and every operation runs under the authenticated user's own permissions. Your AI assistant can only see and modify the objects you're allowed to access.

Dev MCP server prerequisites

You need the following to run the Dev MCP server on your machine:

• Python 3.13 or later.
• uv package manager. Install with curl -LsSf https://astral.sh/uv/install.sh | sh.
• An MCP-compatible IDE. Compatible IDEs include Claude Code, Cursor, Kiro, VS Code with the MCP extension, or Claude Desktop.
• The Dev MCP plug-in. Install the Appian Dev MCP plug-in on your Appian site.

Install the Dev MCP plug-in

An Appian system administrator must install the Dev MCP plug-in before developers can connect their IDE.

To install the Dev MCP plug-in:

1. Open the navigation menu and select Admin Console.
2. In the left navigation menu, under System, click Plug-ins.
3. Click ADD NEW PLUG-INS.
4. In Appian AppMarket Plug-ins, search for and select Appian Dev MCP.
5. Click DEPLOY.

Set up the Dev MCP server

The Dev MCP server runs locally on your machine and communicates with the Dev MCP plug-in installed on your Appian site over HTTPS. After a system administrator installs the plug-in, you can configure your integrated development environment (IDE) to connect.

Download the Dev MCP server bundle

To download the Dev MCP server bundle:

1. Sign in to your Appian site in a browser.

2. Visit the following URL:

   1
   https://<YOUR_SITE>/suite/plugins/servlet/stateless/downloads
   

3. Click Download MCP Server.

   Your browser downloads appian-dev-mcp-server-bundle.tar.gz.

Unpack and install dependencies

To unpack the Dev MCP server bundle and install its dependencies:

1. Run the following command to extract the bundle into a new directory:

   1
   2
   mkdir -p ~/appian-dev-mcp-server
   tar -xzf ~/Downloads/appian-dev-mcp-server-bundle.tar.gz -C ~/appian-dev-mcp-server
   

2. Navigate to the directory and install dependencies:

   1
   2
   cd ~/appian-dev-mcp-server
   uv sync
   

Note the absolute path of ~/appian-dev-mcp-server. You need this path when configuring your IDE.

Add the Dev MCP server to your IDE

To add the Dev MCP server to your IDE:

1. Open the MCP configuration file for your IDE:

   IDE	Config file
   Claude Code (per project)	.mcp.json in the project root.
   Claude Code (global)	Run claude mcp add or edit ~/.claude.json.
   Cursor	~/.cursor/mcp.json.
   Kiro	.kiro/settings/mcp.json in the workspace root.
   VS Code	Per the MCP extension's settings.
   Claude Desktop (Mac)	~/Library/Application Support/Claude/claude_desktop_config.json.
   Claude Desktop (Windows)	%APPDATA%\Claude\claude_desktop_config.json.

2. Copy and paste the following into your configuration file:

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   {
     "mcpServers": {
       "appian": {
         "command": "uv",
         "args": [
           "run",
           "--directory",
           "/ABSOLUTE/PATH/TO/appian-dev-mcp-server",
           "python",
           "-m",
           "lcp_mcp_server"
         ],
         "env": {
           "LCP_URL": "https://your-site.appiancloud.com"
         }
       }
     }
   }
   

3. Replace /ABSOLUTE/PATH/TO/appian-dev-mcp-server with the path you unpacked the bundle into. For example, /Users/you/appian-dev-mcp-server.
4. If you need to customize authentication or configure a network proxy, add environment variables to the env block. See the following sections for details:
   • Authenticate the Dev MCP server.
   • Configure a network proxy for Dev MCP.
   • Dev MCP environment variable reference for the full list.

Install Dev MCP skills

Dev MCP skills are AI coding skills that teach your AI assistant how to build Appian applications. Installing Dev MCP skills produces better first-pass results and fewer retry loops.

The Dev MCP skills are included in the server bundle you extracted in Unpack and install dependencies. To install the skills, run the install script for your operating system from the bundle directory:

• macOS and Linux: bin/install-skills.sh
• Windows: bin\install-skills.bat

The script detects your AI client (Kiro, Claude, or Codex) and installs the skills automatically. If you have edited a previously installed copy, the script leaves your changes in place and stages the update alongside them for you to merge.

Authenticate the Dev MCP server

The Dev MCP Model Context Protocol (MCP) server must authenticate with your Appian site before it can read or write design objects.

Dev MCP supports two authentication methods:

• Browser-based authentication (default): Opens a browser window for you to sign in to your Appian site.
• Username/password authentication: Passes credentials directly through environment variables.

Set up browser authentication

Browser authentication is the default method for the Dev MCP server. The required dependencies are installed during the Unpack and install dependencies step.

To set up browser authentication, download Chromium from the Dev MCP server bundle directory:

1
uv run playwright install chromium

The Chromium download is a one-time download of a few hundred MB. If you cannot download Chromium, see Use an alternate browser to configure a system-installed browser instead.

The first time you invoke a Dev MCP tool, a browser window opens to your Appian site's sign-in page. Complete the sign-in process. Once you reach the Appian interface, the window closes and your session is captured automatically. The tool call then proceeds. You have up to five minutes to finish signing in.

Dev MCP saves your session to ~/.appian-devmcp/ and reuses it for subsequent calls. The session lifecycle works as follows:

• Reuse across restarts: Dev MCP reuses your session across restarts of the MCP server.
• Session expiry: A captured session lasts until your Appian session expires, after which the Dev MCP server reopens the browser so you can sign in again.
• Automatic recovery: If your session expires or is invalidated on the server, Dev MCP detects the change, reopens the browser, and retries your request.

Use an alternate browser

If you cannot install Chromium, set LCP_BROWSER_CHANNEL to either chrome or msedge in the env block of the MCP configuration file you created in Add the Dev MCP server to your IDE.

The Dev MCP server then opens a system-installed browser instead of Playwright's managed Chromium. For the full list of environment variables, see Dev MCP environment variable reference.

Configure single sign-on

By default, the Dev MCP browser opens /suite/. Most Appian sites either redirect automatically to the identity provider or show a sign-in chooser—both work without extra configuration.

If you want to skip the sign-in chooser and go directly to a specific identity provider, set the LCP_SIGNIN_PATH environment variable to your single sign-on (SSO) entry path. For example:

1
"LCP_SIGNIN_PATH": "/suite/?signin=your-idp-name"

Your Appian administrator can tell you the correct signin value for your site.

If your site redirects to a custom landing page after sign-in that is not Appian Designer or an Appian site, set LCP_AUTH_LANDING_PATH to that path so the Dev MCP server knows when sign-in is complete.

Configure multiple users

You can configure multiple Dev MCP servers for the same AI application, each authenticating as a different user. Repeat the server configuration block and specify a USERNAME variable for each:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
{
  "mcpServers": {
    "appian": {
      "command": "uv",
      "args": [
        "run",
        "--directory",
        "/ABSOLUTE/PATH/TO/appian-dev-mcp-server",
        "python",
        "-m",
        "lcp_mcp_server"
      ],
      "env": {
        "LCP_URL": "https://your-site.appiancloud.com",
        "USERNAME": "john.smith"
      }
    },
    "appian-test-user": {
      "command": "uv",
      "args": [
        "run",
        "--directory",
        "/ABSOLUTE/PATH/TO/appian-dev-mcp-server",
        "python",
        "-m",
        "lcp_mcp_server"
      ],
      "env": {
        "LCP_URL": "https://your-site.appiancloud.com",
        "USERNAME": "test.user"
      }
    }
  }
}

Set up username and password authentication

If you cannot open a browser for authentication, Dev MCP supports username and password authentication. Add your credentials and set "LCP_AUTH_METHOD" to "basic" in the env block of your MCP configuration:

1
2
3
4
5
6
"env": {
  "LCP_URL": "https://your-site.appiancloud.com",
  "LCP_AUTH_METHOD": "basic",
  "USERNAME": "your-username",
  "PASSWORD": "your-password"
}

Troubleshoot Dev MCP authentication

The following table lists common authentication issues and resolutions for the Dev MCP server:

Configure a network proxy for Dev MCP

If your network routes traffic through an HTTP proxy, add the standard proxy environment variables to the env block in your Dev MCP server configuration:

1
2
3
4
5
6
"env": {
  "LCP_URL": "https://your-site.appiancloud.com",
  "HTTPS_PROXY": "https://your-proxy-host:port",
  "HTTP_PROXY": "https://your-proxy-host:port",
  "SSL_CERT_FILE": "/path/to/proxy-root-ca.pem"
}

Most corporate proxies perform TLS inspection, replacing upstream certificates with ones signed by the proxy's own root certificate authority (CA). The SSL_CERT_FILE variable points to a file containing that root CA certificate so the Dev MCP server trusts the proxy's certificates. Contact your network or security team to obtain the certificate file.

The HTTPS_PROXY, HTTP_PROXY, and SSL_CERT_FILE variables are standard environment variables, not specific to Dev MCP. The underlying HTTP library reads these variables directly and applies them to all outbound connections the Dev MCP server makes.

Restart your IDE and verify connection

After you configure the Dev MCP server, authentication, and any proxy settings, restart your IDE to load the new MCP server. Quit and relaunch your IDE. For Claude Code, exit the terminal session entirely and relaunch.

To verify the Dev MCP server is connected, ask your AI application:

1
List the applications on my Appian site.

A successful connection returns a list of applications from your site. If you get a 404 error, confirm that a system administrator has installed the Dev MCP plug-in.

Once connected, see Use Dev MCP effectively for prompt guidance, or try the Employee Onboarding example to see Dev MCP build a full application.

Dev MCP environment variable reference

The following table lists all environment variables for the Dev MCP server:

Use Dev MCP effectively

After you connect Dev MCP to your Appian environment, the quality of your results depends on how you structure your prompts.

Dev MCP works best with direct, specific requests that target a single Appian design object. For example, the following prompts produces good results:

• Single record type: Make a record type called Employee with fields for name, email, department, and hire date.
• Focused expression rule: Write an expression rule that calculates business days between two dates.
• Specific interface: Build a form that collects a customer's name, phone number, and address.

Broad, multi-step requests do not produce good results with Dev MCP. For example, the following prompts may not produce the best results:

• Entire application: Build me a loan servicing application.
• Many objects at once: Create a full case management system with approvals.

For broad requests like these, Appian Composer is a better fit. Composer can help you plan and build an entire application using AI directly within Appian Designer.

If you still want to handle complex, multi-step workflows through Dev MCP, write your own IDE-specific configuration files (such as custom prompts or workflow guides) to direct the AI in your development environment.

Example: Build an Employee Onboarding app with Dev MCP

The following eight prompts demonstrate how Dev MCP builds a simple Employee Onboarding application from scratch. Each prompt creates a layer of the app so you can see how Dev MCP handles real, connected Appian objects.

The prompts must run in order, one at a time, because each prompt builds on the previous prompt: the data model must exist before forms can reference it, and forms must exist before the site can route to them.

Prompt 1 — Application and groups

1
2
3
4
Let's build a Modern Onboarding Hub in Appian to replace a legacy system.
HR Specialists manage new hires; Hiring Managers track their team's
onboarding progress. Create the application with prefix OB and add two
persona groups: OB HR Specialist and OB Hiring Manager.

Expected result: Your Appian environment contains a Modern Onboarding Hub application with two groups: OB HR Specialist and OB Hiring Manager.

Prompt 2 — Data model

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Build 5 database-backed record types with camelCase field names and
UPPER_SNAKE_CASE source columns. Include fields createdBy,
createdOn, modifiedBy, modifiedOn, isActive on all tables.

OB Department — departmentId PK, deptName
OB Employee — employeeId PK, firstName, lastName, email, departmentId FK,
  hiringManager (USER), startDate (DATE)
OB Ref Onboarding Task — id PK, taskName, sortOrder
OB Ref Status — id PK, value, sortOrder
OB Employee Task — employeeTaskId PK, dueDate (DATE), completionStatusId FK,
  taskId FK, employeeId FK

Wire bidirectional relationships: Department↔Employee,
Employee↔EmployeeTask, RefOnboardingTask↔EmployeeTask,
RefStatus↔EmployeeTask, plus USER relationships from all
createdBy/modifiedBy/hiringManager fields.

Insert 5 realistic sample rows per table with proper FK references.

Expected result: Five record types with bidirectional relationships, specified fields, and five sample rows per table. You can verify the record types and their relationships in Appian Designer under the Modern Onboarding Hub application.

Prompt 3 — Employee form and workflow

1
2
3
Build a process model called "OB Create Or Update Employee" with a start form (OB_CreateOrUpdateEmployee). The form lets HR set all employee fields and manage an inline list of onboarding tasks. Flow: Start → XOR cancel → Delete Records (removed tasks) → Write Records (employee) → End.

Use record-typed process variables and inputs. Include an isUpdate Boolean variable for the related action context. Use dropdowns for FK fields backed by queries against the ref tables.

Expected result: A process model called OB Create Or Update Employee and an interface called OB_CreateOrUpdateEmployee. The interface includes dropdowns for department and onboarding task fields, and the process model handles both creating and updating employee records.

Prompt 4 — Employee task form and workflow

1
2
Build "OB Create Or Update Employee Task" with start form
OB_CreateOrUpdateEmployeeTask. Flow: Start → XOR cancel → Write Records → End. Use dropdowns for Task and Status FKs. Keep Employee ID as an integer field since it is pre-populated from context.

Expected result: A process model called OB Create Or Update Employee Task and an interface called OB_CreateOrUpdateEmployeeTask. The interface includes dropdowns for task and status fields.

Prompt 5 — Summary views and record actions

1
2
3
4
5
6
7
8
9
Build summary view interfaces for Employee, Employee Task, and Department (OB_EmployeeSummary, OB_EmployeeTaskSummary, OB_DepartmentSummary). Wire each as the Summary view on its record type.

Add 4 record actions:
- Employee: "New Employee" (list action) and "Update Employee" (related
  action, passes rv!record and isUpdate)
- Employee Task: "New Employee Task" (list) and "Update Employee Task"
  (related, passes rv!record and isUpdate)

Wire the related actions as shortcut buttons on the Summary views.

Expected result: Three summary view interfaces (OB_EmployeeSummary, OB_EmployeeTaskSummary, OB_DepartmentSummary) wired to their record types, and four record actions (two for Employee, two for Employee Task) with related actions displayed as shortcut buttons on each summary view.

Prompt 6 — Dashboards and reusable components

1
2
3
4
5
6
7
8
Build 5 interfaces:
- OB_CMPT_LandingPageAlertCard — accent card showing an icon and a count
- OB_CMPT_LandingPageTaskCard — card per task with name, due date, status
- OB_HROnboardingDashboard — HR landing page with an alert card for
  overdue cases and an employee grid with record links
- OB_ManagerOnboardingDashboard — same shape filtered to the logged-in
  user's direct hires
- OB_ReportsPlaceholder — card with "coming soon" text for the site

Expected result: Five interfaces: two reusable card components (OB_CMPT_LandingPageAlertCard and OB_CMPT_LandingPageTaskCard), two role-based dashboards (OB_HROnboardingDashboard and OB_ManagerOnboardingDashboard), and a placeholder reports interface (OB_ReportsPlaceholder).

Prompt 7 — Site

1
2
3
4
Build a site called "OB Employee Onboarding" (display name "Employee
Onboarding", web address ob-employee-onboarding). Three pages:
HR Onboarding Dashboard, Manager Onboarding Dashboard, and Reports
and Dashboards.

Expected result: A site called OB Employee Onboarding accessible at /suite/sites/ob-employee-onboarding with three pages, each wired to the corresponding dashboard or placeholder interface.

Prompt 8 — User filters

1
2
3
4
Add multi-select user filters:
- OB Employee: Department filter sourced from the department relationship
- OB Employee Task: Employee, Status, and Onboarding Task filters — all
  sourced from their respective relationships

Expected result: A Department user filter on the OB Employee record type, and Employee, Status, and Onboarding Task user filters on the OB Employee Task record type. Each filter is sourced from the corresponding relationship.

What the finished application includes

After you finish all eight prompts, the Dev MCP-built application includes:

• Record types: Five related record types.
• Workflows: Two create, read, update, and delete (CRUD) workflows.
• Dashboards: Role-based dashboards.
• Site: A deployable site.
• User filters: Filterable record lists.

You can review what Dev MCP built. Try asking your AI application to list the record types or show the site pages. You can also extend the application further with additional prompts.

Feedback