Which integrations are available for this server?

Allows using Unsplash as an image source for generated presentations, documents, and social posts.

How do I use Gamma MCP Server?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Gamma MCP Server create a presentation about the benefits of renewable energy" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Gamma MCP Server

by statechangelabs

Overview Schema Source Related Servers Discussions Admin

JavaScript

Remote

Gamma MCP Server

An MCP (Model Context Protocol) server that enables AI assistants to generate Gamma presentations, documents, and social media posts using the Gamma.app API.

What is MCP?

The Model Context Protocol (MCP) allows AI assistants like Claude to interact with external tools and data sources. This server exposes Gamma's AI generation capabilities to any MCP-compatible client.

Related MCP server: Gamma MCP Server

Features

🎨 Generate presentations, documents, and social media posts
🤖 AI-powered content generation with customizable options
🎭 Theme support for consistent branding
📝 Multiple text modes: generate, condense, or preserve
🖼️ Image generation options (AI-generated or Unsplash)
📊 Export as PDF or PPTX
🌍 Multi-language support

Prerequisites

Node.js 18 or higher
A Gamma.app account with API access
Gamma API key (get one from Gamma.app API settings)

Installation & Usage

Production Mode (via NPM)

Once published to NPM, you can use the server directly with npx:

Configure your MCP client (e.g., Claude Desktop) by adding to your config file:
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
```
{
  "mcpServers": {
    "gamma": {
      "command": "npx",
      "args": ["-y", "@raydeck/gamma-app-mcp"],
      "env": {
        "GAMMA_API_KEY": "your-gamma-api-key-here"
      }
    }
  }
}
```
Restart your MCP client to load the server

Local Development / Testing Mode

For testing and development before publishing:

Clone/navigate to the repository:
```
cd /path/to/gamma-mcp
```
Install dependencies:
```
npm install
```
Build the project:
```
npm run build
```

Configure your MCP client with the local path:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "gamma": {
      "command": "node",
      "args": ["/absolute/path/to/gamma-mcp/dist/index.js"],
      "env": {
        "GAMMA_API_KEY": "your-gamma-api-key-here"
      }
    }
  }
}

Alternative using npm link:

# In the gamma-mcp directory
npm link

# Then in your MCP config:
{
  "mcpServers": {
    "gamma": {
      "command": "gamma-mcp",
      "env": {
        "GAMMA_API_KEY": "your-gamma-api-key-here"
      }
    }
  }
}

Restart your MCP client

Development Mode (with auto-reload)

For active development with TypeScript hot-reloading:

npm run dev

This runs the server directly from TypeScript source using tsx.

Configuration

Environment Variables

GAMMA_API_KEY (required): Your Gamma API key

Available Tools

`generate_gamma`

Generate AI-powered Gamma content (presentations, documents, or social posts).

Note: This tool returns a generation ID. Use the get_gamma_generation tool to automatically wait for completion and retrieve the final URLs.

Parameters

Parameter	Type	Required	Description
`inputText`	string	✅	The text content to generate from (1-400,000 characters). Can be a short prompt, messy notes, or polished content.
`textMode`	string	❌	How to process input: `generate`, `condense`, or `preserve` (default: `generate`)
`format`	string	❌	Output format: `presentation`, `document`, or `social` (default: `presentation`)
`themeName`	string	❌	Name of a specific theme to use. Only use if the user explicitly requests a custom theme by name. Theme must exist in your Gamma workspace. Omit this parameter to use Gamma's default theme selection.
`numCards`	number	❌	Number of cards/slides to generate (1-60 for Pro, 1-75 for Ultra, default: 10)
`cardSplit`	string	❌	How to split content: `auto` or `inputTextBreaks` (default: `auto`)
`additionalInstructions`	string	❌	Additional instructions for content and layout (1-500 characters)
`exportAs`	string	❌	Export format: `pdf` or `pptx`

Text Options

Parameter	Type	Description
`textOptions.amount`	string	Amount of text per card: `brief`, `medium`, `detailed`, or `extensive`
`textOptions.tone`	string	Tone of voice for the content
`textOptions.audience`	string	Intended audience
`textOptions.language`	string	Output language code (e.g., 'en', 'es', 'fr')

Image Options

Parameter	Type	Description
`imageOptions.source`	string	Image source: `aiGenerated` or `unsplash`
`imageOptions.model`	string	AI model to use for image generation
`imageOptions.style`	string	Artistic style for generated images

Card Options

Parameter	Type	Description
`cardOptions.dimensions`	string	Card dimensions: `fluid`, `16x9`, or `4x3`

Parameter	Type	Description
`sharingOptions.workspaceAccess`	string	Workspace access level

Example Usage

