Cursor MCP Servers 2026: Vad de är och hur du använder dem

March 2026 -- Cursors AI-agent är kraftfull i sig själv. Men utan MCP-servrar är den fast i din editor utan något sätt att nå din databas, dina GitHub-repos, din dokumentation eller de dussintals andra verktyg du använder varje dag.

MCP-servrar löser det. De är bryggan mellan Cursors AI och omvärlden -- och när du väl har konfigurerat dem är skillnaden i vad agenten kan göra som natt och dag.

Denna guide täcker allt: vad MCP är, hur det fungerar inuti Cursor, hur du konfigurerar din första server, de tio mest användbara servrarna för utvecklare, och hur du felsöker när saker går fel.

---

Vad är MCP (Model Context Protocol)?

MCP står för Model Context Protocol. Det är en öppen standard skapad av Anthropic som definierar hur AI-applikationer ansluter till externa verktyg och datakällor via ett enda, konsekvent gränssnitt.

Tänk på det som USB för AI-verktyg. Innan USB behövde varje kringutrustning sin egen proprietära kabel. Innan MCP krävde varje AI-integration anpassad kod -- en specifik API-wrapper för GitHub, en annan för din databas, en annan för Slack. MCP ersätter allt detta med ett protokoll.

En MCP-server är ett lättviktigt program som exponerar ett specifikt verktyg eller en datakälla genom MCP-protokollet. En filesystem MCP-server låter AI:n läsa och skriva filer. En GitHub MCP-server låter AI:n hantera repositorier och pull requests. En databas-MCP-server låter AI:n köra frågor. Varje server är ett litet, fokuserat program som gör en sak bra.

Den viktigaste insikten: MCP-servrar är inte specifika för Cursor. Samma MCP-server som fungerar i Cursor fungerar även i Claude Code, Windsurf och alla andra verktyg som stöder protokollet. Du konfigurerar den en gång och den är portabel över hela din AI-verktygslåda.

---

Varför MCP är viktigt för utvecklare

Utan MCP ser ditt arbetsflöde ut så här:

1. Be Cursors agent om hjälp med en databasfråga
2. Agenten säger att den inte kan komma åt din databas
3. Du kopierar schemat manuellt, klistrar in det i chatten, kör frågan själv, klistrar tillbaka resultaten
4. Agenten analyserar resultaten du klistrade in

Med MCP blir samma arbetsflöde:

1. Be Cursors agent att kontrollera varför användarregistreringar sjönk förra veckan
2. Agenten ansluter till din databas via MCP-servern, kör frågan, analyserar resultaten och ger dig svaret

Det är skillnaden. MCP tar bort flaskhalsen med kopiera-klistra in mellan din AI-agent och de verktyg den behöver. Agenten slutar vara en assistent för enbart text och blir något som faktiskt kan interagera med din infrastruktur.

Från och med March 2026 har MCP-ekosystemet vuxit till över 5,000 community-byggda servrar. Oavsett vilket verktyg eller tjänst du använder finns det förmodligen redan en MCP-server för det.

---

Hur MCP fungerar i Cursor

Arkitekturen har tre lager:

Cursor Agent (AI)
    |
    v
MCP Client (inbyggd i Cursor)
    |
    v
MCP Server (extern process)
    |
    v
External Tool (GitHub, databas, filesystem, etc.)

När du konfigurerar en MCP-server i Cursor är det detta som händer under huven:

1. Cursor startar MCP-servern som en underprocess (för stdio-transport) eller ansluter till den via HTTP (för fjärrservrar).
2. Servern registrerar sina verktyg -- den berättar för Cursor vilka förmågor den erbjuder (t.ex. "Jag kan läsa filer", "Jag kan söka i GitHub-repos", "Jag kan köra SQL-frågor").
3. Cursor-agenten ser dessa verktyg i sin tillgängliga verktygsuppsättning. När agenten bedömer att ett verktyg är relevant för din begäran, anropar den det automatiskt.
4. Servern utför åtgärden mot det externa verktyget och returnerar resultatet till agenten.

Cursor stöder två huvudsakliga transporttyper:

• stdio -- Servern körs lokalt på din maskin. Cursor kommunicerar med den via standard input/output. Detta är den vanligaste konfigurationen för enskilda utvecklare.
• Streamable HTTP -- Servern körs som en oberoende process (lokalt eller fjärrstyrt) och kommunicerar via HTTP. Bättre för teammiljöer och fjärrservrar.

En viktig begränsning: Cursor stöder för närvarande upp till 40 verktyg totalt över alla dina MCP-servrar kombinerat. De flesta uppsättningar fungerar bra med 3 till 5 servrar.

---

Konfigurera din första MCP-server

Förutsättningar: Node.js v18 eller senare och Cursor v0.42 eller senare.

Metod 1: Via Cursor-inställningar (Rekommenderas)

