Utwórz serwer MCP dla Claude Code — praktyczny przewodnik krok po kroku

CometAPI
AnnaNov 22, 2025
Utwórz serwer MCP dla Claude Code — praktyczny przewodnik krok po kroku

Model Context Protocol (MCP) to otwarty standard, który pozwala modelom takim jak Claude od Anthropic oraz narzędziom deweloperskim takim jak Claude Code wywoływać zewnętrzne narzędzia, źródła danych i prompty w bezpieczny, ustandaryzowany sposób.

Ten przewodnik przeprowadzi Cię przez zbudowanie własnego serwera MCP od podstaw, umożliwiając Claude Code dostęp do niestandardowych funkcji i znaczne rozszerzenie możliwości daleko poza wbudowane funkcje.

Czym jest Model Context Protocol (MCP)?

MCP (Model Context Protocol) to otwarta specyfikacja zaprojektowana, aby standaryzować sposób, w jaki klienci modeli językowych (tacy jak Claude, Claude Code czy inne frontend’y LLM) łączą się z serwerami narzędzi i źródłami danych. Pomyśl o MCP jak o „porcie USB-C dla LLM-ów”: definiuje schemat transportu/JSON-RPC oraz wspólny sposób, w jaki serwery publikują trzy typy możliwości:

  • Resources — dane w formie pliku lub dokumentu, które klient może odczytać (np. wiersz bazy danych, plik tekstowy, payload JSON).
  • Tools — wywoływalne funkcje, które model może poprosić hosta o wykonanie (za zgodą użytkownika).
  • Prompts — wielokrotnego użytku szablony promptów lub przepływy pracy, które model/klient może wywołać.

MCP obsługuje wiele transportów (stdio, HTTP, SSE) i dostarcza schemat, SDK oraz przykładowe serwery, dzięki czemu nie musisz samodzielnie wymyślać formatu komunikacji. Protokół jest utrzymywany publicznie (spec + SDK), a także posiada samouczki i galerię przykładowych serwerów, co przyspiesza adopcję.

Jak jest zaprojektowany MCP?

Architektura MCP jest celowo prosta i modułowa: podstawowe elementy to serwery MCP, klienci MCP oraz transporty przenoszące komunikaty opakowane w JSON-RPC między nimi. Poniżej znajdują się główne komponenty, z którymi będziesz pracować, tworząc serwer dla Claude Code (lub innych klientów MCP).

Serwer, klient i protokół

  • MCP server — Usługa, która publikuje narzędzia, zasoby i prompty. Narzędzia mogą wykonywać efekty uboczne lub pobierać dane; zasoby udostępniają treści tylko do odczytu; prompty to szablony, z których klient może korzystać, prosząc model o próbki.
  • MCP client (host) — Zwykle część hosta LLM (np. Claude Code, wtyczka do VS Code, klient przeglądarkowy). Odkrywa dostępne serwery, przedstawia opisy narzędzi modelowi i kieruje wywołania inicjowane przez model do serwerów.
  • Protocol — Komunikaty są kodowane jako JSON-RPC; specyfikacja definiuje zdarzenia cyklu życia, odkrywanie narzędzi, wywołania, uzupełnienia/próbkowanie oraz sposób, w jaki ustrukturyzowane wyniki są odsyłane do klienta i modelu.

Wzorzec komunikacji (co dzieje się podczas użycia narzędzia)

  1. Klient wysyła wiadomość użytkownika do modelu.
  2. Model analizuje kontekst i decyduje się wywołać narzędzie udostępnione przez MCP (lub wiele narzędzi).
  3. Klient przekazuje wywołanie narzędzia do serwera MCP przez wybrany transport.
  4. Serwer wykonuje narzędzie i zwraca wyniki.
  5. Model otrzymuje wynik narzędzia i komponuje finalną odpowiedź dla użytkownika.

Prymitywy implementacyjne

  • Wiadomości JSON-RPC podążają za schematem MCP.
  • Definicje narzędzi są publikowane w odpowiedziach odkrywania serwera, aby klienci mogli zaprezentować je w UI.
  • Resources są referencjonowane przez składnię @source:path przez klientów (np. @postgres:...), co pozwala modelom odwoływać się do zewnętrznych treści bez wprowadzania ogromnych danych bezpośrednio do promptu.

