1~
2**Model Context Protocol (MCP)** är en öppen standard skapad av Anthropic som definierar hur AI-modeller kommunicerar med externa verktyg, datakällor och tjänster. Tänk på det som "AI:s USB-C"  -  en universell kontakt som låter vilken AI-agent som helst prata med vilket verktyg som helst genom ett standardiserat gränssnitt.
3~
4Sedan lanseringen har MCP passerat **97 miljoner månatliga SDK-nedladdningar** och har antagits av alla stora AI-leverantörer: Anthropic, OpenAI, Google, Microsoft och Amazon. I denna guide utforskar vi allt du behöver veta för att bygga med MCP.
5~
6## Varför MCP Finns
7~
8Före MCP behövde varje AI-applikation bygga anpassade integrationer för varje verktyg den ville använda. Vill du att din AI ska läsa filer? Skriv anpassad kod. Fråga en databas? Mer anpassad kod. Posta på Slack? Ännu en integration.
9~
10Detta skapade ett **N×M-problem**: N AI-applikationer som var och en behövde M anpassade integrationer, vilket ledde till dubbelarbete och fragmenterade ekosystem.
11~
12```mermaid
13graph TD
14    subgraph "Before MCP (N×M)"
15        A1[AI App 1] --> T1[GitHub Integration]
16        A1 --> T2[Slack Integration]
17        A1 --> T3[DB Integration]
18        A2[AI App 2] --> T4[GitHub Integration]
19        A2 --> T5[Slack Integration]
20        A2 --> T6[DB Integration]
21    end
22```
23~
24MCP löser detta med ett **enda protokoll** som vilken AI-klient som helst kan använda för att kommunicera med vilken MCP-server som helst:
25~
26```mermaid
27graph TD
28    subgraph "With MCP (N+M)"
29        A1[AI App 1] --> MCP[MCP Protocol]
30        A2[AI App 2] --> MCP
31        MCP --> S1[GitHub Server]
32        MCP --> S2[Slack Server]
33        MCP --> S3[DB Server]
34    end
35```
36~
37## Grundläggande Koncept
38~
39MCP har tre fundamentala primitiver:
40~
41### 1. Verktyg (Tools)
42Verktyg är funktioner som AI:n kan anropa. De representerar åtgärder som "skapa en fil", "fråga en databas" eller "skicka ett meddelande". Varje verktyg har ett namn, en beskrivning och ett JSON Schema för sina parametrar.
43~
44```typescript
45{
46  name: "create_issue",
47  description: "Create a new GitHub issue",
48  inputSchema: {
49    type: "object",
50    properties: {
51      title: { type: "string", description: "Issue title" },
52      body: { type: "string", description: "Issue body" },
53      repo: { type: "string", description: "Repository name" }
54    },
55    required: ["title", "repo"]
56  }
57}
58```
59~
60### 2. Resurser (Resources)
61Resurser är data som AI:n kan läsa. De representerar filer, databasregister, API-svar eller andra datakällor. Resurser identifieras med URI:er.
62~
63```typescript
64{
65  uri: "file:///Users/dev/project/README.md",
66  name: "Project README",
67  mimeType: "text/markdown"
68}
69```
70~
71### 3. Prompts
72Prompts är återanvändbara mallar som hjälper till att strukturera interaktioner. De kan inkludera dynamiska parametrar och är användbara för att standardisera vanliga arbetsflöden.
73~
74```typescript
75{
76  name: "code_review",
77  description: "Review code changes for quality and security",
78  arguments: [
79    { name: "diff", description: "The code diff to review", required: true }
80  ]
81}
82```
83~
84## Arkitektur
85~
86MCP följer en klient-server-arkitektur:
87~
88```mermaid
89graph LR
90    subgraph "Host Application"
91        Client[MCP Client]
92    end
93~
94    subgraph "MCP Server"
95        Server[Server Process]
96        Server --> Tools[Tools]
97        Server --> Resources[Resources]
98        Server --> Prompts[Prompts]
99    end
100~
101    Client -- "JSON-RPC 2.0\n(stdio or SSE)" --> Server
102```
103~
104- **Värd**: AI-applikationen (Claude Desktop, Cursor, din egen app)
105- **Klient**: Upprätthåller en 1:1-anslutning med en MCP-server
106- **Server**: Exponerar verktyg, resurser och prompts till klienten
107- **Transport**: Kommunikation sker via JSON-RPC 2.0 över stdio (lokalt) eller Server-Sent Events (fjärr)
108~
109## Bygga en MCP-Server
110~
111Låt oss bygga en praktisk MCP-server som interagerar med en att-göra-lista lagrad i en JSON-fil.
112~
113### Installation
114~
115```bash
116mkdir mcp-todo-server && cd mcp-todo-server
117npm init -y
118npm install @modelcontextprotocol/sdk zod
119```
120~
121### Serverimplementation
122~
123```typescript
124// src/index.ts
125import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
126import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
127import { z } from "zod";
128import fs from "fs";
129~
130const TODO_FILE = "./todos.json";
131~
132function readTodos(): { id: number; text: string; done: boolean }[] {
133  if (!fs.existsSync(TODO_FILE)) return [];
134  return JSON.parse(fs.readFileSync(TODO_FILE, "utf-8"));
135}
136~
137function writeTodos(todos: { id: number; text: string; done: boolean }[]) {
138  fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2));
139}
140~
141const server = new McpServer({
142  name: "todo-server",
143  version: "1.0.0",
144});
145~
146// Tool: Add a todo
147server.tool(
148  "add_todo",
149  "Add a new todo item",
150  { text: z.string().describe("The todo text") },
151  async ({ text }) => {
152    const todos = readTodos();
153    const newTodo = { id: Date.now(), text, done: false };
154    todos.push(newTodo);
155    writeTodos(todos);
156    return { content: [{ type: "text", text: `Added: "${text}"` }] };
157  }
158);
159~
160// Tool: List todos
161server.tool(
162  "list_todos",
163  "List all todo items",
164  {},
165  async () => {
166    const todos = readTodos();
167    const list = todos
168      .map((t) => `${t.done ? "✅" : "⬜"} [${t.id}] ${t.text}`)
169      .join("\n");
170    return { content: [{ type: "text", text: list || "No todos yet." }] };
171  }
172);
173~
174// Tool: Complete a todo
175server.tool(
176  "complete_todo",
177  "Mark a todo as completed",
178  { id: z.number().describe("The todo ID to complete") },
179  async ({ id }) => {
180    const todos = readTodos();
181    const todo = todos.find((t) => t.id === id);
182    if (!todo) return { content: [{ type: "text", text: "Todo not found." }] };
183    todo.done = true;
184    writeTodos(todos);
185    return { content: [{ type: "text", text: `Completed: "${todo.text}"` }] };
186  }
187);
188~
189// Resource: Current todos as a readable resource
190server.resource(
191  "todos://list",
192  "Current todo list",
193  async () => ({
194    contents: [{
195      uri: "todos://list",
196      mimeType: "application/json",
197      text: JSON.stringify(readTodos(), null, 2),
198    }],
199  })
200);
201~
202// Start the server
203const transport = new StdioServerTransport();
204await server.connect(transport);
205```
206~
207### Konfiguration
208~
209För att använda denna server med Claude Desktop, lägg till den i din konfiguration:
210~
211```json
212{
213  "mcpServers": {
214    "todo": {
215      "command": "npx",
216      "args": ["tsx", "/path/to/mcp-todo-server/src/index.ts"]
217    }
218  }
219}
220```
221~
222## Bygga en MCP-Klient
223~
224Du kan också bygga en anpassad klient som ansluter till vilken MCP-server som helst:
225~
226```typescript
227import { Client } from "@modelcontextprotocol/sdk/client/index.js";
228import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
229~
230const transport = new StdioClientTransport({
231  command: "npx",
232  args: ["tsx", "./src/index.ts"],
233});
234~
235const client = new Client({ name: "my-client", version: "1.0.0" });
236await client.connect(transport);
237~
238// List available tools
239const { tools } = await client.listTools();
240console.log("Available tools:", tools.map((t) => t.name));
241~
242// Call a tool
243const result = await client.callTool({
244  name: "add_todo",
245  arguments: { text: "Write MCP blog post" },
246});
247console.log(result);
248```
249~
250## Populära MCP-Servrar
251~
252MCP-ekosystemet har vuxit snabbt. Här är några av de mest populära servrarna:
253~
254| Server | Beskrivning | Användningsfall |
255|--------|-------------|----------------|
256| **GitHub** | Skapa issues, PR:er, hantera repos | Utvecklingsarbetsflöden |
257| **Slack** | Skicka meddelanden, hantera kanaler | Teamkommunikation |
258| **PostgreSQL** | Fråga och hantera databaser | Datatillgång |
259| **Filesystem** | Läsa, skriva och söka filer | Lokal utveckling |
260| **Puppeteer** | Webbläsarautomatisering och scraping | Webbtestning |
261| **Sentry** | Felövervakning och felsökning | Produktionssupport |
262| **Supabase** | Databas, autentisering, lagring | Backend-operationer |
263~
264## MCP vs A2A (Agent-to-Agent)
265~
266Medan MCP hanterar **agent-till-verktyg**-kommunikation, hanterar Googles **A2A (Agent-to-Agent)**-protokoll **agent-till-agent**-kommunikation. De kompletterar varandra:
267~
268```mermaid
269graph TD
270    Agent1[Agent 1] -- "A2A Protocol" --> Agent2[Agent 2]
271    Agent1 -- "MCP Protocol" --> Tool1[GitHub MCP Server]
272    Agent2 -- "MCP Protocol" --> Tool2[Database MCP Server]
273```
274~
275- **MCP**: Hur en AI-agent använder verktyg (vertikal integration)
276- **A2A**: Hur AI-agenter samarbetar med varandra (horisontell integration)
277~
278## Bästa Praxis
279~
2801. **Håll servrar fokuserade**: En server per domän (GitHub-server, Slack-server, etc.). Bygg inte monolitiska servrar.
2812. **Validera indata med Zod**: Validera alltid verktygsindata med korrekta scheman.
2823. **Hantera fel elegant**: Returnera meningsfulla felmeddelanden, inte stack traces.
2834. **Använd resurser för skrivskyddad data**: Om AI:n bara behöver läsa data, exponera det som en resurs istället för ett verktyg.
2845. **Lägg till bra beskrivningar**: Bra verktygs- och parameterbeskrivningar hjälper AI:n att förstå när och hur varje verktyg ska användas.
2856. **Testa med MCP Inspector**: Använd `npx @modelcontextprotocol/inspector` för att testa din server interaktivt.
286~
287## Kom Igång
288~
289```bash
290# Create a new MCP server from template
291npx @modelcontextprotocol/create-server my-server
292~
293# Test with the MCP Inspector
294npx @modelcontextprotocol/inspector npx tsx ./src/index.ts
295```
296~
297## Sammanfattning
298~
299MCP har blivit de facto-standarden för AI-verktygssanvändning 2026. Oavsett om du bygger anpassade AI-agenter, utökar Claude Code eller skapar integrationer för befintliga plattformar är det viktigt att förstå MCP. Protokollet är enkelt nog att lära sig på en eftermiddag men kraftfullt nog att bygga produktionsklara AI-arbetsflöden.
300~
301**Nästa steg:**
302- Utforska [MCP-specifikationen](https://spec.modelcontextprotocol.io/)
303- Bläddra bland [befintliga MCP-servrar](https://github.com/modelcontextprotocol/servers) för inspiration
304- Bygg din första server med TypeScript eller Python SDK
305- Testa den med Claude Desktop eller MCP Inspector
306~