Um servidor MCP é um pequeno programa que dá a um aplicativo de IA acesso controlado a arquivos, bancos de dados e ferramentas pelo Model Context Protocol. Este artigo define o termo, acompanha uma solicitação passo a passo, mostra exemplos reais e termina com um servidor curto em TypeScript que você pode executar hoje.
Peça a um assistente de IA para resumir as vendas do último trimestre e ele vai dizer, educadamente, que não consegue ver sua planilha. O modelo é inteligente, mas fica numa caixa sem portas. Um servidor MCP é a porta. É um pequeno programa que expõe uma capacidade, como ler arquivos, consultar um banco de dados ou gerar uma imagem, para qualquer app de IA que fale o Model Context Protocol. Você escreve o servidor uma vez, e todo app compatível pode usá-lo sem código de conexão sob medida.
Este artigo explica o que é um servidor MCP, como uma solicitação viaja da sua janela de chat até a ferramenta e de volta, quais servidores as pessoas executam hoje, onde estão os riscos de segurança e como construir um servidor funcional em cerca de vinte linhas de TypeScript.
MCP quer dizer Model Context Protocol, um padrão aberto que a Anthropic lançou em novembro de 2024. Um protocolo é apenas uma forma combinada de se comunicar. Um servidor MCP é qualquer programa que segue essas regras do lado que fornece o serviço: ele anuncia o que pode fazer, aguarda solicitações e devolve resultados num formato previsível. Produtos da Anthropic, da OpenAI, do Google e da Microsoft já suportam MCP, e existem milhares de servidores da comunidade para tudo, de repositórios Git a calendários.
A palavra servidor confunde as pessoas. Um servidor MCP não precisa morar num data center. A maioria roda no seu próprio notebook, como um processo em segundo plano que começa quando seu app de IA é aberto. Outros rodam remotamente, atrás de um endereço web, como qualquer site.
Imagine uma antiga central telefônica. Quem liga não precisa saber como cada casa é ligada. Diz à telefonista com quem quer falar, e ela conecta o cabo certo na tomada certa. O MCP faz o papel dessa telefonista entre um app de IA e o mundo externo. O app diz preciso ler este arquivo ou preciso executar esta consulta, e o protocolo encaminha a solicitação a um servidor que sabe como fazer.
💡 Definição rápida: Um servidor MCP é um programa que lista as ferramentas, os dados e os modelos de prompt que oferece, e permite que um app de IA os chame por um único formato padrão de mensagem.
A analogia mais popular é o USB-C. Antes dele, cada dispositivo tinha seu próprio plugue e cada notebook precisava de uma gaveta cheia de adaptadores. Antes do MCP, cada app de IA precisava de um conector específico para cada serviço: um para o Slack num assistente, outro para o Slack em outro. Conte as combinações. Cinco apps e dez serviços significavam cinquenta integrações separadas. Com o MCP, cada app implementa o lado cliente uma vez e cada serviço implementa um servidor uma vez, então quinze peças de trabalho substituem cinquenta.
Três papéis aparecem em toda configuração MCP, e mantê-los claros elimina a maior parte da confusão.
| Papel | O que é | Exemplo |
|---|---|---|
| Host | O aplicativo de IA com o qual o usuário conversa | Claude Desktop, Cursor, VS Code |
| Cliente | Um conector dentro do host que mantém uma conexão com um servidor | Criado automaticamente pelo host |
| Servidor | O programa que expõe ferramentas, dados ou modelos de prompt | Um servidor de sistema de arquivos, um servidor de banco de dados |
O host cria um cliente por servidor. Conecte cinco servidores e seu app roda cinco clientes, cada um com uma linha privada para o próprio servidor. As mensagens viajam como JSON-RPC 2.0, um formato leve de solicitação e resposta que existe há anos. Nada exótico.
Este é o caminho de uma única pergunta, quais faturas estão vencidas?, por um host conectado a um servidor de contabilidade:
initialize. Cliente e servidor combinam uma versão do protocolo e trocam suas capacidades.tools/list. O servidor responde com todos os nomes de ferramentas, uma descrição simples e um JSON Schema para as entradas.list_overdue_invoices é o próximo passo certo.tools/call com o nome da ferramenta e os argumentos. O servidor faz o trabalho de fato, como executar uma consulta SQL.A chamada do passo 5 é uma pequena mensagem JSON:
{
"jsonrpc": "2.0",
"id": 7,
"method": "tools/call",
"params": {
"name": "list_overdue_invoices",
"arguments": { "days_overdue": 30 }
}
}
O modelo nunca toca no seu banco de dados. Ele apenas produz uma solicitação. O servidor guarda as credenciais e faz o trabalho, e é exatamente por isso que os servidores são o lugar certo para aplicar limites.
Um transporte é o canal que carrega essas mensagens JSON. O MCP define dois padrões.
| Transporte | Onde o servidor roda | Ideal para | Contrapartida |
|---|---|---|---|
| stdio | No seu computador, iniciado pelo host como processo filho | Ferramentas pessoais, acesso a arquivos, desenvolvimento | Um usuário, precisa ser instalado localmente |
| Streamable HTTP | Num endereço web, local ou remoto | Servidores compartilhados por equipes, produtos hospedados | Exige autenticação e hospedagem |
Servidores que usam stdio conversam pela entrada e saída padrão, então não há porta de rede para ser atacada. Servidores Streamable HTTP podem atender muitos usuários ao mesmo tempo, e por isso as empresas de software os publicam. Tutoriais mais antigos mencionam o transporte HTTP+SSE. A especificação atual o substituiu pelo Streamable HTTP.
Um servidor MCP expõe até três tipos de blocos de construção.
| Primitiva | Quem controla | O que faz | Exemplo |
|---|---|---|---|
| Ferramentas | O modelo decide quando chamá-las | Executam ações ou cálculos | Enviar um e-mail, rodar uma consulta, gerar uma imagem |
| Recursos | O aplicativo decide o que anexar | Fornecem dados somente leitura como contexto | Um arquivo, uma linha de banco de dados, um log |
| Prompts | O usuário os escolhe | Modelos de instrução reutilizáveis | "Revise este pull request" |
As ferramentas recebem quase toda a atenção porque permitem que uma IA faça coisas. Os recursos são mais discretos, mas igualmente úteis: alimentam a conversa com contexto sem uma chamada de ferramenta. Os prompts funcionam como comandos de barra que o próprio servidor traz.
O modelo escolhe ferramentas lendo apenas os nomes e as descrições. Uma ferramenta chamada run com a descrição "faz coisas" será usada de forma errada ou ignorada. Uma ferramenta chamada search_invoices com a descrição "Encontra faturas por nome do cliente, status ou intervalo de datas. Devolve até 20 resultados." é escolhida no momento certo.
Um bom design de ferramentas se resume a quatro hábitos:
create_ticket ou list_branches.💡 Dica: Se um assistente continua escolhendo a ferramenta errada, reescreva a descrição antes de mexer em qualquer código. Na prática, isso resolve a maioria das confusões.
A forma mais rápida de entender a ideia é olhar o que as pessoas de fato executam.
O servidor de sistema de arquivos de referência permite que um assistente leia, pesquise e edite arquivos dentro das pastas que você escolher. Aponte-o para o diretório de um projeto e peça todos os comentários TODO agrupados por arquivo. O servidor só consegue acessar as pastas que você listou, então o assistente trabalha dentro de uma cerca que você desenhou.
Servidores de banco de dados expõem uma ferramenta de consulta e, às vezes, a estrutura das tabelas como recurso. Pergunte quais três clientes gastaram mais em setembro, e o modelo escreve o SQL, o servidor o executa e as linhas voltam. Muitas equipes os configuram como somente leitura de propósito. Servidores de busca e da web funcionam do mesmo jeito, entregando ao modelo páginas atualizadas em vez de dados de treinamento desatualizados. Outros servidores populares conectam GitHub, Slack, Google Drive, Notion, Postgres e automação de navegador.
A geração é onde o MCP ganha forma visual. Um servidor de imagens expõe uma ferramenta generate_image. O assistente escreve o prompt, o servidor chama um modelo e uma URL do arquivo aparece de volta no chat. O vídeo funciona do mesmo jeito, com uma diferença: os clipes levam mais tempo, então o servidor inicia uma tarefa e o assistente verifica até ela terminar.
O PicassoIA funciona com esse padrão. Sua API para desenvolvedores fica em https://api.picassoia.com/v1 e usa um token Bearer que começa com pia_sk_. As solicitações seguem o estilo Replicate: cria-se uma previsão, consulta-se até ela terminar e então busca-se o resultado. Cada conta pode executar 5 previsões ao mesmo tempo. Os mesmos quatro modelos estão acessíveis pela API e pelo conector MCP do PicassoIA:
As conexões MCP são gerenciadas na página MCP da sua conta no PicassoIA, e a página de preços lista o que cada plano inclui. Se preferir criar clipes manualmente em vez de usar um assistente, modelos como Seedance 2.0 e Veo 3.1 estão a um clique de distância.
Mais um exemplo, mais perto do dia a dia. Um servidor de publicação de blog pode expor quatro ferramentas: gerar uma imagem, verificar se um slug de URL está livre, listar os modelos de IA disponíveis e salvar o artigo finalizado num banco de dados. Um assistente que recebe um tema chama essas ferramentas em ordem, tenta de novo qualquer imagem que falhe e armazena o resultado. Ninguém escreveu um "robô de artigos". O modelo simplesmente tinha as ferramentas certas e uma tarefa clara.
Um servidor MCP normalmente envolve uma API comum, então por que adicionar uma camada? Porque o leitor é outro. Uma API REST é escrita para desenvolvedores que leem a documentação. Um servidor MCP é escrito para um modelo que precisa ler a documentação em tempo de execução.
| API REST | Chamada de função | Servidor MCP | |
|---|---|---|---|
| Feito para | Desenvolvedores | O modelo de um app | Qualquer app de IA compatível |
| Encontrar ferramentas | Documentação escrita para pessoas | Ferramentas fixadas em cada app | Uma solicitação tools/list em tempo real |
| Reutilização | Cada app escreve seu próprio cliente | Cada app redeclara as funções | Um servidor, vários hosts |
| Configuração típica | Chamadas HTTP no código | Um JSON Schema em cada solicitação | Uma entrada de configuração no host |
O MCP não substitui a chamada de função. O host traduz a lista de ferramentas do servidor para o formato de chamada de função que o modelo já conhece. O MCP apenas padroniza de onde essa lista vem.
💡 Regra prática: Está construindo um app com algumas funções privadas? A chamada de função comum basta. Quer a mesma capacidade em vários assistentes, ou quer que a equipe possa conectá-la? Escreva um servidor MCP.
Um servidor MCP é código que uma IA pode acionar, muitas vezes com credenciais reais por trás. Trate-o como qualquer outro software que toque nas suas contas. Cinco perguntas evitam a maioria dos problemas:
⚠️ Atenção: A descrição de uma ferramenta é um texto em que o modelo confia. Um servidor malicioso pode esconder instruções dentro dela. Conecte apenas servidores que você instalaria como software sem receio.
Construir um servidor dá menos trabalho do que a maioria imagina. Existem SDKs oficiais para TypeScript, Python, Java, C# e várias outras linguagens. Os mesmos três passos valem para todas: criar um servidor, registrar uma ferramenta e conectar um transporte.
Este exemplo registra uma ferramenta que conta palavras e a disponibiliza via stdio. Salve-o como módulo ES.
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
const server = new McpServer({ name: "word-counter", version: "1.0.0" });
server.registerTool(
"count_words",
{
description: "Count the words in a piece of text. Returns a single number.",
inputSchema: { text: z.string() },
},
async ({ text }) => ({
content: [
{ type: "text", text: String(text.trim().split(/\s+/).filter(Boolean).length) },
],
})
);
await server.connect(new StdioServerTransport());
Compile e depois adicione uma entrada no arquivo de configuração do seu host: um nome, o comando node e o caminho do arquivo compilado. Reinicie o host e count_words aparece na lista de ferramentas dele. Pergunte "quantas palavras há neste parágrafo?" e o assistente chama seu código em vez de adivinhar.
Antes de culpar o modelo, teste o servidor sozinho. O MCP Inspector oficial (npx @modelcontextprotocol/inspector node build/index.js) abre uma página no navegador onde você pode listar ferramentas, preencher argumentos e ler as respostas brutas. Se funciona ali, o problema está na configuração do host ou na descrição da ferramenta.
Servidores MCP falam principalmente texto, mas muitos fluxos de trabalho terminam em uma imagem ou um clipe. Uma boa ordem de trabalho é rascunhar a ideia com um modelo de linguagem e depois transformá-la em visuais. O PicassoIA Image cuida das fotografias, o PicassoIA Image Editor Pro corrige e reformata essas imagens, e o PicassoIA Video anima o resultado.
Um modelo que lida bem com uso de ferramentas e código é um parceiro sólido para construir o servidor acima. Aqui está o caminho rápido com o Claude Sonnet 5 no PicassoIA:
low, é rápido e barato. Mude para high ou max quando a tarefa abranger vários arquivos ou esconder um bug difícil.Outros modelos de linguagem valem um teste lado a lado: o GPT 5.6 Terra para texto pronto para produção, o Gemini 3.5 Flash para respostas rápidas e o Kimi K2.6 para tarefas no estilo de agente.
Agora você sabe o que um servidor MCP faz, como uma solicitação passa por ele e onde estão escondidos os riscos. A forma mais rápida de sentir a ideia é usar uma ferramenta que devolve algo que você pode ver. Abra o Picasso IA, descreva uma cena em uma única frase e gere a imagem. Depois rode o mesmo prompt num segundo modelo e compare os resultados. Ferramentas pequenas e intercambiáveis são o hábito que o MCP recompensa, e uma primeira imagem leva menos de um minuto. Experimente o Picasso IA agora e veja para onde o seu prompt leva.
Escolha seu idioma
