Spring til hovedindhold
Dansk— Vælg et sprog
Menu

MCP og Connectors: Den universelle standard

Lektion 16 af 20 Udvikler
På denne side
  1. MCP og Connectors: Den universelle standard
  2. Problemet, som MCP løser
  3. MCP-arkitektur
  4. Brug af OpenAI Connectors
  5. Oprettelse af en MCP-server i Python
  6. Eksponering af MCP-ressourcer
  7. Forbindelse af en MCP-server til Responses API
  8. Mønster: Multi-Connector Hub
  9. Sikkerhed og godkendelse
  10. Vigtige pointer

MCP og Connectors: Den universelle standard

Model Context Protocol (MCP) er en åben standard, der giver modeller mulighed for at interagere med eksterne tjenester gennem en samlet protokol. OpenAI Connectors implementerer denne standard for at forbinde modeller direkte til tredjepartsværktøjer inden for Responses API.

Problemet, som MCP løser

Kerneproblemet er multiplikationen af integrationer: At forbinde N modeller med M tjenester kræver N×M tilpassede integrationer, som hver især skal skrives og vedligeholdes separat. Hver ny service tvinger dig til at gentage arbejdet for hver enkelt applikation, og hver API-ændring risikerer at bryde flere integrationer.

MCP omdanner dette produkt til en sum: Tjenesten eksponerer sine funktioner én gang ved hjælp af protokollen, og enhver kompatibel klient kan derefter bruge dem. Det er den samme logik, der ligger bag printerdrivere eller Language Server Protocol (LSP) i kodeeditorer – standardisering gør ikke integrationerne mere kraftfulde; den gør dem økonomisk bæredygtige.

# Før MCP: manuel integration for hver tjeneste
tools = [
    # Funktion til Slack
    {"type": "function", "name": "slack_send_message", ...},
    {"type": "function", "name": "slack_read_channel", ...},
    # Funktion til Jira
    {"type": "function", "name": "jira_create_ticket", ...},
    {"type": "function", "name": "jira_list_tickets", ...},
    # Funktion til Google Drive
    {"type": "function", "name": "gdrive_list_files", ...},
    # ... dusinvis af funktioner at vedligeholde
]

Med MCP eksponerer hver tjeneste sine funktioner via en standardprotokol, og modellen bruger dem direkte.

MCP-arkitektur

Protokollen definerer tre begreber:

  • MCP-server: En tjeneste, der eksponerer værktøjer, ressourcer og prompts
  • MCP-klient: Systemet, der bruger serverens funktioner
  • Transport: Kommunikationskanalen mellem klient og server
# En MCP-server eksponerer:
# - Værktøjer: Handlinger, som modellen kan udføre
# - Ressourcer: Data, som modellen kan læse
# - Prompts: Fordefinerede prompt-skabeloner

Brug af OpenAI Connectors

Connectors er MCP-servere, der allerede er hostet og vedligeholdt: Du deklarerer dem, godkender adgangen og bruger dem. Dette er det naturlige udgangspunkt – der er ingen grund til at skrive en MCP-server for at tale med en almindelig tjeneste, som nogen allerede har forbundet.

from openai import OpenAI

client = OpenAI()

# Konceptuelt eksempel: connector til en ekstern tjeneste
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Opret en Jira-billet for fejlen på hjemmesiden",
    tools=[
        {
            "type": "mcp",
            "server_label": "jira",
            "server_url": "https://mcp.your-server.com/jira",
            "require_approval": "always"
        }
    ]
)

Parameteren require_approval styrer menneskelig validering:

  • "always": Hver handling kræver godkendelse
  • "never": Automatisk udførelse

Oprettelse af en MCP-server i Python

Det bliver værd at skrive din egen server, så snart en intern tjeneste skal være tilgængelig for flere applikationer. Logikken er den samme som for en intern API: Du skriver den én gang, rent og med sine egne adgangsregler – og hver applikation drager fordel af det uden at skulle genopfinde integrationslaget.

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øg efter en kunde i det interne CRM.

    Args:
        term: Søgeordet (navn, e-mail eller ID)
        field: Feltet, der skal søges i (name, email, id)
    """
    # Din forretningslogik
    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:
    """Opret en salgsmulighed i CRM'en.

    Args:
        client_id: Kundeidentifikator
        title: Titel på muligheden
        amount: Estimeret beløb i euro
        probability: Sandsynlighed for lukning (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"})

Eksponering af MCP-ressourcer

MCP skelner mellem værktøjer, der gør noget, og ressourcer, der leverer noget at læse. Denne sondring er vigtig, fordi den definerer risikoen: En ressource konsulteres uden bivirkninger, mens et værktøj kan ændre verdens tilstand. Godkendelseskontroller fokuserer naturligt på sidstnævnte.

@server.resource("crm://pipeline")
async def sales_pipeline() -> str:
    """Nuværende status for salgspipelinen."""
    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:
    """Komplet profil for en kunde."""
    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
    })

Forbindelse af en MCP-server til Responses API

# MCP connector-konfiguration i API-kaldet
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Hvad er status for vores salgspipeline? "
          "Opret en mulighed for kunde CLI-789: "
          "cloud-migration, 50000 euro, 70% sandsynlighed.",
    tools=[
        {
            "type": "mcp",
            "server_label": "internal-crm",
            "server_url": "https://mcp.internal.example.com/crm",
            "require_approval": "never"
        }
    ]
)

Mønster: Multi-Connector Hub

Her viser standarden sig virkelig stærk: Flere servere deklareret side om side, hvor modellen komponerer på tværs af dem – læser en billet her, søger efter en kunde der og skriver et svar et andet sted. Uden en fælles protokol ville denne samme flow kræve tre specifikke integrationer og deres løbende vedligeholdelse.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Tjek åbne Jira-billetter, send en opsummering til Slack, "
          "og opdater Notion-dashboardet",
    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"
        }
    ]
)

Sikkerhed og godkendelse

# MCP-servere håndterer godkendelse via headers
# eller tokens i konfigurations-URL'en

# Bedste praksis: Brug altid require_approval til skrivehandlinger
tools = [
    {
        "type": "mcp",
        "server_label": "crm",
        "server_url": "https://mcp.example.com/crm",
        "require_approval": "always",  # Menneskelig validering
        "allowed_tools": ["search_client", "client_profile"],  # Begræns værktøjer
    }
]

Vigtige pointer

  • MCP er en åben standard til at forbinde modeller med eksterne tjenester
  • OpenAI Connectors integrerer MCP direkte i Responses API
  • Byg dine egne MCP-servere for at eksponere interne tjenester
  • Brug require_approval til at styre menneskelig validering
  • Forbind flere MCP-servere i et enkelt kald for tværfaglige arbejdsgange