# Referencyjne serwery MCP i kiedy ich nie potrzebujesz

URL: https://developertoolkit.ai/pl/ecosystem/mcp/reference-servers/
Description: Siedem serwerów referencyjnych MCP, te zarchiwizowane i ich następcy oraz audyt .mcp.json „najpierw narzędzia natywne” dla Claude Code, Codex i Cursora.

Referencyjne serwery MCP to siedem małych serwerów (Everything, Fetch, Filesystem, Git, Memory, Sequential Thinking i Time), które grupa sterująca MCP utrzymuje po to, by demonstrować protokół, a nie by działały na produkcji. Claude Code, Codex i Cursor same czytają i edytują pliki oraz uruchamiają `git` własnymi narzędziami, więc serwery referencyjne przydają się głównie w klientach czatowych.

Otwierasz repozytorium i znajdujesz `.mcp.json` skopiowany z wpisu na blogu z 2025 roku: `filesystem`, `git`, `github`, `puppeteer` i `sequential-thinking`. Dwa z tych pakietów są przestarzałe, `git` startuje przez `npx @modelcontextprotocol/server-git`, czyli pakiet, którego nie ma w npm, a serwer Filesystem daje agentowi drugą drogę zapisu plików, której twoje reguły uprawnień dla `Edit` w ogóle nie widzą. Ta strona jest dla programistów, którzy chcą oszczędnej i poprawnej konfiguracji, oraz dla tech leadów odpowiedzialnych za wspólną konfigurację MCP zespołu. Jeśli MCP to dla ciebie nowość, przeczytaj najpierw [wprowadzenie do Model Context Protocol](/pl/ecosystem/mcp/).

## Co daje audyt serwerów referencyjnych

- Tabelę siedmiu utrzymywanych serwerów referencyjnych ze zweryfikowanym pakietem, poleceniem uruchomienia i liczbą narzędzi
- Zarchiwizowane serwery (GitHub, PostgreSQL, Puppeteer, Slack i dziewięć innych) wraz z tym, co je zastąpiło
- Audyt istniejącego `.mcp.json`, `.codex/config.toml` lub `.cursor/mcp.json` według zasady „najpierw narzędzia natywne”, z promptem do skopiowania i krokiem weryfikacji
- Przykład, w którym serwer Filesystem jest właściwą odpowiedzią: katalog notatek dla klienta czatowego
- Kiedy Desktop Commander jest wart swojej znacznie szerszej powierzchni uprawnień i jak go ograniczyć

## Które referencyjne serwery MCP są nadal utrzymywane?

README repozytorium `modelcontextprotocol/servers` wymienia siedem serwerów referencyjnych i mówi wprost, po co istnieją: są „intended as **reference implementations** to demonstrate MCP features and SDK usage”, „not as production-ready solutions” (README odczytane 2026-09-26). To samo README odsyła osoby szukające katalogu serwerów do MCP Registry.

