# Serwery MCP, które rozumieją twój kod: Serena, codebase-memory-mcp, Claude Context i Repomix

URL: https://developertoolkit.ai/pl/ecosystem/mcp/code-intelligence-mcp/
Description: Nawigacja po symbolach dla Claude Code, Codeksa i Cursora: zainstaluj Serenę, codebase-memory-mcp, Claude Context lub Repomix i zrób bezpieczny refaktor.

Serwery MCP do analizy kodu (code intelligence) dają agentowi wiedzę o strukturze repozytorium zamiast pętli grep i czytania plików. Serena wyszukuje i edytuje symbole przez serwery językowe, codebase-memory-mcp śledzi ścieżki wywołań w lokalnym grafie wiedzy, Claude Context wyszukuje semantycznie w bazie wektorowej, a Repomix pakuje repozytorium do jednego pliku. Poprawności zmiany żaden z nich nie dowodzi; robią to twoje testy.

Prosisz agenta o zmianę nazwy `OrderService.applyDiscount` w monorepo TypeScript liczącym 400 000 linii. Agent greppuje `applyDiscount`, czyta 30 plików, żeby odróżnić prawdziwe wywołania od fikstury testowej, napisu w logu i niezwiązanego `applyDiscount` w `CartService`, i kończy mu się kontekst, zanim cokolwiek zmieni. Serwer językowy zna odpowiedź od początku. Agentowi brakuje tylko narzędzia, które go zapyta.

Ta strona jest dla programistów, którzy refaktoryzują duże bazy kodu z agentem, i dla tech leadów, którzy decydują, na którym z tych serwerów zespół się ustandaryzuje. Dostajesz tabelę decyzyjną dla czterech serwerów, Serenę zainstalowaną zgodnie z upstreamem we wszystkich trzech narzędziach, przykład zmiany nazwy we wszystkich wywołaniach, czteroetapowy proces refaktoryzacji (mapa, plan, edycja symboli, testy), audyt instalatora codebase-memory-mcp oraz typowe awarie z krokami naprawy. Strona zakłada, że dodawałeś już serwer MCP; jeśli nie, zacznij od [przeglądu MCP](/pl/ecosystem/mcp/).

## Który serwer code intelligence pasuje do twojej bazy kodu?

Cztery serwery odpowiadają na różne pytania. Wybieraj według pytania, które najczęściej zadajesz agentowi, a nie według liczby gwiazdek.

| | Serena | codebase-memory-mcp | Claude Context | Repomix |
| --- | --- | --- | --- | --- |
| **Odpowiada na** | „Gdzie jest ten symbol, kto się do niego odwołuje, zmień mu nazwę” | „Co to wywołuje, co wywołuje to, czego dotyka ten diff” | „Gdzie jest kod, który obsługuje X” (po znaczeniu) | „Daj mi całe repozytorium albo jego wycinek w jednym pliku” |
| **Silnik** | Serwery językowe (LSP) albo płatna wtyczka JetBrains | Graf wiedzy z Tree-sittera zapisany lokalnie oraz embeddingi wbudowane w binarkę do lokalnego wyszukiwania semantycznego | Embeddingi w bazie wektorowej Milvus lub Zilliz | Kompresja i pakowanie przez Tree-sitter |
| **Edytuje kod** | Tak: `rename_symbol`, `replace_symbol_body`, `insert_after_symbol`, `safe_delete_symbol` | Nie, graf tylko do odczytu | Nie | Nie |
| **Kod opuszcza maszynę** | Nie | Nie (README: „100% locally”) | Tak przy hostowanym dostawcy embeddingów lub Zilliz Cloud; nie przy lokalnym Milvusie i Ollamie | Nie, chyba że pakujesz zdalne repozytorium |
| **Wymaga** | `uv` oraz serwera językowego dla każdego języka | Jednej natywnej binarki | Node.js 20+, bazy wektorowej, dostawcy embeddingów | Node.js (`npx`) |
| **Aktualna wersja (2026-09-26)** | PyPI `serena-agent` 1.7.0 (2026-08-09) | 0.11.0 na npm i PyPI | npm `@zilliz/claude-context-mcp` 0.1.15 (2026-06-22) | npm `repomix` 1.18.1 (2026-09-21) |

Reguły decyzyjne, które wynikają z tabeli:

- **Zmiany nazw, przenoszenie i zmiany sygnatur w języku typowanym**: Serena. Tylko ona z tej czwórki edytuje kod, a zmiana nazwy przez serwer językowy jest dokładna tam, gdzie zamiana tekstu nie jest.
- **„Co się zepsuje, jeśli to zmienię?” w kodzie, którego nie znasz**: codebase-memory-mcp. `trace_path` i `detect_changes` odpowiadają na pytania o wpływ zmiany jednym wywołaniem.
- **Szukanie kodu po intencji w bardzo dużym repozytorium** („gdzie ponawiamy płatności?”), gdy organizacja już utrzymuje bazę wektorową: Claude Context. Najpierw wypróbuj lokalne wyszukiwanie semantyczne codebase-memory-mcp; Claude Context jest najcięższy w utrzymaniu.
- **Przekazanie modelowi całego repozytorium, także cudzego, za jednym razem** albo zamiana biblioteki w skill referencyjny: Repomix.

Serena i codebase-memory-mcp dobrze się uzupełniają: graf wyznacza zasięg zmiany, serwer językowy wykonuje edycję. Instalacja wszystkich czterech kosztuje kontekst i niewiele daje.

**Claude Code ma wbudowaną opcję nawigacji**

Wtyczki Claude Code mogą dostarczać serwery LSP. `typescript-lsp@claude-plugins-official` i `pyright-lsp@claude-plugins-official` dają Claude Code wyszukiwanie referencji bez żadnego serwera MCP; binarkę serwera językowego instalujesz osobno. Zobacz [nawigację po symbolach przy zmianie nazw](/pl/claude-code/build/refactoring-patterns/). Serena to wybór międzynarzędziowy: ten sam serwer działa w Claude Code, Codeksie i Cursorze i dodaje edycję na poziomie symboli.

## Zainstaluj Serenę z upstreamu, nie z marketplace

README Sereny mówi wprost: „Do not install Serena via an MCP or plugin marketplace! They contain outdated and suboptimal installation commands.” Wtyczka `serena` w `claude-plugins-official` nadal uruchamia Serenę przez `uvx --from git+https://github.com/oraios/serena`, czyli drogą, przed którą ostrzega upstream. Zainstaluj narzędzie raz, a potem wskaż je każdemu agentowi.

1. Zainstaluj `uv` (jedyne wymaganie Sereny), potem zainstaluj Serenę jako narzędzie uv i ją zainicjalizuj:

   ```bash
   uv tool install -p 3.13 serena-agent
   serena init
   ```

   `serena init` konfiguruje domyślny backend oparty na serwerach językowych. Niektóre języki wymagają dodatkowej zależności; wymienia je strona o obsłudze języków w dokumentacji Sereny. `serena-agent` 1.7.0 wymaga Pythona od 3.11 do 3.14 (PyPI, sprawdzone 2026-09-26).

2. Podłącz agenta. Konteksty różnią się między narzędziami, bo każdy kontekst wyłącza te narzędzia Sereny, które dublują własne narzędzia agenta do plików i powłoki.

   **Claude Code**

   ```bash
   # all projects; Serena activates the directory Claude Code starts in
   claude mcp add --scope user serena -- serena start-mcp-server --context claude-code --project-from-cwd
   ```

   `serena setup claude-code` zapisuje ten sam wpis za ciebie. Jeśli Serena startuje zbyt wolno i `/mcp` pokazuje ją jako niedziałającą, ustaw `MCP_TIMEOUT=60000` w profilu powłoki, jak radzi dokumentacja klientów Sereny.

   **Codex**

   ```bash
   serena setup codex
   ```

   Albo dodaj blok samodzielnie do `~/.codex/config.toml`:

   ```toml
   [mcp_servers.serena]
   startup_timeout_sec = 15
   command = "serena"
   args = ["start-mcp-server", "--project-from-cwd", "--context=codex"]
   ```

   Aplikacja Codex nie uruchamia sesji w katalogu projektu. Tam zacznij od „Activate the current dir as project using serena”.

   **Cursor**

   Dodaj Serenę do `~/.cursor/mcp.json`. Upstream zaleca kontekst `ide` dla integracji z IDE; poniższy JSON wyprowadzono z tej wskazówki i nie był testowany w binarce Cursora:

   ```json
   {
     "mcpServers": {
       "serena": {
         "command": "serena",
         "args": ["start-mcp-server", "--context", "ide"]
       }
     }
   }
   ```

   Przy globalnym wpisie Serena nie wie, który projekt jest otwarty. Zaczynaj każdy czat od „Activate the current dir as project using serena”. Jeśli Cursor nie znajduje polecenia `serena`, podaj pełną ścieżkę, którą wypisuje `which serena`.

