Using the MCP Server to Let Agents Build Presentations

Why let an AI agent build your next deck

The blank slide still kills momentum. You open PowerPoint, Keynote, or Google Slides, and the first thing you face is an empty canvas. Hours drift by as you drag text boxes, tweak alignment, and search for a font that does not make your startup look like a template factory. By the time the deck is finished, it often looks like a patchwork of different voices, none of them quite matching the brand you have spent months sharpening.

The fix is not a smarter template. It is a protocol that lets any AI agent hand off the heavy lifting to a presentation engine that knows your brand. That protocol is the Model Context Protocol, or MCP. Preso ships an MCP server that exposes a complete presentation builder your agents can call directly. Instead of describing slides to a chatbot and then copying text into a slide editor, you give an agent a prompt and a destination, and the agent instructs Preso to design, build, and deliver a finished, on-brand deck.

This guide walks through the whole flow: what the MCP server is, how to set it up, how to wire your agent to it, and how to go from a one-line prompt to an editable, exportable deck. You will see concrete setups for founder pitch decks, sales decks, and quarterly business reviews. By the end, you will know how to make your AI agent a presentation builder that speaks your brand language.

Prerequisites

Before you start, make sure you have:

• A Preso account. You can sign up and define your brand kit (colors, fonts, logos) so every generated deck comes out on-brand.
• Access to Preso's MCP server endpoint. Preso speaks the Model Context Protocol both ways: it ships an MCP server so external clients can reach your agents, and it lets your agents use any MCP server, tool, API or database, scoped and governed.
• An AI agent or client that supports MCP. Currently, several platforms can act as MCP clients: Claude (via the Claude Desktop app or API), Microsoft Copilot, custom agents built on OpenAI, and others. You can also use the Preso API directly if you are building a headless workflow.
• Basic familiarity with JSON and command-line tools (for the client configuration), but no deep engineering is required for the standard setup.

Pro tip: If you are building a product and want to offer presentation generation to your users, you can bypass the MCP client setup and call the Preso REST API directly. The MCP server is designed for agent-driven workflows; the REST API is ideal for embedding deck generation into your own app. Read more about headless presentations to see which approach fits.

How MCP connects agents to presentation tools

MCP is an open protocol that standardizes how AI agents discover and use external tools. Instead of every agent requiring a custom integration for each service, MCP defines a server that exposes a set of resources, tools, and prompts. The agent describes what it wants to do, and the MCP server interprets that into actions on your behalf.

When you point an MCP client at Preso's MCP server, the client sees preso's available tools: create_presentation, add_slide, apply_brand, generate_narrative, add_voiceover, export_deck, and others. The agent can call these tools in sequence, passing parameters like the slide content, the target audience, the desired language, and the brand identifier.

The official MCP introduction explains the protocol architecture — servers provide tools, clients discover them, and LLMs decide which tools to invoke to satisfy a user request. For presentation building, this means an agent can reason about structure, then use Preso's engine to render slides with professional design, not just text on a blank background.

OpenAI's announcement of MCP highlighted how agents can now orchestrate complex tasks across tools. Microsoft's integration with Copilot shows enterprise scenarios where agents pull data from meetings, emails, and spreadsheets, then push a finished deck to Preso for design. AWS, Google Cloud, and others have published similar guides (see AWS, Google Cloud), confirming MCP is becoming the standard for tool-augmented agents.

Step 1: Get access to Preso's MCP server

First, log into your Preso account. Navigate to the MCP section of the dashboard. You will find your unique MCP server endpoint URL and an API key. Preso's MCP server is a hosted service; you do not need to deploy anything yourself. The endpoint is secure, and every request is authenticated.

If you prefer to build programmatically without an agent, the Preso API documentation walks you through the same capabilities via REST. But for agent-driven creation, MCP is the cleaner abstraction.

Copy the endpoint URL and the API key. You will plug these into your MCP client configuration in the next step.

Warning: Treat your API key like a password. Never commit it to public repositories. Use environment variables or a secure secrets manager when configuring your agent.

Step 2: Configure your AI agent to talk to Preso

Most MCP clients accept a JSON configuration file that lists servers and their credentials. The exact file depends on the client. For example, Claude Desktop uses a claude_desktop_config.json file. Microsoft Copilot and other platforms have their own configuration managers. The general shape is:

{
  "mcpServers": {
    "preso": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-preso"],
      "env": {
        "PRESO_API_KEY": "your-api-key-here"
      }
    }
  }
}

