MCP - Model Context Protocol: guide för svenska AI-team 2026

Vad är Model Context Protocol (MCP)?

Model Context Protocol (MCP) löser ett problem som blev akut när LLM-agenter tog fart 2023–2024: varje leverantör hade sitt eget format för function-calling, och varje agent-ramverk hade sitt eget sätt att beskriva verktyg. Följden var att en integration mot Slack eller Postgres skrevs om från grunden för varje kombination av modell och ramverk.

MCP standardiserar detta lager. En MCP-server exponerar en fast uppsättning tools, resources och prompts. En MCP-klient (agent-runtime) upptäcker dessa via initialize- och list-anrop, och kan sedan anropa dem oavsett vilken modell som driver agenten. Investeringen i en MCP-server överlever därför modellskiften – ni byter från Claude till GPT till Gemini utan att röra integrationslagret.

Protokollet är JSON-RPC 2.0 över tre möjliga transporter: stdio (för lokala servrar som körs som subprocess), HTTP (för remote servrar), och Server-Sent Events (för streaming). Officiella SDK:er finns i Python och TypeScript; community-varianter i Rust, Go och C#.

För bredare orientering: pillarn AI-agenter: Komplett guide för svenska företag 2026 och money-sidan AI-agenter. För multi-agent-mönster som använder MCP: Multi-agent-system: guide för svenska AI-team 2026.

MCP-arkitektur: klient-server-modellen

Sammanfattat

MCP följer klassisk klient-server-modell. Klienten är agent-runtime (Claude Desktop, Claude Agent SDK, LangGraph-app, OpenAI Agents SDK-app) och ansluter till en eller flera MCP-servrar. Kommunikation sker via JSON-RPC 2.0 över stdio (lokal subprocess), HTTP eller SSE. Servern är stateful (håller session-state) men agnostisk mot vilken modell klienten använder. Detta möjliggör tydlig separation of concerns och gör MCP-servrar återanvändbara mellan agenter och ramverk.

MCP-arkitekturen består av tre roller:

• Host. Applikationen som användaren interagerar med – t.ex. Claude Desktop, Cursor, en företagsintern agent-produkt. Hosten håller policy (vilka tools får anropas, med vilken user consent).
• Klient. Runtime-komponenten i hosten som talar MCP-protokollet. En host kan ha flera klienter, en per ansluten server.
• Server. Processen som exponerar tools, resources och prompts. Kan köra lokalt (som subprocess via stdio) eller remote (HTTP/SSE).

Kommunikationsflödet är standardiserat:

1. Klienten initierar med initialize och deklarerar sina capabilities.
2. Servern svarar med sina capabilities och protocolVersion.
3. Klienten anropar tools/list, resources/list och prompts/list för att upptäcka vad servern erbjuder.
4. När agenten (via modellen) vill anropa ett tool skickar klienten tools/call med tool-namn och argument.
5. Servern exekverar och returnerar resultat eller error.

En agent-runtime kan vara ansluten till 3–15 MCP-servrar samtidigt utan att latency blir problematisk. Alice Labs default-setup för svensk enterprise 2026: en klient ansluten till en Fortnox-server, en Visma-server, en Microsoft Graph-server, en intern Postgres-server och en Slack-server.

MCP:s tre primitiver: tools, resources och prompts

Sammanfattat

MCP definierar tre primitiver med olika semantik. Tools är funktioner som agenten anropar och som kan ha side-effects (write, transfer, send email). Resources är read-only datakällor som agenten kan läsa (filer, databaser, API-endpoints). Prompts är parameteriserade mallar som kan användas som utgångspunkt för agent-interaktioner. Skillnaden i side-effect-semantik är kritisk för user consent: tool-anrop kräver explicit approval per anrop, resource-läsning kan auto-godkännas.

Tools är den vanligaste primitiven. En tool är en funktion med typad JSON-schema-input och strukturerad output. Anropas via tools/call. Kan ha side-effects: skriva till en databas, skicka mail, göra en överföring. Klienten ska normalt fråga användaren om consent per anrop av high-risk tools.

