Pular para o conteúdo
Tutoriais

Como Usar MCP no Cursor AI: Integracao

MCP no Cursor transforma o editor num hub que conversa com seu banco, cria issues no GitHub e chama APIs — tudo sem sair do chat. Aqui ta

TL;DR

Como Usar MCP no Cursor AI: Integracao. MCP no Cursor transforma o editor num hub que conversa com seu banco, cria issues no GitHub e chama APIs — tudo sem sair do chat. Aqui ta o setup completo com exemplos que funcionam.

Por que MCP no Cursor muda tudo

Cursor sem MCP ja e forte. Cursor com MCP e outro nivel. A diferenca e que sem MCP o Cursor so enxerga o codigo que esta aberto no editor. Com MCP, ele enxerga o banco de dados, o historico de PRs no GitHub, o estado da sua infra — tudo ao mesmo tempo.

Na pratica, muda completamente o tipo de tarefa que voce consegue fazer no chat. Sem MCP, voce pede 'crie um endpoint de listagem de usuarios' e o Cursor gera codigo generico. Com MCP de PostgreSQL, voce pede a mesma coisa e ele ja sabe que sua tabela users tem as colunas id, name, email, created_at — porque ele consultou o schema real do banco.

Outro exemplo: voce ta debugando um bug e quer ver as issues abertas no repo. Sem MCP, voce abre o browser, vai no GitHub, filtra por label. Com MCP de GitHub, voce digita no chat 'quais issues estao abertas com label bug?' e recebe a lista na hora. Nao e revolucionario? Nao. Mas economiza dezenas de context switches por dia. E isso se acumula.

Galera, a configuracao leva 5 minutos. Serio. Nao tem desculpa pra nao configurar.

Conectando PostgreSQL no Cursor via MCP

Esse e o setup que mais impacta a produtividade no dia a dia. Ter o banco de dados acessivel direto no chat do Cursor significa que o agente consegue gerar queries corretas, criar migrations baseadas no schema real e debugar problemas de dados sem voce sair do editor.

  1. Crie o arquivo de config
    Na raiz do projeto, crie .cursor/mcp.json (se a pasta .cursor nao existir, crie). Esse e o arquivo que o Cursor le pra carregar os MCP Servers.
  2. Adicione o server PostgreSQL
    Cole a config JSON com o comando npx e a connection string do seu banco local. Nunca use credenciais de producao aqui.
  3. Reinicie o Cursor
    O Cursor precisa ser reiniciado pra carregar novos MCP Servers. Feche todas as janelas e abra de novo.
  4. Teste no chat
    Abra o chat do Cursor (Cmd+L) e pergunte 'quais tabelas existem no banco?'. Se retornar a lista de tabelas, ta funcionando.

Aqui vai o JSON de configuracao:

json
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://postgres:postgres@localhost:5432/myapp_dev"
      ]
    }
  }
}

Com o PostgreSQL conectado, voce pode pedir coisas como: 'gere uma migration que adiciona coluna avatar_url na tabela users', 'escreva uma query que retorna os 10 usuarios mais ativos do ultimo mes', 'explique o schema da tabela orders e sugira indices'. O agente consulta o banco real e gera codigo que funciona de primeira.

Dica de seguranca: use sempre o banco de desenvolvimento local. Nunca aponte MCP pra banco de producao. Se precisar consultar dados de prod, faca um dump e restaure localmente.

GitHub via MCP: issues, PRs e code review

O MCP Server de GitHub da acesso a quase tudo da API: issues, pull requests, reviews, busca em codigo, branches. E a integracao mais util depois do banco de dados.

json
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://postgres:postgres@localhost:5432/myapp_dev"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_seu_token_aqui"
      }
    }
  }
}

Pra gerar o token: va em github.com > Settings > Developer settings > Personal access tokens > Fine-grained tokens. De permissao de leitura e escrita em Issues e Pull Requests do repo que voce quer acessar. Token com escopo minimo, sempre.

