# Rejestry i bramki MCP: dopuszczanie serwerów w organizacji

URL: https://developertoolkit.ai/pl/ecosystem/mcp/registry-and-gateways/
Description: Weryfikuj serwery MCP w oficjalnym rejestrze, prowadź katalog zatwierdzonych, egzekwuj go w Claude Code, Codex i Cursorze, a wywołania audytuj przez bramkę.

Organizacja dopuszcza serwery MCP na czterech poziomach: weryfikuje każdy serwer w Official MCP Registry i w repozytorium dostawcy, zapisuje zatwierdzone serwery w jednym recenzowanym katalogu, egzekwuje ten katalog w zarządzanej konfiguracji każdego agenta i kieruje wywołania przez bramkę tam, gdzie potrzebny jest dziennik audytu. Official MCP Registry to indeks w wersji zapoznawczej (preview), a nie zweryfikowana lista.

Wiosną dział bezpieczeństwa zatwierdził GitHub MCP i Sentry MCP. Pół roku później `claude mcp list` na przypadkowym laptopie pokazuje jedenaście serwerów, w tym wpis `figma` wskazujący na pakiet niezwiązanego wydawcy, a jeden z użytkowników Codeksa ma serwer Postgres, którego nikt nie przejrzał. Nikt nie złamał reguły, bo nie było reguły, którą narzędzie mogłoby wyegzekwować, i nikt nie potrafi powiedzieć, które serwery działały w zeszłym tygodniu na danych produkcyjnych.

Ta strona jest dla **tech leada**, który odpowiada za listę zatwierdzonych serwerów, i dla **CTO**, który musi pokazać audytorom, że ta lista działa. Zakłada, że znasz już [zabezpieczanie serwerów MCP](/pl/ecosystem/mcp/mcp-security/), czyli skanowanie i tryby tylko do odczytu dla pojedynczego serwera. Pliki polityk poszczególnych narzędzi, które niosą tę listę, opisuje strona [jedna polityka dla wszystkich agentów kodujących](/pl/org/managed-policy/).

## Co daje organizacyjna lista dozwolonych serwerów MCP

- Powtarzalną procedurę weryfikacji: Official MCP Registry potwierdza tożsamość, repozytorium dostawcy daje podstawę zaufania, a gotowy prompt przeprowadza całość.
- Tabelę decyzyjną: stały zestaw serwerów, katalog zatwierdzonych czy lista zakazanych.
- Jeden plik katalogu, z którego generujesz `allowedMcpServers` dla Claude Code, `requirements.toml` dla Codeksa i listę kontrolną dla Cursora.
- Ścieżkę z bramką dla zespołów, które potrzebują jednego punktu wejścia, skanowania sekretów i logów wywołań.
- Mechaniczne testy, które dowodzą, że lista działa na każdej maszynie, oraz spis tego, co psuje się przy wdrożeniu.

## Czym jest Official MCP Registry i czego nie robi?