If you are using a custom agent built on an LLM that supports MCP tool calling, you can reference the Claude AI help guide on MCP for specifics on how Claude handles tool discovery. The key point is that your agent must be able to invoke tools over the protocol.

Once the configuration is in place, restart your agent client. When you ask the agent something like, "What presentation tools do you have access to?", it should list Preso's tool set. That confirms the connection is live.

Pro tip: For teams, you can share the same Preso MCP endpoint with multiple agents, each using its own API key. Permissions are scoped to the Preso workspace, so all decks generated by your agents stay inside your account, ready for review.

Step 3: Define the presentation prompt and parameters

Now the fun part: you tell the agent what deck you need. The prompt can be as short as a single sentence, or as detailed as a multi-paragraph brief. Because Preso's engine understands plain English, you can describe the purpose, audience, tone, and any specific slides you want.

For instance, to generate a seed-stage investor pitch deck for a SaaS startup:

"Create a 10-slide investor pitch deck for a B2B SaaS startup called MetricsStack that just closed a seed round. The deck should cover the problem, solution, market size, traction (MRR growth, logo count), team, and ask. Use a clean, modern brand style with navy blue and neon green. Add a 2-minute voiceover narration in English."

The agent will parse this, discover that Preso can handle it, and send a sequence of tool calls. The result is a fully designed deck, not a bunch of bullet points on white slides.

For more controllable output, you can break the request into explicit tool calls. For example, you could ask the agent:

1. create_presentation with the brand ID and a title.
2. add_slide with content for each section.
3. apply_brand to ensure consistency.
4. generate_narrative to add the voiceover script.
5. export_deck to produce a PowerPoint file.

Most users will let the agent handle the orchestration. The important part is that the agent knows your brand parameters and the narrative arc you want. Preso's engine handles the design rules, so you do not have to specify font sizes or layout details.

For inspiration, look at the deck templates library. These blueprints cover investor decks, sales decks, QBRs, webinars, and more. Each template is built to work both in the editor and via the API/MCP. You can reference a blueprint in your prompt by name, for example: "Use the investor seed deck blueprint from Preso."

Step 4: Trigger deck generation from your agent

With the prompt ready, instruct your agent to build the deck. In Claude, you might type, "Build the deck I just described using the preso tool." The agent will respond with status updates: "Generating slide 1 of 10..." and so on. If anything is ambiguous, the agent may ask for clarification, which you can provide conversationally.

Behind the scenes, Preso's engine is constructing slides with a proprietary layout algorithm that respects design principles. It places key metrics visually, selects appropriate chart types for data, and adds AI-generated imagery only where it makes sense. Because the engine is taught your brand's visual identity, the output always uses your colors, fonts, and logo treatment.

This process takes a few seconds for a standard deck. For very long presentations, it may take slightly longer, but you can always check the progress in your Preso dashboard. All generated decks appear in your "Decks" list, whether created via MCP, the REST API, or the plain English to deck editor.

If your agent is part of an automated workflow (say, a monthly report for sales teams), you can set up a trigger that fires the prompt on a schedule. Preso's triggers feature lets you generate decks programmatically from events: a new row in a database, a webhook call, or a CRM stage change. Combining MCP with triggers means you can have an agent monitor data sources and produce decks as soon as something changes.

Step 5: Review and refine the deck in the Preso editor

Just because an agent built the deck does not mean you cannot touch it. Every deck created through the MCP server is a fully editable Preso document. Open it in the Preso editor and you will see a familiar slide-by-slide view where you can:

• Edit text inline.
• Swap out AI-generated images for your own.
• Adjust charts and data tables.
• Reorder or delete slides.
• Add speaker notes.
• Record or refine the AI voiceover.

This dual-mode workflow — agent for the heavy lifting, editor for the fine tuning — gives you the speed of automation with the control of a professional presentation tool. Founders who iterate investor decks endlessly can now generate v1 in seconds, then spend their time on storytelling, not alignment.

Pro tip: Use the voiceover feature to add natural narration in any language. The MCP tool generate_narrative writes a script that sounds human, not robotic. You can then have a voice actor record it or use Preso's text-to-speech to produce a polished audio track. This is especially useful for asynchronous pitches or training webinars.

Step 6: Export or share the final deck

When the deck is ready, you have several output options. The MCP tool export_deck can produce:

• PowerPoint (.pptx)
• Google Slides
• PDF
• Preso web link (with secure sharing and tracking)

