A Practical Guide to Using Flux MCP in Claude Desktop, VS Code, and Cursor

September 12, 2026

If you already use an AI coding assistant, the slow part of image work is often not the model itself — it is leaving your editor, copying prompts between tabs, waiting for a job, and bringing the result back into your workflow.

The Flux MCP integration from Ace Data Cloud is a practical way to move that loop into tools builders already use: Claude Desktop, VS Code, Cursor, or any client that can talk to an MCP server. Instead of treating image generation as a separate website, you expose a small set of image tools to the assistant and let it call them when the conversation needs a generated or edited image.

What you can do

The Flux MCP server documented by Ace Data Cloud focuses on a compact set of image workflows:

Text-to-image generation from a prompt.
Image editing from an existing image plus text instructions.
Multi-model usage across Flux Pro, Flux Dev, Flux Schnell, Flux Kontext, and related Flux models.
Model discovery so the assistant can inspect what is available before choosing a model.
Task lookup so generation progress and final results can be checked after a request starts.

The useful mental model is simple: MCP gives your assistant a local tool bridge; Ace Data Cloud supplies the Flux image capability behind that bridge. Your client remains the place where you describe intent, review outputs, and iterate.

How it works

MCP, or Model Context Protocol, standardizes how an AI client calls external tools. The Flux MCP server is installed as a command-line package, then registered in the configuration file used by the client. The important configuration values in the documentation are the command name mcp-flux-pro and the environment variable ACEDATACLOUD_API_TOKEN.

Once the client starts the server, the assistant can see tools such as flux_generate_image, flux_edit_image, flux_get_task, flux_get_tasks_batch, flux_list_models, and flux_list_actions. That tool list is the contract you build around: generate an image, edit an image, list models, or check a task.

Install the server

The recommended installation path is a Python package install:

pip install mcp-flux-pro

If you prefer to work from source, the documentation also shows a repository-based setup:

git clone https://github.com/AceDataCloud/FluxMCP.git
cd FluxMCP
pip install -e .

After installation, the server can be started through the mcp-flux-pro command. In day-to-day usage, you usually do not run it manually; your MCP client launches it from its config file.

Configure Claude Desktop

For Claude Desktop, edit the client configuration file. On macOS, the documented location is ~/Library/Application Support/Claude/claude_desktop_config.json. On Windows, it is %APPDATA%\Claude\claude_desktop_config.json.

Add a server entry like this, replacing the token placeholder with your Ace Data Cloud API token:

{
  "mcpServers": {
    "flux": {
      "command": "mcp-flux-pro",
      "env": {
        "ACEDATACLOUD_API_TOKEN": "your API Token"
      }
    }
  }
}

The guide also supports a uvx configuration, which is useful when you do not want to pre-install the package:

{
  "mcpServers": {
    "flux": {
      "command": "uvx",
      "args": ["mcp-flux-pro"],
      "env": {
        "ACEDATACLOUD_API_TOKEN": "your API Token"
      }
    }
  }
}

Save the file and restart Claude Desktop. After restart, ask the assistant to list Flux models or generate a small test image. That first small test is worth doing before you rely on the setup in a real production workflow.

Configure VS Code or Cursor

For editor-based workflows, create .vscode/mcp.json in the project root. The documented shape uses a top-level servers object instead of Claude Desktop's mcpServers:

{
  "servers": {
    "flux": {
      "command": "mcp-flux-pro",
      "env": {
        "ACEDATACLOUD_API_TOKEN": "your API Token"
      }
    }
  }
}

There is also a uvx version for the editor setup:

{
  "servers": {
    "flux": {
      "command": "uvx",
      "args": ["mcp-flux-pro"],
      "env": {
        "ACEDATACLOUD_API_TOKEN": "your API Token"
      }
    }
  }
}

This is the configuration I would use for project-specific image tasks: product mockups, README artwork, UI placeholder concepts, internal diagrams, or quick visual experiments that should live close to the codebase.

Use the tools like a builder

After the server is connected, you do not need to memorize a large API surface. Start with explicit, verifiable requests:

Ask the assistant to call flux_list_models before selecting a model.
Use flux_generate_image for prompt-only work such as a concept image or hero visual.
Use flux_edit_image when you already have a base image and want a specific change, such as changing a background or clothing color.
Use flux_get_task or flux_get_tasks_batch when the workflow returns a task that needs progress tracking.

Good prompts are still important. A practical prompt includes the subject, style, constraints, and what should remain unchanged. For edits, say exactly what to preserve and exactly what to change. For example: "Use the Flux Kontext Pro model to edit this image and change the clothing color to red" is more operational than "make it better."

A small workflow you can copy

Here is a simple first-session checklist:

Install with pip install mcp-flux-pro, or configure uvx.
Add the appropriate JSON configuration for Claude Desktop, VS Code, or Cursor.
Set ACEDATACLOUD_API_TOKEN in the server environment.
Restart the client.
Ask: "List all available Flux models."
Generate one small image with flux_generate_image.
Edit one existing image with flux_edit_image.
If a task is pending, check it with flux_get_task.

That sequence exercises the important pieces without turning the first run into a large creative project. Once it works, you can fold the tools into normal builder habits: generate a UI illustration while writing docs, test variations while discussing a feature, or modify a visual asset without leaving your assistant.

The full setup details are in the Flux MCP Integration Guide.

Search This Blog

AceDataCloud