Cursor FORMLOVA Guide -- From IDE MCP Setup to Form Creation, Publishing, and Operations

Last updated: May 18, 2026

Cursor has stopped being just an editor. It is where you read pull requests, prototype features, and let an agent do the boring parts of your release. What it does not do out of the box is collect the feedback form, write the auto-reply, and post new submissions into Slack. Adding one MCP server removes that boundary.

FORMLOVA exposes a remote Model Context Protocol server that Cursor registers from its Settings UI or from .cursor/mcp.json at the project root. Pick the GUI path for a one-time setup on your own machine; pick the JSON path when you want the connector to ship with the repository so every teammate gets it on clone. Either way, the next step is talking to Cursor's Agent in the same window where you write code -- "Create a post-release feedback form" -- and a private draft comes back with a preview URL. This guide covers both paths, the project versus global decision, the Agent-mode constraint, the publish review, the operations that follow, and where Cursor, Claude Desktop, and Claude Code each belong in your stack.

The Two-Path Setup -- What This Guide Covers

There are three things to do before Cursor's Agent can build forms for you.

1. Add FORMLOVA as an MCP server. Either open Cursor Settings > MCP > Add new MCP server and paste https://formlova.com/api/mcp, or drop a .cursor/mcp.json file at the project root with the same URL.
2. Click Reconnect so a browser tab opens for OAuth. Sign in to FORMLOVA, approve the scopes, and the tab closes itself.
3. Open the chat panel, switch to Agent mode, and say "Create a post-release feedback form." A private draft and a preview URL come back in the same reply.

That is the whole setup, usually under five minutes. Cursor supports remote MCP servers natively, FORMLOVA authenticates through OAuth, and the configuration is portable enough to share via git. The rest of this article covers the decisions that make the workflow durable: where to write the config, why Agent mode matters, how to refine a draft, how the publish review works, and which client belongs to which moment.

How Cursor Adds MCP Servers -- And How It Differs From Claude Desktop / Claude Code

MCP, the Model Context Protocol, is an open standard that lets an AI client talk to outside systems through a named tool interface. The model does not screen-scrape your form service; it calls structured tools and receives structured results.

Cursor manages MCP servers in two places that share the same configuration: the Settings UI under Cursor Settings > MCP > Add new MCP server (renamed Tools & MCP in some recent builds as of May 2026), and the JSON config files at .cursor/mcp.json for a project or ~/.cursor/mcp.json for your account. Anything added through one surface shows up in the other.

Claude Desktop's MCP setup is GUI-only and per-machine. Claude Code's is a one-liner -- claude mcp add -- that writes into .mcp.json or ~/.claude.json. Cursor sits between the two: the GUI of Claude Desktop with the project-file portability of Claude Code, plus one trait the others do not share -- a chat-mode switch that decides whether MCP tools are reachable at all.

That mode switch is the most important thing to know about Cursor's MCP. MCP tools are callable only in Agent mode. They do not appear in Ask mode, in Cmd+K Quick Edit, or in any other chat surface. Forget this and the FORMLOVA tools look "missing" even after a clean install.

The mechanical differences are small. The workflow consequence is not. Coding, reviewing, and shipping the form that asks "how was the release?" all happen in the same window. The deeper reasoning for putting form work next to publish is in Most form tools stop at creation.

GUI Setup: Adding the Server From Cursor Settings

The steps below are the same on macOS, Windows, and Linux. Cursor needs to be a recent build that supports remote MCP servers; update before continuing if your install predates that.

1. Confirm the FORMLOVA MCP Server URL

FORMLOVA exposes one URL for every MCP client.

https://formlova.com/api/mcp

No trailing slash. No /api/sse -- that was an older transport convention and is not the FORMLOVA endpoint. Whether you connect Cursor, Claude Desktop, Claude Code, ChatGPT, or Gemini CLI, this is the URL. If you do not have a FORMLOVA account yet, sign up on the FORMLOVA setup page first; the OAuth screen in step 3 needs an account to sign in to.

2. Add the Server in Cursor Settings

Open Cursor, click the gear icon in the top right, and choose Cursor Settings. In the sidebar pick MCP (or Tools & MCP in newer builds, as of May 2026). Press Add new MCP server and enter:

Name: formlova
URL: https://formlova.com/api/mcp

The Name is a display label, so use anything you will recognize. Press Add and a new entry appears in the MCP server list.

The entry is registered but still unauthenticated. The next step is the OAuth handshake that connects Cursor to your FORMLOVA account.

