Serwery Cursor MCP 2026: Czym są i jak ich używać
March 2026 -- Agent AI w Cursor jest potężny sam w sobie. Jednak bez serwerów MCP jest on uwięziony wewnątrz Twojego edytora, bez możliwości dotarcia do Twojej bazy danych, Twoich repozytoriów GitHub, Twojej dokumentacji czy dziesiątek innych narzędzi, których używasz każdego dnia.
Serwery MCP rozwiązują ten problem. Stanowią one most między AI w Cursor a światem zewnętrznym -- a gdy już je skonfigurujesz, różnica w tym, co może zrobić agent, jest kolosalna.
Ten przewodnik obejmuje wszystko: czym jest MCP, jak działa wewnątrz Cursor, jak skonfigurować swój pierwszy serwer, dziesięć najużyteczniejszych serwerów dla programistów oraz jak rozwiązywać problemy, gdy coś pójdzie nie tak.
Czym jest MCP (Model Context Protocol)?
MCP to skrót od Model Context Protocol. Jest to otwarty standard stworzony przez Anthropic, który definiuje, jak aplikacje AI łączą się z zewnętrznymi narzędziami i źródłami danych poprzez jeden, spójny interfejs.
Pomyśl o tym jak o USB dla narzędzi AI. Przed USB każde urządzenie peryferyjne potrzebowało własnego, dedykowanego kabla. Przed MCP każda integracja AI wymagała niestandardowego kodu -- innego wrappera API dla GitHub, innego dla bazy danych, jeszcze innego dla Slack. MCP zastępuje to wszystko jednym protokołem.
Serwer MCP to lekki program, który udostępnia konkretne narzędzie lub źródło danych poprzez protokół MCP. Serwer MCP filesystem pozwala AI czytać i zapisywać pliki. Serwer MCP GitHub pozwala AI zarządzać repozytoriami i pull requests. Serwer MCP bazy danych pozwala AI uruchamiać zapytania. Każdy serwer to mały, wyspecjalizowany program, który dobrze robi jedną rzecz.
Kluczowe spostrzeżenie: serwery MCP nie są specyficzne dla Cursor. Ten sam serwer MCP, który działa w Cursor, działa również w Claude Code, Windsurf i każdym innym narzędziu wspierającym ten protokół. Konfigurujesz go raz i jest on przenośny w całym Twoim zestawie narzędzi AI.
Dlaczego MCP ma znaczenie dla programistów
Bez MCP Twój proces pracy wygląda tak:
- Prosisz agenta Cursor o pomoc w zapytaniu do bazy danych
- Agent mówi, że nie ma dostępu do Twojej bazy danych
- Ręcznie kopiujesz schemat, wklejasz go do czatu, samodzielnie uruchamiasz zapytanie, wklejasz wyniki z powrotem
- Agent analizuje wklejone przez Ciebie wyniki
Z MCP ten sam proces wygląda tak:
- Prosisz agenta Cursor o sprawdzenie, dlaczego liczba rejestracji użytkowników spadła w zeszłym tygodniu
- Agent łączy się z Twoją bazą danych przez serwer MCP, uruchamia zapytanie, analizuje wyniki i podaje Ci odpowiedź
To jest ta różnica. MCP usuwa wąskie gardło w postaci kopiowania i wklejania między Twoim agentem AI a narzędziami, których potrzebuje. Agent przestaje być asystentem tylko tekstowym i staje się kimś, kto może faktycznie wchodzić w interakcję z Twoją infrastrukturą.
Stan na March 2026: ekosystem MCP urósł do ponad 5,000 serwerów zbudowanych przez społeczność. Niezależnie od tego, jakiego narzędzia lub usługi używasz, prawdopodobnie istnieje już dla nich serwer MCP.
Jak działa MCP w Cursor
Architektura składa się z trzech warstw:
Cursor Agent (AI)
|
v
MCP Client (built into Cursor)
|
v
MCP Server (external process)
|
v
External Tool (GitHub, database, filesystem, etc.)
Gdy konfigurujesz serwer MCP w Cursor, oto co dzieje się pod maską:
- Cursor uruchamia serwer MCP jako proces potomny (dla transportu stdio) lub łączy się z nim przez HTTP (dla serwerów zdalnych).
- Serwer rejestruje swoje narzędzia -- informuje Cursor, jakie możliwości oferuje (np. "mogę czytać pliki", "mogę przeszukiwać repozytoria GitHub", "mogę uruchamiać zapytania SQL").
- Agent Cursor widzi te narzędzia w swoim zestawie dostępnych narzędzi. Gdy agent uzna, że narzędzie jest istotne dla Twojej prośby, wywołuje je automatycznie.
- Serwer wykonuje akcję w zewnętrznym narzędziu i zwraca wynik do agenta.
Cursor obsługuje dwa główne typy transportu:
- stdio -- Serwer działa lokalnie na Twojej maszynie. Cursor komunikuje się z nim poprzez standardowe wejście/wyjście. Jest to najczęstsza konfiguracja dla indywidualnych programistów.
- Streamable HTTP -- Serwer działa jako niezależny proces (lokalnie lub zdalnie) i komunikuje się przez HTTP. Lepiej sprawdza się w środowiskach zespołowych i przy serwerach zdalnych.
Jedno ważne ograniczenie: Cursor obecnie obsługuje do 40 tools łącznie we wszystkich Twoich serwerach MCP. Większość konfiguracji działa dobrze z 3 do 5 serwerami.
Konfiguracja Twojego pierwszego serwera MCP
Wymagania wstępne: Node.js v18 lub nowszy oraz Cursor v0.42 lub nowszy.
Metoda 1: Przez ustawienia Cursor (Zalecane)
- Otwórz Cursor Settings za pomocą
Cmd + ,(Mac) lubCtrl + ,(Windows/Linux). - Przejdź do Tools & MCP na pasku bocznym.
- Kliknij + Add New MCP Server.
- Wypełnij pola:
- Name: Etykieta dla serwera (np. "Filesystem")
- Transport Type: Wybierz
stdio - Command: Polecenie powłoki do uruchomienia serwera
Na przykład, aby dodać serwer filesystem:
- Name:
filesystem - Type:
stdio - Command:
npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/directory
Metoda 2: Plik konfiguracji na poziomie projektu
Utwórz plik .cursor/mcp.json w głównym katalogu swojego projektu:
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/you/projects/my-app"
]
}
}
}
Ta konfiguracja dotyczy tylko tego projektu. Członkowie zespołu, którzy sklonują repozytorium, otrzymają tę samą konfigurację MCP automatycznie.
Metoda 3: Globalny plik konfiguracji
Utwórz ~/.cursor/mcp.json dla serwerów, które chcesz mieć dostępne we wszystkich projektach:
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
}
}
}
}
Po dodaniu serwera wróć do Cursor Settings > Tools & MCP. Powinieneś zobaczyć swój serwer na liście z zielonym wskaźnikiem pokazującym, że jest połączony. Narzędzia, które dostarcza, pojawią się w sekcji "Available Tools".
Top 10 serwerów MCP dla Cursor
Oto najużyteczniejsze serwery MCP w codziennej pracy programistycznej, oparte na rzeczywistych danych o użytkowaniu i adopcji przez społeczność.
1. Filesystem
Czytaj, zapisuj, przeszukuj i zarządzaj plikami na swojej lokalnej maszynie. Daje agentowi bezpośredni dostęp do plików projektu wykraczający poza to, co Cursor oferuje natywnie.
{
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/directory"]
}
}
2. GitHub
Zarządzaj repozytoriami, issues, pull requests i przeszukiwaniem kodu bezpośrednio przez agenta. Oficjalny serwer MCP GitHub obsługuje wszystkie podstawowe operacje GitHub.
{
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxxxxxxxxxxx"
}
}
}
3. PostgreSQL / SQLite (Baza danych)
Pozwól agentowi odpytywać Twoją bazę danych, sprawdzać schematy i analizować dane bez opuszczania Cursor.
{
"sqlite": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sqlite", "/path/to/database.db"]
}
}
Dla PostgreSQL:
{
"postgres": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres"],
"env": {
"DATABASE_URL": "postgresql://user:pass@localhost:5432/mydb"
}
}
}
4. Brave Search (Wyszukiwanie w sieci)
Daj agentowi możliwość przeszukiwania internetu na żywo. Wykorzystuje niezależny indeks wyszukiwania Brave bez śledzenia.
{
"brave-search": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-brave-search"],
"env": {
"BRAVE_API_KEY": "your_brave_api_key"
}
}
}
5. Playwright (Automatyzacja przeglądarki)
Agent może nawigować po stronach internetowych, wypełniać formularze, robić zrzuty ekranu i pobierać treść za pomocą prawdziwej przeglądarki.
{
"playwright": {
"command": "npx",
"args": ["-y", "@executeautomation/playwright-mcp-server"]
}
}
6. Slack
Czytaj kanały, wysyłaj wiadomości, przeszukuj historię rozmów. Przydatne dla agentów, którzy muszą pobierać kontekst z dyskusji zespołu.
{
"slack": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-slack"],
"env": {
"SLACK_BOT_TOKEN": "xoxb-your-token",
"SLACK_TEAM_ID": "T0123456789"
}
}
}
7. Memory (Trwała wiedza)
Daje agentowi trwałą pamięć między sesjami. Może on przechowywać i przywoływać fakty, decyzje i kontekst, które w przeciwnym razie zostałyby utracone po zamknięciu czatu.
{
"memory": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-memory"]
}
}
8. Context7 (Wyszukiwanie dokumentacji)
Wstrzykuje dokumentację specyficzną dla wersji bezpośrednio do kontekstu agenta. Szczególnie przydatne podczas pracy z frameworkami, gdzie dane treningowe AI mogą być nieaktualne.
{
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp"]
}
}
9. Docker
Zarządzaj kontenerami, obrazami i stosami compose. Agent może uruchamiać usługi, sprawdzać logi i rozwiązywać problemy z kontenerami.
{
"docker": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-docker"]
}
}
10. Sequential Thinking
Nie jest to łącznik z narzędziem, ale wzmacniacz rozumowania. Strukturyzuje proces myślowy agenta dla złożonych, wieloetapowych problemów, dzieląc je na sekwencyjne kroki rozumowania.
{
"sequential-thinking": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
}
}
Zaawansowana konfiguracja
Zmienne środowiskowe
Serwery MCP często potrzebują kluczy API i danych uwierzytelniających. Przekaż je przez pole env w swojej konfiguracji:
{
"mcpServers": {
"my-server": {
"command": "npx",
"args": ["-y", "my-mcp-server"],
"env": {
"API_KEY": "sk-xxxxxxxxxxxx",
"API_URL": "https://api.example.com"
}
}
}
}
Nigdy nie commituj kluczy API do systemu kontroli wersji. W przypadku konfiguracji na poziomie projektu udostępnianych zespołowi, używaj wartości zastępczych i dokumentuj wymagane zmienne środowiskowe oddzielnie.
Budowanie własnego serwera MCP
Jeśli żaden istniejący serwer nie spełnia Twoich potrzeb, możesz zbudować własny. MCP SDK jest dostępne w TypeScript, Python i kilku innych językach:
npm install @modelcontextprotocol/sdk
Minimalny własny serwer w TypeScript:
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
const server = new McpServer({ name: "my-server", version: "1.0.0" });
server.tool("hello", "Says hello to a user", { name: { type: "string" } },
async ({ name }) => ({
content: [{ type: "text", text: `Hello, ${name}!` }]
})
);
const transport = new StdioServerTransport();
await server.connect(transport);
Konfiguracja na poziomie projektu vs. globalna
Używaj poziomu projektu (.cursor/mcp.json) dla:
- Połączeń z bazami danych specyficznych dla projektu
- Wewnętrznych serwerów API
- Narzędzi specyficznych dla projektu, których potrzebują koledzy z zespołu
Używaj poziomu globalnego (~/.cursor/mcp.json) dla:
- Integracji z GitHub, GitLab lub innymi hostami kodu
- Wyszukiwania w sieci
- Narzędzi ogólnego przeznaczenia, takich jak memory lub sequential thinking
Gdy ta sama nazwa serwera pojawia się w obu plikach, priorytet ma konfiguracja na poziomie projektu.
MCP w Cursor vs. Claude Code vs. Windsurf
MCP to otwarty protokół i wszystkie trzy główne narzędzia AI do kodowania teraz go wspierają. Jednak implementacje różnią się w istotny sposób.
| Funkcja | Cursor | Claude Code | Windsurf |
|---|---|---|---|
| Wsparcie MCP | Tak (v0.42+) | Tak (natywne) | Tak |
| Typy transportu | stdio, SSE, Streamable HTTP | stdio, Streamable HTTP | stdio, SSE |
| Konfiguracja | .cursor/mcp.json | ~/.claude/mcp.json lub poziom projektu | .windsurf/mcp.json |
| Limit narzędzi | max 40 tools | Brak sztywnego limitu | Zmienny |
| Instalacja jednym kliknięciem | Tak (wybrane serwery) | Ograniczona | Tak |
| Wsparcie OAuth | Tak | Nie (ręczne tokens) | Tak |
| Kontrola Enterprise | Podstawowa | N/A (narzędzie CLI) | Kontrola na poziomie administratora |
| Blokada IDE (Lock-in) | Tylko Cursor (fork VS Code) | Działa w każdym terminalu / rozszerzeniu VS Code | 40+ wtyczek IDE |
Cursor jest najłatwiejszy w konfiguracji dzięki instalacji serwerów jednym kliknięciem i interfejsowi ustawień. Jego ograniczeniem jest limit 40 narzędzi oraz bycie przypisanym do edytora Cursor.
Claude Code działa w terminalu oraz jako rozszerzenie VS Code. Posiada najgłębszą integrację MCP, ponieważ Anthropic stworzyło zarówno Claude, jak i MCP. Brak limitu narzędzi, ale konfiguracja jest bardziej ręczna.
Windsurf oferuje najszerszą kompatybilność z IDE i najsilniejszą kontrolę dla przedsiębiorstw. Jeśli Twój zespół potrzebuje konfiguracji MCP zarządzanych przez administratora, Windsurf ma przewagę.
Dobra wiadomość: ponieważ MCP to otwarty protokół, same serwery są wymienne. Serwer, który skonfigurujesz dla Cursor, będzie działał w Claude Code i Windsurf przy zmianie jedynie pliku konfiguracyjnego.
Rozwiązywanie typowych problemów
Serwer pokazuje "Not Connected" w ustawieniach
- Sprawdź, czy zainstalowany jest Node.js v18+:
node --version - Zweryfikuj, czy polecenie npx działa poza Cursor: uruchom polecenie bezpośrednio w terminalu
- Spójrz do konsoli deweloperskiej Cursor (
Help > Toggle Developer Tools) w poszukiwaniu komunikatów o błędach - Zrestartuj Cursor po dodaniu lub modyfikacji konfiguracji serwera
Narzędzia nie pojawiają się w dostępnych narzędziach agenta
- Potwierdź, czy zielony wskaźnik statusu serwera jest widoczny w Settings > Tools & MCP
- Sprawdź, czy nie przekroczyłeś limitu 40 tools we wszystkich serwerach
- Spróbuj usunąć i ponownie dodać serwer
Serwer ulega awarii lub przekracza limit czasu (timeout)
- Niektóre serwery potrzebują konkretnych zmiennych środowiskowych. Sprawdź plik README serwera pod kątem wymaganej konfiguracji
- Zwiększ alokację pamięci, jeśli serwer obsługuje duże zestawy danych
- W przypadku serwerów stdio upewnij się, że żaden inny proces nie konkuruje o te same stdin/stdout
Błędy autoryzacji
- Sprawdź dwukrotnie klucze API i tokens w konfiguracji
env - W przypadku GitHub upewnij się, że Twój personal access token ma wymagane uprawnienia (zazwyczaj
repo,read:org) - W przypadku serwerów opartych na OAuth spróbuj ponownie przeprowadzić autoryzację przez interfejs ustawień Cursor
Konfiguracja nie ładuje się
- W przypadku konfiguracji na poziomie projektu sprawdź, czy plik znajduje się w
.cursor/mcp.json(a nie w.cursor/mcp/config.jsonlub innych wariantach) - Sprawdź składnię JSON -- jeden postawiony w złym miejscu przecinek zepsuje cały plik
- Zrestartuj Cursor po każdej zmianie konfiguracji
Podsumowanie
Serwery MCP przekształcają Cursor z inteligentnego edytora tekstu w środowisko programistyczne napędzane przez AI, które może faktycznie wchodzić w interakcję z Twoimi narzędziami i infrastrukturą. Konfiguracja pierwszego serwera zajmuje 5 minut, a wzrost produktywności jest natychmiastowy.
Zacznij od dwóch lub trzech serwerów, które pasują do Twojego codziennego procesu pracy -- filesystem, GitHub i łącznik z bazą danych zaspokajają potrzeby większości programistów. Dodawaj kolejne, gdy znajdziesz konkretne potrzeby. I pamiętaj, że każdy serwer MCP skonfigurowany w Cursor jest przenośny: jeśli jutro zmienisz narzędzie na Claude Code lub Windsurf, Twoje serwery pójdą z Tobą.
Ekosystem MCP rośnie szybko. Z ponad 5,000 dostępnymi serwerami i protokołem wspieranym obecnie przez każde major narzędzie AI do kodowania, MCP nie jest już eksperymentem. To standardowy sposób, w jaki narzędzia AI łączą się ze światem zewnętrznym -- a Cursor to jedno z najlepszych miejsc, aby zacząć go używać.
