Mik azok az MCP-eszközök, és hogyan használják őket az MI-modellek?

Ismerd meg, mik azok az MCP-eszközök, hogyan találják meg és hívják meg őket az MI-modellek az MCP-szervereken keresztül, és hogyan használhatod őket biztonságosan.

Diagram of how MCP works: an AI app (the MCP host) sends tool requests through an MCP client to an MCP server, which connects to tools and returns results.

Az MCP-eszközök olyan függvények, amelyeket egy MI-modell meghívhat, hogy a beszélgetésen kívül végrehajtson egy feladatot. Például kereshet a jegyzeteidben, vagy lekérdezhet egy adatbázist. Minden eszköz egy MCP-szerveren (Model Context Protocol) található, és van neve, valamint rövid leírása, amelyek segítenek a modellnek eldönteni, mikor használja.

Az „MCP-eszköz” kifejezést más értelemben is használják. A hétköznapi szóhasználatban sokan akkor is MCP-eszközökről beszélnek, amikor MCP-szerverekre (az eszközöket kínáló alkalmazásokra) vagy az ilyen szervereket listázó katalógusokra gondolnak. Az MCP Tools emellett egy parancssori program neve is, amellyel listázhatók és meghívhatók egy MCP-szerver eszközei.

Ez az útmutató a protokoll függvényeiről szól, nem a szerverekről, katalógusokról vagy parancssori programokról. Bemutatja, miből áll egy eszköz, milyen típusú eszközöket kínálnak a szerverek, és miben különböznek az eszközök az erőforrásoktól, a promptoktól és a függvényhívástól. Ezután végigveszi, milyen lépésekben használ egy modell egy eszközt, végül pedig a használatukkal kapcsolatos leggyakoribb problémákat tekinti át.

Mik azok az MCP-eszközök?

Az MCP-eszköz olyan függvény, amely lehetővé teszi, hogy az MI-modellek más szoftveralkalmazásokkal végezzenek el feladatokat. Az én MI-ügynökeim és munkafolyamataim például MCP-eszközökkel írnak e-mail-piszkozatokat a Gmailben (create_draft), hoznak létre Trello-kártyákat (trelloWriteCard), és kérnek le élő keresési találatokat a DataForSEO-ból (serp_organic_live_advanced), hogy csak néhányat említsek.

A szoftveralkalmazások gyakran több MCP-eszközt is kínálnak az MCP-szervereiken. A Trello MCP-szervere például jelenleg 14 MCP-eszközzel rendelkezik, amelyekkel az MI-modellek táblákat, listákat, ellenőrzőlistákat, kártyákat és még sok mást olvashatnak és frissíthetnek.

És mivel az MCP szabványosítja az eszközök leírásának és kínálásának módját, a protokollt támogató bármely MI-alkalmazás ugyanazt az MCP-eszközt használhatja.

Miből áll egy MCP-eszköz

Minden MCP-eszközhöz három dolog tartozik:

  • Név: Rövid azonosító, amelyet a modell az eszköz meghívásakor használ (pl. get_event a Google Naptárban).
  • Leírás: Közérthető magyarázat arról, mit csinál az eszköz, és mikor hasznos. A nagy nyelvi modell (LLM) ez alapján dönti el, hogy az eszköz megfelel-e a kérésednek (pl. „Returns a single event on the given calendar.”).
  • Bemenetek: Az eszköz futtatásához szükséges információk, például egy ügyfél neve és egy dátum egy jegyzetkereséshez. A bemeneteket JSON formátumban írják le, ezt a leírást a fejlesztők bemeneti sémának (input schema) nevezik, mert ez határozza meg az egyes bemenetek formáját (szöveg, szám vagy lista).

Egyes eszközök további metaadatokat is megadnak: megjelenítési nevet, az általuk visszaadott eredmények leírását (kimeneti sémát), valamint az eszköz viselkedésére vonatkozó megjegyzéseket (annotációkat).

Az MI-modell soha nem látja az eszköz mögötti kódot. Abból dolgozik, amit az eszköz önmagáról közöl, így egy homályos név vagy leírás miatt a modell rossz eszközt választhat.

Az MCP-eszközök típusai

