# O que é MCP? Como deixar o seu assistente de IA usar ferramentas reais

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

Um assistente de IA que só conversa fica limitado a conselhos. Um que usa as suas ferramentas consegue fazer o trabalho de verdade. O MCP é o padrão que liga as duas coisas.

## The short version

- MCP, o Model Context Protocol, é um padrão aberto que permite que aplicativos de IA se conectem a ferramentas e dados externos de forma consistente.
- A Anthropic apresentou o MCP como padrão aberto em novembro de 2024, e hoje ele é suportado por um número crescente de apps de IA e ferramentas para desenvolvedores.
- No MCP, um aplicativo anfitrião, como um assistente de IA, executa clientes que se conectam a servidores, e cada servidor oferece ferramentas, recursos e prompts.
- Com o MCP, um assistente pode fazer trabalho real em outros softwares, como buscar arquivos, criar designs ou atualizar registros, em vez de só descrever como fazer.
- Conecte servidores MCP com credenciais limitadas e revogáveis, conceda só as permissões que a tarefa exige e revise o que o assistente faz.

**O que é MCP?** O MCP, **Model Context Protocol**, é um padrão aberto que permite que assistentes de IA usem ferramentas e dados reais. Em vez de cada app de IA criar uma integração própria para cada serviço, o serviço oferece um servidor MCP e qualquer assistente compatível com MCP pode se conectar a ele. O resultado é um assistente que age, por exemplo buscando seus arquivos, criando um design ou atualizando um registro, em vez de só dizer como fazer.