3. Authorize with OAuth

Click Reconnect (or Authenticate) on the FORMLOVA row. A browser tab opens automatically, you sign in to FORMLOVA, and the OAuth approval screen lists the scopes Cursor is requesting. Press Authorize, the tab closes itself, and the row turns green to indicate connected.

Close Settings, open the chat panel, switch the mode selector to Agent, and the full surface -- 128 tools across 25 categories spanning forms, responses, analytics, emails, webhooks, workflows, and recipes -- is reachable from your prompts. You do not need to memorize any of them. Cursor's Agent picks the right tool from what you ask, and most days you touch two or three.

JSON Setup: Writing .cursor/mcp.json Directly

Skip the GUI when the connector should ship with the repository -- the "clone the repo, open it in Cursor, get FORMLOVA wired up automatically" experience.

Create a .cursor directory at the project root and add mcp.json inside it:

{
  "mcpServers": {
    "formlova": {
      "url": "https://formlova.com/api/mcp"
    }
  }
}

Save the file and reload the Cursor window. The FORMLOVA entry appears in Cursor Settings > MCP exactly as if you had added it through the GUI. Press Reconnect once to walk through OAuth, and the connector is ready.

The mcpServers key is a map, so additional MCP servers sit alongside FORMLOVA in the same file. If your team already uses a GitHub or Supabase MCP server, append the new entry next to them. A practical pattern: commit shared, project-related servers (FORMLOVA, GitHub, your database MCP) into .cursor/mcp.json; add personal or experimental servers through the Settings UI so they stay out of git.

Project Level vs Global Level -- Where Your Config Lives

This is the part of Cursor that has no direct counterpart in Claude Desktop. The same FORMLOVA entry can sit in one of two locations, and the choice decides whether your team shares the connector or it follows you across every project on your machine.

Project level lives in .cursor/mcp.json at the project root -- a .cursor directory next to your package.json or pyproject.toml. Commit it to git and every teammate sees the FORMLOVA connector the moment they open the project. The right choice for any form that belongs to the project itself: post-release feedback, beta signup, a contact form for the shipped product.

Global level lives in ~/.cursor/mcp.json. Every project you open with Cursor on this machine inherits the connector. Use this for forms that travel with you rather than with the codebase: a blog reader survey, a portfolio inquiry form, an ad-hoc event signup.

If both files define the same server name, the project-level entry wins. That makes it safe to keep a global default while a specific project pins its own version. Different server names coexist side by side.

OAuth credentials are stored per-user regardless of where the config lives. Even when .cursor/mcp.json is committed and the whole team uses the same project-scoped connector, every teammate signs in with their own FORMLOVA account on first use. Sharing the configuration never means sharing the permissions.

In practice, project-level .cursor/mcp.json in git is the cleanest pattern for any team that runs FORMLOVA alongside the product. New members clone, open Cursor, click Reconnect once, and the form work joins the same flow as the code.

Drafting a Form in Cursor Agent Mode

Open Cursor's chat panel and switch to Agent mode. This is the Cursor-specific gate: MCP tools are callable only in Agent mode, not in Ask mode or Cmd+K Quick Edit. If FORMLOVA tools look invisible after a clean setup, the mode selector is the most likely cause.

Short prompts are enough -- no long specification needed on the first message.

Create a post-release feedback form.

The Agent calls the FORMLOVA creation tool, picks a sensible starting field set, and returns a private draft plus a preview URL.

Created a private post-release feedback form draft.

Fields:
- Overall satisfaction (required, 5-point scale)
- Most valuable feature in this release (required, select)
- What would you like us to improve (optional, long text)
- Any bugs to report (optional, long text)
- Email for follow-up (optional)
- Consent to data use (required)

Preview URL: https://formlova.com/preview/...

Open the preview URL in a side-by-side browser tab or in Cursor's built-in browser. You see what a respondent will see: title, field order, required and optional badges, consent checkbox, submit button. The refinement loop is short and specific.

Add a heading "About this release" above the satisfaction question.
Cap the "improve" field at 500 characters.
Add helper text under email: "Optional. Only fill in if you want a reply."

Each instruction lands as a tool call; reopen the same preview URL to see the latest state. You are reacting to a live preview rather than writing a spec in your head. The general "from one prompt to a draft" workflow that works in any MCP client is in ChatGPT form builder guide -- create a private draft from one short prompt.

Reviewing the Preview Before Publishing

