Ai is a local plugin. Install it using npm package: @formio/mcp and add the generated configuration snippet to your AI app's MCP config file. Then restart your AI app.

Ai was flagged by MCP Marketplace's security scan, scoring 4.2/10 (high risk). It has 2 high or critical findings to review. Review the security report on this page carefully before installing it.

What credentials does Ai need?

Ai requires the following credentials or environment variables: FORMIO_PROJECT_URL, FORMIO_BASE_URL, FORMIO_API_KEY, FORMIO_LOGIN_FORM, FORMIO_INSECURE_TLS. You can find setup instructions on the server detail page.

What AI apps work with Ai?

Ai uses the Model Context Protocol (MCP) and works with any MCP-compatible AI app, including Claude, ChatGPT / Codex, Gemini, Copilot, Cursor, and more.

Back to Browse

Ai MCP Server

by Formio

Developer ToolsUse Caution4.2MCP RegistryLocal

Free

Server data from the Official MCP Registry

Create and manage Form.io forms, resources, actions, roles, and projects from your AI agent.

About

Create and manage Form.io forms, resources, actions, roles, and projects from your AI agent.

Security Report

4.2

Use Caution4.2High Risk

This is a Form.io AI MCP server monorepo with developer tooling for Angular resource scaffolding and data planning. The codebase demonstrates reasonable security practices with proper environment variable handling, no hardcoded credentials, and well-scoped permissions. Minor code quality issues around broad exception handling and some informal test structure prevent a higher score, but no critical vulnerabilities were found. Supply chain analysis found 3 known vulnerabilities in dependencies (0 critical, 1 high severity). Package verification found 1 issue (1 critical, 0 high severity).

6 files analyzed · 9 issues found

Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.

Permissions Required

This plugin requests these system permissions. Most are normal for its category.

File System Read

Reads files on your machine. Normal for tools that analyze or process local data.

env_vars

Check that this permission is expected for this type of plugin.

HTTP Network Access

Connects to external APIs or services over the internet.

Unverified package source

We couldn't verify that the installable package matches the reviewed source code. Proceed with caution.

What You'll Need

Set these up before or after installing:

Full URL of the Form.io project to target (e.g. https://api.form.io/my-project, or https://your-host/project-name for self-hosted).Optional

Environment variable: FORMIO_PROJECT_URL

Base URL of your Form.io deployment — the parent of FORMIO_PROJECT_URL (default: https://api.form.io). Set this when self-hosting or using Form.io Enterprise.Optional

Environment variable: FORMIO_BASE_URL

Form.io project API key. Optional — when omitted the server uses a browser-based portal login flow to obtain a JWT.Required

Environment variable: FORMIO_API_KEY

URL of a custom login form used by the browser-based portal login flow. Defaults to the deployment's portal login form.Optional

Environment variable: FORMIO_LOGIN_FORM

Set to 1 to skip TLS certificate verification. For local development against self-signed certificates only — never enable in production.Optional

Environment variable: FORMIO_INSECURE_TLS

How to Install

Add this to your MCP configuration file:

{
  "mcpServers": {
    "io-form-formio-mcp": {
      "env": {
        "FORMIO_API_KEY": "your-formio-api-key-here",
        "FORMIO_BASE_URL": "your-formio-base-url-here",
        "FORMIO_LOGIN_FORM": "your-formio-login-form-here",
        "FORMIO_PROJECT_URL": "your-formio-project-url-here",
        "FORMIO_INSECURE_TLS": "your-formio-insecure-tls-here"
      },
      "args": [
        "-y",
        "@formio/ai-monorepo"
      ],
      "command": "npx"
    }
  }
}

Documentation

View on GitHub

From the project's GitHub README.

The Form.io Agentic Coding Toolset

@formio/ai is what brings Form.io into your agentic coding environment. It provides a series of tools that enable any developer to perform a number of complex actions against the Form.io Enterprise Server using their favorite Agentic Coding toolsets (starting with Claude Code). This turns the Form.io Enterprise Server into a Composable Backend for Agentically Coded Applications.

Getting Started

Getting started is easy. First install Claude Code as follows:

Install Claude Code
Run claude in your Terminal.
Run the following command within Claude Code.

/plugin marketplace add https://github.com/formio/ai.git
/plugin install formio-ai@formio

Claude Code prompts for the Project URL and the Base URL on install. These are described as follows:

Project URL: This is the endpoint for your 'project'. If you are using our SaaS environment (https://portal.form.io), then your project URL will be a sub-domain, such as https://myproject.form.io. However, for most use cases, when Form.io is deployed in your own environment, then the project url is typically a 'sub-directory' structure like https://forms.mysite.com/myproject.
Base URL: This is the endpoint for the deployment. If you are using the SaaS environment (https://portal.form.io), then this is always going to be https://api.form.io. However, for most use cases, when Form.io is deployed in your own environment, then this is the URL of the deployment like https://forms.mysite.com.

What you get

Claude Code plugin: @formio/ai. One-command install. Bundles the MCP server and skill library, registers them with Claude Code.
MCP server: @formio/mcp. Form.io operations (form_*, role_*, action_*, project_*) as MCP tools. Works with any MCP-aware client: Claude Code, Claude Desktop, VS Copilot, and whatever comes next.
Skills library: Ten activatable skills covering app orchestration, form building (webforms and wizards), form embedding, resource planning, JSON-schema authoring, action configuration, authentication & authorization, the @formio/js SDK surface, and the full Form.io REST surface.

Why this exists

Form.io has been the data standardization layer for enterprise data for a decade. With the proliferation of AI coding agents, that standardization matters more, not less.

Build on the Form.io platform, not from scratch. The agent builds complete applications including the data models, forms, workflows, and business logic. Form.io is the platform it builds on. The APIs, data patterns, RBAC, audit infrastructure, and form management capabilities are production-grade and already there. The agent uses them as tools to build applications better.

Standardization across every AI-built app. One model, one set of rules, one audit trail, regardless of which team or which agent built it. With a standardization layer, multiple teams ship multiple applications, all with defensible, reconcilable data layers across the enterprise.

Governance built in. RBAC, group permissions, change history, audit trails — all emitted on the first pass. Every app lands inside the same compliance envelope the enterprise already runs on.

Agentic Skill Library

The plugin ships an activatable skill library. Claude loads the relevant skill on demand based on what you ask — you rarely need to name one explicitly.

Orchestration skills

Orchestration skills are special skills that serve as the entry point for most prompts. Rather than covering a single capability, they coordinate the other skills (planning, schema authoring, actions, deployment, framework scaffolding) to fulfill a broad, plain-language request end to end. When you describe what you want instead of which tool to use, an orchestration skill picks it up and drives the whole pipeline.

Skill	What it does
`formio-application`	Framework-agnostic "build me an app" orchestrator. Turns plain-language intent into a running application backed by a Form.io project — planning resources, importing the template, and handing off to a framework implementor. Also handles adding new features to an existing app.
`formio-form-builder`	"Build me a form" orchestrator. Builds a single form end to end — webform or multi-page wizard — from intent through schema authoring to a saved form in your deployment, with an optional embed handoff. Also handles field edits to an existing form.

All skills

Skill	What it does
`formio-application`	Orchestration entry point for building or extending an application on the Form.io platform (see above).
`formio-form-builder`	Orchestration entry point for building a single form — webform or wizard — end to end (see above).
`formio-form`	Embeds and renders Form.io forms in any web application with the `@formio/js` renderer — pre-fill, conditional fields, calculated values, custom validation, and conditional wizard pages.
`formio-resource-planner`	Plans the resource structure, field configuration, and access/permission model from high-level requirements, then emits a ready-to-import `template.json`.
`formio-schema`	Reference for Form.io JSON schema — the document shapes for projects, forms/resources, and submissions. Used when constructing, editing, or interpreting any Form.io JSON.
`formio-actions`	Reference for configuring Form.io actions — the server-side behavior layer for email notifications, authentication, webhooks, role assignment, and form-to-form saves.
`formio-auth`	Authentication and authorization specialist — login/registration, RBAC, SSO (OIDC/SAML/LDAP), Token Swap, Custom JWT, passwordless email tokens, and JWT/session mechanics.
`formio-api`	Comprehensive Form.io REST API reference — every endpoint across platform admin, project admin, runtime, and PDF scopes.
`formio-sdk`	Reference for the `@formio/js` JavaScript SDK and `@formio/js/utils` Utilities — static and instance methods, VanillaJS rendering, plugins, and helpers.
`formio-angular`	Angular framework implementor. Turns an approved `template.json` plus a target project into a working Angular app using `@formio/angular`. Delegated to by `formio-application`.

Examples and Use Cases

Ready-to-paste example prompts live in examples/ — each file is one self-contained prompt plus notes on what it should exercise. To try one, create a new folder, start Claude Code inside it, and paste the prompt:

mkdir form-app
cd form-app
claude

Build complete applications

Create a brand-new 'greenfield' form-based application — or introduce a new form-based feature within an existing one — using the formio-application orchestration skill. The agent plans the data model, imports it into your Form.io project, and scaffolds the front end, using the Form.io platform as the composable backend for the full application logic.

CRM Application — clients, deals, and activity logs with owner-scoped access.
Help Desk — customer tickets, agent workflows, internal notes, and email notifications.
Storyboard — production → scene → shot hierarchy with collaborative crew access.

This library currently only supports the Angular application framework for new 'greenfield' applications. It generally supports other frameworks using the Vanilla JS @formio/js javascript renderer. Full support for other frameworks are coming soon.

Build forms and wizards

Create complex forms and multi-page conditional wizards with the formio-form-builder skill. The agent authors the form JSON and automatically creates the form within any stage of your deployment — including forms whose submission data must adhere to well-defined external schemas such as FHIR.

College Application Wizard — multi-page wizard with program-driven conditional pages.
FHIR-Compliant Patient Form — submission data that conforms to the FHIR Patient resource.
Customer Feedback Form — conditional follow-up fields and a conditional email notification.
Student Onboarding Wizard — create a wizard and embed it within your application in one pass.

Embed forms in existing applications

Embed an existing form or wizard within any HTML-based application using the formio-form skill.

Embed an Existing Form — render a saved form with @formio/js, pre-fill it, and handle submit events.

Work the REST API via prompt

The formio-api skill knows the full REST surface of your Form.io deployment — create any Resource, Form, Submission, or other entity via prompt.

Create a Patient Resource — create a new resource through the MCP server's first-party tools.

Using the MCP server without the skills

The bundled MCP server is also published standalone as @formio/mcp — you do not need the Claude Code plugin or the skill library to use it. Any MCP-aware client (Claude Code, Claude Desktop, Cursor, VS Code Copilot) can spawn the server directly and call the tools below.

To connect from Claude Code without the plugin, add a .mcp.json to your project root:

{
  "mcpServers": {
    "formio-mcp": {
      "command": "npx",
      "args": ["-y", "@formio/mcp"],
      "env": {
        "FORMIO_BASE_URL": "https://api.form.io",
        "FORMIO_PROJECT_URL": "https://your-project.form.io"
      }
    }
  }
}

In standalone mode, FORMIO_BASE_URL and FORMIO_PROJECT_URL are required env vars (full list). Authentication works the same as in plugin mode: the first authenticated tool call opens the browser portal-login flow, or set FORMIO_API_KEY to skip the browser entirely.

Once connected, prompt the tools directly — no skill activation involved:

Using the formio-mcp tools, show me every form and role in my Form.io project, then export the full project template and save it to ./backup/template.json.

Using the formio-mcp form_create tool, create a new form called "Contact Us" with fields for full name (required), email (required), subject, and message, plus a submit button.

Ready-to-paste versions of these live in examples/mcp/: Inspect and Export a Project and Create a Form Directly.

One caveat: without the skills, the agent authors Form.io JSON (form schemas, action settings, access arrays) from its own general knowledge instead of the conventions the skill library encodes — every operation the tools cover still works, but you give up the guardrails. For other transports (Streamable HTTP for remote clients, SSE for Claude Desktop) and running the server from a clone of this repo, see the MCP server README.

MCP server tools

The bundled @formio/mcp server exposes these tools. Skills prefer these over raw HTTP whenever an operation is covered.

Forms

Tool	Purpose
`form_create`	Create a new form. Use the `formio-schema` skill first to build the JSON definition.
`form_get`	Fetch a single form definition by ID or path.
`form_list`	List forms with optional filtering and pagination.
`form_update`	Update an existing form. Call `form_get` first, edit with `formio-schema`, then update.
`form_revisions_list`	List the immutable published revision summaries for a form (`_vid`, `_id`, `modified`, `user`, `_vnote`). Requires form revisions to be enabled.
`form_revision_get`	Fetch a single immutable form revision by `_vid` or revision document `_id`.

Roles

Tool	Purpose
`role_create`	Create a new project role.
`role_list`	List all project roles.
`role_update`	Full-replacement update of a role. Include all fields you want preserved.

Actions

Tool	Purpose
`action_types_list`	List all action types available on the server.
`action_type_get`	Get an action type's settings schema.
`action_create`	Attach a new action to a form.
`action_list`	List actions on a form.
`action_get`	Get a single action by ID.
`action_update`	Update an action.
`action_delete`	Detach an action from a form.

Project

Tool	Purpose
`project_export`	Export the project's complete template (roles, resources, forms, actions) as a portable JSON document. Use before `project_import` to snapshot.
`project_import`	Import a template JSON — additively merges roles, resources, forms, and actions in one call. Same-machine-name items are overwritten in place; everything else is preserved.
`project_set`	Plugin-mode only — persist a per-cwd Project URL mapping in `~/.formio/projects.json`. Never exposed standalone (the standalone server binds to `FORMIO_PROJECT_URL` via env instead).

Diagnostic

Tool	Purpose
`hello`	Smoke-test tool. Returns a static greeting; useful for verifying MCP wiring before any authenticated call.

Authentication

The MCP server supports two authentication modes:

JWT mode (default). A short-lived local Express server renders the Form.io portal login form; the user signs in once, the JWT comes back via a /callback endpoint, and formioFetch attaches x-jwt-token on every subsequent request. The flow is implicit — the first authenticated tool call triggers it on a cache miss. No explicit authenticate tool exists.
API-key mode. Set FORMIO_API_KEY. All requests attach x-token; the browser flow is skipped entirely.

Login-form auto-resolution

When FORMIO_LOGIN_FORM is unset, the server probes these candidates on the first login attempt and caches the first one that responds (1.5-second timeout per candidate):

${FORMIO_BASE_URL}/formio/user/login (portal-base)
${FORMIO_PROJECT_URL}/admin/login (project admin)
${FORMIO_PROJECT_URL}/user/login (project user)

The probe runs lazily — only when the local auth page is actually served.

Environment variables

Name	Required	Default	Purpose	Hosted SaaS example	Self-hosted example
`FORMIO_BASE_URL`	yes	—	Full base URL of your Form.io deployment.	`https://api.form.io`	`https://forms.example.com`
`FORMIO_PROJECT_URL`	yes*	—	Full URL of your Form.io project. In plugin mode, only used as the pre-filled default offered when prompting for an unmapped cwd.	`https://myproject.form.io`	`https://forms.example.com/myproject`
`FORMIO_API_KEY`	no	`undefined`	Long-lived project API key. When set, the server skips the browser login flow.	`CHANGEME`	`CHANGEME`
`FORMIO_LOGIN_FORM`	no	Auto-resolved	Override the portal login form URL used by the JWT login flow.	`https://formio.form.io/user/login`	`https://forms.example.com/formio/user/login`
`FORMIO_PLUGIN_CONTEXT`	no	`0`	Set by the plugin manifest. When `1`, the server enables `project_set` and reads `FORMIO_PROJECT_URL` from `~/.formio/projects.json` per cwd instead of env.
`FORMIO_INSECURE_TLS`	no	`false`	When `true`, skips TLS certificate verification (sets `NODE_TLS_REJECT_UNAUTHORIZED=0`) — for self-hosted deployments behind self-signed certs. Do not use against production.	—	`true`

* In plugin context, FORMIO_PROJECT_URL is captured per-cwd by the project_set tool and persisted to ~/.formio/projects.json. The verify-project-url SessionStart/PreToolUse hook offers formio_default_project_url (from plugin user-config) as the default the first time you enter a workspace.

Contributing

This is a pnpm + Turborepo monorepo: the @formio/mcp MCP server (packages/mcp-server/), the @formio/ai Claude Code plugin (plugin/, bundling the server + skill library), and the skill test suite (packages/skill-tests/). Setup, conventions, skill-authoring guidelines, and the release flow are in CONTRIBUTING.md. Security reports: SECURITY.md.

License

MIT

Reviews

No reviews yet

Be the first to review this server!

More Developer Tools MCP Servers

Git

Free

by Modelcontextprotocol · Developer Tools

Read, search, and manipulate Git repositories programmatically

Toleno

Free

by Toleno · Developer Tools

Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.

mcp-creator-python

Free

by mcp-marketplace · Developer Tools

Create, build, and publish Python MCP servers to PyPI — conversationally.

Ai MCP Server

About

Security Report

Findings (9)Action required

Permissions Required

What You'll Need

How to Install

Documentation

The Form.io Agentic Coding Toolset

Getting Started

What you get

Why this exists

Agentic Skill Library

Orchestration skills

All skills

Examples and Use Cases

Build complete applications

Build forms and wizards

Embed forms in existing applications

Work the REST API via prompt

Using the MCP server without the skills

MCP server tools

Forms

Roles

Actions

Project

Diagnostic

Authentication

Login-form auto-resolution

Environment variables

Contributing

License

Reviews

No reviews yet

More Developer Tools MCP Servers

Git

Toleno

mcp-creator-python

MarkItDown

MCP Marketplace

FinAgent