Carousels MCP from Houtini
Converts articles and transcripts into 1080x1080 PNG slides at 2x resolution specifically formatted for Instagram.
Turns markdown notes and documentation into structured multi-slide carousel presentations.
Utilizes Puppeteer to render SVG slide designs into final PDF and PNG formats for social media distribution.
Generates slide layouts in SVG format, allowing for the injection of custom charts and diagrams into specific slides.
Generates 1080x1350 PNG slides optimized for Threads from various content sources.
Extracts content from YouTube video transcripts to automatically generate educational or summary carousel slides.
carousels-mcp
MCP server that turns articles, transcripts, and markdown into LinkedIn carousel PDFs, Instagram PNGs, and Threads PNGs. Content in, slides out. No web UI, no cloud service.
Where this came from
I'd been building LinkedIn carousels manually -- Gemini for the content distillation, SVG generation for the slides, Puppeteer for the PDF conversion, then merging everything together. The whole process is documented in this article. It worked well but it was a lot of steps. So I packaged the pipeline into an MCP server. Now Claude handles the orchestration and I just tell it what I want.
Related MCP server: Instagram Carousel MCP
What it does
You've got an article or a YouTube transcript or some markdown notes and you want a carousel. This server handles everything: content extraction, slide planning, SVG generation, PDF/PNG output. Give it a URL and it scrapes the content. Give it just a topic and it tells Claude how to research first using other MCP tools, then call back with the results.
The content extractor is actually quite good at picking the right slide type automatically. Numbers and percentages become stat slides. Ordered lists become step-by-step slides. Strong emphasis becomes takeaway callouts. "Before/after" language triggers comparison slides. The usual content, list, and quote types are there obviously, plus code slides for technical content and a CTA slide at the end.
The five tools
Tool | What it does |
| Shows available templates, including any custom brand kits you've made |
| Converts content into a structured slide plan you can review and edit before committing |
| Takes a slide plan and produces SVGs + PDF/PNG output |
| Full pipeline in one call -- content in, carousel out |
| Creates a custom brand kit by overriding colours and fonts from a base template |
Eleven slide types
cover · content · code · quote · list · cta · stat · comparison · steps · takeaway · dataviz
Multi-platform output
Each platform gets the right dimensions and format. No fiddling with resize tools.
LinkedIn -- 1080x1350, merged into a single PDF carousel
Instagram -- 1080x1080, individual PNG slides at 2x resolution
Threads -- 1080x1350, individual PNGs
Getting started
Claude Desktop config
{
"mcpServers": {
"carousels": {
"command": "npx",
"args": ["-y", "@houtini/carousels-mcp"],
"env": {
"CAROUSEL_TEMPLATES_DIR": "/path/to/your/brand-kits"
}
}
}
}CAROUSEL_TEMPLATES_DIR is optional. Skip it if you're fine with the built-in templates.
Or install globally:
npm install -g @houtini/carousels-mcpPDF and PNG output
SVG generation works out of the box. For the actual PDF and PNG files you need Puppeteer:
npm install -g puppeteerWithout it everything still works -- you just get SVG files. The server tells you this in its response, so you'll know. For most workflows you want Puppeteer installed. The SVG-only path is there as a fallback.
Gemini MCP integration
This is where it gets interesting. If you've got Gemini MCP installed alongside carousels-mcp, the two servers work together through Claude's orchestration. The carousel server can't see Gemini's tools directly -- MCP servers are isolated from each other -- but the tool descriptions teach Claude how to compose them.
What that means in practice:
Research-first carousels. Give
create_carouseljust a topic and it returns orchestration instructions. Claude picks up the workflow, callsgemini_deep_researchfor the content, then calls back with the results. You get a carousel about a topic you haven't written about yet.Custom charts. Use
preview_slidesto get a slide plan, then ask Gemini'sgenerate_svgto create charts or diagrams for specific slides. Inject the SVGs into the plan'scustomSvgfields and callrender_slides. The chart ends up embedded directly in the slide.Quality review. After rendering, Gemini's
analyze_imagecan review the output PNGs and suggest improvements. Useful for catching text overflow or layout issues before you upload.
You don't need Gemini MCP for the core pipeline to work. Content in, carousel out -- that works standalone. But the research and visual enhancement workflows are quite good when both servers are available.
Workflow examples
URL to carousel -- the most common one. Give it an article URL, get a carousel back.
"Turn this into a LinkedIn carousel: https://example.com/my-post"Topic to carousel -- when you haven't written the content yet. Claude researches via Gemini, then builds the slides.
"Make me a carousel about breeding pigs for LinkedIn"YouTube to carousel -- works with Supadata MCP for transcript extraction.
"Turn this YouTube video into a carousel: https://youtube.com/watch?v=..."Data-driven with charts -- research, analyse, then generate chart SVGs to embed in the slides.
"Research renewable energy trends, analyse the data, and make a carousel with charts"Preview, tweak, render -- when you want to review the slide plan before committing.
"I want to review the slides before generating"
→ preview_slides returns editable JSON
→ You adjust slides, swap types, reorder
→ render_slides produces the final outputTemplates
Six built-in templates. I spent a fair amount of time on these -- proper font pairings, warm backgrounds, committed colour palettes. No cold whites, no Inter, no generic SaaS aesthetic.
Template | Description |
| Navy/parchment, Plus Jakarta Sans + Frank Ruhl Libre. The safe default. |
| Dark navy, cyan-to-indigo gradients. Space Grotesk. |
| Lots of whitespace, single teal accent, system fonts. |
| Cream background, amber-to-red warmth. Nunito + Source Serif 4. |
| Deep charcoal with electric lime accents. The trending LinkedIn aesthetic right now, actually. |
| Built for stat and dataviz slides. Generous whitespace around the numbers so they breathe. |
Custom brand kits
Use create_template to build your own. Pick a base template, override the colours and fonts you care about, and it saves a JSON file to your templates directory. Next time you run list_templates, your brand kit shows up alongside the built-ins.
The server is fairly smart about brand detection. If you have custom templates but you're using the default professional, it mentions your brand kits in the response. Gentle nudge, not a nag.
Engagement patterns
There's some deliberate design baked into the SVG generation. Not decorative stuff -- actual patterns from LinkedIn carousel performance research.
Progress bar. Every slide gets a gradient bar at the bottom showing position in the deck. The Zeigarnik effect means people who see "3 of 8" feel compelled to keep swiping. It's thin and unobtrusive, but it works.
50 words per slide maximum. The content extractor enforces this. More than about three seconds of reading time per slide and people scroll past. If your content runs long, it gets split across more slides rather than cramming text in.
Slide 5 anchor. The extractor deliberately places a stat or quote slide at position 5. Mid-carousel drop-off is a real thing and an attention-grabbing slide at that position helps retention.
Output structure
Carousels save to ~/Documents/carousels/ in date-stamped folders:
~/Documents/carousels/2026-03-14-my-article-title/
slide-01.svg
slide-02.svg
...
slide-01.pdf (LinkedIn)
carousel.pdf (merged, ready to upload)
slide-01.png (Instagram/Threads)
slide-02.pngOverride with outputDir parameter or the CAROUSEL_OUTPUT_DIR environment variable.
Tool reference
create_carousel
The full pipeline. Three input modes:
Content mode: Pass
contentdirectly -- runs the pipeline immediately.URL mode: Pass
sourceUrl-- the server fetches the page, extracts article content, runs the pipeline. If the page is JS-rendered and extraction fails, it returns fallback instructions to usefirecrawl_scrapeorweb_fetchinstead.Topic mode: Pass
topicwithout content or URL -- returns orchestration workflows telling Claude how to research first, then call back with content.
Parameter | Type | Default | Description |
| string | -- | Article text, markdown, or transcript. Optional if |
| string | -- | Topic for research-first workflow. Returns orchestration instructions when no content/URL given. |
| string |
| Template to use |
| string | -- | Brand name in slide footers |
| number |
| Target slides (4--12) |
| string | -- | URL to fetch article content from. Also used for CTA slide link. |
| string |
| Output directory |
| string |
|
|
preview_slides
Returns a JSON slide plan you can review and edit before rendering.
Parameter | Type | Default | Description |
| string | required | Content to convert |
| number |
| Target slides (4--12) |
| string | -- | URL for CTA slide |
render_slides
Renders a slide plan (from preview_slides or hand-crafted) to SVG + PDF/PNG.
Parameter | Type | Default | Description |
| object | required | Structured slide plan |
| string |
| Template to use |
| string | -- | Brand name in footers |
| string |
| Output directory |
| string |
|
|
list_templates
Lists built-in and custom templates. No parameters.
create_template
Creates a custom brand kit from a base template.
Parameter | Type | Default | Description |
| string | required | Template name (kebab-case) |
| string |
| Template to extend |
| object | -- | Colour overrides (background, card, title, body, accent, footer) |
| object | -- | Font family overrides |
| object | -- | Layout overrides (margin, padding, radius) |
| string[] | -- | Google Fonts to import |
Environment variables
Variable | Purpose | Default |
| Directory for custom brand kit JSONs | none (built-in only) |
| Base output directory |
|
Requirements
Node.js 18+
Puppeteer (optional, for PDF/PNG output)
Gemini MCP (optional, for research workflows and custom chart generation)
Licence
MIT
Available Tools
5 toolscreate_carouselA
Full pipeline: content → slides → PDF/PNG in one call. Supports three input modes:
Mode 1 (Content provided): Pass article text, markdown, or transcript in the content field. The tool extracts key points, generates slides, and produces output immediately.
Mode 2 (URL provided): Pass a sourceUrl. The tool fetches the page, extracts article content, and runs the full pipeline. If the page is JavaScript-rendered and extraction fails, the tool returns fallback instructions to use firecrawl_scrape or web_fetch instead.
Mode 3 (Topic only): Pass a topic without content or sourceUrl. The tool returns orchestration instructions with multiple research workflows: • Web Research: Use gemini_deep_research → pass result as content • YouTube Summary: Use supadata_transcript → summarize with gemini_chat → pass as content • Data-Driven: Use gemini_deep_research → preview_slides → generate_svg for charts → render_slides • Quick Draft: Use web_fetch to grab a page → pass as content
Common workflows the user might request:
"Make a carousel about [topic]" → Call with topic param, follow returned workflow
"Turn this article into a carousel: [url]" → Call with sourceUrl param
"Here's my content, make a carousel" → Call with content param
"Research [topic] and make a carousel with charts" → Call with topic, follow Data-Driven workflow
Platforms: linkedin (1080×1350 PDF), instagram (1080×1080 PNGs), threads (1080×1350 PNGs)
After rendering: Consider using analyze_image (Gemini MCP) to review the output quality.
| Name | Required | Description | Default |
|---|---|---|---|
| content | No | Article text, markdown, or transcript. Optional if sourceUrl is provided (content will be fetched). If neither content nor sourceUrl is provided, topic must be set. | |
| topic | No | Topic for the carousel. When set without content/sourceUrl, returns orchestration instructions for researching the topic first via available tools (Gemini, web fetch, Supadata). | |
| templateName | No | Template name (run list_templates to see options including user brand kits) | professional |
| brandName | No | Brand name shown in slide footers | |
| slideCount | No | Target number of slides (4-12) | |
| sourceUrl | No | URL to fetch article content from. The server scrapes and cleans HTML automatically. Also used for CTA slide link. | |
| outputDir | No | Output directory (default: ~/Documents/carousels/) | |
| platform | No | Target platform: linkedin (1080x1350 PDF), instagram (1080x1080 PNGs), threads (1080x1350 PNGs) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and does an excellent job disclosing behavioral traits. It explains the three distinct processing modes, fallback behaviors when extraction fails, orchestration workflows for topic-only inputs, platform-specific outputs, and post-rendering suggestions. The only minor gap is not explicitly mentioning rate limits or authentication requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (modes, workflows, platforms, post-rendering) and uses bullet points effectively. While comprehensive, it's appropriately sized for a complex 8-parameter tool with multiple operational modes. Every sentence serves a purpose in clarifying usage.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (8 parameters, 3 distinct modes, multiple workflows) and no annotations or output schema, the description provides exceptional completeness. It covers all operational scenarios, explains behavioral outcomes, provides usage examples, mentions platform specifics, and even suggests follow-up actions. This fully compensates for the lack of structured metadata.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema description coverage, the baseline is 3, but the description adds significant value by explaining how parameters interact in the three modes. It clarifies that content and sourceUrl are mutually exclusive alternatives, topic triggers research workflows, and platform affects output format. This contextual understanding goes beyond the schema's individual parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the tool's purpose as a 'full pipeline' that transforms content into slides and PDF/PNG outputs. It clearly distinguishes from sibling tools like create_template, list_templates, preview_slides, and render_slides by being the comprehensive end-to-end solution rather than individual components.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides extensive guidance on when to use each input mode (content, sourceUrl, topic) and includes specific workflow examples. It explicitly mentions alternatives like firecrawl_scrape, web_fetch, gemini_deep_research, and supadata_transcript for different scenarios, giving clear context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
create_templateA
Create a custom brand template by overriding colors, typography, and layout from a base template.
When to call: When the user wants their carousels to match their brand identity. Saves the template for future use.
Tips:
Start from 'professional' as base. It has the most polished defaults
Pick a dominant accent hue and build a monochromatic gradient (same hue, two lightness stops)
Use warm backgrounds (#F5F3EF) not cold (#FAFAFA)
Avoid Inter, Roboto, Arial. Choose distinctive fonts like Plus Jakarta Sans, Space Grotesk, Outfit
Pair a geometric display font with an editorial serif body font (Frank Ruhl Libre, Source Serif 4)
Returns: Saved template path and confirmation.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Template name (kebab-case recommended) | |
| description | No | Short description of the template style | |
| baseTemplate | No | Template to use as base (inherits unset values) | professional |
| colors | No | Color overrides | |
| typography | No | Font family overrides | |
| layout | No | Layout overrides | |
| googleFonts | No | Google Fonts to import (e.g. "Inter:wght@400;700") |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes that the tool creates and saves a template for future use, includes design recommendations, and specifies the return value (saved template path and confirmation). However, it doesn't mention potential limitations like file size constraints, authentication requirements, or error conditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, when to call, tips, returns). Every sentence adds value: the first sentence explains the core functionality, the 'When to call' provides context, the 'Tips' offer practical guidance, and the 'Returns' clarifies outcomes. No wasted words or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a creation tool with 7 parameters, no annotations, and no output schema, the description does an excellent job covering purpose, usage context, and practical guidance. The main gap is the lack of explicit error handling or constraints documentation, but given the rich guidance provided and 100% schema coverage, it's mostly complete for agent usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema description coverage, the baseline is 3. The description adds significant value by explaining the purpose of parameters through design tips (e.g., 'Pick a dominant accent hue and build a monochromatic gradient' relates to colors.accent, 'Avoid Inter, Roboto, Arial' relates to typography fields). It provides practical guidance that goes beyond the schema's technical documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool creates a custom brand template by overriding colors, typography, and layout from a base template. It specifies the resource (brand template) and action (create by overriding), distinguishing it from siblings like list_templates (list operation) and create_carousel (different resource).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description includes an explicit 'When to call' section stating to use when the user wants carousels to match brand identity and saves the template for future use. It also provides 'Tips' with specific recommendations (e.g., start from 'professional' base, avoid certain fonts), offering clear guidance on when and how to use this tool effectively.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_templatesA
List available carousel design templates (built-in + user brand kits).
When to call: Before creating a carousel, to check if the user has custom brand templates. If they do, suggest using their branded design instead of the default.
Returns: Array of template objects with name, description, and builtin flag.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the return format ('Array of template objects with name, description, and builtin flag'), which is helpful, but lacks details on potential errors, pagination, or performance characteristics (e.g., rate limits). It adequately describes core behavior but misses advanced operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with clear sections (purpose, usage guidelines, returns), using bold headings for readability. Each sentence adds value without redundancy, and the information is front-loaded with the core purpose first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (0 parameters, no output schema, no annotations), the description is largely complete. It covers purpose, usage, and return format. However, without an output schema, it could benefit from more detail on the template object structure (e.g., field types), though the current level is sufficient for basic use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100% (empty schema). The description adds no parameter information, which is appropriate here. A baseline of 4 is applied for zero-parameter tools, as there is no need to compensate for schema gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('List') and resource ('available carousel design templates'), explicitly distinguishing scope ('built-in + user brand kits'). It differentiates from siblings like create_carousel (creation) and create_template (template management), making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance with a dedicated 'When to call' section, specifying timing ('Before creating a carousel') and rationale ('to check if the user has custom brand templates'). It includes an alternative suggestion ('suggest using their branded design instead of the default'), clearly guiding usage relative to other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
preview_slidesA
Convert content into a structured slide plan WITHOUT rendering. Returns editable JSON.
When to call: When the user wants to review or edit slide content before rendering. Also use as the first step in the enhanced workflow (preview → enhance with Gemini → render).
Workflow: Enhanced visuals
Call preview_slides with the content
Review the returned slide plan. Each slide may have an aiSuggestion field
For slides with aiSuggestions, use Gemini MCP tools:
generate_svg for diagrams, charts, flowcharts
generate_image for hero images, illustrations
gemini_chat to rewrite slide copy for punchier hooks
Inject generated SVGs into the slide's customSvg field
Call render_slides with the enhanced plan
Returns: SlidePlan JSON with slides array, sourceTitle, summary.
| Name | Required | Description | Default |
|---|---|---|---|
| content | Yes | Article text, markdown, or transcript to convert into slides | |
| slideCount | No | Target number of slides (4-12) | |
| sourceUrl | No | Original URL of the content (for CTA slide) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses that the tool returns 'editable JSON' and outlines a multi-step workflow, including that slides may have 'aiSuggestion' fields and how to enhance them. However, it doesn't mention error handling, rate limits, or authentication needs, leaving some behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, when to call, workflow, returns). It's appropriately sized but includes a detailed workflow that, while helpful, could be slightly verbose. Every sentence adds value, but it's not maximally concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description compensates well by explaining the return format ('SlidePlan JSON with slides array, sourceTitle, summary') and the workflow context. It addresses complexity by detailing how to use the output with other tools, making it complete for agent understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description does not add any parameter-specific information beyond what the schema provides (e.g., it doesn't explain 'content' formats or 'slideCount' implications in detail), but it doesn't need to since the schema is well-documented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Convert content into a structured slide plan WITHOUT rendering. Returns editable JSON.' It specifies the verb (convert), resource (content into slide plan), and distinguishes from sibling 'render_slides' by emphasizing 'without rendering.'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly provides when to call: 'When the user wants to review or edit slide content before rendering' and positions it as 'the first step in the enhanced workflow.' It distinguishes from 'render_slides' and mentions integration with Gemini MCP tools, offering clear alternatives and context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
render_slidesA
Render a slide plan into SVG + PDF (LinkedIn) or PNG (Instagram/Threads).
When to call: After preview_slides when you've reviewed or enhanced the slide plan. Also accepts manually crafted slide plans.
Supports Gemini-generated visuals: Any slide in the plan can include:
customSvg: Raw SVG content (from generate_svg) embedded directly into the slide
customImageUrl: Local file path to an image (from generate_image)
Tip: Run list_templates first to check for user brand kits.
Returns: Output paths (SVG, PDF/PNG), template used, platform.
| Name | Required | Description | Default |
|---|---|---|---|
| slidePlan | Yes | Structured slide plan (from preview_slides or manually crafted) | |
| templateName | No | Template name (run list_templates to see options) | professional |
| brandName | No | Brand name shown in slide footers | |
| outputDir | No | Output directory (default: ~/Documents/carousels/) | |
| platform | No | Target platform: linkedin (1080x1350 PDF), instagram (1080x1080 PNGs), threads (1080x1350 PNGs) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it supports Gemini-generated visuals (customSvg, customImageUrl), mentions platform-specific output formats, and advises checking for brand kits. However, it doesn't cover potential side effects like file system changes or error conditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, usage, features, tip, returns) and uses bullet points efficiently. Every sentence adds value, though the 'Tip' section could be integrated more seamlessly. It's appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (5 parameters, nested objects) and lack of annotations/output schema, the description does a good job covering key aspects: purpose, usage, visual support, and returns. However, it could better address error handling or performance considerations for a rendering tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema, mentioning slide plan sources and platform outputs but not elaborating on parameter interactions or constraints. Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('render') and resources ('slide plan into SVG + PDF or PNG'), distinguishing it from siblings like preview_slides (which previews) and create_carousel (which may involve different workflows). It explicitly mentions output formats for different platforms.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to call ('After preview_slides when you've reviewed or enhanced the slide plan') and includes alternatives ('Also accepts manually crafted slide plans'). It references sibling tools like list_templates and preview_slides, offering clear context for usage.
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. Dates show when Glama detected each change.
5 tool updates
v1.0.0- First observed
create_carousel - First observed
create_template - First observed
list_templates - First observed
preview_slides - First observed
render_slides
TDQS
Each tool has a distinct, non-overlapping purpose: create_carousel handles the full pipeline, create_template manages brand design, list_templates enumerates available designs, preview_slides structures content without rendering, and render_slides finalizes output. The descriptions clearly differentiate their roles, eliminating ambiguity.
All tool names follow a consistent verb_noun pattern (e.g., create_carousel, list_templates, preview_slides, render_slides), with clear and predictable naming. There are no deviations in style or convention, making the set highly readable and uniform.
With 5 tools, the server is well-scoped for carousel creation and management. Each tool serves a specific function in the workflow (from content processing to rendering and branding), and none feel redundant or missing, fitting the domain appropriately.
The toolset covers the core carousel lifecycle comprehensively: creation, templating, listing, previewing, and rendering. Minor gaps exist, such as no explicit update or delete operations for templates or carousels, but agents can work around this by reusing existing tools (e.g., create_template for updates).
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
MCP server for QPost — lets AI agents publish video and image posts to YouTube, TikTok, Instagram.
Social media MCP server: your Instagram, TikTok, YouTube, LinkedIn and Threads history for your AI.
1Document-to-Markdown MCP server — convert PDF, Office and HTML into LLM-ready Markdown.
Presentations.AI MCP server — create designed slide decks from a topic, text, or document.
Related MCP Servers
- AlicenseAqualityNot gradedmaintenanceAn MCP server that enables AI agents to instantly convert Markdown into beautiful, ready-to-deliver Word, PDF, HTML with sidebars, and Slideshow documents, bridging the "last mile" of AI content generation.7281-
- FlicenseNot gradedqualityBmaintenanceAn MCP server that designs multi-slide Instagram carousels as SVG, provides a live swipeable preview, and exports to PNG. Supports multiple templates, themes, and sizes.1-
- AlicenseAqualityBmaintenanceMCP server for AI-driven document creation, enabling generation of PowerPoint decks with consistent design themes and auto-generated images via ComfyUI.5GPL 3.0
- AlicenseNot gradedqualityAmaintenanceMCP server that enables LinkedIn content generation through Claude, offering brand setup, playbooks, on-brand PDF/PNG rendering, and post tracking with per-client tokens.MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/houtini-ai/carousels-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server