When using with Claude or another MCP client:

Create a 10-slide presentation about "The Future of AI" with a professional tone, 
targeted at business executives, using medium text amount and AI-generated images.

The AI will use the tool like this:

{
  "inputText": "The Future of AI - covering trends, opportunities, and challenges",
  "format": "presentation",
  "numCards": 10,
  "textOptions": {
    "amount": "medium",
    "tone": "professional",
    "audience": "business executives"
  },
  "imageOptions": {
    "source": "aiGenerated"
  }
}

`get_gamma_generation`

Retrieve the status and URLs of a Gamma generation. Automatically polls every 5 seconds until generation is complete (recommended by Gamma API).

Parameters

Parameter	Type	Required	Description
`generationId`	string	✅	The generation ID returned from `generate_gamma`
`pollUntilComplete`	boolean	❌	Whether to automatically poll until complete (default: `true`)
`maxWaitSeconds`	number	❌	Maximum wait time in seconds when polling (default: `300` = 5 minutes)

Automatic Polling (Default Behavior)

By default, the tool automatically polls every 5 seconds until the generation is complete or fails:

✅ Follows Gamma API recommendation (5-second intervals)
✅ Returns final URLs when ready
✅ Times out after 5 minutes (configurable)
✅ Simple single tool call - no manual polling needed

Response

The tool returns a JSON response containing:

Status: pending, processing, completed, or failed
URL: Link to the generated Gamma (editable in Gamma app)
Export URLs: PDF or PPTX download links (if requested during generation)

Example Usage

Automatic polling (recommended):

{
  "generationId": "abc123"
}

Waits until complete and returns final URLs

Custom timeout:

{
  "generationId": "abc123",
  "maxWaitSeconds": 600
}

Waits up to 10 minutes

Single status check (no polling):

{
  "generationId": "abc123",
  "pollUntilComplete": false
}

Returns current status immediately without waiting

Response Format

`generate_gamma` Response

Returns a JSON response from the Gamma API containing:

Generation ID (use with get_gamma_generation)
Initial status

`get_gamma_generation` Response

Returns:

Current status (pending, processing, completed, failed)
Gamma URL (when completed)
Export links for PDF/PPTX (if requested)

Development Workflow

Project Structure

gamma-mcp/
├── src/
│   └── index.ts          # Main server implementation
├── dist/                 # Compiled JavaScript output
├── package.json          # NPM package configuration (includes mcpName for registry validation)
├── server.json           # MCP registry metadata
├── tsconfig.json
└── README.md

Note: The server.json file is required for publishing to the MCP Registry. It contains metadata about your server including its namespace (io.github.statechangelabs/gamma-app-mcp), package information, and deployment configuration.

Building

npm run build

This compiles TypeScript to JavaScript in the dist/ directory.

Validating server.json

Before publishing to the MCP registry, you can validate your server.json:

npm run validate

This checks that your server.json has all required fields and is properly structured for the MCP registry.

Testing Locally

Make changes to src/index.ts
Run npm run build to compile
Restart your MCP client to reload the server
Test with your AI assistant

Publishing to NPM

When ready to publish:

Update version in package.json and server.json:
```
npm version patch  # or minor, or major
```
Then update the version field in server.json to match.
Build the project:
```
npm run build
```
Publish to NPM:
```
npm publish --access public
```
Users can then install via:
```
npx @raydeck/gamma-app-mcp
```

Publishing to the MCP Registry

After publishing to NPM, you can publish to the official MCP registry to make your server discoverable:

Install the MCP Publisher CLI:

# macOS/Linux with Homebrew
brew install mcp-publisher

# Or download pre-built binaries from:
# https://github.com/modelcontextprotocol/registry/releases

Authenticate with GitHub (for io.github.* namespaces):
```
mcp-publisher login github
```
Publish to the registry:
```
mcp-publisher publish
```

Verify publication:

curl "https://registry.modelcontextprotocol.io/v0/servers?search=io.github.statechangelabs/gamma-app-mcp"

For detailed instructions, see the official publishing guide.

Troubleshooting

Server not starting

Verify GAMMA_API_KEY is set correctly in your MCP config
Check that Node.js version is 18 or higher
Ensure the path in your config is absolute and correct

API Errors

Verify your Gamma API key is valid
Check that you have sufficient API credits
Review Gamma API documentation for parameter requirements

MCP Client Not Detecting Server

Ensure the config JSON is valid (use a JSON validator)
Restart your MCP client after config changes
Check client logs for error messages

Resources

License

ISC

Author

Ray Deck

Support

For issues and questions:

GitHub Issues: Create an issue
Gamma API Support: Gamma Help Center

Available Tools

2 tools

generate_gammaA