Az MCP-eszközök funkciójuk szerint négy csoportba sorolhatók:

  • Kereső és lekérdező eszközök: Információt keresnek vagy kérnek le (pl. jegyzetekben keresnek, beolvasnak egy fájlt, vagy lekérdeznek egy adatbázist).
  • Műveleti eszközök: Létrehoznak vagy módosítanak valamit egy másik alkalmazásban (pl. feladatot adnak hozzá, naptáreseményt hoznak létre, ügyfélszolgálati jegyet nyitnak, vagy e-mailt küldenek).
  • Adatfeldolgozó eszközök: Adatokat alakítanak át vagy elemeznek (pl. elemeznek egy táblázatfájlt, vagy számítást végeznek).
  • Rendszereszközök: A helyi rendszerrel kommunikálnak (pl. parancsot hajtanak végre egy terminálban).

MCP-eszközök kontra erőforrások & promptok

Az MCP-eszközök mellett egy MCP-szerver kétféle további építőelemet is kínálhat, amelyeket a protokoll primitíveknek nevez: erőforrásokat és promptokat.

A GitHub hivatalos MCP-szervere például a következőket kínálja:

  • Egy issue_write nevű eszközt, amely issue-kat hoz létre vagy frissít,
  • Egy repository_content nevű erőforrást, amely hozzáférést biztosít egy adattár fájljaihoz,
  • Egy issue_to_fix_workflow nevű promptot, amely előkészíti a lépéseket ahhoz, hogy egy problémát issue-ként jelents be, és a GitHub Copilot kódolási ügynöke pull requestet hozzon létre a javításához.

A különbség abban rejlik, hogy mire szolgálnak, és ki dönti el, mikor kell használni őket: te, az MI-alkalmazás, amelyben dolgozol (pl. a Perplexity), vagy az alkalmazásban futó MI-modell.

  • Az MCP-eszköz műveleteket hajt végre vagy információt keres. Az MI-modell önállóan dönti el, mikor hív meg egy eszközt, az MI-alkalmazásod pedig továbbítja a hívást a szervernek. Az eszközöket az MI-modell választja ki, az MI-alkalmazásodnak pedig meg kell mutatnia neked minden hívást, és lehetővé kell tennie, hogy elutasítsd.
  • Az erőforrás az MCP-szerveren elérhető tartalom, például egy fájl vagy rekordok egy halmaza, amelyek mindegyike saját címmel (URI-val) rendelkezik. Az MI-alkalmazásod lekérdezi a szervertől, milyen erőforrásai vannak, a címe alapján beolvassa a szükségeset, majd a tartalmat kontextusként hozzáadja a beszélgetéshez.
  • A prompt a szerver által biztosított kész üzenetsablon, amely néha kitöltendő mezőket is tartalmaz. Az MI-alkalmazásod megjeleníti az elérhető promptokat, te pedig kiválasztasz egyet, gyakran perjeles paranccsal.

Hogyan használják az MI-modellek az MCP-eszközöket

Egy MI-modell öt lépésben használ egy MCP-eszközt: felderítés, eszközválasztás, meghívás, eredmények és hibakezelés. A modell és a szerver között mindent az MI-alkalmazásod közvetít.

Tegyük fel, hogy megkéred az MI-alkalmazásodat, hogy nézze meg a Trellóban az „Ezen a héten” listádat, és írjon egy e-mail-piszkozatot a szerkesztődnek a fejleményekről. Íme, mi történik az elejétől a végéig:

  1. Felderítés: Amikor az MI-alkalmazásod MCP-klienseken keresztül csatlakozik egy MCP-szerverhez, lekéri a szerver elérhető eszközeinek listáját (ez a tools/list nevű kérés). Az LLM csak azt látja, amit az alkalmazás továbbít neki: az egyes eszközök nevét, leírását és bemeneteit.
  2. Eszközválasztás: Az MI-modell összeveti a kérésedet ezekkel a leírásokkal, és kiválasztja a megfelelő eszközöket. Ebben az esetben ez a Trello trelloReadList eszköze a lista beolvasásához és a Gmail create_draft eszköze az e-mail megírásához. A modell a bemeneteket is kitölti, például hogy melyik listát kell beolvasni.
  3. Meghívás: A modell egy strukturált kéréssel válaszol, amely az eszköz futtatására irányul (ezt a lépést „függvényhívásnak” nevezik). Az MI-alkalmazásod elküldi ezt a kérést a megfelelő szervernek (ez egy tools/call kérés). Emellett meg kell mutatnia neked a hívást, és lehetővé kell tennie, hogy elutasítsd.
  4. Eredmények: A szerver lefuttatja a függvényt, és visszaküldi az eredményt (result), ebben az esetben a listádon lévő kártyákat. Az MI-alkalmazásod hozzáadja az eredményt a beszélgetéshez, a modell pedig eldönti, mi legyen a következő lépés: válaszol neked, vagy meghív egy másik eszközt, például a create_draft eszközt egy, a kártyák alapján megírt e-maillel.
  5. Hibakezelés: Ha az eszköz lefut, de sikertelen – például mert a lista nem létezik –, a hiba az eredmény részeként érkezik vissza. A modell elolvashatja, és más bemenetekkel újra próbálkozhat. Ha maga a kérés hibás – például mert olyan eszközt hív meg, amely nem létezik a szerveren –, az alkalmazás ehelyett protokollhibát kap. Ilyenkor kisebb az esélye, hogy a modell helyre tudja hozni a helyzetet.