Dlaczego integrować Claude Code z serwerami MCP?

Claude Code to oferta Anthropic skoncentrowana na przepływach pracy związanych z kodem i deweloperami (integracja z edytorem/IDE, zrozumienie kodu itd.). Udostępnienie wewnętrznych narzędzi (wyszukiwanie w źródłach, uruchamianie CI, system zgłoszeń, prywatne rejestry) przez serwery MCP pozwala Claude Code wywoływać je jako narzędzia pierwszej klasy w rozmowach o kodzie i przepływach agentów.

Integracja Claude Code z serwerami MCP odblokowuje praktyczne, produkcyjnie istotne możliwości dla agenta kodującego:

1. Pozwól modelowi działać na rzeczywistych systemach

Claude Code może poprosić serwer MCP o zapytanie trackerów zgłoszeń, uruchamianie zapytań do bazy danych, odczyt dużych dokumentów lub tworzenie PR-ów na GitHubie — umożliwiając end-to-endową automatyzację w obrębie sesji kodowania. Jest to wyraźnie wspierane przez dokumentację Claude Code (przykłady: zapytania do Postgresa, Sentry czy tworzenie PR-ów).

2. Odciąż duże dane i wyspecjalizowaną logikę

Zamiast osadzać każde źródło danych w promptcie (co zużywa tokeny), publikujesz dane i narzędzia przez MCP. Model wywołuje narzędzie, otrzymuje ustrukturyzowaną odpowiedź i rozumuje na jej podstawie — zmniejsza to zużycie tokenów i pozwala serwerom obsługiwać ciężkie operacje (zapytania do DB, długie odczyty plików, uwierzytelnianie).

3. Bezpieczeństwo i nadzór

MCP centralizuje kontrolę dostępu i audyt na poziomie serwera, umożliwiając organizacjom tworzenie białych list zatwierdzonych serwerów, kontrolę dostępnych narzędzi oraz ograniczanie wyjść. Claude Code wspiera również korporacyjną konfigurację MCP i zgodę per zakres.

4. Ponowne użycie i ekosystem

Serwery MCP są wielokrotnego użytku między klientami i zespołami. Zbuduj raz, a wiele klientów Claude/LLM może korzystać z tych samych usług (lub podmieniać implementacje).

Co jest potrzebne przed rozpoczęciem?

Minimalne wymagania

  • Maszyna deweloperska z Pythonem 3.10+ (w przykładzie użyjemy Pythona). Alternatywnie Node/inne języki są wspierane przez SDK MCP.
  • uv (narzędzie Astral) lub równoważny runner do uruchamiania serwerów MCP przez stdio (samouczek MCP używa uv). Kroki instalacji poniżej.
  • Zainstalowany Claude Code lub dostęp do klienta Claude (desktop lub CLI), aby zarejestrować i przetestować serwer; ewentualnie dowolny klient zgodny z MCP. Claude Code obsługuje HTTP, SSE oraz lokalne serwery stdio.
  • Uwaga dotycząca bezpieczeństwa: Dodawaj do Claude Code tylko zaufane serwery MCP w ustawieniach zespołowych lub firmowych — MCP przyznaje serwerom dostęp do wrażliwych danych, a ryzyko wstrzyknięć promptów istnieje, jeśli serwer zwraca złośliwe treści.

Jak zainstalować i zweryfikować CLI Claude Code

To jest Przewodnik instalacji i użycia Claude Code.

1) Krótkie podsumowanie — zalecane metody instalacji

Użyj nattywnego instalatora (zalecane) lub Homebrew na macOS/Linux. NPM jest dostępny, jeśli potrzebujesz instalacji opartej na Node. Windows ma instalatory PowerShell/CMD. Źródło: oficjalna dokumentacja Claude Code i GitHub.


2) Wymagania wstępne

  • macOS 10.15+, Ubuntu 20.04+/Debian 10+, lub Windows 10+ (na Windows zalecany WSL).
  • Node.js 18+ wymagany tylko dla metody instalacji przez NPM.

