Como Construir e Vender MCP Servers: o Mercado que Está se Formando para Solo Builders

TL;DR: MCP (Model Context Protocol) se tornou o padrão universal para conectar agentes de IA a ferramentas externas. Você pode construir um MCP Server em um fim de semana usando TypeScript ou Python — e existe um mercado nascente disposto a pagar por servers especializados. Este guia mostra como construir, testar e monetizar o seu.

O mercado de ferramentas para agentes de IA está se formando agora. E a janela de vantagem pioneer está aberta.

Enquanto a maioria dos developers ainda está aprendendo a usar Claude, ChatGPT e outros LLMs, uma nova camada de infraestrutura está emergindo: os MCP Servers — os conectores que transformam agentes de IA de sistemas de chat em operadores de software reais.

Este artigo é para quem quer estar no lado certo dessa equação: não só usando as ferramentas, mas construindo-as e vendendo-as.

O que é MCP (e por que todo agente passou a precisar disso)

MCP — Model Context Protocol — é um protocolo aberto criado pela Anthropic em 2024 e adotado rapidamente pela OpenAI, Google e dezenas de ferramentas do ecossistema.

O problema que ele resolve é simples: como conectar um LLM a fontes de dados e ferramentas externas de forma padronizada?

Antes do MCP, cada integração era construída do zero. Você criava function calls específicas para cada LLM, com schemas diferentes, autenticação ad-hoc, e sem portabilidade. O resultado: código difícil de manter e impossível de reutilizar entre modelos.

O MCP define um protocolo padrão com três primitivas:

• Tools: ações que o agente pode executar (consultar banco de dados, enviar email, criar arquivo)
• Resources: fontes de dados que o agente pode ler (documentos, repositórios, sistemas de arquivos)
• Prompts: templates de instrução reutilizáveis que o server oferece ao cliente

Com MCP, você constrói um server uma vez e ele funciona com Claude Desktop, Cursor, Windsurf, Continue.dev e qualquer outro cliente compatível. A portabilidade é total.

MCP Servers Pagos: a Oportunidade de Negócio que Está se Formando

Aqui está a parte que interessa para o solo builder:

O mercado de MCP Servers está nascendo.

Já existem diretórios públicos como o MCP.so e o repositório oficial modelcontextprotocol/servers no GitHub. A maioria dos servers listados é open source, gratuita, genérica.

O gap está nos servers especializados:

• MCP Server para consultar APIs de nicho (dados financeiros, imobiliários, jurídicos)
• MCP Server com acesso a ferramentas pagas com interface simplificada
• MCP Server para workflows de equipes específicas (agências, escritórios, e-commerces)
• MCP Servers que combinam múltiplas fontes de dados em uma interface única

Esses servers têm valor real e as empresas estão dispostas a pagar por eles — porque a alternativa é construir internamente.

Anatomia de um MCP Server

Antes de construir, entenda como um MCP Server é estruturado.

Transport layer

O MCP suporta dois tipos de transporte:

• stdio: comunicação via stdin/stdout — ideal para tools locais (Claude Desktop, Cursor)
• SSE (Server-Sent Events): comunicação via HTTP — necessário para servers remotos e multi-usuário

Para produtos vendáveis, você vai querer SSE + autenticação.

As três primitivas

MCP Server
├── tools/          → ações executáveis pelo agente
│   ├── get_user    → busca um usuário no banco
│   ├── send_email  → dispara email transacional
│   └── create_doc  → cria documento no Drive
├── resources/      → dados que o agente pode ler
│   ├── schema.sql  → estrutura do banco de dados
│   └── readme.md   → documentação do produto
└── prompts/        → templates de instrução
    └── support_agent → prompt base para suporte ao cliente

O agente (Claude, GPT, Gemini) decide quando e como usar cada tool com base no contexto da conversa. Você só precisa definir o que cada tool faz e qual schema ela espera.

Tutorial: construa seu primeiro MCP Server em TypeScript

Requisitos

• Node.js 18+
• TypeScript
• Conta no Claude Desktop (para testar)

1. Setup inicial

mkdir meu-mcp-server
cd meu-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node tsx

Crie o tsconfig.json:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "./dist",
    "strict": true
  }
}

