# Bramki i modele lokalne: LiteLLM, CC Switch, Claude Code Router, Ollama i LM Studio

URL: https://developertoolkit.ai/pl/ecosystem/agent-tools/gateways-local-models/
Description: Claude Code i Codex przez LiteLLM, CC Switch, Claude Code Router lub OpenRouter albo na Ollamie, LM Studio i llama.cpp, z budżetem na osobę.

Bramka albo lokalny serwer modeli pozwala uruchomić Claude Code i Codex na modelach innych niż endpoint dostawcy: Claude Code przez `ANTHROPIC_BASE_URL` i zmienną z poświadczeniem, Codex przez `--oss` albo własnego dostawcę. LiteLLM dokłada budżety na programistę, a Ollama, LM Studio i llama.cpp serwują modele lokalnie. Za każdą z nich przestają działać Remote Control i dyktowanie głosowe.

Ta strona jest dla **programisty**, który ma uruchomić agenta w sieci, z której kod nie może wyjść, i dla **tech leada**, który potem daje tę samą konfigurację ośmiu osobom z limitem wydatków. Dział bezpieczeństwa zgodził się na „wyłącznie modele lokalne” dla jednego repozytorium; na jednym laptopie agent po dwóch turach zapomniał o instrukcjach, a na kolejnym ktoś użył tagu `:cloud`, nie zauważając tego. Potrzebujesz konfiguracji sprawdzalnie lokalnej, z budżetem na osobę i głośnym błędem przy złym ustawieniu.

## Co daje ci konfiguracja bramki i modeli lokalnych

- **Jedną regułę**, której podlega każda bramka dla Claude Code, i miejsca, w których po cichu się psuje.
- **Tabelę decyzyjną**, która przypisuje twojej sytuacji narzędzie.
- **Działający przykład**: Claude Code na lokalnym modelu z Ollamy, plus Codex i Cursor.
- **Workflow zespołowy**: Ollama za LiteLLM w odizolowanej sieci, z budżetem na programistę i testami, które dowodzą, że nic nie wychodzi.
- **Trzy prompty**, pułapki i typowe awarie z naprawami.

Który model serwować i jak zmierzyć różnicę jakości względem Claude Opus 5.5 czy GPT-6 Astra, opisuje strona o [modelach open-weight i hostowanych samodzielnie](/pl/ecosystem/models/open-weight/). Wersje i ceny modeli są w [centrum modeli](/pl/ecosystem/models/). Wdrożenie bramki dla modeli Claude w całej organizacji opisuje strona o [bramce LLM](/pl/claude-code/team/llm-gateway/), a samą decyzję o hostingu strona [gdzie działa model](/pl/org/model-hosting/).

## Jak Claude Code rozmawia z bramką albo modelem lokalnym?

Claude Code korzysta z Anthropic Messages API. Każdy serwer, który implementuje `POST /v1/messages`, może zastąpić Anthropic: ustawiasz na niego `ANTHROPIC_BASE_URL` i dajesz Claude Code poświadczenie. Ollama, LM Studio i `llama-server` z llama.cpp implementują ten endpoint samodzielnie, więc na jednej maszynie proxy jest opcjonalne. LiteLLM i Claude Code Router stoją przed wieloma backendami naraz.

Najczęściej pomijany element to zmienna z poświadczeniem. Dokumentacja bramek Claude Code (sprawdzona 2026-09-26) podaje trzy reguły:

| Zmienna | Wysyłana jako | Kiedy jej użyć |
| ------- | ------------- | -------------- |
| `ANTHROPIC_AUTH_TOKEN` | nagłówek `Authorization: Bearer` | Bramka oczekuje tokenu bearer; domyślny wybór, jeśli nikt ci nic nie powiedział |
| `ANTHROPIC_API_KEY` | nagłówek `x-api-key` | Bramka oczekuje klucza API; sesja interaktywna raz poprosi cię o jego zatwierdzenie |
| `apiKeyHelper` (ustawienia) | oba nagłówki | Poświadczenie rotuje albo pochodzi z sejfu |

