MCP (Model Context Protocol): Den Komplette Guide for Udviklere

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.

Siden 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.

Hvorfor MCP Eksisterer

Fø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.

Dette skabte et N×M-problem: N AI-applikationer der hver havde brug for M brugerdefinerede integrationer, hvilket førte til dobbeltarbejde og fragmenterede økosystemer.

MCP løser dette med en enkelt protokol som enhver AI-klient kan bruge til at kommunikere med enhver MCP-server:

Grundlæggende Koncepter

MCP har tre fundamentale primitiver:

1. Værktøjer (Tools)

Væ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.

{
  name: "create_issue",
  description: "Create a new GitHub issue",
  inputSchema: {
    type: "object",
    properties: {
      title: { type: "string", description: "Issue title" },
      body: { type: "string", description: "Issue body" },
      repo: { type: "string", description: "Repository name" }
    },
    required: ["title", "repo"]
  }
}

2. Ressourcer (Resources)

Ressourcer er data som AI'en kan læse. De repræsenterer filer, databaseposter, API-svar eller andre datakilder. Ressourcer identificeres med URI'er.

{
  uri: "file:///Users/dev/project/README.md",
  name: "Project README",
  mimeType: "text/markdown"
}

3. Prompts

Prompts er genbrugelige skabeloner der hjælper med at strukturere interaktioner. De kan inkludere dynamiske parametre og er nyttige til at standardisere almindelige arbejdsgange.

{
  name: "code_review",
  description: "Review code changes for quality and security",
  arguments: [
    { name: "diff", description: "The code diff to review", required: true }
  ]
}

Arkitektur

MCP følger en klient-server arkitektur:

• Vært: AI-applikationen (Claude Desktop, Cursor, din egen app)
• Klient: Opretholder en 1:1 forbindelse med en MCP-server
• Server: Eksponerer værktøjer, ressourcer og prompts til klienten
• Transport: Kommunikation sker via JSON-RPC 2.0 over stdio (lokalt) eller Server-Sent Events (fjern)

Bygning af en MCP-Server

Lad os bygge en praktisk MCP-server der interagerer med en opgaveliste gemt i en JSON-fil.

Opsætning

mkdir mcp-todo-server && cd mcp-todo-server
npm init -y
npm install @modelcontextprotocol/sdk zod

Server Implementation

// src/index.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import fs from "fs";

const TODO_FILE = "./todos.json";

function readTodos(): { id: number; text: string; done: boolean }[] {
  if (!fs.existsSync(TODO_FILE)) return [];
  return JSON.parse(fs.readFileSync(TODO_FILE, "utf-8"));
}

function writeTodos(todos: { id: number; text: string; done: boolean }[]) {
  fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2));
}

const server = new McpServer({
  name: "todo-server",
  version: "1.0.0",
});

// Tool: Add a todo
server.tool(
  "add_todo",
  "Add a new todo item",
  { text: z.string().describe("The todo text") },
  async ({ text }) => {
    const todos = readTodos();
    const newTodo = { id: Date.now(), text, done: false };
    todos.push(newTodo);
    writeTodos(todos);
    return { content: [{ type: "text", text: `Added: "${text}"` }] };
  }
);

// Tool: List todos
server.tool(
  "list_todos",
  "List all todo items",
  {},
  async () => {
    const todos = readTodos();
    const list = todos
      .map((t) => `${t.done ? "✅" : "⬜"} [${t.id}] ${t.text}`)
      .join("\n");
    return { content: [{ type: "text", text: list || "No todos yet." }] };
  }
);

// Tool: Complete a todo
server.tool(
  "complete_todo",
  "Mark a todo as completed",
  { id: z.number().describe("The todo ID to complete") },
  async ({ id }) => {
    const todos = readTodos();
    const todo = todos.find((t) => t.id === id);
    if (!todo) return { content: [{ type: "text", text: "Todo not found." }] };
    todo.done = true;
    writeTodos(todos);
    return { content: [{ type: "text", text: `Completed: "${todo.text}"` }] };
  }
);

// Resource: Current todos as a readable resource
server.resource(
  "todos://list",
  "Current todo list",
  async () => ({
    contents: [{
      uri: "todos://list",
      mimeType: "application/json",
      text: JSON.stringify(readTodos(), null, 2),
    }],
  })
);

// Start the server
const transport = new StdioServerTransport();
await server.connect(transport);

Konfiguration

For at bruge denne server med Claude Desktop, tilføj den til din konfiguration:

{
  "mcpServers": {
    "todo": {
      "command": "npx",
      "args": ["tsx", "/path/to/mcp-todo-server/src/index.ts"]
    }
  }
}

Bygning af en MCP-Klient

Du kan også bygge en brugerdefineret klient der forbinder til enhver MCP-server:

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const transport = new StdioClientTransport({
  command: "npx",
  args: ["tsx", "./src/index.ts"],
});

const client = new Client({ name: "my-client", version: "1.0.0" });
await client.connect(transport);

// List available tools
const { tools } = await client.listTools();
console.log("Available tools:", tools.map((t) => t.name));

// Call a tool
const result = await client.callTool({
  name: "add_todo",
  arguments: { text: "Write MCP blog post" },
});
console.log(result);

Populære MCP-Servere

MCP-økosystemet er vokset hurtigt. Her er nogle af de mest populære servere:

MCP vs A2A (Agent-to-Agent)

Mens 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:

• MCP: Hvordan en AI-agent bruger værktøjer (vertikal integration)
• A2A: Hvordan AI-agenter samarbejder med hinanden (horisontal integration)

Bedste Praksis

1. Hold servere fokuserede: En server per domæne (GitHub-server, Slack-server osv.). Byg ikke monolitiske servere.
2. Valider input med Zod: Valider altid værktøjsinput med korrekte skemaer.
3. Håndter fejl elegant: Returner meningsfulde fejlmeddelelser, ikke stack traces.
4. 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.
5. 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.
6. Test med MCP Inspector: Brug npx @modelcontextprotocol/inspector til at teste din server interaktivt.

Kom i Gang

# Create a new MCP server from template
npx @modelcontextprotocol/create-server my-server

# Test with the MCP Inspector
npx @modelcontextprotocol/inspector npx tsx ./src/index.ts

Konklusion

MCP 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.

Næste skridt:

• Udforsk MCP-specifikationen
• Gennemse eksisterende MCP-servere for inspiration
• Byg din første server med TypeScript eller Python SDK
• Test den med Claude Desktop eller MCP Inspector