Konfiguracja MCP w Cursor

Prosisz agenta o “sprawdź, czy tabela users ma kolumnę email_verified”. Przeszukuje twoją bazę kodu, znajduje plik migracji sprzed sześciu miesięcy i zgaduje — czasami prawidłowo, czasami nie. Teraz wyobraź sobie, że agent mógłby zapytać twoją bazę danych bezpośrednio, sprawdzić aktualny schemat i dać ci definitywną odpowiedź. To właśnie robi MCP (Model Context Protocol). Łączy agenta Cursor z zewnętrznymi narzędziami i źródłami danych, zamieniając domysły w fakty.

Co osiągniesz

• Zrozumienie, czym jest MCP i jak rozszerza możliwości Cursor
• Działającą konfigurację serwera MCP przy użyciu mcp.json
• Co najmniej jeden użyteczny serwer MCP zainstalowany i odpowiadający na zapytania agenta
• Wiedzę o trzech metodach transportu (stdio, SSE, Streamable HTTP) i kiedy używać każdej z nich
• Praktyki bezpieczeństwa zarządzania kluczami API i danymi dostępu

Czym jest MCP?

MCP (Model Context Protocol) to otwarty protokół, który umożliwia agentom AI interakcję z zewnętrznymi narzędziami. W Cursor serwery MCP udostępniają narzędzia, które agent może wywoływać — odpytywanie baz danych, przeglądanie stron internetowych, interakcje z API GitHub, czytanie projektów Figma i wiele więcej.

Cursor wspiera trzy możliwości MCP:

Możliwość	Co robi
Tools	Funkcje, które agent może wykonać (zapytanie do bazy danych, utworzenie issue na GitHub itp.)
Prompts	Szablonowe przepływy pracy, które agent może wywołać
Resources	Strukturalne źródła danych, które agent może odczytać

Jak to działa

Konfigurujesz serwery MCP w pliku JSON. Cursor uruchamia je automatycznie i udostępnia ich narzędzia agentowi. Gdy agent zdecyduje, że narzędzie jest istotne dla twojego polecenia, wywołuje narzędzie, otrzymuje wynik i włącza go do odpowiedzi.

Lokalizacje konfiguracji

Konfiguracja MCP znajduje się w plikach mcp.json w jednej z dwóch lokalizacji:

Zakres	Lokalizacja pliku	Przypadek użycia
Projekt	.cursor/mcp.json	Narzędzia specyficzne dla tego projektu (commituj do git dla współdzielenia zespołowego)
Globalna	~/.cursor/mcp.json	Narzędzia, których chcesz wszędzie (osobisty token GitHub itp.)

Instalacja pierwszego serwera MCP

Skonfigurujmy praktyczny serwer MCP. Serwer GitHub to dobry punkt wyjścia, ponieważ natychmiast demonstruje koncepcję i jest przydatny dla większości projektów.

Instalacja jednym kliknięciem

Katalog MCP w Cursor oferuje instalację jednym kliknięciem dla popularnych serwerów. Przejdź do Cursor Settings, a następnie MCP, aby przeglądać dostępne serwery i kliknij “Add to Cursor”, aby je zainstalować.

Ręczna konfiguracja za pomocą mcp.json

Dla większej kontroli utwórz plik konfiguracyjny bezpośrednio.

1. Utwórz plik konfiguracyjny

   mkdir -p .cursor
   touch .cursor/mcp.json

2. Dodaj konfigurację serwera

   Oto serwer MCP GitHub, który pozwala agentowi wchodzić w interakcje z twoimi repozytoriami:

   {
     "mcpServers": {
       "github": {
         "command": "npx",
         "args": ["-y", "@modelcontextprotocol/server-github"],
         "env": {
           "GITHUB_PERSONAL_ACCESS_TOKEN": "${env:GITHUB_TOKEN}"
         }
       }
     }
   }

3. Ustaw zmienną środowiskową

   Dodaj swój token GitHub do profilu powłoki:

   export GITHUB_TOKEN="ghp_twoj_token_tutaj"

4. Zrestartuj Cursor

   Serwery MCP są ładowane przy starcie. Po dodaniu lub zmianie mcp.json zrestartuj Cursor, aby zmiany weszły w życie.

5. Zweryfikuj w panelu agenta

   Otwórz tryb Agent (Cmd+I). Powinieneś zobaczyć narzędzia MCP wymienione w sekcji “Available Tools”, gdy najedziesz na wskaźnik kontekstu.

Praktyczne konfiguracje MCP

Serwer bazy danych (PostgreSQL)

Pozwól agentowi odpytywać schemat bazy danych i uruchamiać zapytania tylko do odczytu:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${env:DATABASE_URL}"
      }
    }
  }
}

Polecenie kopiuj-wklej dla rozwoju świadomego bazy danych

Z skonfigurowanym serwerem Postgres MCP wklej to w trybie Agent:

Sprawdź aktualny schemat bazy danych dla tabeli users.
Następnie utwórz migrację, która dodaje kolumnę boolean email_verified
z wartością domyślną false i indeksem na niej.
Użyj naszych istniejących wzorców migracji.

Agent odpytuje aktualny schemat, widzi bieżące kolumny i generuje dokładną migrację — nie ma zgadywania.

Serwer MCP przeglądarki

Pozwól agentowi przeglądać strony internetowe w celu dokumentacji, sprawdzania działających stron lub testowania:

{
  "mcpServers": {
    "browser": {
      "command": "npx",
      "args": ["-y", "@playwright/mcp@latest"]
    }
  }
}

Serwer sekwencyjnego myślenia

Narzędzie rozumowania, które pomaga agentowi rozwiązywać złożone problemy krok po kroku:

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    }
  }
}

Łączenie wielu serwerów

