Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

MCP en connectors: externe services verbinden

Les 9 van 25 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. MCP en connectors: externe services verbinden
  2. Wat is MCP?
  3. Een MCP-server verbinden
  4. Externe MCP-servers via SSE
  5. OpenAI-connectors
  6. MCP en function tools combineren
  7. MCP-tools filteren
  8. MCP-fouten afhandelen
  9. Belangrijkste punten

Bijgewerkt op 2 november 2026 — Agent Builder. Op 3 juni 2026 kondigde OpenAI de stopzetting van Agent Builder aan, gepland voor 30 november 2026; ChatKit blijft beschikbaar. Vooruitkijkend verwijst OpenAI gebruikers naar de Agents SDK of naar agents in de ChatGPT-werkruimte. Sinds 10 september 2026 biedt OpenAI een openbare bèta van de Agents API aan die agent-orchestratie host (zie ChatGPT in 2026, les 10).

MCP en connectors: externe services verbinden

Het Model Context Protocol (MCP) is een open standaard waarmee uw agent op een gestandaardiseerde manier verbinding maakt met externe services. In plaats van voor elke service integraties opnieuw te schrijven, koppelt u een MCP-server en krijgt uw agent direct nieuwe tools. Waar u eerder driehonderd regels GitHub-clientcode zou hebben geschreven, volstaat nu één serverdeclaratie.

Wat is MCP?

MCP is een open standaard die definieert hoe een client—uw agent—communiceert met een server, oftewel een externe service. Elke MCP-server stelt tools beschikbaar die uw agent kan gebruiken. Het protocol regelt transport, serialisatie en tool-ontdekking. Dit laatste kenmerk is het waardevolst voor dagelijks werk: de agent vraagt de server wat deze kan doen, zodat u geen lijst hoeft bij te houden. De Agents SDK bevat native MCP-ondersteuning en verbindt met elke compatibele server.

Een MCP-server verbinden

De SDK biedt de klasse MCPServerStdio voor lokale servers die communiceren via stdin/stdout—doorgaans een Node-proces gestart met npx.

from agents import Agent, Runner
from agents.mcp import MCPServerStdio

# Lokale MCP-server (communiceert via stdin/stdout)
file_server = MCPServerStdio(
    name="File Manager",
    command="npx",
    args=["-y", "@modelcontextprotocol/server-filesystem", "/path/to/folder"],
)

async def main():
    async with file_server:
        agent = Agent(
            name="File Agent",
            instructions="You manage files for the user.",
            mcp_servers=[file_server],
        )
        result = await Runner.run(agent, "List the files in the root folder.")
        print(result.final_output)

Het async with-blok is niet louter decoratie: het start het serverproces, ontdekt de tools en sluit de server netjes af wanneer het blok eindigt. Een agent die buiten deze context wordt gemaakt, heeft geen tools.

Externe MCP-servers via SSE

Voor gehoste servers gebruikt u MCPServerSse en het SSE-transport (Server-Sent Events). De logica blijft gelijk; alleen de URL en authenticatieheaders veranderen.

from agents.mcp import MCPServerSse

github_server = MCPServerSse(
    name="GitHub",
    url="https://mcp.github.com/sse",
    headers={"Authorization": "Bearer ghp_your_token"},
)

async def main():
    async with github_server:
        agent = Agent(
            name="DevOps Agent",
            instructions="You manage GitHub repositories.",
            mcp_servers=[github_server],
        )
        result = await Runner.run(
            agent,
            "Create an issue in the my-project repo with the title 'Critical Bug'"
        )
        print(result.final_output)

OpenAI-connectors

Naast MCP biedt OpenAI connectors aan die direct op het platform worden beheerd. Deze integreren in Agent Builder en blijven bruikbaar via de SDK zonder dat u zelf een server hoeft te hosten.

from agents import Agent, Runner

# Connectors die in Agent Builder zijn geconfigureerd, zijn automatisch beschikbaar
agent = Agent(
    name="CRM Agent",
    instructions="""You are a CRM assistant. Use the connectors
    to access Salesforce, HubSpot, and Google Workspace.""",
    model="gpt-5.6-terra",
    # Connectors zijn gekoppeld aan de configuratie van de agent op het platform
)