| Serwer | Pakiet i polecenie uruchomienia | Narzędzia | Co robi | Potrzebny w Claude Code, Codex lub Cursorze? |
| --- | --- | --- | --- | --- |
| Filesystem | npm `@modelcontextprotocol/server-filesystem`: `npx -y @modelcontextprotocol/server-filesystem DIR [DIR…]` | 13 | Czyta, zapisuje, edytuje, przenosi i wyszukuje pliki w dozwolonych katalogach | Rzadko. Wszystkie trzy mają natywne narzędzia plikowe. Użyj go dla katalogu poza projektem, z węższą powierzchnią niż powłoka |
| Git | PyPI `mcp-server-git`: `uvx mcp-server-git --repository PATH` | 12 | Status, diffy, log, show, add, commit, reset, branch, checkout | Nie. Agenci uruchamiają `git` w powłoce. Serwer nie ma push, pull ani fetch |
| Fetch | PyPI `mcp-server-fetch`: `uvx mcp-server-fetch` | 1 | Pobiera URL i zamienia HTML na Markdown | Rzadko. Claude Code ma narzędzie do pobierania stron, Codex ma `--search`. Zobacz ostrzeżenie o SSRF niżej |
| Memory | npm `@modelcontextprotocol/server-memory`: `npx -y @modelcontextprotocol/server-memory` | 9 | Graf wiedzy z encji, relacji i obserwacji w pliku JSONL | Rzadko. Pamięć projektu należy do `CLAUDE.md` lub `AGENTS.md`, gdzie przechodzi review w gicie |
| Sequential Thinking | npm `@modelcontextprotocol/server-sequential-thinking`: `npx -y @modelcontextprotocol/server-sequential-thinking` | 1 | Narzędzie `sequential_thinking`, które zapisuje ponumerowane myśli z możliwością rewizji | Opcjonalny. Podniesienie poziomu wysiłku (effort) modelu zwykle robi to samo |
| Time | PyPI `mcp-server-time`: `uvx mcp-server-time` | 2 | Bieżący czas i konwersja między strefami IANA | Rzadko. Agent może uruchomić `date` |
| Everything | npm `@modelcontextprotocol/server-everything`: `npx -y @modelcontextprotocol/server-everything` | wiele | Serwer testowy, który ćwiczy każdą funkcję MCP | Nigdy na co dzień. Jest dla osób budujących klientów MCP |

**Wersje i popularność na 2026-09-26:** serwery w TypeScripcie są w wersji npm `2026.8.31`, a serwery w Pythonie w wersji PyPI `2026.8.18` (sprawdzone przez `npm view` i API JSON PyPI). Repozytorium `modelcontextprotocol/servers` ma około 90,6 tys. gwiazdek na GitHubie (API GitHuba, odczyt 2026-09-26, zapisany w dossier MCP tego serwisu). Gwiazdki należą do całego repozytorium, a nie do jednego serwera, więc nic nie mówią o tym, ile osób używa serwera Filesystem.

**Pułapki: nazwy pakietów, które wyglądają dobrze, a są złe (npm i PyPI, sprawdzone 2026-09-26)**

- **`@modelcontextprotocol/server-git`, `-server-fetch` i `-server-time` nie istnieją w npm** (404). Git, Fetch i Time to pakiety Pythona: uruchamiaj je przez `uvx`, nie `npx`.
- **`mcp-server-filesystem` w PyPI zwraca 404.** Filesystem jest tylko w npm.
- **`@modelcontextprotocol/server-github` jest przestarzały** („Package no longer supported”). Podobnie `-server-postgres`, `-server-puppeteer`, `-server-slack`, `-server-gitlab` i `-server-brave-search`. Ich kod leży w repozytorium `servers-archived`.
- **Anthropic nie publikuje w npm żadnych serwerów MCP.** Każdy pakiet `@anthropic/…` czy `@anthropic-ai/mcp` jest wymyślony.

## Które serwery referencyjne zarchiwizowano i co je zastąpiło?

Trzynaście dawnych serwerów referencyjnych leży teraz w `modelcontextprotocol/servers-archived`, którego README zapowiada wprost, że nie będzie już ani poprawek bezpieczeństwa, ani poprawek błędów („No security updates or bug fixes will be provided”). Zarchiwizowany pakiet potrafi startować jeszcze miesiącami, dlatego nieaktualne konfiguracje przeżywają kolejne przeglądy. Zastąp każdy z nich utrzymywanym następcą:

| Zarchiwizowany serwer | Użyj zamiast niego | Gdzie opisujemy to w serwisie |
| --- | --- | --- |
| GitHub | Oficjalny serwer MCP GitHuba (zdalny lub w Dockerze) albo CLI `gh` | [Serwer GitHub MCP](/pl/ecosystem/mcp/github-mcp/) |
| GitLab | Oficjalny serwer MCP GitLaba (beta) | [Serwer GitHub MCP (sekcja o GitLabie)](/pl/ecosystem/mcp/github-mcp/) |
| PostgreSQL, SQLite, Redis | Utrzymywany serwer bazodanowy, domyślnie tylko do odczytu | [Serwery MCP dla baz danych](/pl/ecosystem/mcp/database-mcp/) |
| Puppeteer | Playwright MCP lub Chrome DevTools MCP | [MCP do automatyzacji przeglądarki](/pl/ecosystem/mcp/browser-automation/) |
| Brave Search | Własny serwer Brave, `@brave/brave-search-mcp-server` | [MCP do researchu w sieci](/pl/ecosystem/mcp/web-research-mcp/) |
| Sentry | Oficjalny serwer MCP Sentry | [MCP do obserwowalności](/pl/ecosystem/mcp/observability-mcp/) |
| Slack | Oficjalny zdalny serwer MCP Slacka, instalowany przez wtyczkę `slack` (`slackapi/slack-skills-plugin`, dawniej `slack-mcp-plugin`); README serwerów referencyjnych wskazuje też fork utrzymywany przez Zencoder | [Konfiguracja MCP w Claude Code (wtyczka Slack)](/pl/claude-code/quick-start/mcp-setup/) |
| Google Drive, Google Maps, AWS KB Retrieval, EverArt | Nie polecamy tu następcy. Sprawdź własny serwer dostawcy w MCP Registry | — |

## Jak przeprowadzić audyt .mcp.json według zasady „najpierw narzędzia natywne”?

Zrób audyt, zanim zacznie się etap budowy: konfiguracja MCP decyduje, do jakich narzędzi agent sięgnie, zanim napisze choć linijkę. Rób go, gdy przejmujesz repozytorium, i powtarzaj za każdym razem, gdy ktoś dodaje serwer.

Zasada: **narzędzie natywne wygrywa z serwerem MCP, który robi to samo.** Narzędzia natywne działają w modelu uprawnień agenta. Zdublowane narzędzie MCP dostaje własną nazwę i własne reguły: w Claude Code reguła deny dla `Edit` nie obejmuje `mcp__filesystem__write_file`.

1. **Wypisz, co jest skonfigurowane.** Uruchom listowanie dla każdego narzędzia, którego używa zespół.

    **Claude Code**

    ```bash
    claude mcp list          # health-checks approved servers; unapproved .mcp.json entries show as pending
    ```
    W sesji `/context` pokazuje, ile okna kontekstu zajmują narzędzia MCP. Zanotuj tę liczbę.

    **Codex**

    ```bash
    codex mcp list           # name, command, args, enabled or disabled
    codex mcp get git --json # full entry, including enabled_tools and disabled_tools
    ```
    W sesji `/mcp` wypisuje narzędzia MCP załadowane przez Codex (`/mcp verbose` po szczegóły).

    **Cursor**

    Otwórz `.cursor/mcp.json` w projekcie i `~/.cursor/mcp.json` w katalogu domowym. Oba mają ten sam kształt `mcpServers` co `.mcp.json`.

2. **Sklasyfikuj każdy serwer.** Przypisz każdy wpis do jednej z czterech grup:

    | Grupa | Test | Działanie |
    | --- | --- | --- |
    | Duplikat | Narzędzie natywne robi to samo (pliki, `git`, `date`, pobranie strony) | Usuń |
    | Zarchiwizowany lub przestarzały | Pakiet jest na liście pułapek wyżej | Zastąp następcą albo usuń |
    | Uzasadniona luka | Sięga tam, gdzie agent nie sięga: katalog poza projektem, API, baza danych | Zostaw, zawężony do minimum katalogów lub narzędzi |
    | Nieznany | Nikt w zespole nie wie, do czego służy | Usuń. Kto go potrzebuje, doda go ponownie z uzasadnieniem |