2. Estrutura básica do server

Crie src/index.ts:

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { z } from "zod";

const server = new Server(
  {
    name: "meu-mcp-server",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

// Define a tool de busca de CEP como exemplo
const BuscarCepSchema = z.object({
  cep: z.string().describe("CEP no formato 00000-000 ou 00000000"),
});

// Lista as tools disponíveis
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "buscar_cep",
        description: "Busca endereço completo a partir de um CEP brasileiro",
        inputSchema: {
          type: "object",
          properties: {
            cep: {
              type: "string",
              description: "CEP no formato 00000-000 ou 00000000",
            },
          },
          required: ["cep"],
        },
      },
    ],
  };
});

// Implementa a lógica de cada tool
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "buscar_cep") {
    const { cep } = BuscarCepSchema.parse(request.params.arguments ?? {});
    const cepLimpo = cep.replace(/\D/g, "");

    const response = await fetch(`https://viacep.com.br/ws/${cepLimpo}/json/`);
    const dados = await response.json();

    if (dados.erro) {
      return {
        content: [{ type: "text", text: "CEP não encontrado." }],
        isError: true,
      };
    }

    return {
      content: [
        {
          type: "text",
          text: `Endereço: ${dados.logradouro}, ${dados.bairro}, ${dados.localidade} - ${dados.uf}`,
        },
      ],
    };
  }

  throw new Error(`Tool desconhecida: ${request.params.name}`);
});

// Inicia o server via stdio
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("MCP Server rodando via stdio");
}

main().catch(console.error);

3. Testando com Claude Desktop

Adicione ao claude_desktop_config.json (Mac: ~/Library/Application Support/Claude/, Windows: %APPDATA%\Claude\):

{
  "mcpServers": {
    "meu-mcp-server": {
      "command": "npx",
      "args": ["tsx", "/caminho/absoluto/para/src/index.ts"]
    }
  }
}

Reinicie o Claude Desktop. O ícone de ferramentas vai aparecer no chat — clique e confirme que seu server está listado.

Agora pergunte ao Claude: “Qual é o endereço do CEP 01310-100?”

O agente vai chamar sua tool automaticamente.

4. Adicionando Resources

Resources permitem que o agente leia arquivos ou dados estruturados do seu server:

import {
  ListResourcesRequestSchema,
  ReadResourceRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";

server.setRequestHandler(ListResourcesRequestSchema, async () => {
  return {
    resources: [
      {
        uri: "config://schema",
        name: "Database Schema",
        description: "Estrutura do banco de dados do produto",
        mimeType: "text/plain",
      },
    ],
  };
});

server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
  if (request.params.uri === "config://schema") {
    return {
      contents: [
        {
          uri: "config://schema",
          mimeType: "text/plain",
          text: "CREATE TABLE users (id UUID PRIMARY KEY, email TEXT UNIQUE NOT NULL...)",
        },
      ],
    };
  }
  throw new Error("Resource não encontrado");
});

5. Migrando de stdio para SSE (produto multi-tenant)

O server em stdio funciona localmente e é suficiente para validação. Para vender acesso a múltiplos clientes simultâneos, você precisa de SSE com autenticação.

npm install express cors
npm install -D @types/express @types/cors

Crie src/server-sse.ts:

import express from "express";
import cors from "cors";
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";

if (!process.env.API_KEY) {
  console.error("Erro: variável de ambiente API_KEY não definida.");
  process.exit(1);
}

const app = express();
app.use(cors());
app.use(express.json());

// Autenticação simples por API key
function authenticate(req: express.Request, res: express.Response, next: express.NextFunction) {
  const apiKey = req.headers["x-api-key"];
  if (!apiKey || apiKey !== process.env.API_KEY) {
    res.status(401).json({ error: "Unauthorized" });
    return;
  }
  next();
}

// Sessões ativas por cliente
const transports = new Map<string, SSEServerTransport>();

app.get("/sse", authenticate, async (req, res) => {
  const transport = new SSEServerTransport("/messages", res);
  const sessionId = transport.sessionId;
  transports.set(sessionId, transport);

  const server = createServer();
  await server.connect(transport);

  res.on("close", () => transports.delete(sessionId));
});

