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

MCP és csatlakozók: az univerzális szabvány

16. lecke 20 közül Fejlesztő
Ezen az oldalon
  1. MCP és csatlakozók: az univerzális szabvány
  2. A probléma, amelyet az MCP megold
  3. Az MCP architektúrája
  4. Az OpenAI Connectors használata
  5. MCP szerver létrehozása Pythonban
  6. MCP erőforrások közzététele
  7. MCP szerver csatlakoztatása a Responses API-hoz
  8. Minta: Több csatlakozós központ
  9. Biztonság és hitelesítés
  10. Főbb megállapítások

MCP és csatlakozók: az univerzális szabvány

A Model Context Protocol (MCP) egy nyílt szabvány, amely lehetővé teszi a modellek számára, hogy egységes protokollon keresztül lépjenek kapcsolatba külső szolgáltatásokkal. Az OpenAI Connectors ezt a szabványt valósítja meg, hogy a Responses API-n belül közvetlenül összekösse a modelleket harmadik féltől származó eszközökkel.

A probléma, amelyet az MCP megold

A központi kérdés az integrációk elszaporodása: N modell és M szolgáltatás összekapcsolása N×M egyedi integrációt igényel, amelyek mindegyikét külön-külön kell megírni és karbantartani. Minden új szolgáltatás arra kényszerít, hogy minden alkalmazás esetén megismételd a munkát, és minden API-változás kockázatot jelent, hogy több integráció is meghibásodik.

Az MCP ezt a szorzatot összeggé alakítja: a szolgáltatás egyszer teszi közzé képességeit a protokoll segítségével, és bármely kompatibilis kliens fogyasztja azokat. Ez ugyanaz a logika, mint a nyomtató-illesztőprogramok vagy a kódszerkesztőkben használt Language Server Protocol (LSP) esetében – a szabványosítás nem teszi erősebbé az integrációkat, hanem gazdaságilag fenntarthatóvá teszi őket.

# MCP előtt: manuális integráció minden szolgáltatáshoz
tools = [
    # Funkció a Slackhez
    {"type": "function", "name": "slack_send_message", ...},
    {"type": "function", "name": "slack_read_channel", ...},
    # Funkció a Jirához
    {"type": "function", "name": "jira_create_ticket", ...},
    {"type": "function", "name": "jira_list_tickets", ...},
    # Funkció a Google Drive-hoz
    {"type": "function", "name": "gdrive_list_files", ...},
    # ... tucatnyi karbantartandó funkció
]

Az MCP segítségével minden szolgáltatás szabványos protokollon keresztül teszi közzé képességeit, és a modell közvetlenül fogyasztja azokat.

Az MCP architektúrája

A protokoll három fogalmat definiál:

  • MCP Server: Egy szolgáltatás, amely eszközöket, erőforrásokat és promptokat tesz közzé
  • MCP Client: A rendszer, amely fogyasztja a szerver képességeit
  • Transport: A kommunikációs csatorna a kliens és a szerver között
# Egy MCP szerver a következőket teszi közzé:
# - Tools: Műveletek, amelyeket a modell végrehajthat
# - Resources: Adatok, amelyeket a modell olvashat
# - Prompts: Előre definiált prompt sablonok

Az OpenAI Connectors használata

A Connectors olyan MCP szerverek, amelyeket már üzemeltetnek és karbantartanak: csak deklarálnod kell őket, hitelesítened kell, és már használhatod is. Ez a természetes belépési pont – nincs szükséged saját MCP szerver írására, ha egy gyakori szolgáltatásról van szó, amelyet valaki már összekötött.

from openai import OpenAI

client = OpenAI()

# Fogalmi példa: csatlakozó egy külső szolgáltatáshoz
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Create a Jira ticket for the homepage bug",
    tools=[
        {
            "type": "mcp",
            "server_label": "jira",
            "server_url": "https://mcp.your-server.com/jira",
            "require_approval": "always"
        }
    ]
)

A require_approval paraméter szabályozza az emberi jóváhagyást:

  • "always": Minden művelet jóváhagyást igényel
  • "never": Automatikus végrehajtás

MCP szerver létrehozása Pythonban

Saját szerver írása akkor válik érdemessé, ha egy belső szolgáltatást több alkalmazásnak is elérhetővé kell tenni. A logika ugyanaz, mint egy belső API esetében: egyszer írod meg, tisztán, a saját hozzáférési szabályaiddal – és minden alkalmazás profitál belőle anélkül, hogy újra fel kellene találni az integrációs réteget.

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:
    """Keresés egy ügyfél után a belső CRM-ben.

    Args:
        term: A keresési kifejezés (név, e-mail vagy azonosító)
        field: A mező, amelyben keresni kell (name, email, id)
    """
    # Üzleti logika
    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:
    """Értékesítési lehetőség létrehozása a CRM-ben.

    Args:
        client_id: Ügyfél azonosítója
        title: A lehetőség címe
        amount: Becsült összeg euróban
        probability: Zárás valószínűsége (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 erőforrások közzététele

Az MCP különbséget tesz a tools (eszközök) és a resources (erőforrások) között: az előbbiek csinálnak valamit, míg az utóbbiak olvasnivalót biztosítanak. Ez a megkülönböztetés fontos, mert meghatározza a kockázatot: egy erőforrást mellékhatások nélkül konzultálnak, míg egy eszköz módosíthatja a világ állapotát. A jóváhagyási vezérlők természetesen ez utóbbira fókuszálnak.

@server.resource("crm://pipeline")
async def sales_pipeline() -> str:
    """Az értékesítési tölcsér aktuális állapota."""
    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:
    """Egy ügyfél teljes profilja."""
    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
    })

MCP szerver csatlakoztatása a Responses API-hoz

# MCP csatlakozó konfigurációja az API hívásban
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What is the status of our sales pipeline? "
          "Create an opportunity for client CLI-789: "
          "cloud migration, 50000 euros, 70% probability.",
    tools=[
        {
            "type": "mcp",
            "server_label": "internal-crm",
            "server_url": "https://mcp.internal.example.com/crm",
            "require_approval": "never"
        }
    ]
)

Minta: Több csatlakozós központ

Itt mutatkozik meg igazán a szabvány ereje: több szerver deklarálása egymás mellett, ahol a modell ezek között komponál – itt jegyet olvas, ott ügyfelet keres, máshol választ ír. Közös protokoll nélkül ugyanez a folyamat három specifikus integrációt és azok folyamatos karbantartását igényelné.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Check open Jira tickets, send a summary to Slack, "
          "and update the Notion dashboard",
    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"
        }
    ]
)

Biztonság és hitelesítés

# Az MCP szerverek a hitelesítést fejléceken keresztül
# vagy tokenekkel kezelik a konfigurációs URL-ben

# Legjobb gyakorlat: mindig használj require_approval-t írási műveleteknél
tools = [
    {
        "type": "mcp",
        "server_label": "crm",
        "server_url": "https://mcp.example.com/crm",
        "require_approval": "always",  # Emberi jóváhagyás
        "allowed_tools": ["search_client", "client_profile"],  # Eszközök korlátozása
    }
]

Főbb megállapítások

  • Az MCP egy nyílt szabvány a modellek és a külső szolgáltatások összekapcsolására
  • Az OpenAI Connectors közvetlenül integrálja az MCP-t a Responses API-ba
  • Készíts saját MCP szervereket belső szolgáltatások közzétételéhez
  • Használd a require_approval paramétert az emberi jóváhagyás szabályozására
  • Csatlakoztass több MCP szervert egyetlen hívásban a funkciókon átnyúló munkafolyamatokhoz