3. Sprawdź połączenie. Uruchom `/mcp` w Claude Code lub Codeksie (w Cursorze otwórz listę MCP w ustawieniach) i potwierdź, że `serena` jest połączona. Potem poproś: „Use serena to give me the symbols overview of src/orders/order-service.ts”. Agent powinien wywołać `get_symbols_overview`, a nie czytać plik.

### Jak sprawić, żeby agent używał Sereny, a nie grepa

Dokumentacja klientów Sereny podaje, że nowsze wydania Claude Code i nowsze modele mocno ciążą ku wbudowanym narzędziom, więc w długich sesjach agent często pomija Serenę. Upstream dostarcza na to hooki (oznaczone jako alfa). `remind` przypomina agentowi o Serenie po serii wywołań `grep` lub `read_file`, `activate` aktywuje projekt na starcie sesji, a `cleanup` sprząta stan hooków na końcu. Dodaj je do `.claude/settings.json`:

```json
{
  "hooks": {
    "SessionStart": [
      { "matcher": "", "hooks": [{ "type": "command", "command": "serena-hooks activate --client=claude-code" }] }
    ],
    "PreToolUse": [
      { "matcher": "", "hooks": [{ "type": "command", "command": "serena-hooks remind --client=claude-code" }] }
    ],
    "SessionEnd": [
      { "matcher": "", "hooks": [{ "type": "command", "command": "serena-hooks cleanup --client=claude-code" }] }
    ]
  }
}
```

Upstream oferuje też hook `auto-approve` i zastępczy prompt systemowy (`claude --system-prompt="$(serena prompts print-cc-system-prompt-override)"`). Na początek pomiń oba. Hook zatwierdza narzędzia edycyjne Sereny bez pytania, gdy pracujesz w trybie `acceptEdits` lub `auto`, a `--system-prompt` zastępuje domyślny prompt systemowy Claude Code, zamiast go uzupełniać.

Dokumentacja Sereny podaje wersję dla Codeksa w `~/.codex/hooks.json` (`--client=codex`, `PreToolUse` dopasowane do `Bash` oraz hook `reset` po narzędziach Sereny). Skopiuj ten blok z upstreamu zamiast przerabiać powyższy JSON; jego sprzątanie w `SessionEnd` wymaga Codeksa 0.145.0 lub nowszego. Ta sama dokumentacja każe też ustawić `codex_hooks = true` w sekcji `[features]`. W codex-cli 0.157.1 takiej flagi nie ma na liście: `codex features list` pokazuje `hooks` jako stabilną i domyślnie włączoną, więc ten krok pomiń. Codex uruchamia nowy lub zmieniony hook dopiero wtedy, gdy zaufasz mu w `/hooks` (codex-cli 0.157.1).

## Zmień nazwę OrderService.applyDiscount we wszystkich wywołaniach przez Serenę

To zadanie z początku strony. Prompt podaje symbol przez ścieżkę nazwy Sereny (`OrderService/applyDiscount`) i plik, więc serwer językowy rozpoznaje dokładnie jeden symbol.

**Prompt do skopiowania: zmiana nazwy na poziomie symbolu przez Serenę**

```text
Use serena for this task, not grep or text replacement.
1. find_symbol OrderService/applyDiscount in src/orders/order-service.ts and show its signature.
2. find_referencing_symbols for it and list every referencing symbol with its file. Mark which ones are tests.
3. Stop and show me that list before editing.
4. After I confirm, rename_symbol to applyPromotion. Then search for the string "applyDiscount" and report every remaining hit (strings, docs, mocks, dynamic property access) without changing them.
5. Run npm run typecheck and npm test and paste the summaries.
```

Co powinieneś zobaczyć: wywołania `find_symbol`, potem `find_referencing_symbols` (każdy wynik zawiera odwołujący się symbol i fragment kodu wokół referencji), pauzę na twoje potwierdzenie, a potem jedno wywołanie `rename_symbol`. Zmiana nazwy obejmuje w jednej operacji każdą referencję znaną serwerowi językowemu. `CartService.applyDiscount` zostaje nietknięty, bo to inny symbol.

Ostatnie wyszukiwanie tekstowe ma znaczenie. Serwer językowy nie widzi nazwy metody w napisie, fiksturze JSON, mocku w rodzaju `vi.spyOn(service, 'applyDiscount')` ani w `service[methodName]()`. W tych miejscach zmiana nazwy psuje się po cichu, a sprawdzenie typów nie wyłapie przypadków z napisami. W Javie i innych językach z przeciążaniem wybierz przeciążenie w `find_symbol` indeksem liczonym od zera, np. `OrderService/applyDiscount[0]`; dokumentacja `rename_symbol` w Serenie podaje, że jego ścieżka nazwy może zamiast tego wymagać sygnatury metody.

