> ## Documentation Index
> Fetch the complete documentation index at: https://docs.lovable.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Chat connectors: Connect your tools to Lovable using MCP servers

> Connect your own tool accounts to Lovable as chat connectors (MCP servers). Lovable reads real context from tools like Notion, Linear, Jira, or Miro while you build, so results match your actual work.

A **chat connector (MCP server)** connects one of your own tool accounts to the Lovable chat. Once connected, Lovable can look things up in that tool while it builds for you: your Notion docs, your Linear tickets, your Miro boards. You describe what you want, and Lovable grounds the result in your real content instead of guessing.

Chat connections are **personal**. You sign in with your own account, only you can use the connection, and it never becomes part of the app you publish. Chat connectors are built on **MCP (Model Context Protocol)**, an open standard that connects AI systems like Lovable to external tools. You don't need to know anything about MCP to use them.

Lovable includes prebuilt chat connectors for popular tools and supports [custom MCP servers](/integrations/custom-mcp) on all plans.

## Why use chat connectors

Chat connectors unlock two key capabilities:

* **Bring your existing context into Lovable.**\
  Lovable can read your team’s documentation, tickets, and design files to build prototypes and flows aligned with your standards.
* **Connect your work in Lovable back to your workflows.**\
  Lovable can take follow-up actions in your connected tools, such as updating ticket statuses, adding prototype links as comments, or creating new items when supported.

Lovable becomes more powerful when it understands your team’s world, eliminating guesswork and speeding up iteration.

Here is what that looks like in practice:

| **Scenario**                                               | **Example prompt**                                               | **Example outcome**                                                                                                    |
| :--------------------------------------------------------- | :--------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------- |
| A **product manager** connects **Linear** or **Jira**      | *Generate a prototype based on tickets in the current sprint.*   | Lovable reads issue descriptions and acceptance criteria to build aligned, testable UI.                                |
| A **marketer** connects **Notion** or **Confluence**       | *Turn our Q4 campaign brief into a landing page.*                | Lovable uses the document as context to generate an on-brand, editable page.                                           |
| A **designer** connects **Miro**                           | *Prototype the signup flow from our whiteboard.*                 | Lovable reads flow diagrams to scaffold UI navigation and turns them into an interactive prototype your team can test. |
| An **engineer** connects **n8n** or an internal MCP server | *Build a workflow UI that lists users and allows deleting them.* | Lovable builds an app that uses live data and workflows.                                                               |

## How chat connectors relate to Lovable's other MCP features

Lovable uses MCP in three different ways, each connecting a different system for a different purpose. Chat connectors bring **external tools into Lovable** as context while you build.

| Feature                                                | Direction                   | What it does                                                                 |
| ------------------------------------------------------ | --------------------------- | ---------------------------------------------------------------------------- |
| **Chat connectors** (this page)                        | Lovable uses external tools | Lovable pulls context from services such as Notion or Linear while you build |
| [Lovable MCP server](/integrations/lovable-mcp-server) | AI tools build in Lovable   | External AI tools create, edit, and manage your Lovable projects             |
| [Agent integrations](/features/agent-integrations)     | AI assistants use your app  | Your users' assistants call the actions you expose in your published app     |

## How chat connections work

Chat connections behave differently from the other connection types in a few important ways:

