Overview

Slidespeak MCP Server is a lightweight API server designed to automate the creation, styling, and export of PowerPoint presentations. It exposes a simple HTTP API that accepts structured slide definitions (text, layout hints, speaker notes, and styling instructions) and returns generated presentation files (PPTX/PDF) or export URLs. This makes it suitable for workflows that need programmatic slide generation from data, templates, or AI-generated content.

The server is useful when you want to integrate slide generation into pipelines — for example, generating lecture slides from outlines, converting meeting notes to a deck, or programmatically batching exports for reporting. It supports configurable styling, templating, and export formats so you can maintain consistent brand and visual standards across generated decks.

Features

HTTP API for creating and exporting PowerPoint (PPTX) and PDF files
JSON-based slide specification (titles, content, speaker notes, layout/style hints)
Template and style support for consistent branding
Export endpoints that return downloadable files or presigned URLs
Run locally, in Docker, or as part of CI/CD pipelines
Simple API key authentication and configurable environment variables
Extensible to integrate with AI services or custom content generators

Installation / Configuration

Clone the repository and run locally with Node.js (Node 16+ recommended):

git clone https://github.com/SlideSpeak/slidespeak-mcp.git
cd slidespeak-mcp
npm install
npm run build
npm start

Run with Docker:

# build
docker build -t slidespeak/mcp .

# run
docker run -it --rm -p 3000:3000 \
  -e MCP_API_KEY="your_api_key_here" \
  -e PORT=3000 \
  slidespeak/mcp

Example docker-compose.yml:

version: "3.8"
services:
  mcp:
    image: slidespeak/mcp:latest
    ports:
      - "3000:3000"
    environment:
      - MCP_API_KEY=${MCP_API_KEY}
      - PORT=3000

Common environment variables

Variable	Description	Default
MCP_API_KEY	API key for server authentication	(required)
PORT	HTTP port to listen on	3000
TEMPLATES_DIR	Directory for slide templates	./templates
OUTPUT_DIR	Where generated files are stored	./output

API Surface (Available Resources)

Below is a concise list of typical endpoints you’ll find in the MCP server.

Method	Path	Description
POST	/generate	Generate slides from a JSON specification (returns job id or file)
POST	/export	Request export of an existing slide job to PPTX/PDF
GET	/status/:id	Check job/export status
GET	/download/:file	Download generated file
GET	/health	Health check

Authentication: include the API key as a Bearer token:

Authorization: Bearer <MCP_API_KEY>

Request/response formats use JSON. Large exports may return an asynchronous job id you can poll via /status.

Example Usage

Generate a deck in one request (synchronous small job):

curl example:

curl -X POST "http://localhost:3000/generate" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $MCP_API_KEY" \
  -d '{
    "title": "Weekly Metrics",
    "slides": [
      {"title": "Overview", "content": "This week we saw growth in X.", "notes": "Call out top-line metrics", "layout": "title-content"},
      {"title": "Details", "content": "Metric A: 123\nMetric B: 456", "layout": "bullet"}
    ],
    "template": "corporate-template.potx",
    "export": {"format": "pptx"}
  }'

Python example (requests):

import requests, os
api_key = os.getenv("MCP_API_KEY")
payload = {
  "title": "Project Update",
  "slides": [
    {"title": "Summary", "content": "Progress update...", "layout": "title-content"}
  ],
  "export": {"format": "pptx"}
}
r = requests.post("http://localhost:3000/generate", json=payload,
                  headers={"Authorization": f"Bearer {api_key}"})
print(r.json())

Typical response (synchronous):

{
  "status": "done",
  "file": "/download/weekly-metrics-2026-04-10.pptx"
}

Asynchronous job pattern:

POST /generate -> returns job id
GET /status/:id -> returns {status: “pending” | “running” | “done”, file: “…” }
GET /download/:file -> retrieve binary PPTX

Use Cases

Automated report generation: Produce weekly or monthly performance decks from data pipelines (CSV → JSON → slides).
AI-assisted slide authoring: Combine LLM-generated content with templates to produce finished slides programmatically.
LMS integration: Generate course presentation materials on-demand from lesson plans or markdown content.
Meeting automation: Turn meeting notes into a shareable slide deck with speaker notes for distribution.
Batch exports: Convert hundreds of templated reports into PPTX/PDF in CI for archival or distribution.

Tips for Developers

Keep slide content concise and use layout hints to improve automated placement.
Use templates (.potx) placed in the TEMPLATES_DIR to ensure brand consistency.
For large exports, prefer asynchronous export flows and poll /status to avoid HTTP timeouts.
Validate your JSON against the server’s spec (look for an OpenAPI or example schema in the repo) before sending large batches.

Available Tools / Resources

GitHub repo: https://github.com/SlideSpeak/slidespeak-mcp
Example templates and sample payloads (see the /examples folder in the repo)
OpenAPI spec (if included) for client code generation
Docker image for quick local deployment

This server is intended to be an integration point in developer workflows — use it as a building block to automate slide creation, standardize presentation output, and streamline export processes.

Slidespeak MCP Server PowerPoint Presentation API