Leonardo.ai MCP. Control the entire visual asset pipeline, from prompt to final audit.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Leonardo.ai MCP Server connects your AI client to a full suite of generative image tools. Generate high-fidelity visuals using specific models, audit usage metrics, manage custom model libraries, and refine images with context extensions—all from natural conversation.
What your AI agents can do
Create variation
Generates an unzoom context extension to expand a visual image created by Leonardo.ai.
Delete generation
Removes specific image generation history logs and the associated images from your account.
Generate image
Creates new images based on a text prompt, returning an ID that lets you poll for the final result.
You provide a text prompt and the agent runs the generation job, returning a unique ID you can use later to check status or retrieve results.
The server retrieves your current token balance, daily limits, and total generations performed for your account.
You list all fine-tuned models trained specifically on your Leonardo instance, ensuring you use the right model for a specific style.
The agent takes an existing image and generates context extensions or variations around it, keeping the visual structure intact.
You list past generations, retrieving not only the images but also the specific prompts and model metadata used to create them.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
Leonardo.ai (Generative AI & Models) MCP Server: 10 Tools for Visual Assets
Use these tools to manage every step of image generation, from listing available models and prompting new visuals to auditing history logs and refining assets.
019d75c6create variation
Generates an unzoom context extension to expand a visual image created by Leonardo.ai.
019d75c6delete generation
Removes specific image generation history logs and the associated images from your account.
019d75c6generate image
Creates new images based on a text prompt, returning an ID that lets you poll for the final result.
019d75c6get generation
Checks the current status or retrieves the completed image result of a previous generation job using its unique ID.
019d75c6get model
Retrieves specific details and parameters for any defined Leonardo.ai model.
019d75c6get user
Fetches your active authenticated Leonardo AI user metrics, including token usage and limits.
019d75c6list custom models
Lists all fine-tuned or custom-trained models that exist explicitly on your personal Leonardo instance.
019d75c6list platform models
Lists every global, public model available across the entire Leonardo.ai platform.
019d75c6list user generations
Retrieves a list of all image generations previously initiated by your account.
019d75c6upload init image
Acquires a secure URL for uploading an initial image dataset used in guided or reference-based generation tasks.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Leonardo.ai (Generative AI & Models), then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
What you can do with this MCP connector
Connect your AI client to Leonardo.ai's whole suite of image tools. You can generate high-fidelity visuals, manage custom models, audit usage metrics, and refine images using context extensions—all just by talking to your agent.
Generating Images from Scratch
When you need a new visual, you give the agent a text prompt; it runs the generation job and returns a unique ID. You'll use that ID later if you gotta check the status or grab the final picture. If you wanna create multiple images, your client can list every global model available across the whole Leonardo platform using list_platform_models, giving you options like Phoenix or Kino XL.
When you decide on a specific style, you've got to use get_model to pull up all the parameters for that exact model.
Refining and Extending Visuals
Got an image you love but it needs more? You can upload an initial image dataset using upload_init_image; this grabs a secure URL so your agent knows how to reference it. From there, you can create variations of existing art or generate unzoom context extensions with create_variation, which expands the visual while keeping the structure locked down.
If you wanna use an existing piece as a guide for a new generation, that initial image upload is what lets you do it.
Managing Your Models and Work
Want to make sure you're using the right style? The server lets you check all the custom-trained or fine-tuned models saved directly on your personal Leonardo account with list_custom_models. You can also track every single image generation job that left your account by running list_user_generations; this list gives you not only the images but also the specific prompts and model details used when they were made.
If something went wrong or you just want a clean slate, you can delete specific history logs and the associated pictures using delete_generation.
Checking Your Account Status and History
You gotta keep tabs on your usage. To see how much juice you've got left, your client runs get_user, which fetches your current token balance, any daily limits, and your total generation count for the account. If you run a job and need to know when it’s done or what the final result was, you use that unique ID with get_generation to check its status or retrieve the finished image.
This whole system keeps track of everything so you never hit an unexpected budget wall.
How Leonardo.ai MCP Works
- 1 Subscribe to this server and enter your Leonardo.ai API Key into your AI client.
- 2 Tell your agent what you need—for example, 'Generate a futuristic cityscape using the Phoenix model.'
- 3 The agent executes
generate_image, gets a Generation ID, monitors its status withget_generation, and returns the final high-resolution links when done.
The bottom line is: you talk to your agent like talking to a teammate, and it handles all the complex API calls needed to generate and manage visual assets.
Who Is Leonardo.ai MCP For?
This server is for digital artists, product designers, and marketing content teams who are tired of jumping between Leonardo.ai's dashboard sections (generation page, model tab, history log). It puts all generation control—from basic prompting to complex asset auditing—directly into your AI client.
You use the agent to iterate on visual concepts. Instead of manually adjusting prompts and re-running, you ask for variations using create_variation and analyze what works immediately.
You automate batch asset production. You can run multiple generations and then use list_user_generations to audit which images were used in the last campaign, tracking prompts and models.
You manage resources. You monitor team token usage using get_user and ensure that the right custom model is selected for every major project rollout using list_custom_models.
What Changes When You Connect
- Manage Your Budget: Use
get_userto check token usage and daily limits in real time. You won't accidentally run a massive generation job that blows your budget mid-project. - Stay Organized: Instead of digging through dashboards, use
list_user_generationsto pull up every asset you made last week. You get the prompt, model UUID, and image URL all in one place. - Target Specific Styles: Need a specific look? Use
list_custom_modelsto see exactly which fine-tuned models are available on your account before running any expensive prompts. - Refine Without Redoing: Don't start from scratch. Upload an image using
upload_init_image, then ask the agent to use it for a guided variation, saving time and maintaining consistency. - Know Your Options: The server separates global tools (
list_platform_models) from your personal ones (list_custom_models), letting you choose the right model every single time.
Real-World Use Cases
The Branding Refresh
A marketing team needs 20 variations of a character portrait. Instead of running 20 separate prompts, they ask their agent to generate_image once, and then chain the action by calling create_variation. The agent handles this loop, giving them 20 consistent starting points instantly.
The Historical Audit
A creative director needs to prove which assets were used in Q1. They ask their agent to run list_user_generations. The agent returns a list of all past jobs, allowing the director to verify not just the image, but the exact prompt and model UUID used.
The Model Selection Dilemma
A designer needs an asset that matches a specific brand aesthetic. They first run list_custom_models to see if their team trained a suitable style. If it exists, they use get_model to verify its parameters before running the final generation.
The Clean Slate
An art director is finished with a test project and needs to clear out old data cluttering the account history. They instruct their agent to use delete_generation on specific job IDs, keeping the dashboard clean for the next quarter.
The Tradeoffs
Assuming All Prompts Work
The user runs a complex prompt but forgets which model UUID was used. They then can't replicate the asset because they don't know if it came from Phoenix or Kino XL.
→
Always check your sources first. Run list_user_generations to retrieve the full metadata for past jobs, confirming the exact model and prompt that created the asset.
Over-relying on General Prompts
A user prompts for a 'sci-fi portrait' but gets inconsistent results because they didn't specify which pre-trained style or custom model to use.
→
Before generating, run list_platform_models and list_custom_models. Specify the exact model UUID in your prompt—e.g., 'Use the Phoenix model (UUID: 123) for this sci-fi portrait.'
Ignoring Asset State
The user tries to refine an image that hasn't finished generating yet, resulting in a failed create_variation call and wasted tokens.
→
Never assume status. After running generate_image, immediately use get_generation with the returned ID until the server reports 'COMPLETED'. Only then should you attempt to refine it.
When It Fits, When It Doesn't
Use this MCP Server if your workflow is heavily focused on iterative, high-volume visual content creation and detailed asset lifecycle management. If you need to know what was made (history), how it was made (model UUID/prompt), or if the account has enough credit (get_user), this server is essential.
Don't use this if your primary goal is general data fetching, like listing contacts or managing inventory records. For those tasks, you need a different type of connector—a standard CRM or database API. This tool only deals with image generation and the unique metadata around that process.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Leonardo.ai. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This server provides 10 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Diving into the dashboard to manage assets is slow.
Today, if you want to check your account credits or see what generated last month, you have to navigate multiple tabs in the web interface. You click 'History,' find the job ID, then copy that URL and paste it somewhere else just to check the final asset details. It's a multi-step, manual process.
With this MCP server, your agent handles all those clicks for you. Just ask: 'What was my token usage last week?' or 'Show me the 5 most recent generations.' You get the data instantly in conversation—no dashboard jumping required.
Leonardo.ai (Generative AI & Models) MCP Server
Previously, creating a variation meant starting over or manually uploading the original image into a secondary workflow section. The process was clunky and often lost structural context.
Now, you simply ask your agent to refine it: 'Expand this landscape.' It takes care of running `create_variation` in the background. You get high-quality expansions with structural consistency, every time.
Common Questions About Leonardo.ai MCP
How do I check my remaining tokens using the generate_image tool? +
You use the get_user tool to retrieve active account metrics. This call reports your current token balance and daily limit without affecting any generation credits.
Does list_platform_models show my custom models too? +
No, it only shows public, global models hosted on Leonardo.ai. To see the styles trained by your team, you must use list_custom_models.
What is the difference between generate_image and create_variation? +
generate_image starts from scratch using a prompt. create_variation, however, takes an already existing image and expands or modifies its context based on that original visual.
How do I get the result of a generation job if it's running? +
You run generate_image first to get the ID. Then, you use get_generation and pass that specific ID repeatedly until the status changes from 'PENDING' to 'COMPLETED'.
When I use upload_init_image, how secure is my input data for image-to-image generation? +
It provides a temporary, presigned URL. This means the client uses that specific link to track and upload your initial image dataset, ensuring the file access is protected and limited only to that inference job.
Does delete_generation completely remove all records of an old generation? +
Yes, it explicitly removes both the entire generation history log entry and the associated image files from your account. Use this when you need a complete wipe of specific data.
Before I run generate_image, what details can I check using get_model? +
It pulls detailed parameters for any specified model UUID. This lets you verify technical constraints—like required aspect ratios or supported input resolutions—before your generation attempt.
If I need to audit my account limits, how does get_user help me beyond checking tokens? +
It gives a full breakdown of active user metrics. You can check things like daily generation caps and usage history across the entire billing cycle, not just token consumption.
Can I check the progress of my image generation through my agent? +
Yes. Use the get_generation_status tool with the Generation ID provided when you started the request. Your agent will poll the Leonardo API and return the final image URLs and metadata once the process is complete.
How do I find which AI models are available for generation? +
Ask your agent to list_platform_models or list_custom_models. It will return a list of available UUIDs and model names (like Phoenix or Kino XL), which are required when triggering a new image generation request.
Can my agent perform image-to-image transformations? +
Absolutely. Use the upload_init_image tool to acquire a secure presigned URL for your source image. Once uploaded, you can command your agent to trigger a generation that uses that image as a reference for guided AI transformations.
Multi-server workflows that include Leonardo.ai (Generative AI & Models) MCP
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
AI21 Labs
Access state-of-the-art language models for text generation, summarization, and semantic understanding at enterprise scale.
LanceDB (Serverless Vector DB)
Manage vectorized data via LanceDB — perform similarity searches, create tables, and manage multi-modal embeddings.
Baidu Qianfan
Orchestrate Baidu Qianfan AI models — manage chat completions, embeddings, and prompt templates directly from any AI agent.
You might also like
Linear
Streamline issue tracking and project management via Linear — list teams, query issues, create comments and inspect cycles directly from any AI agent.
Text Diff Engine
Exact character-by-character string comparison. Stop relying on LLM summaries and get absolute text diffs for code and contracts.
Nubank MX
Manage your Nubank Mexico banking from any AI agent — check balances, review transactions, send SPEI transfers, pay bills, and track spending analytics.