1. **Samo `ANTHROPIC_BASE_URL` niczego nie przełącza.** Zmienna z poświadczeniem bramki ma pierwszeństwo przed zapisanym logowaniem claude.ai. Bez niej aktywne zostaje logowanie, a z nim jego limity i rozliczenia.
2. **Blok `env` w pliku ustawień wygrywa z eksportem w powłoce** tej samej zmiennej. Nigdy nie wpisuj poświadczenia do projektowego `.claude/settings.json`, bo ten plik trafia do repozytorium; użyj `~/.claude/settings.json` albo ustawień zarządzanych.
3. **Dowodem jest `/status`.** Zakładka **Status** pokazuje wiersz `Anthropic base URL` z adresem bramki i wiersz `Auth token` albo `API key` z nazwą ustawionej zmiennej. Wiersz `Login method` z kontem claude.ai oznacza, że poświadczenie bramki nie dotarło.

Przewodnik Ollamy dla Claude Code dodaje `ANTHROPIC_API_KEY=""` obok `ANTHROPIC_AUTH_TOKEN`, żeby zapomniany klucz API gdzieś w środowisku nie przejął sesji.

## Której bramki albo serwera modeli lokalnych użyć?

Zacznij od tego, kto z niej korzysta i gdzie działa model.

| Twoja sytuacja | Wybierz | Dlaczego |
| -------------- | ------- | -------- |
| Jedna osoba, chcesz dziś wypróbować model lokalny | **Ollama** (`ollama launch claude`) | Jedno polecenie podłącza Claude Code albo Codex do modelu lokalnego; Codex ma też `--oss` |
| Jedna osoba, aplikacja desktopowa i graficzny wybór modelu | **LM Studio** | CLI `lms`, lokalny endpoint `/v1/messages` i `--local-provider lmstudio` w Codex |
| Własna kwantyzacja, bez demona, nietypowy sprzęt | **llama.cpp** (`llama-server`) | Pełna kontrola; wywołania narzędzi wymagają `--jinja` |
| Jedna osoba przełącza Claude Code między kilkoma hostowanymi dostawcami | **CC Switch** albo **Claude Code Router** | CC Switch to aplikacja desktopowa, która przepisuje konfigurację dostawcy; CCR to lokalna bramka z regułami routingu i fallbackami |
| Jedna osoba, wiele hostowanych modeli za jednym kluczem | **OpenRouter** | Hostowany router z endpointem zgodnym z Anthropic (źródło wtórne, patrz niżej) |
| Zespół z kluczami, budżetami i logami, modele lokalne albo hostowane | Proxy **LiteLLM** | Klucze wirtualne dla każdego programisty, `max_budget` na klucz albo zespół, jedno miejsce do zmiany dostawcy |
| Modele Claude przez bramkę organizacji albo kontrakt chmurowy | Nie ta strona | [Bramka LLM](/pl/claude-code/team/llm-gateway/) i [gdzie działa model](/pl/org/model-hosting/) |

**Popularność na dzień 2026-09-26** (gwiazdki GitHub odczytane przez API GitHub): Ollama 181 740; CC Switch 136 915; llama.cpp 129 535; LiteLLM 59 639; Claude Code Router 37 429; otwartoźródłowe CLI `lms` od LM Studio 5318 (sama aplikacja jest zamknięta). Gwiazdki mierzą zainteresowanie, a nie bezpieczeństwo.

## Uruchom Claude Code na lokalnym modelu w Ollamie

To oficjalna integracja Ollamy z Claude Code (`docs/integrations/claude-code.mdx` w `ollama/ollama`, sprawdzona 2026-09-26). Działa, bo Ollama „supports a subset of the Anthropic Messages API”.

1. Uruchom Ollamę z kontekstem odpowiednim dla agenta. Domyślny kontekst Ollamy zależy od VRAM: 4k tokenów poniżej 24 GiB, 32k przy 24–48 GiB, 256k od 48 GiB. Ollama zaleca dla narzędzi programistycznych co najmniej 64 000 tokenów, więc na typowym laptopie domyślne ustawienie po cichu obcina prompt systemowy agenta:

   ```bash
   # Terminal 1
   OLLAMA_CONTEXT_LENGTH=64000 ollama serve
   ```

