Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

MCP en Connectors: De Universele Standaard

Les 16 van 20 Ontwikkelaar
Op deze pagina
  1. MCP en Connectors: De Universele Standaard
  2. Het Probleem dat MCP Oplost
  3. MCP-architectuur
  4. OpenAI Connectors Gebruiken
  5. Een MCP-server Maken in Python
  6. MCP-bronnen Beschikbaar Stellen
  7. Een MCP-server Verbinden met de Responses API
  8. Patroon: Multi-connector Hub
  9. Beveiliging en Authenticatie
  10. Belangrijkste punten

MCP en Connectors: De Universele Standaard

Het Model Context Protocol (MCP) is een open standaard die modellen in staat stelt om via een uniform protocol te communiceren met externe diensten. OpenAI Connectors implementeren deze standaard om modellen binnen de Responses API direct te koppelen aan tools van derden.

Het Probleem dat MCP Oplost

De kern van het probleem ligt in de exponentiële toename van integraties: het verbinden van N modellen met M diensten vereist N×M maatwerkintegraties, die elk afzonderlijk geschreven en onderhouden moeten worden. Elke nieuwe dienst dwingt u om het werk voor elke applicatie te herhalen, en elke API-wijziging riskeert het breken van meerdere integraties.

MCP verandert dit product in een som: de dienst stelt zijn mogelijkheden één keer bloot via het protocol, en elke compatibele client kan deze gebruiken. Dit is dezelfde logica als achter printerdrivers of het Language Server Protocol (LSP) in code-editors: standaardisering maakt integraties niet krachtiger, maar economisch duurzaam.

# Voor MCP: handmatige integratie voor elke dienst
tools = [
    # Functie voor Slack
    {"type": "function", "name": "slack_send_message", ...},
    {"type": "function", "name": "slack_read_channel", ...},
    # Functie voor Jira
    {"type": "function", "name": "jira_create_ticket", ...},
    {"type": "function", "name": "jira_list_tickets", ...},
    # Functie voor Google Drive
    {"type": "function", "name": "gdrive_list_files", ...},
    # ... tientallen functies om te onderhouden
]

Met MCP stelt elke dienst zijn mogelijkheden bloot via een standaardprotocol, en consumeert het model deze direct.

MCP-architectuur

Het protocol definieert drie concepten:

  • MCP-server: Een dienst die tools, bronnen en prompts beschikbaar stelt
  • MCP-client: Het systeem dat de mogelijkheden van de server gebruikt
  • Transport: Het communicatiekanaal tussen client en server
# Een MCP-server stelt bloot:
# - Tools: Acties die het model kan uitvoeren
# - Resources: Gegevens die het model kan lezen
# - Prompts: Vooraf gedefinieerde prompt-sjablonen

OpenAI Connectors Gebruiken

Connectors zijn MCP-servers die al gehost en onderhouden worden: u declareert ze, authenticeert zich en gebruikt ze. Dit is het natuurlijke startpunt; er is geen behoefte om een MCP-server te schrijven om te communiceren met een veelvoorkomende dienst waarmee iemand anders al een verbinding heeft gelegd.

from openai import OpenAI

client = OpenAI()

# Conceptueel voorbeeld: connector naar een externe dienst
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Maak een Jira-ticket aan voor de bug op de homepage",
    tools=[
        {
            "type": "mcp",
            "server_label": "jira",
            "server_url": "https://mcp.your-server.com/jira",
            "require_approval": "always"
        }
    ]
)

De parameter require_approval stuurt de menselijke validatie aan:

  • "always": Elke actie vereist goedkeuring
  • "never": Automatische uitvoering

Een MCP-server Maken in Python

Het schrijven van uw eigen server wordt de moeite waard zodra een interne dienst bereikbaar moet zijn voor meerdere applicaties. De logica is dezelfde als bij een interne API: u schrijft het één keer, netjes, met eigen toegangsregels, en elke applicatie profiteert zonder de integratielaag opnieuw uit te vinden.

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:
    """Zoek naar een klant in het interne CRM.

    Args:
        term: De zoekterm (naam, e-mail of ID)
        field: Het veld om in te zoeken (name, email, id)
    """
    # Uw bedrijfslogica
    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:
    """Maak een verkoopkans aan in het CRM.

    Args:
        client_id: Klantidentificatie
        title: Titel van de kans
        amount: Geschat bedrag in euro
        probability: Slagingskans (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"})

MCP-bronnen Beschikbaar Stellen

MCP maakt onderscheid tussen tools, die iets doen, en resources, die iets bieden om te lezen. Dit onderscheid is belangrijk omdat het het risico definieert: een resource wordt geraadpleegd zonder neveneffecten, terwijl een tool de staat van de wereld kan wijzigen. Goedkeuringscontroles richten zich van nature op het laatste.

@server.resource("crm://pipeline")
async def sales_pipeline() -> str:
    """Huidige staat van de verkoop-pipeline."""
    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:
    """Volledig profiel van een klant."""
    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
    })

Een MCP-server Verbinden met de Responses API

# MCP-connectorconfiguratie in de API-aanroep
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Wat is de status van onze verkoop-pipeline? "
          "Maak een kans aan voor klant CLI-789: "
          "cloud migratie, 50000 euro, 70% kans.",
    tools=[
        {
            "type": "mcp",
            "server_label": "internal-crm",
            "server_url": "https://mcp.internal.example.com/crm",
            "require_approval": "never"
        }
    ]
)

Patroon: Multi-connector Hub

Hier komt de standaard echt tot zijn recht: meerdere servers naast elkaar gedeclareerd, waarbij het model eroverheen composeert—hier een ticket lezen, daar een klant zoeken, ergens anders een antwoord schrijven. Zonder een gemeenschappelijk protocol zou dezezelfde flow drie specifieke integraties vereisen met hun voortdurende onderhoud.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Controleer open Jira-tickets, stuur een samenvatting naar Slack, "
          "en werk het Notion-dashboard bij",
    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"
        }
    ]
)

Beveiliging en Authenticatie

# MCP-servers handelen authenticatie af via headers
# of tokens in de configuratie-URL

# Best practice: gebruik altijd require_approval voor schrijfacties
tools = [
    {
        "type": "mcp",
        "server_label": "crm",
        "server_url": "https://mcp.example.com/crm",
        "require_approval": "always",  # Menselijke validatie
        "allowed_tools": ["search_client", "client_profile"],  # Beperk tools
    }
]

Belangrijkste punten

  • MCP is een open standaard voor het verbinden van modellen met externe diensten
  • OpenAI Connectors integreren MCP direct in de Responses API
  • Bouw uw eigen MCP-servers om interne diensten beschikbaar te stellen
  • Gebruik require_approval om menselijke validatie te sturen
  • Verbind meerdere MCP-servers in één aanroep voor cross-functionele workflows