3) Polecenia instalacji (wybierz jedno)

Native (zalecane — bez zależności od Node), macOS / Linux / WSL:

curl -fsSL https://claude.ai/install.sh | bash
# optional: install latest explicitly

curl -fsSL https://claude.ai/install.sh | bash -s latest
# or install a specific version

curl -fsSL https://claude.ai/install.sh | bash -s 1.0.58

Windows PowerShell:

irm https://claude.ai/install.ps1 | iex
# or for latest: & (::Create((irm https://claude.ai/install.ps1))) latest

(To są oficjalne natywne skrypty instalatora).

NPM (jeśli chcesz globalną instalację opartą na Node):

# requires Node.js 18+

npm install -g @anthropic-ai/claude-code

Nie używaj sudo npm install -g — ostrzeżenie przed globalnymi instalacjami z sudo (problemy z uprawnieniami/bezpieczeństwem). Jeśli napotkasz problemy z uprawnieniami, użyj nvm lub popraw prefix globalny npm zamiast korzystać z sudo.

4) Zweryfikuj, że binarka została zainstalowana (podstawowe sprawdzenia)

Uruchom lokalnie bezpośrednio po instalacji:

# is the command on PATH?

which claude

# version (or -v)

claude --version
# or

claude -v

# help (sanity check)

claude --help

Oczekiwane: which pokazuje ścieżkę (np. /usr/local/bin/claude lub ~/.nvm/.../bin/claude), a claude --version wypisuje string podobny do semver. Dokumentacja i README pokazują claude jako główny punkt wejścia CLI.


5) Zweryfikuj kondycję instalacji i konfigurację (zalecane sprawdzenia)

a) claude doctor, uruchom:

claude doctor

Wbudowana diagnostyka sprawdza typ instalacji, częste problemy (np. uprawnienia npm), zależności takie jak ripgrep, i sugeruje poprawki. Dokumentacja wyraźnie zaleca uruchomienie claude doctor po instalacji.

b) Wykonaj smoke test (nieinteraktywny)

W katalogu projektu:

cd /path/to/your/project
claude -p "Explain this project in 3 sentences"

To używa trybu print (-p), aby wysłać pojedynczy prompt i zakończyć; dobre do CI lub szybkich testów funkcjonalnych.

c) Weryfikacja uwierzytelnienia (upewnij się, że CLI może połączyć się z Anthropic)

Claude Code obsługuje kilka przepływów uwierzytelniania (Console OAuth, klucz API, integracje dostawców). Typowe sprawdzenia:

  1. Jeśli używasz klucza API (CI/headless/zmienna środowiskowa lokalnie):
export ANTHROPIC_API_KEY="sk-..."
# then

claude auth status
claude auth whoami    # or `claude auth whoami` / `claude whoami` depending on version

Możesz użyć klucza API CometAPI, aby korzystać z Claude Code. Używanie API Claude przez CometAPI da Ci 20% zniżki.

  1. Jeśli użyłeś OAuth przez konsolę — uruchom:
claude auth status
claude auth whoami

Powinieneś zobaczyć informacje o koncie/planie lub potwierdzenie, że jesteś uwierzytelniony.

Przygotowanie środowiska krok po kroku

Poniżej znajdują się konkretne kroki przygotowania dwóch popularnych stosów deweloperskich (TypeScript i Python), a następnie szybkie testy, aby upewnić się, że wszystko działa.

H3 — A. Konfiguracja TypeScript/Node (najszybsza droga)

  1. Utwórz projekt i zainstaluj SDK:
mkdir mcp-demo && cd mcp-demo
npm init -y
npm install @modelcontextprotocol/sdk express zod
npm install --save-dev typescript tsx @types/node @types/express
  1. Utwórz server.ts. (Pełny przykład znajduje się w sekcji „Jak szybko zbudować…”.)
  2. Uruchom:
npx -y tsx server.ts
  1. Przetestuj lokalnie za pomocą MCP Inspector lub dodaj do Claude Code:
npx @modelcontextprotocol/inspector
# or (for Claude Code)