## Refaktoryzuj dużą bazę kodu: mapa wywołań, plan, edycja symboli, testy

Zmiana nazwy to jeden krok. Prawdziwy refaktor, na przykład wydzielenie logiki rabatów z `OrderService` do klasy `PromotionEngine`, wymaga najpierw zasięgu zmiany. Ten proces używa codebase-memory-mcp do mapy i Sereny do edycji. Przebiega tak samo we wszystkich trzech narzędziach; różni się tylko instalacja.

1. **Zapisz punkt odniesienia.** Na nowej gałęzi uruchom sprawdzenie typów, lint i pełny zestaw testów, i zachowaj wynik. Jeśli kod, który przenosisz, ma słabe pokrycie, najpierw dopisz testy charakteryzujące; [jak silna jest twoja wyrocznia testowa](/pl/workflows/test/oracle-strength/) pokazuje, jak to sprawdzić.

2. **Zmapuj wywołania.** Zaindeksuj repozytorium raz, potem prześledź ścieżki przychodzące.

   **Prompt do skopiowania: zasięg zmiany przez codebase-memory-mcp**

   ```text
   Use codebase-memory-mcp. If this repository is not indexed, run index_repository first and wait for index_status to report it done.
   Then run trace_path on OrderService.applyDiscount with direction inbound and depth 3, and search_graph for the HTTP routes that reach it.
   Write docs/refactor/promotion-engine-impact.md with: every caller grouped by module, the routes and background jobs that reach the method, and the tests that exercise each path. Mark callers that no test reaches. Do not edit code.
   ```

   Bez MCP to samo zapytanie uruchomisz w terminalu: `codebase-memory-mcp cli trace_path --project my-project --function-name applyDiscount --direction inbound`.

3. **Zaplanuj zmianę w przeglądalnych kawałkach.** Poproś o plan w pliku, który przeczytasz w całości.

   **Prompt do skopiowania: plan refaktoru z mapy wpływu**

   ```text
   Read docs/refactor/promotion-engine-impact.md. Plan moving the discount logic from OrderService into a new PromotionEngine class in src/promotions/. Split the work into slices that each keep the build green: 1) create PromotionEngine and delegate to it, 2) move callers module by module, 3) delete the delegate. For each slice list the symbols that change, the tests that prove it, and any caller marked as untested. Save it to docs/refactor/promotion-engine-plan.md. Do not edit code.
   ```

   Przejrzyj ten plan. To kontrakt dla reszty pracy, a wywołania bez testów to miejsca, w których dopisujesz testy przed przeniesieniem.

4. **Edytuj na poziomie symboli, kawałek po kawałku.**

   **Prompt do skopiowania: jeden kawałek planu przez Serenę**

   ```text
   Execute slice 1 of docs/refactor/promotion-engine-plan.md using serena's symbolic tools: create PromotionEngine, move the body of OrderService/applyDiscount with replace_symbol_body, and insert the delegating method with insert_after_symbol. Do not use text replacement on source files. After the edit, check get_diagnostics_for_file on every file you touched, run npm run typecheck and npm test, and commit only if both pass. Then stop and report.
   ```

5. **Udowodnij zmianę testami, potem sprawdź, co według grafu się zmieniło.** Uruchom pełną bramkę i porównaj z punktem odniesienia. Potem poproś agenta o `detect_changes`, które mapuje niezatwierdzony diff na dotknięte symbole z klasyfikacją ryzyka. Każdy dotknięty symbol powinien być w planie. Wszystko spoza planu to rozrost zakresu albo pominięte wywołanie.

## Zainstaluj codebase-memory-mcp tak, żeby nie przepisał ci konfiguracji

codebase-memory-mcp (DeusData) indeksuje repozytorium do trwałego lokalnego grafu i udostępnia 17 narzędzi MCP, w tym `index_repository`, `search_graph`, `trace_path` (alias `trace_call_path`), `detect_changes`, `query_graph` i `get_architecture`. Nie potrzebuje klucza API, a README stwierdza, że działa „100% locally and collects no telemetry”. `search_graph` wyszukuje też semantycznie modelem embeddingów wkompilowanym w binarkę, więc szukanie kodu po znaczeniu nie wymaga bazy wektorowej.