2. Uruchom Claude Code podłączony do modelu lokalnego. `qwen3.5` to tag z przewodnika Ollamy; zastąp go lokalnym tagiem, który sam oceniłeś:

   ```bash
   # Terminal 2, interactive: pick a model, Ollama starts Claude Code for you
   ollama launch claude

   # Headless, for scripts and CI: no selectors, pulls the model if needed
   ollama launch claude --model qwen3.5 --yes -- -p "How does this repository work? Name the entry point and the test command."
   ```

   `--yes` pomija selektory i wymaga `--model`. Wszystko po `--` trafia do Claude Code, więc `-p` uruchamia go w trybie print.

3. Sprawdź, czy model naprawdę działa lokalnie i z ustawionym kontekstem:

   ```bash
   ollama ps   # CONTEXT should read 64000; PROCESSOR should read 100% GPU
   ```

Powinieneś zobaczyć odpowiedź Claude Code, która wymienia pliki istniejące w twoim repozytorium. Jeśli odpowiedź jest ogólnikowa albo pomija pliki, model nie wywołał narzędzi: najpierw sprawdź kontekst w `ollama ps`, potem spróbuj modelu obsługującego wywołania narzędzi. Przewodnik Ollamy każe „use tools with compatible models”, a strona zgodności zaznacza, że kontrola wyboru narzędzi, narzędzia odroczone i hostowane wyszukiwanie w sieci „are not fully supported”.

Konfiguracja ręczna z tego samego przewodnika, bez `ollama launch`:

```bash
export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://localhost:11434
claude --model qwen3.5
```

**Tag :cloud to nie jest model lokalny**

Tagi modeli Ollamy kończące się na `:cloud` (w przykładach Ollamy są m.in. `kimi-k2.7-code:cloud` i `gemma4:cloud`) działają na serwerach Ollamy, nie na twojej maszynie. Przewodnik Ollamy dla Codex używa też drugiej pisowni, `gpt-oss:120b-cloud`, więc każdy tag zawierający `cloud` traktuj jako zdalny. Przewodniki Ollamy oferują też wyszukiwanie w sieci przez hostowaną usługę Ollamy (przewodnik Codex podaje, że wymaga ono `ollama signin`). Przypinaj wyłącznie tagi lokalne, wyłącz wyszukiwanie w sieci (krok 5 niżej) i sprawdź `ollama ps`, zanim zaufasz konfiguracji.

### Ten sam model lokalny w Codex albo Cursor

**Claude Code**

    Opisane wyżej: `ollama launch claude` albo `ANTHROPIC_BASE_URL` z `ANTHROPIC_AUTH_TOKEN` i `ANTHROPIC_API_KEY=""`. Dla LM Studio schemat jest ten sam po `lms server start`: `ANTHROPIC_BASE_URL=http://localhost:1234`, a jako `--model` podajesz ID załadowanego modelu. Endpoint opisuje dokumentacja LM Studio; połączenie z Claude Code pochodzi z wyciągu wyszukiwarki ze strony lmstudio.ai (źródło wtórne), więc zanim na nim polegasz, uruchom test dymny. `llama-server` uruchom z `--jinja` (wymagane do wywołań narzędzi) i `-c 65536`, a potem ustaw `ANTHROPIC_BASE_URL` na jego port; llama.cpp nie dokumentuje połączenia z Claude Code, więc obowiązuje ten sam test dymny.

**Codex**

    Codex ma wbudowany przełącznik dla lokalnych dostawców (`--oss` i `--local-provider`, `--help` codex-cli 0.157.1):

    ```bash
    codex --oss --local-provider ollama -m qwen3.5
    codex --oss --local-provider lmstudio -m LOADED_MODEL_ID   # after `lms server start`
    ollama launch codex                                        # Ollama writes a dedicated Codex profile
    codex --profile ollama-launch -c 'web_search="disabled"'   # that profile, with Ollama's hosted web search off
    ```

    `ollama launch codex --restore` usuwa ten profil.

    Przewodnik Ollamy dla Codex również wymaga co najmniej 64k kontekstu. Własny dostawca w `config.toml` musi obsługiwać Responses API (`wire_api = "responses"`); pełny blok jest na stronie o [modelach open-weight i hostowanych samodzielnie](/pl/ecosystem/models/open-weight/).