Asking Cursor to publish does not publish the form immediately. FORMLOVA runs a server-side checklist, and if any blocking item is missing the response comes back with the gaps and preview URLs instead of a public URL.

Publish this form.

A typical first reply:

There are items to confirm before publishing.

- Preview URL: https://formlova.com/preview/...
- Thank-you page preview: https://formlova.com/preview/.../thankyou
- Duplicate submission prevention: not set
- Privacy policy URL: not set
- Sales-email auto-detection: not confirmed (text input fields present)

Walk through both preview URLs as a respondent, then return to Cursor and answer the blocking items in one message.

Both previews look good. Prevent duplicate submissions by email.
Privacy policy URL: https://example.com/privacy.
Enable sales-email detection.
Publish now.

The Agent requests a confirmation token, the FORMLOVA server validates the checklist, and the form publishes. The handshake is enforced server-side, so the publish call refuses to act on missing blockers regardless of what the client says. The full review flow with annotated screenshots is in Review a form before publishing.

Post-Publish Operations From Inside the IDE

Most tutorials end when the form goes live. The actual work begins right after, when responses arrive and operational tasks pile up. Cursor keeps that work inside the same window the engineering team already uses for code.

Filter and Triage Responses

When a release ships, responses arrive in bursts. Reading every row is rarely the right move -- ask the Agent for a slice that fits the next decision.

Show this week's feedback with satisfaction of 3 or lower.
List only the responses that mention bugs and summarize them.
Exclude likely sales pitches and show only real feedback.

Each request returns a structured table in the Agent pane. Click into a response, change its status, or add an internal note from the same chat. Because the relevant code is open in the same window, the jump from "interesting feedback" to "open the file, write the fix, raise a GitHub issue" stays in one place. The See-Route-Act loop is covered in How to view, filter, and manage form responses.

Tune Auto-Reply Emails

On the standard plan and higher, auto-reply emails are fully customizable. For a post-release form, "Thanks for the feedback -- we'll consider it for the next release" is usually the right tone.

Update this form's auto-reply to say
"Thanks for using the new release. We'll review your feedback for the next iteration."
Open with "Thanks for trying the release."
Sign it from the engineering team.
Send a test to my address when you're happy with it.

The Agent shows the proposed copy as a preview and asks, "Save this version?" Nothing changes on the live form until you say yes -- a careless auto-reply edit is the kind of mistake every recipient sees in their inbox.

Add Automations from Workflow Place

When the request becomes "I want this to happen automatically," look at Workflow Place -- the shared catalog of FORMLOVA recipes. Some run entirely inside FORMLOVA; others orchestrate other MCP servers like Slack, HubSpot, or Notion.

Find a workflow recipe that posts new feedback responses to Slack.
Show me recipes that send a follow-up email three days after submission.

The Agent lists candidates, you pick one, and the recipe's prompt template applies to your form. Because Cursor is an IDE, you can annotate the relevant code with a comment that points back to the new automation without leaving the window. The full reading order is in How to find and apply Workflow Place recipes from chat.

Claude Desktop vs Claude Code vs Cursor -- When to Use Each

The three clients reach the same FORMLOVA server with the same URL, and the 128 tools across 25 categories are identical. What changes is where the conversation lives and how the configuration travels.

In practice: post-release feedback forms fit Cursor because the people who own them already have the IDE open for the release; release-operation forms run from Claude Code because the engineer scripting the release is already in the terminal; general inquiry forms fit Claude Desktop because non-engineer teammates handle most of the responses. The GUI walkthrough is in Claude Desktop FORMLOVA Guide -- From Connector Setup to Form Operations; the CLI walkthrough is in Claude Code FORMLOVA Guide -- From One CLI Command to Form Creation, Publishing, and Operations.

Troubleshooting -- Cursor-Specific Failure Modes

Most issues fall into a small set of buckets, different from the Claude Desktop and Claude Code ones.

The FORMLOVA row is red in Settings. Confirm the URL is exactly https://formlova.com/api/mcp -- no trailing slash, no /api/sse. Press Reconnect; if that fails, delete the entry and add it again.

Agent mode does not see the FORMLOVA tools. Double-check the mode selector at the top of the chat panel. MCP tools are reachable only in Agent mode; Ask mode and Cmd+K Quick Edit do not see them. This is the most common cause of "the connector is connected but nothing works."

You edited .cursor/mcp.json but Cursor has not picked up the change. Cursor reads MCP configuration at window load. Reload the window (Cmd+Shift+P -> Reload Window), or quit and relaunch.

