How to connect a Gamma MCP to Cursor (4 steps)

Gamma's API isn't something you can guess your way through.

Before you can write a generator, an exporter, or a sync that keeps a deck up to date, you need to see what the API actually returns, and that usually means leaving the editor for a scratch script or an API client.

To help your developers query Gamma data without leaving Cursor, we'll show you how to connect Gamma with Merge Agent Handler's Gamma MCP server.

How it works

Merge Agent Handler connects Cursor to the Gamma API through the Merge CLI.

You'd install the CLI, authenticate once, and run a single setup command from your project root.

That command writes a ## Merge CLI section to your project's .cursorrules file, which tells Cursor's agent when to call merge search-tools and merge execute-tool to reach Gamma.

Merge will manage your Gamma API key on your behalf, so it never lives in your project files or your local environment.

Related: How to use the Gamma MCP in Claude Code

Prerequisites

Before getting started, you'll need the following:

• A Merge Agent Handler account
• Cursor installed
• pipx installed (run pipx --version to confirm, or install via pip install pipx)
• A Gamma account with API access enabled

If you want to connect Merge Agent Handler's Gamma MCP with internal or customer-facing agentic products, you can follow the steps in our docs.

1. Install the Merge CLI

Add the Merge CLI to your environment with pipx: pipx install merge-api

Confirm the installation succeeded: merge --version

2. Log in to Merge

Connect the CLI to your Merge Agent Handler account: merge login

This links the CLI to your account so Merge can make authorized requests against Gamma on your behalf.

3. Connect the CLI to Cursor

Run the following from the root of the project where you want to use Merge tools:

merge setup cursor

This writes a ## Merge CLI section to .cursorrules so Cursor knows to use the CLI for third-party services. The command is idempotent, so it's safe to re-run if you need to reset.

Related: How to integrate a Gamma MCP with Codex

4. Authenticate Gamma

Open a Cursor chat in your project and run a query like:

Kick off a test deck generation from a short outline and show me the full response, including the job status field and the export URL once it's ready, so I can model the response type correctly before I write the poller.

The first time you invoke a Gamma tool, a Magic Link will appear to complete connector authentication.

{{this-blog-only-cta}}

Gamma MCP FAQ

In case you have more questions on setting up and using the Gamma MCP in Cursor, we've addressed several more commonly-asked questions below.

What can you do once the Gamma MCP is connected to Cursor?

With Gamma connected, Cursor can:

• Inspect a generation job's response before writing the poller: kick off a deck generation request and see the real status field and how it transitions, so your polling logic checks the right value instead of a guess

• Resolve theme IDs before hardcoding them: pull the list of available themes to get their real IDs, since the API references themes by ID rather than the name shown in the Gamma editor

• Check the export response shape before writing the download handler: request an export and see exactly how the format and download URL come back, before you write the code that fetches it

• Inspect a deck object before writing a parser: retrieve a deck to see the exact fields it returns, title, URL, slide count, status, so your types match the API instead of an assumption

• Validate pagination on a real workspace listing: list decks in a workspace to see how the pagination cursor is returned before you implement your pagination loop

Why use Merge Agent Handler vs. a self-hosted Gamma MCP server?

You can build your own MCP server that calls the Gamma API directly. For a solo developer generating decks from their own workspace, that's a workable starting point: get an API key, write the tool schemas you need, and wire it to Cursor.

The friction shows up once more than one person needs it, or the decks contain sensitive content. Gamma's API key model means a self-hosted setup either shares one key across everyone using it or leaves each developer to manage their own, and there's no built-in way to limit which operations a given agent can reach.

Merge Agent Handler centralizes Gamma authentication and adds a control layer on top.

You can scope which Gamma operations a given agent is allowed to call, so a tool built to inspect deck structure for testing doesn't also get access to generation or export, and every call is logged with the timestamp, tool name, and inputs.

Why connect Gamma to Cursor?

Developers writing code against Gamma have to understand its API model before the code works correctly: an async generation job with a status field to poll, exports that return a download URL in a specific shape, and themes referenced by ID rather than name.

That structure is documented, but reading about it isn't the same as seeing what a real API call returns.

With the Gamma MCP connected, Cursor can pull real Gamma responses directly in the chat panel. You can kick off a generation job while writing the poller that will watch it, request an export while writing the handler that downloads it, or resolve a theme ID while writing the call that references it.

The data your code depends on and the code itself live in the same session, which cuts the round-trip to a separate API client or scratch script.

Can I use Merge's Gamma MCP with my employees?

Yes, Merge for Workforce is built to help organizations provision, secure, and govern how employees connect AI tools like Cursor to systems like Gamma.

Common patterns include:

• Provisioning and access control via SCIM with identity providers like Okta and Microsoft Entra ID, so IT can manage which employees can generate or edit Gamma decks by role or team

• DLP and policy enforcement on tool calls, so admins can restrict which workspaces or folders an employee's AI can reach before a deck is created or exported

• User-level audit logging so security and IT teams can review which decks were generated, exported, or updated, by which employee identity, and when

Put together, employees can use the Gamma MCP to generate decks, check export status, validate deck structure while building internal tools, and more, while IT keeps centralized control over which workspaces and operations each identity can reach.