In the editor, the export menu offers the same formats. If you built the deck via an agent and want to send it straight to a team member, you can share a Preso link that controls viewing permissions. That way, stakeholders see the latest version without drowning in email attachments.

For headless workflows, the export step can be automated. The MCP server can deliver the exported file to cloud storage, email, or a content management system via integration with Zapier or custom webhooks. For example, a retail buyer pitch deck generated from Shopify data (like this wholesale template) can export as PDF and land in the buyer's inbox minutes after the data triggers the build.

Use cases that move the needle

Let's ground this in real workflows.

Startup fundraising: Founders often spend weeks polishing a pitch deck. With MCP, a founder can connect Claude or another agent to their CRM and Notion workspace. The agent pulls in the latest traction numbers, team bios, and market research, then instructs Preso to build the deck using the SaaS investor deck template. The result is a data-accurate, beautifully designed deck in minutes, not days. If an investor asks for a variant tailored to their fund thesis, the founder just tweaks the prompt.

Sales and marketing teams: A sales manager can define a prompt that turns a CRM opportunity into a client-ready proposal. The agent reads the deal amount, industry, and decision-maker role, then generates a deck with the right case studies and pricing options. Preso's engine automatically picks the most relevant slides from the marketing strategy blueprint or the e-commerce brand launch template depending on your vertical.

Hospitality and events: A hotel group can schedule an MCP agent to monitor its property management system. When a new group lead comes in, the agent triggers a deck using the venue sales proposal template and the property showcase template, combining room photos, floor plans, and pricing. The deck is emailed to the event planner automatically.

Enterprise training: A learning and development team asks an agent to build a 40-slide onboarding deck for new hires. The agent pulls policy documents from a internal wiki, summarizes them into slides, and adds a voiceover in the employee's preferred language. The deck is exported to Google Slides for the HR team to review, but the design is consistent and on-brand.

For businesses already using AI agents to automate workflows, adding presentation generation closes a gap that wastes hours every week. Zapier's guide on MCP agents automating presentations shows how teams are connecting multiple apps this way. Notion's technical blog demonstrates pulling structured data from Notion databases and turning it into slides with a single command.

Integrating MCP with your existing stack

Preso's MCP server is not a standalone tool; it fits into a broader automation landscape. If you already use tools like Make, Zapier, or custom Node scripts, you can use the REST API in parallel with MCP. For example, a webhook from your CRM could trigger a Zap that calls the Preso API, or an MCP agent could watch for new records and kick off deck generation.

For SaaS products that want to offer presentation generation natively, Preso's triggers and API let you embed the engine directly. The SaaS & Startups page gives a good overview of how product-led companies are using this to auto-generate investor updates from their product metrics dashboards.

The API documentation covers authentication, endpoints, and webhook events. The MCP layer adds an abstraction that agents understand natively, so you can mix and match: use MCP for conversational agents, and the REST API for scheduled, server-side generation.

Security, governance, and brand control

When you let an agent build decks, you want to ensure the output never drifts off-brand. Preso's MCP server enforces brand settings at the workspace level. Every deck generated inherits the brand kit you defined: logo, color palette, typography, and even image style guidelines. The agent cannot override these; it can only specify which brand to use if you have multiple brands in your workspace.

Governance goes further if you choose to scope the MCP server's capabilities. You can limit which tools are available to a given agent, restrict exports to certain formats, or require a human approval step before a deck is sent externally. These controls live in your Preso workspace settings.

All data in transit is encrypted via TLS, and your API keys never leave your control. Since you host nothing, there is no infrastructure to patch or maintain.

Key takeaways

• MCP is the bridge: It lets any compatible AI agent call Preso's presentation tools as if they were native functions. This avoids the copy-paste grind and ensures every deck is designed, not just assembled.
• Prompts are the new slide builder: Instead of moving shapes, you describe the story and your brand. The engine handles the visual execution.
• You stay in control: Every deck is editable in the Preso editor. You can tweak content, swap images, and record voiceovers after the agent finishes.
• Automation scales: With triggers and the API, you can generate hundreds of personalized decks for clients, investors, or trainees without increasing headcount.
• On-brand every time: Brand settings are enforced at the workspace level, so your agents cannot produce off-brand output.

If you are still spending Friday afternoons aligning text boxes in PowerPoint, let your agent do the heavy lifting. Set up Preso's MCP server, connect it to your favorite AI assistant, and turn a prompt into a polished deck today.

Start building with Preso