Spring til hovedindhold
Dansk— Vælg et sprog
Menu

MCP og Connectors: Tilslutning af eksterne tjenester

Lektion 9 af 25 Opdateret 2. november 2026 Udvikler
På denne side
  1. MCP og Connectors: Tilslutning af eksterne tjenester
  2. Hvad er MCP?
  3. Tilslutning af en MCP-server
  4. Fjerne MCP-servere via SSE
  5. OpenAI Connectors
  6. Kombination af MCP og funktionsværktøjer
  7. Filtrering af MCP-værktøjer
  8. Håndtering af MCP-fejl
  9. Vigtige pointer

Opdateret 2. november 2026 — Agent Builder. Den 3. juni 2026 annoncerede OpenAI lukningen af Agent Builder, planlagt til 30. november 2026; ChatKit forbliver tilgængeligt. Fremover henviser OpenAI brugere til Agents SDK eller agenter i ChatGPT-arbejdsområdet. Siden 10. september 2026 har OpenAI udbudt en offentlig beta af Agents API, der hoster agent-orchestrering (se ChatGPT i 2026, lektion 10).

MCP og Connectors: Tilslutning af eksterne tjenester

Model Context Protocol (MCP) er en åben standard, der lader din agent forbinde til eksterne tjenester på en standardiseret måde. I stedet for at omskrive integrationer for hver enkelt tjeneste, tilslutter du blot en MCP-server, og din agent får øjeblikkeligt adgang til nye værktøjer. Hvor du måske tidligere skulle skrive tre hundrede linjer GitHub-klientkode, behøver du nu kun en enkelt serverdeklaration.

Hvad er MCP?

MCP er en åben standard, der definerer, hvordan en klient – din agent – kommunikerer med en server, altså en ekstern tjeneste. Hver MCP-server eksponerer værktøjer, som din agent kan bruge. Protokollen håndterer transport, serialisering og opdagelse af værktøjer. Denne sidste funktion er den mest værdifulde i det daglige arbejde: agenten spørger serveren, hvad den kan gøre, så du slipper for at vedligeholde en liste. Agents SDK indeholder native MCP-understøttelse og kan forbinde til enhver kompatibel server.

Tilslutning af en MCP-server

SDK’et tilbyder klassen MCPServerStdio til lokale servere, der kommunikerer via stdin/stdout – typisk en Node-proces startet med npx.

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

# Lokal MCP-server (kommunikerer 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)

async with-blokken er ikke blot pynt: den starter serverprocessen, opdager dens værktøjer og lukker den pænt ned, når blokken afsluttes. En agent, der oprettes uden for denne kontekst, vil ikke have nogen værktøjer.

Fjerne MCP-servere via SSE

Til hostede servere bruger du MCPServerSse og SSE-transporten (Server-Sent Events). Logikken er den samme; det er kun URL’en og autentificeringsheadere, der ændres.

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

Ud over MCP tilbyder OpenAI connectors, der administreres direkte på platformen. De integreres i Agent Builder og forbliver brugbare via SDK’et uden at kræve, at du hoster en server.

from agents import Agent, Runner

# Connectors konfigureret i Agent Builder er automatisk tilgængelige
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 er knyttet til agentens konfiguration på platformen
)

Fraværet af en mcp_servers-parameter giver god mening: connectors er knyttet til agentens konfiguration på platformen. De håndterer OAuth-autentificering, paginering og rate limiting for dig – tre områder, der ellers kræver betydelig tid, hvis de håndteres manuelt.

Kombination af MCP og funktionsværktøjer

Du behøver ikke vælge. En enkelt agent kan bruge en MCP-server til dataadgang og dine egne funktioner til forretningslogik, som du ikke ønsker at delegere.

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)

Momsberegningen bliver i din kode, hvor den er testbar og reviderbar; hentning af ordrer sker gennem PostgreSQL MCP-serveren. Det er den opdeling, du bør sigte efter.

Filtrering af MCP-værktøjer

En MCP-server kan eksponere snesevis af værktøjer, hvoraf de fleste ikke er relevante for dit use case – og hver enkelt af dem bruger kontekst og øger risikoen for et upassende kald. Start med at inspicere, hvad der faktisk er tilgængeligt.

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

# Du kan filtrere under forbindelse
async with server:
    tools = await server.list_tools()
    # Inspicer tilgængelige værktøjer
    for tool in tools:
        print(f"- {tool.name}: {tool.description}")

Håndtering af MCP-fejl

En MCP-server er en proces eller en fjernservice: den kan fejle ved start, miste forbindelsen eller have et udløbet token. Planlæg for en degraderet tilstand i stedet for at lade undtagelsen boble op til brugeren.

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 uden 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

Fallback-agenten lader ikke som om, den virker: den meddeler utilgængeligheden. En agent, der opfinder et svar, når dens datakilde er nede, koster langt mere end en, der indrømmer, at den ikke kan fortsætte.

Vigtige pointer

  • MCP er en åben protokol til at forbinde eksterne tjenester til din agent
  • Brug MCPServerStdio til lokale servere og MCPServerSse til fjerne servere
  • OpenAI Connectors er administrerede integrationer på platformen
  • Du kan kombinere funktionsværktøjer og MCP-servere i samme agent
  • Håndtér MCP-forbindelsesfejl med en degraderet tilstand