Generate a Gamma presentation, document, or social media post using AI. Requires GAMMA_API_KEY environment variable to be set. The inputText parameter is required and should contain the content you want in your slides. Supports various customization options including format, theme, number of cards, text options, image options, and more.

ParametersJSON Schema

Name	Required	Description	Default
`format`	No	The output format type	presentation
`exportAs`	No	Export the generated content as PDF or PPTX
`numCards`	No	Number of cards/slides to generate (1-60 for Pro, 1-75 for Ultra)
`textMode`	No	How to process the input text. 'generate' creates new content from a prompt, 'condense' summarizes the input, 'preserve' keeps the input text mostly as-is.	generate
`cardSplit`	No	How to split content into cards. 'auto' lets AI decide, 'inputTextBreaks' uses line breaks in input.	auto
`inputText`	Yes	The text content to generate from (1-100,000 tokens / ~1-400,000 characters). Can be a short prompt, messy notes, or polished content.
`themeName`	No	Name of a specific theme to use. ONLY use if the user explicitly requests a custom theme by name. Theme must exist in your Gamma workspace. Omit this parameter to use Gamma's default theme selection.
`cardOptions`	No	Card layout options
`textOptions`	No	Options for text generation
`imageOptions`	No	Options for image generation/sourcing
`sharingOptions`	No	Sharing and access options
`additionalInstructions`	No	Additional instructions to guide content and layout (1-500 characters)

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden. It discloses the API key requirement and mandatory inputText, which are useful behavior expectations. However, it does not describe what the tool returns (likely a generation ID or resource), whether it is asynchronous, error conditions, or any side effects. This is a generation tool with no output schema, so some return-value or workflow context is missing.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three sentences long and fairly efficient. It front-loads the purpose and then adds the API key requirement and inputText note. The final sentence listing customization options is somewhat redundant with the schema but still provides a helpful high-level summary. It is not overly verbose and earns its place, though it could be slightly tighter.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has high complexity (12 parameters, nested objects, no output schema), and the description gives a useful overview but leaves gaps: it doesn't explain what the generated output looks like or how to retrieve it, which is especially relevant given the sibling 'get_gamma_generation'. The rich schema compensates for parameter-level detail, but for a generation tool, the missing workflow context (e.g., returns an ID, asynchronous) makes it incomplete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, providing detailed explanations for every parameter. The description's mention of 'format, theme, number of cards, text options, image options' merely restates what the schema already documents, adding no new meaning or constraints. The baseline of 3 applies because the schema does the heavy lifting, and the description doesn't supplement it.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('Generate') and resource ('Gamma presentation, document, or social media post'), clearly distinguishing it from the sibling tool 'get_gamma_generation'. It also indicates the AI-driven generation nature, leaving no ambiguity about the tool's core function.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives clear context: it requires the GAMMA_API_KEY environment variable and the inputText parameter is required with expected content. It implies this tool is for creating new content, while the sibling 'get_gamma_generation' likely retrieves existing content, but it never explicitly says 'use this when you want to create, use get_gamma_generation to retrieve'. This is clear context without explicit exclusions or alternative naming.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_gamma_generationA

Retrieve the status and URLs of a Gamma generation. By default, automatically polls every 5 seconds until generation is complete (recommended). Returns the final URLs to the generated Gamma, plus PDF/PPTX export URLs if requested. Supports both automatic polling (default) and single status checks.

ParametersJSON Schema

Name	Required	Description
`generationId`	Yes	The generation ID returned from the generate_gamma tool. This is used to check the status and retrieve URLs for the generated content.
`maxWaitSeconds`	No	Maximum time in seconds to wait for generation to complete when polling. Default: 300 (5 minutes). Only used when pollUntilComplete is true.
`pollUntilComplete`	No	Whether to automatically poll every 5 seconds until the generation is complete. Recommended: true (default). Set to false to only check status once.

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Without annotations, the description carries the full burden and does well by disclosing the polling interval (every 5 seconds), the default behavior, and the return of final URLs and optional export URLs. It does not mention timeout handling or error scenarios, but the core behavior is transparent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise, front-loaded, and every sentence earns its place. It conveys purpose, default behavior, alternatives, and return contents in just two sentences without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a polling tool with no output schema, the description adequately explains what is returned and how polling works. It does not detail status values or error handling, and the phrase 'if requested' is slightly ambiguous, but overall it is complete enough for an agent to use the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema already provides complete and clear descriptions for all three parameters, covering generationId, maxWaitSeconds, and pollUntilComplete. The description adds no additional parameter-specific semantics beyond what the schema already provides, so baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves the status and URLs of a Gamma generation, using a specific verb and resource. It distinguishes this from the sibling tool generate_gamma by focusing on retrieval and status checking.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly recommends automatic polling by default and notes the alternative of single status checks, giving clear guidance on when to use each mode. It does not explicitly mention the sibling tool, but the context of retrieving versus generating is implied strongly.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

