MCP (Model Context Protocol): Den Kompletta Guiden för Utvecklare

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.

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

Varför MCP Finns

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

Detta skapade ett N×M-problem: N AI-applikationer som var och en behövde M anpassade integrationer, vilket ledde till dubbelarbete och fragmenterade ekosystem.

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

Grundläggande Koncept

MCP har tre fundamentala primitiver:

1. Verktyg (Tools)

Verktyg ä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.

{
  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. Resurser (Resources)

Resurser är data som AI:n kan läsa. De representerar filer, databasregister, API-svar eller andra datakällor. Resurser identifieras med URI:er.

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

3. Prompts

Prompts ä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.

{
  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öljer en klient-server-arkitektur:

• Värd: AI-applikationen (Claude Desktop, Cursor, din egen app)
• Klient: Upprätthåller en 1:1-anslutning med en MCP-server
• Server: Exponerar verktyg, resurser och prompts till klienten
• Transport: Kommunikation sker via JSON-RPC 2.0 över stdio (lokalt) eller Server-Sent Events (fjärr)

Bygga en MCP-Server

Låt oss bygga en praktisk MCP-server som interagerar med en att-göra-lista lagrad i en JSON-fil.

Installation

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

Serverimplementation

// 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

För att använda denna server med Claude Desktop, lägg till den i din konfiguration:

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

Bygga en MCP-Klient

Du kan också bygga en anpassad klient som ansluter till vilken MCP-server som helst:

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ära MCP-Servrar

MCP-ekosystemet har vuxit snabbt. Här är några av de mest populära servrarna:

MCP vs A2A (Agent-to-Agent)

Medan MCP hanterar agent-till-verktyg-kommunikation, hanterar Googles A2A (Agent-to-Agent)-protokoll agent-till-agent-kommunikation. De kompletterar varandra:

• MCP: Hur en AI-agent använder verktyg (vertikal integration)
• A2A: Hur AI-agenter samarbetar med varandra (horisontell integration)

Bästa Praxis

1. Håll servrar fokuserade: En server per domän (GitHub-server, Slack-server, etc.). Bygg inte monolitiska servrar.
2. Validera indata med Zod: Validera alltid verktygsindata med korrekta scheman.
3. Hantera fel elegant: Returnera meningsfulla felmeddelanden, inte stack traces.
4. 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.
5. 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.
6. Testa med MCP Inspector: Använd npx @modelcontextprotocol/inspector för att testa din server interaktivt.

Kom Igång

# 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

Sammanfattning

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

Nästa steg:

• Utforska MCP-specifikationen
• Bläddra bland befintliga MCP-servrar för inspiration
• Bygg din första server med TypeScript eller Python SDK
• Testa den med Claude Desktop eller MCP Inspector