3. **Przekaż klasyfikację agentowi.** Wklej ten prompt w katalogu głównym repozytorium. Agent proponuje zmiany i niczego nie edytuje.

    **Prompt do skopiowania: audyt MCP „najpierw narzędzia natywne”**

    ```text
    Audit the MCP configuration in this repository: .mcp.json, .cursor/mcp.json and .codex/config.toml, whichever exist.
    For every server, report in a table:
    1. name, command and args, and whether the package is npm, PyPI, Docker or a remote URL;
    2. whether the package is deprecated or archived (check `npm view <pkg> deprecated` or the PyPI JSON API; do not guess);
    3. which of your own native tools already does the same job, if any;
    4. a verdict: remove, replace with a maintained server (name it), or keep with narrower scope (say how).
    Flag any Python server launched with npx, any credential written inline, and any Filesystem or Desktop Commander entry whose allowed directory is a home directory or /.
    Do not edit any file. End with the exact commands to apply your verdicts for Claude Code (`claude mcp remove -s project NAME`) and Codex (`codex mcp remove NAME`); for entries in a project .codex/config.toml, give the TOML lines to delete instead.
    ```

4. **Wprowadź werdykty.** Przejrzyj tabelę od agenta, a potem sam usuń lub zawęź wpisy.

    **Claude Code**

    ```bash
    claude mcp remove -s project filesystem
    claude mcp remove -s project sequential-thinking
    ```
    Aby wyłączyć serwer bez usuwania wpisu, użyj w sesji `/mcp disable SERVER_NAME`.

    **Codex**

    ```bash
    codex mcp remove filesystem
    ```
    `codex mcp remove` edytuje `~/.codex/config.toml`; wpisy projektowe usuń z `.codex/config.toml` ręcznie.

    Aby zostawić serwer, ale go ograniczyć, edytuj `~/.codex/config.toml` (albo projektowy `.codex/config.toml`). Codex 0.157.1 przyjmuje przy każdym serwerze klucze `enabled` i `enabled_tools`:

    ```toml
    [mcp_servers.git]
    command = "uvx"
    args = ["mcp-server-git", "--repository", "."]
    enabled_tools = ["git_status", "git_log", "git_diff"]   # read-only subset
    # enabled = false                                       # keep the entry, load nothing
    ```

    **Cursor**

    Usuń wpisy z `.cursor/mcp.json`. Zacommituj plik projektu, żeby cały zespół dostał tę samą zmianę.

5. **Zweryfikuj odchudzoną konfigurację.** Powtórz listowanie z kroku 1 i porównaj `/context` z zanotowaną liczbą. W Codex porównaj `/mcp verbose` przed zmianą i po niej; w Cursorze porównaj wpisy, które zostały w `.cursor/mcp.json` i `~/.cursor/mcp.json`, z krokiem 1. Potem uruchom test dymny z następnej sekcji. Otwórz zmianę jako pull request, który mówi, dlaczego każdy serwer zniknął, żeby recenzent sprawdzał uzasadnienia, a nie JSON.

Claude Code i Codex domyślnie odraczają definicje narzędzi MCP przez wyszukiwanie narzędzi (tool search), więc bezczynny serwer kosztuje dziś mniej kontekstu niż w 2025 roku. Audyt i tak się opłaca: ryzykiem zdublowanego narzędzia jest obejście uprawnień, a nie tylko tokeny.

## Jak udowodnić, że odchudzona konfiguracja nadal działa?

Nie czytaj nowej konfiguracji z nadzieją, że jest dobra. Każ agentowi sprawdzić w praktyce każdą funkcję, którą właśnie przeniosłeś z MCP na narzędzia natywne, i podać, którego narzędzia użył.

**Prompt do skopiowania: test dymny po usunięciu serwerów MCP**

```text
Run a smoke test of your tools after an MCP cleanup. For each task, name the exact tool you used (native or MCP):
1. Read package.json and report the "name" field.
2. Show `git status` and the last three commits.
3. Create tmp/mcp-smoke.txt containing today's date, then delete it.
4. Fetch https://modelcontextprotocol.io and report the page title.
If any task needs a tool you do not have, say so instead of working around it. Do not change any other file.
```