claude mcp add --transport http my-server http://localhost:3000/mcp

(Inspector i polecenia Claude pozwalają zweryfikować discovery i wywoływać narzędzia.)

Jak szybko zbudować serwer MCP dla Claude Code?

szybka lista kontrolna

  1. Uruchom serwer (zalecany Streamable HTTP): node server.ts lub uvicorn server:app.
  2. Ze swojej maszyny deweloperskiej, albo:
  • Użyj MCP Inspector, aby zweryfikować (npx @modelcontextprotocol/inspector) i potwierdzić tools/list oraz resources/list; albo
  • Dodaj serwer do Claude Code: claude mcp add --transport http <name> http://<host>:<port>/mcp (lub skorzystaj z przepływów w interfejsie web, jeśli Twój klient wspiera zdalne MCP).

Jeśli planujesz użyć konektora Messages API Anthropic dla zdalnego MCP (bez osobnego klienta), przeczytaj dokumentację Claude — może być wymagany nagłówek w wersji beta (sprawdź dokumentację pod kątem dokładnego nagłówka i aktualnego statusu wsparcia).

Poniżej znajdują się dwa kompletne, lecz kompaktowe przykłady serwerów, które możesz skopiować, uruchomić i podłączyć do Claude Code (lub MCP Inspector). Przykład TypeScript używa Express + SDK TypeScript; przykład Python pokazuje montowanie FastAPI.

Uwaga: poniższy kod podąża za publicznymi przykładami SDK i jest celowo minimalny dla przejrzystości. W produkcji dodaj uwierzytelnianie, logowanie, ograniczanie tempa i walidację wejść wykraczającą poza domyślne w SDK.


Example 1: TypeScript + Express (Streamable HTTP)

Utwórz server.ts (komplet):

// server.ts
import express from "express";
import * as z from "zod/v4";
import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";

const server = new McpServer({ name: "claude-code-demo", version: "0.1.0" });

// Register a simple tool: add two numbers
server.registerTool(
  "add",
  {
    title: "Add",
    description: "Add two numbers a and b",
    inputSchema: { a: z.number(), b: z.number() },
    outputSchema: { result: z.number() }
  },
  async ({ a, b }) => {
    const output = { result: a + b };
    return {
      content: ,
      structuredContent: output
    };
  }
);

// Register a resource: greet user (dynamic)
server.registerResource(
  "greeting",
  new ResourceTemplate("greeting://{name}", { list: undefined }),
  { title: "Greeting", description: "Return a greeting for the name" },
  async (uri, params) => {
    return {
      contents: 
    };
  }
);

// Express + Streamable HTTP transport
const app = express();
app.use(express.json());

app.post("/mcp", async (req, res) => {
  const transport = new StreamableHTTPServerTransport({ enableJsonResponse: true });
  // Close transport when connection closes
  res.on("close", () => transport.close());
  await server.connect(transport);
  await transport.handleRequest(req, res, req.body);
});

const port = parseInt(process.env.PORT || "3000", 10);
app.listen(port, () => console.log(`MCP server listening: http://localhost:${port}/mcp`));

Uruchom:

npm install
npx -y tsx server.ts

Następnie podłącz w Claude Code (przykład):

# Add the remote server to your Claude Code MCP list (local dev)

claude mcp add --transport http my-demo http://localhost:3000/mcp

Ten przykład jest dostosowany z oficjalnego Quick Start SDK TypeScript i pokazuje, jak zarejestrować narzędzia i zasoby, a następnie wystawić je przez Streamable HTTP.


Example 2: Python + FastAPI (FastMCP + Streamable HTTP)

Utwórz server.py (komplet):

# server.py

from fastapi import FastAPI
from mcp.server.fastmcp import FastMCP

app = FastAPI()
mcp = FastMCP("claude-python-demo", stateless_http=True)

# tool: simple sum

@mcp.tool()
def add(a: int, b: int) -> dict:
    """Add two integers"""
    return {"result": a + b}

# resource: simple greeting resource template

@mcp.resource("greeting://{name}")
def greeting(name: str):
    return {"contents": }

