This server connects AI assistants to Ridvay Studio, enabling creation, editing, and management of graphic designs (posters, flyers, social media posts) directly from chat.
Generate designs from a text brief: Describe what you want and Ridvay's AI engine creates the design automatically (~20–40 seconds, uses generation credits). Supports square, story, portrait, landscape, A4, slide, or custom canvas sizes.
Compose your own designs: The AI assistant builds the layout using Ridvay's design IR format and saves it to Ridvay for rendering — no Ridvay-side AI generation consumed, giving full creative control.
Learn the design format: Retrieve the Ridvay design IR specification (element types, fonts, backgrounds, worked examples) to compose designs from scratch.
Edit existing designs: Apply natural-language edits to a previously created design (e.g., "make the headline red", "switch to a dark theme") using a design ID.
Check rendering status: Poll whether a design's AI-generated images have finished rendering and retrieve updated view/share/edit links.
Sharing control: Publish designs as unlisted public share links or keep them private to the account.
Brand Kit integration: Optionally apply the account's brand colors, fonts, and logo when generating or refining designs.
Allows GitHub Copilot (VS Code agent mode) to create and edit Ridvay Studio posters, flyers, and social designs directly from chat.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@ridvay-mcp Create a poster for our weekend flash sale – 30% off everything"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP (Model Context Protocol) server that lets AI assistants — Claude Code, Claude Desktop, GitHub Copilot (VS Code agent mode), Cursor, and any other MCP client — create and edit Ridvay Studio posters, flyers, and social designs straight from a chat conversation.
Every design comes back as a working share link (ridvay.com/d/…) plus links to open and
edit it in the Studio editor.
The same server runs at https://mcp.ridvay.com (streamable HTTP). Two ways to authenticate:
URL with your key — for clients that add connectors by URL and cannot set headers (claude.ai custom connectors, ChatGPT connectors): https://mcp.ridvay.com/mcp/sk-ridvay-…. Treat that URL like the key itself; revoke it any time at ridvay.com/user/api-keys.
Bearer header — for clients that support headers: https://mcp.ridvay.com/mcp with Authorization: Bearer sk-ridvay-…. Claude Code: claude mcp add --transport http ridvay https://mcp.ridvay.com/mcp --header "Authorization: Bearer sk-ridvay-…".
Try it without an account — https://mcp.ridvay.com/mcp/demo is a sandbox: no key, no sign-up, the free tools only (design guide, compose a design, render, export PNG, share). Designs made there are public and may be removed; it is rate-limited per network. Claude Code: claude mcp add --transport http ridvay-demo https://mcp.ridvay.com/mcp/demo.
Sign in (OAuth 2.1) — for clients that support MCP OAuth (claude.ai custom connectors, ChatGPT connectors/plugins, Claude Code, Cursor, MCP Inspector): add https://mcp.ridvay.com/mcp with no key, and the client discovers api.ridvay.com as the authorization server, registers itself (Dynamic Client Registration) or presents a Client ID Metadata Document, and sends you to ridvay.com/oauth/consent to approve. The token it receives is a normal Ridvay API key named " (OAuth)", so you can revoke it any time from your account page (or the client can call the revocation endpoint).
list_designs, share_design (view / edit / live-image / screen links), get_values and set_values
(update a design's declared {{variables}} — a menu board or price board that refreshes itself on the
/screen/<id> page and the /img/<id>.png live image), and list_brands (pass brand_id to generate_poster).
Related MCP server: KieAI MCP
Every frame of that GIF was designed and rendered by this MCP server — a four-page design
composed as design IR, saved with create_poster, then exported page by page with
export_poster. No screen recording, no image editor.
Tool | What it does |
| Start here — the design-IR authoring spec (element types, backgrounds, fonts, worked example) that teaches your assistant to compose designs itself. |
| The preferred path: your assistant composes the design as Ridvay design IR — Ridvay only stores, renders, and shares it. Fast, free, full creative control. |
| Fallback: Ridvay's AI designs from a text brief (slower, consumes the account's generation credits). |
| Turn an existing design image (poster photo, screenshot, export — file path or URL) into an editable design: text becomes editable, shapes become vectors, imagery is re-rendered fresh. Slow (1–4 min), uses generation credits. |
| Natural-language edit of an existing design ( |
| Report whether a design's AI images finished rendering and return its links + view count ( |
| Render a design to a downloadable PNG/JPEG at its native pixel size ( |
| Add motion (entrance/exit, page transitions, morph) — blank for a tasteful default, or describe it. |
| Render an animated design to a downloadable H.264 MP4 (optional looped soundtrack). |
| Poll an async |
Your AI client is the designer; Ridvay is the save/render/share backend. Client-authored
designs may still include prompt image slots — Ridvay renders those server-side after
creation. generate_poster remains for when the assistant can't compose the design itself.
Export & motion: export_poster gives you the actual poster image at its real dimensions
(e.g. a 1080×1350 PNG), not the share page. For animation, either include motion fields when
you compose the design (see the guide) or call animate_poster, then export_video for an MP4.
size accepts 1080x1080 (default), 1080x1920 / story, 1080x1350, 1920x1080,
a4, slide, or any WxH.
Every shared design also gets an always-current image URL — each fetch re-resolves the
design's live data bindings ({{time.now}}, countdowns, JSON feeds, declared {{vars}}),
so an embedded image never goes stale (re-rendered at most every 60 s):
https://ridvay.com/img/{designId}.pngDeclared vars are filled from query params, which makes personalized email images a one-URL job with your ESP's merge tags:
https://ridvay.com/img/abc123.png?name=*|FNAME|*A .jpg variant plus page, scale, w, and quality params are supported — see
get_design_guide ("Live data bindings + live image URL") for the bindings format (including
the reserved param names that can't double as binding/var keys).
Every live-image load and every /d/ share-page view counts toward the design's view
count — check_poster reports it as Views: N.
Sign in and create a key at ridvay.com/user/api-keys. Designs generated through MCP appear in your own My designs.
Claude Code
claude mcp add --scope user ridvay --env RIDVAY_API_KEY=sk-ridvay-… -- npx -y ridvay-mcpClaude Desktop — add to claude_desktop_config.json
(macOS: ~/Library/Application Support/Claude/claude_desktop_config.json):
{
"mcpServers": {
"ridvay": {
"command": "npx",
"args": ["-y", "ridvay-mcp"],
"env": { "RIDVAY_API_KEY": "sk-ridvay-…" }
}
}
}VS Code / GitHub Copilot agent mode — add to your user mcp.json
(Command Palette → "MCP: Open User Configuration"), then enable ridvay in the
Copilot Chat tools picker:
{
"servers": {
"ridvay": {
"type": "stdio",
"command": "npx",
"args": ["-y", "ridvay-mcp"],
"env": { "RIDVAY_API_KEY": "sk-ridvay-…" }
}
}
}Then ask your assistant things like:
Generate a story-size poster for our weekend flash sale — 30% off everything, Saturday only.
A poster, straight from a brief
Generate a story-size poster for our weekend flash sale — 30% off everything, Saturday only.
A promo video, end to end — design, animation, and MP4 in one turn:
Using the ridvay MCP, create a 3-page 1080x1920 promo video design about [topic]. Page 1: a bold hook. Page 2: three or four key points with accent bars. Page 3: a worked example plus a call to action. Dark navy background, blue accents, Poppins headlines. Then animate it with snappy staggered entrances and morph transitions, and render it to MP4.
An existing design, made editable again
Recreate ~/Desktop/last-years-flyer.png as an editable design, then change the date to October 3rd and set the headline in our brand blue.
An image that never goes stale — live bindings resolve on every fetch:
Build a 1080x1080 status card with today's date and a countdown to our September 1 launch, then give me the live image URL.
A longer walkthrough of the video example, with the agent's actual tool sequence, is on the blog: Ridvay MCP: free AI design generation from Claude Code.
Var | Required | Meaning |
| yes | Your Ridvay API key ( |
| no | Default |
| no | Base for returned links, default |
| no | Admin/platform keys only: act on behalf of a specific user. |
Sharing: generate_poster / create_poster create an unlisted public share link by
default so the chat reply contains a working /d/{id} URL. Pass share: false to keep
a design private to your account (only the Studio edit link is returned).
Deferred images: generation returns as soon as the layout is ready; AI/stock images
render server-side in the background (~1 min). check_poster reports on and, if
needed, re-triggers that pass.
Content and usage data from the MCP (such as prompts and generated designs) may be used to
improve Ridvay's products, services, and AI features. Requests include basic attribution:
the connecting MCP client's name/version and, when the assistant provides the optional
agent_model argument, the model id that authored the design.
npm install
npm run build # emits dist/
npm test # vitest unit suite
node dist/index.js # run the stdio server directly (needs RIDVAY_API_KEY)MIT © Ridvay
Check whether a generated Ridvay design has finished rendering its AI images, and get its view/edit links again. Use after generate_poster reports images still rendering.
| Name | Required | Description | Default |
|---|---|---|---|
| design_id | Yes | The design ID returned by generate_poster. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It explains the tool checks rendering status and returns links, but does not disclose potential error behavior, permissions needed, or side effects. The description is 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 two sentences long, front-loaded with the purpose, and contains no unnecessary information. Every word adds value.
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 one-parameter tool without an output schema, the description covers the essential aspects: purpose, when to use, what it returns (status and links). Minor lack of details on error handling, but sufficient for selection and invocation.
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%, with the parameter description stating 'The design ID returned by generate_poster.' The tool description adds extra context by specifying that this tool is used after generate_poster, enhancing the parameter's meaning beyond 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 checks if AI images have finished rendering for a generated Ridvay design and retrieves view/edit links. It distinguishes from sibling tools by specifying it is used after generate_poster indicates ongoing 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?
The description explicitly says 'Use after generate_poster reports images still rendering,' providing clear context for when to use this tool. It implies not to use it if rendering is complete, but does not explicitly state 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.
Save a poster design that YOU (the assistant) composed as Ridvay design IR — you control every element, color, and font; Ridvay only stores, renders, and shares it. No Ridvay-side AI generation is involved. Call get_design_guide first for the IR format. Use generate_poster instead when Ridvay's AI should do the designing. Returns view/share/edit links.
| Name | Required | Description | Default |
|---|---|---|---|
| share | No | Create an unlisted public share link (/d/…). Default true; set false to keep the design private to the account. | |
| design | Yes | The full design IR document (see get_design_guide): { version, type: "design", title, pages: [{ width, height, background, elements }] }. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite no annotations, the description reveals important behaviors: no AI generation, user controls all elements, and returns view/share/edit links. It could be more specific about validation or side effects but is quite transparent.
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 three succinct sentences, each adding essential information with no redundancy. It is front-loaded with the core action and immediately provides prerequisite and alternative guidance.
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 nested design object and no output schema, the description covers the prerequisite, return format, and key behavioral aspects. It could mention overwrite behavior or identification details but is largely complete.
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 adds value by reminding to use get_design_guide for the design parameter's IR format and explaining the share parameter's default and privacy implications beyond 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's verb ('Save a poster design') and resource ('Ridvay design IR'), and distinguishes it from related tools. It specifies that the user controls every element and Ridvay only stores/renders/shares, leaving no ambiguity.
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 calling get_design_guide first for the IR format and using generate_poster when AI should do the designing, providing clear when-to-use and when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate a poster, flyer, social-media post, story, banner, or any graphic design from a text brief using Ridvay Studio's AI design engine. Returns links to view, share, and edit the design. Describe the content, occasion, style, and any text that must appear. Typical run time is 20–40 seconds.
| Name | Required | Description | Default |
|---|---|---|---|
| size | No | Canvas size hint. Accepts "1080x1080" (square post, default), "1080x1920" or "story" (vertical story), "1080x1350" (portrait post), "1920x1080" (landscape), "a4" (print poster), "slide" (presentation). | |
| share | No | Create an unlisted public share link (/d/…) for the poster. Default true; set false to keep the design private to the account. | |
| prompt | Yes | The design brief: what the poster is for, the exact text/wording to include, desired mood/style/colors. More detail gives better results. | |
| use_brand | No | Apply the account's Brand Kit (colors, fonts, logo). Default false. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavior. It mentions the generation process, output (links to view/share/edit), and typical run time. It does not cover rate limits, errors, or destruction behavior, but the creation action is implied.
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?
Three sentences, each serving a distinct purpose: what the tool does, what it returns, and how to use it. No unnecessary words; front-loaded with key 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?
No output schema exists, so the description adequately explains the return value (links). It covers parameters, usage advice, and run time. Missing details like error handling or success conditions, but sufficient for a generation tool with 4 simple parameters.
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 100% coverage, providing a solid baseline. The description adds value by explaining the structure of the prompt ('content, occasion, style, text'), clarifying the 'share' parameter, and giving examples for 'size'. This enriches understanding beyond 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 specifies the verb 'generate' and the resource 'graphic design', listing multiple output types (poster, flyer, social-media post, etc.) and distinguishing from siblings like 'check_poster' and 'refine_poster' by emphasizing AI generation from a text brief.
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 users to describe content, occasion, style, and required text, and notes typical run time. It does not explicitly state when not to use this tool or mention alternatives like 'create_poster', but the usage context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns the Ridvay design IR format (JSON contract, element types, fonts, backgrounds, worked example) so YOU can compose a poster design yourself and save it with create_poster. Always call this before your first create_poster call.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It describes the tool as returning a design guide and implies it is a read-only operation, but does not detail permissions, side effects, or other 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two sentences. Each sentence adds value: the first states what it returns, the second provides the usage context. No extraneous 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?
Given the tool has no parameters and no output schema, the description sufficiently explains its role among siblings (get_design_guide is a prerequisite for create_poster). It lists key components of the returned guide, though a full format specification is not provided.
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 zero parameters, and schema coverage is 100% (no params). The description adds context by explaining the purpose and contents of the returned data, which compensates for the lack of an output 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 states explicitly that the tool returns the Ridvay design IR format including JSON contract, element types, fonts, backgrounds, and a worked example. It clearly distinguishes from siblings (like create_poster) by positioning itself as a prerequisite step.
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 clear guidance: 'Always call this before your first create_poster call.' This tells the agent exactly when to use the tool, though it does not explicitly list conditions when not to use it or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Edit a previously generated Ridvay design with a natural-language instruction (e.g. "make the headline red", "add our opening hours", "swap to a dark theme"). Requires the design ID returned by generate_poster.
| Name | Required | Description | Default |
|---|---|---|---|
| design_id | Yes | The design ID returned by generate_poster. | |
| use_brand | No | Re-apply the account's Brand Kit while editing. Default false. | |
| instruction | Yes | What to change, in plain language. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It describes the core action (edit via natural language) and mentions brand kit re-application. But it omits behavioral traits such as whether edits are destructive or reversible, idempotency, or authentication needs.
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, front-loaded with purpose and a helpful parenthetical list of instructions. No wasted words; every sentence earns its place.
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, the description explains usage for a modification tool. However, it lacks details on return values, error conditions, or scope of changes. Adequate but leaves gaps.
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% with descriptions for all 3 parameters. The description adds value by clarifying the source of design_id and providing instruction examples, but does not significantly enhance the meaning of use_brand beyond 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 verb 'Edit' and resource 'previously generated Ridvay design', with concrete examples. It is specific and distinguishable from siblings like generate_poster (creation) and check_poster (status).
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 states prerequisite: 'Requires the design ID returned by generate_poster.' Provides example instructions. However, it does not mention when not to use this tool or compare directly to alternatives like create_poster.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.0check_postercreate_postergenerate_posterget_design_guiderefine_posterEach tool has a clearly distinct purpose: get_design_guide provides the format for manual design, create_poster saves a manual design, generate_poster creates with AI, check_poster checks rendering status, and refine_poster edits existing designs. No overlap in functionality.
All tool names follow consistent verb_noun snake_case pattern (e.g., check_poster, create_poster, generate_poster, get_design_guide, refine_poster). No mixing of conventions or styles.
With 5 tools, the server is well-scoped for its purpose. Each tool is necessary for the core workflow of creating and managing graphic designs, without bloat or deficiency.
The tool surface covers the main lifecycle: creation (manual and AI), status checking, and editing. Missing a delete or list tool is a minor gap, but the core design workflow is complete.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
MCP server for Midjourney AI image generation and editing
An MCP server that integrates with Discord to provide AI-powered features.
The Canva MCP server connects AI assistants (like Claude, ChatGPT, and Cursor) to Canva's API, enabling them to create and manage designs directly within chat conversations. Key capabilities include generating new designs from prompts, autofilling templates, searching and resizing existing designs, importing files from URLs, exporting designs as PDFs or images, and managing folders and comments without switching between tools.
MCP server for Flux AI image generation
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/tom-tgr/ridvay-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
