Jak łączyć modele ze światem, po jednym serwerze naraz
autor: Mat Siems
CZĘŚCI I–X · ROZDZIAŁY 1–100 · MATSIEMS.COM
Część I
Problem N na M
Po co istnieje protokół i dlaczego właśnie teraz.
Rozdział 1 · Część I
Wtyczka do każdego gniazdka
Witaj. Oto przewodnik praktyka po Model Context Protocol, zwykle skracanym do MCP, w stanie na październik 2026 roku. Ma sto krótkich rozdziałów, a każdy ma cię nauczyć jednej rzeczy, której użyjesz jeszcze w tym tygodniu – niezależnie od tego, czy budujesz serwery, utrzymujesz hosty, które się z nimi łączą, czy też ktoś wyżej w hierarchii poprosił cię, żebyś do piątku „miał zdanie na temat MCP”.
Zacznijmy od prostego opisu. MCP to otwarty protokół, który pozwala aplikacji AI łączyć się z zewnętrznymi narzędziami i danymi przez jeden standardowy interfejs. Po jednej stronie stoi coś, co rozmawia z modelem: aplikacja czatowa, agent programistyczny, IDE. Po drugiej – coś, co umie wykonać konkretną robotę: przeszukać system zgłoszeń, odpytać bazę danych, przeczytać folder, wysłać wiadomość. MCP to uzgodniony kształt rozmowy między nimi. Aplikacja pyta, co jest dostępne, druga strona to opisuje, a od tej chwili model może zlecać pracę i odbierać wyniki.
Porównanie, po które sięgają wszyscy, to USB-C, i tym razem banał naprawdę zarabia na siebie. Zanim pojawiło się wspólne złącze, każde urządzenie miało własny kabel, a każda szuflada zapełniała się niewłaściwymi. Potem producent buduje jedno gniazdo i ufa, że cokolwiek przyjdzie, będzie pasować. MCP robi to samo z przestrzenią między modelami a światem. Zbuduj serwer raz, a każdy host mówiący tym protokołem może go podłączyć. Zbuduj host raz, a skorzysta z dowolnego serwera.
Protokół jest nudny celowo. Tylko tak może trafić wszędzie.
Co to oznacza w praktyce? Że kiedy chcesz, by twój asystent czytał firmową wiki, nie czekasz już, aż producent asystenta napisze integrację z wiki, ani nie piszesz jej sam w formacie wtyczek konkretnego dostawcy, który do wiosny zostanie wycofany. Znajdujesz albo budujesz serwer MCP dla wiki i go podłączasz. Ten sam serwer działa potem w twoim agencie programistycznym, w desktopowej aplikacji czatowej i w wewnętrznym narzędziu, które buduje twój zespół platformowy, bo wszystkie mówią tym samym językiem.
Oznacza to też drobną zmianę w myśleniu o modelu. Model sam w sobie wie to, na czym go wytrenowano, i to, co mu wkleisz. Model z podłączonymi serwerami MCP potrafi coś sprawdzić, wykonać działanie i dociągnąć świeży kontekst, gdy go potrzebuje – w granicach, które wyznaczysz. Ta ostatnia klauzula zajmie dobrą jedną trzecią tej książki, bo wtyczka pasująca do wszystkiego pasuje też do rzeczy, których wcale nie miałeś na myśli.
Reszta części pierwszej wyjaśnia, po co protokół istnieje, skąd się wziął i czym nie jest. Jeśli się niecierpliwisz, przeskocz do rozdziału dziesiątego i coś podłącz. Wrócisz tu. Wszyscy wracają, zwykle zaraz po pierwszym wywołaniu narzędzia, które ich zaskoczy.
Ryc. 1 · Wtyczka do każdego gniazdka. Hosty i serwery spotykają się przez jeden standardowy interfejs: pytaj, opisz, zleć, zwróć.
Rozdział 2 · Część I
Mnożenie jest wrogiem
Każdy problem z integracją jest po cichu problemem z mnożeniem, a mnożenie jest wrogiem. Załóżmy, że w twojej organizacji liczy się pięć aplikacji AI i dwadzieścia systemów, do których mają one sięgać. Jeśli każda aplikacja integruje się z każdym systemem na własnych warunkach, potrzebujesz stu integracji. Każdą napisze kto inny, w innym stylu, z innym wyobrażeniem o tym, jak wygląda błąd. Każda zepsuje się według własnego harmonogramu.
To jest problem N na M i jest starszy niż modele językowe. To przez niego mamy sterowniki SQL, sterowniki drukarek, HTTP i skromne gniazdko elektryczne. Za każdym razem lekarstwo było to samo: uzgodnić kształt pośrodku. Wtedy każda aplikacja implementuje ten kształt raz, każdy system implementuje go raz, a sto integracji zapada się w dwadzieścia pięć kawałków pracy. N plus M, a nie N razy M. Arytmetyka staje się tym bardziej przekonująca, im większe są liczby, a w narzędziach AI liczby rosły bardzo szybko.
Przed MCP każdy dostawca modeli i każdy framework agentowy miał własny sposób opisywania narzędzia. Wszystkie były podobne, bo wszystkie sprowadzały się do JSON Schema z nazwą i opisem, ale podobne to nie to samo. Narzędzie napisane dla jednego frameworka trzeba było przepakować dla następnego. Firma, która chciała, by jej produkt był osiągalny z asystentów AI, musiała wybrać faworytów albo wypuścić pięć nieco różnych wtyczek i utrzymywać wszystkie. Większość wybierała jedną i liczyła na szczęście.
Koszt integracji rośnie z iloczynem twoich wyborów. Standardy sprawiają, że rośnie z ich sumą.
MCP przesuwa porozumienie o warstwę niżej. Nie obchodzi go, jaki model stoi za hostem ani w jakim języku napisano serwer. Obchodzi go to, żeby obie strony wymieniały te same komunikaty: wylistuj swoje narzędzia, wywołaj to, oto wynik. Kiedy to jest ustalone, ludzie znający system zgłoszeń budują serwer systemu zgłoszeń, a ludzie budujący hosty skupiają się na hostowaniu. Każda strona robi to, do czego jest najlepiej przygotowana, i robi to raz.
Jest pewien koszt i warto go nazwać. Wspólny kształt to kompromis. Niektóre systemy mają możliwości, których protokół nie wyraża zgrabnie, a niektóre hosty chciałyby funkcji, których protokół jeszcze nie oferuje. Spotkasz obie frustracje. Wymiana wciąż jest korzystna, z tego samego powodu, dla którego nikt nie projektuje wtyczki na zamówienie do swojego czajnika: wartość pasowania wszędzie jest większa niż wartość idealnego pasowania gdziekolwiek.
Więc kiedy ktoś zapyta, dlaczego twój zespół miałby używać MCP zamiast pisać bezpośrednią integrację, policz na głos. Policz hosty, które za dwa lata będziesz chciał obsługiwać, policz systemy i pomnóż. Potem policz jeszcze raz i dodaj. Różnica między tymi dwiema liczbami to całe uzasadnienie biznesowe i rzadko potrzebuje slajdu.
Ryc. 2 · Mnożenie jest wrogiem. Pięć aplikacji i dwadzieścia systemów: sto połączeń punkt-punkt kontra dwadzieścia pięć przez MCP.
Rozdział 3 · Część I
Życie przed protokołem
Warto pamiętać, jak to robiliśmy wcześniej, choćby po to, żeby nikt nie zaproponował z nostalgią powrotu do starych metod. Modele językowe nauczyły się wywoływać funkcje jakiś czas przed powstaniem MCP. Opisywałeś funkcję nazwą, zdaniem wyjaśnienia i JSON Schema dla argumentów; model odpowiadał nie prozą, lecz ustrukturyzowaną prośbą o jej wywołanie; twój kod uruchamiał funkcję i oddawał odpowiedź. To działało. Nadal działa. Prawdę mówiąc, dokładnie to dzieje się pod spodem MCP.
Kłopot leżał we wszystkim dookoła. API każdego dostawcy miało własną kopertę na definicje narzędzi i ich wyniki. Każdy framework agentowy owijał te koperty jeszcze raz we własne abstrakcje, z własnymi dekoratorami i klasami bazowymi. Zespół, który chciał, by asystent przeszukiwał dokumentację, pisał funkcję wyszukiwania, wpinał ją w jeden framework i pół roku później odkrywał, że połowa firmy używa innego asystenta, który jej nie widzi. Funkcja była w porządku. Problemem był klej, a klej za każdym razem robiono na miarę.
Potem przyszły ekosystemy wtyczek. Kilka produktów dawało stronom trzecim możliwość rozszerzania ich, każdy z własnym formatem manifestu, procesem recenzji i cyklem życia. Wtyczka zbudowana dla jednego produktu była bezużyteczna dla innego. Niektóre z tych ekosystemów wygaszono, a wraz z nimi ich wtyczki. Jeśli na którymś budowałeś, odebrałeś lekcję, której każda platforma prędzej czy później udziela: byłeś najemcą, nie właścicielem.
Kod-klej to ciemna materia oprogramowania. Trzyma wszystko w kupie, a nikt nie widzi, ile go jest.
Był też koszt subtelniejszy. Ponieważ każda integracja żyła wewnątrz konkretnej aplikacji, wiedziała o tej aplikacji za dużo. Zakładała określony model, określony styl promptów, określony sposób pytania użytkownika o zgodę. Przeniesienie jej oznaczało rozplątywanie tych założeń. Testowanie jej oznaczało uruchamianie całej aplikacji. Ponowne użycie oznaczało kopiowanie, a kopiowanie – dwie wersje, które z czasem się rozjeżdżają.
Odpowiedzią MCP jest rozdzielenie. Serwer wie o systemie, który opakowuje, i nic o modelu. Host wie o modelu i o użytkowniku, a nic o wnętrznościach systemu. Protokół to wąska, precyzyjnie opisana szczelina między nimi. To w tej szczelinie ponowne użycie staje się możliwe i to tam można testować bez modelu w pętli.
Nic z tego nie było porażką wyobraźni ludzi, którzy byli tu przed nami. Wywoływanie funkcji było właściwym prymitywem. Wtyczki były rozsądnym eksperymentem. Brakowało im po prostu neutralnego środka, którego nikt nie posiada, a każdy może zaimplementować. Jeśli dziś utrzymujesz stertę integracji sprzed MCP, nie musisz przepisywać ich w weekend. Opakuj najczęściej używaną jako serwer, podłącz ją do dwóch hostów i zobacz, czy szuflada z klejem zrobi się lżejsza. Zwykle się robi, a potem już nigdy nie cięższa.
Ryc. 3 · Życie przed protokołem. Wywołanie funkcji, wtyczki i serwery MCP porównane pod kątem formatu, ponownego użycia, właściciela i testów.
Rozdział 4 · Część I
Krótka historia młodego standardu
Historia jest krótka, bo nie było na nią wiele kalendarza. Anthropic opublikował Model Context Protocol jako otwartą specyfikację w listopadzie 2024 roku, razem z SDK i garścią serwerów referencyjnych do takich rzeczy jak systemy plików, Git i bazy danych. W chwili premiery była to propozycja jednej firmy, zaimplementowana w desktopowej aplikacji tej firmy, z obietnicą, że każdy może na niej budować. Takie obietnice są częste. Większość nie znajduje chętnych.
Ta znalazła. W ciągu 2025 roku protokół przyjęło zdumiewająco szerokie grono hostów: asystenci i zestawy narzędzi agentowych innych dostawców modeli, główne IDE i agenci programistyczni oraz długi ogon mniejszych narzędzi. Firmy zaczęły wydawać oficjalne serwery dla swoich produktów, a liczba serwerów społecznościowych rosła szybciej, niż ktokolwiek był w stanie sensownie je policzyć. Pod koniec roku pytanie „czy to obsługuje MCP?” stało się rutynowym punktem każdej oceny narzędzi, zadawanym tym samym tonem co „czy to ma API?”.
Sama specyfikacja zmieniała się szybko. Rewizje oznacza się datą, a nie numerem wersji, i każda coś dodawała albo zaostrzała: strumieniowy transport HTTP w miejsce wcześniejszego, bardziej topornego; ramy autoryzacji oparte na OAuth; ustrukturyzowane wyniki narzędzi; sposoby, by serwer mógł zadać użytkownikowi pytanie; maszynerię do długotrwałej pracy. Niektóre wczesne funkcje usunięto, gdy okazały się bardziej kłopotliwe, niż były warte. To zdrowy znak. Standardy, które nigdy niczego nie odejmują, zamieniają się w muzea.
Standard staje się prawdziwy w dniu, w którym jego autor przestaje być jego jedynym implementatorem.
W grudniu 2025 roku Anthropic przekazał MCP nowo powołanej otwartej fundacji pod skrzydłami Linux Foundation, obok wkładów innych firm. W praktyce oznacza to, że protokołem zarządza się teraz jawnie, poprzez propozycje, grupy robocze i opiekunów wywodzących się z kilku organizacji, a nie według mapy drogowej jednego dostawcy. Kupującemu daje to odpowiedź na pytanie, które zawsze pada przy młodym standardzie: co będzie, jeśli firma, która za nim stoi, zmieni zdanie?
Co wynieść z tej historii? Przede wszystkim wyczucie tempa. Szczegóły zmieniały się co kilka miesięcy i nadal będą się zmieniać. Pola zmieniają nazwy, przybywa możliwości, wycofane mechanizmy jeszcze przez jakiś czas pokutują w starszych serwerach. Dlatego ta książka opiera się na zasadach, a gdy wymienia konkretny mechanizm, mówi, po co on istnieje – żebyś rozpoznał jego następcę.
Jest też lekcja w tym, dlaczego protokół się rozprzestrzenił. MCP nie był najbystrzejszym możliwym projektem. Był na tyle prosty, że dało się go zaimplementować w jedno popołudnie, na tyle otwarty, że nikt nie musiał prosić o pozwolenie, i użyteczny od pierwszego dnia. Te trzy cechy prawie zawsze wygrywają z pomysłowością. Jeśli kiedyś przyjdzie ci projektować wewnętrzny standard, zapamiętaj kolejność: użyteczny, potem otwarty, potem prosty, a dopiero potem, jeśli zostanie czasu, pomysłowy.
Ryc. 4 · Krótka historia młodego standardu. Od otwartej specyfikacji w listopadzie 2024 do zarządzania przez Linux Foundation w grudniu 2025.
Rozdział 5 · Część I
Model tylko mówi
Najbardziej użyteczny fakt o MCP jest zarazem tym, który najczęściej rozumie się opacznie. Model nigdy nie wywołuje narzędzia. Model tylko mówi. Kiedy ludzie mówią, że „model przeszukał bazę danych”, w rzeczywistości model wyprodukował tekst, który w ustrukturyzowany sposób oznajmia: chciałbym, żeby narzędzie wyszukiwania zostało wywołane z tymi argumentami, a zwyczajny kawałek oprogramowania zdecydował, czy to zrobić.
Tym kawałkiem oprogramowania jest host: aplikacja czatowa, agent programistyczny, IDE. Host dał modelowi listę narzędzi, o które ten może prosić, każde z nazwą, opisem i schematem. Gdy odpowiedź modelu zawiera prośbę o narzędzie, host ją odczytuje, sprawdza własne reguły, być może pyta cię o zgodę, a potem wysyła żądanie przez MCP do tego serwera, który to narzędzie udostępnia. Serwer wykonuje pracę i zwraca wynik. Host wkłada wynik z powrotem do rozmowy, a model, czytając go, decyduje, co powiedzieć albo o co poprosić dalej.
Dlaczego to ważne? Bo każda właściwość bezpieczeństwa, każde uprawnienie, każdy dziennik audytu żyje w hoście i w serwerze, a nie w modelu. Model nie może wyjść poza swoje narzędzia, bo nie potrafi zrobić absolutnie nic poza produkowaniem tekstu. Jeśli serwer udostępnia narzędzie, które usuwa rekordy, model może poprosić o usunięcie rekordów; czy do tego dojdzie, zależy od reguł zatwierdzania w hoście i od kontroli po stronie serwera. Jeśli nikt niczego nie sprawdza, jedyną strażą jest osąd modelu, a na osąd modelu może wpłynąć cokolwiek, co trafi do jego kontekstu.
Model proponuje. Host rozporządza. Serwer odwala robotę i trzyma paragony.
To wyjaśnia także, dlaczego serwery MCP nie muszą wiedzieć, jakiemu modelowi służą. Dostają poprawnie sformułowane żądanie i zwracają poprawnie sformułowany wynik. Czy żądanie pochodziło od czołowego modelu, od małego modelu lokalnego, czy od uprzęży testowej, w której ktoś wpisywał JSON ręcznie – tego nie widzą i nie powinny widzieć. Jedno z najlepszych debugowań, jakie kiedykolwiek przeprowadzisz, polega na wywołaniu serwera bezpośrednio, bez żadnego modelu w polu widzenia, żeby sprawdzić, czy problem leży powyżej, czy poniżej protokołu.
To wyjaśnia również, dlaczego opisy narzędzi mają takie znaczenie. Model wybiera, o co poprosić, wyłącznie na podstawie tego, co mu powiedziano. Narzędzie o nazwie query z opisem „wykonuje zapytanie” będzie wołane w dziwnych momentach z dziwnymi argumentami. Narzędzie o nazwie search_open_tickets z opisem „znajduje otwarte zgłoszenia supportowe pasujące do frazy; zwraca najwyżej dwadzieścia” będzie wołane wtedy, kiedy powinno. Model nie czyta twojego kodu źródłowego. Czyta twoje przymiotniki.
Trzymaj w głowie tę sekwencję: model prosi, host decyduje, serwer działa, wynik wraca. Kiedy coś pójdzie nie tak, zapytaj, który z czterech kroków zawiódł. Większość zamieszania wokół agentów bierze się z wyobrażania sobie piątego kroku, w którym model sam sięgnął i coś zrobił. Nie zrobił. Pozwoliło mu na to coś, co sam skonfigurowałeś.
Ryc. 5 · Model tylko mówi. Model emituje tekst; host sprawdza reguły, wywołuje serwer i zwraca wynik.
Rozdział 6 · Część I
Kontekst jest produktem
Nazwa mówi ci, na czym polega robota, jeśli przeczytasz ją powoli. Model Context Protocol – protokół kontekstu modelu. Nie protokół narzędzi, choć narzędzia są jego najsłynniejszą funkcją, i nie protokół agentów, choć agenci używają go intensywnie. To protokół dostarczania modelowi kontekstu: właściwych faktów, właściwych plików, właściwych możliwości, w chwili, gdy model ich potrzebuje.
Użyteczność modelu jest ograniczona tym, co mieści się w jego oknie kontekstu. Potrafi rozumować tylko o tym, co widzi. Przed protokołami takimi jak MCP głównymi sposobami wprowadzania kontekstu było ręczne wklejanie, upychanie w prompcie najlepszych trafień systemu wyszukiwania albo dostrajanie modelu. Każdy z nich ma swoje miejsce. Wszystkie trzy łączy jedna słabość: ktoś musiał z góry zdecydować, czego model będzie potrzebował. MCP pozwala modelowi, albo aplikacji wokół niego, pobierać kontekst na żądanie. Zadaj pytanie o incydenty z zeszłego tygodnia, a asystent może pójść i sprawdzić, zamiast polegać na tym, co akurat ktoś wkleił.
To ujęcie wyjaśnia trzy serwerowe prymitywy protokołu lepiej niż jakikolwiek diagram. Narzędzia pozwalają modelowi pobierać albo zmieniać rzeczy, gdy sam tak postanowi. Zasoby pozwalają aplikacji dołączyć dane, na przykład plik albo rekord, wprost do rozmowy. Prompty pozwalają użytkownikowi sięgnąć po przygotowany przepis. Wszystkie trzy służą przenoszeniu właściwego materiału w pole widzenia modelu. Wszystkie trzy kosztują miejsce w skończonym oknie.
Kontekst nie jest za darmo. Każdy token, który podajesz modelowi, to token, przez który musi się przedrzeć, żeby znaleźć ten jeden ważny.
Ten koszt to ciche ograniczenie stojące za dużą częścią dobrego projektowania MCP. Serwer, który zwraca dziesięć tysięcy wierszy, nie okazał hojności; okazał brak manier. Host, który przed pierwszą wiadomością ładuje pełne definicje dwustu narzędzi, wydał sporą część budżetu na jadłospisy. Dobre serwery zwracają mniej i wskazują, gdzie jest więcej. Dobre hosty ładują definicje narzędzi leniwie i pozwalają modelowi wyszukać to, czego potrzebuje. Obie idee spotkasz jeszcze w dalszych częściach.
Wynika z tego praktyczny nawyk. Oceniając serwer, nie pytaj tylko, czy potrafi wykonać zadanie. Zapytaj, ile kontekstu na to wydaje. Wywołaj narzędzie ręcznie i spójrz, jak duże jest to, co wraca. Policz narzędzia, które ogłasza, i przeczytaj ich opisy tak, jakbyś był modelem z małym biurkiem i nieprzekraczalnym terminem. Serwer, który odpowiada dwustoma słowami tam, gdzie konkurent odpowiada dwoma tysiącami, nie jest mniej zdolny. Jest bardziej taktowny, a taktowne serwery dają lepsze odpowiedzi, bo modelowi zostaje miejsce na myślenie.
Protokół przenosi kontekst. Twoim zadaniem jest dopilnować, żeby przenosił go we właściwej ilości. Lejek, nie hydrant.
Ryc. 6 · Kontekst jest produktem. Narzędzia, zasoby i prompty spływają do skończonego okna: zwracaj mniej, linkuj więcej.
Rozdział 7 · Część I
Pożyczone idee, uczciwie podpisane
Dobre standardy są w większości pożyczone, a MCP uczciwie przyznaje się do swoich długów. Najwyraźniejszy z nich zaciągnął u Language Server Protocol, który dekadę wcześniej rozwiązał uderzająco podobny problem dla edytorów kodu. Przed LSP każdy edytor potrzebował osobnej wtyczki do każdego języka, żeby mieć podpowiadanie, przejście do definicji i czerwone wężyki pod błędami. Po nim zespół języka pisał jeden serwer języka, a każdy edytor mówiący protokołem dostawał te funkcje. N na M stało się N plus M. Brzmi znajomo?
Projektanci MCP wzięli coś więcej niż arytmetykę. Wzięli kształt. W LSP klient, czyli edytor, uruchamia serwer, często jako podproces rozmawiający przez standardowe wejście i wyjście, a obaj wymieniają komunikaty JSON-RPC. Zaczynają od uzgadniania przy inicjalizacji, w którym każda strona deklaruje swoje możliwości, żeby żadna nie musiała zgadywać, co obsługuje druga. Dalej płyną żądania, odpowiedzi i powiadomienia w obu kierunkach. Jeśli kiedykolwiek debugowałeś serwer języka, rozumiesz z MCP więcej, niż ci się wydaje.
Drugi dług to JSON-RPC 2.0, mała, stara i celowo nudna specyfikacja zdalnych wywołań procedur zakodowanych w JSON. Komunikat jest albo żądaniem z nazwą metody, parametrami i identyfikatorem, albo odpowiedzią niosącą wynik lub błąd dla tego identyfikatora, albo powiadomieniem, czyli żądaniem, które nie oczekuje odpowiedzi. To niemal wszystko. MCP dokłada na wierzch własne metody, takie jak listowanie narzędzi czy odczyt zasobów, ale koperta to niezmieniony JSON-RPC. Biblioteki do niego istnieją w każdym języku, co jest jednym z powodów, dla których serwery MCP tak szybko pojawiły się w tylu językach.
Nikt nie zbiera laurów za wynalezienie koperty. Wszyscy korzystają na tym, że nie trzeba jej wymyślać od nowa.
Inne długi są mniej bezpośrednie. OAuth dostarcza opowieść o autoryzacji dla serwerów zdalnych, i to w całości, a nie tylko w duchu. JSON Schema opisuje wejścia i wyjścia narzędzi. URI nazywają zasoby. Server-sent events niosą strumienie przez HTTP. Żadnej z tych rzeczy nie wynaleziono dla MCP i właśnie w tym tkwi ich wartość: każda przychodzi z narzędziami, dokumentacją i pokoleniem inżynierów, którzy znają już jej ostre krawędzie.
Dlaczego praktyka miałby obchodzić rodowód? Bo pożyczone idee przychodzą z pożyczonymi odpowiedziami. Kiedy zastanawiasz się, jak obsłużyć anulowane żądanie, światy LSP i JSON-RPC mają na ten temat zdanie. Kiedy zastanawiasz się, jak zweryfikować token, świat OAuth ma za sobą dekadę bolesnych lekcji, wiele z nich spisanych w formie biuletynów bezpieczeństwa. Jeden dobry artykuł o projektowaniu serwerów języka zrobi z ciebie lepszego autora serwerów MCP niż dziesięć zdyszanych wpisów o agentach.
Część wspólna to protokół, a protokół to w większości część wspólna. To nie zarzut. Najlepszy komplement, jaki można prawić standardowi, to stwierdzić, że jego elementom ufano, zanim ktokolwiek je złożył w całość.
Ryc. 7 · Pożyczone idee, uczciwie podpisane. Warstwy MCP i to, co każda pożycza od LSP, JSON-RPC, SSE, JSON Schema, URI i OAuth.
Rozdział 8 · Część I
Czym MCP nie jest
Każda udana technologia przyciąga obietnice, których nigdy nie składała. MCP zebrał swoją porcję, więc warto poświęcić rozdział temu, czym nie jest. Oszczędza to spotkań.
Nie jest frameworkiem agentowym. MCP nie decyduje, kiedy wywołać narzędzie, jak zaplanować wieloetapowe zadanie, jak ponawiać próby ani kiedy przestać. Te wybory należą do hosta i do modelu w jego środku. Framework może używać MCP do sięgania po narzędzia i wiele to robi, ale protokół nie ma zdania o pętlach, pamięci ani rozumowaniu. Jeśli wybierasz między MCP a frameworkiem agentowym, źle odczytałeś jedno z nich.
Nie zastępuje twojego API. Serwer MCP zwykle stoi przed istniejącym API i tłumaczy je na kształt, z którego model potrafi dobrze korzystać. API nadal istnieje, nadal obsługuje twoją aplikację webową i partnerów, nadal niesie prawdziwą logikę biznesową. Serwer, który tę logikę powiela, zamiast ją wywoływać, z czasem się rozjedzie. Myśl o serwerze jak o dobrze poinstruowanej recepcjonistce, a nie jak o drugim budynku.
Nie jest modelem bezpieczeństwa. MCP określa, jak powinna działać autoryzacja dla serwerów zdalnych, i daje hostom informacje potrzebne, by poprosić o zgodę. Nie sprawi, że złośliwy serwer stanie się uczciwy, niedbały – staranny, a model – odporny na instrukcje ukryte w danych. Bezpieczeństwo to coś, co budujesz za pomocą MCP, z hostów, serwerów, tokenów i polityk. Nie jest czymś, co MCP wręcza ci przez sam fakt instalacji.
Protokół mówi ci, jak rozmawiać. Nie powie ci, komu ufać.
Nie jest funkcją modelu. Modele trenuje się do używania narzędzi, ale MCP żyje całkowicie poza modelem, w oprogramowaniu wokół niego. Dlatego ten sam serwer działa z różnymi modelami i dlatego host może obsługiwać MCP z modelem, który nigdy o nim nie słyszał.
Nie jest sklepem, choć rejestry istnieją; nie jest platformą hostingową, choć wiele firm chętnie postawi ci serwer; i nie jest gwarancją jakości, choć ludzie czasem traktują samo istnienie serwera jako dowód, że działa. Serwer to kod, który ktoś napisał. Część jest znakomita. Część powstała w jedno popołudnie i nikt jej potem nie dotknął.
Czym więc jest? Protokołem: precyzyjnym porozumieniem co do komunikatów, ich kolejności i znaczenia, zawartym między klientem działającym w imieniu hosta a serwerem oferującym możliwości. To skromniejsza deklaracja niż szum wokół niego i znacznie trwalsza. Gdy ktoś na spotkaniu proponuje MCP jako rozwiązanie problemu, zadaj najpierw jedno pytanie: czy to jest problem dwóch programów, które muszą uzgodnić, jak ze sobą rozmawiać? Jeśli tak, MCP może pomóc. Jeśli nie, to złe narzędzie, choćby akronim był najmodniejszy.
Ryc. 8 · Czym MCP nie jest. Sześć rzeczy, którymi MCP nie jest, i dlaczego; czym jest: protokołem między klientem a serwerem.
Rozdział 9 · Część I
Kształt ekosystemu
Protokół sam w sobie jest dokumentem. Ekosystem to to, co się dzieje, gdy implementuje go tylu ludzi, że implementowanie staje się domyślnym wyborem. MCP przekroczył tę granicę szybko i dobrze znać głównych mieszkańców, zanim zaczniesz czegokolwiek szukać.
Najliczniejsze są serwery. Niektóre są oficjalne, zbudowane i utrzymywane przez firmę, której produkt opakowują: własny serwer systemu zgłoszeń, serwer dostawcy chmury, serwer firmy płatniczej. Niektóre są społecznościowe, często dla produktów, które oficjalnego serwera jeszcze nie mają, i wahają się od znakomitych po porzucone. Niektóre są wewnętrzne, zbudowane przez firmy dla własnych systemów i nigdy nieopublikowane. Przy wyborze serwera te trzy kategorie niosą bardzo różne oczekiwania co do wsparcia i bezpieczeństwa, a ty powinieneś wiedzieć, z którą masz do czynienia.
Hosty to aplikacje, które łączą się z serwerami w imieniu użytkownika i modelu. Należą do nich asystenci czatowi na desktopie i w przeglądarce, agenci programistyczni w terminalu i w IDE oraz rosnąca liczba narzędzi biznesowych, które po cichu stały się hostami, bo dodały asystenta. Hosty różnią się tym, które części protokołu obsługują. Niemal wszystkie obsługują narzędzia. Mniej obsługuje każdą funkcję po stronie klienta. Część szósta oprowadza po najważniejszych.
Pomiędzy nimi siedzą SDK. Oficjalne SDK istnieją dla głównych języków, utrzymywane równolegle ze specyfikacją, i zajmują się nudnymi częściami: ramkowaniem komunikatów, uzgadnianiem połączenia, negocjacją możliwości, transportami. Większość serwerów, które spotkasz, powstała na którymś z nich. Większość serwerów, które zbudujesz, też powinna.
Ekosystemy budują ludzie, którzy rozwiązują własny problem w sposób, który przypadkiem rozwiązuje i twój.
Rejestry to sposób, w jaki ktokolwiek cokolwiek znajduje. Istnieje oficjalny rejestr metadanych serwerów, prowadzony jawnie, na którym mogą budować inne katalogi i spisy w hostach. Są kuratorowane katalogi wewnątrz głównych hostów, gdzie administrator może włączyć sprawdzony konektor, a nikt nie musi dotykać pliku konfiguracyjnego. Są też nieformalne listy, które wyrastają w każdym ekosystemie, jedne starannie prowadzone, inne zbudowane głównie z entuzjazmu. Odkrywaniem zajmuje się porządnie część dziewiąta.
Efekt sieciowy jest prawdziwy i działa w obie strony. Każdy nowy host podnosi wartość każdego istniejącego serwera, a każdy nowy serwer czyni każdy host bardziej użytecznym. Ta pętla sprawiła, że MCP się rozprzestrzenił, i ona też odpowiada za problem jakości w ekosystemie: kiedy zbudowanie serwera jest łatwe, a opublikowanie darmowe, serwerów przybywa szybciej, niż ktokolwiek zdoła je sprawdzić.
Twój praktyczny ruch na ten tydzień to mała inwentaryzacja. Spisz hosty, których twój zespół już używa, a przy każdym serwery, z którymi się łączy. Zaznacz, które są oficjalne, które społecznościowe, a które wewnętrzne. Większość zespołów, które to robią, zaskakują obie listy. Zaskoczenie jest w porządku. Niewiedza to wersja droższa.
Ryc. 9 · Kształt ekosystemu. Ekosystem: serwery, hosty, SDK i rejestry, powiązane dwukierunkowym efektem sieciowym.
Rozdział 10 · Część I
Twoje pierwsze dziesięć minut
Teoria jest przyjemna, ale nic nie uczy MCP tak, jak oglądanie na żywo wywołania narzędzia. Poświęć na to teraz dziesięć minut, a kolejne dziewięćdziesiąt rozdziałów nabierze więcej sensu.
Wybierz host, którego już używasz. Jeśli to Claude Code, otwórz terminal w projekcie i dodaj serwer poleceniem claude mcp add; jeśli to desktopowa aplikacja czatowa, znajdź jej ustawienia konektorów albo rozszerzeń. Wybierz serwer, którego zadanie rozumiesz w całości i którego promień rażenia jest niewielki: serwer systemu plików skierowany na folder roboczy do zabawy, serwer dokumentacji dla znanej ci biblioteki, konektor tylko do odczytu do narzędzia, z którego korzystasz na co dzień. Omijaj wszystko, co potrafi wysyłać maile albo przelewać pieniądze. Uczysz się, a nie bierzesz udziału w castingu.
Po podłączeniu sprawdź, czy host go widzi. Większość hostów pokazuje podłączone serwery i ich narzędzia w jakimś oczywistym miejscu; w Claude Code polecenie /mcp wypisuje je razem ze statusem. Przeczytaj nazwy i opisy narzędzi. Dokładnie to przeczyta model, więc warto spojrzeć na nie jego oczami. Czy opisy są jasne? Czy wiedziałbyś, kiedy użyć każdego z nich?
Teraz zadaj pytanie, które wymaga serwera. Nie „użyj narzędzia systemu plików”, bo to niczego cię nie nauczy, tylko prawdziwe pytanie, którego odpowiedź kryje się za serwerem: które pliki w tym folderze wspominają o fakturach albo co dokumentacja mówi o ponawianiu prób. Obserwuj, co się dzieje. Host pokaże prośbę modelu o narzędzie, często razem z argumentami, i może poprosić cię o zgodę. Zatwierdź. Potem spójrz na wynik, który zwrócił serwer, zanim model go streścił.
Pierwsze wywołanie narzędzia to sztuczka magiczna. Drugie to mechanizm. Postaraj się szybko dotrzeć do drugiego.
Ostatni krok to ten, który ludzie pomijają. Sprawdź. Porównaj odpowiedź ze źródłem na własną rękę. Czy model wywołał narzędzie, którego się spodziewałeś, z sensownymi argumentami? Czy serwer zwrócił to, co ty byś zwrócił? Czy streszczenie zgadzało się z wynikiem, czy model coś dohaftował? Kalibrujesz trzy rzeczy naraz: jakość serwera, osąd modelu i własne wyczucie, na ile ufać tej parze.
A potem zrób jeszcze jedno. Zadaj pytanie, na które serwer nie zna odpowiedzi, i zobacz, czy model to przyzna, czy coś wymyśli. Dobre połączenie powie, że nie udało mu się znaleźć informacji. Słabe zmyśli ją z pełnym przekonaniem. Wiedza o tym, które masz, jest warta więcej niż jakikolwiek benchmark.
Jeśli wykonałeś te kroki, rozumiesz pętlę protokołu lepiej niż większość ludzi, którzy o nim mówią: odkryj, zapytaj, wywołaj, zwróć. Wszystko inne w tej książce to szczegóły dotyczące jednego z tych czterech słów plus kwestie bezpieczeństwa, które pojawiają się w chwili, gdy podłączysz coś ciekawszego niż folder do zabawy. Ciesz się folderem do zabawy, póki możesz.
Ryc. 10 · Twoje pierwsze dziesięć minut. Pierwsza sesja: podłącz mały serwer, zapytaj, zatwierdź, przeczytaj surowy wynik, sprawdź.
Darmowy fragment · Część I
Czytaj dalej
Przeczytałeś pierwsze 10 z 100 rozdziałów książki Przewodnik praktyka po MCP. Pełne wydanie zawiera wszystkie rozdziały i plansze, w PDF i EPUB, po angielsku, francusku, polsku i hiszpańsku.