Twój mcp.json może zawierać wiele serwerów. Oto kompleksowa konfiguracja:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${env:GITHUB_TOKEN}"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${env:DATABASE_URL}"
      }
    },
    "browser": {
      "command": "npx",
      "args": ["-y", "@playwright/mcp@latest"]
    }
  }
}

Zdalne serwery MCP (SSE i HTTP)

Dla serwerów MCP działających jako zdalne usługi (nie lokalne narzędzia CLI) użyj konfiguracji opartej na URL:

{
  "mcpServers": {
    "remote-service": {
      "url": "https://api.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:SERVICE_TOKEN}"
      }
    }
  }
}

Zdalne serwery obsługują uwierzytelnianie OAuth. Cursor obsługuje przepływ OAuth automatycznie — konfigurujesz dane klienta, a Cursor zarządza odświeżaniem tokena:

{
  "mcpServers": {
    "oauth-service": {
      "url": "https://api.example.com/mcp",
      "auth": {
        "CLIENT_ID": "${env:MCP_CLIENT_ID}",
        "CLIENT_SECRET": "${env:MCP_CLIENT_SECRET}",
        "scopes": ["read", "write"]
      }
    }
  }
}

Interpolacja konfiguracji

Cursor wspiera podstawianie zmiennych w wartościach mcp.json:

Zmienna	Tłumaczy się na
${env:NAME}	Zmienna środowiskowa
${userHome}	Twój katalog domowy
${workspaceFolder}	Katalog główny projektu
${workspaceFolderBasename}	Nazwa folderu projektu
${pathSeparator}	Separator ścieżki OS

To pozwala pisać przenośne konfiguracje:

{
  "mcpServers": {
    "custom-tool": {
      "command": "python",
      "args": ["${workspaceFolder}/tools/mcp_server.py"],
      "env": {
        "API_KEY": "${env:CUSTOM_API_KEY}"
      }
    }
  }
}

Zatwierdzanie narzędzi i auto-run

Domyślnie agent prosi o pozwolenie przed wywołaniem narzędzi MCP. To jest oddzielne od ustawienia auto-run dla poleceń terminala.

Aby włączyć auto-run dla narzędzi MCP:

1. Otwórz Cursor Settings, a następnie Agent
2. Włącz auto-run dla narzędzi MCP w sekcji bezpieczeństwa

Uwaga

Włączaj auto-run tylko dla narzędzi MCP, którym w pełni ufasz. Źle skonfigurowany serwer MCP z auto-run może wykonać niezamierzone operacje na zewnętrznych usługach. Zacznij od ręcznego zatwierdzania i włączaj auto-run selektywnie.

Przełączanie poszczególnych narzędzi

Możesz włączać lub wyłączać konkretne narzędzia MCP w panelu agenta. Kliknij nazwę narzędzia na liście dostępnych narzędzi, aby je przełączyć. Wyłączone narzędzia nie są ładowane do kontekstu i nie mogą być wywoływane.

Najlepsze praktyki bezpieczeństwa

• Nigdy nie koduj na stałe kluczy API w mcp.json — zawsze używaj ${env:VARIABLE_NAME}
• Używaj ograniczonych kluczy API z minimalnymi wymaganymi uprawnieniami
• Przeglądaj kod źródłowy serwera dla krytycznych integracji przed zaufaniem im
• Używaj konfiguracji na poziomie projektu dla serwerów współdzielonych zespołowo, konfiguracji globalnych dla osobistych tokenów
• Dodaj .cursor/mcp.json do .gitignore, jeśli zawiera wrażliwe nazwy zmiennych środowiskowych, których nie chcesz w kontroli wersji (lub użyj interpolacji ${env:} i commituj plik)

Polecenie kopiuj-wklej do testowania konfiguracji MCP

Po skonfigurowaniu serwerów MCP sprawdź, czy działają:

Wypisz wszystkie narzędzia MCP aktualnie dostępne dla ciebie.
Następnie użyj narzędzia GitHub, aby wypisać moich 5 najnowszych repozytoriów.

Jeśli agent pokazuje narzędzia i pomyślnie odpytuje GitHub, twoja konfiguracja MCP działa.

Gdy coś się zepsuje

Serwer MCP nie uruchamia się: Sprawdź panel wyjścia Cursor (View, a następnie Output, następnie wybierz serwer MCP z rozwijanej listy) w poszukiwaniu komunikatów o błędach. Częste przyczyny: brak npx, Node.js nie w PATH lub nieprawidłowy JSON w mcp.json.

Narzędzia się pojawiają, ale agent ich nie używa: Agent używa narzędzi MCP, gdy uzna je za istotne. Wspomnij o narzędziu po nazwie w swoim poleceniu: “Użyj narzędzia MCP GitHub, aby sprawdzić otwarte issue.”

Błędy “Permission denied”: Twój klucz API lub token nie ma wymaganych uprawnień. Sprawdź zakresy i uprawnienia dla skonfigurowanego tokena.

Serwer zawiesza się w trakcie rozmowy: Serwery MCP działają jako oddzielne procesy. Jeśli jeden się zawiesi, zrestartuj Cursor. Jeśli zawiesza się wielokrotnie, sprawdź użycie pamięci — niektóre serwery mają duże obciążenie przy dużych zbiorach danych.

Zmienne środowiskowe się nie rozwiązują: Upewnij się, że zmienna jest ustawiona w twoim profilu powłoki (.bashrc, .zshrc), a nie tylko w bieżącej sesji terminala. Cursor odczytuje zmienne środowiskowe przy starcie.

Co dalej

Zarządzanie kontekstem Opanuj symbole @, odniesienia do plików i integrację dokumentów -- umiejętności kontekstowe, które czynią każde polecenie bardziej efektywnym.