Generate PowerPoint Presentations with Claude via Poesius MCP: Developer Guide

Poesius provides a native Model Context Protocol (MCP) integration that allows Claude, Cursor, and other MCP-compatible AI clients to generate consulting-grade PowerPoint presentations directly from a conversation or agentic workflow. No platform switching, no manual export step—Claude can call Poesius's tools to create a fully formatted .pptx file and return a download link.

This guide covers the MCP setup, available tools, and practical workflows for developers and teams building AI-powered presentation pipelines.

What is MCP?

The Model Context Protocol (MCP) is an open standard for AI assistants to connect with external tools and data sources. Instead of AI being limited to conversational output, MCP allows AI models to call tools, retrieve resources, and take actions in external systems.

Poesius's MCP server exposes presentation generation as callable tools, so Claude can generate a full consulting-grade PPTX file as part of a conversation or agentic workflow.

Available Poesius MCP Tools

list_templates

Returns the available presentation templates for the authenticated account.

Tool: list_templates
Input: (none)
Output: Array of template objects with id, name, description, and thumbnail URL

Use this first to identify which template to use for generation.

generate_slides

End-to-end slide generation from content input. Accepts document text, structured outline, or combined research notes and generates a complete, formatted PPTX.

Tool: generate_slides
Input:
  - content: string (document text, outline, or research notes)
  - template_id: string (from list_templates)
  - slide_count: integer (optional; default determined by content)
  - narrative_style: "pyramid_principle" | "scqa" | "hypothesis_driven" (optional)
Output:
  - job_id: string
  - status: "processing" | "complete" | "error"
  - download_url: string (when complete)

generate_narrative

Two-step workflow, step 1: Generate a consulting-structured narrative from content. Returns a narrative object that can be reviewed and refined before slide generation.

Tool: generate_narrative
Input:
  - content: string
  - framework: "pyramid_principle" | "scqa" | "mece" (optional)
Output:
  - narrative: object (governing_idea, supporting_arguments[], evidence[])
  - slide_plan: object (slide titles, chart types, structure)

create_slides_from_narrative

Two-step workflow, step 2: Generate slides from a refined narrative object. Use after generate_narrative and any human refinement of the narrative.

Tool: create_slides_from_narrative
Input:
  - narrative: object (from generate_narrative or custom)
  - template_id: string
Output:
  - job_id: string
  - download_url: string (when complete)

refine_slides

Adjust an existing presentation based on feedback. Accepts a job_id and refinement instructions; returns an updated PPTX.

Tool: refine_slides
Input:
  - job_id: string
  - refinements: string (natural language description of changes)
Output:
  - job_id: string (new job)
  - download_url: string (when complete)

Setting Up Poesius MCP

Prerequisites

• Poesius account with API access enabled (app.poesius.com)
• API key from your Poesius account settings
• MCP-compatible AI client (Claude Desktop, Cursor, or custom MCP client)

Claude Desktop Configuration

Add Poesius to your Claude Desktop MCP configuration file:

{
  "mcpServers": {
    "poesius": {
      "command": "npx",
      "args": ["-y", "@poesius/mcp-server"],
      "env": {
        "POESIUS_API_KEY": "your-api-key-here"
      }
    }
  }
}

Location of config file:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

After configuration, restart Claude Desktop and Poesius tools will be available in the tool menu.

Cursor Configuration

In Cursor, add the Poesius MCP server through Settings > Features > MCP Servers. Provide the same server configuration as above.

Custom MCP Client

For custom implementations, use the MCP SDK to connect to the Poesius MCP server:

import { Client } from "@modelcontextprotocol/sdk/client/index.js";

const client = new Client({
  name: "poesius-client",
  version: "1.0.0"
});

// Connect to Poesius MCP server
await client.connect(transport);

// List available tools
const tools = await client.listTools();

// Call generate_slides
const result = await client.callTool({
  name: "generate_slides",
  arguments: {
    content: "...",
    template_id: "consulting-standard",
    narrative_style: "pyramid_principle"
  }
});

Practical Workflows

Workflow 1: Research-to-presentation (one-step)

Ask Claude to generate a presentation from research materials:

User: "Generate a 15-slide strategy presentation from this market research report [paste content]. Use our consulting template and structure it with Pyramid Principle."

Claude (with Poesius MCP):

1. Calls list_templates to identify available templates
2. Calls generate_slides with content and pyramid_principle narrative style
3. Returns download link to completed PPTX

Total time: 3-5 minutes for generation, zero manual work.

Workflow 2: Narrative review (two-step)

For complex presentations where narrative structure should be reviewed before generation:

Step 1: "Generate the narrative structure for a competitive analysis presentation. Our key thesis is that we should acquire Company X. The research is [paste content]."

Claude: Calls generate_narrative, returns governing idea, MECE supporting arguments, evidence map, and slide plan.

Step 2 (after human review): "The narrative looks right. Generate the slides from this narrative using the M&A template."

Claude: Calls create_slides_from_narrative with the approved narrative.

Workflow 3: Agentic pipeline (automated)

For teams building automated presentation pipelines:

import anthropic
import json

client = anthropic.Anthropic()

# Step 1: Generate with MCP tools
response = client.messages.create(
    model="claude-opus-4-5",
    max_tokens=4096,
    tools=[...],  # Poesius MCP tools
    messages=[{
        "role": "user",
        "content": f"Generate a quarterly business review presentation from this data: {report_data}"
    }]
)

# Extract download URL from tool call response
for block in response.content:
    if block.type == "tool_result":
        download_url = json.loads(block.content)["download_url"]

Workflow 4: Refinement loop

For iterative improvement:

Round 1: Generate initial presentation Review: Download and review in PowerPoint Round 2: "The financial analysis slide needs to show a waterfall bridge rather than a bar chart. The competitive positioning should be more aggressive. Make these changes."

Claude: Calls refine_slides with the original job_id and refinement instructions.

REST API Alternative

If you prefer to call Poesius directly without MCP, the REST API provides equivalent functionality:

Base URL: https://poe.poesius.com/api/v1

Authentication: Bearer token (API key)

Key endpoints:

• POST /generate — Submit document and template, returns job_id
• GET /status/{job_id} — Check generation status
• GET /download/{job_id} — Download completed PPTX
• GET /templates — List available templates

Full API documentation: https://docs.poesius.com/

Frequently Asked Questions

Does Poesius MCP work with Claude.ai (the web app)?

MCP tools are currently available in Claude Desktop and MCP-compatible clients. Claude.ai (web) may gain MCP tool support in future releases. Check Anthropic's documentation for the current status.

Can I use Poesius MCP from within Cursor for code documentation presentations?

Yes. Cursor supports MCP tools and can call Poesius to generate presentations from code documentation, architecture decisions, or technical specifications.

What file formats does Poesius output?

Poesius outputs .pptx (PowerPoint format) files. These are fully editable in PowerPoint, Keynote (with conversion), and Google Slides (with import).

How do I specify my company template via MCP?

Use list_templates first to get the ID of your company template, then pass that template_id to generate_slides or create_slides_from_narrative. Templates are configured in your Poesius account at app.poesius.com.

Is there rate limiting on MCP tool calls?

Rate limits depend on your Poesius plan tier. Individual plans have lower limits; enterprise plans have higher or custom limits. Contact Poesius for enterprise rate limit information.

Related Resources

• Poesius API Documentation
• Get Started with Poesius
• Poesius REST API for PowerPoint Generation
• MCP Overview: Model Context Protocol for AI Workflows