A lényeg az, hogy a modell kizárólag a leírásuk alapján választja ki az eszközöket, a szerverekkel pedig minden kommunikációt az MI-alkalmazásod bonyolít le.

Az MCP-eszközök gyakori problémái és elkerülésük módja

Az MCP-eszközökkel kapcsolatos problémák négy tényezőre vezethetők vissza: hány eszköz van csatlakoztatva, hogyan vannak elnevezve és leírva, mennyi adatot adnak vissza, és mely szerverekről származnak.

Íme, hogyan jelentkeznek az egyes problémák, és mi segít rajtuk:

Probléma

Hogyan jelentkezik

Mi segít

Túl sok csatlakoztatott eszköz

Minden eszközdefiníció helyet foglal a modell kontextusablakában, még mielőtt bármit kérdeznél, és minél hosszabb a lista, annál rosszabb az eszközválasztás.

Csak azokat a szervereket csatlakoztasd, amelyekre az adott feladathoz szükség van, és kapcsold ki a nem használt eszközöket, ha az MI-alkalmazásod ezt lehetővé teszi. Példa: a GitHub MCP-szerverén csak a szükséges eszközcsoportokat (toolseteket) engedélyezheted.

Homályos vagy átfedő leírások

A modell rossz eszközt hív meg, vagy a megfelelőt rossz bemenetekkel, mert két leírás hasonlóan hangzik, vagy az egyik túl keveset árul el.

Adj meg egyértelmű, konkrét neveket és leírásokat, ideális esetben egy példával arra, hogy mikor érdemes használni az eszközt. Ha egy szerver eszközeinél rendre hibás hívások történnek, az MCP Inspector, a hivatalos tesztelőeszköz, pontosan megmutatja, mit közölnek magukról az egyes eszközök.

Azonos eszköznév két szerveren

Két szerver is kínál search nevű eszközt, és nem lehet tudni, melyiknek szól egy adott hívás.

Az eszköznevek elé írd előtagként a szerver nevét. Példa: a Trello szervere (trelloSearch, trelloReadList).

Túl nagy eredmények

Egy eszköz többet ad vissza, mint amennyire a feladathoz szükség van – például egy teljes e-mail-szálat a formázással együtt –, és ezzel telezsúfolja a modell kontextusát.

Használj olyan eszközöket, amelyek tömör formátumokat kínálnak. Példa: a Gmail get_thread eszközének leírása egyszerű szöveges formátumot javasol, „hogy elkerülhető legyen a kontextus kimerülése”.

Nem megbízható szerverek

Egy gondatlanul fejlesztett vagy rosszindulatú szerver eszközhívásokon keresztül adatokat szivárogtathat ki a beszélgetésedből.

Csak megbízható forrásból származó szervereket csatlakoztass, és hagyd bekapcsolva a jóváhagyást azoknál az eszközöknél, amelyek módosítanak valamit vagy adatokat küldenek ki.

Miért van szükség a jóváhagyásodra az MCP-eszközökhöz?

Az MCP-eszközökhöz azért van szükség a jóváhagyásodra, mert enélkül az MI-modell nem szándékolt módosításokat végezhetne, vagy érzékeny adatokat oszthatna meg egy olyan szerverrel, amely felett nincs irányításod.

Egy félreértett kérés vagy egy homályosan leírt eszköz rossz műveletet indíthat el. Ráadásul minden hívás elküldi bizonyos adataidat egy szervernek.

Ezért várja el a protokoll, hogy az MI-alkalmazások egy embert is bevonjanak a folyamatba, aki bármely eszközhívást elutasíthat.

