MCP-revolutionen: Hur Model Context Protocol förändrar allt

Vad är MCP?

Model Context Protocol är ett öppet protokoll utvecklat av Anthropic som definierar hur AI-modeller kan kommunicera med externa system på ett standardiserat sätt. Tänk på det som USB-C för AI: en universell kontakt som låter samma modell prata med vilken datakälla eller tjänst som helst, utan att behöva bygga unika integrationer för varje fall.

Före MCP var varje AI-integration en custom-byggd lösning. Om du ville att din AI-assistent skulle kunna läsa från din databas behövde du bygga en specifik integration. Om du ville att den skulle kunna skicka Slack-meddelanden behövde du bygga en till. Varje integration hade sitt eget format, sin egen autentisering och sina egna buggar. MCP löser det här genom att definiera ett gemensamt protokoll som alla kan implementera.

Protokollet baseras på JSON-RPC 2.0 och definierar tre huvudkoncept: Tools (funktioner som AI:n kan anropa), Resources (data som AI:n kan läsa), och Prompts (fördefinierade instruktioner). En MCP-server exponerar dessa capabilities, och en MCP-klient (t.ex. Claude Desktop eller Claude Code) konsumerar dem.

Det vackra med MCP är att det är modell-agnostiskt. Även om Anthropic skapade det, kan vilken AI-modell som helst implementera klientsidan. Och serversidan är helt oberoende av vilken modell som använder den. En MCP-server för din databas fungerar lika bra med Claude som med GPT eller Gemini.

Arkitektur

MCP:s arkitektur är medvetet enkel. Det finns två roller: klienten (AI-modellen eller applikationen som använder AI) och servern (den tjänst som exponerar tools, resources och prompts). Kommunikationen sker över antingen stdio (för lokala processer) eller Server-Sent Events (SSE) för nätverk.

  ┌─────────────────────────────────────────────────────────┐
  │                    MCP Host                              │
  │  (Claude Desktop, Claude Code, egna appar)              │
  │                                                         │
  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐    │
  │  │ MCP Client  │  │ MCP Client  │  │ MCP Client  │    │
  │  │ (BigQuery)  │  │ (Slack)     │  │ (GitHub)    │    │
  │  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘    │
  └─────────┼────────────────┼────────────────┼────────────┘
            │ stdio/SSE      │ stdio/SSE      │ stdio/SSE
            │ JSON-RPC       │ JSON-RPC       │ JSON-RPC
  ┌─────────┴──────┐ ┌──────┴───────┐ ┌──────┴──────┐
  │  MCP Server    │ │  MCP Server  │ │  MCP Server │
  │  (BigQuery)    │ │  (Slack)     │ │  (GitHub)   │
  │                │ │              │ │             │
  │  Tools:        │ │  Tools:      │ │  Tools:     │
  │  - run_query   │ │  - send_msg  │ │  - get_pr   │
  │  - get_schema  │ │  - read_ch   │ │  - review   │
  │                │ │              │ │             │
  │  Resources:    │ │  Resources:  │ │  Resources: │
  │  - tables      │ │  - channels  │ │  - repos    │
  └────────────────┘ └──────────────┘ └─────────────┘

Varje MCP-klient hanterar en enda serveranslutning. Om du vill koppla till både BigQuery och Slack skapar hosten två separata klienter. Det isolerar felhantering - om Slack-servern kraschar påverkas inte BigQuery-anslutningen.

Kommunikationsflödet är enkelt: klienten skickar en JSON-RPC request (t.ex. "anropa tool X med dessa parametrar"), servern bearbetar requesten och returnerar ett JSON-RPC response. För tools innebär det ofta att servern kör någon operation mot en extern tjänst och returnerar resultatet. För resources returneras data direkt.

Det som gör MCP kraftfullt är discovery-mekanismen. När en klient ansluter till en server ber den servern att lista alla tillgängliga tools, resources och prompts. Servern returnerar fullständiga JSON Schema-definitioner för varje capability, inklusive parameterbeskrivningar. AI-modellen använder sedan dessa schemas för att förstå vad den kan göra och hur den ska formatera sina anrop.

