Luma MCP tools let an AI assistant call Luma AI's Ray video models and Photon image models directly, so you can generate, extend, and upscale clips from a chat window or an agent script instead of clicking through a dashboard. In 2026 there are three real categories: the official server from Luma Labs, community servers built on the Dream Machine API, and multi-model platforms that expose Luma alongside dozens of other models. Wireflow sits in the third group, chaining Luma with image, audio, and editing models on one visual canvas. This guide ranks eight options by what they actually do, what they cost you in setup time, and where each one breaks down.
Quick Summary
- Wireflow: visual canvas plus MCP access to Luma and 100+ other models. Best Overall
- Luma API MCP (official): first-party server for Ray and Photon. Best Official Option
- luma-ai-mcp-server (bobtista): deepest Dream Machine tool coverage. Most Complete Community Server
- AceDataCloud LumaMCP: hosted API wrapper with task tracking. Best for Quick Setup
- fal: fast hosted inference for Luma and rival video models. Best for Speed
- Replicate: versioned model hosting with a broad catalog. Best for Version Control
- CometAPI: one key across many providers. Best Aggregator
- Smithery: registry and hosting layer for MCP servers. Best for Discovery
What a Luma MCP Tool Actually Does
The Model Context Protocol lets an assistant like Claude or Cursor discover and call external tools. A Luma MCP server wraps the Dream Machine API as those tools: create a generation from text or from a start and end keyframe, poll a job, extend a clip, upscale it, or check your credit balance. The assistant reasons, the server calls the API, and you never touch a request body. For a walkthrough of the same pattern applied to a full pipeline, the 'luma mcp' feature page shows the node setup end to end.
The difference between these tools is not the model, since every option below eventually hits Luma's Ray family. It is what happens around the generation: whether jobs are tracked for you, whether output can feed a second model, and whether you maintain a local process. That last point splits the list cleanly between self-hosted servers and hosted platforms like the ones covered in our MCP servers for video editing roundup.
1. Wireflow: Best Overall
Wireflow is a node canvas with an MCP server in front of it, so an agent triggers a whole workflow rather than a single Luma call. A real Luma job is rarely one generation: a prompt cleaned up by an LLM, a still used as a keyframe, a Ray render, an upscale, an audio pass. On a canvas those are five connected nodes you rerun with one input change, and the model chaining guide covers how the handoffs are wired.
The tradeoff is honest: if all you want is "generate a 5 second clip from this sentence," a single-purpose Luma server is less machinery. Wireflow earns the top spot when the output has to be finished rather than raw, when the same recipe runs across many inputs, and when you want the model choice to stay swappable. Pricing is credit based per node run, listed on the pricing page, so a chain that touches four models costs four charges rather than a flat seat fee.
2. Luma API MCP (Official)
The official server from Luma AI is powered by the Ray video and Photon image models, and it is the safest bet for API accuracy. When Luma ships a parameter, the first-party server gets it first, unlike community wrappers that lag a release behind. Setup is one MCP config entry plus a Luma API key.
What you do not get is orchestration. The server returns a generation id and a URL; whatever happens to that file next is your problem. Teams who need it to land somewhere specific pair it with a second layer, the same reason developers reach for a hosted video API for agents instead of raw endpoints.
3. luma-ai-mcp-server (bobtista)
The community server from bobtista covers the widest set of Dream Machine v1 operations here: create, list, status-check and delete generations, keyframe interpolation, extending and reversing clips, upscaling, image generation with reference, style and character images, generated audio, and credit and camera-motion queries. It is the closest thing to a full Dream Machine console exposed as tools.
Because it is community maintained, treat the repo's last commit date as part of your evaluation. It runs locally over stdio, so it fits a single developer machine well and a shared team environment poorly. If several people need the same capability, a shared endpoint of the kind described in our Claude to video editing setup is the sturdier pattern.
4. AceDataCloud LumaMCP
AceDataCloud ships an MCP server that calls Luma Dream Machine through its own hosted API, supporting text to video, image to video, extension, multiple aspect ratios, looping clips, clarity enhancement, and task tracking. Task tracking is the useful part: video jobs take minutes, and a server that polls for you removes the most common failure in agent scripts, an assistant declaring success on a job that has not rendered.
The cost of that convenience is a second vendor between you and Luma, with its own pricing, rate limits, and outage surface. It is a reasonable trade when you want a Luma tool working in an afternoon, and a poor one when you need per-call cost transparency of the kind we broke down in the Seedance pricing comparison.
5. fal
fal is an inference host rather than a Luma-specific tool, and it is here because it runs Luma models next to competing video models on one account and one key. A/B testing becomes trivial: swap the model string, rerun the same prompt. Cold start times are among the fastest in the category, which matters when an agent is waiting.
You are working at the model endpoint level here, so job tracking, retries, and file storage are yours to build. Our fal MCP walkthrough covers what that plumbing looks like in practice.
6. Replicate
Replicate pins every model to an immutable version hash, which is the single best reason to use it: a pipeline that produced a specific look six months ago still produces it today. For studios with approved visual standards, that reproducibility is worth more than raw speed.
The catalog structure means Luma models arrive through community or partner listings, so availability of the newest Ray release can trail the official API. Predictions are also billed by compute time rather than per clip, which makes cost forecasting harder; teams who outgrew that model often follow the path in our Replicate to canvas migration guide.
7. CometAPI
CometAPI aggregates hundreds of models behind one key and one billing relationship, Luma's Ray line included. If your stack already calls several providers, collapsing them into a single account removes real accounting overhead, and its published notes on Ray3's step-based generation are a decent primer on what the model is doing internally.
Aggregators trail first-party APIs on new parameters, and you inherit the aggregator's uptime. Use it for breadth and convenience, not for day-one access to a new Luma feature. The same tradeoff shows up across AI video generation MCP tools generally.
8. Smithery
Smithery is not a Luma tool; it is how you find and run one. It indexes MCP servers, including the Luma servers above, and can host them so you skip local installs and config file editing. For anyone evaluating three candidates in an hour, that is the fastest route to a working comparison.
Hosting someone else's server means your Luma API key lives with a third party, so read the deployment model before pasting credentials. Registries are best treated as a discovery step ahead of a decision, similar to how the n8n versus MCP comparison frames automation choices.
Comparison Table
| Tool | Type | Luma coverage | Job tracking | Multi-model chaining | Best for |
|---|---|---|---|---|---|
| Wireflow | Canvas + MCP | Ray and Photon via nodes | Yes | Yes | Finished outputs, repeatable recipes |
| Luma API MCP | Official server | Full, first-party | Manual | No | Accuracy and new features |
| bobtista server | Community server | Widest tool set | Manual | No | Solo developers, deep control |
| AceDataCloud | Hosted wrapper | Core video ops | Yes | No | Fastest setup |
| fal | Inference host | Model endpoints | Manual | Partial | Speed, model A/B tests |
| Replicate | Model host | Versioned listings | Manual | Partial | Reproducibility |
| CometAPI | Aggregator | Via unified API | Manual | Partial | One key, many providers |
| Smithery | Registry and host | Depends on server | Depends | No | Discovery and trials |
How to Choose
Pick by the shape of your job. One-off clips from a chat window: the official server. Every Dream Machine operation on your own machine: the bobtista server. A working setup today with polling handled: AceDataCloud. Identical prompts across competing models: fal. Locked, reproducible output: Replicate. Many providers, one invoice: CometAPI. Still deciding: Smithery. A finished asset that involves more than one model: a canvas, per the chain multiple models in one call guide.
Try it yourself: Build this workflow in Wireflow. The nodes are pre-configured with the MCP render and restyle setup discussed above.
FAQ
What is a Luma MCP server? A small program that exposes Luma's Dream Machine API as Model Context Protocol tools, so an assistant can create, poll, extend, and upscale generations without writing HTTP requests.
Is there an official Luma MCP server? Yes. Luma Labs publishes one covering its Ray video and Photon image models. It is the most accurate option for current API parameters and the right starting point for single generations.
Do I need a Luma API key? For the official and community servers, yes, and generations bill to that key. Hosted wrappers and aggregators can use their own upstream key and bill you on their pricing instead, which changes your cost model.
Which Luma MCP tool has the most features? The bobtista community server exposes the widest set of Dream Machine operations, including keyframe interpolation, reversing and extending clips, upscaling, reference and style and character images, and audio generation.
Can I use Luma MCP tools with an agent instead of a chat client? Yes. MCP is client agnostic, so any agent framework with an MCP client can call these servers. Long render times are the main constraint, so build for asynchronous polling, not blocking calls.
Do MCP tools add cost on top of Luma's pricing? Self-hosted servers add none; you pay Luma directly. Hosted wrappers, aggregators, and platforms add their own margin or credit charge in exchange for tracking, retries, and storage.
Can I chain Luma with other models through MCP? Not with a single-purpose Luma server, which returns a file and stops. Chaining requires an orchestration layer that passes the output into the next model, which is what canvas platforms and workflow tools provide.
What should I check before trusting a community MCP server? Last commit date, whether it tracks the current Dream Machine API version, how it stores your API key, and whether it polls job status. A stale server fails on newly added parameters first.
Conclusion
The category has settled into a clear split: first-party and community servers give precise, cheap access to single generations, while hosted platforms trade a margin for tracking, storage, and passing output into the next model. Start with the official server if you need a clip in a chat window, and move to an orchestration layer once the deliverable involves several models and repeated runs. Wireflow is built for that second case, and the developer overview is the shortest path to seeing whether it fits your pipeline.
Would you rather we just built it?
We get on a call, learn your style, build the workflow, and ship the deliverables on a schedule. You keep the workflow either way.