Instalacja jednym poleceniem to `curl -fsSL https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/install.sh | bash`. Skrypt pobiera natywną binarkę i uruchamia jej polecenie `install`, które wykrywa każdego agenta na maszynie i zapisuje jego konfigurację: dla Claude Code wpis MCP w `~/.claude.json` plus skill, trzech subagentów i hooki na `SessionStart`, `SubagentStart` oraz `PreToolUse` dla `Grep`, `Glob` i `Bash`. Dla Codeksa zapisuje `config.toml`, dodaje odnośnik w `$CODEX_HOME/AGENTS.md`, skill i agentów. Na komputerze zespołowym to więcej zmian, niż zamawiałeś.

1. **Przeczytaj skrypt, zanim go uruchomisz.** Pobierz `install.sh` (albo `install.ps1` na Windowsie) do pliku, przeczytaj go i dopiero wtedy uruchom.

2. **Zainstaluj samą binarkę.** Przekaż `--skip-config`, żeby instalator nie ruszał konfiguracji agentów:

   ```bash
   bash install.sh --skip-config
   ```

   Albo użyj menedżera pakietów: `npm install -g codebase-memory-mcp` lub `pip install codebase-memory-mcp` (oba 0.11.0, sprawdzone 2026-09-26).

3. **Dodaj serwer sam, tam gdzie chcesz.**

   **Claude Code**

   ```bash
   claude mcp add codebase-memory -- /usr/local/bin/codebase-memory-mcp
   ```

   **Codex**

   ```bash
   codex mcp add codebase-memory -- /usr/local/bin/codebase-memory-mcp
   ```

   **Cursor**

   ```json
   {
     "mcpServers": {
       "codebase-memory-mcp": { "command": "/usr/local/bin/codebase-memory-mcp", "args": [] }
     }
   }
   ```

   Zastąp `/usr/local/bin/codebase-memory-mcp` ścieżką, którą wypisuje `which codebase-memory-mcp`. Polecenia dla Claude Code i Codeksa wyprowadzono z JSON-a w README. `/mcp` powinno potem pokazać serwer z 17 narzędziami.

4. **Powiedz „Index this project”** i potwierdź wynik przez `index_status`. Aby nowe projekty indeksowały się automatycznie przy pierwszym połączeniu, uruchom `codebase-memory-mcp config set auto_index true`. Zaindeksowane projekty odświeża watcher działający w tle.

Jeśli pełny instalator już przeszedł, `codebase-memory-mcp uninstall` usuwa należące do niego wpisy konfiguracji, skille, hooki i instrukcje oraz sam plik binarny, pyta przed usunięciem indeksów i wypisuje (ale nie usuwa) ścieżkę skryptu instalacyjnego.

**Ostrzeżenie Defendera**

README podaje, że Microsoft Defender może oznaczyć binarkę z wydania jako `Trojan:Script/Wacatac.B!ml`, nazywa to znanym fałszywym alarmem i odsyła do dowodów w `SECURITY.md`. Nie każ programistom klikać „zignoruj”. Sprawdź SHA-256 z notatkami do wydania albo zbuduj ze źródeł i zostaw decyzję zespołowi bezpieczeństwa. Repozytorium zebrało ★44,9 tys. w siedem miesięcy od utworzenia 2026-02-24; traktuj to jako miarę uwagi, a nie audyt.

## Claude Context: wyszukiwanie semantyczne, gdy możesz utrzymać bazę wektorową

Claude Context (Zilliz) dzieli kod na fragmenty według AST, liczy dla nich embeddingi, zapisuje je w Milvusie lub Zilliz Cloud i odpowiada na zapytania w języku naturalnym hybrydowym wyszukiwaniem BM25 i wektorowym. Udostępnia cztery narzędzia: `index_codebase`, `search_code`, `clear_index` i `get_indexing_status`. Najbardziej pomaga tam, gdzie powiązany kod nie ma wspólnego słownictwa, więc wyszukiwanie tekstowe go nie znajdzie.

To też jedyny serwer w tym zestawieniu z zależnościami zewnętrznymi. Przy domyślnym `EMBEDDING_PROVIDER=OpenAI` fragmenty kodu trafiają do API embeddingów, a wektory do Zilliz Cloud. W pełni lokalnie zadziała z własnym Milvusem i `EMBEDDING_PROVIDER=Ollama`.

Trzymaj klucze poza linią poleceń i poza commitowanymi plikami:

**Claude Code**

```bash
claude mcp add --scope project claude-context \
  -e 'OPENAI_API_KEY=${OPENAI_API_KEY}' -e 'MILVUS_TOKEN=${MILVUS_TOKEN}' \
  -- npx -y @zilliz/claude-context-mcp@0.1.15
```

