1~
2**Model Context Protocol (MCP)** er en åben standard skabt af Anthropic, der definerer hvordan AI-modeller kommunikerer med eksterne værktøjer, datakilder og tjenester. Tænk på det som "AI's USB-C"  -  et universelt stik der lader enhver AI-agent tale med ethvert værktøj gennem en standardiseret grænseflade.
3~
4Siden lanceringen har MCP krydset **97 millioner månedlige SDK-downloads** og er blevet adopteret af alle store AI-udbydere: Anthropic, OpenAI, Google, Microsoft og Amazon. I denne guide udforsker vi alt, du har brug for at vide for at bygge med MCP.
5~
6## Hvorfor MCP Eksisterer
7~
8Før MCP skulle hver AI-applikation bygge brugerdefinerede integrationer for hvert værktøj, den ville bruge. Vil du have din AI til at læse filer? Skriv brugerdefineret kode. Forespørge en database? Mere brugerdefineret kode. Poste på Slack? Endnu en integration.
9~
10Dette skabte et **N×M-problem**: N AI-applikationer der hver havde brug for M brugerdefinerede integrationer, hvilket førte til dobbeltarbejde og fragmenterede økosystemer.
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 dette med **en enkelt protokol** som enhver AI-klient kan bruge til at kommunikere med enhver MCP-server:
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æggende Koncepter
38~
39MCP har tre fundamentale primitiver:
40~
41### 1. Værktøjer (Tools)
42Værktøjer er funktioner som AI'en kan kalde. De repræsenterer handlinger som "opret en fil", "forespørg en database" eller "send en besked". Hvert værktøj har et navn, en beskrivelse og et JSON Schema for sine parametre.
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. Ressourcer (Resources)
61Ressourcer er data som AI'en kan læse. De repræsenterer filer, databaseposter, API-svar eller andre datakilder. Ressourcer identificeres 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 er genbrugelige skabeloner der hjælper med at strukturere interaktioner. De kan inkludere dynamiske parametre og er nyttige til at standardisere almindelige arbejdsgange.
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ølger 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ært**: AI-applikationen (Claude Desktop, Cursor, din egen app)
105- **Klient**: Opretholder en 1:1 forbindelse med en MCP-server
106- **Server**: Eksponerer værktøjer, ressourcer og prompts til klienten
107- **Transport**: Kommunikation sker via JSON-RPC 2.0 over stdio (lokalt) eller Server-Sent Events (fjern)
108~
109## Bygning af en MCP-Server
110~
111Lad os bygge en praktisk MCP-server der interagerer med en opgaveliste gemt i en JSON-fil.
112~
113### Opsætning
114~
115```bash
116mkdir mcp-todo-server && cd mcp-todo-server
117npm init -y
118npm install @modelcontextprotocol/sdk zod
119```
120~
121### Server Implementation
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~
209For at bruge denne server med Claude Desktop, tilføj den til 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## Bygning af en MCP-Klient
223~
224Du kan også bygge en brugerdefineret klient der forbinder til enhver MCP-server:
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ære MCP-Servere
251~
252MCP-økosystemet er vokset hurtigt. Her er nogle af de mest populære servere:
253~
254| Server | Beskrivelse | Anvendelse |
255|--------|------------|------------|
256| **GitHub** | Opret issues, PRs, administrer repos | Udviklingsarbejdsgange |
257| **Slack** | Send beskeder, administrer kanaler | Teamkommunikation |
258| **PostgreSQL** | Forespørg og administrer databaser | Datatilgang |
259| **Filesystem** | Læs, skriv og søg filer | Lokal udvikling |
260| **Puppeteer** | Browserautomatisering og scraping | Webtestning |
261| **Sentry** | Fejlovervågning og debugging | Produktionssupport |
262| **Supabase** | Database, auth, lagring | Backend-operationer |
263~
264## MCP vs A2A (Agent-to-Agent)
265~
266Mens MCP håndterer **agent-til-værktøj** kommunikation, håndterer Googles **A2A (Agent-to-Agent)** protokol **agent-til-agent** kommunikation. De er komplementære:
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**: Hvordan en AI-agent bruger værktøjer (vertikal integration)
276- **A2A**: Hvordan AI-agenter samarbejder med hinanden (horisontal integration)
277~
278## Bedste Praksis
279~
2801. **Hold servere fokuserede**: En server per domæne (GitHub-server, Slack-server osv.). Byg ikke monolitiske servere.
2812. **Valider input med Zod**: Valider altid værktøjsinput med korrekte skemaer.
2823. **Håndter fejl elegant**: Returner meningsfulde fejlmeddelelser, ikke stack traces.
2834. **Brug ressourcer til skrivebeskyttede data**: Hvis AI'en kun behøver at læse data, eksponér det som en ressource i stedet for et værktøj.
2845. **Tilføj ordentlige beskrivelser**: Gode værktøjs- og parameterbeskrivelser hjælper AI'en med at forstå hvornår og hvordan hvert værktøj skal bruges.
2856. **Test med MCP Inspector**: Brug `npx @modelcontextprotocol/inspector` til at teste din server interaktivt.
286~
287## Kom i Gang
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## Konklusion
298~
299MCP er blevet de facto-standarden for AI-værktøjsbrug i 2026. Uanset om du bygger brugerdefinerede AI-agenter, udvider Claude Code eller opretter integrationer til eksisterende platforme, er forståelse af MCP essentiel. Protokollen er enkel nok til at lære på en eftermiddag, men kraftfuld nok til at bygge produktionsklare AI-arbejdsgange.
300~
301**Næste skridt:**
302- Udforsk [MCP-specifikationen](https://spec.modelcontextprotocol.io/)
303- Gennemse [eksisterende MCP-servere](https://github.com/modelcontextprotocol/servers) for inspiration
304- Byg din første server med TypeScript eller Python SDK
305- Test den med Claude Desktop eller MCP Inspector
306~