W Codex uruchom sesję z `--search` albo uznaj `curl` w powłoce za natywną drogę dla zadania 4.

Test przechodzi, gdy wszystkie cztery zadania są wykonane, każde narzędziem natywnym, i nie ma żadnego wywołania usuniętego serwera. W zespole pull request zatwierdza tech lead, a wpis w `CODEOWNERS` dla `.mcp.json`, `.cursor/mcp.json` i `.codex/config.toml` sprawia, że kolejne dodane serwery przechodzą ten sam przegląd.

## Przykład: katalog notatek dla klienta czatowego przez serwer Filesystem

Tu serwer Filesystem jest właściwym narzędziem. Klient czatowy, taki jak Claude Desktop, nie ma własnych narzędzi plikowych, a ty chcesz, żeby czytał i porządkował folder notatek w Markdownie, i nic więcej.

1. **Ogranicz serwer do jednej ścieżki bezwzględnej.** Serwer dotyka tylko katalogów podanych jako argumenty albo katalogów, które klient wysyła jako MCP Roots. W Claude Desktop dodaj to do `claude_desktop_config.json` (z README serwera; w Windows uruchamiaj przez `"command": "cmd"` i wstaw `"/c", "npx"` na początek `args`):

    ```json
    {
      "mcpServers": {
        "notes": {
          "command": "npx",
          "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me/notes"]
        }
      }
    }
    ```

2. **Albo dodaj go do agenta kodującego**, gdy chcesz mieć folder notatek w każdym projekcie, nie dając tam agentowi powłoki.

    **Claude Code**

    ```bash
    claude mcp add -s user notes -- npx -y @modelcontextprotocol/server-filesystem /Users/me/notes
    ```
    Na jedną sesję natywną alternatywą jest `claude --add-dir /Users/me/notes` (albo `/add-dir` w sesji). Folder zostaje wtedy pod regułami uprawnień samego Claude Code.

    **Codex**

    ```bash
    codex mcp add notes -- npx -y @modelcontextprotocol/server-filesystem /Users/me/notes
    ```
    Na jedną sesję natywną alternatywą jest `codex --add-dir /Users/me/notes`.

    **Cursor**

    Dodaj ten sam wpis `notes` co w JSON-ie dla Claude Desktop do `~/.cursor/mcp.json` (wszystkie projekty) albo `.cursor/mcp.json` (tylko ten projekt).

3. **Ustaw tryb tylko do odczytu, jeśli potrzebujesz wyłącznie odczytu.** Wariant z Dockerem z README montuje folder z flagą `ro`, więc zapisy padają na poziomie systemu plików, a nie zależą od posłuszeństwa modelu:

    ```json
    {
      "mcpServers": {
        "notes": {
          "command": "docker",
          "args": ["run", "-i", "--rm",
            "--mount", "type=bind,src=/Users/me/notes,dst=/projects/notes,ro",
            "mcp/filesystem", "/projects"]
        }
      }
    }
    ```

4. **Uruchom zadanie.** Wklej ten prompt w kliencie czatowym lub agencie.

    **Prompt do skopiowania: porządkowanie folderu notatek przez serwer Filesystem**

    ```text
    Use only the tools from the "notes" MCP server. First call list_allowed_directories and tell me what you can reach.
    Then find every Markdown file under that directory modified in the last 30 days (use get_file_info), and list the ones with no top-level heading.
    For each of them, propose a one-line "# " heading based on the content. Apply the headings with edit_file and dryRun set to true, show me the diffs, and wait for my "apply" before running edit_file for real.
    Do not create, move or delete any file.
    ```

Czego się spodziewać: wywołania `list_allowed_directories`, które zwraca tylko `/Users/me/notes` (albo `/projects` w Dockerze), serii wywołań `search_files` i `get_file_info` oraz diffów w stylu gita z próbnego przebiegu. Serwer oznacza swoje narzędzia adnotacjami MCP: narzędzia odczytu mają `readOnlyHint: true`, a `write_file`, `edit_file` i `move_file` są oznaczone jako destrukcyjne. Klient, który respektuje te wskazówki, może automatycznie zatwierdzać odczyty i nadal pytać przed zapisem.

