Title
Create new category
Edit page index title
Edit category
Edit link
Flux MCP Server
The Flux MCP Server lets you connect an external AI client—such as Claude, ChatGPT, Codex, Cursor, or Devin—directly to Flux. Once connected, your AI client can read your live PCB designs, start design work, and collaborate with the Flux AI agent without you leaving the tool you already work in. This page explains what the Flux MCP Server is, which clients it supports, how to connect one, and the hardware workflows it unlocks.
What Is the Flux MCP Server?
The Model Context Protocol (MCP) is an open standard that lets AI clients talk to external tools and data sources through a single, consistent interface. Instead of being limited to chat, an MCP-compatible AI client can call tools, read live data, and take actions in the systems you connect it to.
Flux supports MCP because hardware design rarely happens in isolation. Your firmware might live in a coding assistant, your notes in another AI tool, and your board in Flux. The Flux MCP Server bridges that gap: it exposes your Flux projects to any MCP client so your AI agent of choice can work with your hardware design as easily as it works with your code.
What makes Flux different from a generic MCP implementation is live hardware design context. The Flux MCP Server does not just return static files. It gives connected AI clients access to your actual board—its components, nets, designators, and routing status—and lets them start real design work through the Flux AI-powered design assistant. Every design change is made by the Flux AI agent inside your cloud project, so your AI client collaborates on the real design rather than a local copy.
Flux projects live in the cloud, and the Flux AI agent does the work inside them. A connected client describes what a board should do, and the agent picks the components, draws the schematic, places and routes the PCB, and reports back. There is no local project directory to open and no tool for editing a single net by hand—your AI client asks the agent for an outcome instead.
What Can You Do with Flux MCP?
Once your AI client is connected, it can drive real hardware workflows against your live designs. In practice, this means your AI client can:
Inspect live PCB designs — read a project's metadata and what the board contains today, including component and net counts and how many traces are routed.
Retrieve pin assignments and net names — get the designators and net names on the board so your client can reference parts and connections accurately.
Generate firmware pin mappings — use the live pin and net data to produce pin-map headers and firmware definitions that match the actual hardware.
Identify potential hardware issues — reason about the design context and flag problems, such as a peripheral wired to the wrong pins.
Create design threads — start a conversation with the Flux AI agent to request changes on a project.
Request schematic and layout updates — ask the agent to add components, redraw connections, or route the PCB, then read back what changed.
Synchronize firmware with new hardware revisions — follow a design thread until the agent finishes, then update firmware to match the new revision.
These are engineering workflows, not protocol mechanics: the goal is to keep your firmware, your design intent, and your board aligned as the hardware evolves.
Supported AI Clients
Any MCP-compatible AI client can connect to the Flux MCP Server. Flux provides copy-paste setup instructions for the most popular clients, including:
Claude (Claude.ai)
Claude Code
ChatGPT
Codex
Devin
Cursor
VS Code
Notion AI
Because the Flux MCP Server speaks the standard MCP protocol over Streamable HTTP, it also works with other MCP-compatible clients beyond the list above. If your client supports remote MCP servers, it can connect to Flux.
How to Connect the Flux MCP Server
Prerequisites
Server URL: https://app.flux.ai/mcp (Streamable HTTP transport)
Authentication
You can authenticate in one of two ways.
OAuth (recommended). Most MCP clients support OAuth. Add the server URL without any credentials and your client opens a browser window to sign in with your Flux account. For example, with Claude Code:
API key. Alternatively, authenticate with a Flux API key sent as a bearer token. Create one from the account menu under API Keys, then add the server to your client:
The scopes granted to an API key determine what the integration can do: read-only tools require project read access, creating projects requires write access, and tools that message the agent additionally require the agent-run scope (since agent runs spend ACUs).
Configuration
The fastest way to configure your client is from inside Flux, which generates copy-paste instructions tailored to each supported client:
Open any project and click the antenna icon (AI Integrations) in the chat composer.
Choose Manage integrations.
Switch to the Flux MCP tab and pick your client.
Verifying the connection
After adding the server, ask your AI client to list your Flux projects. If it returns projects you can access, the connection is working. Reads such as listing and reading projects are free and do not start an agent run, so they are a safe way to confirm communication before you request any design work.
When Flux first connects, it sends your client a short set of usage instructions describing how Flux works—that projects live in the cloud and that design changes are made by messaging the agent. Well-behaved clients load these into the model's context before their first call, so your client understands the Flux workflow from the start.
Example Hardware Development Workflow
Here is a realistic end-to-end scenario. You're writing firmware for a new board in your coding assistant, with that assistant connected to Flux over MCP.
Connect to Flux. Your AI client authenticates and lists your projects.
Read the live PCB context. The client reads the project to see its components, nets, and designators, and whether the PCB is routed.
Retrieve MCU pin assignments. Using the live design data, the client pulls the pin assignments and net names for the microcontroller.
Generate firmware headers. The client generates a pin-map header from the real assignments, so the firmware matches the hardware.
Detect a hardware issue. While generating the header, the client notices a peripheral is wired to the wrong pins.
Open a Flux design thread. The client starts a thread with the Flux AI agent, describing the fix it needs in the schematic.
Wait for the updated schematic. The client waits for the run to settle rather than polling repeatedly. Agent runs take minutes and consume ACUs.
Update firmware based on the new revision. Once the agent reports the change, the client reads the updated design and regenerates the firmware to match.
This is the core value of the Flux MCP Server: your AI client and the Flux AI agent work together, with the live board as the shared source of truth, so hardware and firmware stay in sync as the design evolves. For more on how AI can steer this kind of work, see the steerable AI design agent.
Best Practices
Ask for an outcome, not a procedure. State the goal and its constraints—supply voltage, load current, interfaces, connectors, MCU family, board size, cost—and let the Flux AI agent choose the implementation.
One objective per message. A single request that chains schematic, layout, routing, and export work will be done poorly, if at all. Break large tasks into separate threads or messages.
Read before you ask. Reads are free and do not spend credits, so read the project first to ground your request in the actual design and refer to parts and nets by their designator.
Review AI-generated changes. Confirm what the agent reported before treating a change as landed, and validate firmware against the real hardware before deployment.
Use revisions to stay consistent. After the agent updates a design, re-read it and regenerate dependent artifacts (like pin-map headers) so firmware and hardware stay aligned.
Teach Flux your conventions. Use the Flux Knowledge Base to record how your team works—preferred connectors, review steps, naming conventions—so connected clients and the agent follow them automatically.
Collaborate with your team. Because design threads live in the cloud project, teammates can see and continue the work your AI client started, supporting collaborative PCB design.
Organization-restricted access
You can limit an integration to a single organization, which is useful for team-level agents and automations:
With OAuth, pick the organization on the consent page when authorizing the client.
With an API key, set the Organization dropdown when creating the key.
Either way, the integration can only see and modify projects owned by that organization—your personal projects and other organizations stay inaccessible.
Troubleshooting
Issue | Solution |
|---|---|
Authentication failures | Confirm you signed in with the right Flux account during OAuth, or that your API key is valid and sent as |
Connection issues | Check that the server URL is exactly |
Unavailable boards or missing project context | The integration only sees projects your credentials can access. If a project is missing, confirm it's owned by or shared with your account—and, for organization-restricted keys, that it belongs to the selected organization. |
A request seems stuck | Agent runs take minutes and report recent activity while they work, so silence is not failure. Wait for the run to settle instead of sending repeated requests. If a run fails, the thread reports a failure reason explaining why. |
Synchronization problems | Never assume a design change landed until a response confirms it. After the agent finishes, re-read the project and regenerate any dependent firmware so it matches the current revision. |
FAQs
What is the Flux MCP Server?
The Flux MCP Server is a Model Context Protocol endpoint that lets external AI clients connect to Flux, read your live PCB designs, and collaborate with the Flux AI design assistant to make hardware changes—all from the AI client you already use.
Which AI clients work with Flux MCP?
Flux provides ready-made setup instructions for Claude, Claude Code, ChatGPT, Codex, Devin, Cursor, VS Code, and Notion AI. Any other MCP-compatible client that supports remote servers can connect too.
Can I connect ChatGPT to Flux?
Yes. ChatGPT is one of the supported clients. Use the server URL https://app.flux.ai/mcp and follow the copy-paste instructions in the Flux MCP tab of AI Integrations inside Flux.
Does Flux work with Claude Code?
Yes. You can add Flux to Claude Code with a single command, using OAuth (claude mcp add -t http flux https://app.flux.ai/mcp) or an API key sent as a bearer token.
Can Flux MCP generate firmware?
The Flux MCP Server gives your AI client the live pin assignments and net names from your board so the client can generate firmware pin mappings and headers that match the hardware. The firmware code is produced by your connected AI client; Flux supplies the accurate hardware context.
How does Flux MCP use live PCB data?
When your client reads a project, Flux returns what the board contains today—component and net counts, their designators and names, and how many traces are routed. Your AI client uses this live context to ground its work and to ask the Flux AI agent for precise, design-aware changes.
Next Steps
Flux: AI-Powered PCB Design Assistant — learn what the Flux AI agent can do inside your projects.
Flux Knowledge Base — teach Flux your workflows so connected clients follow them automatically.
AI-powered design assistant — a deeper look at designing with AI in Flux.