Pojedyncze cudzysłowy zostawiają `${OPENAI_API_KEY}` dosłownie w `.mcp.json` (sprawdzone w Claude Code 2.1.283); Claude Code podstawia wartość ze środowiska przy starcie.

**Codex**

```bash
codex mcp add claude-context -- npx -y @zilliz/claude-context-mcp@0.1.15
```

Potem przekaż zmienne z powłoki zamiast je zapisywać: dodaj jedną linię do nowego bloku w `~/.codex/config.toml`:

```toml
env_vars = ["OPENAI_API_KEY", "MILVUS_TOKEN"]
```

`codex mcp get claude-context` pokazuje wtedy obie zmienne jako zamaskowane (codex-cli 0.157.1).

**Cursor**

README wpisuje klucze w blok `env`; trzymaj to w globalnym `~/.cursor/mcp.json`, nigdy w repozytorium:

```json
{
  "mcpServers": {
    "claude-context": {
      "command": "npx",
      "args": ["-y", "@zilliz/claude-context-mcp@0.1.15"],
      "env": { "OPENAI_API_KEY": "YOUR_OPENAI_KEY", "MILVUS_TOKEN": "YOUR_ZILLIZ_TOKEN" }
    }
  }
}
```

`MILVUS_ADDRESS` jest opcjonalne przy osobistym kluczu API Zilliz; dodaj je dla własnego Milvusa. Potem przejdź ścieżkę dostawcy: „Index this codebase”, „Check the indexing status”, „Find functions that handle user authentication”.

