Meme Studio
Server Details
Make memes from a big catalog of templates and GIFs or your own photo, and get the finished image
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- ChatGPT
- –
- Claude
- –
TDQS
Scored across 4 tools
Each tool has a clearly distinct role: one creates memes, one fetches a single template's details, one lists trending/popular templates, and one searches the catalog. The only near-neighbour pair is popular_templates vs search_templates, but browsing-by-popularity versus searching-by-keyword is unambiguous. get_template's ability to find slots in a user-supplied image reinforces rather than confuses create_meme's image mode.
Names are all snake_case and mostly follow verb_noun (create_meme, get_template, search_templates), which is readable and predictable. popular_templates is a noun phrase without a verb, a minor deviation from the pattern, but it is self-explanatory.
Four tools is lean but covers the core loop: discover templates (search, popular), inspect slots (get_template), and produce a meme (create_meme). It is on the thin side — no tool manages previously created memes — but every tool earns its place with no redundancy.
The creation lifecycle is covered: discovery, slot inspection, and rendering with preview/final output plus an editor link. Gaps are minor — there is no way to list a full catalog page, retrieve or re-render a previously created meme, or delete saved work, all of which agents can work around via the returned editor link and search.
Available Tools
4 toolscreate_memeARead-onlyIdempotentInspect
Create a meme on exactly one of: template (a catalog id), image (your own picture in base64 or a data: URL; JPEG, PNG, WebP or GIF, up to 5 MB and 25 megapixels (16 for WebP, 8 for GIF, less for a large progressive JPEG), 100 px or more a side, at most 4:1; a GIF gives its first frame) or image_url (an https address the server downloads). Your own picture is laid out like a template, with slots found in it (see get_template). Captions go in slots, classic top/bottom positions or boxes (fractions of the image, x and y the top-left corner), plus optional author, emojis, stickers, shapes with text and a filter. The server fits and colours every caption, and may write a line break (\n) into a returned caption text, to keep a short word or a number off the end of a line, to keep a quote on one line or to break a long word after an underscore: a returned text sent back as it is comes out the same. With author, the handle goes in the first corner free of other layers, and of faces when it can: bottom right, top right, bottom left, top left. When a top and a bottom caption leave no corner free, the bottom one moves up a little to free one for the handle, given or saved by the person in the studio. Returns the link that opens the meme in Meme Studio (an editor link, never an image source), what each caption got, warnings and a picture: picture "preview" (800 px to check, the default with a template) or "final" (the finished meme at 1200 px with the invisible watermark, like the studio download; the default with your own picture, because the link cannot carry it and only reopens the captions). For a file on disk, with a terminal, do not paste its base64 yourself: pipe the tools/call JSON from the shell into curl --data-binary @-, without a temporary copy of the picture, to the server's /mcp (Content-Type: application/json, Accept: application/json, text/event-stream; no initialize needed), then decode the data of the image item in result.content from base64 into a file for the person.
| Name | Required | Description | Default |
|---|---|---|---|
| image | No | Your own picture instead of a template: JPEG, PNG, WebP or GIF in base64 (a data: URL works too), up to 5 MB and 25 megapixels (16 for WebP, 8 for GIF, less for a large progressive JPEG) | |
| author | No | The person's handle, with or without @, only if they gave it | |
| emojis | No | ||
| filter | No | ||
| shapes | No | ||
| picture | No | preview: 800 px to check (the default with a template); final: the finished meme at 1200 px (the default with image or image_url) | |
| preview | No | false: return no picture | |
| captions | Yes | ||
| language | No | Language of the person: es opens the Spanish studio, en the English one | es |
| stickers | No | ||
| template | No | Template id; or give image or image_url instead | |
| image_url | No | Your own picture instead of a template: an https address the server downloads | |
| filter_strength | No | 0 to 1; the studio default when missing |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite readOnlyHint=true, the description goes well beyond the annotations by disclosing that the return is an editor link (never an image source), that captions may come back with server-inserted line breaks, where the author handle is placed and how corners are claimed, and that captions are auto-fit and coloured. It also says what the returned picture contains (watermark, 1200 px, or 800 px preview) — none of which the annotations convey.
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 core requirement is front-loaded in the first sentence, but the body is a dense run-on with deeply nested parentheses covering caption re-fitting, handle placement and a curl/pipe recipe. Nearly all content is useful, yet the packing makes it harder to scan than it needs to be.
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 13-parameter tool with no output schema, the description carries the return-value burden well: editor link, per-caption results, warnings, and the preview/final picture distinction with defaults. Only a few low-risk parameters (language, filter_strength) and the exact response item shape are left unaddressed.
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 62% schema coverage across 13 params, the description adds real meaning: the one-of constraint among template/image/image_url, the accepted image formats and size/pixel limits including the first-frame GIF rule, and the three caption placement modes (slot, classic position, x/y box fractions). It leaves language, filter_strength, preview and several nested fields to 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 first sentence gives a specific verb and resource ("Create a meme") and immediately constrains the source to exactly one of template, image or image_url. It also names the sibling get_template as the place to find slots, so an agent can distinguish this creation tool from the discovery tools without opening a schema.
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?
It states the mutually-exclusive source rule, tells the agent to consult get_template for slots, and explains which picture default applies to which source. It also gives a concrete when-to-use-a-shell workflow for files on disk instead of pasting base64. What's missing is any explicit when-not-to-use guidance relative to popular_templates/search_templates.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_templateARead-onlyIdempotentInspect
Details of one template: names, what it is used for, tags, size, whether it is animated and its slots (the boxes where captions go). Each slot has fits_chars, about how many characters fit in it at a good size (0 is a small slot for a word or two): keep its caption under that or the text comes out small. With image: true (or show_slots: true) it also returns the picture with the slots outlined and numbered. Instead of template, give your own picture as image (base64) or image_url, as in create_meme: you get the slots found in that picture, the same ones create_meme uses with it.
| Name | Required | Description | Default |
|---|---|---|---|
| image | No | true: also return the picture with the numbered slots. Or your own picture in base64 instead of template, as in create_meme | |
| template | No | Template id from search_templates, the same you give create_meme; or give image or image_url instead | |
| image_url | No | Your own picture instead of template: an https address the server downloads | |
| show_slots | No | Also return the picture with the numbered slots, the same as image: true |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With readOnlyHint and idempotentHint already declaring the safety profile, the description adds real behavioral value: the fits_chars semantics (characters that fit before text renders small, with 0 meaning a word-or-two slot) is actionable guidance not present in annotations. It also explains that image: true / show_slots: true switches the response to an outlined, numbered picture. It does not disclose failure behavior for a bad template id or an unreachable image_url.
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 main purpose and return fields are front-loaded, and each sentence carries information. It is dense with stacked parentheticals and long clause chains, which costs a little readability but avoids filler.
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?
There is no output schema, so the description has to describe returned data, and it does so thoroughly, down to per-slot fits_chars. For a zero-required-parameter read tool with fully documented schema, the remaining gap is only edge-case behavior (invalid id, download failure).
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 parameter descriptions already state the template/image/image_url substitution and the show_slots equivalence to image: true. The description mostly restates that relationship; its only meaningful addition is confirming that slots detected in a user-supplied image are identical to those create_meme would use.
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 opens with a concrete resource and enumerates the fields returned (names, tags, size, animated, slots), so an agent knows exactly what a call yields. It also references siblings by name (template id from search_templates, semantics matching create_meme), but never explicitly contrasts this tool with search_templates or popular_templates for discovery vs. detail retrieval.
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?
It clearly lays out the two usage modes: pass a template id, or supply your own picture via image (base64) or image_url, and states the custom-image path returns the same slots create_meme uses. What's missing is any exclusion guidance – e.g. to call search_templates first when the id is unknown, or when popular_templates is the better entry point.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
popular_templatesBRead-onlyIdempotentInspect
Templates people choose most in Meme Studio: trending this week or most used overall.
| Name | Required | Description | Default |
|---|---|---|---|
| kind | No | trending | |
| limit | No | ||
| animated | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and a closed-world scope, so the safety profile is fully covered elsewhere. The description's one contribution is ranking semantics ('trending this week' vs 'most used overall'), which tells the agent the ordering changes by mode. It says nothing about result shape, ordering guarantees, or whether an empty result is possible.
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?
A single compact sentence that front-loads the resource and then the two modes. Nothing is wasted, though the fragment style ('Templates people choose most in Meme Studio:') is slightly less direct than a verb-first phrasing would be.
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 three-parameter tool with no output schema and 0% schema description coverage, the description should at minimum explain what 'limit' caps and what 'animated' filters. Neither is addressed, so an agent must guess at two of the three inputs. Annotations cover the safety story, which keeps this from a 1.
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 0%, so the description must carry parameter meaning. It only implicitly explains the 'kind' values (trending/most used) and leaves 'limit' (max 30) and 'animated' (a filter, presumably) entirely unexplained in both schema and description. 'Animated' in particular is ambiguous — filter vs. include — and the description does nothing to resolve it.
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 names the resource (templates) and the discriminating characteristic (most popular), and splits it into two concrete modes: trending this week and most used overall. That maps cleanly onto the sibling get_template/search_templates distinction by signalling this is a ranked, popularity-ordered list rather than a lookup or query. The retrieval verb itself is only implied ('Templates people choose most'), which keeps it from a 5.
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?
Usage is implied rather than stated: an agent can infer this is the tool to call when it wants popular template suggestions rather than a specific template or a keyword search. There is no explicit 'use this instead of search_templates when...' guidance, and no mention that it takes no required parameters, so selection still relies on inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_templatesARead-onlyIdempotentInspect
Search the Meme Studio catalog by name, keywords or what the meme is used for (intent), in Spanish or English. Best matches first, each with what it is used for.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| query | Yes | The joke, the situation or the template name, in any language | |
| animated | No | true: only animated templates; false: only still ones |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, non-destructive and closed-world semantics, so the safety profile is covered. The description adds genuinely new behavior: results are relevance-ranked ('best matches first') and each result carries its intended use, which matters since there is no output schema. Pagination and empty-result behavior remain undisclosed.
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 compact sentences, front-loaded with the action and scope. There is mild redundancy between 'what the meme is used for (intent)' and the closing 'each with what it is used for', but nothing is wasted overall.
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?
With no output schema and only three parameters, the description covers the essentials: what is searched, in which languages, how results are ordered, and what each result contains. It stops short of explaining result-set sizing or how 'limit' bounds the response, which would complete the picture.
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 67%: query and animated are documented in the schema, while limit has no description anywhere. The description adds the intent/'what the meme is used for' search dimension and notes Spanish or English input, which slightly extends the schema's 'any language' phrasing, but the limit parameter stays opaque.
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?
States a specific verb and resource ('Search the Meme Studio catalog') plus the three search axes: name, keywords and intent, with multilingual coverage and relevance ordering. The search-vs-lookup distinction against siblings like get_template and popular_templates is inferable but never stated explicitly.
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?
Usage is implied: this is the tool for finding a template when you have a joke, situation or name in mind. There is no explicit when-to-use vs. when-not guidance and no routing to get_template (single fetch) or popular_templates (browse without a query).
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.
4 tool updates
- First observed
create_meme - First observed
get_template - First observed
popular_templates - First observed
search_templates
Related MCP Connectors
Search 400+ meme templates, see what's trending, and render memes with your captions.
Search 25,000+ meme templates and create shareable memes on memebo.at. Free, anonymous, no API key.
Imgflip MCP — wraps Imgflip API (free, no auth for template listing)
AI meme video templates: how-tos, recommended settings, example prompts and FAQ. Free, no key.
Related MCP Servers
- AlicenseBqualityDmaintenanceGenerates custom memes with text overlays using pre-configured templates. Supports multiple meme formats with customizable text positioning, fonts, and automatic word wrapping.2MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI assistants to create memes by searching 400+ classic templates, inspecting their caption slots, and rendering captioned images with permanent PNG URLs. Also surfaces trending templates and supports adjustable aspect ratios.MIT

Memeboat MCPofficial
AlicenseAqualityCmaintenanceSearch 25,000+ meme templates and create shareable memes directly from your AI assistant.384 npm2MIT- AlicenseNot gradedqualityBmaintenanceLets users describe a situation and get five captioned memes in an editable editor, with optional server-side PNG rendering for hosts that cannot display the editor.2MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.