**Cursor**

    Czy agent Cursora może używać modelu serwowanego na twojej maszynie albo w twojej sieci, nie zweryfikowano na dzień 2026-09-26. Nie planuj konfiguracji wyłącznie lokalnej ani odizolowanej na Cursorze, dopóki opiekun konta Cursor nie potwierdzi ścieżki danych na piśmie. `claude` i `codex` działają w zintegrowanym terminalu Cursora, więc programista może zostać przy Cursorze jako edytorze, a dla objętego ograniczeniami repozytorium używać agenta terminalowego.

## Przełączanie dostawców dla jednej osoby: CC Switch, Claude Code Router i OpenRouter

Wszystkie trzy to narzędzia indywidualne. Żadne nie daje budżetów zespołowych, a dwa z nich wysyłają kod do hostowanych dostawców.

**CC Switch** (`farion1231/cc-switch`, MIT) to aplikacja desktopowa w Tauri, która przełącza dostawców, serwery MCP, skille i prompty dla Claude Code, Codex, Gemini CLI, OpenCode i sześciu innych narzędzi wymienionych w README. Instalacja: `brew install --cask cc-switch` na macOS albo instalator MSI, wersja przenośna lub buildy dla Linuksa z wydań na GitHubie. Istnieją strony podszywające się pod projekt, a aplikacja trzyma twoje klucze dostawców, więc pobieraj ją wyłącznie z wydań na GitHubie albo z `ccswitch.io`, jedynej strony, którą repozytorium nazywa oficjalną.

**Claude Code Router** (npm `@musistudio/claude-code-router` 3.1.1, MIT) określa się jako „a local model gateway and control plane for coding agents”. Wersja 3 to przede wszystkim aplikacja desktopowa, z alternatywnym CLI wymagającym Node 22 lub nowszego:

```bash
npm install -g @musistudio/claude-code-router
ccr ui    # management UI at http://127.0.0.1:3458; the gateway listens on http://127.0.0.1:3456
```

W interfejsie: **Providers** > **Add Provider**, potem **Server** > **Start**, potem **Agent Config** > wybierz Claude Code (albo Codex, OpenCode i inne) > zastosuj.

**OpenRouter** to hostowany router z endpointem zgodnym z Anthropic. Jego cookbook ustawia `ANTHROPIC_BASE_URL=https://openrouter.ai/api` i umieszcza klucz OpenRouter w `ANTHROPIC_AUTH_TOKEN`, a także ostrzega, że wywołania narzędzi i rozszerzone myślenie mogą nie działać z modelami spoza Anthropic. Oba szczegóły są wtórne (wyciąg wyszukiwarki ze strony openrouter.ai, nie sama strona, stan na 2026-09-26); sprawdź cookbook przed konfiguracją.

## Zespół w sieci odizolowanej z budżetem na programistę

To workflow, do którego prowadzi cała strona: **lokalny serwer modelu → bramka LiteLLM z kluczami i budżetami → zarządzane ustawienia agenta → testy dymne → ewaluacje → code review jak dotąd**. Serwer modelu nie nasłuchuje poza własnym hostem, każdy programista ma klucz z limitem wydatków, a ponieważ sieć blokuje ruch wychodzący do hostowanych endpointów, laptop bez klucza do bramki dostaje błąd zamiast po cichu użyć logowania claude.ai.

1. **Serwuj model na jednym hoście, tylko na localhost.** Uruchom Ollamę (albo vLLM, opisany na [stronie o modelach open-weight](/pl/ecosystem/models/open-weight/)) na serwerze z GPU z `OLLAMA_CONTEXT_LENGTH=64000`, pobieraj wyłącznie tagi lokalne i zostaw go na `localhost:11434`. LiteLLM działa na tym samym hoście i jest jedynym punktem, do którego łączą się programiści, więc serwer modelu nie potrzebuje własnego uwierzytelniania. Na brzegu sieci zablokuj laptopom programistów ruch wychodzący do hostowanych endpointów modeli i przepuszczaj tylko `llm-gw.internal`; bez tej blokady laptop bez klucza do bramki wraca do zapisanego logowania claude.ai.

