Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

MCP és csatlakozók: Külső szolgáltatások összekapcsolása

9. lecke 25 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. MCP és csatlakozók: Külső szolgáltatások összekapcsolása
  2. Mi az az MCP?
  3. MCP szerver csatlakoztatása
  4. Távoli MCP szerverek SSE-n keresztül
  5. OpenAI csatlakozók
  6. MCP és függvényeszközök kombinálása
  7. MCP eszközök szűrése
  8. MCP hibák kezelése
  9. Főbb megállapítások

Frissítve: 2026. november 2. — Agent Builder. 2026. június 3-án az OpenAI bejelentette az Agent Builder leállítását, amelyre 2026. november 30-án kerül sor; a ChatKit továbbra is elérhető marad. A jövőben az OpenAI az Agents SDK-t vagy a ChatGPT munkaterületi ügynökeit ajánlja a felhasználóknak. 2026. szeptember 10. óta az OpenAI nyilvános béta verziójú Agents API-t kínál, amely az ügynök-orchestrációt hosztolja (lásd: ChatGPT 2026-ban, 10. lecke).

MCP és csatlakozók: Külső szolgáltatások összekapcsolása

A Model Context Protocol (MCP) egy nyílt szabvány, amely lehetővé teszi, hogy az ügynököd szabványosított módon kapcsolódjon külső szolgáltatásokhoz. Ahelyett, hogy minden egyes szolgáltatáshoz újraírnád az integrációkat, csupán csatlakoztatsz egy MCP szervert, és az ügynököd azonnal új eszközökkel gyarapodik. Ahol korábban háromszáz sor GitHub klienskódot írtál volna, most már csak egyetlen szerverdeklarációra van szükséged.

Mi az az MCP?

Az MCP egy nyílt szabvány, amely meghatározza, hogyan kommunikál egy kliens – a te ügynököd – egy szerverrel, azaz egy külső szolgáltatással. Minden MCP szerver olyan eszközöket tesz közzé, amelyeket az ügynököd használhat. A protokoll kezeli a szállítást, a szerializációt és az eszközök felfedezését. Ez utóbbi funkció a legértékesebb a napi munkában: az ügynök lekérdezi a szervert, hogy megtudja, mire képes, így neked nem kell karbantartanod egy listát. Az Agents SDK natív MCP-támogatást tartalmaz, és bármely kompatibilis szerverhez képes csatlakozni.

MCP szerver csatlakoztatása

Az SDK biztosítja az MCPServerStdio osztályt azokhoz a helyi szerverekhez, amelyek stdin/stdout keresztül kommunikálnak – ez jellemzően egy npx parancsokkal indított Node folyamat.

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

# Helyi MCP szerver (stdin/stdout kommunikáció)
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)

Az async with blokk nem csupán dekoráció: ez indítja el a szerverfolyamatot, fedezi fel az eszközeit, és zárja le tisztán a folyamatot, amikor a blokk véget ér. Egy ezen a kontextuson kívül létrehozott ügynöknek nem lesznek eszközei.

Távoli MCP szerverek SSE-n keresztül

Hosztolt szerverek esetén használd az MCPServerSse osztályt és az SSE (Server-Sent Events) szállítási réteget. A logika ugyanaz marad; csak az URL és a hitelesítési fejlécek változnak.

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 csatlakozók

Az MCP mellett az OpenAI közvetlenül a platformon kezelt csatlakozókat (connectors) is kínál. Ezek integrálódnak az Agent Builderbe, és az SDK-n keresztül is használhatók maradnak anélkül, hogy saját szervert kellene hosztolnod.

from agents import Agent, Runner

# Az Agent Builderben konfigurált csatlakozók automatikusan elérhetők
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",
    # A csatlakozók a platformon lévő ügynökkonfigurációhoz vannak kötve
)

Az mcp_servers paraméter hiánya logikus: a csatlakozók az ügynök platformon lévő konfigurációjához vannak kötve. Ezek kezelik helyetted az OAuth hitelesítést, a lapozást és a sebességkorlátozást – három olyan területet, amelyek manuális kezelése jelentős időt emészt fel.

MCP és függvényeszközök kombinálása

Nem kell választanod. Egyetlen ügynök használhat MCP szervert az adatok hozzáféréséhez, és a saját függvényeidet olyan üzleti logikához, amelyet nem szeretnél kiszervezni.

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)

Az ÁFA-számítás a te kódodban marad, ahol tesztelhető és ellenőrizhető; a rendelések lekérése pedig a PostgreSQL MCP szerveren keresztül történik. Ez az a felosztás, amire törekedned kell.

MCP eszközök szűrése

Egy MCP szerver tucatnyi eszközt is közzétehet, amelyek többsége nem lesz releváns a te esettedben – mindegyikük fogyasztja a kontextust és növeli a nem megfelelő hívások kockázatát. Kezdd annak vizsgálatával, hogy mi is áll valójában rendelkezésre.

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

# Szűrhetsz a csatlakozás során
async with server:
    tools = await server.list_tools()
    # Vizsgáld meg az elérhető eszközöket
    for tool in tools:
        print(f"- {tool.name}: {tool.description}")

MCP hibák kezelése

Egy MCP szerver egy folyamat vagy távoli szolgáltatás: előfordulhat, hogy nem indul el, megszakad a kapcsolata, vagy lejár a tokenje. Tervezz degradált üzemmódot ahelyett, hogy hagynád, hogy a kivétel felbukkanjon a felhasználó előtt.

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:
        # Tartalék megoldás MCP nélkül
        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

A tartalék ügynök nem tetteti, hogy működik: bejelenti a elérhetetlenséget. Egy olyan ügynök, amely kitalál egy választ, amikor az adatforrása leállt, sokkal többe kerül, mint az, amely bevallja, hogy nem tud továbbhaladni.

Főbb megállapítások

  • Az MCP egy nyílt protokoll külső szolgáltatások ügynökhöz való csatlakoztatására
  • Használd az MCPServerStdio osztályt helyi szerverekhez, az MCPServerSse osztályt pedig távoli szerverekhez
  • Az OpenAI csatlakozók a platformon kezelt integrációk
  • Kombinálhatsz függvényeszközöket és MCP szervereket ugyanabban az ügynökben
  • Kezeld az MCP csatlakozási hibákat degradált üzemmóddal