Íme egy praktikus módszer az eszközök csoportosítására aszerint, hogy mennyi ellenőrzést igényelnek:

  • Csak olvasó műveletek: Ha egy eszköz csak lekér valamit – például beolvas egy listát a Trello trelloReadList eszközével –, azzal semmi sem változik. Ezek a hívások előzetes kérdés nélkül is futhatnak, feltéve, hogy az MI-alkalmazásod megmutatja, melyik eszköz futott, és mit kérdezett le.
  • Visszavonható műveletek: Egy e-mail-piszkozat létrehozása a Gmail create_draft eszközével vagy egy Trello-kártya hozzáadása visszafordítható változtatással jár. A hívás futtatása előtt ellenőrizd a bemeneteket.
  • Vissza nem vonható műveletek: Egy e-mail elküldése a Gmail send_message eszközével, rekordok törlése vagy bármi, ami fizetéssel vagy érzékeny adatokkal jár, nem fordítható vissza. Ezekhez minden alkalommal adj kifejezett engedélyt.

MCP-eszközök használata a Perplexityben

A Perplexity mindkét irányban együttműködik az MCP-eszközökkel: használhatja az általad csatlakoztatott MCP-szerverek eszközeit, és saját eszközöket is kínál más MI-alkalmazásoknak.

  • MCP-szerverek csatlakoztatása a Perplexityhez: A Pro, Max és Enterprise csomagokkal a Perplexityt bármilyen olyan külső eszközhöz vagy adatforráshoz csatlakoztathatod, amely MCP-szerverrel rendelkezik, és használhatod a válaszokban, valamint a Perplexity Computer ügynöki munkafolyamataiban. A Mac-alkalmazásban a számítógépeden futó MCP-szervereket is csatlakoztathatod
  • A Perplexity eszközeinek használata más MI-alkalmazásokban: A Perplexity MCP-szervere négy eszközt (perplexity_search, perplexity_ask, perplexity_research és perplexity_reason) kínál minden olyan MI-alkalmazásnak, amely támogatja a távoli MCP-szervereket, például a Claude Code-nak. Egy külön szerver segítségével más MI-alkalmazások többlépéses feladatokat adhatnak át a Perplexity Computernek.

GYIK az MCP-eszközökről

Az MCP csupán eszközhívás?

Nem, az MCP nem csupán eszközhívás. Az eszközhívás az, ahogyan a modell egy eszközt kér, az MCP pedig az, ahogyan az MI-alkalmazás megtalálja az eszközöket, és minden hívást ahhoz a szerverhez irányít, amely futtatja.

Az eszközhívás (más néven függvényhívás) a munka MI-modellre eső része: a modell lát egy eszközlistát, és egy kéréssel válaszol, hogy futtassák valamelyiket. Önmagában az eszközhívással minden MI-alkalmazásnak saját magának kell definiálnia és futtatnia az összes eszközt.

Az MCP-vel az eszközök szervereken helyezkedhetnek el, így bármely MCP-t támogató MI-alkalmazás felkínálhatja őket a modelljének, és a modell kéréseit a megfelelő szerverhez továbbíthatja.

Felváltja az MCP az API-kat?

Nem, az MCP nem fogja felváltani az API-kat, mert az MCP és az API-k együttműködnek. Az MCP-eszközök gyakran meglévő API-kra épülnek, és amikor a modell meghív egy eszközt, az MCP-szerver jellemzően egy API-kérést indít.

Mely MI-alkalmazások támogatják az MCP-eszközöket?

Az MCP-eszközök olyan MI-asszisztensekben működnek, mint a Claude, a ChatGPT és a Perplexity, valamint olyan fejlesztőeszközökben, mint a Visual Studio Code és a Cursor. Az MCP dokumentációja ezeket nevezi meg, és megjegyzi, hogy sok más alkalmazás is támogatja őket.

Magának az MI-modellnek is támogatnia kell az MCP-t?

Nem. Az MI-modellnek nem kell támogatnia az MCP-t, mert a protokollt az MI-alkalmazásod kezeli. Az alkalmazás csatlakozik a szerverekhez, továbbítja azok eszközeit a modellnek, és a modell eszközkéréseit visszaküldi a megfelelő szervernek. A modellnek csak a függvényhívást kell támogatnia.

Elavulóban van az MCP?

Nem, az MCP fejlesztése továbbra is aktívan zajlik. A karbantartói 2026 júliusában kiadták az MCP-specifikáció új verzióját, 2026 augusztusában pedig közzétettek egy frissített ütemtervet, amelyben többek között az is szerepel, hogy a szerverek fokozatosan fedhessék fel az eszközeiket, ahogy a beszélgetés egyre szűkebb témára fókuszál.