Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

MCP och anslutningar: den universella standarden

Lektion 16 av 20 Utvecklare
På denna sida
  1. MCP och anslutningar: den universella standarden
  2. Problemet som MCP löser
  3. MCP-arkitektur
  4. Använda OpenAI Connectors
  5. Skapa en MCP-server i Python
  6. Exponera MCP-resurser
  7. Ansluta en MCP-server till Responses API
  8. Mönster: Hubb för flera anslutningar
  9. Säkerhet och autentisering
  10. Viktiga punkter

MCP och anslutningar: den universella standarden

Model Context Protocol (MCP) är en öppen standard som låter modeller interagera med externa tjänster via ett enhetligt protokoll. OpenAI Connectors implementerar denna standard för att länka modeller direkt till tredjepartsverktyg inom Responses API.

Problemet som MCP löser

Kärnproblemet är multiplikationen av integrationer: att koppla N modeller till M tjänster kräver N×M skräddarsydda integrationer, var och en skriven och underhållen separat. Varje ny tjänst tvingar dig att upprepa arbetet för varje applikation, och varje API-ändring riskerar att bryta flera integrationer.

MCP omvandlar denna produkt till en summa: tjänsten exponerar sina funktioner en gång med hjälp av protokollet, och vilken kompatibel klient som helst kan konsumera dem. Detta är samma logik som bakom skrivardrivrutiner eller Language Server Protocol (LSP) i kodredigerare – standardisering gör inte integrationer kraftfullare; den gör dem ekonomiskt hållbara.

# Före MCP: manuell integration för varje tjänst
tools = [
    # Funktion för Slack
    {"type": "function", "name": "slack_send_message", ...},
    {"type": "function", "name": "slack_read_channel", ...},
    # Funktion för Jira
    {"type": "function", "name": "jira_create_ticket", ...},
    {"type": "function", "name": "jira_list_tickets", ...},
    # Funktion för Google Drive
    {"type": "function", "name": "gdrive_list_files", ...},
    # ... dussintals funktioner att underhålla
]

Med MCP exponerar varje tjänst sina funktioner via ett standardprotokoll, och modellen konsumerar dem direkt.

MCP-arkitektur

Protokollet definierar tre begrepp:

  • MCP-server: En tjänst som exponerar verktyg, resurser och promptar
  • MCP-klient: Systemet som konsumerar serverns funktioner
  • Transport: Kommunikationskanalen mellan klient och server
# En MCP-server exponerar:
# - Verktyg: Åtgärder som modellen kan utföra
# - Resurser: Data som modellen kan läsa
# - Promptar: Fördefinierade prompt-mallar

Använda OpenAI Connectors

Connectors är MCP-servrar som redan är värdar och underhållna: du deklarerar dem, autentiserar och konsumerar. Detta är den naturliga ingångspunkten – det finns inget behov av att skriva en MCP-server för att prata med en vanlig tjänst som någon redan har anslutit.

from openai import OpenAI

client = OpenAI()

# Konceptuellt exempel: anslutning till en extern tjänst
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Skapa en Jira-biljett för buggen på hemsidan",
    tools=[
        {
            "type": "mcp",
            "server_label": "jira",
            "server_url": "https://mcp.your-server.com/jira",
            "require_approval": "always"
        }
    ]
)

Parametern require_approval styr mänsklig validering:

  • "always": Varje åtgärd kräver godkännande
  • "never": Automatisk körning

Skapa en MCP-server i Python

Att skriva din egen server blir lönsamt så snart en intern tjänst behöver vara tillgänglig för flera applikationer. Logiken är densamma som för ett internt API: du skriver det en gång, rent, med egna åtkomstregler – och varje applikation drar nytta utan att behöva uppfinna integrationslagret på nytt.

from mcp.server import Server
from mcp.types import Tool, TextContent
import json

server = Server("my-crm")

@server.tool()
async def search_client(term: str, field: str = "name") -> str:
    """Sök efter en kund i det interna CRM-systemet.

    Args:
        term: Sökterm (namn, e-post eller ID)
        field: Fält att söka i (name, email, id)
    """
    # Din affärslogik
    results = await crm_database.search(term, field=field)
    return json.dumps([{
        "id": r.id,
        "name": r.name,
        "email": r.email,
        "company": r.company
    } for r in results])