2 tool updatesv1.0.1Aug 9, 2026
- First observedgenerate_gamma
- First observedget_gamma_generation

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A4/5.0

Scored 2026-08-09 21:30 across 2 tools

Disambiguation5/5

The two tools have clearly distinct purposes: one initiates a generation and the other retrieves its status/results. There is no overlap or ambiguity between them.

Naming Consistency5/5

Both tool names follow a consistent verb_noun pattern: generate_gamma and get_gamma_generation. The naming is predictable and grammatically consistent.

Tool Count3/5

With only 2 tools, the server feels minimal and borderline for its stated purpose. While the tools cover the core generate-and-retrieve workflow, the server would benefit from additional tools such as listing templates or canceling generations.

Completeness4/5

The two tools provide a complete lifecycle for a single generation request: create and retrieve. Minor gaps exist such as no update or delete functionality, but these are not critical for the primary use case of generating content.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

Need Help?

Related Servers

Related MCP Connectors

MagicSlidesOAuth
io.github.theindianappguy
Create presentations, docs, sheets and meeting notes from chat. Hosted link, editor, PPTX & PDF.
Workplace & Productivity Design Tools Content Management Systems
1
presentationsOAuth
com.getalai
Generate, edit, and export AI presentations to PDF, PPTX, or a shareable link.
App Automation Workplace & Productivity Design Tools
25
NexDoc Design AOAuth
design.nexdoc.mcp
Give your AI agents a design superpower. Generate, edit, and publish publication-grade decks, reports, landing pages, resumes, and marketing visuals directly within your agent workflow. Delivering frontier-level design quality at 3× the speed and 53× lower cost -from conversational prompt to live link or vector PDF in minutes.
Design Tools Marketing
161
GRTwo DocsOAuth
io.github.grtwo-jcansler
Publish and share Markdown/HTML docs from AI assistants. Requires grtwo.app Pro. OAuth or API key.
Content Management Systems Documentation Access
2

Related MCP Servers

Gamma MCP Server
Content Management Systems Workplace & Productivity App Automation
sarafina98
A
license
Not graded
quality
D
maintenance
Enables AI-powered generation of presentations, documents, and webpages through the Gamma API. Supports theme selection, folder management, and automatic export to PowerPoint or PDF formats.
Updated 10 months ago (2025-11-12 01:54 UTC)
7 npm
MIT
Gamma MCP Server
Content Management Systems Workplace & Productivity App Automation
isakskogstad
F
license
Not graded
quality
Not graded
maintenance
Enables AI assistants to generate presentations, documents, and webpages through the Gamma.app API with support for custom themes, tones, audiences, and image generation.
Updated 10 months ago (2025-11-19 05:40 UTC)
7 npm
-
gamma-app-mcp
Workplace & Productivity Marketing
cphoskins
A
license
A
quality
C
maintenance
Enables generating presentations, documents, webpages, and social posts via Gamma's API with full parameter surface including templates, folders, headers/footers, and email sharing.
Updated 5 months ago (2026-04-09 00:17 UTC)
6
MIT
Gamma MCP Server
AI & Machine Learning Content Management Systems Marketing
Themoneyhollic
A
license
Not graded
quality
D
maintenance
Enables generating AI-powered presentations via the Gamma API directly from MCP clients like Claude for Desktop.
Updated a year ago (2025-05-14 21:19 UTC)
7 npm
MIT

Gamma MCP Server

What is MCP?

Features

Prerequisites

Installation & Usage

Production Mode (via NPM)

Local Development / Testing Mode

Development Mode (with auto-reload)

Configuration

Environment Variables

Available Tools

generate_gamma

Parameters

Text Options

Image Options

Card Options

Sharing Options

Example Usage

get_gamma_generation

Parameters

Automatic Polling (Default Behavior)

Response

Example Usage

Response Format

generate_gamma Response

get_gamma_generation Response

Development Workflow

Project Structure

Building

Validating server.json

Testing Locally

Publishing to NPM

Publishing to the MCP Registry

Troubleshooting

Server not starting

API Errors

MCP Client Not Detecting Server

Resources

License

Author

Support

Available Tools

TDQS

TDQS

Tool Schema Changelog

TDQS

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

Gamma MCP Server

Gamma MCP Server

gamma-app-mcp

Gamma MCP Server

`generate_gamma`

`get_gamma_generation`

`generate_gamma` Response

`get_gamma_generation` Response