**Roots zastępują twoje argumenty**

README mówi, że katalogi wysłane przez klienta jako MCP Roots „completely replace” te podane w argumentach. Jeśli klient wysyła Roots, twój starannie wybrany argument `/Users/me/notes` przestaje obowiązywać. Poproś agenta, żeby na początku sesji wywołał `list_allowed_directories` i pokazał faktyczny zakres. Roots są przestarzałe w specyfikacji MCP 2026-07-28 (zobacz [co zmieniło się w MCP 2026-07-28](/pl/ecosystem/mcp/spec-2026-07-28/)), więc spodziewaj się zmian w tym zachowaniu.

## Kiedy Git, Fetch, Memory, Sequential Thinking i Time mają sens?

Każdy z tych serwerów wypełnia lukę w kliencie, któremu brakuje natywnego narzędzia. W agencie kodującym najpierw sięgnij po drogę natywną.

### Git: lokalne repozytorium dla klienta bez powłoki

`mcp-server-git` pasuje do klienta czatowego, który przegląda lokalne repozytorium. Jego narzędzia czytają status, diffy i historię, potrafią też stage'ować, commitować, tworzyć gałęzie i je przełączać; nic nie dociera do zdalnego repozytorium. README wciąż opisuje go jako „in early development”.

```bash
claude mcp add git -- uvx mcp-server-git --repository /Users/me/code/api
codex mcp add git -- uvx mcp-server-git --repository /Users/me/code/api
```

W Claude Code, Codex i Cursorze agent uruchamia `git` w powłoce, pod własnymi regułami zatwierdzania. Do pull requestów i issues użyj `gh` albo [serwera GitHub MCP](/pl/ecosystem/mcp/github-mcp/).

### Fetch: strony jako Markdown, z ostrzeżeniem o SSRF

`mcp-server-fetch` ma jedno narzędzie, `fetch`, które domyślnie zwraca do 5000 znaków. Dłuższe strony model czyta porcjami przez `start_index`. Serwer respektuje `robots.txt` dla żądań inicjowanych przez model; `--ignore-robots-txt`, `--user-agent` i `--proxy-url` zmieniają to zachowanie. README zawiera ostrzeżenie: serwer „can access local/internal IP addresses”. Agent, który podąży za linkiem ze strony z prompt injection, może więc dotrzeć do twojej sieci wewnętrznej. Uruchamiaj go tylko tam, gdzie to akceptujesz. Wyszukiwanie i scraping na większą skalę opisuje strona o [serwerach MCP do researchu w sieci](/pl/ecosystem/mcp/web-research-mcp/).

### Memory: graf wiedzy w jednym pliku JSONL

Serwer Memory zapisuje encje, relacje i obserwacje w pliku JSONL. Ścieżkę ustawia `MEMORY_FILE_PATH`, a domyślnie plik leży w katalogu samego serwera, czyli przy `npx` w pamięci podręcznej pakietów. Ustaw zmienną na ścieżkę objętą kopią zapasową:

```bash
claude mcp add memory -e MEMORY_FILE_PATH=/Users/me/.agent-memory/memory.jsonl -- npx -y @modelcontextprotocol/server-memory
```

W zespole programistów wiedza o projekcie w `CLAUDE.md` lub `AGENTS.md` wygrywa, bo zmienia się przez commity po review. Narzędzia pamięci między sesjami opisuje strona o [wtyczkach trwałej pamięci](/pl/ecosystem/plugins/memory-plugins/).

### Sequential Thinking: opcjonalny w erze modeli rozumujących