Zanim się na nim ustandaryzujesz, oceń kondycję projektu. Na 2026-09-26 ostatnie wydanie npm pochodziło z 2026-06-22, ostatni push z 2026-07-14. Strojenie indeksu przy wyszukiwaniu semantycznym opisuje strona o [wyszukiwaniu semantycznym w dużych bazach kodu](/pl/workflows/build/large-codebases/#daj-agentowi-analizę-kodu-zamiast-pętli-grepa).

## Repomix: całe repozytorium w jednym pliku

Repomix pakuje repozytorium albo jego wycinek wybrany globem do jednego pliku przyjaznego modelom (domyślnie XML), z liczbą tokenów i skanem sekretów przez Secretlint. To bardziej format dostarczenia niż indeks. Używaj go, żeby przestudiować cudzą bibliotekę bez klonowania jej do projektu, przekazać modelowi cały moduł naraz albo wygenerować skill referencyjny.

Jako serwer MCP w wersji 1.18.1 rejestruje sześć narzędzi (przetestowany handshake, 2026-09-26): `pack_codebase`, `pack_remote_repository`, `read_repomix_output`, `grep_repomix_output`, `generate_skill` i `attach_packed_output`.

**Claude Code**

```bash
claude mcp add repomix -- npx -y repomix --mcp
```

Repomix ma też własny marketplace wtyczek: `/plugin marketplace add yamadashy/repomix`, a potem `/plugin install repomix-mcp@repomix`.

**Codex**

```bash
codex mcp add repomix -- npx -y repomix --mcp
```

**Cursor**

```json
{ "mcpServers": { "repomix": { "command": "npx", "args": ["-y", "repomix", "--mcp"] } } }
```

Dodaj `--sandbox` po `--mcp`, żeby ograniczyć narzędzia plikowe do katalogu roboczego. Bez tej flagi README mówi, że serwer „can read any path the host user can”; z nią pakowanie zdalne i generowanie skilli są wyłączone.

CLI robi to samo bez MCP:

```bash
npx repomix --compress                                       # packs the current directory into repomix-output.xml
npx repomix --remote yamadashy/repomix --compress            # packs a GitHub repository without cloning it
npx repomix --include "src/**/*.ts" --ignore "**/*.test.ts"  # packs a slice
npx repomix --skill-generate                                 # writes a Claude Agent Skill to .claude/skills/<name>/
```

`--compress` używa Tree-sittera, żeby zachować sygnatury i pominąć ciała funkcji. Dostawca deklaruje około 70% mniej tokenów; ta strona tego nie mierzyła. `--skill-output <path>` zapisuje skill gdzie indziej, jeśli twój agent czyta skille z innego katalogu.

**Prompt do skopiowania: poznaj bibliotekę, zanim od niej uzależnisz projekt**

```text
Use repomix pack_remote_repository on honojs/hono with compress on and includePatterns "src/**". Then grep_repomix_output for how middleware ordering works. Explain the order in which middleware runs, with the file and function names you found, and tell me what our src/server/app.ts must change to put the auth middleware before rate limiting.
```

## Jak udowodnić poprawność refaktoru bez czytania każdej linii?

Serwer code intelligence sprawia, że edycje agenta są precyzyjniejsze. Nie sprawia, że są poprawne. Dowodem jest ta sama bramka co przy każdej zmianie agenta, plus dwa sprawdzenia, które te serwery czynią tanimi.

| Sprawdzenie | Co wyłapuje | Kto odpowiada |
| --- | --- | --- |
| Sprawdzenie typów i lint na każdym kawałku | Pominięte referencje w kodzie typowanym, zepsute importy | CI, blokujące |
| Pełny zestaw testów porównany z punktem odniesienia | Zmiany zachowania, których typy nie widzą | CI, blokujące |
| Pliki testów bez zmian, chyba że plan je wymienia (`git diff --stat -- '*.test.ts'`) | Agenta, który „naprawił” testy, żeby refaktor przeszedł | Recenzent |
| Pozostałe wystąpienia starej nazwy w tekście, wypisane w PR | Nazwy pominięte w napisach, mockach, fiksturach i dostępie dynamicznym | Autor (agent), sprawdza recenzent |
| Wynik `detect_changes` zgodny z listą symboli z planu | Rozrost zakresu i pominięte wywołania | Recenzent |
| Pliki z mapą wpływu i planem dołączone do PR | Refaktor, którego nikt nie zaudytuje po fakcie | Tech lead |

Tech lead zatwierdza na podstawie tych dowodów. Strona o [pakiecie dowodów](/pl/workflows/ship/evidence-bundle/) ma szablon PR, który czyni te wiersze obowiązkowymi, a [przegląd pull requesta od agenta](/pl/workflows/ship/agent-pr-review/) opisuje sam przegląd.

## Ile kontekstu kosztują serwery code intelligence

Każdy serwer dodaje do sesji definicje narzędzi, a niektóre zwracają duże wyniki. Claude Code 2.1.283 i codex-cli 0.157.1 domyślnie ładują schematy narzędzi MCP przez tool search, więc bezczynne serwery kosztują mało; okno zapełniają wyniki.

- **Serena**: użyj kontekstu pasującego do agenta (`claude-code`, `codex`, `ide`), żeby nie płacić za zdublowane narzędzia do plików i powłoki.
- **codebase-memory-mcp**: domyślnie stronicuje odpowiedzi i przyjmuje `max_output_tokens`. Proś o jeden poziom głębokości naraz zamiast całego drzewa wywołań.
- **Repomix**: spakowane repozytorium to największy pojedynczy wynik, jaki możesz dodać. Pakuj wycinek globem z `--compress` i przeszukuj wynik grepem zamiast czytać go w całości.
- **Claude Context**: `search_code` zwraca fragmenty, więc węższe zapytania zwracają mniej.

Mierz zamiast zgadywać: uruchom `/context` w Claude Code przed jednym zapytaniem i po nim. Ogólny wzorzec opisuje strona o [obniżaniu kosztu tokenów MCP](/pl/ecosystem/mcp/reducing-mcp-token-cost/).

## Jak popularne są te serwery?

Na 2026-09-26 (gwiazdki GitHub odczytane ze stron repozytoriów; instalacje wtyczek z claude.com/plugins): codebase-memory-mcp ★44,9 tys., Serena ★29,8 tys. i 89 147 instalacji wtyczki z marketplace, Repomix ★28 494, Claude Context ★12 572. Serena, codebase-memory-mcp i Repomix są w oficjalnym rejestrze MCP; Claude Context nie.

## Kiedy serwery code intelligence zawodzą

**Agent ignoruje Serenę i i tak greppuje.** W długich sesjach wygrywają wbudowane narzędzia. Naprawa: dodaj hooki `remind` i `activate` opisane wyżej i nazwij narzędzie Sereny w prompcie („use find_referencing_symbols”).

**Serena nie widzi symboli albo trafia w zły projekt.** Globalna konfiguracja uruchomiła Serenę poza repozytorium albo brakuje serwera językowego dla danego języka. Naprawa: aktywuj projekt tak, jak pokazują wyżej zakładki Codex i Cursor, w Claude Code i Codeksie używaj `--project-from-cwd` i zainstaluj zależność ze strony o obsłudze języków w dokumentacji Sereny.

**`/mcp` pokazuje Serenę jako niedziałającą po starcie.** Serwer językowy startuje dłużej, niż klient czeka. Naprawa: ustaw `MCP_TIMEOUT=60000` dla Claude Code albo zwiększ `startup_timeout_sec` w Codeksie.

**Zmiana nazwy przeszła sprawdzenie typów, ale wysypała się w czasie działania.** Napis, mock, fikstura albo wywołanie `obj[name]()` nadal używa starej nazwy. Naprawa: po każdej zmianie nazwy szukaj starej nazwy w tekście, jak wymaga prompt powyżej, i popraw te miejsca ręcznie albo przejrzaną zamianą tekstu.

**`trace_path` pomija wywołanie.** Dynamiczne wywołanie, wstrzykiwanie zależności po tokenie tekstowym albo refleksja nie zostawiają krawędzi statycznej. Naprawa: uruchom `check_index_coverage` dla tych ścieżek, porównaj z `find_referencing_symbols` z Sereny, a to, czego nie widzi żadne z nich, zostaw testom.

**codebase-memory-mcp zmienił konfigurację twojego agenta.** Nowe hooki odpalają się przy każdym wywołaniu `Grep` i `Bash`, a pojawił się skill, którego nie instalowałeś. Naprawa: `codebase-memory-mcp uninstall`, potem ponowna instalacja z `--skip-config` i ręczne dodanie serwera.

**Claude Context zwraca nieaktualne wyniki.** Indeks powstał przed dużym merge'em albo przepisaniem historii. Naprawa: `clear_index`, potem ponownie `index_codebase`, i sprawdź `get_indexing_status`, zanim zaczniesz pytać.

**Spakowane repozytorium zalało kontekst.** Naprawa: pakuj wycinek przez `--include`, używaj `--compress` i pozwól agentowi wywoływać `grep_repomix_output` zamiast `read_repomix_output` na całym pliku.

**Pułapki: nazwy i ścieżki instalacji, które wyglądają dobrze, a są złe**

Sprawdzone 2026-09-26 w PyPI, npm, Claude Code 2.1.283 i codex-cli 0.157.1:

- **`serena` na PyPI lub npm**: oba to niezwiązane pakiety. Właściwy pakiet to PyPI `serena-agent`, instalowany przez `uv tool install -p 3.13 serena-agent`.
- **Wtyczka `serena` z marketplace**: nadal używa ścieżki `uvx --from git+…`, przed którą ostrzega upstream.
- **`codex_hooks = true`** z przewodnika Sereny dla Codeksa: w codex-cli 0.157.1 nie ma takiej flagi na liście, a `hooks` jest stabilne i włączone.
- **`repomix` na PyPI (0.5.0) i `@repomix/mcp` na npm**: pierwszy to niezwiązany pakiet, drugi nie istnieje. Serwer to npm `repomix` z `--mcp`.
- **npm `claude-context` (2.0.0)**: niezwiązany szablon, a `@zilliz/claude-context` nie istnieje. Serwer to `@zilliz/claude-context-mcp`.
- **Wtyczka `zilliz` w `claude-plugins-official`**: skille do zarządzania Zilliz Cloud, nie Claude Context.

**Co te serwery mogą czytać**

Każdy z tych serwerów działa z uprawnieniami twojego użytkownika i czyta drzewo źródeł. Repomix bez `--sandbox` może czytać każdą ścieżkę, którą ty możesz. Wyniki narzędzi są dla agenta niezaufanym wejściem, jak każdy plik, który czyta. Zanim wdrożysz którykolwiek z nich w zespole, przeczytaj o [zabezpieczaniu serwerów MCP](/pl/ecosystem/mcp/mcp-security/).

## Dokąd dalej z analizą kodu

- [Strategie dla dużych baz kodu](/pl/workflows/build/large-codebases/) — Dzielenie zmian, hierarchie kontekstu i równoległe refaktory na milionie linii.
- [Wzorce refaktoryzacji w Claude Code](/pl/claude-code/build/refactoring-patterns/) — Wtyczki LSP, pętle przenieś-i-sprawdź i bramki refaktoru w Claude Code.
- [Indeksowanie i wyszukiwanie kodu](/pl/workflows/context/codebase-indexing/) — Jak każdy agent przeszukuje twój kod i jak ułatwić mu znalezienie go.
- [Najważniejsze serwery MCP](/pl/ecosystem/mcp/top-mcp-servers/) — Gdzie ta czwórka plasuje się wśród serwerów, które zespoły instalują najczęściej.
- [Pakiet dowodów](/pl/workflows/ship/evidence-bundle/) — Szablon PR, dzięki któremu dowody refaktoru da się przejrzeć.
- [Hooki w Claude Code](/pl/claude-code/automate/hooks-automation/) — Jak działają hooki takie jak przypomnienia Sereny i jak je debugować.