Resources är read-only datakällor med URI-adressering (t.ex. file:///data/kunder.json eller postgres://db/orders/42). Anropas via resources/read. Utan side-effects och kan därför auto-godkännas i klienten.

Prompts är parameteriserade mallar som servern erbjuder. En Postgres-server kan t.ex. erbjuda en "analyze_schema"-prompt som tar en tabell som input och returnerar en färdig prompt för agenten att köra. Används för att kapsla in domänkunskap på servern istället för i klienten.

Praktisk regel Alice Labs använder för svensk enterprise: läsning av kundhistorik = resource, skrivning av CRM-anteckning = tool, förslag på standardformulering = prompt.

Tillgängliga MCP-servers 2026: Slack, Postgres, GitHub, Filesystem m.fl.

Sammanfattat

200+ officiella och community-MCP-servers är publicerade 2026. Officiella (Anthropic): Filesystem, Postgres, SQLite, GitHub, Slack, Google Drive, Puppeteer, Fetch, Git, Memory. Community: Linear, Notion, Playwright, Sentry, Stripe, Airtable, Jira, Confluence, Azure DevOps. Merparten är MIT- eller Apache-licensierade och tillgängliga på GitHub. Alice Labs har byggt 30+ svenska specifika servrar (Fortnox, Visma, Björn Lundén, Klarna).

MCP-ekosystemet 2026 delas grovt i tre kategorier:

• Officiella servrar från Anthropic. Filesystem, Postgres, SQLite, GitHub, Slack, Google Drive, Puppeteer, Fetch, Git, Memory. Underhållna i modelcontextprotocol/servers på GitHub, MIT-licens. Produktionsklara för de flesta enterprise-use-cases.
• Officiella från plattforms-leverantörer. Linear, Notion, Playwright (Microsoft), Sentry, Stripe, Airtable, Cloudflare. Underhållna av respektive företag; kvaliteten är genomgående hög.
• Community-servrar. Ett par hundra på GitHub under Awesome-MCP. Kvaliteten varierar; audit code och licens innan produktion.

För svenska team är två luckor uppenbara 2026: Fortnox, Visma och Björn Lundén saknar officiella MCP-servrar. Alice Labs har byggt interna varianter mot dessa API:er och kör dem i produktion hos svensk mid-market. Om ni har liknande behov, kontakta oss – vissa av dessa kan open-sourcas mot gemenskapen.

Så bygger ni egen MCP-server (Python eller TypeScript)

Sammanfattat

Att bygga egen MCP-server tar typiskt 1–3 dagar för ett fokuserat use-case. Med officiella SDK:er (Python: mcp; TypeScript: @modelcontextprotocol/sdk) definieras tools med JSON-schema för input, en handler-funktion för exekvering, och en transport (stdio för lokala; HTTP för remote). Alice Labs default-mönster: en dedikerad server per externt system (Fortnox, Visma, Salesforce) istället för en monolitisk server – gör permissions och versioning enklare.

Att bygga egen MCP-server är påfallande enkelt jämfört med att bygga custom function-calling per modell. Officiella SDK:er finns i Python och TypeScript; båda tar cirka en dag att komma igång med och 2–4 dagar till produktionsklar för ett fokuserat use-case.

Grundstruktur i Python (använder mcp-paketet):

# fortnox_mcp_server.py
from mcp.server import Server
from mcp.types import Tool, TextContent
import httpx

server = Server("fortnox")

@server.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="fortnox_get_invoice",
            description="Hämta en faktura från Fortnox på fakturanummer",
            inputSchema={
                "type": "object",
                "properties": {
                    "invoice_number": {"type": "string"},
                },
                "required": ["invoice_number"],
            },
        ),
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    if name == "fortnox_get_invoice":
        async with httpx.AsyncClient() as client:
            response = await client.get(
                f"https://api.fortnox.se/3/invoices/{arguments['invoice_number']}",
                headers={"Authorization": f"Bearer {FORTNOX_TOKEN}"},
            )
        return [TextContent(type="text", text=response.text)]
    raise ValueError(f"Unknown tool: {name}")

if __name__ == "__main__":
    from mcp.server.stdio import stdio_server
    import asyncio
    asyncio.run(stdio_server(server))

Alice Labs default-mönster: en server per externt system istället för en monolitisk server. Skäl: permissions kan sättas per server, versioning är enklare, och en trasig server drar inte ner de andra. Undantag: mycket små interna verktyg samlas i en gemensam "internal-tools"-server.