Serwer daje modelowi narzędzie-brudnopis do ponumerowanych myśli z możliwością rewizji. Pomagał modelom bez wbudowanego rozumowania. Przy obecnych modelach podniesienie poziomu wysiłku (effort) zwykle robi to samo bez dodatkowego narzędzia; to ocena redakcyjna, a nie zmierzony wynik. Jeśli go zostawiasz, ustaw `DISABLE_THOUGHT_LOGGING=true`, żeby nie logował każdej myśli.

### Time i Everything: nisza i testowanie

Time odpowiada na pytanie „która jest godzina w `Asia/Tokyo`” dwoma narzędziami; agent z powłoką może zamiast tego uruchomić `date`. Everything to serwer testowy dla osób budujących klientów MCP. Łącz go z MCP Inspectorem (`npx @modelcontextprotocol/inspector`, npm 2.8.0), gdy [budujesz własny serwer MCP](/pl/ecosystem/mcp/custom-mcp-development/).

## Kiedy Desktop Commander jest tego wart?

Desktop Commander (`wonderwhy-er/DesktopCommanderMCP`, około 9,8 tys. gwiazdek na GitHubie i npm `0.2.51` na 2026-09-26) to serwer społecznościowy, który daje klientowi czatowemu terminal. Uruchamia długo działające procesy i z nimi rozmawia (`start_process`, `interact_with_process`, `read_process_output`), wyszukuje przez ripgrep, edytuje pliki blokami i czyta pliki Excel oraz PDF. Jego README wymienia około 25 narzędzi.

Jest pomyślany dla Claude Desktop. W Claude Code, Codex i Cursorze dubluje wbudowane narzędzia powłoki i plików oraz poszerza powierzchnię uprawnień, więc dodawaj go tam tylko dla konkretnej luki. Polecenia instalacji z README:

```bash
# Claude Desktop (writes claude_desktop_config.json; auto-updates on restart)
npx @wonderwhy-er/desktop-commander@latest setup

# Claude Code and Codex, per the README
claude mcp add --scope user desktop-commander -- npx -y @wonderwhy-er/desktop-commander@latest
codex mcp add desktop-commander -- npx -y @wonderwhy-er/desktop-commander@latest
```

**Pułapki Desktop Commandera według jego własnego README**

- **`allowedDirectories` ogranicza tylko narzędzia plikowe.** Polecenia terminala „can still access files outside allowed directories”.
- **Puste `allowedDirectories` (`[]`) otwiera operacjom plikowym cały system plików.**
- **Blokadę poleceń da się obejść** „through various methods including symlinks, command substitution, and absolute paths or code execution”. To barierka, nie sandbox.
- **Zmieniaj jego konfigurację w osobnym czacie.** README ostrzega, że model może próbować poszerzyć `allowedDirectories`, gdy trafi na ograniczenie.
- **`@latest` aktualizuje się przy każdym restarcie.** W zespole przypnij wersję, na przykład `@wonderwhy-er/desktop-commander@0.2.51`, i aktualizuj świadomie.
- **Każde wywołanie narzędzia trafia do lokalnego logu bez redakcji.** `claude_tool_call.log` zapisuje argumenty każdego wywołania, w tym treść poleceń i ścieżki, a zrotowane logi nie są usuwane.
- **Telemetria działa, dopóki jej nie wyłączysz.** Jest pseudonimowa i nie obejmuje treści plików, ścieżek ani argumentów; ustaw `telemetryEnabled` na `false`, żeby z niej zrezygnować.
- Dla prawdziwej izolacji README poleca instalację w Dockerze. Zobacz [sandboksy dla agentów kodujących](/pl/ecosystem/agent-tools/sandboxes/).

Naprawdę przydaje się wtedy, gdy klient czatowy ma pilnować działającego procesu:

**Prompt do skopiowania: nadzór nad serwerem deweloperskim z Claude Desktop**

```text
Using Desktop Commander, start `npm run dev` in /Users/me/code/shop with start_process and keep the session ID.
Wait until the output shows the server is listening, then keep reading the output with read_process_output.
If you see a compilation error or an unhandled exception, read the file named in the stack trace, propose a fix as a diff, and wait for my approval before you edit anything.
Do not run any other command.
```

