Lovable's MCP support works in two directions. Inside Lovable, connect 14+ chat connectors (Notion, Linear, Jira/Confluence, Sentry, and more) plus an open MCP registry to give the AI build-time context — personal, and never part of your published app. Separately, the Lovable MCP server (mcp.lovable.dev) lets external AI clients — officially Claude Desktop, Claude Code, Cursor, and VS Code — create, edit, and publish Lovable projects via OAuth.
| Fact | Value |
|---|---|
| Tool | MCP |
| Difficulty | Intermediate |
| Time required | 15-25 minutes |
| Compatibility | Lovable (all plans for the MCP server, Enterprise requires admin enablement); Claude Desktop, Claude Code, Cursor, VS Code as MCP clients |
| Last updated | September 2026 |
Two Directions of MCP in Lovable
MCP support in Lovable runs in two directions, and conflating them is the most common source of confusion when people search for 'lovable mcp.' The first direction is chat connectors — personal, build-time integrations (14+ as of September 2026, spanning tools like Notion, Linear, Jira/Confluence, Sentry, and PostHog) that give the AI extra context while you're actively building, without ever becoming part of your published app. An August 2026 MCP registry addition lets you go beyond the curated catalog to add other MCP servers manually.
The second direction is the Lovable MCP server itself (mcp.lovable.dev), new in 2026 — this flips the relationship, letting external AI clients like Claude or Cursor control your Lovable projects directly: creating them, sending build messages, inspecting diffs, running SQL against Lovable Cloud, and publishing. This tutorial covers both, in the order most builders actually need them: chat connectors first (useful to almost anyone building in Lovable), then the MCP server (useful mainly to developers who want to drive Lovable from an external coding environment).
Prerequisites
- An active Lovable account (any plan) with at least one project
- For chat connectors: an account with the third-party service you want to connect (Notion, Linear, etc.)
- For the Lovable MCP server direction: one of the officially supported clients — Claude Desktop, claude.ai, Claude Code, Cursor, or VS Code
- Enterprise workspaces: admin access to enable the Lovable MCP server in Security settings before it can be used
Step-by-step guide
Connect a chat connector inside Lovable
Open your Lovable project and click the Settings icon in the top-right corner of the editor. Navigate to Connectors, then find the 'Chat connectors' or 'Personal connectors' section — this is distinct from the shared/app connectors used for things like Stripe or Resend. Browse the catalog (Amplitude, Atlassian, Confidence, Granola, Hex, HeyGen, Linear, Miro, Notion, n8n, Polar, PostHog, Sanity, Sentry) and click 'Connect' next to the service you want. Each connector requires you to sign in with your own account for that service — this is a personal connection tied to you specifically, not the workspace. A team member who wants the same connector must go through their own OAuth flow separately.
Expected result: The connector shows as active with your account name or workspace next to it. You can now reference it in chat using @ followed by the connector name.
Reference the connector's content in your prompts
With a connector active, describe what you want Lovable to pull in. For Notion, reference the specific page or database you mean by name; for Linear, reference the ticket or project. Lovable's AI reads the connected content for that message and uses it as context for generating or editing your app — the connector doesn't automatically sync data into your database, it just gives the AI something concrete to read from instead of you retyping a spec by hand.
Expected result: Lovable's response reflects the actual content of the referenced Notion page or Linear ticket, not a generic guess at what an onboarding flow usually looks like.
Browse the open MCP registry for connectors beyond the curated list
If the service you need isn't in Lovable's curated 14-connector catalog, check the MCP registry, added August 24, 2026. This lets you browse directories of MCP servers beyond what Lovable officially curates and add one manually, expanding your available context sources without waiting for Lovable to add official support for a specific tool.
Expected result: You can browse and connect MCP servers outside Lovable's default 14-connector list from the same Connectors settings panel.
Add the Lovable MCP server to Claude Desktop
This is the reverse direction: instead of pulling context into Lovable, you're giving an external AI client the ability to control Lovable itself — create projects, send build messages, inspect file diffs and edit history, run SQL against your Lovable Cloud database, and publish apps. In Claude Desktop, open the connector or MCP settings and add a new remote MCP server pointing to https://mcp.lovable.dev. Claude will initiate an OAuth flow in your browser — log in with your existing Lovable account and approve the connection. Once approved, Claude has access to the tools the Lovable MCP server exposes, scoped to your Lovable account's permissions.
Expected result: Claude Desktop shows the Lovable MCP server as connected. Asking Claude to 'list my Lovable projects' or similar returns real data from your account.
Add the Lovable MCP server to Cursor or VS Code
Cursor and VS Code both support remote MCP servers via a configuration file rather than a settings UI. Add an entry for the Lovable MCP server to your MCP configuration (project-level or global, depending on your setup), pointing at the same https://mcp.lovable.dev endpoint used for Claude Desktop. On first use, your editor will prompt an OAuth login the same way Claude Desktop does — complete it in the browser window that opens. Claude Code supports the same remote server via its own MCP configuration. In every case, the underlying connection is identical — only the client-side configuration step differs.
1{2 "mcpServers": {3 "lovable": {4 "url": "https://mcp.lovable.dev",5 "transport": "http"6 }7 }8}Expected result: Your editor's MCP panel or tool list shows the Lovable server as connected after completing the OAuth login.
Verify the connection and watch credit usage
Test the connection with a low-stakes action first — asking the connected AI client to list your existing Lovable projects is a good first check, since it reads data without changing anything. Once confirmed, try a small build action, like asking Claude Code to send a single chat message to a specific Lovable project and report back what changed. Remember that every action taken through the Lovable MCP server consumes credits from your normal workspace balance, identical to using Lovable's own editor directly. Check Cloud → Usage in Lovable periodically if you're running frequent automated actions through an external client, so a script or agent loop doesn't burn through your monthly allowance unexpectedly.
Expected result: The connected AI client successfully lists or modifies a real Lovable project, and the corresponding credit usage appears in Lovable's Cloud → Usage panel.
Complete working example
1{2 "mcpServers": {3 "lovable": {4 "url": "https://mcp.lovable.dev",5 "transport": "http"6 }7 }8}Common mistakes when using MCP connectors in Lovable
Why it's a problem: Assuming a chat connector will be available to your app's end users after publishing
How to avoid: Chat connectors are explicitly personal and build-time only. If end users need a live integration, set up a shared/app connector (like the native Stripe or Resend connectors) instead — a completely different category from personal MCP chat connectors.
Why it's a problem: Trying to connect an unsupported AI client to the Lovable MCP server
How to avoid: Stick to the officially documented clients — Claude Desktop, claude.ai, Claude Code, Cursor, and VS Code. Codex CLI has been listed as 'coming soon' since the server's May 2026 launch; other clients cannot complete the OAuth flow at all per Lovable's own docs.
Why it's a problem: Expecting the Lovable MCP server to be free of credit costs because the server access itself is free on every plan
How to avoid: Server access being available on all plans (including Free) is separate from the cost of the actions it performs — every project creation, chat message, or publish action taken through the server consumes your normal workspace credits.
Why it's a problem: Vague references to connected content in prompts, like 'use my notes' instead of naming the specific document
How to avoid: Name the exact page, ticket, or document you mean. The AI can't guess which of several connected Notion pages or Linear tickets you're referring to without a specific reference.
Why it's a problem: Forgetting each teammate needs their own OAuth connection for a shared workspace
How to avoid: Chat connectors are per-person, not per-workspace. If a whole team needs Notion context available in Lovable, each member connects their own account individually.
Best practices
- Treat chat connectors as personal and per-person — each team member who wants a given connector needs to complete their own OAuth flow, since the connection is tied to the individual, not the workspace.
- Only connect services you actively reference in prompts. An idle connector adds clutter to your settings panel without adding useful context.
- Review permissions before adding a connector from the open MCP registry (Aug 2026) — registry servers aren't vetted the same way Lovable's curated 14-connector catalog is.
- Remember chat connectors never ship with your published app — if end users of your deployed app need a live integration (payments, email, analytics), use a shared/app connector instead, not a personal chat connector.
- Confirm your AI client is on Lovable's officially supported list (Claude Desktop/claude.ai, Claude Code, Cursor, VS Code) before troubleshooting an MCP server connection — unsupported clients simply cannot complete OAuth.
- Monitor Cloud → Usage after connecting the Lovable MCP server to an automated workflow, since every action it takes consumes normal workspace credits just like manual use of the editor.
Still stuck?
Copy one of these prompts to get a personalized, step-by-step explanation.
Explain the difference between an MCP 'chat connector' inside a no-code AI builder (personal, build-time only, not part of the published app) and an MCP server exposed BY that builder for external clients to control it. Use Lovable's 2026 implementation as the example, and list which official AI clients can authenticate to Lovable's own MCP server.
In Claude Code, I want to connect to Lovable's remote MCP server at https://mcp.lovable.dev using OAuth. Walk me through adding it to my MCP configuration and completing the authentication flow, and explain what tools become available once it's connected (project creation, chat messages, file diffs, SQL access, publishing).
Frequently asked questions
What does 'lovable mcp' actually mean?
It refers to two separate but related things. First, MCP chat connectors inside Lovable — personal, build-time integrations (Notion, Linear, Jira/Confluence, and 11+ others) that give the AI extra context while you're chatting, without becoming part of your published app. Second, the Lovable MCP server (mcp.lovable.dev) — the reverse direction, where external AI tools like Claude or Cursor connect to Lovable itself and can create, edit, and publish your projects programmatically. Most people searching 'lovable mcp' mean the first (connectors inside Lovable); developers automating their workflow usually mean the second.
Do MCP chat connectors become part of my published app?
No. Chat connectors are explicitly personal and build-time only — you sign in with your own account, only you (not your published app or its end users) can use the connection, and it never ships as part of the app you publish. If you need a service to work inside your deployed app (for example, sending real Stripe payments or Resend emails to your users), that's a shared or app connector, a different category entirely from the personal chat connectors covered here.
Which AI clients can control Lovable through the Lovable MCP server?
As of September 2026, Lovable's official documentation lists Claude (Desktop and claude.ai), Claude Code, Cursor, and VS Code as supported OAuth clients, with ChatGPT also mentioned. OpenAI's Codex CLI support has been listed as 'coming soon' since the server's original May 2026 launch. Official docs are explicit that other MCP clients cannot complete the OAuth authentication flow at this time — if a client isn't on this list, expect the connection to fail even if it technically speaks the MCP protocol.
Is the Lovable MCP server free to use?
The server itself is available on every Lovable plan, including Free, according to Lovable's official documentation. Enterprise workspaces require an admin to explicitly enable it in Security settings first. What isn't free: every action the connected AI client takes through the server — creating a project, sending a chat message, publishing an app — consumes credits from your normal workspace balance, exactly as if you'd done it inside Lovable's own editor.
How many MCP chat connectors does Lovable support?
The curated catalog has grown to 14+ connectors as of September 2026: Amplitude, Atlassian (bundling Jira and Confluence), Confidence, Granola, Hex, HeyGen, Linear, Miro, Notion, n8n, Polar, PostHog, Sanity, and Sentry. Beyond the curated list, Lovable added MCP registry support on August 24, 2026, letting you browse and add other MCP servers that aren't part of the official catalog.
What's a practical use case for MCP chat connectors?
Pulling existing context into your prompts instead of retyping it. Connect Notion and reference a product spec doc directly in chat rather than copy-pasting it; connect Linear and pull a ticket's acceptance criteria into a build prompt; connect Sentry and ask Lovable to look at a specific error's stack trace while fixing a bug. The connector gives the AI read access to that context for the duration of your chat session — it's a research and grounding tool, not a data pipeline.
Can I use MCP connectors and the Lovable MCP server at the same time?
Yes, and many technical builders do. A typical setup: chat connectors (Notion, Linear) are active inside Lovable's own editor for day-to-day building, while the Lovable MCP server is separately configured in Claude Code or Cursor on a developer's machine so they can trigger Lovable builds, inspect diffs, or publish changes without leaving their usual coding environment. The two run independently and don't interfere with each other. For teams standardizing this dual setup across multiple developers, RapidDev can help configure and document the workflow so it's consistent across the team.
Talk to an Expert
Our team has built 1,000+ apps. Get personalized help with your project.
Book a free consultation