# mount the streamable-http MCP endpoint (FastMCP exposes an ASGI app)

app.mount("/mcp", mcp.streamable_http_app())

# optional endpoint to demonstrate other API routes

@app.get("/")
async def root():
    return {"status": "OK"}

Uruchom:

uvicorn server:app --reload --port 8000

Połącz za pomocą Inspector:

npx @modelcontextprotocol/inspector
# In Inspector select Streamable HTTP and enter http://localhost:8000/mcp

Przykłady SDK Pythona i narzędzia FastMCP ułatwiają rejestrowanie funkcji dekorowanych @mcp.tool() i @mcp.resource(), które LLM może odkrywać i wywoływać.


Jak Claude Code faktycznie wywołuje Twoje narzędzia?

Gdy LLM decyduje się użyć narzędzia, klient wysyła wywołanie JSON-RPC do serwera MCP. Serwer wykonuje żądane narzędzie (np. zapytuje DB, uruchamia testy lub wywołuje zewnętrzne API) i zwraca ustrukturyzowaną treść oraz prezentowalną treść. Klient (Claude Code) może następnie włączyć ustrukturyzowany wynik do kontekstu modelu, aby model mógł kontynuować rozumowanie na podstawie wiarygodnych danych — nie tylko tekstowego wyjścia serwera. SDK TypeScript wspiera rejestrowanie inputSchema i outputSchema (zod), dzięki czemu argumenty i wyniki są walidowane i maszynowo typowane.


Jakich narzędzi testowania i debugowania używać?

MCP Inspector

MCP Inspector to oficjalne wizualne narzędzie deweloperskie do testowania serwerów MCP. Pozwala połączyć się z serwerem (stdio, SSE lub streamable-HTTP), wylistować narzędzia, wywołać je ręcznie oraz obejrzeć cykl życia komunikatów JSON-RPC — bezcenne podczas rozwoju. Uruchom go przez npx @modelcontextprotocol/inspector.

Testy lokalne vs zdalne

  • Local (stdio) — szybka pętla iteracji dla aplikacji desktopowych i offline’owego debugowania.
  • Streamable HTTP — testuj z Inspector albo połącz z Claude Code, używając claude mcp add w CLI lub konektora MCP w Messages API do testów zdalnych. Upewnij się, że przekazujesz wymagane nagłówki uwierzytelniające dla swojego serwera.

Podsumowanie

MCP to praktyczny most między nowoczesnymi LLM-ami a systemami, które faktycznie przechowują dane i wykonują działania. W przepływach pracy związanych z kodem integracja Claude Code z serwerem MCP daje modelowi ustrukturyzowany, audytowalny dostęp do repozytoriów, CI, trackerów zgłoszeń i niestandardowych narzędzi — co przekłada się na precyzyjniejszą automatyzację i bezpieczniejsze efekty uboczne. Dzięki oficjalnym SDK w TypeScript i Pythonie, Streamable HTTP do zdalnego hostingu oraz narzędziom takim jak MCP Inspector, można zbudować minimalny serwer w kilka minut i iterować w kierunku wdrożenia produkcyjnego.

Deweloperzy mogą uzyskać dostęp do Claude Sonnet 4.5 API i Claude Opus 4.1 API itd. przez CometAPI, najbardziej aktualna wersja modelu jest zawsze synchronizowana z oficjalną stroną. Aby rozpocząć, sprawdź możliwości modelu w Playground i zapoznaj się z przewodnikiem po API po szczegółowe instrukcje. Przed uzyskaniem dostępu upewnij się, że zalogowałeś się do CometAPI i uzyskałeś klucz API. CometAPI oferuje ceny znacznie niższe niż oficjalne, aby ułatwić integrację.

Gotowy do działania?→ Zarejestruj się w CometAPI już dziś!

Jeśli chcesz poznać więcej porad, przewodników i nowości o AI, obserwuj nas na VK, X i Discord!

Gotowy na obniżenie kosztów rozwoju AI o 20%?

Zacznij za darmo w kilka minut. Dołączone kredyty na bezpłatny okres próbny. Karta kredytowa nie jest wymagana.

Czytaj więcej