## Gdy referencyjne serwery MCP zawodzą

- **`npx` zwraca 404 dla `@modelcontextprotocol/server-git`.** Git, Fetch i Time to pakiety PyPI. Zainstaluj `uv` i uruchamiaj je przez `uvx mcp-server-git`, `uvx mcp-server-fetch` lub `uvx mcp-server-time`.
- **Serwer Filesystem kończy działanie przy starcie.** Potrzebuje co najmniej jednego dozwolonego katalogu. Rzuca błąd, gdy startuje bez katalogów w argumentach, a klient nie wysyła Roots. Dodaj ścieżkę bezwzględną do `args`.
- **„Access denied” na ścieżce, którą dopuściłeś.** Względna ścieżka w `args` albo Roots, które zastąpiły twoje argumenty. Używaj ścieżek bezwzględnych i poproś agenta o wywołanie `list_allowed_directories`.
- **„Permission denied” z systemu operacyjnego.** Serwer działa jako twój użytkownik, więc nie przeczyta plików należących do roota ani innego konta. Popraw uprawnienia plików albo użyj wariantu z Dockerem i bind mountem.
- **Duże pliki zalewają kontekst.** `read_text_file` zwraca cały plik, jeśli nie podasz `head` lub `tail`. Każ agentowi najpierw szukać przez `search_files`, potem czytać z `head`, a do `directory_tree` przekazywać `excludePatterns`, na przykład `node_modules`.
- **Fetch zwraca uciętą stronę.** To domyślny limit 5000 znaków. Poproś agenta o kontynuację z `start_index` albo o większe `max_length` w wywołaniu.
- **Graf Memory jest pusty po czyszczeniu pamięci podręcznej.** Nie ustawiono `MEMORY_FILE_PATH`, więc plik leżał w cache'u `npx`. Ustaw stałą ścieżkę i przywróć JSONL z kopii zapasowej.
- **`mcp-server-git` lub `mcp-server-fetch` pada po `pip install`.** Oba README wymagają MCP Python SDK 1.x (`mcp>=1.29.0,<2`). Środowisko z SDK 2.0 je psuje. `uvx` rozwiązuje właściwą wersję w izolowanym środowisku.
- **Zarchiwizowany serwer wciąż „działa”.** Przestarzały pakiet może startować, dopóki nie zmieni się API za nim. Nie czekaj na awarię: zastąp go następcą z tabeli zarchiwizowanych serwerów.
- **Agent zapisał plik, który twoje reguły uprawnień powinny zablokować.** Użył narzędzia zapisu z MCP, a nie natywnego. Usuń zdublowany serwer albo dodaj regułę deny dla nazwy narzędzia MCP, na przykład `mcp__filesystem__write_file` w Claude Code.

## Dokąd dalej z serwerami MCP

- [Startowy zestaw MCP](/pl/ecosystem/mcp/essential-servers/) — Serwery, których większość zespołów potrzebuje po audycie, i kiedy CLI ze skillem wygrywa z MCP.
- [Zabezpieczanie serwerów MCP](/pl/ecosystem/mcp/mcp-security/) — Listy dozwolonych serwerów, najmniejsze uprawnienia i prompt injection przez wyniki narzędzi.
- [Mniejszy koszt tokenów MCP](/pl/ecosystem/mcp/reducing-mcp-token-cost/) — Zmierz i obetnij to, ile definicje i wyniki narzędzi MCP kosztują w każdej sesji.
- [Rejestry i bramki MCP](/pl/ecosystem/mcp/registry-and-gateways/) — Dopuszczaj serwery dla całej organizacji zamiast audytować repozytoria jedno po drugim.

Dopiero zaczynasz z MCP? Zacznij od [wprowadzenia do Model Context Protocol](/pl/ecosystem/mcp/).