För djupare implementation, se officiella MCP quickstart för servers. För integration med LangGraph: LangGraph guide för svenska team 2026.

Säkerhets-implikationer: permissions, sandboxing, prompt-injection

Sammanfattat

MCP:s säkerhetsmodell bygger på minsta-privilegium: varje server exponerar endast nödvändiga tools och resources, med explicit user consent per high-risk tool-call i klient-runtime. Fyra praktiska säkerhetsimplikationer 2026: (1) OAuth eller token-scoping per server, (2) sandboxing av lokala stdio-servrar, (3) prompt-injection-filtrering på tool-descriptions, (4) audit-loggning per tool-anrop för EU AI Act Artikel 12. Anthropic publicerade ett security best practices-dokument 2026.

MCP:s säkerhetsmodell är korrekt designad men kräver disciplin i implementationen. Fyra praktiska principer Alice Labs använder för svensk enterprise 2026:

1. OAuth eller token-scoping per server. En Fortnox-MCP-server ska inte ha admin-token för hela kontot – bara scoped-token för de endpoints tools faktiskt behöver. Rotera automatiskt.
2. Sandboxing av lokala stdio-servrar. När MCP-servrar körs som subprocess med filesystem-access, kör dem i en container eller Firecracker-VM med read-only-mount av bara det som behövs.
3. Prompt-injection-filtrering på tool-descriptions. Nyare attack: en manipulerad tool-description kan innehålla injection-instruktioner som modellen läser. Sanitera beskrivningar från tredjeparts-servrar innan de exponeras till agenten.
4. Audit-loggning per tool-anrop. Under EU AI Act Artikel 12 (loggning) och Artikel 15 (cybersäkerhet) måste varje tool-anrop loggas med tillräcklig granularitet för spårbarhet: vem, vilken agent, vilken server, vilket tool, vilka argument, vilket resultat.

Se Anthropics MCP security best practices för fullständig checklista. För bredare EU AI Act-genomgång: EU AI Act 2026: checklista för svenska företag.

MCP vs custom function-calling: när vinner MCP?

Sammanfattat

MCP vinner när ni bygger fler än ett verktyg som ska återanvändas mellan flera agenter eller modellskiften. Custom function-calling vinner när ni har extremt tight latens-krav (in-process anrop), när verktyget bara används av en enda agent, eller när ni är låsta i en leverantörsstack utan MCP-stöd. För 90 procent av enterprise-use-cases 2026 vinner MCP på återanvändbarhet, ramverks-portabilitet och overhead-vinst över tid.

Beslutsmatris Alice Labs använder 2026:

• Bygg MCP-server när: Verktyget kommer användas av mer än en agent, ni vill kunna byta modell utan att röra integrationen, verktyget är generellt (Slack, Postgres, GitHub), eller ni bygger en produkt som andra team ska konsumera.
• Bygg custom function-calling när: Extremt tight latency-krav (sub-10ms per anrop), verktyget är strikt privat till en agent, eller ni är låsta i en stack utan MCP-stöd (mycket sällsynt 2026).

Overhead-jämförelse: en MCP-server har typiskt 10–50 ms extra latency per tool-call jämfört med in-process function-calling (stdio-transport) eller 30–150 ms (HTTP). För enterprise-agenter där själva LLM-anropet tar 500–5000 ms är detta försumbart. För real-time-agenter med sub-second-krav kan det spela roll.

Kostnadsvinst över 12 månader: Alice Labs beräkning från 30+ svenska MCP-servrar visar 30–60 procent besparing på integrationstid jämfört med custom-approach, eftersom samma server återanvänds över modellskiften och nya agenter.

MCP-adoption 2026: Anthropic, OpenAI, Google, Microsoft

Sammanfattat

MCP-adoption 2026 är bred över hela LLM-branschen. Anthropic (native): Claude Desktop, Claude Agent SDK, Claude Code, alla Anthropic-produkter. OpenAI: Agents SDK stöder MCP-servrar sedan Q1 2026. Google DeepMind: Vertex AI Agent Builder adopterade MCP Q2 2026. Microsoft: Semantic Kernel och Copilot Studio har MCP-connector-stöd. Merparten av större agent-ramverk (LangGraph, CrewAI, AutoGen) har MCP-adapters. MCP är otvetydigt de facto-standard 2026.

