Cursor MCP szerverek 2026: Mik ezek és hogyan használjuk őket
March 2026 -- A Cursor AI ágense önmagában is hatékony. De MCP szerverek nélkül be van zárva a szerkesztőbe, nincs módja elérni az adatbázisodat, a GitHub repóidat, a dokumentációdat vagy a többi tucatnyi eszközt, amit nap mint nap használsz.
Az MCP szerverek megoldják ezt. Ezek jelentik a hidat a Cursor AI-ja és a külvilág között -- és amint beállítod őket, az ágens képességeiben tapasztalható különbség ég és föld lesz.
Ez az útmutató mindenre kiterjed: mi az az MCP, hogyan működik a Cursor-on belül, hogyan állítsd be az első szerveredet, melyik a tíz leghasznosabb szerver a fejlesztők számára, és hogyan hárítsd el a hibákat, ha valami elromlik.
Mi az az MCP (Model Context Protocol)?
Az MCP a Model Context Protocol rövidítése. Ez egy az Anthropic által létrehozott nyílt szabvány, amely meghatározza, hogyan kapcsolódjanak az AI alkalmazások külső eszközökhöz és adatforrásokhoz egyetlen, konzisztens interfészen keresztül.
Gondolj rá úgy, mint az AI eszközök USB-jére. Az USB előtt minden perifériának saját, egyedi kábelre volt szüksége. Az MCP előtt minden AI integrációhoz egyedi kód kellett -- egy külön API wrapper a GitHub-hoz, egy másik az adatbázishoz, egy másik a Slack-hez. Az MCP mindezt egyetlen protokollal váltja fel.
Egy MCP szerver egy könnyűsúlyú program, amely egy specifikus eszközt vagy adatforrást tesz elérhetővé az MCP protokollon keresztül. Egy filesystem MCP szerver lehetővé teszi az AI számára a fájlok olvasását és írását. Egy GitHub MCP szerver lehetővé teszi az AI számára a repók és pull request-ek kezelését. Egy adatbázis MCP szerver lehetővé teszi az AI számára lekérdezések futtatását. Minden szerver egy kicsi, fókuszált program, amely egy dolgot csinál jól.
A legfontosabb felismerés: az MCP szerverek nem Cursor-specifikusak. Ugyanaz az MCP szerver, amely működik a Cursor-ban, működik a Claude Code-ban, a Windsurf-ben és minden más eszközben is, amely támogatja a protokollt. Egyszer konfigurálod, és hordozható a teljes AI eszköztáradban.
Miért fontos az MCP a fejlesztőknek?
MCP nélkül a munkafolyamatod így néz ki:
- Megkéred a Cursor ágensét, hogy segítsen egy adatbázis-lekérdezésben
- Az ágens azt mondja, hogy nem fér hozzá az adatbázishoz
- Manuálisan másolod a sémát, beilleszted a chatbe, magad futtatod a lekérdezést, visszamásolod az eredményeket
- Az ágens elemzi az általad beillesztett eredményeket
Az MCP-vel ugyanez a folyamat így néz ki:
- Megkéred a Cursor ágensét, hogy ellenőrizze, miért csökkent a felhasználói regisztrációk száma a múlt héten
- Az ágens az MCP szerveren keresztül csatlakozik az adatbázishoz, lefuttatja a lekérdezést, elemzi az eredményeket, és megadja a választ
Ez a különbség. Az MCP megszünteti a másolás-beillesztés okozta szűk keresztmetszetet az AI ágens és a szükséges eszközök között. Az ágens nem csupán egy szöveges asszisztens lesz, hanem valaki, aki ténylegesen képes interakcióba lépni az infrastruktúráddal.
2026 márciusára az MCP ökoszisztéma több mint 5,000 közösség által épített szerverre nőtt. Bármilyen eszközt vagy szolgáltatást is használsz, valószínűleg már létezik hozzá MCP szerver.
Hogyan működik az MCP a Cursor-ban?
Az architektúra három rétegből áll:
Cursor Agent (AI)
|
v
MCP Client (built into Cursor)
|
v
MCP Server (external process)
|
v
External Tool (GitHub, database, filesystem, etc.)
Amikor konfigurálsz egy MCP szervert a Cursor-ban, a színfalak mögött a következő történik:
- A Cursor elindítja az MCP szervert gyermekfolyamatként (stdio transzporthoz) vagy HTTP-n keresztül csatlakozik hozzá (távoli szerverek esetén).
- A szerver regisztrálja az eszközeit -- közli a Cursor-ral, milyen képességeket kínál (pl. "tudok fájlokat olvasni", "tudok keresni GitHub repókban", "tudok SQL lekérdezéseket futtatni").
- A Cursor ágens látja ezeket az eszközöket az elérhető eszközkészletében. Amikor az ágens úgy ítéli meg, hogy egy eszköz releváns a kérésedhez, automatikusan meghívja azt.
- A szerver végrehajtja a műveletet a külső eszközön, és visszaküldi az eredményt az ágensnek.
A Cursor két fő transzport típust támogat:
- stdio -- A szerver helyileg fut a gépeden. A Cursor standard input/output-on keresztül kommunikál vele. Ez a leggyakoribb felállás egyéni fejlesztők számára.
- Streamable HTTP -- A szerver független folyamatként fut (helyileg vagy távolról), és HTTP-n keresztül kommunikál. Jobb csapatorientált környezetekhez és távoli szerverekhez.
Egy fontos korlátozás: a Cursor jelenleg összesen legfeljebb 40 tools használatát támogatja az összes MCP szerveredet együttvéve. A legtöbb összeállítás jól működik 3-5 szerverrel.
Az első MCP szervered beállítása
Előfeltételek: Node.js v18 vagy újabb és Cursor v0.42 vagy újabb.
1. módszer: A Cursor beállításain keresztül (Ajánlott)
- Nyisd meg a Cursor Settings-t a
Cmd + ,(Mac) vagyCtrl + ,(Windows/Linux) billentyűkkel. - Navigálj a Tools & MCP részhez az oldalsávon.
- Kattints az + Add New MCP Server gombra.
- Töltsd ki a mezőket:
- Name: A szerver címkéje (pl. "Filesystem")
- Transport Type: Válaszd az
stdioopciót - Command: A parancs a szerver elindításához
Például a filesystem szerver hozzáadásához:
- Name:
filesystem - Type:
stdio - Command:
npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/directory
2. módszer: Projekt-szintű konfigurációs fájl
Hozz létre egy .cursor/mcp.json fájlt a projekt gyökerében:
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/you/projects/my-app"
]
}
}
}
Ez a konfiguráció csak erre a projektre vonatkozik. Azok a csapattagok, akik klónozzák a repót, automatikusan megkapják ugyanazt az MCP beállítást.
3. módszer: Globális konfigurációs fájl
Hozz létre egy ~/.cursor/mcp.json fájlt azokhoz a szerverekhez, amelyeket minden projektben el szeretnél érni:
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
}
}
}
}
A szerver hozzáadása után menj vissza a Cursor Settings > Tools & MCP részhez. Látnod kell a szervert a listában egy zöld jelzéssel, ami mutatja, hogy csatlakozva van. Az általa kínált eszközök az "Available Tools" alatt jelennek meg.
Top 10 MCP szerver Cursor-hoz
Ezek a leghasznosabb MCP szerverek a napi fejlesztői munkához, a valós használati adatok és a közösségi elfogadottság alapján.
1. Filesystem
Fájlok olvasása, írása, keresése és kezelése a helyi gépen. Közvetlen hozzáférést biztosít az ágensnek a projektfájlokhoz azon túl is, amit a Cursor natívan nyújt.
{
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/directory"]
}
}
2. GitHub
Repók, issue-k, pull request-ek kezelése és kódkeresés közvetlenül az ágensből. A hivatalos GitHub MCP szerver támogatja az összes alapvető GitHub műveletet.
{
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxxxxxxxxxxx"
}
}
}
3. PostgreSQL / SQLite (Adatbázis)
Lehetővé teszi az ágens számára az adatbázis lekérdezését, a sémák vizsgálatát és az adatok elemzését anélkül, hogy elhagyná a Cursor-t.
{
"sqlite": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sqlite", "/path/to/database.db"]
}
}
PostgreSQL esetén:
{
"postgres": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres"],
"env": {
"DATABASE_URL": "postgresql://user:pass@localhost:5432/mydb"
}
}
}
4. Brave Search (Webes keresés)
Képessé teszi az ágenst az élő weben való keresésre. A Brave független keresési indexét használja nyomon követés nélkül.
{
"brave-search": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-brave-search"],
"env": {
"BRAVE_API_KEY": "your_brave_api_key"
}
}
}
5. Playwright (Böngésző automatizálás)
Az ágens képes weboldalakon navigálni, űrlapokat kitölteni, képernyőképeket készíni és tartalmat kinyerni egy valódi böngésző használatával.
{
"playwright": {
"command": "npx",
"args": ["-y", "@executeautomation/playwright-mcp-server"]
}
}
6. Slack
Csatornák olvasása, üzenetek küldése, beszélgetési előzmények keresése. Hasznos olyan ágensek számára, amelyeknek kontextust kell kinyerniük a csapattal folytatott megbeszélésekből.
{
"slack": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-slack"],
"env": {
"SLACK_BOT_TOKEN": "xoxb-your-token",
"SLACK_TEAM_ID": "T0123456789"
}
}
}
7. Memory (Perzisztens tudás)
Perzisztens memóriát biztosít az ágensnek a munkamenetek között. Képes tárolni és felidézni tényeket, döntéseket és kontextust, amely egyébként elveszne a chat bezárásakor.
{
"memory": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-memory"]
}
}
8. Context7 (Dokumentáció keresés)
Verzió-specifikus dokumentációt injektál közvetlenül az ágens kontextusába. Különösen hasznos olyan keretrendszerekkel való munka során, ahol az AI tanító adatai elavultak lehetnek.
{
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp"]
}
}
9. Docker
Konténerek, image-ek és compose stack-ek kezelése. Az ágens képes szolgáltatásokat elindítani, logokat ellenőrizni és konténer-hibákat elhárítani.
{
"docker": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-docker"]
}
}
10. Sequential Thinking
Nem egy eszköz-konnektor, hanem egy gondolkodás-fokozó. Strukturálja az ágens gondolkodási folyamatát összetett, több lépésből álló problémák esetén, szekvenciális érvelési lépésekre bontva azokat.
{
"sequential-thinking": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
}
}
Haladó konfiguráció
Környezeti változók
Az MCP szervereknek gyakran szükségük van API kulcsokra és hitelesítő adatokra. Ezeket az env mezőn keresztül adhatod át a konfigurációdban:
{
"mcpServers": {
"my-server": {
"command": "npx",
"args": ["-y", "my-mcp-server"],
"env": {
"API_KEY": "sk-xxxxxxxxxxxx",
"API_URL": "https://api.example.com"
}
}
}
}
Soha ne commit-old az API kulcsokat a verziókövetőbe. A csapattal megosztott projekt-szintű konfigurációkhoz használj helyőrző értékeket, és dokumentáld külön a szükséges környezeti változókat.
Egyedi MCP szerver építése
Ha nincs olyan létező szerver, amely megfelelne az igényeidnek, építhetsz egyet. Az MCP SDK elérhető TypeScript, Python és számos más nyelven:
npm install @modelcontextprotocol/sdk
Egy minimális egyedi szerver TypeScript nyelven:
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);
Projekt-szintű vs. Globális konfiguráció
Használd a projekt-szintű (.cursor/mcp.json) konfigurációt:
- Egy adott projekthez tartozó adatbázis-kapcsolatokhoz
- Belső API szerverekhez
- Projekt-specifikus eszközökhöz, amikre a csapattársaknak is szükségük van
Használd a globális (~/.cursor/mcp.json) konfigurációt:
- GitHub, GitLab vagy más kódgazda integrációkhoz
- Webes kereséshez
- Általános célú eszközökhöz, mint a memory vagy a sequential thinking
Ha ugyanaz a szervernév mindkét fájlban szerepel, a projekt-szintű konfiguráció élvez elsőbbséget.
MCP a Cursor vs. Claude Code vs. Windsurf összevetésben
Az MCP egy nyílt protokoll, és mára mindhárom nagy AI kódoló eszköz támogatja. De a megvalósítások jelentősen eltérnek.
| Funkció | Cursor | Claude Code | Windsurf |
|---|---|---|---|
| MCP támogatás | Igen (v0.42+) | Igen (natív) | Igen |
| Transzport típusok | stdio, SSE, Streamable HTTP | stdio, Streamable HTTP | stdio, SSE |
| Konfiguráció | .cursor/mcp.json | ~/.claude/mcp.json vagy projekt-szintű | .windsurf/mcp.json |
| Eszköz korlát | Max 40 eszköz | Nincs fix korlát | Változó |
| Egykattintásos telepítés | Igen (válogatott szerverek) | Korlátozott | Igen |
| OAuth támogatás | Igen | Nem (manuális tokens) | Igen |
| Vállalati vezérlők | Alapvető | N/A (CLI eszköz) | Adminisztrátori szintű vezérlők |
| IDE kötöttség | Csak Cursor (VS Code fork) | Bármilyen terminálban / VS Code extension-ben működik | 40+ IDE plugin |
A Cursor a legegyszerűbben beállítható az egykattintásos szervertelepítésnek és a beállítási felületnek köszönhetően. Korlátja a 40 eszközös limit és a Cursor szerkesztőhöz való kötöttség.
A Claude Code a terminálban és VS Code extension-ként fut. Ebben a legmélyebb az MCP integráció, mivel az Anthropic hozta létre a Claude-ot és az MCP-t is. Nincs eszközlimit, de a beállítás manuálisabb.
A Windsurf kínálja a legszélesebb IDE kompatibilitást és a legerősebb vállalati vezérlőket. Ha a csapatodnak adminisztrátor által kezelt MCP konfigurációkra van szüksége, a Windsurf előnyben van.
A jó hír: mivel az MCP nyílt protokoll, maguk a szerverek felcserélhetőek. Egy szerver, amit a Cursor-hoz konfiguráltál, működni fog a Claude Code-ban és a Windsurf-ben is, mindössze a konfigurációs fájl módosításával.
Gyakori problémák elhárítása
A szerver "Not Connected" állapotot mutat a beállításokban
- Ellenőrizd, hogy a Node.js v18+ telepítve van-e:
node --version - Ellenőrizd, hogy az npx parancs működik-e a Cursor-on kívül: futtasd a parancsot közvetlenül a terminálodban
- Nézd meg a Cursor fejlesztői konzolját (
Help > Toggle Developer Tools) a hibaüzenetekért - Indítsd újra a Cursor-t a szerverkonfigurációk hozzáadása vagy módosítása után
Az eszközök nem jelennek meg az ágens elérhető eszközei között
- Erősítsd meg, hogy a szerver zöld állapotjelzője látható a Settings > Tools & MCP alatt
- Ellenőrizd, hogy nem lépted-e túl a 40 eszközös korlátot az összes szerveren
- Próbáld meg eltávolítani, majd újra hozzáadni a szervert
A szerver összeomlik vagy túllépi az időkorlátot
- Egyes szervereknek specifikus környezeti változókra van szükségük. Ellenőrizd a szerver README fájlját a szükséges konfigurációért
- Növeld a memóriafoglalást, ha a szerver nagy adathalmazokat kezel
- Stdio szerverek esetén győződj meg róla, hogy más folyamat nem verseng ugyanazért a stdin/stdout csatornáért
Hitelesítési hibák
- Ellenőrizd kétszer is az API kulcsokat és tokeneket az
envkonfigurációban - GitHub esetén győződj meg róla, hogy a personal access token rendelkezik a szükséges jogosultságokkal (jellemzően
repo,read:org) - OAuth-alapú szerverek esetén próbálj meg újra hitelesíteni a Cursor beállítási felületén keresztül
A konfiguráció nem töltődik be
- Projekt-szintű konfigurációk esetén ellenőrizd, hogy a fájl pontosan a
.cursor/mcp.jsonhelyen van-e (nem.cursor/mcp/config.jsonvagy más változat) - Ellenőrizd a JSON szintaktikát -- egyetlen rossz helyre tett vessző is tönkreteheti az egész fájlt
- Bármilyen konfigurációs módosítás után indítsd újra a Cursor-t
Összegzés
Az MCP szerverek a Cursor-t egy okos szövegszerkesztőből egy AI-vezérelt fejlesztői környezetté alakítják át, amely ténylegesen képes interakcióba lépni az eszközeiddel és az infrastruktúráddal. Az első szerver beállítása öt percet vesz igénybe, a termelékenység növekedése pedig azonnali.
Kezdd két vagy három olyan szerverrel, amely illeszkedik a napi munkafolyamatodhoz -- a filesystem, a GitHub és egy adatbázis-konnektor a legtöbb fejlesztő igényeit lefedi. Adj hozzá többet, ahogy specifikus igényeid merülnek fel. És ne feledd, hogy minden MCP szerver, amit a Cursor-ban konfigurálsz, hordozható: ha holnap átváltasz Claude Code-ra vagy Windsurf-re, a szervereid jönnek veled.
Az MCP ökoszisztéma gyorsan növekszik. Több mint 5,000 elérhető szerverrel és a protokoll minden nagyobb AI kódoló eszköz általi támogatásával az MCP már nem kísérlet. Ez a szabványos módja annak, ahogy az AI eszközök kapcsolódnak a külvilághoz -- és a Cursor az egyik legjobb hely a használatának megkezdéséhez.