@server.tool()
async def create_opportunity(
    client_id: str,
    title: str,
    amount: float,
    probability: int
) -> str:
    """Skapa en försäljningsmöjlighet i CRM-systemet.

    Args:
        client_id: Kundidentifierare
        title: Rubrik för möjligheten
        amount: Uppskattat belopp i euro
        probability: Sannolikhet för avslut (0–100)
    """
    opp = await crm_database.create_opportunity(
        client_id=client_id,
        title=title,
        amount=amount,
        probability=probability
    )
    return json.dumps({"id": opp.id, "status": "created"})

Exponera MCP-resurser

MCP skiljer på verktyg, som gör något, och resurser, som tillhandahåller något att läsa. Denna åtskillnad är viktig eftersom den definierar risk: en resurs konsulteras utan sidoeffekter, medan ett verktyg kan modifiera världens tillstånd. Godkännandekontroller fokuserar naturligt på det senare.

@server.resource("crm://pipeline")
async def sales_pipeline() -> str:
    """Nuvarande tillstånd i försäljningspipelinen."""
    pipeline = await crm_database.get_pipeline()
    return json.dumps({
        "total_opportunities": pipeline.count,
        "total_value": pipeline.total_value,
        "by_stage": {
            "prospecting": pipeline.prospecting,
            "qualification": pipeline.qualification,
            "proposal": pipeline.proposal,
            "negotiation": pipeline.negotiation,
            "closing": pipeline.closing
        }
    })

@server.resource("crm://client/{client_id}")
async def client_profile(client_id: str) -> str:
    """Komplett profil för en kund."""
    client = await crm_database.get_client(client_id)
    return json.dumps({
        "name": client.name,
        "email": client.email,
        "purchase_history": client.purchases,
        "satisfaction_score": client.nps
    })

Ansluta en MCP-server till Responses API

# MCP-anslutningskonfiguration i API-anropet
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Vad är statusen på vår försäljningspipeline? "
          "Skapa en möjlighet för kund CLI-789: "
          "cloud-migrering, 50000 euro, 70 % sannolikhet.",
    tools=[
        {
            "type": "mcp",
            "server_label": "internal-crm",
            "server_url": "https://mcp.internal.example.com/crm",
            "require_approval": "never"
        }
    ]
)

Mönster: Hubb för flera anslutningar

Här visar standarden verkligen sin styrka: flera servrar deklarerade sida vid sida, där modellen komponerar över dem – läser en biljett här, söker efter en kund där, skriver ett svar någon annanstans. Utan ett gemensamt protokoll skulle samma flöde kräva tre specifika integrationer och deras löpande underhåll.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Kontrollera öppna Jira-biljetter, skicka en sammanfattning till Slack, "
          "och uppdatera Notion-dashboarden",
    tools=[
        {
            "type": "mcp",
            "server_label": "jira",
            "server_url": "https://mcp.example.com/jira",
            "require_approval": "always"
        },
        {
            "type": "mcp",
            "server_label": "slack",
            "server_url": "https://mcp.example.com/slack",
            "require_approval": "always"
        },
        {
            "type": "mcp",
            "server_label": "notion",
            "server_url": "https://mcp.example.com/notion",
            "require_approval": "always"
        }
    ]
)

Säkerhet och autentisering

# MCP-servrar hanterar autentisering via headers
# eller tokens i konfigurations-URL:en

# Bästa praxis: använd alltid require_approval för skrivåtgärder
tools = [
    {
        "type": "mcp",
        "server_label": "crm",
        "server_url": "https://mcp.example.com/crm",
        "require_approval": "always",  # Mänsklig validering
        "allowed_tools": ["search_client", "client_profile"],  # Begränsa verktyg
    }
]

Viktiga punkter

  • MCP är en öppen standard för att koppla modeller till externa tjänster
  • OpenAI Connectors integrerar MCP direkt i Responses API
  • Bygg dina egna MCP-servrar för att exponera interna tjänster
  • Använd require_approval för att styra mänsklig validering
  • Anslut flera MCP-servrar i ett enda anrop för tvärfunktionella arbetsflöden