app.post("/messages", authenticate, async (req, res) => {
  const sessionId = req.query.sessionId as string;
  const transport = transports.get(sessionId);
  if (!transport) {
    res.status(404).json({ error: "Session not found" });
    return;
  }
  await transport.handlePostMessage(req, res);
});

function createServer() {
  const server = new Server(
    { name: "meu-mcp-server", version: "1.0.0" },
    { capabilities: { tools: {} } }
  );

  // Reuse the same handlers from the stdio version
  server.setRequestHandler(ListToolsRequestSchema, async () => ({
    tools: [{ name: "buscar_cep", description: "Busca CEP", inputSchema: { type: "object", properties: { cep: { type: "string" } }, required: ["cep"] } }],
  }));

  server.setRequestHandler(CallToolRequestSchema, async (request) => {
    if (request.params.name === "buscar_cep") {
      const { cep } = request.params.arguments as { cep: string };
      const response = await fetch(`https://viacep.com.br/ws/${cep.replace(/\D/g, "")}/json/`);
      const dados = await response.json();
      return { content: [{ type: "text", text: `${dados.logradouro}, ${dados.bairro}, ${dados.localidade} - ${dados.uf}` }] };
    }
    throw new Error(`Tool desconhecida: ${request.params.name}`);
  });

  return server;
}

app.listen(process.env.PORT || 3000, () => console.log("MCP SSE Server rodando"));

Com esse setup, cada cliente recebe uma API key única. O server aceita múltiplas conexões simultâneas e está pronto para deploy no Railway, Fly.io ou Cloudflare Workers.

Do MVP ao Primeiro Pagamento: o Fluxo Real para Lançar um MCP Server

Distribuição

Open source com paid tier: lance o core como open source no GitHub, cobre pela versão gerenciada (hosted) ou por features avançadas. Modelo comprovado no ecossistema dev.

Diretórios de MCP: submeta para o MCP.so, o hub oficial modelcontextprotocol/servers e comunidades como o subreddit r/ClaudeAI. Visibilidade gratuita.

Marketplace de agentes: plataformas como Poe, Character.ai e outras estão adicionando marketplaces de ferramentas. Posicione-se cedo.

Venda direta B2B: empresas que já usam Claude Enterprise ou OpenAI Teams têm budget e precisam de integrações específicas. LinkedIn + cold outreach funciona.

Modelos de cobrança

Exemplo de precificação trabalhado: MCP para e-commerce

Produto: MCP Server que conecta um agente de suporte ao Shopify

Comprador típico: dono de e-commerce com 500–5.000 pedidos/mês que usa Claude Desktop ou Cursor internamente

Problema: o time de suporte passa 40% do tempo buscando status de pedido, atualizando rastreamento e respondendo perguntas que o agente poderia responder sozinho

Valor entregue: automatiza ~60% das consultas de suporte em menos de 10 minutos de setup

Custo de operação (seu):

• Cloudflare Workers: ~$5/mês para até 10M requisições
• Manutenção: ~2h/mês

Tabela de preços:

Por que esse preço funciona: se o server automatiza 20 tickets por dia a um custo médio de R$10 cada (tempo de atendente), a economia mensal é ~R$6.000. O cliente paga R$449 e economiza R$6.000. O ROI é óbvio — e a conversa de venda é de 5 minutos.

Infraestrutura: comparativo para servers remotos

Recomendação: Comece com Cloudflare Workers. Zero cold start significa que cada chamada do agente responde instantaneamente — crítico para UX. Railway e Fly.io são melhores quando você precisa de funcionalidades de container ou deploy multi-região.

Autenticação production-ready

O exemplo de auth na seção anterior (comparação simples de API key) funciona para MVP, mas para produto real você precisa de:

Rate limiting (via Upstash Redis):

// Rate limit: 100 req/min por API key
import { Redis } from "@upstash/redis";

const redis = new Redis({
  url: process.env.UPSTASH_REDIS_REST_URL,
  token: process.env.UPSTASH_REDIS_REST_TOKEN,
});

async function checkRateLimit(apiKey: string): Promise<boolean> {
  const key = `ratelimit:${apiKey}`;
  const current = await redis.incr(key);
  if (current === 1) await redis.expire(key, 60);
  return current <= 100;
}