* **Personal to you.** You connect with your own account, and only you can use or manage the connection. Teammates who want the same tool connect their own accounts.
* **Chat only.** Lovable uses the connection while you build. It is never included in your published app, and your app's visitors can never reach the connected tool through it. If your published app itself needs the tool, use an [app + chat connector](/integrations/app-connectors).
* **Read first, act when supported.** Lovable can read structured content such as docs, issues, and diagrams. Where the tool supports it, Lovable can also take limited actions, such as creating or updating items.
* **Available on all plans, everywhere you build.** Once connected, the tool is available as context across your projects. Workspace admins can manage which chat connectors are available, described under [Managing chat connectors](#managing-chat-connectors-in-your-workspace).

## Prebuilt chat connectors

Lovable includes prebuilt chat connectors for these tools. Expand one to see what connecting it unlocks:

<AccordionGroup>
  <Accordion title="Amplitude: product analytics and feedback">
    **Turn user behavior into better product decisions.**

    Bring product insights, user funnels, and feedback into Lovable so you can iterate on flows, optimize layouts, and run experiments with a simple prompt. See the [Amplitude MCP docs](https://amplitude.com/docs/amplitude-ai/amplitude-mcp).
  </Accordion>

  <Accordion title="Atlassian: Jira issues and Confluence pages">
    **Turn product documentation into working prototypes.**

    Lovable can read product documentation and linked Jira epics (PRDs, specs, architecture docs) to generate prototypes that match your team’s standards. Embed generated prototypes back into Confluence for feedback. See the [Atlassian MCP docs](https://support.atlassian.com/atlassian-rovo-mcp-server/docs/getting-started-with-the-atlassian-remote-mcp-server/).
  </Accordion>

  <Accordion title="Confidence: feature flags and experiment data">
    **Build and iterate with real experimentation context.**

    Lovable can evaluate feature flags, read experiment results, and incorporate rollout logic into your apps, helping you ship features that are informed by real user experiments. See the [Confidence MCP docs](https://confidence.spotify.com/docs/sdks/mcp-servers).
  </Accordion>

  <Accordion title="Granola: meeting notes, decisions, and action items">
    **Turn meeting context into specs and tickets.**

    Lovable can search across past meetings, pull out decisions and action items, and use what was agreed to generate PRDs, user stories, or follow-up tasks, without digging through notes. See the [Granola MCP docs](https://docs.granola.ai/help-center/sharing/integrations/mcp).
  </Accordion>

  <Accordion title="Hex: notebooks and workspace data">
    **Build apps powered by real analysis and data workflows.**

    Lovable can query Hex notebooks, explore datasets, and use results as context to generate data-driven apps, dashboards, and workflows aligned with your existing analyses. See the [Hex MCP docs](https://learn.hex.tech/docs/administration/mcp-server).
  </Accordion>

  <Accordion title="HeyGen: AI avatars, voices, and video generation">
    **Generate AI avatars and videos directly from your Lovable apps.**

    Lovable can use HeyGen to create AI-generated avatar videos, voiceovers, and personalized video content as part of your apps and workflows. See the [HeyGen MCP docs](https://developers.heygen.com/mcp/overview).
  </Accordion>

  <Accordion title="Linear: issues and project data">
    **Prototype from real issues and tickets.**

    Lovable can read Linear issues, including descriptions and acceptance criteria, to generate functional prototypes. Attach resulting apps back to Linear for review. See the [Linear MCP docs](https://linear.app/docs/mcp).
  </Accordion>

  <Accordion title="Miro: boards and diagrams">
    **Bring your boards to life.**

    Lovable can convert user flows, wireframes, or information architecture from your boards into interactive prototypes you can test and export back for feedback. See the [Miro MCP docs](https://miro.com/ai/mcp/).
  </Accordion>

  <Accordion title="Notion: pages and databases">
    **Build directly from your team’s Notion workspace.**

    Lovable can read PRDs, design specs, or marketing briefs and turn them into working apps, landing pages, or prototypes. Embed generated Lovable apps back into Notion for seamless collaboration. Need your published app to read or write Notion while people use it? Use the [Notion app + chat connector](/integrations/notion) instead. See the [Notion MCP docs](https://developers.notion.com/docs/mcp).
  </Accordion>

  <Accordion title="n8n: automation workflows">
    **Build workflow-rich apps with live data.**

    Connect your n8n automations to Lovable to pull data from tools like HubSpot, Google Sheets, or Slack, and build user-facing apps powered by existing automations. See the [n8n MCP docs](https://docs.n8n.io/advanced-ai/mcp/accessing-n8n-mcp-server/).
  </Accordion>

  <Accordion title="Polar: billing, products, customers, and subscriptions">
    **Build subscription-enabled apps with real billing context.**

    Lovable can use your Polar setup as context when scaffolding SaaS apps, checkout flows, pricing pages, subscription management, and customer billing experiences. See the [Polar MCP docs](https://polar.sh/docs/integrate/mcp).
  </Accordion>

  <Accordion title="PostHog: product analytics data">
    **Turn product analytics into better features.**

    Lovable can query user behavior, analyze funnels and events, and use real usage insights to generate flows, features, and improvements grounded in how users actually interact with your product. See the [PostHog MCP docs](https://posthog.com/docs/model-context-protocol).
  </Accordion>

  <Accordion title="Sanity: CMS content and schemas">
    **Build content-driven apps with your CMS data.**

    Lovable can read your Sanity documents, schemas, and structured content to generate apps, landing pages, and content management interfaces aligned with your content model. See the [Sanity MCP docs](https://www.sanity.io/docs/ai/mcp-server).
  </Accordion>

  <Accordion title="Sentry: issues, errors, and project insights">
    **Debug and monitor your apps with real error data.**

    Lovable can read Sentry issues, exceptions, and performance data to help you identify and fix problems faster. See the [Sentry MCP docs](https://docs.sentry.io/product/sentry-mcp/).
  </Accordion>
</AccordionGroup>

## How to add a prebuilt chat connector

To connect a prebuilt chat connector:

<Steps>
  <Step title="Select the connector">
    Open [**Connectors**](https://lovable.dev/dashboard?connectors) and select a chat connector, for example Notion or Linear. See [Where to find connectors](/integrations/introduction#where-to-find-connectors) for every place you can open the catalog.
  </Step>

  <Step title="Add a connection">
    Click **Add connection**. If the connector supports more than one connection type, choose **Chat connector**.
  </Step>

  <Step title="Authorize">
    Sign in and grant Lovable access to your account.
  </Step>
</Steps>

### Additional setup for specific chat connectors

**[n8n](https://docs.n8n.io/advanced-ai/mcp/accessing-n8n-mcp-server/)**

In addition to these steps, you need to do the following in n8n:

* Go to **Settings → MCP access** and toggle **Enable MCP access** (requires instance owner or admin permissions)
* For each workflow you want to expose, go to **Settings** in the workflow editor and toggle **Available in MCP.**

**[Amplitude](https://amplitude.com/)**

If you plan to analyze your Lovable-built app, make sure it is already sending data to Amplitude before using the connector. See the [Amplitude Quickstart guide](https://amplitude.com/docs/get-started/amplitude-quickstart) for setup instructions.

**[Hex](https://learn.hex.tech/docs/administration/mcp-server)**

Hex requires you to provide a custom server URL when connecting. For most users, the default URL is `https://app.hex.tech/mcp`. If you are on a single-tenant, EU multi-tenant, or HIPAA multi-tenant instance, replace `app.hex.tech` with your custom Hex domain (for example, `https://your-company.hex.tech/mcp` or `https://eu.hex.tech/mcp`).

## Custom MCP servers

If a tool isn't in the catalog but offers an MCP server, you can still connect it. Custom MCP servers bring internal or third-party systems into Lovable as chat connectors, which is perfect for private APIs, internal CRMs, or custom data sources. See [Connect a custom MCP server](/integrations/custom-mcp) for setup steps, authentication options, and admin controls.

## Managing chat connectors in your workspace

Chat connections are personal, so you review or revoke your own connections anytime in [**Connectors**](https://lovable.dev/dashboard?connectors), which you can also reach from inside a project, as described in [Where to find connectors](/integrations/introduction#where-to-find-connectors).

Chat connectors, including custom MCP servers, are enabled by default on all plans, including Enterprise.

On Business and Enterprise plans, workspace admins and owners can turn chat connectors off for the whole workspace or disable individual ones. See [Chat connector controls](/integrations/admin-controls#chat-connector-controls) for the settings and where to find them.

## FAQ

<AccordionGroup>
  <Accordion title="Can my teammates use my chat connection?">
    No. Chat connections are personal, so only you can use and manage yours. Teammates who want the same tool connect it themselves with their own accounts.
  </Accordion>

  <Accordion title="Is a chat connection part of my published app?">
    No. Chat connections only give Lovable context while you build. Your published app and its visitors can never reach the connected tool through them. If your app itself needs the tool, use an [app + chat connector](/integrations/app-connectors).
  </Accordion>

  <Accordion title="What's the difference between a chat connector and an app + chat connector?">
    A chat connector (MCP server) uses your own account, is personal to you, and works only in the chat. An app + chat connector runs on one shared account and also works in your published app. The [decision table](/integrations/introduction#which-connection-type-do-i-need) on the overview shows when to pick each one.
  </Accordion>

  <Accordion title="Why can't I connect a chat connector?">
    A workspace admin may have disabled the connector, custom MCP servers, or all chat connectors for the workspace. See [Chat connector controls](/integrations/admin-controls#chat-connector-controls) for the settings and ask an admin to check them.
  </Accordion>
</AccordionGroup>