Com GitHub conectado, da pra fazer coisas como: 'crie uma issue no repo X com titulo Bug no login e descricao detalhada', 'liste os PRs abertos que estao esperando review', 'busque no codigo do repo onde a funcao calculateTotal e usada'. Tudo no chat do Cursor.

Um workflow que eu uso muito: abro o chat, peco 'liste as issues com label feature-request do ultimo sprint' e depois peco pro Cursor criar um branch e comecar a implementar a feature direto. O contexto da issue ja ta carregado, entao o codigo gerado ja considera os requisitos escritos la.

APIs REST customizadas via MCP

Quando voce precisa conectar o Cursor a uma API que nao tem MCP Server pronto, da pra criar um custom server rapido. E mais simples do que parece.

Digamos que voce tem uma API interna da empresa em api.minhaempresa.com que retorna dados de clientes. Em vez de copiar e colar JSONs de resposta no chat do Cursor, voce cria um MCP Server que faz esse fetch automaticamente.

typescript
// mcp-api-interna.ts
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: 'api-interna', version: '1.0.0' });
const API_BASE = 'https://api.minhaempresa.com';
const API_KEY = process.env.API_KEY || '';

server.tool(
  'get_clientes',
  'Busca clientes na API interna por nome ou email',
  { query: z.string().describe('Nome ou email do cliente') },
  async ({ query }) => {
    const res = await fetch(`${API_BASE}/clientes?search=${query}`, {
      headers: { Authorization: `Bearer ${API_KEY}` },
    });
    const data = await res.json();
    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
  }
);

server.tool(
  'get_pedidos',
  'Lista pedidos de um cliente por ID',
  { clienteId: z.string().describe('ID do cliente') },
  async ({ clienteId }) => {
    const res = await fetch(`${API_BASE}/clientes/${clienteId}/pedidos`, {
      headers: { Authorization: `Bearer ${API_KEY}` },
    });
    const data = await res.json();
    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

E a config no .cursor/mcp.json:

json
{
  "mcpServers": {
    "api-interna": {
      "command": "npx",
      "args": ["tsx", "./mcp-api-interna.ts"],
      "env": {
        "API_KEY": "sua_api_key_aqui"
      }
    }
  }
}

Pronto. Agora voce pode perguntar no chat do Cursor 'busca o cliente Joao Silva na API interna' e ele chama a tool automaticamente. O retorno vem direto no contexto da conversa, entao voce pode continuar com 'agora gera um componente que exibe esses dados do cliente'. O fluxo fica natural.

5 workflows produtivos com MCP no Cursor

Ter MCP configurado e so o comeco. O valor de verdade ta em como voce usa no dia a dia. Aqui vao 5 workflows que eu uso toda semana e que economizam tempo real.

O workflow de schema-first development e o que mais impacta. Antes do MCP, eu escrevia types manualmente baseado no que eu lembrava do banco. Agora o Cursor consulta o schema e gera tudo automatico. Zero typo, zero campo esquecido.

O issue-to-code tambem e absurdo. Voce literalmente fala 'implementa a issue #42' e o Cursor le a issue, entende os requisitos, cria o branch, gera o codigo e os testes. Claro que voce precisa revisar — mas o ponto de partida e muito melhor do que comecar do zero.

Setup completo — o que voce precisa ter

  • Cursor atualizado (versao mais recente)
  • Node.js 18+ instalado (pra rodar os servers via npx)
  • .cursor/mcp.json criado na raiz do projeto
  • PostgreSQL local rodando (Docker Compose recomendado)
  • GitHub token com permissoes minimas gerado
  • .cursor/mcp.json no .gitignore (pra nao commitar tokens)

Um detalhe que pouca gente lembra: adicione o .cursor/mcp.json no .gitignore. Ele tem tokens e connection strings que nao devem ir pro repositorio. Crie um .cursor/mcp.json.example com placeholders pra o time saber como configurar.

Transforme sua carreira dev

Quer dominar as ferramentas que vao definir o mercado? No CrazyStack voce aprende React, Node.js e as melhores praticas de desenvolvimento na pratica. MCP e Cursor sao ferramentas poderosas, mas o diferencial e saber construir projetos completos.