Auditoria de chamadas (essencial para debugging e compliance):

const callLog = [];

function logCall(apiKey: string, tool: string, input: any, output: any) {
  callLog.push({
    timestamp: new Date().toISOString(),
    apiKey: apiKey.substring(0, 8) + "...", // parcial
    tool,
    duration: Date.now() - start,
    success: !output.isError,
  });
}

Rotação de chaves (segurança):

• Gere uma nova API key a cada 90 dias
• Permita que o usuário revocation de chaves compromised
• Mantenha histórico de chaves ativas por cliente

Stack de auth recomendado:

• Clerk ou Auth.js para gerenciamento de usuários
• API keys próprias para o server MCP (separado do auth do app principal)

Do MVP ao Primeiro Pagamento: o Fluxo Real para Lançar um MCP Server

Este é o fluxo que funciona para um solo builder lançar um MCP Server como produto:

1. Identificar uma integração que todo mundo precisa mas ninguém fez bem
   ↓
2. Construir o MVP em stdio (local, rápido de testar)
   ↓
3. Migrar para SSE + autenticação
   ↓
4. Deploy em Cloudflare Workers ou Railway
   ↓
5. Landing page simples + formulário de early access
   ↓
6. 10 clientes beta gratuitos → validar uso real
   ↓
7. Cobrar a partir do cliente #11

O ciclo completo do MVP ao primeiro pagamento pode acontecer em 2–3 semanas. A barreira técnica é baixa. A barreira de execução é o que separa.

Perguntas Frequentes sobre MCP Servers

Preciso saber TypeScript para construir um MCP Server?

Não obrigatoriamente. O SDK oficial existe em TypeScript e Python. Se você já escreve Python, o mcp package da Anthropic tem uma API similar. Há também SDKs não-oficiais em Go, Rust e Kotlin.

Posso construir MCP Servers sem que meu cliente precise do Claude?

O MCP foi adotado por múltiplos clientes: Cursor, Windsurf, Continue.dev, Cline, e outros. Você não está preso ao Claude. Seu server vai funcionar com qualquer cliente compatível com o protocolo.

Qual a diferença entre MCP Server e uma API REST convencional?

Uma API REST requer que o desenvolvedor saiba exatamente quais endpoints chamar e em que ordem. Um MCP Server expõe capabilities — e o agente decide como e quando usá-las baseado no contexto da conversa. Isso muda completamente a UX para o usuário final. Para ver como um produto SaaS existente pode ser adaptado para consumo direto por agentes via protocolo MCP, veja o WebMCP.

É possível monetizar um MCP Server open source?

Sim. O modelo open core funciona bem: código aberto, server gerenciado pago. Você também pode oferecer suporte, customização e features avançadas como produto pago. Veja como Supabase, PlanetScale e outros fazem com projetos open source.

Como gerenciar autenticação para múltiplos clientes no MCP Server?

Use OAuth 2.0 com tokens por workspace ou API keys únicas por cliente. O SDK MCP suporta autenticação no nível do transport. Para simplificar, use Clerk ou Auth.js para o auth e gere API keys próprias para o server.

Hora de construir

O repositório modelcontextprotocol/servers no GitHub tem mais de 8.000 estrelas e cresce toda semana. O MCP.so lista centenas de servers — quase todos gratuitos, quase todos genéricos. Os primeiros servers pagos especializados que estão surgindo cobram entre $19 e $99/mês e têm listas de espera.

Isso não é especulação sobre o futuro. É o estado atual do mercado.

A barreira técnica para construir um MCP Server funcional é menor do que para qualquer outro tipo de produto de software: sem banco de dados para projetar, sem frontend para construir, sem API REST para documentar. Você define tools, implementa lógica, conecta ao transport. É isso.

O que decide quem lucra com isso não é quem tem mais experiência técnica. É quem para de ler e começa a construir.

Para ir mais fundo: veja como Skills no Claude Code funcionam como extensões locais de comportamento e como Subagents permitem orquestrar múltiplos agentes em paralelo — os dois se integram naturalmente com a arquitetura MCP.