Alai
Allows generating professional presentations directly from Markdown content, enabling users to transform structured text and notes into slides with automated layouts and themes.
Alai - AI Presentation Maker MCP Server
AI presentation maker and slide generator for Claude, Cursor, and MCP clients. Create designer-level presentations, pitch decks, and slides from text. Export to PowerPoint (PPTX) and PDF.
What is Alai?
Alai is an AI presentation maker and the fastest way to create high-quality, beautiful slides without design skills.
Generate slides from text - Turn notes, markdown, URLs, or documents into polished presentations
Beautify existing slides - Restyle and improve your PowerPoint presentations with AI
Export anywhere - Download as PowerPoint (PPTX), PDF, or shareable link
Professional themes - Designer-level templates for any occasion
Speaker notes - AI-generated talking points for each slide
Nano Banana Pro Image Slides - Theme-aware image slide generation that matches your deck's visual style
Edit and iterate - Make targeted changes to text, icons, and images on existing slides
Related MCP server: Google Slides MCP Server
Use Cases
Pitch decks - Create investor-ready presentations from your notes
Sales presentations - Generate compelling slides for prospects
Meeting notes to slides - Transform your notes into shareable decks
PowerPoint beautification - Restyle existing slides with professional themes
Marketing presentations - Build product and campaign decks quickly
Features
Generate designer-level presentations from text, markdown, or meeting notes
AI-powered slide beautification and restyling
Export to PowerPoint (PPTX) or PDF
Professional pitch deck themes
Add and remove slides from existing presentations
Edit and iterate on existing slides with targeted prompts
Generate speaker notes automatically
Server URL
https://slides-api.getalai.com/mcp/Glama / Local Wrapper
This repository includes a local MCP wrapper so Glama can build, start, and inspect the server automatically.
The wrapper runs over stdio and forwards tool calls to the hosted Alai MCP endpoint:
ALAI_MCP_URL- optional override for the upstream MCP URLALAI_API_KEY- optional API key used when forwarding tool calls upstreamapi_key- alternate env var name supported for Glama placeholder arguments
Tool introspection works without credentials, which is enough for Glama to inspect the server. Real tool execution requires a valid API key.
Run locally
npm install
npm startWith upstream credentials:
ALAI_API_KEY=sk_your_key npm startAuthentication
The server accepts either a static API key or an OAuth 2.1 bearer token on the same endpoint.
API Key
Get a key from getalai.com and pass it in one of these headers:
api-key: sk_your_keyAuthorization: Bearer sk_your_key
OAuth 2.1 with Dynamic Client Registration
The server implements RFC 9728 Protected Resource Metadata and delegates authorization to Supabase, which supports RFC 7591 Dynamic Client Registration and PKCE (S256). Spec-compliant MCP clients (e.g. Claude Desktop, MCP Inspector) can auto-discover the flow:
GET https://slides-api.getalai.com/.well-known/oauth-protected-resourceThe response's authorization_servers entry points at the Supabase authorization server, whose /.well-known/oauth-authorization-server document advertises the registration_endpoint, authorization_endpoint, and token_endpoint. After the authorization code + PKCE flow, the client sends Authorization: Bearer <jwt> to the MCP endpoint.
Available Tools
Tool | Description |
| Verify your API key and return your user ID |
| Create a presentation from text content |
| Check async operation status |
| List themes available to the authenticated user |
| List vibes (visual styles) available to the authenticated user |
| List all your presentations |
| Add a slide (classic or creative) to an existing presentation |
| Remove a slide from a presentation |
| Export to PDF, PPTX, or shareable link |
| Generate speaker notes for slides |
| Permanently delete a presentation |
Workflow
Call
generate_presentationwith your contentPoll
get_generation_statusevery 2-5 seconds until status iscompletedUse the returned
presentation_idfor further operations
Example Usage
Generate a Presentation
Call get_themes and get_vibes first to discover the IDs available to your account, then pass them in:
{
"input_text": "Benefits of AI in the workplace: increased productivity, enhanced creativity, improved efficiency",
"title": "AI in the Workplace",
"theme_id": "<id from get_themes>",
"vibe_id": "<id from get_vibes>",
"slide_range": "2-5",
"include_ai_images": true,
"num_creative_variants": 1,
"total_variants_per_slide": 1,
"image_ids": [],
"export_formats": ["link"],
"language": "English"
}Only input_text is required. num_creative_variants must be 0–2 (set to ≥1 when using vibe_id). total_variants_per_slide must be 1–4. export_formats accepts "link", "pdf", "ppt".
Check Generation Status
{
"generation_id": "abc123-def456"
}Export Presentation
{
"presentation_id": "xyz789",
"formats": ["pdf", "link"]
}Available Themes
Call get_themes to discover the themes available to your account (returns theme IDs and display names). A handful of built-in legacy theme names you can pass directly as theme_id:
AURORA_FLUXMIDNIGHT_EMBEREMERALD_FORESTDESERT_BLOOMDONUTOAKPRISMATICASIMPLE_LIGHTSIMPLE_DARKCYBERPUNK
Configuration
For Claude Desktop / MCP Clients
OAuth-capable clients (Claude Desktop, MCP Inspector, Cursor, etc.) can use just the URL — the client will discover and run the OAuth 2.1 + DCR flow on first connect:
{
"mcpServers": {
"alai-presentations": {
"url": "https://slides-api.getalai.com/mcp/",
"transport": "streamable-http"
}
}
}If you prefer to skip OAuth and use a static API key, add a header block:
{
"mcpServers": {
"alai-presentations": {
"url": "https://slides-api.getalai.com/mcp/",
"transport": "streamable-http",
"headers": {
"api-key": "sk_your_api_key"
}
}
}
}Links
License
MIT License - See LICENSE file for details.
Available Tools
11 toolscreate_slideAInspect
Add a new slide to an existing presentation. Use this for targeted edits after a deck already exists, including classic content slides or more creative visually led slides.
| Name | Required | Description | Default |
|---|---|---|---|
| presentation_id | Yes | Target presentation that will receive the new slide. | |
| prompt | Yes | Instruction describing the content or intent of the new slide. | |
| slide_type | No | Choose classic for structured content or creative for more visual exploration. | |
| insert_after_slide_id | No | Existing slide identifier after which the new slide should be inserted. | |
| theme_id | No | Optional theme override for the new slide. | |
| vibe_id | No | Optional vibe override for the new slide. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must bear the full burden. It discloses the mutation (adding a slide) and mentions slide types, but lacks details on side effects, authentication, rate limits, or error behavior. Adequate but not rich.
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 concise with two clear sentences. It front-loads the main purpose and follows with usage context. No unnecessary words.
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 6 parameters with full schema descriptions and no output schema, the description provides adequate context for a creation tool. It mentions slide types and targeted edits, which is sufficient for most use cases.
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 schema covers all 6 parameters with descriptions (100% coverage). The description adds minimal extra meaning beyond the schema, such as explaining 'classic' vs 'creative' slide types. Baseline 3 is appropriate.
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 action (Add a new slide), the target resource (existing presentation), and distinguishes from siblings like generate_presentation (creates whole deck) and delete_slide (removes). The scope is well-defined.
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 explicitly mentions using this for targeted edits after a deck already exists, which provides clear context. It does not explicitly state when not to use it or list alternatives, but the sibling tool names imply other use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
delete_presentationAInspect
Delete a presentation permanently. Use this destructive action only when the caller explicitly intends to remove the deck.
| Name | Required | Description | Default |
|---|---|---|---|
| presentation_id | Yes | Presentation identifier to delete permanently. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the destructive and permanent nature, but lacks details on cascading effects, permissions, or rate limits. Adequate for a simple delete action.
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 a single sentence that is front-loaded with the purpose and usage condition. No unnecessary words.
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?
The tool is simple with one parameter and no output schema. The description covers purpose, usage, and a key behavioral trait (permanence). It could mention return values or error conditions but is sufficient for the tool's simplicity.
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 coverage is 100%, and the description of the sole parameter matches the schema. The description adds no extra meaning beyond what the schema already provides, meeting the baseline.
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 action (delete) and the resource (presentation), with the modifier 'permanently' that distinguishes it from non-destructive operations. Sibling tools like delete_slide operate on different resources.
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 explicitly advises using this tool only when the caller intends permanent removal, providing a clear 'when to use' condition. It does not mention when not to use, but the condition covers that implicitly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
delete_slideAInspect
Remove a slide from a presentation permanently. Use this only when you know the exact slide identifier to delete.
| Name | Required | Description | Default |
|---|---|---|---|
| presentation_id | Yes | Presentation that owns the slide. | |
| slide_id | Yes | Slide identifier to remove from the presentation. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description indicates the action is permanent ('permanently'), which is useful for a delete operation. However, it lacks details on side effects (e.g., impact on references, undo ability), and there are no annotations to supplement this. The description is adequate but not thorough for a destructive tool.
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 consists of two short, front-loaded sentences with no unnecessary words. Every sentence adds value: first states the action, second provides usage context.
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 simple delete tool with two parameters and no output schema, the description covers the essential purpose and usage condition. It could mention whether deletion is reversible, but overall it is sufficient for an agent to understand and invoke the tool correctly.
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 input schema provides complete descriptions for both parameters (presentation_id, slide_id), achieving 100% coverage. The tool description adds no additional meaning beyond what the schema already conveys, so the baseline score of 3 is appropriate.
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 action ('Remove a slide from a presentation permanently') with a specific verb and resource, and it distinguishes itself from sibling tools like create_slide and delete_presentation by focusing on slides.
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: 'Use this only when you know the exact slide identifier to delete.' This tells the agent when to use the tool, though it doesn't mention alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
export_presentationAInspect
Export a finished presentation to PDF, PowerPoint, or a shareable link. Use this after generation or editing when you need a deliverable artifact.
| Name | Required | Description | Default |
|---|---|---|---|
| presentation_id | Yes | Presentation to export. | |
| formats | Yes | One or more export formats to generate. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility for transparency. It does not disclose whether the original presentation is modified, what permissions are required, rate limits, or behavior if the presentation is not finished. This is a significant gap for a tool that produces external artifacts.
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 consists of two concise sentences that front-load the action and outputs, then provide usage context. No unnecessary words.
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 2-parameter tool with no output schema, the description covers the basic purpose and usage context. However, it is incomplete regarding return values or side effects, which would be helpful for an agent.
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%, and the description adds minimal extra meaning beyond the schema. It reiterates the formats but does not elaborate on parameter syntax or constraints. Baseline of 3 is appropriate.
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 exports a presentation to specific formats (PDF, PowerPoint, link), using a specific verb and resource. It distinguishes from sibling tools like create_slide or delete_presentation by focusing on the export action.
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 advises using the tool 'after generation or editing when you need a deliverable artifact,' providing clear usage context. However, it does not explicitly state when not to use it or mention alternatives, though none exist among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_presentationAInspect
Create a new presentation from raw text or markdown. Use this to turn notes, outlines, meeting summaries, or draft content into an Alai deck before polling get_generation_status.
| Name | Required | Description | Default |
|---|---|---|---|
| input_text | Yes | The source content to transform into slides. | |
| title | No | Presentation title shown in the deck and exports. | |
| theme_id | No | Theme identifier from get_themes. Use this to control layout family. | |
| vibe_id | No | Visual style identifier from get_vibes. Use only after discovering valid IDs. | |
| language | No | Presentation language, for example English or Spanish. | |
| export_formats | No | Formats to generate when the deck is ready. | |
| slide_range | No | Requested slide count range such as 2-5. | |
| include_ai_images | No | Whether Alai should generate image content for slides. | |
| num_creative_variants | No | How many creative variants to generate per slide. | |
| total_variants_per_slide | No | Total variant count to generate for each slide. | |
| image_ids | No | Existing uploaded image identifiers to reuse in the deck. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It correctly implies the tool is asynchronous (by mentioning polling), but does not disclose auth needs, side effects, or error behavior. The description is adequate but could be more explicit about the generation process.
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 two sentences, front-loaded with the action verb 'Create'. Every word serves a purpose with no redundancy. It is concise and easy to parse.
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 complexity (11 parameters, no output schema), the description is minimal. It correctly sets up the workflow with get_generation_status but omits return value description, error cases, or parameter relationships (e.g., theme_id vs vibe_id). The parameter schema partially compensates.
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 baseline is 3. The tool description adds no additional parameter meaning beyond the schema. It mentions 'raw text or markdown' which aligns with input_text but doesn't augment the schema.
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 presentation from raw text or markdown, with explicit use cases (notes, outlines, meeting summaries). It distinguishes from siblings like create_slide (individual slides) and get_generation_status (polling), and even references the correct subsequent tool.
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 explains when to use the tool: to turn raw text into a deck before polling get_generation_status. It provides context for the workflow but does not explicitly exclude scenarios or mention alternatives like create_slide for single slides, though this is implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_transcriptsAInspect
Generate speaker notes or transcripts for slides in an existing presentation. Use this when the deck visuals are ready and you need talking points for delivery.
| Name | Required | Description | Default |
|---|---|---|---|
| presentation_id | Yes | Presentation whose slides need speaker notes. | |
| slide_ids | No | Optional subset of slide identifiers to process. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It fails to mention whether the tool overwrites existing notes, is additive, or requires any permissions. The side effects and safety of the operation are unclear.
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 concise (two sentences) and well-structured, with the first sentence stating purpose and the second providing usage context. No unnecessary words.
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?
The tool has no output schema, so the description should indicate what is returned (e.g., updated presentation, success message). It does not, leaving agents uncertain about the outcome. Additionally, it does not clarify if the operation is synchronous or async, despite a sibling tool for generation status.
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?
Input schema coverage is 100%, with clear descriptions for both parameters. The description does not add significant meaning beyond the schema, except hinting that the output is speaker notes or transcripts. Baseline 3 is appropriate.
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: 'Generate speaker notes or transcripts for slides in an existing presentation.' It uses a specific verb ('generate') and resource ('speaker notes or transcripts for slides'), and distinguishes from sibling tools like create_slide and generate_presentation.
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 usage guidance: 'Use this when the deck visuals are ready and you need talking points for delivery.' It implies when to use but does not explicitly mention when not to use or suggest alternatives, leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_generation_statusAInspect
Check the status of an asynchronous presentation generation job. Use this after generate_presentation until the status reaches completed or failed.
| Name | Required | Description | Default |
|---|---|---|---|
| generation_id | Yes | Generation job identifier returned by generate_presentation. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses that the job is asynchronous and implies polling is needed, but lacks details on response structure, possible statuses, or error handling. Basic disclosure is present but not comprehensive.
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 extremely concise at two sentences, front-loading the purpose and usage guidance without any filler. Every word contributes meaning.
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 simplicity (one parameter, polling for status), the description is largely complete. It covers purpose and usage timing. It could mention possible status values or retry logic, but overall adequate.
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% for the single parameter, which already states it is a generation job identifier. The tool description adds no further semantic value for the parameter, so baseline 3 is appropriate.
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: checking the status of an asynchronous presentation generation job. It specifies the resource (generation job) and action (check status), and distinguishes it from sibling tools like generate_presentation.
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 explicitly tells the agent to use this after generate_presentation and until the status reaches completed or failed, providing clear temporal guidance. However, it does not mention alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_presentationsAInspect
List presentations owned by the authenticated user. Use this when you need to pick an existing presentation_id before editing, exporting, or deleting.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must convey behavioral traits. It states the tool lists presentations 'owned by the authenticated user,' implying read-only access. However, it does not mention whether results are paginated, sorted, or limited, nor does it specify the output format. This is adequate for a simple list operation but leaves some 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 extremely concise: two sentences. The first states the action and scope, the second provides usage guidance. Every word adds value, and it is front-loaded with the core purpose.
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 output schema and zero parameters, the description covers the tool's purpose and usage context well. It does not describe the return format or fields, which might be helpful, but the omission is minor for a listing tool that simply returns presentation objects. Sibling tools like 'get_themes' are similarly brief.
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 input schema has zero parameters, so no parameter documentation is needed. The description does not add parameter-level details, but none are required. With 100% schema coverage (no params), the baseline is 4.
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 that the tool lists presentations owned by the authenticated user, using a specific verb ('List') and resource ('presentations'). It distinguishes itself from sibling tools like 'create_slide' and 'delete_presentation' by explicitly mentioning its role as a prerequisite for editing, exporting, or deleting.
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 explicitly tells when to use this tool: 'when you need to pick an existing presentation_id before editing, exporting, or deleting.' This provides clear context and alternative actions (the editing/exporting/deleting tools), helping the agent decide correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_themesAInspect
List themes available to the authenticated account. Call this before generate_presentation when you need valid theme_id values.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full behavioral burden. It indicates a read operation with no side effects, but lacks details on authentication, rate limits, or response structure. Adequate but minimal.
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?
Two sentences, both front-loaded: first defines purpose, second gives usage tip. No wasted words, excellent conciseness.
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 parameters and no output schema, the description is mostly complete, explaining what it does and why to use it. It could mention the output format, but the tip implies theme_id values are returned. Slightly lacking, but overall adequate.
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?
There are no parameters, so the schema is fully covered. The description adds no extra parameter info, but none is needed. Baseline score for zero parameters is 4.
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 lists themes and specifies it's for the authenticated account. It also provides a usage tip linking to generate_presentation, distinguishing it from other list tools like get_vibes.
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 explicitly advises to call this before generate_presentation to obtain valid theme_id values, giving clear context for when to use it. It does not mention exclusions or alternatives, but the guidance is sufficient for this simple tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_vibesAInspect
List available vibe identifiers that control the visual style of generated decks. Use this before setting vibe_id on generate_presentation or create_slide.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, but the description is straightforward about the behavior. It doesn't elaborate on response format or potential side effects, but the tool is simple with no parameters.
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?
Two concise sentences, front-loaded with the primary action and purpose. No wasted words.
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 simple listing tool with no parameters and no output schema, the description is complete. It explains what it does and when to use it.
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?
There are no parameters, and the schema coverage is 100%. The description adds no extra info about parameters, but none is needed. Baseline score of 4 applies.
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 it lists vibe identifiers for visual style, with a specific verb and resource. It differentiates its purpose from siblings like get_themes by specifying that it's for controlling deck style.
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 instructs to use this tool before setting vibe_id on generate_presentation or create_slide, providing direct context for when to invoke it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pingAInspect
Verify the configured Alai credentials and return account identity details. Use this first when you need to confirm authentication before creating or exporting presentations.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses the action (verification) and output (identity details) but omits potential side effects or error scenarios. Adequate for a simple ping.
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?
Two concise sentences: first states purpose, second gives usage context. No wasted words, front-loaded with key action.
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 tool with no parameters and no output schema, the description sufficiently explains purpose and usage. Could mention error handling or latency, but contextually complete for its simplicity.
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?
No parameters exist, and schema coverage is 100%. Description does not need to add parameter info, so baseline score applies.
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?
Clearly states the verb 'verify' and the resource 'Alai credentials', and specifies the return of 'account identity details'. Differentiates from sibling tools focused on presentation manipulation.
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 advises using this tool before creating or exporting presentations to confirm authentication. Does not mention when not to use, but provides clear positive guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Each tool targets a distinct action and resource, such as creating, deleting, exporting, or listing. No two tools have overlapping purposes, making it easy for an agent to select the correct one.
All tool names follow a consistent verb_noun pattern in snake_case (e.g., create_slide, delete_presentation, get_themes). This predictability aids agent understanding.
With 11 tools covering creation, deletion, export, status checking, listing, and authentication, the count is well-scoped for a presentation generation service.
The set lacks update operations (e.g., update_slide, update_presentation) and retrieval of a single presentation's details (e.g., get_slides). This could force agents to work around gaps, though core create/delete/export flows exist.
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
Generate polished PowerPoint presentations from text prompts, YouTube videos, or structured outlin…
Create polished slide decks from text or YouTube links in seconds. Fetch video transcripts to tran…
Build decks in your own brand, from the AI agent you already use. Then edit them yourself.
Design mobile-first presentations — create, edit, preview, and publish from your AI.
Related MCP Servers
- AlicenseAqualityDmaintenanceCreates and manipulates PowerPoint presentations with capabilities for adding various slide types, generating images, and incorporating tables and charts through natural language commands.11144MIT
- FlicenseBqualityDmaintenanceEnables interaction with Google Slides presentations through OAuth2 authentication. Supports creating new slides, adding rectangles, and managing presentation content through natural language commands.6-
- AlicenseNot gradedqualityDmaintenanceEnables 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.16MIT
- FlicenseNot gradedqualityCmaintenanceRemote MCP server running on Cloudflare Workers that creates PowerPoint presentations with customizable slides, layouts, and bullet points, along with basic calculator functions.-
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/getalai/alai-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server