A Anthropic apresentou o MCP como padrão aberto em novembro de 2024, e desde então ele foi adotado por um número crescente de aplicativos de IA e ferramentas para desenvolvedores. O [site oficial do MCP](https://modelcontextprotocol.io) o descreve como um jeito universal de conectar aplicativos de IA a sistemas externos e o compara a uma porta USB-C para a IA.

## Como o MCP funciona: anfitriões, clientes e servidores

O MCP tem três papéis. Você só lida diretamente com o primeiro e o terceiro.

| Papel | O que é | Exemplo |
| --- | --- | --- |
| Anfitrião | O aplicativo de IA que você usa | Um app de assistente de IA ou uma ferramenta de IA para programar |
| Cliente | Um conector dentro do anfitrião, um por servidor | Cuida da conversa com um serviço |
| Servidor | Um programa que expõe as capacidades de um serviço | Uma ferramenta de design, um repositório de arquivos, uma agenda, um banco de dados |

Um anfitrião pode se conectar a vários servidores ao mesmo tempo, cada um pelo seu próprio cliente.

Cada servidor pode oferecer três tipos de coisa. **Ferramentas** são ações que o assistente pode realizar, como “criar um design”. **Recursos** são dados que ele pode ler, como um arquivo ou um perfil de marca. **Prompts** são instruções prontas que o servidor sugere para tarefas comuns. Os servidores podem rodar no seu próprio computador, conversando pela entrada e saída padrão, ou na web, conversando por HTTP.

## O que acontece quando um assistente usa uma ferramenta

Por trás de um pedido simples, os passos são sempre os mesmos. Vale conhecê-los, porque cada um é um ponto em que você continua no controle.

1. **O assistente descobre o que está disponível** Ao se conectar, o cliente pede a cada servidor a lista de ferramentas, com nome, descrição e as entradas que cada uma aceita.
2. **Você pede algo** Por exemplo: crie um story anunciando que abrimos até tarde às sextas.
3. **O assistente escolhe uma ferramenta** Ele decide que uma ferramenta de design serve e preenche as entradas a partir do seu pedido. Muitos apps pedem a sua permissão antes de uma ferramenta rodar.
4. **O servidor faz o trabalho** Ele chama o serviço real com as credenciais que você forneceu, e só com as permissões que essas credenciais permitem.
5. **O resultado volta** O servidor devolve o resultado, como um link para o novo design, e o assistente conta o que fez.

```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"
    }
  }
}
```

Como uma chamada de ferramenta aparece por dentro. As mensagens do MCP usam JSON-RPC: um método, o nome de uma ferramenta e os argumentos dela. Você nunca precisa escrever isso; o assistente escreve.

## O que o MCP torna possível no design

A maior parte do trabalho de design é uma cadeia de pequenos passos em vários apps. O MCP permite que um assistente cuide dessa cadeia para você, dentro das ferramentas que você já usa, enquanto a palavra final continua sendo sua.

### Assistente sem ferramentas

- Sugere um título; você copia para o seu app de design
- Descreve uma paleta; você digita os códigos hex
- Explica como redimensionar; você faz isso cinco vezes
- Não vê o seu kit de marca nem os designs anteriores

### Assistente com MCP

- Cria o design com o título no lugar
- Busca materiais reais e os aplica
- Faz cópias em todos os tamanhos que você pedir
- Lê o seu perfil de marca antes de começar

A qualidade continua dependendo da ferramenta do outro lado. Um assistente conectado a uma ferramenta de design com um sistema de marca forte produz trabalho fiel à marca; um conectado a uma tela em branco produz trabalho genérico. [Ferramentas de design com IA](https://gradiently.design/pt-br/guide/ai-design-tools) mostra como avaliar isso, e [diretrizes de marca para IA](https://gradiently.design/pt-br/guide/brand-guidelines-for-ai) mostra como dar a um assistente regras que ele consegue seguir.

## Como usar o MCP com segurança

Conectar um assistente a um serviço real significa que ele pode mudar coisas reais. Trate uma conexão MCP como dar acesso a um colega novo e capaz: específico, limitado e fácil de retirar.

- **Use chaves com escopo.** Crie uma chave que permita só o que a tarefa precisa, como ler designs sem reservar nada.
- **Uma chave por lugar.** Dê a cada chave o nome do lugar onde ela é usada, para poder revogar uma sem quebrar as outras.
- **Mantenha as chaves em segredo.** Guarde-as em um gerenciador de senhas ou nas configurações seguras do cliente, nunca em arquivos compartilhados ou capturas de tela.
- **Revise antes de aprovar.** Leia o que uma ferramenta está prestes a fazer, principalmente quando ela cria, altera ou gasta algo.
- **Desconfie de conteúdo de origem duvidosa.** Textos que um assistente lê por meio de uma ferramenta, como uma página web ou um documento, podem conter instruções. Mantenha as ferramentas sensíveis desligadas quando trabalhar com material em que você não confia.
- **Revogue o que não usa.** Chaves antigas são risco sem benefício.

| Permissão | Permite ao assistente | Conceda quando |
| --- | --- | --- |
| Ler designs | Listar e abrir os seus designs | Ele precisa ver ou partir de trabalhos anteriores |
| Criar e editar designs | Criar designs novos e alterá-los | Você quer que ele produza trabalho para você |
| Buscar Marks | Consultar materiais no Mercado | Ele deve encontrar um visual para um briefing |
| Gerar marcas | Criar propostas de marca a partir de uma descrição | Você está montando uma marca nova |
| Reservar Marks | Reservar um Mark para o seu workspace | Só se você quiser que ele aja sobre a posse |

Os escopos de uma chave do Gradiently, como exemplo de privilégio mínimo: a maioria das tarefas de design precisa só dos três primeiros.

> **Conecte só servidores em que você confia** Um servidor MCP executa código em seu nome e vê o que o assistente envia para ele. Use servidores publicados pelo próprio serviço ou por pessoas em quem você confia e leia quais permissões eles pedem.

## O Gradiently e o MCP

O Gradiently mantém um servidor MCP hospedado em `https://gradiently.design/api/mcp`. Crie uma chave em Configurações, na seção API e agentes, escolha o que ela pode fazer (como ler designs, criar e editar designs, buscar Marks ou gerar marcas) e adicione-a ao seu cliente MCP. A chave aparece uma única vez e pode ser revogada a qualquer momento. O seu assistente passa então a buscar Marks, ler o seu workspace, gerar opções de marca e criar designs que abrem no Studio para você finalizar.

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

O formato de uma entrada MCP remota nos clientes que usam uma configuração em JSON. Coloque a sua chave no lugar de YOUR_KEY e mantenha o arquivo privado.

Para ver como isso funciona na prática, veja [criar designs com o Claude](https://gradiently.design/pt-br/guide/design-with-claude). Para a configuração passo a passo em clientes diferentes, veja [como conectar um assistente de IA](https://gradiently.design/pt-br/guide/connect-ai-assistant) e a [documentação para desenvolvedores](https://gradiently.design/pt-br/developers/mcp).

## FAQ

### O que é MCP em IA?

O MCP, Model Context Protocol, é um padrão aberto para conectar aplicativos de IA a ferramentas e dados externos, para que um assistente possa agir em outros softwares em vez de só dar conselhos.

### Quem criou o MCP?

A Anthropic apresentou o Model Context Protocol como padrão aberto em novembro de 2024. Ele é desenvolvido de forma aberta, e muitos apps de IA e ferramentas para desenvolvedores já o suportam.

### O que é um servidor MCP?

Um programa que expõe as capacidades de um serviço para assistentes de IA, como ferramentas para chamar, recursos para ler e prompts para usar. Pode rodar no seu computador ou na web.

### O MCP é seguro?

É tão seguro quanto as permissões que você concede. Conecte só servidores em que confia, use chaves com escopo e revogáveis, revise as ações antes de aprová-las e remova as chaves que não usa mais.

### Preciso programar para usar o MCP?

Geralmente não. Muitos apps de IA permitem adicionar um servidor MCP com uma URL e uma chave, e o assistente cuida sozinho das chamadas de ferramenta.