# MCP servers for designers: AI assistants that use real tools

[Canonical HTML page](https://gradiently.design/guide/mcp-servers-for-designers)

An assistant that can only describe a poster is a consultant. Give it an MCP server and it can make the poster, in your brand, in the tool you already use.

## The short version

- An MCP server is a small service that lets an AI assistant use a real tool through the open Model Context Protocol.
- MCP servers for design let an assistant search assets, read design files or brand settings, and create designs that open in a design tool.
- The assistant is the host, the MCP server is the tool's side of the connection, and permissions decide what the assistant may do.
- Gradiently runs a hosted MCP server, so ChatGPT, Claude and other assistants that support remote MCP servers can search Marks and create designs that open in the Studio.
- Use one scoped key per assistant and tick only the permissions it needs.

**MCP servers for design** are connectors that let an AI assistant use a real design tool instead of only talking about one. MCP, the Model Context Protocol, is an open standard: a design tool publishes an MCP server, and any assistant that speaks the protocol, such as Claude or ChatGPT, can call its actions. For designers that means an assistant that can look up your brand, find the right asset, lay out a design and save it where you can open and finish it.

## What an MCP server actually is

Think of three parts. The **host** is the app you talk to, such as Claude Desktop or ChatGPT. Inside it, an **MCP client** keeps the connection open. The **MCP server** belongs to the tool and lists what the assistant may do: its tools (actions), its resources (things to read) and sometimes ready prompts. The full specification lives at [modelcontextprotocol.io](https://modelcontextprotocol.io), and [what is MCP](https://gradiently.design/guide/what-is-mcp) explains it in plain words.

| Part | What it is | Design example |
| --- | --- | --- |
| Host | The AI app you type into | Claude, ChatGPT, an editor with an assistant |
| Client | The connection inside the host | Added once in the host's settings |
| Server | The tool's side, listing its actions | A design tool's hosted MCP endpoint |
| Tools | Actions the assistant can call | Search Marks, create a design, make a story size |
| Permissions | What the key allows | Read designs, create and edit, search Marks |

The vocabulary you will meet when connecting a design tool to an assistant.

## What changes when your assistant has tools

### Chat only

- Suggests a layout in words
- Guesses your colours from a description
- Writes copy you paste somewhere else
- Generates a flat image you cannot edit

### With an MCP server

- Saves a real, layered design
- Reads your actual brand settings
- Places the copy in the design itself
- Hands you a file you can open and adjust

The difference shows up most in the last line. An image model returns pixels; type is often garbled and nothing can be moved. A design tool reached over MCP returns a design with live text, layers and sizes. [AI image generators vs design tools](https://gradiently.design/guide/ai-image-generator-vs-design-tool) goes deeper into that split.

## Kinds of MCP servers a designer might connect

- **Design file servers** that let an assistant read frames, components and variables from a design file. Figma, for example, documents an MCP server for handing designs to code.
- **Design creation servers** that make finished work: posts, stories, posters, headers. Gradiently's server is one.
- **Asset servers** for searching photos, icons or a brand's own library.
- **Browser and file system servers** that let an assistant open a web page or read a folder of references.
- **Project servers** for issue trackers and docs, so briefs and feedback travel with the work.

You rarely need many. One design server plus whatever already holds your briefs is a strong start.

## How one request travels

1. **You ask in plain words** "Make a portrait Instagram post for our Friday tasting, 7pm, in our brand."
2. **The assistant picks tools** It sees the server's list of actions and chooses the ones that fit: read the brand, then create a design at 1080×1350.
3. **The server does the work** The design tool lays the post out with your fonts, colours and background, and saves it.
4. **You get a link back** The assistant replies with the result. You open it in the tool, adjust, and export.

A portrait event post for a Friday wine tasting at 7pm on a deep gradient background

What that request can come back as: a saved, editable design on the brand's Mark, not a flat picture.

## Connecting Gradiently's MCP server

Gradiently runs a hosted MCP server that works inside ChatGPT, Claude and any assistant that supports remote MCP servers. Once connected, an assistant can search Marks, the living gradient and material backgrounds every Gradiently design wears, read your workspace and brand, and create designs that open in the Studio. When the assistant lays the design out itself it spends no Gradiently credits; the thinking happens on your assistant's plan.

An owner or admin creates a scoped API key in **Settings › API and agents**, then adds the endpoint to the client. Clients that read a JSON configuration take a snippet like this:

```json
{
  "mcpServers": {
    "gradiently": {
      "url": "https://gradiently.design/api/mcp",
      "headers": { "Authorization": "Bearer YOUR_KEY" }
    }
  }
}
```

Replace YOUR_KEY with a key from Settings. Never commit a real key to a repository.

[Connecting an AI assistant](https://gradiently.design/guide/connect-ai-assistant) has the full walkthrough, and the [developer docs](https://gradiently.design/developers/mcp) list every tool. Once you are connected, [MCP design prompts](https://gradiently.design/guide/mcp-prompts-for-design) gives you requests to copy.

## Keeping design connections safe

### Avoid

- One key with every permission, shared by every app
- Pasting keys into chats or documents
- Servers from sources you cannot identify
- Leaving keys alive for tools you stopped using

### Do

- One key per assistant, named after where it runs
- Tick only the permissions that job needs
- Connect servers published by the tool's own maker
- Revoke keys you no longer use

An MCP server can only do what its key allows, so the key is your main control. In Gradiently a key only works in the workspace that issued it, carries only the permissions ticked when it was made, and can be revoked at any time. For day to day habits in each assistant, see [designing with Claude](https://gradiently.design/guide/design-with-claude) and [designing with ChatGPT](https://gradiently.design/guide/design-with-chatgpt).

## FAQ

### What is an MCP server in design?

It is a connector a design tool publishes so AI assistants can use it through the Model Context Protocol. The assistant can then read assets or brand settings and create designs rather than only describe them.

### Which AI assistants support MCP servers?

Claude supports MCP servers, and ChatGPT can connect to remote MCP servers where its plan and settings allow. Support differs between apps and changes over time, so check each one's help pages.

### Does Gradiently have an MCP server?

Yes. Its hosted server lets ChatGPT, Claude and other assistants that support remote MCP servers search Marks, read your workspace and create designs that open in the Studio. Setup is in the [developer docs](https://gradiently.design/developers/mcp).

### Do designs made through MCP use Gradiently credits?

Not when your assistant lays the design out itself with Gradiently's tools. If you ask it to hand the job to Gradiently's Designer, that work is measured in credits.

### Are MCP servers safe to connect?

They are as safe as the keys you give them. Connect servers published by the tool's maker, use one scoped key per assistant and revoke keys you stop using.