Implementera en MCP-server

Låt oss bygga en MCP-server från grunden. Vi skapar en server som ger AI:n tillgång till vårt BigQuery-dataset - specifikt möjligheten att lista tabeller, visa schema och köra read-only frågor. Det är exakt den typ av server vi använder i kundprojekt.

Vi använder TypeScript och det officiella MCP SDK:t från Anthropic. Först installerar vi beroendena:

npm init -y
npm install @modelcontextprotocol/sdk @google-cloud/bigquery zod
npm install -D typescript @types/node tsx

Sedan bygger vi själva servern. Den har tre tools: list_tables, get_schema och run_query. Notera hur varje tool har ett fullständigt Zod-schema som definierar dess input:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { BigQuery } from "@google-cloud/bigquery";
import { z } from "zod";

const PROJECT_ID = process.env.GCP_PROJECT ?? "enterprise-data";
const ALLOWED_DATASETS = ["core", "staging", "analytics"];
const bq = new BigQuery({ projectId: PROJECT_ID });

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

// Tool 1: Lista tabeller i ett dataset
server.tool(
  "list_tables",
  "Lista alla tabeller i ett BigQuery-dataset",
  {
    dataset: z.enum(["core", "staging", "analytics"])
      .describe("Datasetet att lista tabeller från"),
  },
  async ({ dataset }) => {
    const [tables] = await bq.dataset(dataset).getTables();
    const tableInfo = tables.map((t) => ({
      name: t.id,
      type: t.metadata.type,
      rows: t.metadata.numRows,
      size: t.metadata.numBytes,
      modified: t.metadata.lastModifiedTime,
    }));
    return {
      content: [
        {
          type: "text" as const,
          text: JSON.stringify(tableInfo, null, 2),
        },
      ],
    };
  }
);

// Tool 2: Visa schema för en tabell
server.tool(
  "get_schema",
  "Hämta schema för en BigQuery-tabell",
  {
    dataset: z.enum(["core", "staging", "analytics"]),
    table: z.string().describe("Tabellnamn"),
  },
  async ({ dataset, table }) => {
    const [metadata] = await bq.dataset(dataset).table(table).getMetadata();
    return {
      content: [
        {
          type: "text" as const,
          text: JSON.stringify(metadata.schema.fields, null, 2),
        },
      ],
    };
  }
);

// Tool 3: Kör en read-only SQL-fråga
server.tool(
  "run_query",
  "Kör en read-only SQL-fråga mot BigQuery (max 1000 rader)",
  {
    sql: z.string().describe("SQL-frågan att köra (måste vara SELECT)"),
    max_rows: z.number().optional().default(100)
      .describe("Max antal rader att returnera"),
  },
  async ({ sql, max_rows }) => {
    // Säkerhetskontroll: bara SELECT
    const normalized = sql.trim().toUpperCase();
    if (!normalized.startsWith("SELECT")) {
      return {
        content: [{
          type: "text" as const,
          text: "Fel: Bara SELECT-frågor är tillåtna.",
        }],
        isError: true,
      };
    }

    const [rows] = await bq.query({
      query: sql,
      maximumBytesBilled: "1000000000", // 1 GB limit
      maxResults: Math.min(max_rows ?? 100, 1000),
    });

    return {
      content: [{
        type: "text" as const,
        text: JSON.stringify(rows, null, 2),
      }],
    };
  }
);

// Starta servern
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("BigQuery MCP server running on stdio");
}

main().catch(console.error);

Servern är medvetet begränsad: den tillåter bara SELECT-frågor, har en 1 GB byte-limit för att förhindra dyra frågor, och begränsar resultaten till max 1000 rader. Det är kritiskt för en produktion - du vill inte att en AI-modell av misstag ska köra en full table scan på en petabyte-tabell.

För att koppla servern till Claude Code lägger vi till den i konfigurationsfilen:

{
  "mcpServers": {
    "bigquery": {
      "command": "npx",
      "args": ["tsx", "/path/to/bigquery-server.ts"],
      "env": {
        "GCP_PROJECT": "enterprise-data",
        "GOOGLE_APPLICATION_CREDENTIALS": "/path/to/sa-key.json"
      }
    }
  }
}

När Claude Code startar ser den automatiskt alla tools från bigquery-servern. Du kan nu säga till Claude "lista alla tabeller i core-datasetet" eller "visa mig de 10 största företagen i core.companies" och den använder MCP-tools för att hämta svaren direkt från BigQuery.

Claude + MCP i praktiken

Vi kör för närvarande 8 MCP-servrar i vår Claude Code-setup i produktion. Varje server ger Claude tillgång till en specifik del av vår infrastruktur. Här är en översikt:

Det som gör kombinationen Claude + MCP så kraftfull är att Claude kan kedja tools från olika servrar i samma konversation. En typisk fråga som "finns det några BigQuery-tabeller som inte har uppdaterats på mer än 24 timmar? Om ja, skapa en Slack-alert i #data-pipeline" använder både BigQuery MCP och Slack MCP i sekvens.

Vi har också sett enorma produktivitetsvinster från MCP i kodgranskningar. Claude Code kan nu läsa hela PR-kontexten från GitHub, kontrollera om ändringarna bryter några BigQuery-schemas, och läsa relevant dokumentation från Notion - allt i en enda konversation utan att utvecklaren behöver byta verktyg.

“MCP är inte bara ett tekniskt protokoll - det är ett paradigmskifte. Istället för att AI:n går på information du klistrar in, går den på information den kan hämta själv. Det är skillnaden mellan att ge någon en karta och att ge någon GPS.”

- Simon Axelsson

En oväntad fördel är att MCP tvingar dig att bygga bra API:er. När du vet att en AI-modell ska använda dina tools börjar du tänka mer på tydliga beskrivningar, bra felmeddelanden, och meningsfulla returvärden. Det höjer kvaliteten på hela systemet.

Praktiska exempel

Låt oss gå igenom tre konkreta scenarion där MCP har förändrat hur vi jobbar. Varje exempel visar ett verkligt arbetsflöde från vår dagliga utveckling.

Alla tre exemplen visar samma mönster: MCP eliminerar kontextbyte. Istället för att hoppa mellan 5 olika verktyg och manuellt klistra in data mellan dem, stannar du i en enda konversation där AI:n har tillgång till allt den behöver. Det är inte bara snabbare - det är fundamentalt annorlunda.

Framtiden för MCP

MCP är fortfarande ungt, men adoptionen accelererar snabbt. Tusentals MCP-servrar finns redan tillgängliga på registret mcp.run, från stora databaser som PostgreSQL och MongoDB till nischade tjänster som Jira och Figma. Ekosystemet växer exponentiellt.

Det finns några trender som vi tror kommer att forma MCP:s framtid. För det första kommer remote MCP-servrar (över SSE/HTTP) att bli standard istället för lokala stdio-servrar. Det öppnar för hosted MCP-tjänster där du kopplar upp din AI mot en molnbaserad server utan att behöva installera något lokalt.

För det andra kommer säkerhet att bli allt viktigare. I dag har MCP-servrar samma tillgång som användaren som kör dem. Vi förutser att det kommer att utvecklas mer granulära behörighetsmodeller, där AI:n får specifika tillstånd för varje tool-anrop, liknande hur mobilappar frågar om tillgång till kamera och mikrofon.

För det tredje tror vi att MCP kommer att bli det dominerande sättet att bygga AI-agenter. Istället för att bygga monolitiska agenter som har all logik inbyggd, kommer agenter att vara tunna klienter som orkestrerar MCP-tools från olika servrar. Det gör agenter enklare att bygga, testa och underhålla.

Om du inte har börjat använda MCP än är nu rätt tid att börja. Börja med att lägga till en eller två MCP-servrar till din Claude-setup - BigQuery och Slack är bra startpunkter. När du vant dig vid arbetsflödet kommer du att undra hur du klarade dig utan det.