Moduł 4 35 min Zaawansowany

MCP Servers - łączenie ze światem

Czego się nauczysz
  • Rozumiesz architekturę MCP (host → client → server)
  • Potrafisz podłączyć i skonfigurować MCP server
  • Znasz popularne serwery MCP i ich zastosowania
  • Wiesz, jak zacząć tworzyć własny MCP server

Czym jest MCP

Model Context Protocol (MCP) to otwarty standard łączenia modeli AI z zewnętrznymi narzędziami i źródłami danych.

Architektura:

Host (Claude Code) → Client (protokół MCP) → Server (GitHub, Slack, baza...)

3 prymitywy MCP:

  • Tools - akcje, które Claude może wykonać (np. "utwórz issue na GitHub")
  • Resources - dane, do których Claude ma dostęp (np. "zawartość pliku z Google Drive")
  • Prompts - szablony promptów udostępnione przez serwer

Konfiguracja

Serwery MCP konfiguruje się w .mcp.json (root projektu) lub ~/.claude.json (globalnie):

{
  "mcpServers": {
    "nazwa-serwera": {
      "command": "npx",
      "args": ["-y", "nazwa-paczki"],
      "env": {
        "API_KEY": "twoj-klucz"
      }
    }
  }
}

Zarządzanie w sesji: /mcp - interaktywne dodawanie/usuwanie serwerów.

Popularne MCP Servers

GitHub (oficjalny)

Operacje na repozytoriach, issues, pull requestach.

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxx..."
      }
    }
  }
}

Filesystem

Dostęp do plików poza bieżącym katalogiem.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y",
        "@modelcontextprotocol/server-filesystem",
        "/ścieżka/do/katalogu"]
    }
  }
}

Wyszukiwanie w internecie w czasie rzeczywistym.

{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": ["-y",
        "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "BSAxx..."
      }
    }
  }
}

PostgreSQL / Supabase

Bezpośredni dostęp do bazy danych.

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y",
        "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://user:pass@host:5432/db"
      }
    }
  }
}

Inne popularne

  • Slack - wiadomości, kanały
  • Google Drive - dokumenty
  • Notion - notatki i bazy
  • Linear - zarządzanie zadaniami
  • Sentry - monitoring błędów
  • Puppeteer/Playwright - automatyzacja przeglądarki

Instalacja MCP - krok po kroku

  1. Znajdź serwer: modelcontextprotocol.io/docs/servers lub npm
  2. Dodaj konfigurację do .mcp.json
  3. Ustaw zmienne środowiskowe (klucze API) w polu env
  4. Zrestartuj Claude Code lub wpisz /mcp
  5. Zweryfikuj: "Jakie narzędzia MCP mam dostępne?"

Tworzenie własnego MCP (podstawy)

Minimalny serwer w TypeScript:

import { Server } from
  "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from
  "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server({
  name: "moj-serwer",
  version: "1.0.0"
}, { capabilities: { tools: {} } });

server.setRequestHandler("tools/list", async () => ({
  tools: [{
    name: "powitanie",
    description: "Generuje powitanie",
    inputSchema: {
      type: "object",
      properties: {
        imie: { type: "string" }
      },
      required: ["imie"]
    }
  }]
}));

server.setRequestHandler("tools/call", async (req) => {
  if (req.params.name === "powitanie") {
    return {
      content: [{
        type: "text",
        text: `Cześć, ${req.params.arguments.imie}!`
      }]
    };
  }
});

const transport = new StdioServerTransport();
await server.connect(transport);

Ćwiczenie praktyczne: Podłącz i przetestuj 2 MCP servers:

  1. Filesystem: Podłącz server filesystem z dostępem do katalogu domowego. Zapytaj Claude Code: "Jakie projekty mam w ~/projects?"
  2. Brave Search: Podłącz Brave Search. Zapytaj: "Jaki jest najnowszy release Node.js?"

Bonus: Znajdź i zainstaluj MCP server przydatny w Twojej pracy.

Co dalej

W następnej lekcji poznasz subagentów - sposób na delegowanie zadań do izolowanych kontekstów.