1. Öppna Cursor-inställningar med Cmd + , (Mac) eller Ctrl + , (Windows/Linux).
2. Navigera till Tools & MCP i sidofältet.
3. Klicka på + Add New MCP Server.
4. Fyll i fälten:
   • Name: En etikett för servern (t.ex. "Filesystem")
   • Transport Type: Välj stdio
   • Command: Shell-kommandot för att starta servern

Till exempel, för att lägga till filesystem-servern:

• Name: filesystem
• Type: stdio
• Command: npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/directory

Metod 2: Konfigurationsfil på projektnivå

Skapa en .cursor/mcp.json-fil i din projektrot:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/you/projects/my-app"
      ]
    }
  }
}

Denna konfiguration gäller endast för detta projekt. Teammedlemmar som klonar repot får samma MCP-inställningar automatiskt.

Metod 3: Global konfigurationsfil

Skapa ~/.cursor/mcp.json för servrar du vill ha tillgängliga i alla projekt:

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

Efter att du har lagt till en server, gå tillbaka till Cursor Settings > Tools & MCP. Du bör se din server listad med en grön indikator som visar att den är ansluten. Verktygen den tillhandahåller kommer att visas under "Available Tools".

---

Topp 10 MCP-servrar för Cursor

Dessa är de mest användbara MCP-servrarna för dagligt utvecklingsarbete, baserat på verklig användningsdata och community-adoption.

1. Filesystem

Läs, skriv, sök och hantera filer på din lokala maskin. Ger agenten direkt tillgång till projektfiler utöver vad Cursor tillhandahåller nativt.

{
  "filesystem": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/directory"]
  }
}

2. GitHub

Hantera repositorier, issues, pull requests och kodsökning direkt från agenten. Den officiella GitHub MCP-servern stöder alla kärnfunktioner i GitHub.

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

3. PostgreSQL / SQLite (Databas)

Låt agenten köra frågor mot din databas, inspektera scheman och analysera data utan att lämna Cursor.

{
  "sqlite": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-sqlite", "/path/to/database.db"]
  }
}

För PostgreSQL:

{
  "postgres": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-postgres"],
    "env": {
      "DATABASE_URL": "postgresql://user:pass@localhost:5432/mydb"
    }
  }
}

4. Brave Search (Webbsökning)

Ge agenten förmågan att söka på den levande webben. Använder Braves oberoende sökindex utan spårning.

{
  "brave-search": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-brave-search"],
    "env": {
      "BRAVE_API_KEY": "your_brave_api_key"
    }
  }
}

5. Playwright (Webbläsarautomatisering)

Agenten kan navigera på webbplatser, fylla i formulär, ta skärmdumpar och skrapa innehåll med en riktig webbläsare.

{
  "playwright": {
    "command": "npx",
    "args": ["-y", "@executeautomation/playwright-mcp-server"]
  }
}

6. Slack

Läs kanaler, posta meddelanden, sök i konversationshistorik. Användbart för agenter som behöver hämta kontext från teamdiskussioner.

{
  "slack": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-slack"],
    "env": {
      "SLACK_BOT_TOKEN": "xoxb-your-token",
      "SLACK_TEAM_ID": "T0123456789"
    }
  }
}

7. Memory (Bestående kunskap)

Ger agenten ett bestående minne över sessioner. Den kan lagra och återkalla fakta, beslut och kontext som annars skulle gå förlorade när du stänger en chatt.

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

8. Context7 (Dokumentationssökning)

Injicerar versionsspecifik dokumentation direkt i agentens kontext. Särskilt användbart när du arbetar med ramverk där AI:ns träningsdata kan vara föråldrad.

{
  "context7": {
    "command": "npx",
    "args": ["-y", "@upstash/context7-mcp"]
  }
}

9. Docker

Hantera containers, images och compose-stackar. Agenten kan starta tjänster, kontrollera loggar och felsöka containerproblem.

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

10. Sequential Thinking

Inte en verktygskoppling utan en resonemangsförstärkare. Den strukturerar agentens tankeprocess för komplexa problem i flera steg genom att dela upp dem i sekventiella resonemangssteg.

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

---

Avancerad konfiguration

Miljövariabler

MCP-servrar behöver ofta API-nycklar och inloggningsuppgifter. Skicka dem via env-fältet i din konfiguration:

{
  "mcpServers": {
    "my-server": {
      "command": "npx",
      "args": ["-y", "my-mcp-server"],
      "env": {
        "API_KEY": "sk-xxxxxxxxxxxx",
        "API_URL": "https://api.example.com"
      }
    }
  }
}

Checka aldrig in API-nycklar i versionshantering. För konfigurationer på projektnivå som delas med ett team, använd platshållarvärden och dokumentera de nödvändiga miljövariablerna separat.

Bygga en anpassad MCP-server

Om ingen befintlig server passar dina behov kan du bygga en. MCP SDK finns tillgängligt i TypeScript, Python och flera andra språk:

npm install @modelcontextprotocol/sdk

En minimal anpassad server i 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);

Projektnivå vs. Global konfiguration

Använd projektnivå (.cursor/mcp.json) för:

• Databasanslutningar specifika för ett projekt
• Interna API-servrar
• Projektspecifika verktyg som teammedlemmar behöver

Använd global (~/.cursor/mcp.json) för:

• Integrationer med GitHub, GitLab eller andra kodvärdar
• Webbsökning
• Allmänna verktyg som memory eller sequential thinking

När samma servernamn förekommer i båda filerna har konfigurationen på projektnivå prioritet.

---

MCP i Cursor vs. Claude Code vs. Windsurf

MCP är ett öppet protokoll, och alla tre stora AI-kodningsverktyg stöder det nu. Men implementeringarna skiljer sig åt på betydelsefulla sätt.

Funktion	Cursor	Claude Code	Windsurf
MCP-stöd	Ja (v0.42+)	Ja (nativt)	Ja
Transporttyper	stdio, SSE, Streamable HTTP	stdio, Streamable HTTP	stdio, SSE
Konfiguration	.cursor/mcp.json	~/.claude/mcp.json eller projektnivå	.windsurf/mcp.json
Verktygsgräns	Max 40 verktyg	Ingen hård gräns	Varierar
Enklicksinstallation	Ja (utvalda servrar)	Begränsad	Ja
OAuth-stöd	Ja	Nej (manuella tokens)	Ja
Företagskontroller	Grundläggande	N/A (CLI-verktyg)	Kontroller på adminnivå
IDE-låsning	Endast Cursor (VS Code-fork)	Fungerar i valfri terminal / VS Code-tillägg	40+ IDE-plugins

Cursor är enklast att konfigurera tack vare dess enklicksinstallation av servrar och inställnings-UI. Dess begränsning är taket på 40 verktyg och att det är låst till Cursor-editorn.

Claude Code körs i terminalen och som ett VS Code-tillägg. Det har den djupaste MCP-integrationen eftersom Anthropic skapade både Claude och MCP. Ingen verktygsgräns, men konfigurationen är mer manuell.

Windsurf erbjuder den bredaste IDE-kompatibiliteten och de starkaste företagskontrollerna. Om ditt team behöver admin-hanterade MCP-konfigurationer har Windsurf ett försprång.

Den goda nyheten: eftersom MCP är ett öppet protokoll är själva servrarna utbytbara. En server du konfigurerar för Cursor fungerar i Claude Code och Windsurf med endast en ändring i konfigurationsfilen.

---

Felsökning av vanliga problem

Servern visar "Not Connected" i inställningarna

• Kontrollera att Node.js v18+ är installerat: node --version
• Verifiera att npx-kommandot fungerar utanför Cursor: kör kommandot direkt i din terminal
• Titta i Cursors utvecklarkonsol (Help > Toggle Developer Tools) efter felmeddelanden
• Starta om Cursor efter att du lagt till eller ändrat serverkonfigurationer

Verktyg visas inte i agentens tillgängliga verktyg

• Bekräfta att serverns gröna statusindikator visas i Settings > Tools & MCP
• Kontrollera att du inte har överskridit gränsen på 40 verktyg totalt över alla servrar
• Prova att ta bort och lägga till servern igen

Servern kraschar eller gör timeout

• Vissa servrar behöver specifika miljövariabler. Kontrollera serverns README för nödvändig konfiguration
• Öka minnesallokeringen om servern hanterar stora datamängder
• För stdio-servrar, se till att ingen annan process konkurrerar om samma stdin/stdout

Autentiseringsfel

• Dubbelkolla API-nycklar och tokens i env-konfigurationen
• För GitHub, se till att din personal access token har de nödvändiga behörigheterna (vanligtvis repo, read:org)
• För OAuth-baserade servrar, försök att autentisera igen via Cursors inställnings-UI

Konfigurationen laddas inte

• För konfigurationer på projektnivå, verifiera att filen ligger på .cursor/mcp.json (inte .cursor/mcp/config.json eller andra varianter)
• Validera JSON-syntaxen -- ett enda felplacerat kommatecken kommer att förstöra hela filen
• Starta om Cursor efter varje konfigurationsändring

---

Slutsats

MCP-servrar förvandlar Cursor från en smart textredigerare till en AI-driven utvecklingsmiljö som faktiskt kan interagera med dina verktyg och din infrastruktur. Konfigurationen tar fem minuter för din första server, och produktivitetsvinsten är omedelbar.

Börja med två eller tre servrar som matchar ditt dagliga arbetsflöde -- filesystem, GitHub och en databaskoppling täcker de flesta utvecklare. Lägg till fler när du upptäcker specifika behov. Och kom ihåg att varje MCP-server du konfigurerar i Cursor är portabel: om du byter till Claude Code eller Windsurf imorgon följer dina servrar med dig.

MCP-ekosystemet växer snabbt. Med över 5,000 servrar tillgängliga och ett protokoll som nu stöds av alla stora AI-kodningsverktyg, är MCP inte längre ett experiment. Det är standarden för hur AI-verktyg ansluter till omvärlden -- och Cursor är en av de bästa platserna att börja använda det på.