Adoption-status per leverantör Q3 2026:

Slutsatsen är entydig 2026: bygg MCP-servrar från dag 1. Investeringen fungerar i alla större agent-stackar och överlever modellskiften. Se relaterad protokoll-genomgång i vår engelska guide: MCP vs A2A Comparison 2026.

Toolchain för svenska team: Fortnox, Visma, Microsoft 365, Salesforce

Sammanfattat

Rekommenderad MCP-toolchain för svenska team 2026: officiella servers för Slack, GitHub, Postgres, Google Drive, Filesystem. Community-servers för Linear, Notion, Playwright. Alice Labs-interna servrar för Fortnox, Visma, Björn Lundén, Microsoft Graph (för Microsoft 365) och Salesforce. All hosting i EU-region (AWS Frankfurt eller Azure Sweden Central) med OAuth-scoped tokens och audit-loggning för EU AI Act Artikel 12.

Alice Labs default-toolchain för svensk enterprise 2026:

• Officiella servers. Postgres (för intern databas), Filesystem (kontrollerad), GitHub (kod), Slack (intern kommunikation), Google Drive (om relevant), Fetch (webbsökning).
• Community-servers med audit. Linear eller Jira (ärendehantering), Notion (dokumentation), Playwright (browser-automation), Sentry (fel-monitoring).
• Alice Labs-interna servers. Fortnox (ekonomi), Visma (löner och ekonomi), Björn Lundén (bokföring), Microsoft Graph (Microsoft 365), Salesforce (CRM), Zendesk (support), 46elks (svensk telefoni).
• Hosting. Alla remote-servrar körs på AWS Frankfurt eller Azure Sweden Central. Lokala stdio-servrar körs i sandboxade Docker-containrar med read-only-mounts.
• Governance. OAuth-scoped tokens per server, audit-loggning per tool-anrop till immutable log store, per-team-permissions via enterprise-provisioning.

Om ni redan är Microsoft 365-hus, se även vår genomgång i pillarn för svensk enterprise: AI-agenter: Komplett guide för svenska företag 2026 och listan över de bästa AI-agent-ramverken: Bästa AI-agent-ramverken 2026.

Alice Labs learnings från 30+ MCP-servrar i produktion

Sammanfattat

Fem learnings från Alice Labs 30+ MCP-servrar i nordisk produktion 2024–2026: (1) en server per externt system, inte monolitisk; (2) audit-log varje tool-anrop från dag 1; (3) OAuth-scoped tokens per server; (4) prompt-injection-sanitisering på alla tool-descriptions från tredjepart; (5) sandboxa lokala stdio-servrar. Genomsnittlig tid att bygga en produktionsklar server: 2–4 dagar. Genomsnittlig kostnadsbesparing vs custom function-calling: 30–60 procent över 12 månader.

Fem konkreta learnings från Alice Labs 30+ MCP-servrar i svensk och nordisk produktion 2024–2026:

1. En server per externt system. Inte en monolitisk "internal-tools" med 40 disparata tools. Servers per system gör permissions, versioning och felsökning enklare.
2. Audit-log varje tool-anrop från dag 1. Inte "vi lägger till det senare". Under EU AI Act Artikel 12 blir det ett produktionsblocker om ni inte har det.
3. OAuth-scoped tokens per server. Aldrig admin-tokens. Rotera automatiskt. Använd secrets-manager (AWS Secrets Manager, Azure Key Vault) och injicera vid start.
4. Prompt-injection-sanitisering på tool-descriptions. När ni använder tredjeparts-servrar (community), sanitera deras tool-descriptions innan de exponeras till agenten. Nyare attack-yta som fångar oförberedda team.
5. Sandboxa lokala stdio-servrar. Ingen filesystem-server ska ha read-write-access till hela hem-katalogen. Kör i container med read-only-mount av exakt de sökvägar som behövs.

Fördjupning i orkestreringen som konsumerar MCP: LangGraph guide för svenska team 2026. Multi-agent-mönster med MCP-baserade sub-agents: Multi-agent-system: guide för svenska AI-team 2026.