Skip to main content
Glama

list_themes

Read-onlyIdempotent

Browse the complete catalog of available slide themes without starting a new project. Returns all primary and secondary themes for use in presentations and carousels.

Instructions

Idempotent read-only listing of all available themes (8+). Unlike discover_themes, this does NOT start a slide-creation workflow — call it any time the user asks "what themes are there?" mid-conversation. Returns the same tiered theme catalog (primary/secondary). Models MUST present every theme returned, never truncate.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault

No arguments

Implementation Reference

  • Handler function for the list_themes tool. Loads the theme catalog and returns a JSON response with all themes (id, name, emoji, style, palette, tier), theme count, primary/secondary theme lists, and an instruction for the model to present all themes.
    export async function handleListThemes() {
      const themes = await loadThemeCatalog();
      return {
        content: [{
          type: "text" as const,
          text: JSON.stringify({
            themes: themes.map(t => ({
              id: t.id,
              name: t.name,
              emoji: t.emoji,
              style: t.style,
              palette: t.palette,
              tier: t.tier,
            })),
            themeCount: themes.length,
            primaryThemes: themes.filter(t => t.tier === "primary").map(t => t.id),
            secondaryThemes: themes.filter(t => t.tier === "secondary").map(t => t.id),
            instruction: `Present ALL ${themes.length} themes to the user. This is a read-only listing — calling this tool does NOT advance the slide-creation workflow. If the user wants to switch themes, they should re-invoke discover_themes or pass theme=<id> directly to create_slides.`,
          }),
        }],
      };
    }
  • Schema definition for list_themes input. Empty object because the tool takes no input parameters.
    // ── Tool: list_themes (idempotent) ──
    
    export const ListThemesInputSchema = {};
  • Registration of the list_themes tool on the MCP server with its description, empty input schema, hints (read-only, idempotent), and handler binding.
    server.tool(
      "list_themes",
      `Idempotent read-only listing of all available themes (8+). Unlike discover_themes, this does NOT start a slide-creation workflow — call it any time the user asks "what themes are there?" mid-conversation. Returns the same tiered theme catalog (primary/secondary). Models MUST present every theme returned, never truncate.`,
      ListThemesInputSchema,
      { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
      async () => handleListThemes(),
    );
  • Helper function that loads themes by first trying to fetch from the remote catalog, then merging with any missing fallback themes, and falling back entirely to the hardcoded THEME_CATALOG_FALLBACK array.
    async function loadThemeCatalog(): Promise<TieredTheme[]> {
      try {
        const fetched = await fetchCatalog();
        if (fetched && fetched.length > 0) {
          const tiered = withTier(fetched);
          const fetchedIds = new Set(tiered.map((t) => t.id));
          const missing = THEME_CATALOG_FALLBACK.filter((t) => !fetchedIds.has(t.id));
          return [...tiered, ...missing];
        }
      } catch {
        // fall through to fallback
      }
      return THEME_CATALOG_FALLBACK;
    }
  • Alias of the schema (same location as schema line 21) -- ListThemesInputSchema is the empty input schema used for the list_themes tool.
    export const ListThemesInputSchema = {};
    
    // ── Tool: edit_slides (token-efficient partial edits) ──
    
    export const EditInputSchema = {
      htmlPath: z.string().optional().describe("Path to HTML to edit. Falls back to cached HTML from last create_slides call."),
      operation: z.enum(["replace_slide", "patch_css", "swap_token", "patch_class"]).describe("Edit operation: replace_slide swaps one slide block; patch_css appends CSS rules to <style>; swap_token replaces a CSS variable's value; patch_class adds/removes a class on a slide."),
      slideIndex: z.number().int().positive().optional().describe("1-indexed slide position. Required for replace_slide and patch_class. Omit for global ops (patch_css, swap_token)."),
      payload: z.union([z.string(), z.record(z.string())]).describe("For replace_slide: the new <div class=\"slide\">...</div> HTML string. For patch_css: a CSS rules string. For swap_token: an object {tokenName: newValue}, e.g. {\"--coral\": \"#FF0000\"}. For patch_class: an object {add?: string, remove?: string}."),
    };
    
    // ── Tool 2: create_slides ──
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint and idempotentHint. Description adds that it returns tiered catalog (primary/secondary) and instructs models not to truncate. This adds value beyond annotations, though annotations cover core behavioral traits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences, each essential: purpose, usage guidance with sibling differentiation, and a behavioral constraint. Front-loaded with key info. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter listing tool with good annotations and no output schema, the description provides enough context: what it lists, when to use, output structure (tiered catalog), and behavior (no truncation). Complete enough for effective agent invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters in schema; baseline is 4. Description does not need to add param information. No additional details about parameters are necessary and none are missing.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states it lists themes (8+), is idempotent and read-only, and distinguishes from sibling discover_themes which starts a workflow. Uses specific verb and resource.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says when to call ('any time user asks what themes are there? mid-conversation') and that unlike discover_themes it does not start a slide-creation workflow, naming the alternative.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

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/06ketan/slideshot'

If you have feedback or need assistance with the MCP directory API, please join our Discord server