[Official MCP Registry](https://github.com/modelcontextprotocol/registry) to publiczny indeks metadanych serwerów MCP: nazwy, wersji, pakietów i zdalnych adresów URL. Jego README nazywa go „an app store for MCP servers”. Wystartował w wersji zapoznawczej 2025-09-08, a jego API jest zamrożone w wersji v0.1 od 2025-10-24; ogólnej dostępności (GA) nie ogłoszono (sprawdzone 2026-09-26 i ponownie 2026-10-12, gdy status w README się nie zmienił, a najnowszym wydaniem było v1.8.1 z 2026-08-06). Według stanu na 2026-09-26 rejestr zawierał 36 176 serwerów w najnowszej wersji, policzonych przez API rejestru podczas przygotowywania tej strony.

Trzy cechy decydują o tym, jak go używać:

| Cecha | Co oznacza dla twojej listy |
| --- | --- |
| **Tylko weryfikacja przestrzeni nazw.** Nazwy `io.github.<user>/…` wymagają, by wydawca uwierzytelnił się jako ten użytkownik GitHuba; nazwy `com.example/…` wymagają dowodu własności domeny przez DNS albo HTTP. | Nazwa `io.github.getsentry/sentry-mcp` dowodzi, kto opublikował wpis. Nie dowodzi, że serwer jest bezpieczny ani że to ten, o który ci chodziło. |
| **Minimalna moderacja.** Polityka moderacji rejestru mówi, że nie usuwa „low-quality or buggy servers” ani „servers with security vulnerabilities”, a konsumenci powinni zakładać „minimal-to-no moderation”. | Obecność w rejestrze nigdy nie jest zatwierdzeniem. Kilka wpisów `*/github`, `*/figma` i `*/sentry` pochodzi od wydawców niezwiązanych z tymi dostawcami. |
| **Wersje mogą odstawać od pakietów.** Według stanu na 2026-09-26 wpis Sereny miał wersję 1.5.3, a PyPI 1.7.0; Next.js DevTools miał 0.3.6 wobec 0.4.0 w npm. | Przypinaj wersje z rejestru pakietów, z którego instalujesz, a nie z MCP Registry. |

Rejestr zakłada istnienie **agregatorów**: usług, które kopiują jego dane „on a regular but infrequent basis (e.g., once per hour)” i dodają coś od siebie, na przykład oceny albo skanowanie bezpieczeństwa. Agregator, który dodatkowo udostępnia OpenAPI rejestru, to **subrejestr** (subregistry). To jest model prywatnego rejestru: twoja własna, przefiltrowana i przejrzana kopia, a nie żywa zależność od publicznego indeksu.

Wpis w rejestrze to nie to samo co MCP Server Card. SEP-2127 osiągnął status Final 2026-10-06 (Extensions Track, identyfikator rozszerzenia `io.modelcontextprotocol/server-card`): standardowy, samodzielny format opisujący serwer, zanim klient się połączy, z dostępnymi transportami, wersjami protokołu i wskazówkami połączenia. Wersja specyfikacji to wciąż 2026-07-28 (sprawdzone 2026-10-12). Traktuj kartę jak własny opis serwera, podobnie jak jego README, i zachowaj kontrolę tożsamości z poniższych kroków weryfikacji.

## Który wzorzec listy dozwolonych pasuje do twojej organizacji?

Wybierz wzorzec, zanim napiszesz jakikolwiek plik. Ostrzejsze wzorce odbierają programistom swobodę, więc dopasuj je do ryzyka, a nie do przyzwyczajeń.

| Wzorzec | Co mogą programiści | Kiedy go wybrać | Mechanizm w Claude Code |
| --- | --- | --- | --- |
| **Stały zestaw** | Używać dokładnie wdrożonych serwerów; nic nie dodają | Kod regulowany, kontraktorzy, runnery CI | `managed-mcp.json` |
| **Katalog zatwierdzonych** | Dodać dowolny serwer z listy; reszta jest blokowana | Większość zespołów produktowych | `allowedMcpServers` + `allowManagedMcpServersOnly: true` |
| **Dostarczone plus własne** | Dostają twoje zdalne serwery automatycznie i zachowują własne | Wczesne wdrożenie, repozytoria niskiego ryzyka | `managedMcpServers` |
| **Tylko lista zakazanych** | Dodać wszystko poza znanymi złymi serwerami | Wyłącznie tymczasowo, zanim zbudujesz katalog | `deniedMcpServers` |

Dalsza część strony buduje **katalog zatwierdzonych**, bo na nim kończy większość organizacji, a trzy pozostałe wzorce to podzbiory jego kroków.

## Jak zweryfikować serwer w rejestrze?

1. **Przeszukaj rejestr i zostaw tylko przestrzeń nazw dostawcy.** API rejestru zwraca każdy wpis pasujący do nazwy produktu, z pakietami i zdalnymi adresami; linia `select` zostawia przestrzeń nazw dostawcy:

   ```bash
   # terminal; needs curl and jq
   curl -s "https://registry.modelcontextprotocol.io/v0.1/servers?search=sentry&version=latest" \
     | jq '.servers[]
           | select(.server.name | startswith("io.github.getsentry/"))
           | {name: .server.name, version: .server.version,
           repo: .server.repository.url,
           packages: [.server.packages[]?.identifier],
           remotes: [.server.remotes[]?.url]}'
   ```

   Według stanu na 2026-09-26 wpis dostawcy to `io.github.getsentry/sentry-mcp` 0.42.0 z pakietem npm `@sentry/mcp-server` i zdalnym adresem `https://mcp.sentry.dev/mcp`. Usuń linię `select`, aby zobaczyć pozostałe wyniki dla `sentry`: każdy z nich to kandydat na listę zakazanych, nie dozwolonych.

2. **Potwierdź tożsamość poza rejestrem.** `repository.url` musi należeć do organizacji dostawcy na GitHubie, a README dostawcy musi wskazywać ten sam pakiet lub URL. Sam pakiet sprawdź przez `npm view <package> name version repository.url deprecated` albo `https://pypi.org/pypi/<package>/json`.

3. **Wybieraj zdalny URL, gdy dostawca go oferuje.** Serwer HTTP hostowany przez dostawcę, z OAuth, nie uruchamia żadnego kodu na laptopie, a wzorce URL łatwiej egzekwować niż dokładne polecenia. Zapisz wariant tylko do odczytu, jeśli istnieje, na przykład `https://api.githubcopilot.com/mcp/readonly` GitHuba.

4. **Przeskanuj i sklasyfikuj.** Uruchom skan ze strony [zabezpieczanie serwerów MCP](/pl/ecosystem/mcp/mcp-security/) i oznacz serwer jako **tylko do odczytu** albo **z możliwością zapisu**. Serwery z zapisem, które dotykają produkcji, wymagają podpisu imiennie wskazanej osoby od bezpieczeństwa.

5. **Zapisz decyzję w katalogu** (następna sekcja) razem z dowodami: nazwą w rejestrze, repozytorium, przypiętą wersją, transportem, przełącznikiem tylko do odczytu i osobą zatwierdzającą.

**Prompt do skopiowania: weryfikacja serwera MCP do katalogu organizacji**

```text
Vet the MCP server "Sentry" for our organization's MCP catalog. Do not
install, start or connect to it.

1. Query https://registry.modelcontextprotocol.io/v0.1/servers?search=sentry&version=latest
   and list every entry: name, version, repository URL, packages, remotes.
2. Identify the one entry whose repository belongs to the vendor's own GitHub
   organization. Explain why each other entry is not the vendor's.
3. For the vendor entry, check the package with `npm view <package> name
   version repository.url deprecated` (or the PyPI JSON API) and report any
   difference between the registry version and the package version.
4. State whether a vendor-hosted remote URL exists and whether a read-only
   URL, flag or scope exists.
5. Output one YAML block in the format of mcp-catalog/servers.yaml with
   fields: name, registry_name, repository, transport, url or command,
   version, read_only, evidence. List any write tools in a comment next to
   read_only. Leave approver empty.
```

## Zbuduj katalog zatwierdzonych serwerów jako prywatny rejestr

W większości organizacji prywatny rejestr to przejrzany plik w repozytorium polityk, a nie serwer. Jest jedynym źródłem konfiguracji każdego narzędzia, a pull request jest zapisem zatwierdzenia.

```yaml
# mcp-catalog/servers.yaml — one entry per approved server
- name: github
  registry_name: io.github.github/github-mcp-server
  repository: https://github.com/github/github-mcp-server
  transport: http
  url: https://api.githubcopilot.com/mcp/readonly
  version: remote        # vendor-hosted; nothing to pin
  read_only: true
  evidence: "registry entry + vendor README checked 2026-09-26"
  approver: "@acme/platform-security"
- name: sentry
  registry_name: io.github.getsentry/sentry-mcp
  repository: https://github.com/getsentry/sentry-mcp
  transport: http
  url: https://mcp.sentry.dev/mcp
  version: 0.42.0        # registry entry and npm @sentry/mcp-server, 2026-09-26
  read_only: false       # write tools listed in the approving pull request
  evidence: "registry entry + npm view @sentry/mcp-server, 2026-09-26"
  approver: "@acme/platform-security"
- name: playwright
  registry_name: io.github.microsoft/playwright-mcp
  repository: https://github.com/microsoft/playwright-mcp
  transport: stdio
  command: [npx, "@playwright/mcp@0.0.82"]
  version: 0.0.82
  read_only: true
  evidence: "npm view @playwright/mcp version, 2026-09-26"
  approver: "@acme/frontend-leads"
```

Przy każdym wpisie podaj programistom dokładne polecenie instalacji. Każda linia poniżej pasuje do listy dozwolonych Claude Code i do `identity` w Codeksie z następnej sekcji: adresy URL pasują do wzorców, a polecenia zgadzają się argument po argumencie.

```bash
# terminal; Claude Code
claude mcp add --transport http github https://api.githubcopilot.com/mcp/readonly
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp
claude mcp add playwright -- npx @playwright/mcp@0.0.82

# terminal; Codex
codex mcp add github --url https://api.githubcopilot.com/mcp/readonly
codex mcp add sentry --url https://mcp.sentry.dev/mcp
codex mcp add playwright -- npx @playwright/mcp@0.0.82
```

W Codeksie klucz wymagania musi się zgadzać z nazwą, której używa programista, więc `name` jest częścią kontraktu, a nie etykietą.

Warto znać jeszcze dwie formy katalogu:

- **Marketplace pluginów.** Claude Code nie ma wbudowanego rejestru MCP do przeglądania. Dokumentacja Anthropic o zarządzanym MCP sugeruje dystrybucję zatwierdzonych serwerów jako pluginów w [zespołowym marketplace pluginów](/pl/ecosystem/plugins/team-marketplace/), dzięki czemu programiści instalują je z `/plugin`.
- **Subrejestr.** Jeśli utrzymujesz wiele wewnętrznych serwerów, uruchom agregator, który co godzinę kopiuje publiczny rejestr z parametrem `updated_since`, filtruje go do zatwierdzonych nazw i dodaje twoje serwery. Publikowanie własnych serwerów w publicznym rejestrze opisuje strona [tworzenie własnego serwera MCP](/pl/ecosystem/mcp/custom-mcp-development/).

## Wyegzekwuj katalog w każdym agencie

Każde narzędzie egzekwuje listę w innym miejscu i według innych reguł dopasowania. Generuj wszystkie trzy pliki z `servers.yaml` i sprawdzaj je w CI testem zgodności ze strony [jedna polityka dla wszystkich agentów kodujących](/pl/org/managed-policy/).

**Claude Code**

Umieść listę w zarządzanym źródle ustawień: w ustawieniach zarządzanych z serwera (konsola administracyjna claude.ai), we wdrożonym `managed-settings.json`, w profilu MDM albo w polityce rejestru systemu. `allowManagedMcpServersOnly: true` nie pozwala użytkownikom poszerzać listy we własnych ustawieniach; listy zakazanych nadal łączą się ze wszystkich zakresów.

```json
{
  "allowManagedMcpServersOnly": true,
  "allowedMcpServers": [
    { "serverUrl": "https://api.githubcopilot.com/mcp/readonly" },
    { "serverUrl": "https://mcp.sentry.dev/*" },
    { "serverCommand": ["npx", "@playwright/mcp@0.0.82"] }
  ],
  "deniedMcpServers": [
    { "serverUrl": "https://*.untrusted.example.com/*" }
  ]
}
```

O tym, czy lista naprawdę działa, decydują reguły dopasowania:

- Gdy lista ma choć jeden wpis `serverUrl`, każdy zdalny serwer musi pasować do wzorca URL; gdy ma choć jeden `serverCommand`, każdy serwer stdio musi pasować do polecenia dokładnie, argument po argumencie. `["npx", "-y", "server"]` nie pasuje do `["npx", "server"]`.
- Wpis `serverName` nie jest zabezpieczeniem, bo nazwę wybiera użytkownik.
- Dopasowanie do listy zakazanych zawsze wygrywa.
- Aby dostarczyć zdalne serwery wszystkim bez przejmowania wyłącznej kontroli, wpisz je w `managedMcpServers` (v2.1.259 lub nowsza, według dokumentacji zarządzanego MCP i dziennika zmian Claude Code, sprawdzonych 2026-09-26). Wpisy muszą być serwerami HTTP albo SSE pod adresem `https://`, bez `command`, i ładują się bez wpisu na liście dozwolonych.
- Dla stałego zestawu wdróż `managed-mcp.json` do `/Library/Application Support/ClaudeCode/` (macOS), `/etc/claude-code/` (Linux i WSL) albo `C:\Program Files\ClaudeCode\` (Windows). Nie da się go dostarczyć przez ustawienia zarządzane z serwera.

**Codex**

Codex czyta ograniczenia administratora z `requirements.toml`. Plik systemowy to `/etc/codex/requirements.toml` na Uniksie i `%ProgramData%\OpenAI\Codex\requirements.toml` na Windows; Codex czyta też warstwy wymagań z MDM i ze źródeł zarządzanych przez firmę. Każdy zatwierdzony serwer to tabela z kluczem równym jego **nazwie** i polem `identity`:

```toml
[mcp_servers.github.identity]
url = "https://api.githubcopilot.com/mcp/readonly"

[mcp_servers.sentry.identity]
url = { match = "prefix", value = "https://mcp.sentry.dev/" }

[mcp_servers.playwright.identity]
command = { executable = "npx", args = [{ match = "exact", value = "@playwright/mcp@0.0.82" }] }
```

Zachowanie odczytane z kodu źródłowego Codeksa na tagu `rust-v0.157.1` i na `main` 2026-09-26:

- Gdy `mcp_servers` istnieje, Codex **wyłącza każdy skonfigurowany serwer, którego nazwy nie ma na liście**, albo którego polecenie lub URL nie pasuje do `identity` wpisu. Próba logowania lub połączenia kończy się wtedy komunikatem „the MCP server is disabled by managed requirements”.
- Zwykłe `url = "…"` to dokładne porównanie napisów. Do luźniejszych dopasowań użyj `{ match = "prefix", … }` albo `{ match = "regex", expression = … }`; wyrażenie regularne musi pasować do całej wartości.
- Zwykłe `command = "npx"` przypina tylko plik wykonywalny i ignoruje argumenty, więc zatwierdza każdy serwer uruchamiany przez `npx`. Używaj formy z `executable` i `args`, która wymaga tej samej liczby argumentów w tej samej kolejności.
- Pluginy mają własną tabelę: `[plugins."<plugin>@<marketplace>".mcp_servers.<name>.identity]`.

**Cursor**

Organizacyjnych ustawień MCP w Cursorze nie udało się zweryfikować 2026-09-26, bo cursor.com był niedostępny ze środowiska, w którym sprawdzano tę stronę. Definicje typów Cursor SDK 1.0.32 wymieniają `team` i `mdm` wśród źródeł ustawień, więc warstwy zespołowe i dostarczane przez MDM istnieją; sprawdź w panelu administracyjnym, czy pozwalają ograniczyć serwery MCP do listy, i zapisz odpowiedź z datą.

Do tego czasu egzekwuj katalog wokół Cursora, a nie w nim:

- Zatwierdź w repozytorium plik `.cursor/mcp.json` w zakresie projektu, zawierający wyłącznie serwery z katalogu, i obejmij go regułą `CODEOWNERS`.
- Skieruj ten plik na profil bramki (następna sekcja), aby jeden przejrzany wpis niósł cały katalog.
- Przy każdym wydaniu uruchom test kontrolny z sekcji o weryfikacji na maszynie z Cursorem.

## Kiedy potrzebujesz bramki MCP?

Bramka (gateway) to proces między agentem a serwerami MCP: agent łączy się z jednym wpisem, a bramka uruchamia serwery za nim albo pośredniczy w ruchu do nich. Dodaj ją, gdy potrzebujesz przynajmniej jednej z tych rzeczy:

- **Jednego punktu wejścia dla kilku narzędzi.** Jeden profil obsługuje Claude Code, Cursora i innych klientów, więc lista dozwolonych w narzędziu kurczy się do jednego wpisu bramki.
- **Izolacji.** Serwery stdio działają w kontenerach, a nie w sesji programisty.
- **Centralnych kontroli.** Skanowania sekretów w argumentach i odpowiedziach, weryfikacji podpisów obrazów serwerów i logów wywołań w jednym miejscu.

[Docker MCP Gateway](https://github.com/docker/mcp-gateway) to opcja zweryfikowana w tej witrynie. Według stanu na 2026-09-26 repozytorium `docker/mcp-gateway` miało 1,6 tys. gwiazdek na GitHubie, a repozytorium katalogu `docker/mcp-registry` 558 gwiazdek i 1,5 tys. forków ze zgłoszeń serwerów (GitHub). Dla audytu liczą się domyślne ustawienia `gateway run`:

| Flaga | Domyślnie | Co robi |
| --- | --- | --- |
| `--log-calls` | włączona | Loguje każde wywołanie narzędzia z nazwą narzędzia i tylko kształtem argumentów; surowe wartości argumentów nie trafiają do logu |
| `--block-secrets` | włączona | Skanuje argumenty wywołań i tekstowe odpowiedzi w poszukiwaniu wartości wyglądających na sekrety, przed wykonaniem i po nim |
| `--verify-signatures` | włączona dla obrazów Docker MCP | Wymaga obrazów wskazanych przez digest i weryfikuje je przed pobraniem lub uruchomieniem |
| `--block-network` | wyłączona | Dodatkowo ogranicza dostęp serwerów do sieci |

**Claude Code**

```bash
# terminal; vendor lines from the docker/mcp-gateway README
docker mcp catalog pull mcp/docker-mcp-catalog
docker mcp profile create --name dev-tools \
  --server catalog://mcp/docker-mcp-catalog/github
docker mcp client connect claude-code --profile dev-tools --global
```

Następnie dopuść na liście samo polecenie bramki, dokładnie w takiej postaci, w jakiej uruchamia je klient, żeby nie przeszedł żaden inny serwer stdio:

```json
{ "serverCommand": ["docker", "mcp", "gateway", "run", "--profile", "dev-tools"] }
```

To tylko przykład. Odczytaj polecenie, które naprawdę zapisało `docker mcp client connect` (`claude mcp list`, potem `claude mcp get <name>`), i skopiuj je na listę, bo wpis musi pasować argument po argumencie.

**Codex**

```bash
# terminal; assembled from the README's manual client entry
codex mcp add MCP_DOCKER -- docker mcp gateway run --profile dev-tools
```

Nie zweryfikowano, czy `docker mcp client connect` obsługuje Codeksa, więc dodaj wpis ręcznie. Odpowiadające mu wymaganie:

```toml
[mcp_servers.MCP_DOCKER.identity]
command = { executable = "docker", args = [
  { match = "exact", value = "mcp" },
  { match = "exact", value = "gateway" },
  { match = "exact", value = "run" },
  { match = "exact", value = "--profile" },
  { match = "exact", value = "dev-tools" },
] }
```

**Cursor**

```bash
# terminal; vendor line from the docker/mcp-gateway README
docker mcp profile create --name dev-tools \
  --server catalog://mcp/docker-mcp-catalog/github --connect cursor
```

Zatwierdź powstały wpis bramki w `.cursor/mcp.json` i przeglądaj jego zmiany tak jak kod.

Poza Docker Desktop najpierw uruchom `docker mcp feature enable profiles`. Profile można wypychać do rejestru OCI i z niego pobierać; w ten sposób jeden przejrzany profil trafia na każdą maszynę.

Materiały badawcze tej witryny wymieniają jeszcze dwie ścieżki z bramką, których tu nie testowano: proxy LiteLLM ma bramkę MCP obok bramki modeli, a polityka [Claude apps gateway](/pl/claude-code/team/llm-gateway/) jest jednym ze źródeł zarządzanych, z których Claude Code czyta `managedMcpServers`. Zanim na którejś się oprzesz, sprawdź ją w jej własnej dokumentacji.

**Pułapki przy dopuszczaniu serwerów MCP**

- **Nazwa w rejestrze to nie tożsamość dostawcy.** Niezwiązani wydawcy rejestrują łudząco podobne nazwy. Dopasuj repozytorium do organizacji dostawcy na GitHubie.
- **Bramka przenosi listę dozwolonych, a nie ją usuwa.** Gdy agenci ufają wpisowi bramki, prawdziwą listą staje się profil bramki. Przeglądaj zmiany profilu jak zmiany polityki.
- **Logi wywołań to nie zapis działań.** Log Dockera przechowuje nazwy narzędzi i kształt argumentów, bez wartości. Aby zobaczyć, co zmieniono, użyj dziennika audytu usługi docelowej (GitHub, Sentry).
- **W Codeksie nazwa jest kontraktem.** Programista, który zarejestruje GitHuba jako `gh` zamiast `github`, dostanie wyłączony serwer mimo zatwierdzonego URL.
- **Aktualizacja Claude Code może poszerzyć stały zestaw.** Od v2.1.259 (dziennik zmian Claude Code) `allowedMcpServers` nie filtruje już serwerów z `managed-mcp.json`, chyba że używają rozwijania `${VAR}`. Jeśli ukrywałeś tak część z nich, dodaj wpisy `deniedMcpServers`.
- **Zablokowane serwery znikają bez słowa.** Claude Code usuwa zablokowany serwer z `/mcp` i `claude mcp list`, nie podając powodu. Ogłaszaj każde usunięcie.

Bramka zmienia też koszt kontekstu: jeden wpis może udostępnić wszystkie narzędzia swojego profilu. Trzymaj osobne profile dla zespołów, mierz `/context` w Claude Code przed podłączeniem i po nim, a gdy lista narzędzi rośnie, sięgnij po techniki ze strony [jak obniżyć koszt tokenów MCP](/pl/ecosystem/mcp/reducing-mcp-token-cost/).

## Audytuj, które serwery naprawdę działają

Egzekwowanie mówi, co wolno uruchomić; audyt mówi, co zostało uruchomione. Zbieraj oba sygnały w jednym miejscu.

- **Telemetria Claude Code.** Przy skonfigurowanym [eksporcie OpenTelemetry](/pl/ecosystem/observability/agent-telemetry/) ustaw `OTEL_LOG_TOOL_DETAILS=1`, aby zdarzenia narzędzi zawierały nazwy serwerów i narzędzi MCP. Agreguj je po serwerze, żeby zobaczyć rzeczywiste użycie w każdym zespole.
- **Logi bramki.** Wysyłaj log wywołań bramki do tego samego kolektora i ustaw alert na wywołania narzędzi spoza oczekiwanego profilu.
- **Dzienniki audytu usług.** Przy serwerach z możliwością zapisu to dziennik audytu samej usługi pokazuje, co się zmieniło.

**Prompt do skopiowania: comiesięczny przegląd listy dozwolonych MCP**

```text
Monthly MCP allowlist review. Inputs: mcp-catalog/servers.yaml, the rendered
managed-settings.json and requirements.toml in this repository, and the CSV
export mcp-usage.csv (columns: date, team, tool, mcp_server, mcp_tool, count).

1. List catalog servers with zero calls in the last 30 days. Propose removal.
2. List any mcp_server in the usage export that is not in the catalog. For
   each, say which enforcement path should have blocked it.
3. For every catalog entry, compare the pinned version with the current
   package version (npm view / PyPI JSON) and flag version bumps that need a
   new review.
4. Confirm the three files agree on names, URLs and commands.
Output a Markdown table per section and a list of pull requests to open.
Do not edit any file.
```

## Jak udowodnić, że lista działa na każdej maszynie?

Nikt nie czyta każdego wywołania narzędzia. Sprawdzaj konfigurację mechanicznie na maszynie kontrolnej dla każdej platformy, a potem na próbce całej floty przy każdym wydaniu.

1. **Test negatywny w Claude Code.** Przy wdrożonym `managed-mcp.json` polecenie `claude mcp add --transport http test https://example.com/mcp` musi zakończyć się błędem `Cannot add MCP server: enterprise MCP configuration is active and has exclusive control over MCP servers`. Przy liście dozwolonych dodanie serwera spoza listy musi zwrócić `not allowed by enterprise policy`. URL nie musi istnieć; kontrola polityki odrzuca polecenie wcześniej.

2. **Kontrola inwentarza.** `claude mcp list` pokazuje tylko serwery z katalogu. Jeśli przy `managed-mcp.json` nadal widać własny serwer użytkownika, Claude Code nie czyta pliku: sprawdź ścieżkę i uprawnienia katalogów nadrzędnych. `/status` pokazuje wpisy `managedMcpServers`, które zostały odrzucone, i powód.

3. **Test niezgodnej nazwy w Codeksie.** Zarejestruj zatwierdzony URL pod złą nazwą i sprawdź, że Codex go wyłącza. To dowodzi, że plik wymagań jest wczytany, a nie tylko że akurat skonfigurowano właściwe serwery.

4. **Kontrola bramki.** Wywołaj jedno narzędzie przez bramkę i sprawdź, że wywołanie pojawia się w kolektorze z zespołem i nazwą narzędzia.

5. **Zatwierdzenie.** Tech lead jest właścicielem katalogu i zatwierdza dodania; osoba odpowiedzialna za bezpieczeństwo podpisuje każdy serwer z zapisem i dostępem do produkcji; zespół platformowy odpowiada za wdrożenie i powyższe testy. Wyniki każdego wydania zapisuj w repozytorium polityk.

Miarą, którą raportujesz zarządowi, jest **pokrycie egzekwowania**: odsetek sprawdzonych maszyn, na których testy negatywne przechodzą, osobno dla każdego narzędzia. Wszystko poniżej 100% to błąd wdrożenia, a nie kwestia polityki.

## Co psuje się przy wdrażaniu listy dozwolonych MCP?

**Programiści tracą serwer bez żadnego komunikatu.** Claude Code po cichu usuwa zablokowane serwery z `/mcp`. Naprawa: opublikuj katalog i listę usuwanych serwerów przed wdrożeniem i pokaż komunikat z testu negatywnego, żeby ludzie rozpoznawali działanie polityki.

**Codex wyłącza zatwierdzony serwer.** Nazwa różni się od klucza wymagania albo różnią się argumenty (`npx -y …` wobec `identity` bez `-y`). Naprawa: opublikuj dokładną linię `codex mcp add` dla każdego wpisu katalogu i generuj wymagania z tego samego pliku.

**Zadania CI padają przy starcie.** Zadanie, które przekazuje `--mcp-config` na maszynie z `managed-mcp.json`, kończy się komunikatem `You cannot dynamically configure MCP servers when an enterprise MCP config is present`. Naprawa: daj runnerom CI własny plik zarządzany z serwerami, których potrzebuje zadanie.

**Serwer dostarczony w ustawieniach nigdy się nie ładuje.** `managedMcpServers` odrzuca adresy `http://`, wpisy z `command` i odwołania `${VAR}`, a Claude Code starszy niż v2.1.259 ignoruje ten klucz. Naprawa: przeczytaj `/status`, popraw wpis i ustal minimalną wersję klienta we wdrożeniu.

**Użytkownicy i tak poszerzyli listę.** Brakuje `allowManagedMcpServersOnly`, więc dołączyły się listy z poziomu użytkownika. Naprawa: dodaj flagę. Przy więcej niż jednym źródle zarządzanym odczyt blokady ze wszystkich źródeł wymaga v2.1.273 lub nowszej, według dokumentacji zarządzanego MCP w Claude Code (sprawdzone 2026-09-26).

**Zmiana profilu bramki weszła bez przeglądu.** Ktoś dodał serwer do wspólnego profilu i wszyscy klienci go dostali. Naprawa: trzymaj profile w repozytorium polityk, wypychaj je do rejestru OCI tylko z CI i traktuj diff profilu jak diff listy dozwolonych.

## Co dalej z zarządzaniem MCP

- [Jedna polityka dla wszystkich agentów kodujących](/pl/org/managed-policy/) — Wdróż katalog w jednej wersjonowanej polityce dla Claude Code, Codeksa, Cursora i Copilota.
- [Zabezpieczanie serwerów MCP](/pl/ecosystem/mcp/mcp-security/) — Skanowanie, tryby tylko do odczytu i testy prompt injection dla każdego serwera z listy.
- [Bezpieczeństwo MCP dla CTO](/pl/cto-scorecard-guide/mcp-security/) — Jak autoryzować każdą tożsamość i narzędzie oraz co raportować zarządowi.
- [Tożsamość agentów i sekrety](/pl/org/agent-identity-and-secrets/) — Jakie poświadczenie powinien mieć każdy serwer MCP i jak je rotować.
- [Zespołowy marketplace pluginów](/pl/ecosystem/plugins/team-marketplace/) — Dystrybuuj zatwierdzone serwery jako pluginy instalowane z /plugin.
- [Wprowadzenie do MCP](/pl/ecosystem/mcp/) — Transporty, zakresy i format konfiguracji, jeśli dopiero zaczynasz z MCP.