2. **Zainstaluj LiteLLM z przypiętą wersją, z wewnętrznego lustra.** Wersje 1.82.7 i 1.82.8 opublikowane w PyPI 24 marca 2026 kradły poświadczenia; 1.82.8 dodawała też plik `.pth`, który uruchamia się przy każdym starcie Pythona. Obie zniknęły z PyPI (JSON PyPI z 2026-09-26 po 1.82.6 wymienia od razu 1.83.0), a incydent śledzi zgłoszenie BerriAI/litellm#24518. Lustro albo cache nadal może je przechowywać, więc przypnij wersję i weryfikuj skróty:

   ```bash
   uv tool install 'litellm[proxy]==1.102.1'
   # For a server image: pin with hashes and install with pip --require-hashes
   echo 'litellm[proxy]==1.102.1' > requirements.in
   uv pip compile --generate-hashes requirements.in -o requirements.txt
   ```

3. **Opisz model i jego cenę wewnętrzną.** Klucze wirtualne i budżety wymagają bazy Postgres, którą proxy odczytuje z `DATABASE_URL`. Lokalny model domyślnie nic nie kosztuje za token, więc budżet nigdy by nie zadziałał. Nadaj mu wewnętrzną cenę za token (koszt GPU podzielony przez zmierzoną przepustowość) przez `input_cost_per_token` i `output_cost_per_token`:

   ```yaml title="litellm-config.yaml"
   model_list:
     - model_name: local-coder
       litellm_params:
         model: ollama_chat/qwen3.5
         api_base: http://localhost:11434
         input_cost_per_token: 0.0000004    # internal price, not a vendor price
         output_cost_per_token: 0.0000016

   general_settings:
     master_key: os.environ/LITELLM_MASTER_KEY
     database_url: os.environ/DATABASE_URL
   ```

   ```bash
   litellm --config litellm-config.yaml    # listens on port 4000
   ```