Het ontbreken van een mcp_servers-parameter is logisch: connectors zijn gekoppeld aan de configuratie van de agent op het platform. Zij nemen OAuth-authenticatie, paginatie en rate limiting voor hun rekening—drie gebieden die bij handmatige implementatie veel tijd kosten.

MCP en function tools combineren

U hoeft niet te kiezen. Eén agent kan een MCP-server gebruiken voor data-toegang en uw eigen functies voor bedrijfslogica die u niet wilt delegeren.

from agents import Agent, Runner, function_tool
from agents.mcp import MCPServerStdio

@function_tool
def calculate_invoice(amount_excl_tax: float, vat_rate: float = 20.0) -> str:
    """Calculates the total amount including tax for an invoice."""
    amount_incl_tax = amount_excl_tax * (1 + vat_rate / 100)
    return f"Excl. tax: €{amount_excl_tax}, VAT {vat_rate}%: €{amount_excl_tax * vat_rate / 100:.2f}, Incl. tax: €{amount_incl_tax:.2f}"

db_server = MCPServerStdio(
    name="Database",
    command="npx",
    args=["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:pass@localhost/mydb"],
)

async def main():
    async with db_server:
        agent = Agent(
            name="Accounting Agent",
            instructions="""You handle accounting.
            Use the database for customer data
            and the calculation function for invoices.""",
            tools=[calculate_invoice],
            mcp_servers=[db_server],
        )
        result = await Runner.run(
            agent,
            "Retrieve orders for customer Alice and calculate the total invoice"
        )
        print(result.final_output)

De btw-berekening blijft in uw code, waar deze testbaar en auditbaar is; het ophalen van orders verloopt via de PostgreSQL-MCP-server. Dat is de verdeling die u moet nastreven.

MCP-tools filteren

Een MCP-server kan tientallen tools beschikbaar stellen, waarvan de meeste voor uw use case niet relevant zijn—en elke tool verbruikt context en verhoogt het risico op een ongepaste aanroep. Begin met inspecteren wat er daadwerkelijk beschikbaar is.

server = MCPServerStdio(
    name="GitHub",
    command="npx",
    args=["-y", "@modelcontextprotocol/server-github"],
)

# U kunt tijdens de verbinding filteren
async with server:
    tools = await server.list_tools()
    # Inspecteer beschikbare tools
    for tool in tools:
        print(f"- {tool.name}: {tool.description}")

MCP-fouten afhandelen

Een MCP-server is een proces of een externe service: deze kan niet starten, de verbinding verliezen of een verlopen token hebben. Voorzie een gedegradeerde modus in plaats van de uitzondering tot bij de gebruiker te laten doordringen.

from agents.mcp import MCPServerStdio

async def create_agent_with_mcp():
    server = MCPServerStdio(
        name="External Service",
        command="npx",
        args=["-y", "my-mcp-server"],
    )

    try:
        async with server:
            agent = Agent(
                name="My Agent",
                instructions="Use the external service.",
                mcp_servers=[server],
            )
            result = await Runner.run(agent, "Execute the task.")
            return result.final_output
    except Exception as e:
        # Fallback zonder MCP
        fallback_agent = Agent(
            name="My Agent (degraded mode)",
            instructions="The external service is unavailable. Inform the user.",
        )
        result = await Runner.run(fallback_agent, "The service is unavailable.")
        return result.final_output

De fallback-agent doet niet alsof hij werkt: hij meldt de onbeschikbaarheid. Een agent die een respons verzint wanneer zijn databron niet bereikbaar is, kost veel meer dan een agent die toegeeft niet verder te kunnen.

Belangrijkste punten

  • MCP is een open protocol om externe services met uw agent te verbinden
  • Gebruik MCPServerStdio voor lokale servers en MCPServerSse voor externe servers
  • OpenAI-connectors zijn beheerde integraties op het platform
  • U kunt function tools en MCP-servers in dezelfde agent combineren
  • Handel MCP-verbindingsfouten af met een gedegradeerde modus