An "Unauthorized" error appears mid-conversation. The OAuth session expired. Press Reconnect on the FORMLOVA row, complete OAuth again, and retry.

The OAuth browser tab never opens. A popup blocker is the most common cause. Allow popups for formlova.com and try Reconnect again.

The Agent replies in English even though you typed in another language. That preference lives in your FORMLOVA profile. Say "Set my profile language to English" (or "Japanese") in chat and the next reply switches. The full list against the live product is on the FORMLOVA setup page troubleshooting section.

Plan Boundary -- What Each Tier Unlocks

Connecting Cursor works on every FORMLOVA plan. Differences show up in what the tools can do after the connection. Prices are in JPY because FORMLOVA bills in JPY; your bank handles the conversion if you pay from another currency.

The free plan covers the end-to-end evaluation: create a feedback form, run the publish review, collect responses, export to CSV, triage from inside the IDE. Teams usually upgrade to standard the first time they want to rewrite the auto-reply or schedule reminders. Premium comes in when bulk sends, paid events, or shared audit logs arrive.

FAQ

Why are FORMLOVA tools only callable in Agent mode?

That is how Cursor's chat surface is structured as of May 2026. MCP tools are wired into the Agent runtime, not into Ask mode or Cmd+K Quick Edit. If the connector shows as connected in Settings but the Agent does not see its tools, switch the mode to Agent and try the prompt again. Cursor evolves quickly, so this constraint may relax in newer builds -- check the official Cursor MCP documentation if your version looks different.

What happens if both .cursor/mcp.json and ~/.cursor/mcp.json define the same server name?

The project-level entry in .cursor/mcp.json takes precedence. That makes it safe to keep a default in ~/.cursor/mcp.json for personal use while a specific project pins its own version inside the repository. Different server names coexist, so you can run several MCP servers from both locations as long as their names are unique.

Do I need Cursor Pro to use MCP?

No. Cursor supports MCP servers on its free tier. Cursor's own plan tiers affect model selection, request limits, and certain Agent-mode capabilities, but the MCP connector itself is not gated. FORMLOVA's plan tiers are independent -- connecting works on the free plan, and standard or premium upgrades unlock the features in the plan boundary table above.

Will the FORMLOVA connector clash with VS Code extensions or Copilot?

No. MCP servers run at the Cursor layer rather than as VS Code extensions. Copilot, lint extensions, and language servers continue to work as before, and the FORMLOVA tools appear inside the Agent pane while the rest of the editor stays unchanged.

Can I run several MCP servers in .cursor/mcp.json at the same time?

Yes. The mcpServers key is a map, so each server is a top-level entry. Many teams keep a GitHub MCP server, a database MCP server, and FORMLOVA side by side in the same file -- Cursor reads the merged list at startup and routes each request to the right server based on what you ask the Agent.

Can Cursor publish a form or delete data without my approval?

No. Any operation with real-world impact -- publish, unpublish, delete, send bulk email, send a filtered reply -- is gated server-side. FORMLOVA returns a confirmation token request and refuses to act unless the call carries explicit approval. The protection is enforced by the FORMLOVA MCP server, not the model's prompt, so it works even if the Agent misreads your message.

Related Articles

• MCP Form Service Guide -- From AI Creation to Form Operations
• Claude Desktop FORMLOVA Guide -- From Connector Setup to Form Operations
• Claude Code FORMLOVA Guide -- From One CLI Command to Form Creation, Publishing, and Operations
• ChatGPT Form Builder Guide -- Create a Private Draft Form From One Short Prompt
• Review a Form Before Publishing with FORMLOVA
• Find a Recipe in Workflow Place and Set It Up From Chat

Try FORMLOVA on the free plan

References

• Cursor: Model Context Protocol (accessed 2026-05-18)
• Cursor: Cursor Settings (accessed 2026-05-18)
• Model Context Protocol: Introduction (accessed 2026-05-18)
• FORMLOVA setup guide (accessed 2026-05-18)

Disclosure and Verification

This guide is written by the FORMLOVA development team. The Cursor connection steps were verified against Cursor's official Model Context Protocol documentation, Cursor's Settings documentation, the Model Context Protocol specification, and the FORMLOVA setup page on May 18, 2026, then walked through end to end against the live product before publication. Cursor's Settings UI labels (including the recent Tools & MCP rename), the Agent-mode constraint, and the configuration file paths can change on Cursor's side without notice; before adopting this workflow for production use, confirm the current state in the linked Cursor documentation.