# What is MCP? Letting your AI assistant use real tools

[Canonical HTML page](https://gradiently.design/guide/what-is-mcp)

An AI assistant that can only talk is limited to advice. One that can use your tools can actually do the work. MCP is the standard that connects the two.

## The short version

- MCP, the Model Context Protocol, is an open standard that lets AI applications connect to external tools and data in a consistent way.
- Anthropic introduced MCP as an open standard in November 2024, and it is now supported by a growing number of AI apps and developer tools.
- In MCP, a host application such as an AI assistant runs clients that connect to servers, and each server offers tools, resources and prompts.
- With MCP, an assistant can do real work in other software, such as searching assets, creating designs or updating records, instead of only describing how.
- Connect MCP servers with scoped, revocable credentials, grant only the permissions a task needs and review what the assistant does.

**What is MCP?** MCP, the **Model Context Protocol**, is an open standard that lets AI assistants use real tools and data. Instead of every AI app building a custom integration for every service, a service offers one MCP server and any MCP-capable assistant can connect to it. The result is an assistant that can act, such as searching your files, creating a design or updating a record, rather than only telling you how.

Anthropic introduced MCP as an open standard in November 2024, and it has since been adopted by a growing number of AI applications and developer tools. The [official MCP site](https://modelcontextprotocol.io) describes it as a universal way to connect AI applications to external systems, and compares it to a USB-C port for AI.

## How MCP works: hosts, clients and servers

MCP has three roles. You only ever deal with the first and third directly.

| Role | What it is | Example |
| --- | --- | --- |
| Host | The AI application you use | An AI assistant app, or an AI coding tool |
| Client | A connector inside the host, one per server | Handles the conversation with one service |
| Server | A program that exposes a service's abilities | A design tool, a file store, a calendar, a database |

One host can connect to many servers at once, each through its own client.

Each server can offer three kinds of thing. **Tools** are actions the assistant can take, such as "create a design". **Resources** are data it can read, such as a file or a brand profile. **Prompts** are ready-made instructions the server suggests for common jobs. Servers can run on your own computer, talking over standard input and output, or on the web, talking over HTTP.

## What happens when an assistant uses a tool

Behind a simple request, the steps are always the same. It helps to know them, because each one is a place where you stay in control.

1. **The assistant learns what's available** When it connects, the client asks each server for its list of tools, with a name, a description and the inputs each one takes.
2. **You ask for something** For example: make a story announcing that we open late on Fridays.
3. **The assistant chooses a tool** It decides that a design tool fits and fills in the inputs from your request. Many apps ask your permission before a tool runs.
4. **The server does the work** It calls the real service with the credentials you gave it, and only with the permissions those credentials allow.
5. **The result comes back** The server returns the outcome, such as a link to the new design, and the assistant tells you what it did.

```json
{
  "jsonrpc": "2.0",
  "id": 7,
  "method": "tools/call",
  "params": {
    "name": "design",
    "arguments": {
      "request": "A story announcing that we open late on Fridays",
      "size": "ig-story"
    }
  }
}
```

What a tool call looks like on the wire. MCP messages use JSON-RPC: a method, a tool name and its arguments. You never have to write these; the assistant does.

## What MCP makes possible for design

Most design work is a chain of small steps across several apps. MCP lets an assistant carry that chain for you, inside the tools you already use, while you keep the final say.

### Assistant without tools

- Suggests a headline; you copy it into your design app
- Describes a palette; you type the hex codes in
- Explains how to resize; you do it five times
- Can't see your brand kit or past designs

### Assistant with MCP

- Creates the design with the headline in place
- Searches real assets and applies them
- Makes copies at every size you ask for
- Reads your brand profile before it starts

The quality still depends on the tool at the other end. An assistant connected to a design tool with a strong brand system produces on-brand work; one connected to a blank canvas produces generic work. [AI design tools](https://gradiently.design/guide/ai-design-tools) covers how to judge that, and [brand guidelines for AI](https://gradiently.design/guide/brand-guidelines-for-ai) shows how to give an assistant rules it can follow.

## Staying safe with MCP

Connecting an assistant to a real service means it can change real things. Treat an MCP connection like giving a capable new colleague access: specific, limited and easy to take back.

- **Use scoped keys.** Create a key that allows only what the task needs, such as reading designs but not claiming anything.
- **One key per place.** Name each key after where it is used, so you can revoke one without breaking the others.
- **Keep keys secret.** Store them in a password manager or the client's secure settings, never in shared files or screenshots.
- **Review before approving.** Read what a tool is about to do, especially when it creates, changes or spends something.
- **Be wary of untrusted content.** Text an assistant reads through a tool, such as a web page or a document, can contain instructions. Keep sensitive tools off when working with material you don't trust.
- **Revoke what you don't use.** Old keys are risk with no benefit.

| Permission | Lets the assistant | Grant it when |
| --- | --- | --- |
| Read designs | List and open your designs | It needs to see or build on past work |
| Create and edit designs | Make new designs and change them | You want it to produce work for you |
| Search Marks | Look up materials in the Market | It should find a look for a brief |
| Generate brands | Make brand candidates from a description | You are setting up a new brand |
| Claim Marks | Claim a Mark for your workspace | Only if you want it to act on ownership |

Scopes on a Gradiently key, as an example of least privilege: most design tasks need only the first three.

> **Only connect servers you trust** An MCP server runs code on your behalf and sees what the assistant sends it. Use servers published by the service itself or by people you trust, and read what permissions they ask for.

## Gradiently and MCP

Gradiently runs a hosted MCP server at `https://gradiently.design/api/mcp`. Create a key in Settings under API and agents, choose what it can do (such as reading designs, creating and editing designs, searching Marks or generating brands) and add it to your MCP client. The key is shown once and can be revoked at any time. Your assistant can then search Marks, read your workspace, generate brand options and make designs that open in the Studio for you to finish.

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

The shape of a remote MCP entry in clients that use a JSON config. Put your key in place of YOUR_KEY and keep the file private.

For a walkthrough of what that looks like in practice, see [designing with Claude](https://gradiently.design/guide/design-with-claude). For step-by-step setup in different clients, see [connecting an AI assistant](https://gradiently.design/guide/connect-ai-assistant) and the [developer docs](https://gradiently.design/developers/mcp).

## FAQ

### What is MCP in AI?

MCP, the Model Context Protocol, is an open standard for connecting AI applications to external tools and data, so an assistant can take actions in other software instead of only giving advice.

### Who created MCP?

Anthropic introduced the Model Context Protocol as an open standard in November 2024. It is developed in the open, and many AI apps and developer tools now support it.

### What is an MCP server?

A program that exposes a service's abilities to AI assistants, as tools to call, resources to read and prompts to use. It can run on your computer or on the web.

### Is MCP safe to use?

It is as safe as the permissions you grant. Connect only servers you trust, use scoped and revocable keys, review actions before approving them and remove keys you no longer use.

### Do I need to code to use MCP?

Usually not. Many AI apps let you add an MCP server with a URL and a key, and the assistant handles the tool calls itself.