4. **Wydaj każdemu programiście klucz z budżetem.** `models` ogranicza, co klucz może wywołać, `max_budget` limituje wydatki w twojej wewnętrznej walucie, a `budget_duration` go resetuje (na przykład `30d`). Klucz główny pochodzi z sejfu i nigdy nie trafia na maszynę programisty:

   ```bash
   curl -sS https://llm-gw.internal:4000/key/generate \
     -H "Authorization: Bearer $LITELLM_MASTER_KEY" \
     -H "Content-Type: application/json" \
     -d '{"key_alias": "dev-anna", "models": ["local-coder"], "max_budget": 50, "budget_duration": "30d"}'
   ```

   Adres bramki to `https`: klucze programistów i klucz główny przechodzą przez sieć wewnętrzną, więc zakończ TLS na reverse proxy przed LiteLLM (albo w samym LiteLLM) z certyfikatem z wewnętrznego CA. Jeśli Claude Code zgłosi wtedy błędy certyfikatów, zobacz `NODE_EXTRA_CA_CERTS` w sekcji [co psuje się za bramką](#co-psuje-się-za-bramką-i-jak-to-naprawić).

   Limit na poziomie zespołu ustawisz przez `POST /team/new`, który też przyjmuje `max_budget`, a `/key/info` pokazuje wydatki klucza.

5. **Skieruj każdego agenta na bramkę przez ustawienia zarządzane.** Zmapuj wszystkie aliasy modeli Claude Code na serwowany model, bo Claude Code wywołuje alias Haiku do pracy w tle, na przykład do tytułów sesji, a twoja bramka go nie serwuje. Wyłącz ruch nieistotny, który inaczej nadal idzie do Anthropic i GitHuba (sprawdzanie wersji, telemetria, informacje o wydaniach):

   ```json title="Managed settings: env block"
   {
     "env": {
       "ANTHROPIC_BASE_URL": "https://llm-gw.internal:4000",
       "ANTHROPIC_MODEL": "local-coder",
       "ANTHROPIC_DEFAULT_OPUS_MODEL": "local-coder",
       "ANTHROPIC_DEFAULT_SONNET_MODEL": "local-coder",
       "ANTHROPIC_DEFAULT_HAIKU_MODEL": "local-coder",
       "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
     },
     "permissions": {
       "deny": ["WebSearch", "WebFetch"]
     },
     "skipWebFetchPreflight": true
   }
   ```

   Każdy programista podaje własny klucz jako `ANTHROPIC_AUTH_TOKEN` (eksport w powłoce, `~/.claude/settings.json` albo `apiKeyHelper` czytający z sejfu). `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` wyłącza też automatyczne aktualizacje, więc dostarczaj Claude Code przez menedżer pakietów albo wewnętrzne lustro. `skipWebFetchPreflight` wyłącza sprawdzanie domen przez WebFetch, które mimo ustawionej zmiennej łączy się z `api.anthropic.com`. Reguła `deny` całkowicie odbiera agentowi wyszukiwanie i pobieranie stron, bo w sieci odizolowanej każde z nich jest drogą na zewnątrz (a przez Ollamę także wywołaniem jej hostowanego wyszukiwania). Gdzie leżą ustawienia zarządzane i jak są egzekwowane, opisuje strona o [polityce zarządzanej](/pl/org/managed-policy/).

   Dla Codex dodaj dostawcę w `config.toml` z `base_url = "https://llm-gw.internal:4000/v1"`, `env_key` wskazującym zmienną z kluczem programisty i `wire_api = "responses"`. LiteLLM dokumentuje endpoint Responses API; potwierdź go w swojej wersji, a test dymny niech pokaże, czy wywołania narzędzi Codex przetrwają drogę w obie strony.

6. **Zweryfikuj konfigurację, zanim ktokolwiek zacznie na niej pracować.** Przeprowadź testy z następnej sekcji na jednym laptopie, a potem wdrażaj.

7. **Rób code review wyników agenta tak samo jak wcześniej.** Model lokalny zmienia miejsce generowania tokenów, a nie sposób dowodzenia, że zmiana jest poprawna: merge nadal blokują testy, CI, [bot do code review](/pl/ecosystem/observability/ai-code-review-bots/) i zatwierdzenie przez człowieka.

## Jak udowodnić, że bramka działa i ruch zostaje lokalnie?

Przeprowadź te testy na jednej maszynie programisty przed wdrożeniem i po każdej aktualizacji bramki, modelu albo Claude Code. Tech lead (albo właściciel bramki w zespole platformowym) zatwierdza testy; recenzent pull requesta nadal zatwierdza każdą zmianę.

| Test | Jak | Warunek zaliczenia |
| ---- | --- | ------------------ |
| **Bramka odpowiada** | `curl -sS -w '\n%{http_code}\n' -X POST "$ANTHROPIC_BASE_URL/v1/messages" -H "Authorization: Bearer $ANTHROPIC_AUTH_TOKEN" -H "anthropic-version: 2023-06-01" -H "content-type: application/json" -d '{"model": "local-coder", "max_tokens": 1, "messages": [{"role": "user", "content": "."}]}'` | HTTP `200` i JSON z `"type":"message"` oraz tablicą `content`; `401` oznacza zły klucz albo zły nagłówek |
| **Sesja idzie przez bramkę** | `/status` w Claude Code | `Anthropic base URL` pokazuje bramkę; `Auth token` wskazuje `ANTHROPIC_AUTH_TOKEN`; brak wiersza `Login method` |
| **Narzędzia działają** | Prompt testu dymnego poniżej | Odpowiedź wymienia prawdziwe pliki i prawdziwe polecenie, bez ogólników |
| **Kontekst się mieści** | `ollama ps` na serwerze; `/context` w Claude Code | Kontekst serwera co najmniej 64 000; prompt systemowy i narzędzia zostawiają miejsce na pracę |
| **Budżet działa** | Wydaj testowy klucz z `"max_budget": 0.01` i wysyłaj prompty, aż się wyczerpie | Bramka odrzuca kolejne żądania; `/key/info` pokazuje wydatki |
| **Nic nie wychodzi** | Logi ruchu wychodzącego z laptopa i serwera podczas sesji | Brak połączeń z `api.anthropic.com`, `ollama.com` i innymi hostowanymi endpointami |

Jakość wyników to osobne pytanie niż łączność. Zanim zespół zacznie polegać na modelu lokalnym, przepuść te same 20–30 zadań z własnych scalonych pull requestów przez bramkę i przez model domyślny, zgodnie z protokołem ewaluacji na stronie o [modelach open-weight i hostowanych samodzielnie](/pl/ecosystem/models/open-weight/). Żadne źródło pierwotne nie mierzy spadku jakości modelu lokalnego w Claude Code, więc liczy się tylko twój własny odsetek zaliczonych zadań. Narzędzia do powtarzalnych przebiegów opisuje strona o [ewaluacji agentów](/pl/ecosystem/observability/evals-coding-agents/).

## Prompty do skopiowania dla bramek i modeli lokalnych

**Prompt do skopiowania: test dymny wymuszający wywołania narzędzi**

```text
Without asking me anything, do the following and report each result:
1. List the three largest files under src/ with their sizes, using a shell command.
2. Read package.json (or pyproject.toml) and tell me the exact test command.
3. Run that test command with a filter that selects a single test file, and
   report the exit code.
If you cannot run a tool, say "TOOL CALL FAILED" and stop. Do not guess file
names or commands.
```

**Prompt do skopiowania: konfiguracja bramki LiteLLM i skrypt do kluczy**

```text
Write two files for an internal LiteLLM gateway that serves one Ollama model.
1. litellm-config.yaml: a model_list entry with model_name "local-coder",
   model "ollama_chat/qwen3.5", api_base http://localhost:11434, and
   input_cost_per_token / output_cost_per_token set from these numbers:
   GPU cost 2.40 per hour, measured throughput 1,500 output tokens per
   second and 6,000 input tokens per second. Show the arithmetic.
   general_settings reads master_key and database_url from os.environ/.
2. scripts/issue-key.sh: takes a developer alias and a monthly budget,
   calls POST /key/generate with key_alias, models ["local-coder"],
   max_budget and budget_duration "30d", reads LITELLM_MASTER_KEY from the
   environment, and prints only the new key. Fail on a non-200 response.
Pin litellm[proxy]==1.102.1 in requirements.in. Never put a key in a file.
Show the files; do not run anything.
```

**Prompt do skopiowania: audyt laptopa pod kątem ruchu z pominięciem bramki**

```text
Audit how Claude Code on this machine reaches a model. Read, without
printing secret values: the env block of ~/.claude/settings.json, the
project's .claude/settings.json and .claude/settings.local.json, and the
shell variables whose names start with ANTHROPIC_ or CLAUDE_CODE_.
Report in a table: which file or shell sets ANTHROPIC_BASE_URL, which
credential variable is set and where, whether ANTHROPIC_API_KEY is set to
a non-empty value anywhere, whether all four ANTHROPIC_*MODEL variables
point at the same served model, and whether
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC is 1. Flag any credential in a
committed file and any model name that contains "cloud".
```

**Pułapki: polecenia dla bramek i modeli lokalnych, które wyglądają dobrze, a nie są**

- **`npm i litellm`.** Pakiet npm `litellm` to niepowiązany port w JavaScripcie. Proxy to pakiet PyPI `litellm[proxy]`, z przypiętą wersją.
- **`ccr code` jako szybki start v3.** README wersji 3 używa aplikacji desktopowej albo `npm install -g @musistudio/claude-code-router` i `ccr ui`.
- **`llama-server` bez `--jinja`.** Wywołania narzędzi go wymagają; obecne buildy włączają go domyślnie, starsze nie.
- **Popularne proxy „darmowego Claude”.** Projekty, które udostępniają subskrypcje konsumenckie albo łączą darmowych dostawców w jedno API (na przykład CLIProxyAPI czy sub2api), mogą łamać regulaminy dostawców. Nie wdrażaj ich bez przeglądu warunków.

## Co psuje się za bramką i jak to naprawić

- **Znikają Remote Control i `/voice`.** Oba wymagają tożsamości claude.ai i są niedostępne, gdy aktywne jest `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN` albo `apiKeyHelper`. Od v2.1.196 Remote Control jest też wyłączone, gdy `ANTHROPIC_BASE_URL` wskazuje host inny niż Anthropic. Naprawa: zaakceptuj to w sesjach przez bramkę albo usuń zmienne bramki i zaloguj się przez claude.ai do pracy, która może korzystać z Anthropic. `claude doctor` pokazuje, co blokuje Remote Control. Alternatywy opisują strony o [klientach zdalnych i mobilnych](/pl/ecosystem/agent-tools/remote-mobile/) oraz o [sterowaniu głosem](/pl/ecosystem/agent-tools/voice-input/).
- **Claude Tag i sesje w chmurze ignorują bramkę.** Zawsze używają API Anthropic, a Claude Tag jest dostępny wyłącznie w usłudze first-party Anthropic (przegląd Claude Tag, sprawdzone 2026-10-12). Wcześniejsza aplikacja Claude w Slacku przestała odpowiadać w kanałach przestrzeni roboczych sparowanych z organizacją Claude 2026-10-05. Naprawa: nie włączaj tych powierzchni użytkownikom, których ruch musi zostać na bramce.
- **Ostrzeżenie przy starcie wymienia dwa źródła poświadczeń.** Obecne są jednocześnie poświadczenie bramki i zapisane logowanie. Naprawa: `/logout`, żeby zostało tylko poświadczenie bramki.
- **Claude Code prosi o logowanie, choć test curl przechodzi.** Poświadczenie leży w projektowym pliku ustawień, który działa dopiero po kreatorze pierwszego uruchomienia i potwierdzeniu zaufania do folderu. Naprawa: wyeksportuj `ANTHROPIC_AUTH_TOKEN` w powłoce albo wpisz je do `~/.claude/settings.json` lub ustawień zarządzanych.
- **Błędy `400` z `context_management` albo `Extra inputs are not permitted`.** Upstream odrzuca pola, które Claude Code wysyła do endpointów Anthropic. Naprawa: `CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1`.
- **Bramka zgłasza limit kontekstu własnymi słowami.** Claude Code nie rozpoznaje błędu, więc nie kompaktuje i nie ponawia. Naprawa: `/compact`, a potem ustaw `CLAUDE_CODE_AUTO_COMPACT_WINDOW` na limit bramki. Ta zmienna ma dolną granicę 100 000 tokenów, więc dla lokalnego modelu z 64K kontekstu naprawą pozostaje `/compact`, a prawdziwym rozwiązaniem jest większy kontekst na serwerze.
- **Wywołania w tle kończą się błędem nieznanego modelu.** Claude Code poprosił o alias Haiku. Naprawa: ustaw wszystkie cztery zmienne `ANTHROPIC_*MODEL` na serwowany model, jak w kroku 5.
- **Agent zapomina o instrukcjach albo odpowiada bez czytania plików.** Obcięty kontekst albo model bez wywołań narzędzi. Naprawa: `ollama ps` dla kontekstu, potem prompt testu dymnego; jeśli narzędzia dalej nie działają, zmień model.
- **`403` z treścią HTML i pustymi logami bramki.** Zapora aplikacji webowych przed bramką zablokowała treść żądania, bo prompty zawierają kod źródłowy i znaczniki w stylu XML. Naprawa: wyłącz inspekcję treści dla ścieżki `/v1/messages`.
- **Błędy certyfikatów, choć curl działa.** Claude Code nie ufa twojemu wewnętrznemu CA. Naprawa: ustaw `NODE_EXTRA_CA_CERTS` na pakiet certyfikatów CA.
- **Budżet nigdy nie zadziała.** Lokalny model nie ma ceny, więc wydatki stoją na zerze. Naprawa: ustaw `input_cost_per_token` i `output_cost_per_token` jak w kroku 3.

## Co dalej z bramkami i modelami lokalnymi

- [Modele open-weight i hostowane samodzielnie](/pl/ecosystem/models/open-weight/): który model serwować, vLLM dla wspólnego serwera GPU i protokół ewaluacji mierzący różnicę jakości.
- [Bramka LLM dla Claude Code](/pl/claude-code/team/llm-gateway/): wdrożenie bramki dla modeli Claude w całej organizacji.
- [Ile kosztowali agenci?](/pl/ecosystem/observability/agent-cost-tracking/): budżety w bramce obok `/usage`, ccusage i raportów wydatków.
- [Gdzie działa model](/pl/org/model-hosting/): SaaS, ścieżki chmurowe, bramki i hosting własny porównane z perspektywy CTO.
- [Sandboksy dla agentów](/pl/ecosystem/agent-tools/sandboxes/): odizoluj maszynę agenta, nie tylko ruch do modelu.
- [Przegląd narzędzi agentowych](/pl/ecosystem/agent-tools/): pozostałe półki, od multiplekserów po boty do code review.
