Source: https://ailoot.ai/integrations/pl/
Canonical: https://ailoot.ai/integrations/pl/
Language: pl

[Integracje](https://ailoot.ai/docs/pl/integrations/) 

# Połącz Ailoot z ulubionymi narzędziami — Klucz API Ailoot i konfiguracja klientów

Agenci, edytory, czaty i SDK przyjmujące klucz Ailoot. Przycisk „Skonfiguruj” pokaże, gdzie wpisać adres i klucz, oraz gotową konfigurację do skopiowania.

**85**aplikacji

**77**gotowych

**8**w trakcie weryfikacji

 Wyszukiwanie aplikacji 

## Agenci w terminalu

Agenci programistyczni i CLI: piszą kod, uruchamiają polecenia, edytują pliki.

CC

### [Claude Code](https://ailoot.ai/docs/pl/integrations/claude-code/)

Agent w terminalu

Anthropic Messages

Agent Anthropic w terminalu: pisze kod, edytuje pliki i uruchamia polecenia.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/claude-code/)

#### Gdzie skonfigurować

Zmienne środowiskowe lub blok "env" w ~/.claude/settings.json (dla jednego projektu — .claude/settings.local.json); rozszerzenie VS Code — claudeCode.environmentVariables; sprawdzenie — polecenie /status

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

`~/.claude/settings.json`

```json
{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.ailoot.ai",
    "ANTHROPIC_MODEL": "claude-sonnet-5-5",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "claude-opus-5-5",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-5-5",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "claude-haiku-4-5",
    "CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY": "1"
  }
}
```

```bash
export AILOOT_API_KEY="sk-..."
export ANTHROPIC_AUTH_TOKEN="$AILOOT_API_KEY"
claude
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Adres bez /v1: Claude Code samodzielnie dodaje /v1/messages. ANTHROPIC\_AUTH\_TOKEN jest wysyłany jako Authorization: Bearer, ANTHROPIC\_API\_KEY — jako x-api-key; Ailoot przyjmuje oba. CLAUDE\_CODE\_ENABLE\_GATEWAY\_MODEL\_DISCOVERY=1 pobiera nasze modele do /model przez /v1/models. Przy błędach 400 dotyczących nieznanych pól — CLAUDE\_CODE\_DISABLE\_EXPERIMENTAL\_BETAS=1. Dokumentacja Anthropic nie przewiduje działania Claude Code z modelami innymi niż Claude przez bramę, choć nasz /v1/messages je obsługuje; zalecamy modele Claude. Remote Control i wprowadzanie głosowe są niedostępne przy korzystaniu z bramy.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/claude-code/)[Dokumentacja aplikacji ↗](https://code.claude.com/docs/en/llm-gateway-connect)

OC

### [OpenAI Codex CLI](https://ailoot.ai/docs/pl/integrations/openai-codex-cli/)

Agent w terminalu

OpenAI Responses

Agent OpenAI do terminala, korzystający z formatu Responses.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/openai-codex-cli/)

#### Gdzie skonfigurować

~/.codex/config.toml (wyłącznie plik użytkownika: w projektowym .codex/config.toml klucze model\_provider/model\_providers są ignorowane); klucz — w zmiennej wskazanej przez env\_key

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/responses, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

`~/.codex/config.toml`

```toml
model = "gpt-6.1-sol"
model_provider = "ailoot"

[model_providers.ailoot]
name = "Ailoot"
base_url = "https://api.ailoot.ai/v1"
env_key = "AILOOT_API_KEY"
wire_api = "responses"
```

```bash
export AILOOT_API_KEY="sk-..."
codex
```

Przykładowy model: `gpt-6.1-sol`

#### Ważne

Codex działa wyłącznie przez OpenAI Responses API (dokumentacja wymienia tylko wire\_api = "responses"), dlatego wymagany jest nasz /v1/responses. ID dostawców openai, ollama, lmstudio są zarezerwowane. Alternatywa — openai\_base\_url = "https://api.ailoot.ai/v1" dla wbudowanego dostawcy openai. Ailoot zwraca Codex listę modeli w formacie manifestu Codex (GET /v1/models z client\_version). Wybieraj konkretny model, który ma format OpenAI Responses w katalogu. W zrzucie z 2026-09-30 gemini-3.6-flash ma OpenAI Chat, Anthropic Messages i Gemini, ale nie Responses, dlatego nie nadaje się do Codex. Sprawdzaj zestaw formatów na karcie modelu, a nie na podstawie nazwy rodziny.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/openai-codex-cli/)[Dokumentacja aplikacji ↗](https://learn.chatgpt.com/docs/config-file/config-advanced)

HA

### [Hermes Agent](https://ailoot.ai/docs/pl/integrations/hermes-agent/)

Agent w terminalu

OpenAI ChatOpenAI ResponsesAnthropic Messages

Agent Nous Research do terminala, z pamięcią i umiejętnościami.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/hermes-agent/)

#### Gdzie skonfigurować

hermes model → „Custom endpoint (self-hosted / VLLM / etc.)” lub ~/.hermes/config.yaml (sekcja model lub słownik providers)

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

`~/.hermes/config.yaml`

```yaml
model:
  default: claude-sonnet-5-5
  provider: custom
  base_url: https://api.ailoot.ai/v1
  key_env: AILOOT_API_KEY

# kilka formatów jednocześnie — nazwani dostawcy:
providers:
  ailoot:
    api: https://api.ailoot.ai/v1
    key_env: AILOOT_API_KEY
    transport: chat_completions
    default_model: gpt-6.1-sol
  ailoot-claude:
    api: https://api.ailoot.ai
    key_env: AILOOT_API_KEY
    transport: anthropic_messages
    default_model: claude-sonnet-5-5

# w sesji: /model custom:claude-sonnet-5-5
```

Klucz jest odczytywany ze zmiennej `AILOOT_API_KEY` — ustaw ją przed uruchomieniem:

```bash
export AILOOT_API_KEY="sk-..."   # dodaj do ~/.zshrc lub ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # następnie uruchom terminal ponownie
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

transport: chat\_completions (OpenAI Chat), anthropic\_messages (Anthropic Messages) lub codex\_responses (OpenAI Responses). LLM\_MODEL w .env nie jest już używane; OPENAI\_BASE\_URL działa wyłącznie dla dostawcy openai-api. Dla anthropic\_messages podaj adres bez /v1 — SDK Anthropic samodzielnie doda /v1/messages. Zadania pomocnicze (rozpoznawanie obrazów, skracanie historii) domyślnie korzystają z tego samego głównego modelu.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/hermes-agent/)[Dokumentacja aplikacji ↗](https://hermes-agent.nousresearch.com/docs/integrations/providers)

Op

### [OpenClaw](https://ailoot.ai/docs/pl/integrations/openclaw/)

Agent w terminalu

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Osobisty asystent AI na własnym komputerze: czaty, komunikatory, zadania.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/openclaw/)

#### Gdzie skonfigurować

Konfiguracja OpenClaw (~/.openclaw/openclaw.json) → models.providers.\<id\>; model domyślny — agents.defaults.model.primary; bezpieczna edycja — openclaw config set models.providers.\<id\> '\<json\>' --strict-json --merge

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```json
{
  "agents": {
    "defaults": {
      "model": {
        "primary": "ailoot/claude-sonnet-5-5"
      }
    }
  },
  "models": {
    "mode": "merge",
    "providers": {
      "ailoot": {
        "baseUrl": "https://api.ailoot.ai/v1",
        "apiKey": "${AILOOT_API_KEY}",
        "api": "openai-completions",
        "models": [
          {
            "id": "claude-sonnet-5-5",
            "name": "Claude Sonnet 5.5",
            "reasoning": true,
            "input": [
              "text"
            ],
            "contextWindow": 1000000,
            "maxTokens": 128000
          },
          {
            "id": "deepseek-v4-pro",
            "name": "DeepSeek V4 Pro",
            "reasoning": true,
            "input": [
              "text"
            ],
            "contextWindow": 1000000,
            "maxTokens": 131072
          }
        ]
      },
      "ailoot-claude": {
        "baseUrl": "https://api.ailoot.ai",
        "apiKey": "${AILOOT_API_KEY}",
        "api": "anthropic-messages",
        "models": [
          {
            "id": "claude-opus-5-5",
            "name": "Claude Opus 5.5",
            "reasoning": true,
            "input": [
              "text"
            ],
            "contextWindow": 1000000,
            "maxTokens": 131072
          }
        ]
      }
    }
  }
}
```

Klucz jest odczytywany ze zmiennej `AILOOT_API_KEY` — ustaw ją przed uruchomieniem:

```bash
export AILOOT_API_KEY="sk-..."   # dodaj do ~/.zshrc lub ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # następnie uruchom terminal ponownie
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Adaptery api: openai-completions (domyślnie przy ustawionym baseUrl), openai-responses (tylko jeśli serwer obsługuje /v1/responses — Ailoot obsługuje), anthropic-messages, google-generative-ai i inne. W przykładach OpenClaw baseUrl dla anthropic-messages nie zawiera /v1. OpenClaw może przekazywać obrazy, gdy input modelu zawiera "image". W przykładach Claude pozostawiono tylko tekst: w zrzucie katalogu z 2026-09-30 te metody nie deklarują wejścia image. Dodawaj "image" wyłącznie dla konkretnego modelu, którego aktualna karta w katalogu deklaruje obraz na wejściu i wybrany format API. Na przykład gemini-3.6-flash w tym zrzucie deklaruje wejście image dla OpenAI Chat; rzeczywista obsługa zależy od karty modelu i formatu. Ścieżkę głównego pliku konfiguracji przyjęto na podstawie powszechnej praktyki OpenClaw; na przeczytanej stronie wspomniano również ~/.openclaw/agents/\<agentId\>/agent/models.json.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/openclaw/)[Dokumentacja aplikacji ↗](https://docs.openclaw.ai/gateway/config-tools/custom-providers)

Op

### [opencode](https://ailoot.ai/docs/pl/integrations/opencode/)

Agent w terminalu

OpenAI Chat

Otwarty agent w terminalu, obsługujący dowolnego dostawcę zgodnego z OpenAI.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/opencode/)

#### Gdzie skonfigurować

opencode.json (w projekcie lub ~/.config/opencode/opencode.json) → provider.\<id\>; klucz — przez /connect lub "apiKey": "{env:VAR}"

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```json
{
  "$schema": "https://opencode.ai/config.json",
  "model": "ailoot/claude-sonnet-5-5",
  "provider": {
    "ailoot": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ailoot",
      "options": {
        "baseURL": "https://api.ailoot.ai/v1",
        "apiKey": "{env:AILOOT_API_KEY}"
      },
      "models": {
        "claude-sonnet-5-5": {
          "name": "Claude Sonnet 5.5"
        },
        "gpt-6.1-sol": {
          "name": "GPT-6.1 Sol"
        },
        "deepseek-v4-pro": {
          "name": "DeepSeek V4 Pro"
        }
      }
    }
  }
}
```

Klucz jest odczytywany ze zmiennej `AILOOT_API_KEY` — ustaw ją przed uruchomieniem:

```bash
export AILOOT_API_KEY="sk-..."   # dodaj do ~/.zshrc lub ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # następnie uruchom terminal ponownie
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Pakiet @ai-sdk/openai-compatible wysyła żądania do /v1/chat/completions. Dla modeli wymagających /v1/responses dokumentacja opencode wskazuje pakiet @ai-sdk/openai. Dokumentacja opencode nie opisuje dostawcy zgodnego z Anthropic z własnym baseURL. Wybieraj modele, dla których aktualny katalog deklaruje format OpenAI Chat. W zrzucie z 2026-09-30 gemini-3.6-flash ma ten format; pozostałe modele Gemini sprawdzaj na ich kartach. Ta ścieżka nie używa natywnego formatu Gemini. Obecność metody w katalogu nie oznacza rzeczywistego testu konkretnej wersji klienta.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/opencode/)[Dokumentacja aplikacji ↗](https://opencode.ai/docs/providers/)

QC

### [Qwen Code](https://ailoot.ai/docs/pl/integrations/qwen-code/)

Agent w terminalu

OpenAI ChatAnthropic MessagesGemini

Agent konsolowy zespołu Qwen: formaty OpenAI, Anthropic i Gemini.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/qwen-code/)

#### Gdzie skonfigurować

Zmienne OPENAI\_API\_KEY / OPENAI\_BASE\_URL / OPENAI\_MODEL, polecenie /auth wewnątrz sesji lub ~/.qwen/settings.json (modelProviders + security.auth.selectedType)

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```bash
export AILOOT_API_KEY="sk-..."
# szybki sposób
export OPENAI_API_KEY="$AILOOT_API_KEY"
export OPENAI_BASE_URL=https://api.ailoot.ai/v1
export OPENAI_MODEL=qwen3.8-max
qwen
```

`~/.qwen/settings.json`

```json
{
  "modelProviders": {
    "openai": [
      {
        "id": "qwen3.8-max",
        "name": "Qwen 3.8 Max (Ailoot)",
        "envKey": "AILOOT_API_KEY",
        "baseUrl": "https://api.ailoot.ai/v1"
      },
      {
        "id": "claude-sonnet-5-5",
        "name": "Claude Sonnet 5.5 (Ailoot)",
        "envKey": "AILOOT_API_KEY",
        "baseUrl": "https://api.ailoot.ai/v1"
      }
    ]
  },
  "security": {
    "auth": {
      "selectedType": "openai"
    }
  },
  "model": {
    "name": "qwen3.8-max"
  }
}
```

Klucz jest odczytywany ze zmiennej `AILOOT_API_KEY` — ustaw ją przed uruchomieniem:

```bash
export AILOOT_API_KEY="sk-..."   # dodaj do ~/.zshrc lub ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # następnie uruchom terminal ponownie
```

Przykładowy model: `qwen3.8-max`

#### Ważne

Typy protokołu: openai (Chat Completions), anthropic, gemini, vertex-ai. Dla openai baseUrl zawiera /v1. Przykład w dokumentacji dla anthropic i gemini nie zawiera baseUrl, dlatego zalecamy wariant openai. Dla typu openai wybieraj model z formatem OpenAI Chat w katalogu: gemini-3.6-flash go ma. Zestaw formatów innych modeli Gemini może się różnić — sprawdź kartę konkretnego modelu. Wariant z settings.json odczytuje klucz ze zmiennej AILOOT\_API\_KEY (pole envKey): ustaw ją poleceniem export AILOOT\_API\_KEY=sk-... lub wierszem AILOOT\_API\_KEY=sk-... w ~/.qwen/.env, inaczej Qwen Code rozpocznie pracę z pustym kluczem i otrzyma 401.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/qwen-code/)[Dokumentacja aplikacji ↗](https://qwenlm.github.io/qwen-code-docs/en/users/configuration/auth/)

GC

### [Gemini CLI](https://ailoot.ai/docs/pl/integrations/gemini-cli/)

Agent w terminalu

Gemini

Agent Google w terminalu, korzystający z natywnego formatu Gemini.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/gemini-cli/)

#### Gdzie skonfigurować

Zmienne środowiskowe GEMINI\_API\_KEY i GOOGLE\_GEMINI\_BASE\_URL; sposób logowania — ~/.gemini/settings.json → security.auth.selectedType = "gemini-api-key"; model — GEMINI\_MODEL lub flaga -m

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1beta/models/{model}:generateContent, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```bash
export AILOOT_API_KEY="sk-..."
export GEMINI_API_KEY="$AILOOT_API_KEY"
export GOOGLE_GEMINI_BASE_URL=https://api.ailoot.ai
export GEMINI_MODEL=gemini-3.8-flash
gemini
```

`~/.gemini/settings.json`

```json
{
  "security": {
    "auth": {
      "selectedType": "gemini-api-key"
    }
  }
}
```

Przykładowy model: `gemini-3.8-flash`

#### Ważne

Adres bez /v1beta: SDK sam dodaje /v1beta/models/{model}:generateContent. Adres musi korzystać z HTTPS. Klucz jest przesyłany w nagłówku x-goog-api-key — Ailoot go obsługuje. Odpowiednie są tylko modele, dla których katalog wskazuje format Gemini. Przed uruchomieniem sprawdź dostępność dokładnego ID i tej metody dla swojego klucza. Ailoot przekazuje płatną odpowiedź Gemini w całości po obliczeniu kosztu, a nie słowo po słowie, więc przy długich odpowiedziach tekst nie pojawia się od razu.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/gemini-cli/)[Dokumentacja aplikacji ↗](https://geminicli.com/docs/reference/configuration/)

KC

### [Kimi CLI](https://ailoot.ai/docs/pl/integrations/kimi-cli/)

Agent w terminalu

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Agent konsolowy Moonshot do pracy z kodem.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/kimi-cli/)

#### Gdzie skonfigurować

~/.kimi/config.toml (sekcje providers i models, default\_model); /login obsługuje wyłącznie platformy Moonshot — własny adres ustawia się ręcznie w pliku

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

`~/.kimi/config.toml`

```toml
default_model = "ailoot-kimi"

[providers.ailoot]
type = "openai_legacy"
base_url = "https://api.ailoot.ai/v1"
api_key = "sk-..."

[providers.ailoot-claude]
type = "anthropic"
base_url = "https://api.ailoot.ai"
api_key = "sk-..."

[models.ailoot-kimi]
provider = "ailoot"
model = "kimi-k3"
max_context_size = 262144
capabilities = ["thinking"]

[models.ailoot-sonnet]
provider = "ailoot-claude"
model = "claude-sonnet-5-5"
max_context_size = 1000000
capabilities = ["thinking", "image_in"]
```

Przykładowy model: `kimi-k3`

#### Ważne

Typy: openai\_legacy (Chat Completions, base\_url z /v1), openai\_responses (Responses, z /v1), anthropic (bez /v1), gemini (base\_url to adres główny Google, u nas https://api.ailoot.ai). Narzędzie SearchWeb działa wyłącznie z własną platformą Moonshot; FetchURL przy innym adresie API przechodzi na lokalne pobieranie.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/kimi-cli/)[Dokumentacja aplikacji ↗](https://moonshotai.github.io/kimi-cli/en/configuration/providers.html)

Cr

### [Crush](https://ailoot.ai/docs/pl/integrations/crush/)

Agent w terminalu

OpenAI ChatAnthropic Messages

Agent Charm w terminalu, konfigurowany w pliku crushrc.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/crush/)

#### Gdzie skonfigurować

crushrc (konfiguracja Bash): ./.crushrc, ./crushrc lub ~/.config/crush/crushrc; stary format crush.json jest przestarzały, ale nadal działa

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

`~/.config/crush/crushrc`

```bash
export AILOOT_API_KEY="sk-..."
provider add ailoot --type openai-compat \
  --base-url "https://api.ailoot.ai/v1" \
  --api-key "$AILOOT_API_KEY"

model add ailoot/deepseek-v4-pro \
  --name "DeepSeek V4 Pro (Ailoot)" \
  --context-window 1000000 \
  --default-max-tokens 32000

# format Anthropic dla Claude: adres bez /v1
provider add ailoot-claude --type anthropic \
  --base-url "https://api.ailoot.ai" \
  --api-key "$AILOOT_API_KEY"

model add ailoot-claude/claude-sonnet-5-5 \
  --name "Claude Sonnet 5.5 (Ailoot)" \
  --context-window 1000000 \
  --default-max-tokens 64000 \
  --can-reason true --supports-images false
```

Klucz jest odczytywany ze zmiennej `AILOOT_API_KEY` — ustaw ją przed uruchomieniem:

```bash
export AILOOT_API_KEY="sk-..."   # dodaj do ~/.zshrc lub ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # następnie uruchom terminal ponownie
```

Przykładowy model: `deepseek-v4-pro`

#### Ważne

Typ openai-compat oznacza format OpenAI Chat, z adresem zawierającym /v1. Typ anthropic oznacza format Messages, z adresem bez /v1: Crush przekazuje go do anthropic-sdk-go, a ten samodzielnie dodaje /v1/messages. Przykład z README Crush z /v1 utworzyłby ścieżkę /v1/v1/messages i błąd 404. Klucz jest wysyłany w nagłówku x-api-key, który Ailoot przyjmuje. Jeśli lista modeli jest pusta, dostawca openai-compat pobierze je samodzielnie z /v1/models. crushrc jest wykonywany jako kod: nie uruchamiaj Crush w cudzych folderach zawierających taki plik. W tym przykładzie Claude ma supports-images = false: zrzut katalogu z 2026-09-30 deklaruje dla wybranego formatu Messages wyłącznie tekst. Jeśli Twoja wersja Crush obsługuje tę flagę, włączaj ją tylko dla modelu, którego aktualna karta w katalogu deklaruje wejście image w wybranym formacie API; sama flaga klienta nie dodaje modelowi obsługi obrazów.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/crush/)[Dokumentacja aplikacji ↗](https://github.com/charmbracelet/crush#custom-providers)

Ai

### [Aider](https://ailoot.ai/docs/pl/integrations/aider/)

Agent w terminalu

OpenAI Chat

Programowanie w parze z AI bezpośrednio w repozytorium git.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/aider/)

#### Gdzie skonfigurować

Zmienne OPENAI\_API\_BASE i OPENAI\_API\_KEY, flaga --model openai/\<model\>

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```bash
export AILOOT_API_KEY="sk-..."
export OPENAI_API_BASE=https://api.ailoot.ai/v1
export OPENAI_API_KEY="$AILOOT_API_KEY"
aider --model openai/deepseek-v4-pro
```

Przykładowy model: `openai/deepseek-v4-pro`

#### Ważne

Prefiks openai/ jest wymagany: dzięki niemu Aider (przez LiteLLM) wysyła żądania do zgodnego z OpenAI /v1/chat/completions. W przypadku modeli nieznanych Aiderowi program ostrzega o nieznanej długości kontekstu — to nie jest błąd. Na tej stronie dokumentacji nie opisano adresu Anthropic z własnym base URL.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/aider/)[Dokumentacja aplikacji ↗](https://aider.chat/docs/llms/openai-compat.html)

Go

### [Goose](https://ailoot.ai/docs/pl/integrations/goose/)

Agent w terminalu

OpenAI ChatAnthropic Messages

Otwarty agent do terminala i komputera, z rozszerzeniami MCP.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/goose/)

#### Gdzie skonfigurować

goose configure → Custom Providers → Add A Custom Provider lub JSON w ~/.config/goose/custom\_providers/ (Windows: %APPDATA%\\Block\\goose\\config\\custom\_providers\\); alternatywa — wbudowany dostawca OpenAI z OPENAI\_HOST/OPENAI\_BASE\_PATH

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

`~/.config/goose/custom_providers/ailoot.json`

```json
{
  "name": "ailoot",
  "engine": "openai",
  "display_name": "Ailoot",
  "description": "Ailoot API",
  "api_key_env": "AILOOT_API_KEY",
  "base_url": "https://api.ailoot.ai/v1/chat/completions",
  "models": [
    {
      "name": "claude-sonnet-5-5",
      "context_limit": 1000000
    },
    {
      "name": "gpt-6.1-sol",
      "context_limit": 272000
    }
  ],
  "supports_streaming": true,
  "requires_auth": true
}
```

```bash
export AILOOT_API_KEY="sk-..."
goose session start --provider ailoot

# wariant z wbudowanym dostawcą OpenAI:
export GOOSE_PROVIDER=openai
export OPENAI_HOST=https://api.ailoot.ai
export OPENAI_BASE_PATH=v1/chat/completions
export OPENAI_API_KEY="$AILOOT_API_KEY"
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Silniki własnego dostawcy: openai, anthropic, ollama. W przykładzie Goose base\_url dla engine openai jest pełną ścieżką do /v1/chat/completions. Dla wbudowanego dostawcy OPENAI\_HOST to adres główny bez ścieżki, a OPENAI\_BASE\_PATH to ścieżka (domyślnie v1/chat/completions). Goose ignoruje klucz w config.yaml — odczytuje go wyłącznie ze zmiennej lub magazynu kluczy. Repozytorium przeniesiono do aaif-goose/goose.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/goose/)[Dokumentacja aplikacji ↗](https://github.com/aaif-goose/goose/blob/main/documentation/docs/getting-started/providers.md)

FD

### [Factory Droid](https://ailoot.ai/docs/pl/integrations/factory-droid/)

Agent w terminalu

OpenAI ChatOpenAI ResponsesAnthropic Messages

Agent Factory do terminala, z własnymi modelami.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/factory-droid/)

#### Gdzie skonfigurować

~/.factory/settings.json → tablica customModels; wybór modelu — polecenie /model, sekcja „Custom models”

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```json
{
  "customModels": [
    {
      "model": "claude-sonnet-5-5",
      "displayName": "Claude Sonnet 5.5 (Ailoot)",
      "baseUrl": "https://api.ailoot.ai",
      "apiKey": "${AILOOT_API_KEY}",
      "provider": "anthropic",
      "maxOutputTokens": 64000
    },
    {
      "model": "gpt-6.1-sol",
      "displayName": "GPT-6.1 Sol (Ailoot)",
      "baseUrl": "https://api.ailoot.ai/v1",
      "apiKey": "${AILOOT_API_KEY}",
      "provider": "openai",
      "maxOutputTokens": 64000
    },
    {
      "model": "deepseek-v4-pro",
      "displayName": "DeepSeek V4 Pro (Ailoot)",
      "baseUrl": "https://api.ailoot.ai/v1",
      "apiKey": "${AILOOT_API_KEY}",
      "provider": "generic-chat-completion-api",
      "maxOutputTokens": 32000
    }
  ]
}
```

Klucz jest odczytywany ze zmiennej `AILOOT_API_KEY` — ustaw ją przed uruchomieniem:

```bash
export AILOOT_API_KEY="sk-..."   # dodaj do ~/.zshrc lub ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # następnie uruchom terminal ponownie
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

provider: anthropic = Messages API (baseUrl jak dla Anthropic, bez /v1), openai = Responses API (z /v1), generic-chat-completion-api = Chat Completions (z /v1). Dla anthropic klucz jest domyślnie wysyłany w x-api-key (Ailoot go przyjmuje); "authMode": "bearer" przełączy na Authorization. Klucze pozostają lokalnie. Factory w pełni testuje tylko oficjalne API Anthropic i OpenAI.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/factory-droid/)[Dokumentacja aplikacji ↗](https://docs.factory.com/model-independence/byok)

Am

### [Amp](https://ailoot.ai/docs/pl/integrations/amp/)

Agent w terminalu

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Agent programistyczny Amp z elastycznym kierowaniem żądań do modeli.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/amp/)

#### Gdzie skonfigurować

Ustawienia → Model Routing → Add → Custom URL (lub workspace Model Routing dla zespołu); w terminalu — amp config model-providers (list, test, set-priority, edit-router…)

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Model Routing → Add → Custom URL
  Format:   anthropic-messages
  Base URL: https://api.ailoot.ai
  API key:  sk-...
  Model mapping:
    anthropic/claude-fable-5 -> anthropic/claude-fable-5

Drugie połączenie dla GPT:
  Format:   responses
  Base URL: https://api.ailoot.ai/v1
  API key:  sk-...
  Model mapping:
    openai/gpt-5.6-sol -> gpt-5.6-sol

Sprawdzenie: amp config model-providers check-access --provider-model anthropic/claude-fable-5
```

Przykładowy model: `claude-fable-5`

#### Ważne

Formaty Custom URL: chat-completions (\<base\>/chat/completions), responses (\<base\>/responses), anthropic-messages (\<base\>/v1/messages, /v1 nie jest dodawane drugi raz), google-genai (\<base\>/models/\<model\>:streamGenerateContent). Klucz jest wysyłany jako Authorization: Bearer. Mapowanie używa kanonicznych ID Amp w postaci provider/model; strzałka określa ID wysyłany do nas. Modele nieobjęte połączeniem Amp obsługuje samodzielnie w ramach własnych kredytów. Dokument wymaga, aby własny host był dostępny z Amp — adres jest publiczny, więc ten warunek jest spełniony.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/amp/)[Dokumentacja aplikacji ↗](https://ampcode.com/docs/markdown/customize/model-routing)

AI

### [AIChat](https://ailoot.ai/docs/pl/integrations/aichat/)

Agent w terminalu

OpenAI ChatAnthropic MessagesGemini

Uniwersalny czat w terminalu, z rolami, sesjami i RAG.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/aichat/)

#### Gdzie skonfigurować

config.yaml AIChat → clients (typy openai-compatible, claude, gemini); model — -m \<client\>:\<model\>

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```yaml
clients:
  - type: openai-compatible
    name: ailoot
    api_base: https://api.ailoot.ai/v1
    api_key: sk-...
    models:
      - name: deepseek-v4-pro
        max_input_tokens: 1000000
        supports_function_calling: true
  - type: claude
    api_base: https://api.ailoot.ai/v1
    api_key: sk-...
  - type: gemini
    api_base: https://api.ailoot.ai/v1beta
    api_key: sk-...
```

```bash
aichat -m ailoot:deepseek-v4-pro 'Cześć'
```

Przykładowy model: `deepseek-v4-pro`

#### Ważne

W przykładowej konfiguracji AIChat api\_base dla claude zawiera /v1, a dla gemini — /v1beta; tak samo należy ustawić je dla Ailoot. Trzy aplikacje klienckie zapewniają dostęp do wszystkich trzech formatów Ailoot: OpenAI, Anthropic i Gemini.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/aichat/)[Dokumentacja aplikacji ↗](https://github.com/sigoden/aichat/blob/main/config.example.yaml)

CC

### [Continue CLI](https://ailoot.ai/docs/pl/integrations/continue-cli/)

Agent w terminalu

OpenAI Chat

Konsolowa wersja Continue dla agentów i automatyzacji.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/continue-cli/)

#### Gdzie skonfigurować

Konfiguracja YAML Continue (config.yaml), przekazywana do CLI flagą --config \<path\>

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

`ailoot.yaml`

```text
name: Ailoot
version: 0.0.1
schema: v1
models:
  - name: Claude Sonnet 5.5 (Ailoot)
    provider: openai
    model: claude-sonnet-5-5
    apiBase: https://api.ailoot.ai/v1
    apiKey: sk-...

# uruchomienie:
cn --config ./ailoot.yaml
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Dla usług zgodnych z OpenAI Continue używa provider: openai i apiBase z /v1. Format konfiguracji jest wspólny dla rozszerzenia i CLI, a plik przekazuje się flagą --config.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/continue-cli/)[Dokumentacja aplikacji ↗](https://docs.continue.dev/customize/model-providers/top-level/openai)

Fo

### [ForgeCode](https://ailoot.ai/docs/pl/integrations/forge/)

Agent w terminalu

OpenAI Chat

Agent w terminalu, z konfigurowalnymi dostawcami.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/forge/)

#### Gdzie skonfigurować

forge provider login → OpenAI-compatible (zalecany sposób); przestarzały sposób — .env z OPENAI\_URL i OPENAI\_API\_KEY oraz model w forge.yaml

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```bash
# zalecane:
forge provider login   # wybierz OpenAI-compatible, wpisz https://api.ailoot.ai/v1 i sk-...

# przestarzały sposób (.env):
OPENAI_API_KEY=sk-...
OPENAI_URL=https://api.ailoot.ai/v1

# forge.yaml
model: claude-sonnet-5-5
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Konfigurację przez .env oznaczono jako przestarzałą: przy pierwszym uruchomieniu Forge przenosi zmienne do własnego magazynu plikowego. W README nie podano dokładnych nazw opcji kreatora provider login.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/forge/)[Dokumentacja aplikacji ↗](https://github.com/tailcallhq/forgecode)

GC

### [GitHub Copilot CLI](https://ailoot.ai/docs/pl/integrations/github-copilot-cli/)

Agent w terminalu

OpenAI ChatAnthropic Messages

Copilot w terminalu, z własnymi modelami.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/github-copilot-cli/)

#### Gdzie skonfigurować

Zmienne środowiskowe COPILOT\_PROVIDER\_BASE\_URL, COPILOT\_PROVIDER\_TYPE, COPILOT\_PROVIDER\_API\_KEY, COPILOT\_MODEL (lub flaga --model)

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```bash
export AILOOT_API_KEY="sk-..."
unset COPILOT_PROVIDER_TYPE
# tryb zgodny z OpenAI
export COPILOT_PROVIDER_BASE_URL=https://api.ailoot.ai/v1
export COPILOT_PROVIDER_API_KEY="$AILOOT_API_KEY"
export COPILOT_MODEL=gpt-6.1-sol
copilot

# tryb Anthropic
export COPILOT_PROVIDER_TYPE=anthropic
export COPILOT_PROVIDER_BASE_URL=https://api.ailoot.ai
export COPILOT_PROVIDER_API_KEY="$AILOOT_API_KEY"
export COPILOT_MODEL=claude-sonnet-5-5
copilot
```

Przykładowy model: `gpt-6.1-sol`

#### Ważne

Typy: openai (domyślnie, dowolny serwer zgodny z OpenAI), azure, anthropic. Model musi obsługiwać wywoływanie narzędzi i strumieniowanie. COPILOT\_PROVIDER\_WIRE\_API pozwala wybrać protokół, ale jego wartości nie są wymienione na stronie. Limity można ustawić przez COPILOT\_PROVIDER\_MAX\_PROMPT\_TOKENS / MAX\_OUTPUT\_TOKENS.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/github-copilot-cli/)[Dokumentacja aplikacji ↗](https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/use-byok-models)

Gp

### [gptme](https://ailoot.ai/docs/pl/integrations/gptme/)

Agent w terminalu

OpenAI Chat

Osobisty agent w terminalu: kod, pliki, przeglądarka.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/gptme/)

#### Gdzie skonfigurować

~/.config/gptme/config.toml → \[\[providers\]\]; model wybiera się jako \<provider\>/\<model\>

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

`~/.config/gptme/config.toml`

```toml
[[providers]]
name = "ailoot"
base_url = "https://api.ailoot.ai/v1"
api_key_env = "AILOOT_API_KEY"
default_model = "claude-sonnet-5-5"
```

```bash
export AILOOT_API_KEY="sk-..."
gptme 'cześć' -m ailoot/claude-sonnet-5-5
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Dowolny serwer zgodny z OpenAI; klucz jest szukany w api\_key, następnie w api\_key\_env, a potem w \<NAME\>\_API\_KEY. Lista dostawców — gptme-util providers list.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/gptme/)[Dokumentacja aplikacji ↗](https://github.com/gptme/gptme/blob/master/docs/providers-custom.rst)

KC

### [Kilo Code CLI](https://ailoot.ai/docs/pl/integrations/kilo-code-cli/)

Agent w terminalu

OpenAI ChatOpenAI ResponsesAnthropic Messages

Agent konsolowy Kilo Code.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/kilo-code-cli/)

#### Gdzie skonfigurować

~/.config/kilo/kilo.jsonc (lub ./kilo.jsonc; także KILO\_CONFIG) → provider.\<id\>.options.baseURL; w rozszerzeniu — Settings → Providers → Custom provider

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```json
{
  "$schema": "https://app.kilo.ai/config.json",
  "model": "openai-compatible/claude-sonnet-5-5",
  "provider": {
    "openai-compatible": {
      "options": {
        "apiKey": "{env:AILOOT_API_KEY}",
        "baseURL": "https://api.ailoot.ai/v1"
      },
      "models": {
        "claude-sonnet-5-5": {
          "name": "Claude Sonnet 5.5 (Ailoot)",
          "tool_call": true,
          "limit": {
            "context": 1000000,
            "output": 64000
          }
        }
      }
    }
  }
}
```

Klucz jest odczytywany ze zmiennej `AILOOT_API_KEY` — ustaw ją przed uruchomieniem:

```bash
export AILOOT_API_KEY="sk-..."   # dodaj do ~/.zshrc lub ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # następnie uruchom terminal ponownie
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Okno Custom provider umożliwia wybór protokołu: OpenAI Compatible (Chat Completions), OpenAI Responses, Anthropic Messages. {env:VAR} działa wyłącznie w zaufanej konfiguracji globalnej (~/.config/kilo); w projektowym kilo.json klucz ze zmiennej nie zostanie podstawiony.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/kilo-code-cli/)[Dokumentacja aplikacji ↗](https://kilo.ai/docs/code-with-ai/agents/custom-models)

LL

### [LLM](https://ailoot.ai/docs/pl/integrations/llm-cli/)

Agent w terminalu

OpenAI ChatOpenAI Responses

Narzędzie do wysyłania żądań do modeli z wiersza poleceń.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/llm-cli/)

#### Gdzie skonfigurować

Plik extra-openai-models.yaml w katalogu ustawień llm; klucz — llm keys set \<name\>

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

`extra-openai-models.yaml`

```text
- model_id: ailoot-sonnet
  model_name: claude-sonnet-5-5
  api_base: "https://api.ailoot.ai/v1"
  api_key_name: ailoot
  supports_tools: true
  vision: true
- model_id: ailoot-gpt
  model_name: gpt-6.1-sol
  api_base: "https://api.ailoot.ai/v1"
  api_key_name: ailoot
  responses: true
```

```bash
llm keys set ailoot
llm -m ailoot-sonnet 'Cześć'
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Domyślnie Chat Completions; responses: true przełącza model na /responses. Przy ustawionym api\_base klucz OpenAI nie jest wysyłany — potrzebne jest api\_key\_name. To narzędzie CLI do wysyłania żądań, a nie agent.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/llm-cli/)[Dokumentacja aplikacji ↗](https://llm.datasette.io/en/stable/other-models.html)

MS

### [mini-SWE-agent](https://ailoot.ai/docs/pl/integrations/mini-swe-agent/)

Agent w terminalu

OpenAI Chat

Minimalistyczny agent do zadań w repozytorium.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/mini-swe-agent/)

#### Gdzie skonfigurować

Konfiguracja YAML agenta → sekcja model (model\_name, model\_kwargs); domyślną ścieżkę do konfiguracji zmienia ustawienie MSWEA\_MINI\_CONFIG\_PATH

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```yaml
# fragment konfiguracji agenta
model:
  model_name: "claude-sonnet-5-5"
  model_kwargs:
    custom_llm_provider: "openai"
    api_base: "https://api.ailoot.ai/v1"
  cost_tracking: "ignore_errors"
```

```bash
export AILOOT_API_KEY="sk-..."
export OPENAI_API_KEY="$AILOOT_API_KEY"
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Działa przez LiteLLM: model\_kwargs są przekazywane bezpośrednio do litellm.completion. Bez rejestru cen LiteLLM zgłasza nieznany koszt — wyłączamy śledzenie przez cost\_tracking: "ignore\_errors" (lub MSWEA\_COST\_TRACKING=ignore\_errors). Przekazywanie klucza przez OPENAI\_API\_KEY jest standardem LiteLLM; nie pokazano go na samej stronie mini-SWE-agent.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/mini-swe-agent/)[Dokumentacja aplikacji ↗](https://github.com/SWE-agent/mini-swe-agent/blob/main/docs/models/local_models.md)

OC

### [OpenHands CLI](https://ailoot.ai/docs/pl/integrations/openhands-cli/)

Agent w terminalu

OpenAI Chat

Autonomiczny agent do programowania w trybie wiersza poleceń.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/openhands-cli/)

#### Gdzie skonfigurować

Ctrl+P → Settings (dostawca i model), plik ~/.openhands/agent\_settings.json (llm.model / llm.api\_key / llm.base\_url) lub zmienne LLM\_MODEL, LLM\_API\_KEY, LLM\_BASE\_URL z flagą --override-with-envs

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

`~/.openhands/agent_settings.json`

```json
{
  "llm": {
    "model": "openai/claude-sonnet-5-5",
    "api_key": "sk-...",
    "base_url": "https://api.ailoot.ai/v1"
  }
}
```

```bash
export AILOOT_API_KEY="sk-..."
# jednorazowo przez zmienne środowiskowe:
export LLM_MODEL=openai/claude-sonnet-5-5
export LLM_API_KEY="$AILOOT_API_KEY"
export LLM_BASE_URL=https://api.ailoot.ai/v1
openhands --override-with-envs
```

Przykładowy model: `openai/claude-sonnet-5-5`

#### Ważne

OpenHands korzysta z LiteLLM; dla proxy OpenAI dokumentacja zaleca Custom Model w postaci openai/\<model\> oraz Base URL proxy. Zmiany wprowadzone przez --override-with-envs nie są zapisywane. W interfejsie internetowym: Settings → LLM → Advanced → Custom Model, Base URL, API Key.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/openhands-cli/)[Dokumentacja aplikacji ↗](https://docs.openhands.dev/openhands/usage/cli/command-reference)

Pi

### [Pi](https://ailoot.ai/docs/pl/integrations/pi/)

Agent w terminalu

OpenAI ChatAnthropic MessagesGemini

Minimalistyczny agent programistyczny do terminala.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/pi/)

#### Gdzie skonfigurować

~/.pi/agent/models.json (lub projektowy .pi/models.json po uznaniu projektu za zaufany); wybór — /model

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```json
{
  "providers": {
    "ailoot": {
      "baseUrl": "https://api.ailoot.ai/v1",
      "api": "openai-completions",
      "apiKey": "$AILOOT_API_KEY",
      "models": [
        {
          "id": "claude-sonnet-5-5",
          "input": [
            "text",
            "image"
          ]
        },
        {
          "id": "deepseek-v4-pro"
        }
      ]
    }
  }
}
```

Klucz jest odczytywany ze zmiennej `AILOOT_API_KEY` — ustaw ją przed uruchomieniem:

```bash
export AILOOT_API_KEY="sk-..."   # dodaj do ~/.zshrc lub ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # następnie uruchom terminal ponownie
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Dokumentacja Pi wyraźnie dopuszcza endpointy zgodne z OpenAI, Anthropic i Google przez models.json; przykład dotyczy api: openai-completions. apiKey obsługuje $NAME/${NAME}, wartość dosłowną lub !polecenie. Plik jest ponownie odczytywany przy otwieraniu /model.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/pi/)[Dokumentacja aplikacji ↗](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/models.md)

Pl

### [Plandex](https://ailoot.ai/docs/pl/integrations/plandex/)

Agent w terminalu

OpenAI Chat

Agent do dużych zadań: plan, zmiany w piaskownicy, zastosowanie zmian.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/plandex/)

#### Gdzie skonfigurować

plandex models custom (lub \\models custom w REPL) — otwiera plik JSON własnych modeli i dostawców

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```json
{
  "$schema": "https://plandex.ai/schemas/models-input.schema.json",
  "providers": [
    {
      "name": "ailoot",
      "baseUrl": "https://api.ailoot.ai/v1",
      "apiKeyEnvVar": "AILOOT_API_KEY"
    }
  ],
  "models": [
    {
      "modelId": "ailoot-claude-sonnet-5-5",
      "publisher": "anthropic",
      "description": "Claude Sonnet 5.5 via Ailoot",
      "defaultMaxConvoTokens": 75000,
      "maxTokens": 1000000,
      "maxOutputTokens": 64000,
      "reservedOutputTokens": 32000,
      "preferredOutputFormat": "xml",
      "providers": [
        {
          "provider": "custom",
          "customProvider": "ailoot",
          "modelName": "claude-sonnet-5-5"
        }
      ]
    }
  ]
}
```

Klucz jest odczytywany ze zmiennej `AILOOT_API_KEY` — ustaw ją przed uruchomieniem:

```bash
export AILOOT_API_KEY="sk-..."   # dodaj do ~/.zshrc lub ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # następnie uruchom terminal ponownie
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Własni dostawcy działają wyłącznie w Plandex na własnym serwerze; w chmurze z kluczami BYO dopuszczani są tylko dostawcy wbudowani. Wszyscy własni dostawcy muszą być zgodni z OpenAI (Chat Completions). Następnie model dodaje się do własnego model pack.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/plandex/)[Dokumentacja aplikacji ↗](https://github.com/plandex-ai/plandex/blob/main/docs/docs/models/custom-models.md)

TA

### [Trae Agent](https://ailoot.ai/docs/pl/integrations/trae-agent/)

Agent w terminalu

OpenAI ChatAnthropic Messages

Badawczy agent ByteDance do zadań programistycznych.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/trae-agent/)

#### Gdzie skonfigurować

trae\_config.yaml → model\_providers.\<name\>.base\_url; alternatywa — zmienne OPENAI\_BASE\_URL / ANTHROPIC\_BASE\_URL w .env

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

`trae_config.yaml`

```yaml
agents:
  trae_agent:
    model: trae_agent_model

model_providers:
  openai:
    api_key: sk-...
    provider: openai
    base_url: https://api.ailoot.ai/v1

models:
  trae_agent_model:
    model_provider: openai
    model: gpt-6.1-sol
    max_tokens: 4096
    temperature: 0.5
```

Przykładowy model: `gpt-6.1-sol`

#### Ważne

W YAML używaj wyłącznie spacji, bez tabulatorów. Dla formatu Anthropic — provider: anthropic i ANTHROPIC\_BASE\_URL (README nie określa dokładnego wymogu dotyczącego /v1 dla anthropic; użyj https://api.ailoot.ai).

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/trae-agent/)[Dokumentacja aplikacji ↗](https://github.com/bytedance/trae-agent#using-base-url)

Wa

### [Warp](https://ailoot.ai/docs/pl/integrations/warp/)

Agent w terminalu

OpenAI Chat

Terminal z wbudowanym agentem i własnym adresem modelu.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/warp/)

#### Gdzie skonfigurować

Settings → wyszukaj „inference endpoint” → Custom inference endpoint: bazowy URL, klucz, ID modeli; następnie wybierz model z listy

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Settings → inference endpoint
  Endpoint URL: https://api.ailoot.ai/v1
  API key:      sk-...
  Models:       claude-sonnet-5-5, gpt-6.1-sol, deepseek-v4-pro
Następnie wybierz np. claude-sonnet-5-5 z listy modeli (zamiast Auto).
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Wyłącznie OpenAI Chat Completions (POST /v1/chat/completions). Żądania przechodzą przez serwery Warp: klucz jest przechowywany lokalnie, ale przekazywany do backendu Warp w każdym żądaniu. Tryby Auto i własne routery zawsze zużywają kredyty Warp; agenci chmurowi nie używają tego endpointu. Dostępne w planie Free i planach płatnych dla osób oraz zespołów do 10 osób. Wybieraj modele, dla których aktualny katalog deklaruje format OpenAI Chat. W zrzucie z 2026-09-30 gemini-3.6-flash ma ten format; pozostałe modele Gemini sprawdzaj na ich kartach. Ta ścieżka nie używa natywnego formatu Gemini. Obecność metody w katalogu nie oznacza rzeczywistego testu konkretnej wersji klienta.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/warp/)[Dokumentacja aplikacji ↗](https://docs.warp.dev/agents/inference/custom-inference-endpoint/)

## Edytory i IDE

Rozszerzenia i wbudowani asystenci edytorów kodu.

Cl

### [Cline](https://ailoot.ai/docs/pl/integrations/cline/)

Rozszerzenie edytora

OpenAI ChatAnthropic Messages

Autonomiczny agent w VS Code i JetBrains: plan, edycje, polecenia.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/cline/)

#### Gdzie skonfigurować

Panel Cline → ikona koła zębatego (Settings) → API Provider = „OpenAI Compatible” → pola Base URL, API Key, Model ID. Druga opcja: API Provider = „Anthropic” → zaznacz „Use custom base URL”.

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
OpenAI Compatible (zalecane):
  API Provider: OpenAI Compatible
  Base URL:     https://api.ailoot.ai/v1
  API Key:      sk-...
  Model ID:     claude-sonnet-5-5   (lub gpt-6.1-sol, deepseek-v4-pro, qwen3.8-max)
  Model Configuration: Context Window i Max Output Tokens — zgodnie z modelem; Image Support — tylko dla modeli rozpoznających obrazy.

Anthropic (Messages):
  API Provider:      Anthropic
  Anthropic API Key: sk-...
  [x] Use custom base URL → https://api.ailoot.ai
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

OpenAI Compatible wysyła żądania do /v1/chat/completions, dlatego adres zawiera /v1. Opcja Anthropic wysyła je do /v1/messages, z adresem bez /v1, ale jej lista modeli zawiera wyłącznie nazwy Anthropic — pozostałe modele Ailoot są dostępne przez OpenAI Compatible. Tryb agenta wymaga modelu obsługującego wywoływanie narzędzi. Modele Gemini 3.1 Pro nie są dostępne przez chat/completions (mają tylko formaty Gemini i Anthropic) — tutaj wybierz gemini-3.6-flash.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/cline/)[Dokumentacja aplikacji ↗](https://docs.cline.bot/provider-config/openai-compatible)

RC

### [Roo Code](https://ailoot.ai/docs/pl/integrations/roo-code/)

Rozszerzenie edytora

OpenAI ChatAnthropic Messages

Agent w VS Code z trybami do kodu, architektury i debugowania.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/roo-code/)

#### Gdzie skonfigurować

Panel Roo Code → koło zębate → API Provider = „OpenAI Compatible” → Base URL, API Key, Model; opcjonalnie Model Configuration (Max Output Tokens, Context Window, Image Support, Computer Use, ceny). Dostawca Anthropic ma pole wyboru „Use custom base URL”.

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
API Provider: OpenAI Compatible
Base URL:     https://api.ailoot.ai/v1
API Key:      sk-...
Model:        gpt-6.1-sol   (lub claude-sonnet-5-5, kimi-k3, glm-5.3)

Wariant przez Anthropic:
API Provider: Anthropic, API key sk-..., [x] Use custom base URL → https://api.ailoot.ai
```

Przykładowy model: `gpt-6.1-sol`

#### Ważne

Roo Code wywołuje narzędzia wyłącznie w formacie OpenAI, dlatego model musi obsługiwać tools w /v1/chat/completions. Wariant Anthropic wysyła żądania do /v1/messages, z adresem bez /v1.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/roo-code/)[Dokumentacja aplikacji ↗](https://roocodeinc.github.io/Roo-Code/providers/openai-compatible/)

KC

### [Kilo Code](https://ailoot.ai/docs/pl/integrations/kilo-code/)

Rozszerzenie edytora

OpenAI Chat

Agent w VS Code z trybami i własnymi modelami.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/kilo-code/)

#### Gdzie skonfigurować

Settings (koło zębate) → karta Providers → na dole „Custom provider” → Provider ID, Display name, Provider API = „OpenAI Compatible”, Base URL, API key, Models (lista jest pobierana z /v1/models). Ustawienia są zapisywane w kilo.json.

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Provider ID:   ailoot
Display name:  Ailoot
Provider API:  OpenAI Compatible
Base URL:      https://api.ailoot.ai/v1
API key:       sk-...
Models:        wybierz z listy, np. claude-sonnet-5-5, gpt-6.1-sol, deepseek-v4-pro
```

Przykładowy model: `deepseek-v4-pro`

#### Ważne

Kilo wysyła żądanie do {Base URL}/models i samodzielnie wyświetla listę modeli — nasz GET /v1/models zwraca cały katalog. Można też podać pełny adres .../v1/chat/completions. Obsługiwane są własne nagłówki.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/kilo-code/)[Dokumentacja aplikacji ↗](https://kilo.ai/docs/ai-providers/openai-compatible)

Co

### [Continue](https://ailoot.ai/docs/pl/integrations/continue/)

Rozszerzenie edytora

OpenAI Chat

Asystent dla VS Code i JetBrains: czat, edycje, agent.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/continue/)

#### Gdzie skonfigurować

Plik ~/.continue/config.yaml (lub edytor konfiguracji Continue): wpis w models\[\] z provider: openai i apiBase.

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
name: Ailoot
version: 0.0.1
schema: v1
models:
  - name: Ailoot Claude Sonnet 5.5
    provider: openai
    model: claude-sonnet-5-5
    apiBase: https://api.ailoot.ai/v1
    apiKey: sk-...
  - name: Ailoot GPT-6.1 Sol
    provider: openai
    model: gpt-6.1-sol
    apiBase: https://api.ailoot.ai/v1
    apiKey: sk-...
    # useResponsesApi: false   # tylko jeśli chcesz wymusić korzystanie z /chat/completions
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

apiBase musi kończyć się na /v1. Dla nazw z serii gpt-5/o Continue może samodzielnie wybrać /v1/responses; nasze gpt-\* obsługują zarówno /v1/responses, jak i /v1/chat/completions, a useResponsesApi: false wymusza chat/completions. useLegacyCompletionsEndpoint nie jest potrzebne.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/continue/)[Dokumentacja aplikacji ↗](https://docs.continue.dev/customize/model-providers/top-level/openai)

Ze

### [Zed](https://ailoot.ai/docs/pl/integrations/zed/)

Edytor kodu

OpenAI ChatOpenAI ResponsesAnthropic Messages

Szybki edytor kodu z wbudowanym agentem.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/zed/)

#### Gdzie skonfigurować

Agent Settings (agent::OpenSettings) → LLM Providers → Add Provider lub settings.json → language\_models.openai\_compatible / language\_models.anthropic\_compatible. Klucz — w oknie ustawień (przechowywany w systemowym magazynie kluczy) lub w zmiennej \<PROVIDER\_ID\_UPPERCASE\>\_API\_KEY.

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```json
{
  "language_models": {
    "openai_compatible": {
      "ailoot": {
        "api_url": "https://api.ailoot.ai/v1",
        "available_models": [
          {
            "name": "gpt-6.1-sol",
            "display_name": "GPT-6.1 Sol (Ailoot)",
            "max_tokens": 272000,
            "capabilities": {
              "tools": true,
              "images": false,
              "chat_completions": true
            }
          },
          {
            "name": "deepseek-v4-pro",
            "display_name": "DeepSeek V4 Pro (Ailoot)",
            "max_tokens": 128000
          }
        ]
      }
    },
    "anthropic_compatible": {
      "ailoot-claude": {
        "api_url": "https://api.ailoot.ai",
        "available_models": [
          {
            "name": "claude-sonnet-5-5",
            "display_name": "Claude Sonnet 5.5 (Ailoot)",
            "max_tokens": 200000,
            "capabilities": {
              "tools": true,
              "images": false,
              "prompt_caching": false
            }
          }
        ]
      }
    }
  }
}
```

```bash
export AILOOT_API_KEY="sk-..."
export AILOOT_CLAUDE_API_KEY="$AILOOT_API_KEY"
```

Przykładowy model: `gpt-6.1-sol`

#### Ważne

Dla openai\_compatible adres zawiera /v1 (żądania do /v1/chat/completions; capabilities.chat\_completions = false przełącza model na /v1/responses). Dla anthropic\_compatible adres jest bez /v1 (żądania do /v1/messages; Zed wysyła klucz w x-api-key — Ailoot go przyjmuje). Domyślnie images = false i parallel\_tool\_calls = false. Zed potrafi przekazywać obrazy, ale włączaj images wyłącznie dla konkretnego modelu, którego aktualna karta w katalogu deklaruje wejście image w wybranym formacie API. W przykładach GPT i Claude images = false: zrzut z 2026-09-30 deklaruje dla nich wyłącznie tekst. Na przykład gemini-3.6-flash w tym zrzucie deklaruje wejście image dla OpenAI Chat; rzeczywista obsługa zależy od karty modelu i formatu. Dla modeli rozumujących dostępne jest pole reasoning\_effort. Wartości max\_tokens w przykładzie oznaczają rozmiar kontekstu; dokładne limity sprawdzaj w katalogu modeli.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/zed/)[Dokumentacja aplikacji ↗](https://zed.dev/docs/ai/use-api-access)

VC

### [VS Code + Copilot Chat](https://ailoot.ai/docs/pl/integrations/vscode-copilot-byok/)

Rozszerzenie edytora

OpenAI ChatOpenAI ResponsesAnthropic Messages

Własny dostawca w Copilot Chat dla VS Code.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/vscode-copilot-byok/)

#### Gdzie skonfigurować

Wybór modelu w czacie → Manage Language Models (koło zębate) → Add Models → Custom Endpoint → VS Code otworzy chatLanguageModels.json. (Stare ustawienie github.copilot.chat.customOAIModels jest przestarzałe.)

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```json
[
  {
    "name": "Ailoot",
    "vendor": "customendpoint",
    "apiKey": "${input:ailootApiKey}",
    "apiType": "chat-completions",
    "models": [
      {
        "id": "gpt-6.1-sol",
        "name": "GPT-6.1 Sol (Ailoot)",
        "url": "https://api.ailoot.ai/v1/chat/completions",
        "toolCalling": true,
        "vision": false,
        "maxInputTokens": 200000,
        "maxOutputTokens": 32000
      }
    ]
  },
  {
    "name": "Ailoot Claude",
    "vendor": "customendpoint",
    "apiKey": "${input:ailootApiKey}",
    "apiType": "messages",
    "models": [
      {
        "id": "claude-sonnet-5-5",
        "name": "Claude Sonnet 5.5 (Ailoot)",
        "url": "https://api.ailoot.ai/v1/messages",
        "toolCalling": true,
        "vision": false,
        "maxInputTokens": 200000,
        "maxOutputTokens": 32000
      }
    ]
  }
]
```

Przykładowy model: `gpt-6.1-sol`

#### Ważne

url to PEŁNA ścieżka endpointu. Wartości apiType: chat-completions, responses (url .../v1/responses), messages (url .../v1/messages). BYOK działa bez planu Copilot i logowania do GitHub, ale wyłącznie w czacie lub trybie agenta — podpowiedzi w tekście nadal korzystają z Copilot. Administratorzy organizacji (Business/Enterprise) mogą wyłączyć politykę BYOK. Powyższe limity tokenów są przykładami; używaj wartości z katalogu. W tych przykładach vision = false: zrzut katalogu z 2026-09-30 deklaruje wyłącznie tekst dla GPT/OpenAI Chat i Claude/Anthropic Messages. Jeśli Twoja wersja VS Code oferuje vision, włączaj je tylko dla modelu, którego aktualna karta w katalogu deklaruje wejście image w wybranym formacie API; obecność pola w kliencie nie potwierdza obsługi obrazów przez wybrany model.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/vscode-copilot-byok/)[Dokumentacja aplikacji ↗](https://code.visualstudio.com/docs/agent-customization/language-models)

JA

### [JetBrains AI Assistant](https://ailoot.ai/docs/pl/integrations/jetbrains-ai-assistant/)

Edytor kodu

OpenAI Chat

Wbudowany asystent IDE JetBrains z własnym kluczem.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/jetbrains-ai-assistant/)

#### Gdzie skonfigurować

Settings | Tools | AI Assistant | Providers & API keys → Third-party AI providers → OpenAI-compatible → URL, API Key → Test Connection → Apply → AI Chat / Models Assignment

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Provider: OpenAI-compatible
URL: https://api.ailoot.ai/v1
API Key: sk-...
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Wybierz OpenAI-compatible, wpisz https://api.ailoot.ai/v1 w polu URL oraz swój API Key. Kliknij Test Connection, potem Apply i wybierz model w AI Chat. Przypisz go do funkcji IDE w Models Assignment. Włącz Tool calling tylko dla modelu obsługującego narzędzia; uzupełnianie kodu ma osobne ustawienia.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/jetbrains-ai-assistant/)[Dokumentacja aplikacji ↗](https://www.jetbrains.com/help/ai-assistant/use-custom-models.html)

Xc

### [Xcode](https://ailoot.ai/docs/pl/integrations/xcode/)

Edytor kodu

OpenAI Chat

Coding Intelligence w Xcode z zewnętrznym dostawcą.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/xcode/)

#### Gdzie skonfigurować

Xcode → Settings → Intelligence → Chat → Add a Chat Provider → Internet Hosted → URL, API Key, API Key Header, opis → Add.

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Type:           Internet Hosted
URL:            https://api.ailoot.ai        (BEZ /v1 — Xcode sam doda /v1/models i /v1/chat/completions)
API Key:        sk-...
API Key Header: x-api-key
Description:    Ailoot
→ następnie wybierz modele z listy (np. claude-sonnet-5-5, gpt-6.1-sol)
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Apple wymaga, aby dostawca obsługiwał Chat Completions i odpowiadał na {URL}/v1/models oraz {URL}/v1/chat/completions. Ailoot przyjmuje klucz w x-api-key oraz Authorization: Bearer (jeśli wybierzesz nagłówek Authorization, według relacji użytkowników Xcode samodzielnie doda prefiks Bearer). Agentów Xcode konfiguruje się osobno; nie są objęci tą instrukcją.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/xcode/)[Dokumentacja aplikacji ↗](https://developer.apple.com/documentation/xcode/setting-up-coding-intelligence)

AN

### [avante.nvim](https://ailoot.ai/docs/pl/integrations/avante-nvim/)

Wtyczka Neovim

OpenAI ChatAnthropic Messages

Wtyczka Neovim: czat i edycje bezpośrednio w buforze.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/avante-nvim/)

#### Gdzie skonfigurować

opts dla yetone/avante.nvim w lazy.nvim: opts.providers.\<name\> z \_\_inherited\_from = 'openai' (własny dostawca zgodny z OpenAI) lub nadpisanie providers.claude.endpoint; klucz pochodzi ze zmiennej wskazanej w api\_key\_name (obsługiwane są nazwy AVANTE\_\*).

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```lua
opts = {
  provider = "ailoot",
  providers = {
    ailoot = {
      __inherited_from = "openai",
      endpoint = "https://api.ailoot.ai/v1",
      api_key_name = "AILOOT_API_KEY",
      model = "claude-sonnet-5-5",
    },
    claude = {
      endpoint = "https://api.ailoot.ai",   -- Anthropic Messages, bez /v1
      model = "claude-sonnet-5-5",
    },
  },
}
-- w terminalu: export AILOOT_API_KEY=sk-...
-- dostawca claude odczytuje AVANTE_ANTHROPIC_API_KEY lub ANTHROPIC_API_KEY
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

W wiki wtyczki adres zgodny z OpenAI kończy się na /v1 (wtyczka dopisuje /chat/completions). Wbudowany dostawca claude używa adresu w postaci https://api.anthropic.com, dlatego dla Ailoot podaj adres bez /v1. Własni dostawcy bez \_\_inherited\_from wymagają pełnego adresu i własnych funkcji odczytu odpowiedzi.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/avante-nvim/)[Dokumentacja aplikacji ↗](https://github.com/avante-corp/avante.nvim/wiki/Custom-providers)

CN

### [codecompanion.nvim](https://ailoot.ai/docs/pl/integrations/codecompanion-nvim/)

Wtyczka Neovim

OpenAI ChatAnthropic Messages

Czat i edycje w tekście w Neovim.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/codecompanion-nvim/)

#### Gdzie skonfigurować

require('codecompanion').setup({ adapters = { http = { ... } } }) przez adapters.extend('openai\_compatible', ...) lub extend('anthropic', ...); następnie interactions.chat/inline.adapter.

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```lua
require("codecompanion").setup({
  adapters = {
    http = {
      ailoot = function()
        return require("codecompanion.adapters").extend("openai_compatible", {
          env = {
            url = "https://api.ailoot.ai",
            api_key = "AILOOT_API_KEY",        -- nazwa zmiennej środowiskowej przechowującej sk-...
            chat_url = "/v1/chat/completions",
          },
          schema = { model = { default = "gpt-6.1-sol" } },
        })
      end,
    },
  },
  interactions = {
    chat = { adapter = "ailoot" },
    inline = { adapter = "ailoot" },
  },
})
```

Klucz jest odczytywany ze zmiennej `AILOOT_API_KEY` — ustaw ją przed uruchomieniem:

```bash
export AILOOT_API_KEY="sk-..."   # dodaj do ~/.zshrc lub ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # następnie uruchom terminal ponownie
```

Przykładowy model: `gpt-6.1-sol`

#### Ważne

openai\_compatible rozdziela host (env.url, bez /v1) i ścieżkę (env.chat\_url). Wartości env mogą być nazwą zmiennej środowiskowej, cmd:..., file:... lub funkcją Lua. Adapter anthropic można podobnie rozszerzyć o własny url dla /v1/messages.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/codecompanion-nvim/)[Dokumentacja aplikacji ↗](https://codecompanion.olimorris.dev/configuration/adapters-http)

Gp

### [gptel](https://ailoot.ai/docs/pl/integrations/gptel/)

Pakiet Emacs

OpenAI ChatAnthropic MessagesGemini

Prosty klient modeli językowych dla Emacs.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/gptel/)

#### Gdzie skonfigurować

init.el: zarejestruj backend przez gptel-make-openai (OpenAI Chat), gptel-make-anthropic (Messages) lub gptel-make-gemini — każdy ma :host, :endpoint, :key, :stream, :models; następnie ustaw gptel-backend i gptel-model.

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```lisp
(setq gptel-model 'claude-sonnet-5-5
      gptel-backend
      (gptel-make-openai "Ailoot"
        :host "api.ailoot.ai"
        :endpoint "/v1/chat/completions"
        :stream t
        :key (getenv "AILOOT_API_KEY")               ; lub (gptel-api-key-from-environment "AILOOT_API_KEY")
        :models '(claude-sonnet-5-5 gpt-6.1-sol deepseek-v4-pro qwen3.8-max)))

;; wariant Anthropic Messages
(gptel-make-anthropic "Ailoot-Claude"
  :host "api.ailoot.ai"          ; domyślna ścieżka /v1/messages
  :stream t
  :key (getenv "AILOOT_API_KEY")
  :models '(claude-sonnet-5-5 claude-opus-5-5))
```

Klucz jest odczytywany ze zmiennej `AILOOT_API_KEY` — ustaw ją przed uruchomieniem:

```bash
export AILOOT_API_KEY="sk-..."   # dodaj do ~/.zshrc lub ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # następnie uruchom terminal ponownie
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

:host to wyłącznie nazwa hosta (bez https:// i ścieżki), a ścieżkę ustawia się w :endpoint. gptel-make-anthropic wysyła nagłówki x-api-key i anthropic-version — Ailoot je przyjmuje.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/gptel/)[Dokumentacja aplikacji ↗](https://github.com/karthink/gptel)

TI

### [Theia IDE](https://ailoot.ai/docs/pl/integrations/theia/)

Edytor kodu

OpenAI Chat

Otwarte IDE z modułem Theia AI.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/theia/)

#### Gdzie skonfigurować

Preferences → AI-features → OpenAiCustom (lub klucz ai-features.openAiCustom.customOpenAiModels w settings.json; okno AI Configuration — Alt+A).

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```json
{
  "ai-features.openAiCustom.customOpenAiModels": [
    {
      "model": "claude-sonnet-5-5",
      "url": "https://api.ailoot.ai/v1",
      "id": "ailoot-claude-sonnet-5-5",
      "apiKey": "sk-...",
      "developerMessageSettings": "system"
    }
  ]
}
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

url to adres bazowy kończący się na /v1. Dla modeli innych niż OpenAI bezpieczny wybór to developerMessageSettings: "system".

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/theia/)[Dokumentacja aplikacji ↗](https://theia-ide.org/docs/user_ai/)

TI

### [Trae IDE](https://ailoot.ai/docs/pl/integrations/trae/)

Edytor kodu

OpenAI ChatAnthropic Messages

Edytor kodu Trae z własnymi modelami.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/trae/)

#### Gdzie skonfigurować

Settings → Models → Add Model → Custom Model → API Format, Request URL (przełącznik Full URL), Model ID, Display Name, API Key; opcjonalnie Advanced Settings.

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Format OpenAI:
  API Format:  OpenAI Chat Completions
  Full URL:    OFF
  Request URL: https://api.ailoot.ai/v1
  Model ID:    gpt-6.1-sol
  API Key:     sk-...

Format Anthropic:
  API Format:  Anthropic Messages
  Full URL:    OFF
  Request URL: https://api.ailoot.ai
  Model ID:    claude-sonnet-5-5
  API Key:     sk-...
```

Przykładowy model: `gpt-6.1-sol`

#### Ważne

Przy wyłączonym Full URL Trae samodzielnie dopisuje ścieżkę wybranego formatu (dla OpenAI — adres z /v1, dla Anthropic — bez /v1). Przy włączonym Full URL wpisz https://api.ailoot.ai/v1/chat/completions lub https://api.ailoot.ai/v1/messages. Pole Model Series dostosowuje wskazówki do rodziny modelu.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/trae/)[Dokumentacja aplikacji ↗](https://docs.trae.ai/ide/models)

## Aplikacje czatu

Czaty na komputer, telefon i do przeglądarki, notatki i programy do uruchamiania aplikacji.

OW

### [Open WebUI](https://ailoot.ai/docs/pl/integrations/open-webui/)

Czat internetowy, własny serwer

OpenAI Chat

Popularny czat internetowy na własnym serwerze.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/open-webui/)

#### Gdzie skonfigurować

Settings \> Admin \> Connections \> Manage OpenAI API Connections \> + Add Connection (lub zmienne środowiskowe OPENAI\_API\_BASE\_URL / OPENAI\_API\_KEY przy uruchamianiu kontenera)

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
UI: URL = https://api.ailoot.ai/v1
API Key = sk-...
Model IDs: puste (zostaną pobrane z /v1/models) lub dodaj ręcznie claude-sonnet-5-5, gpt-6.1-sol

Docker env:
OPENAI_API_BASE_URL=https://api.ailoot.ai/v1
OPENAI_API_KEY=sk-...
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Format OpenAI Chat Completions; URL musi zawierać /v1 i nie może kończyć się ukośnikiem. Lista modeli jest pobierana z /v1/models; przy dużym katalogu (252 modele) wygodniej ograniczyć Model IDs i włączyć pamięć podręczną listy modeli (Cache Base Model List / ENABLE\_BASE\_MODELS\_CACHE=True). Dla osadzeń RAG dostępne jest osobne RAG\_OPENAI\_API\_BASE\_URL.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/open-webui/)[Dokumentacja aplikacji ↗](https://docs.openwebui.com/getting-started/quick-start/connect-a-provider/starting-with-openai-compatible/)

Li

### [LibreChat](https://ailoot.ai/docs/pl/integrations/librechat/)

Czat internetowy, własny serwer

OpenAI ChatAnthropic Messages

Czat internetowy na własnym serwerze, z agentami i wieloma dostawcami.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/librechat/)

#### Gdzie skonfigurować

Plik librechat.yaml → endpoints.custom (klucz w .env przez ${VAR}); dla formatu Anthropic pole provider: 'anthropic'

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```yaml
endpoints:
  custom:
    - name: 'Ailoot'
      apiKey: '${AILOOT_API_KEY}'
      baseURL: 'https://api.ailoot.ai/v1'
      models:
        default: ['gpt-6.1-sol', 'claude-sonnet-5-5', 'deepseek-v4-pro']
        fetch: true
      titleConvo: true
      titleModel: 'gpt-6.1-sol'
      modelDisplayLabel: 'Ailoot'
    - name: 'Ailoot Claude'
      provider: 'anthropic'
      apiKey: '${AILOOT_API_KEY}'
      baseURL: 'https://api.ailoot.ai'
      models:
        default: ['claude-sonnet-5-5']
        fetch: false
# .env: AILOOT_API_KEY=sk-...
```

Przykładowy model: `gpt-6.1-sol`

#### Ważne

Zwykły custom endpoint = OpenAI Chat Completions (baseURL z /v1). provider: 'anthropic' włącza natywnego klienta /v1/messages; w przykładzie dokumentacji baseURL dla Anthropic podano bez /v1 (https://api.anthropic.com), dlatego u nas jest to https://api.ailoot.ai. fetch: true pobiera listę z /v1/models.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/librechat/)[Dokumentacja aplikacji ↗](https://www.librechat.ai/docs/configuration/librechat_yaml/object_structure/custom_endpoint)

CS

### [Cherry Studio](https://ailoot.ai/docs/pl/integrations/cherry-studio/)

Aplikacja komputerowa

OpenAI ChatOpenAI ResponsesAnthropic Messages

Aplikacja kliencka na komputer, z asystentami i bazą wiedzy.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/cherry-studio/)

#### Gdzie skonfigurować

Settings (koło zębate) \> Model Provider \> + Add Provider \> typ protokołu OpenAI / OpenAI Responses / Anthropic / Gemini

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Provider Name: Ailoot
Typ: OpenAI (lub OpenAI Responses / Anthropic)
API Key: sk-...
Base URL: https://api.ailoot.ai
→ Sprawdź podgląd końcowego adresu pod polem: powinien wyglądać tak https://api.ailoot.ai/v1/chat/completions (dla Anthropic — https://api.ailoot.ai/v1/messages)
Models: + claude-sonnet-5-5, gpt-6.1-sol
Następnie przycisk Model Check
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Dokumentacja potwierdza protokoły OpenAI, Anthropic, OpenAI Responses i Gemini oraz podgląd końcowej ścieżki pod polem, ale nie opisuje zasad dopisywania /v1 — kieruj się podglądem. Wszystkie trzy nasze formaty (Chat Completions, Responses, Messages) są odpowiednie.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/cherry-studio/)[Dokumentacja aplikacji ↗](https://cherryai.com/docs/en/pre-basic/providers/zi-ding-yi-fu-wu-shang/)

Ch

### [Chatbox](https://ailoot.ai/docs/pl/integrations/chatbox/)

Komputer i telefon

OpenAI Chat

Czat na komputer i telefon.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/chatbox/)

#### Gdzie skonfigurować

Ustawienia (przycisk na pasku bocznym) \> Model Provider \> Add (na dole) \> typ OpenAI API Compatible

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Name: Ailoot
API Mode: OpenAI API Compatible
API Key: sk-...
API Host: https://api.ailoot.ai
API Path: (puste, domyślnie /v1/chat/completions)
Models: + gpt-6.1-sol, claude-sonnet-5-5 (vision wyłączone w tych przykładach; tool_use — zgodnie z możliwościami wybranego modelu)
```

Przykładowy model: `gpt-6.1-sol`

#### Ważne

W dokumentacji API Host podano bez /v1 (przykład https://api.openai.com), a domyślna ścieżka to /v1/chat/completions. Istnieje również typ Google Gemini compatible, ale nie sprawdzono go dla naszego /v1beta. Import konfiguracji JSON (type: 'openai', apiHost, apiPath) jest dostępny od 1.15.1 przez chatbox://provider/import?config=\<base64\>. Dla pokazanych GPT i Claude vision jest wyłączone: zrzut katalogu z 2026-09-30 deklaruje w formacie OpenAI Chat wyłącznie tekst. Jeśli Twoja wersja Chatbox oferuje vision, włącz je tylko dla modelu, którego aktualna karta w katalogu deklaruje wejście image w wybranym formacie API; możliwość dołączenia obrazu w aplikacji klienckiej nie dowodzi, że model go obsługuje.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/chatbox/)[Dokumentacja aplikacji ↗](https://docs.chatboxai.app/en/guides/providers)

Lo

### [LobeChat](https://ailoot.ai/docs/pl/integrations/lobechat/)

Czat internetowy, własny serwer

OpenAI ChatAnthropic Messages

Nowoczesny czat z wtyczkami i bazą wiedzy.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/lobechat/)

#### Gdzie skonfigurować

Self-host: zmienne środowiskowe OPENAI\_PROXY\_URL / OPENAI\_API\_KEY / OPENAI\_MODEL\_LIST, ANTHROPIC\_PROXY\_URL, GOOGLE\_PROXY\_URL

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```bash
OPENAI_API_KEY=sk-...
OPENAI_PROXY_URL=https://api.ailoot.ai/v1
OPENAI_MODEL_LIST=-all,+gpt-6.1-sol,+claude-sonnet-5-5,+deepseek-v4-pro

# format Anthropic (opcjonalnie)
ANTHROPIC_API_KEY=sk-...
ANTHROPIC_PROXY_URL=https://api.ailoot.ai
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

OPENAI\_PROXY\_URL domyślnie ma wartość https://api.openai.com/v1, dlatego podajemy adres z /v1. ANTHROPIC\_PROXY\_URL domyślnie ma wartość https://api.anthropic.com (bez /v1). Przez GOOGLE\_PROXY\_URL teoretycznie można podłączyć format Gemini (https://api.ailoot.ai), ale nie sprawdziliśmy tego wariantu. Korzystaj z trybu serwerowego: jeśli żądania są wysyłane bezpośrednio z przeglądarki, API Ailoot może je obecnie odrzucić zgodnie z zasadami CORS.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/lobechat/)[Dokumentacja aplikacji ↗](https://lobehub.com/docs/self-hosting/environment-variables/model-provider)

Ja

### [Jan](https://ailoot.ai/docs/pl/integrations/jan/)

Aplikacja komputerowa

OpenAI ChatAnthropic Messages

Otwarty czat na komputer, z modelami lokalnymi i chmurowymi.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/jan/)

#### Gdzie skonfigurować

Settings \> Model Providers \> Add Provider → wybierz format OpenAI-compatible lub Anthropic-compatible

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
OpenAI-compatible:
  Provider name: Ailoot
  Base URL: https://api.ailoot.ai/v1
  API key: sk-...
Anthropic-compatible:
  Provider name: Ailoot Claude
  Base URL: https://api.ailoot.ai
  API key: sk-...
Models: zostaną pobrane z {base_url}/models lub dodaj ręcznie: claude-sonnet-5-5
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Dokumentacja: dla usług zgodnych z OpenAI Base URL musi zawierać /v1 (inaczej 404); końcowy ukośnik jest usuwany. Przykład LiteLLM dla trybu Anthropic nie zawiera /v1. Możliwości modelu (tools, vision) dla własnych dostawców ustawia się ręcznie. Obsługiwane są klucze zapasowe (ponowienie wyłącznie przy 401/403/429).

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/jan/)[Dokumentacja aplikacji ↗](https://www.jan.ai/docs/desktop/remote-models/custom-endpoint)

Si

### [SillyTavern](https://ailoot.ai/docs/pl/integrations/sillytavern/)

Czat z odgrywaniem ról

OpenAI Chat

Interfejs do czatów z odgrywaniem ról i postaciami.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/sillytavern/)

#### Gdzie skonfigurować

API Connections \> API: Chat Completion \> Chat Completion Source: Custom (OpenAI-compatible)

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Custom Endpoint (Base URL): https://api.ailoot.ai/v1
Custom API Key: sk-...
Model: wybierz z listy (/v1/models) lub wpisz claude-sonnet-5-5
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Dokumentacja: przy problemach z połączeniem dodaj /v1 i NIE dodawaj /chat/completions. Lista modeli jest pobierana, jeśli serwer udostępnia /v1/models (nasz udostępnia).

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/sillytavern/)[Dokumentacja aplikacji ↗](https://docs.sillytavern.app/usage/api-connections/openai/)

An

### [AnythingLLM](https://ailoot.ai/docs/pl/integrations/anythingllm/)

Czat z dokumentami

OpenAI Chat

Czat z Twoimi dokumentami na komputerze lub serwerze.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/anythingllm/)

#### Gdzie skonfigurować

Settings \> AI Providers \> LLM \> Generic OpenAI (Docker: env LLM\_PROVIDER='generic-openai')

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
UI: Base URL = https://api.ailoot.ai/v1
API Key = sk-...
Chat Model Name = deepseek-v4-pro
Token context window = zgodnie z modelem

Docker .env:
LLM_PROVIDER='generic-openai'
GENERIC_OPEN_AI_BASE_PATH='https://api.ailoot.ai/v1'
GENERIC_OPEN_AI_MODEL_PREF='deepseek-v4-pro'
GENERIC_OPEN_AI_MODEL_TOKEN_LIMIT=128000
GENERIC_OPEN_AI_API_KEY='sk-...'
```

Przykładowy model: `deepseek-v4-pro`

#### Ważne

W dokumentacji dostawcę oznaczono jako „dla programistów”. W razie potrzeby ustaw GENERIC\_OPEN\_AI\_MODEL\_MAX\_TOKEN\_KEY='max\_completion\_tokens'. Dla osadzeń dostępny jest osobny generic-openai embedder (EMBEDDING\_BASE\_PATH + GENERIC\_OPEN\_AI\_EMBEDDING\_API\_KEY) — model nemotron-3-embed przez /v1/embeddings.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/anythingllm/)[Dokumentacja aplikacji ↗](https://docs.anythingllm.com/setup/llm-configuration/cloud/openai-generic)

BA

### [big-AGI](https://ailoot.ai/docs/pl/integrations/big-agi/)

Czat internetowy, własny serwer

OpenAI ChatAnthropic Messages

Zaawansowany interfejs internetowy do pracy z wieloma modelami.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/big-agi/)

#### Gdzie skonfigurować

Zmienne środowiskowe przy wdrożeniu: OPENAI\_API\_KEY / OPENAI\_API\_HOST, ANTHROPIC\_API\_KEY / ANTHROPIC\_API\_HOST; w interfejsie — Models \> Add OpenAI-compatible

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```bash
OPENAI_API_KEY=sk-...
OPENAI_API_HOST=https://api.ailoot.ai
ANTHROPIC_API_KEY=sk-...
ANTHROPIC_API_HOST=https://api.ailoot.ai
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

W dokumentacji zmienne opisano jako zamiennik backend host dla OpenAI i Anthropic (dla proxy i własnych endpointów); użyto słowa „host”, dlatego podajemy adres bez /v1, ale dokładnego formatu ścieżki nie opisano — sprawdź go przy pierwszym żądaniu.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/big-agi/)[Dokumentacja aplikacji ↗](https://github.com/enricoros/big-AGI/blob/main/docs/environment-variables.md)

Bo

### [BoltAI](https://ailoot.ai/docs/pl/integrations/boltai/)

Aplikacja na Maca

OpenAI Chat

Natywna aplikacja kliencka AI dla macOS.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/boltai/)

#### Gdzie skonfigurować

Settings \> Models \> (+) \> OpenAI-compatible Server

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Friendly name: Ailoot
API Endpoint URL: https://api.ailoot.ai/v1/chat/completions
API Key: sk-...
Model ID: gpt-6.1-sol
Context length: zgodnie z modelem
Streaming: włącz
```

Przykładowy model: `gpt-6.1-sol`

#### Ważne

Wymagany jest pełny adres chat completions. Aby AI Command korzystała z tej usługi, ustaw ją jako domyślną. Instrukcja opiera się na pomocy BoltAI; w BoltAI 2 okna mogą się różnić.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/boltai/)[Dokumentacja aplikacji ↗](https://boltai.com/help/how-to-setup-custom-openai-server)

HF

### [Hugging Face Chat UI](https://ailoot.ai/docs/pl/integrations/hugging-face-chat-ui/)

Czat internetowy, własny serwer

OpenAI Chat

Otwarty czat internetowy Hugging Face na własnym serwerze.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/hugging-face-chat-ui/)

#### Gdzie skonfigurować

Plik .env.local (OPENAI\_BASE\_URL, OPENAI\_API\_KEY)

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```bash
OPENAI_BASE_URL=https://api.ailoot.ai/v1
OPENAI_API_KEY=sk-...
```

Przykładowy model: `deepseek-v4-pro`

#### Ważne

Chat UI działa wyłącznie z API zgodnymi z OpenAI przez OPENAI\_BASE\_URL i pobiera listę modeli z /models.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/hugging-face-chat-ui/)[Dokumentacja aplikacji ↗](https://github.com/huggingface/chat-ui)

MS

### [Msty Studio](https://ailoot.ai/docs/pl/integrations/msty-studio/)

Aplikacja komputerowa

OpenAI Chat

Czat na komputer, z modelami lokalnymi i chmurowymi.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/msty-studio/)

#### Gdzie skonfigurować

Model Hub \> Model Providers \> Add Provider \> OpenAI-compatible

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Provider: OpenAI Compatible
Name: Ailoot
API Endpoint: https://api.ailoot.ai/v1
API Key: sk-...
Models: gpt-6.1-sol, claude-sonnet-5-5
```

Przykładowy model: `gpt-6.1-sol`

#### Ważne

Dokumentacja potwierdza własnego dostawcę zgodnego z OpenAI, ale nie podaje formatu adresu; /v1 to standardowy adres główny OpenAI API, a przy błędzie 404 sprawdź wariant bez /v1. Dokumentacja nie opisuje własnego endpointu zgodnego z Anthropic.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/msty-studio/)[Dokumentacja aplikacji ↗](https://docs.msty.ai/studio/managing-models/online-providers)

Ne

### [NextChat](https://ailoot.ai/docs/pl/integrations/nextchat/)

Czat internetowy, własny serwer

OpenAI Chat

Lekki czat internetowy, który można szybko wdrożyć.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/nextchat/)

#### Gdzie skonfigurować

Vercel / Docker: BASE\_URL, OPENAI\_API\_KEY, CUSTOM\_MODELS, DEFAULT\_MODEL

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```bash
OPENAI_API_KEY=sk-...
BASE_URL=https://api.ailoot.ai
CUSTOM_MODELS=-all,+gpt-6.1-sol,+claude-sonnet-5-5,+deepseek-v4-pro
DEFAULT_MODEL=gpt-6.1-sol
```

Przykładowy model: `gpt-6.1-sol`

#### Ważne

W tej konfiguracji korzystaj z OpenAI Chat przez serwer NextChat. Przy wdrażaniu w Vercel lub Docker ustaw BASE\_URL=https://api.ailoot.ai bez /v1 oraz OPENAI\_API\_KEY, CUSTOM\_MODELS i DEFAULT\_MODEL. Po zmianie tych zmiennych wdróż serwer ponownie.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/nextchat/)[Dokumentacja aplikacji ↗](https://github.com/ChatGPTNextWeb/NextChat#environment-variables)

OC

### [Obsidian Copilot](https://ailoot.ai/docs/pl/integrations/obsidian-copilot/)

Wtyczka Obsidian

OpenAI Chat

Czat z notatkami Obsidian.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/obsidian-copilot/)

#### Gdzie skonfigurować

Settings \> Copilot \> BYOK \> Add a provider \> Add a custom provider

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Base URL: https://api.ailoot.ai/v1
API key: sk-...
Model ID: claude-sonnet-5-5 (lub wybierz z listy /v1/models)
Następnie Test; włącz model w Basic > Agents > Quick Chat
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Lista modeli jest pobierana z /v1/models; model można też wpisać ręcznie. Jeśli Test się powiedzie, ale Quick Chat nie wysyła wiadomości — włącz Enable CORS u dostawcy (odpowiedź będzie przesłana w całości, bez strumieniowania). Klucze są przechowywane w Obsidian Keychain.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/obsidian-copilot/)[Dokumentacja aplikacji ↗](https://github.com/logancyang/obsidian-copilot/blob/master/docs/llm-providers.md)

PA

### [Page Assist](https://ailoot.ai/docs/pl/integrations/page-assist/)

Rozszerzenie przeglądarki

OpenAI Chat

Rozszerzenie przeglądarki: czat z otwartą stroną.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/page-assist/)

#### Gdzie skonfigurować

Ikona Page Assist \> Settings \> OpenAI Compatible API \> Add Provider \> Custom

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Provider: Custom
Name: Ailoot
Base URL: https://api.ailoot.ai/v1
API Key: sk-...
Następnie dodaj modele ręcznie: gpt-6.1-sol, claude-sonnet-5-5
```

Przykładowy model: `gpt-6.1-sol`

#### Ważne

Dokumentacja potwierdza Custom z API URL i kluczem; format URL nie jest opisany, a /v1 to standardowy adres główny OpenAI API. Automatyczne pobieranie modeli jest gwarantowane wyłącznie dla Ollama, LM Studio i Llamafile — dla pozostałych modele dodaje się ręcznie.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/page-assist/)[Dokumentacja aplikacji ↗](https://docs.pageassist.xyz/providers/openai)

RA

### [Raycast AI](https://ailoot.ai/docs/pl/integrations/raycast-ai/)

Launcher

OpenAI Chat

AI w launcherze Raycast: szybkie polecenia i czat.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/raycast-ai/)

#### Gdzie skonfigurować

Settings \> AI \> Models & Providers \> Custom Providers \> Reveal Providers Config → plik ~/.config/raycast/ai/providers.yaml

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```yaml
providers:
  - id: ailoot
    name: Ailoot
    base_url: https://api.ailoot.ai/v1
    api_keys:
      ailoot: sk-...
    models:
      - id: claude-sonnet-5-5
        name: Claude Sonnet 5.5
        provider: ailoot
        context: 200000
        abilities:
          temperature:
            supported: true
          vision:
            supported: false
          system_message:
            supported: true
          tools:
            supported: true
      - id: gpt-6.1-sol
        name: GPT-6.1 Sol
        provider: ailoot
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

base\_url to endpoint zgodny z OpenAI, bez sufiksu /chat/completions. Raycast ponownie odczytuje plik bez restartu. Jeśli abilities nie są ustawione, przyjmuje się, że tools i vision nie są obsługiwane. Modele pojawiają się w Quick AI, AI Chat i AI Commands. W tym przykładzie vision.supported = false: zrzut katalogu z 2026-09-30 deklaruje dla Claude/OpenAI Chat wyłącznie tekst. Jeśli Twoja wersja Raycast obsługuje tę opcję, włączaj vision tylko dla modelu, którego aktualna karta w katalogu deklaruje wejście image w formacie OpenAI Chat; sama flaga klienta nie potwierdza obsługi obrazów przez API.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/raycast-ai/)[Dokumentacja aplikacji ↗](https://manual.raycast.com/ai/custom-providers)

Ty

### [TypingMind](https://ailoot.ai/docs/pl/integrations/typingmind/)

Aplikacja internetowa

OpenAI Chat

Wygodny interfejs czatu w przeglądarce i na komputerze.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/typingmind/)

#### Gdzie skonfigurować

Models (lewy pasek boczny) \> + Add Custom Model

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Name: Claude Sonnet 5.5 (Ailoot)
API Type: OpenAI Chat Completions
Endpoint: https://api.ailoot.ai/v1/chat/completions
Model ID: claude-sonnet-5-5
Custom Headers: Authorization = Bearer sk-...
Context Length: zgodnie z modelem
Test → Save
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Endpoint podaje się jako pełną ścieżkę. Klucz jest przekazywany we własnym nagłówku Authorization: Bearer sk-... — Ailoot go przyjmuje. Internetowa wersja TypingMind komunikuje się z API bezpośrednio z przeglądarki, a takie żądania może obecnie zablokować CORS; pewniejsza jest wersja komputerowa. Typ Gemini w TypingMind wysyła klucz w nagłówku apiKey, którego Ailoot nie przyjmuje — użyj typu OpenAI Chat Completions.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/typingmind/)[Dokumentacja aplikacji ↗](https://docs.typingmind.com/manage-and-connect-ai-models/ollama)

## SDK i frameworki

Biblioteki do własnych aplikacji, agentów i RAG.

OS

### [OpenAI SDK (Python)](https://ailoot.ai/docs/pl/integrations/openai-python-sdk/)

SDK

OpenAI ChatOpenAI Responses

Oficjalna biblioteka OpenAI dla Pythona.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/openai-python-sdk/)

#### Gdzie skonfigurować

Parametr konstruktora OpenAI(base\_url=..., api\_key=...) lub zmienne środowiskowe OPENAI\_BASE\_URL i OPENAI\_API\_KEY

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```bash
export AILOOT_API_KEY="sk-..."
# zmienne środowiskowe
export OPENAI_BASE_URL="https://api.ailoot.ai/v1"
export OPENAI_API_KEY="$AILOOT_API_KEY"

# lub w kodzie
```

`ailoot-openai-python-sdk.py`

```python
import os
from openai import OpenAI
client = OpenAI(max_retries=0, base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"])
r = client.chat.completions.create(model="gpt-6.1-sol", messages=[{"role":"user","content":"Cześć"}])
print(r.choices[0].message.content)
# Responses API: client.responses.create(model="gpt-6.1-sol", input="Cześć")
# Embeddingi: client.embeddings.create(model="nemotron-3-embed", input=["tekst"])
```

```bash
python3 ailoot-openai-python-sdk.py
```

Przykładowy model: `gpt-6.1-sol, claude-sonnet-5-5, deepseek-v4-pro, qwen3.8-max (czat); nemotron-3-embed (embeddingi)`

#### Ważne

Adres z /v1: SDK samodzielnie dodaje /chat/completions, /responses, /embeddings, /images/\*, /audio/\*. Działają Chat Completions i Responses (Responses — dla modeli, które mają ten format w katalogu). Strumieniowanie i narzędzia są standardowe. Błędy Ailoot są zwracane w JSON z Request ID i obsługiwane jako openai.APIStatusError.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/openai-python-sdk/)[Dokumentacja aplikacji ↗](https://github.com/openai/openai-python)

OS

### [OpenAI SDK (Node.js)](https://ailoot.ai/docs/pl/integrations/openai-node-js-sdk/)

SDK

OpenAI ChatOpenAI Responses

Oficjalna biblioteka OpenAI dla JavaScriptu i TypeScriptu.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/openai-node-js-sdk/)

#### Gdzie skonfigurować

Opcja konstruktora new OpenAI({ baseURL, apiKey }); domyślnie SDK odczytuje zmienną środowiskową OPENAI\_BASE\_URL

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```js
import OpenAI from "openai";
const client = new OpenAI({maxRetries: 0,
  baseURL: "https://api.ailoot.ai/v1",
  apiKey: process.env.AILOOT_API_KEY // sk-...
});
const r = await client.chat.completions.create({
  model: "claude-sonnet-5-5",
  messages: [{ role: "user", content: "Cześć" }]
});
console.log(r.choices[0].message.content);
```

Klucz jest odczytywany ze zmiennej `AILOOT_API_KEY` — ustaw ją przed uruchomieniem:

```bash
export AILOOT_API_KEY="sk-..."   # dodaj do ~/.zshrc lub ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # następnie uruchom terminal ponownie
```

Przykładowy model: `claude-sonnet-5-5, gpt-6.1-sol, grok-4.7`

#### Ważne

README pokazuje opcję baseURL; odczyt OPENAI\_BASE\_URL widać w kodzie źródłowym klienta (src/client.ts), a wartość domyślna to https://api.openai.com/v1. Adres Ailoot podawaj z /v1. Dostępne są zarówno chat.completions, jak i responses.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/openai-node-js-sdk/)[Dokumentacja aplikacji ↗](https://github.com/openai/openai-node)

AS

### [Anthropic SDK (Python)](https://ailoot.ai/docs/pl/integrations/anthropic-python-sdk/)

SDK

Anthropic Messages

Oficjalna biblioteka Anthropic dla Pythona.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/anthropic-python-sdk/)

#### Gdzie skonfigurować

Parametr Anthropic(base\_url=...) lub zmienna środowiskowa ANTHROPIC\_BASE\_URL; klucz: api\_key lub ANTHROPIC\_API\_KEY

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```bash
export AILOOT_API_KEY="sk-..."
export ANTHROPIC_BASE_URL="https://api.ailoot.ai"
export ANTHROPIC_API_KEY="$AILOOT_API_KEY"
```

`ailoot-anthropic-python-sdk.py`

```python
import os
from anthropic import Anthropic
client = Anthropic(max_retries=0, base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"])
msg = client.messages.create(
    model="claude-sonnet-5-5", max_tokens=1024,
    messages=[{"role": "user", "content": "Cześć"}])
print(msg.content[0].text)
```

```bash
python3 ailoot-anthropic-python-sdk.py
```

Przykładowy model: `claude-sonnet-5-5, claude-opus-5-5; także przez /v1/messages gpt-6.1-sol, deepseek-v4-pro, gemini-3.6-flash`

#### Ważne

Adres BEZ /v1: SDK samodzielnie dodaje /v1/messages. Brama przyjmuje klucz w x-api-key (tak wysyła go SDK) oraz w Authorization: Bearer. Działają strumieniowanie, narzędzia i /v1/messages/count\_tokens. Przetwarzanie wsadowe (Batches) i Files API nie są deklarowane w katalogu Ailoot.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/anthropic-python-sdk/)[Dokumentacja aplikacji ↗](https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/python)

VA

### [Vercel AI SDK](https://ailoot.ai/docs/pl/integrations/vercel-ai-sdk/)

SDK

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Framework TypeScript do aplikacji AI korzystających z dowolnych dostawców.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/vercel-ai-sdk/)

#### Gdzie skonfigurować

Dostawcy: createOpenAICompatible({ name, baseURL, apiKey }) z @ai-sdk/openai-compatible; createAnthropic({ baseURL, apiKey }) z @ai-sdk/anthropic; createGoogleGenerativeAI({ baseURL, apiKey }) z @ai-sdk/google; createOpenAI({ baseURL }) lub OPENAI\_BASE\_URL

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```js
import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
import { createAnthropic } from "@ai-sdk/anthropic";
import { createGoogleGenerativeAI } from "@ai-sdk/google";
import { generateText } from "ai";

const ailoot = createOpenAICompatible({ name: "ailoot", baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY });
const claude = createAnthropic({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY });
const gemini = createGoogleGenerativeAI({ baseURL: "https://api.ailoot.ai/v1beta", apiKey: process.env.AILOOT_API_KEY });

const { text } = await generateText({ model: ailoot("deepseek-v4-pro"), prompt: "Cześć" });
// claude("claude-sonnet-5-5"), gemini("gemini-3.6-flash")
```

Klucz jest odczytywany ze zmiennej `AILOOT_API_KEY` — ustaw ją przed uruchomieniem:

```bash
export AILOOT_API_KEY="sk-..."   # dodaj do ~/.zshrc lub ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # następnie uruchom terminal ponownie
```

Przykładowy model: `deepseek-v4-pro (zgodny z OpenAI), claude-sonnet-5-5 (Anthropic), gemini-3.6-flash (Gemini)`

#### Ważne

Dostawcy używają różnych adresów: zgodny z OpenAI i Anthropic — z /v1 (domyślnie Anthropic używa https://api.anthropic.com/v1), Google — z /v1beta (domyślnie https://generativelanguage.googleapis.com/v1beta). Dostawca @ai-sdk/openai domyślnie korzysta z Responses API; dla modeli bez metody responses używaj openai.chat("id") lub createOpenAICompatible.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/vercel-ai-sdk/)[Dokumentacja aplikacji ↗](https://ai-sdk.dev/providers/openai-compatible-providers)

La

### [LangChain](https://ailoot.ai/docs/pl/integrations/langchain/)

Framework

OpenAI ChatOpenAI ResponsesAnthropic Messages

Framework do łańcuchów, agentów i RAG.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/langchain/)

#### Gdzie skonfigurować

ChatOpenAI(base\_url=...) lub zmienne OPENAI\_API\_BASE / OPENAI\_BASE\_URL; ChatAnthropic(base\_url=...) lub ANTHROPIC\_API\_URL / ANTHROPIC\_BASE\_URL

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```python
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-6.1-sol", base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"])
print(llm.invoke("Cześć").content)

from langchain_anthropic import ChatAnthropic
claude = ChatAnthropic(model="claude-sonnet-5-5", base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"])
```

Przykładowy model: `gpt-6.1-sol, qwen3.8-max (ChatOpenAI); claude-sonnet-5-5 (ChatAnthropic)`

#### Ważne

ChatOpenAI: adres z /v1. Zgodnie z dokumentacją ChatOpenAI obsługuje wyłącznie oficjalną specyfikację OpenAI: niestandardowe pola, takie jak reasoning\_content w modelach innych dostawców, nie są zachowywane. Dla Claude lepszy jest ChatAnthropic: adres bez /v1, SDK samodzielnie dodaje /v1/messages. Parametr base\_url oraz zmienne ANTHROPIC\_API\_URL/ANTHROPIC\_BASE\_URL w ChatAnthropic opisano w dokumentacji klasy w kodzie źródłowym (langchain\_anthropic/chat\_models.py); nie ma ich na stronie integracji. Flaga use\_responses\_api włącza tryb Responses w ChatOpenAI.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/langchain/)[Dokumentacja aplikacji ↗](https://docs.langchain.com/oss/python/integrations/chat/openai)

Cr

### [CrewAI](https://ailoot.ai/docs/pl/integrations/crewai/)

Framework agentów

OpenAI ChatAnthropic Messages

Zespoły agentów z rolami i zadaniami.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/crewai/)

#### Gdzie skonfigurować

crewai.LLM(model=..., base\_url=..., api\_key=...); zmienne OPENAI\_API\_KEY i OPENAI\_BASE\_URL; dla Claude — natywny dostawca anthropic/ z base\_url

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/messages, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```python
import os
from crewai import LLM
# format zgodny z OpenAI
llm = LLM(model="openai/gpt-6.1-sol", base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"])
# Anthropic Messages
claude = LLM(model="anthropic/claude-sonnet-5-5", base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_tokens=4096)
```

Przykładowy model: `openai/gpt-6.1-sol, anthropic/claude-sonnet-5-5`

#### Ważne

Prefiks openai/ lub anthropic/ wybiera dostawcę w CrewAI, a w żądaniu wysyłany jest id bez prefiksu. Dla OpenAI adres zawiera /v1, dla Anthropic — bez /v1. W dokumentacji opisano także flagę custom\_openai=True dla dowolnej bramy zgodnej z OpenAI. Anthropic wymaga max\_tokens.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/crewai/)[Dokumentacja aplikacji ↗](https://docs.crewai.com/en/concepts/llms)

GG

### [Google GenAI SDK (Python)](https://ailoot.ai/docs/pl/integrations/google-genai-python/)

SDK

Gemini

Oficjalna biblioteka Google dla Gemini API.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/google-genai-python/)

#### Gdzie skonfigurować

genai.Client(api\_key=..., http\_options=types.HttpOptions(base\_url=...))

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1beta/models/{model}:generateContent, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```python
import os
from google import genai
from google.genai import types
client = genai.Client(
    api_key=os.environ["AILOOT_API_KEY"],
    http_options=types.HttpOptions(base_url="https://api.ailoot.ai"))
r = client.models.generate_content(model="gemini-3.6-flash", contents="Cześć")
print(r.text)
```

Przykładowy model: `gemini-3.6-flash, gemini-3.1-pro`

#### Ważne

Adres bez /v1beta: SDK samodzielnie buduje /v1beta/models/{model}:generateContent. Klucz jest wysyłany w nagłówku x-goog-api-key — Ailoot go przyjmuje. Dostępne są tylko modele z formatem Gemini. Dokumentacja nie opisuje własnego adresu dla wersji JavaScript (@google/genai), dlatego jej tutaj nie przedstawiamy.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/google-genai-python/)[Dokumentacja aplikacji ↗](https://github.com/googleapis/python-genai#custom-base-url)

Li

### [LiteLLM](https://ailoot.ai/docs/pl/integrations/litellm/)

SDK

OpenAI Chat

Wspólny interfejs w Pythonie do dziesiątek dostawców.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/litellm/)

#### Gdzie skonfigurować

litellm.completion(model="openai/\<id\>", api\_base=..., api\_key=...)

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```python
import os
import litellm
r = litellm.completion(
    model="openai/claude-sonnet-5-5",
    api_base="https://api.ailoot.ai/v1",
    api_key=os.environ["AILOOT_API_KEY"],
    messages=[{"role": "user", "content": "Cześć"}])
print(r.choices[0].message.content)
# embeddingi: litellm.embedding(model="openai/nemotron-3-embed", api_base="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], input=["tekst"])
```

Przykładowy model: `openai/claude-sonnet-5-5, openai/qwen3.8-max, openai/nemotron-3-embed`

#### Ważne

Prefiks openai/ oznacza protokół zgodny z OpenAI; do Ailoot wysyłany jest id bez prefiksu. LiteLLM samodzielnie dodaje /chat/completions i /embeddings; zgodnie z dokumentacją przy błędzie Not Found adres powinien kończyć się na /v1.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/litellm/)[Dokumentacja aplikacji ↗](https://docs.litellm.ai/docs/providers/openai_compatible)

LP

### [LiteLLM Proxy](https://ailoot.ai/docs/pl/integrations/litellm-proxy/)

Własna brama

OpenAI Chat

Własna brama z kluczami, limitami i logami, korzystająca z Ailoot.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/litellm-proxy/)

#### Gdzie skonfigurować

config.yaml → model\_list → litellm\_params (model, api\_base, api\_key); uruchomienie litellm --config config.yaml

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```yaml
model_list:
  - model_name: claude-sonnet
    litellm_params:
      model: openai/claude-sonnet-5-5
      api_base: https://api.ailoot.ai/v1
      api_key: os.environ/AILOOT_API_KEY
  - model_name: gpt-sol
    litellm_params:
      model: openai/gpt-6.1-sol
      api_base: https://api.ailoot.ai/v1
      api_key: os.environ/AILOOT_API_KEY

# uruchomienie: litellm --config config.yaml
```

Klucz jest odczytywany ze zmiennej `AILOOT_API_KEY` — ustaw ją przed uruchomieniem:

```bash
export AILOOT_API_KEY="sk-..."   # dodaj do ~/.zshrc lub ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # następnie uruchom terminal ponownie
```

Przykładowy model: `openai/claude-sonnet-5-5, openai/gpt-6.1-sol`

#### Ważne

Proxy przyda się, jeśli chcesz udostępnić zespołowi własne wewnętrzne klucze, korzystając z jednego klucza Ailoot. Opłaty w Ailoot obciążają klucz wskazany w api\_key. Adres zawiera /v1.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/litellm-proxy/)[Dokumentacja aplikacji ↗](https://docs.litellm.ai/docs/providers/openai_compatible)

Ll

### [LlamaIndex](https://ailoot.ai/docs/pl/integrations/llamaindex/)

Framework

OpenAI Chat

Framework do wyszukiwania we własnych danych i RAG.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/llamaindex/)

#### Gdzie skonfigurować

Pakiet llama-index-llms-openai-like, klasa OpenAILike(api\_base=..., api\_key=..., model=..., is\_chat\_model=True)

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```bash
pip install llama-index-llms-openai-like
```

```python
import os
from llama_index.llms.openai_like import OpenAILike
llm = OpenAILike(
    model="deepseek-v4-pro",
    api_base="https://api.ailoot.ai/v1",
    api_key=os.environ["AILOOT_API_KEY"],
    is_chat_model=True,
    is_function_calling_model=True,
    context_window=128000)
print(llm.complete("Cześć"))
```

Przykładowy model: `deepseek-v4-pro, claude-sonnet-5-5, gpt-6.1-sol`

#### Ważne

Adres z /v1. is\_chat\_model=True jest wymagane, inaczej klasa użyje przestarzałego /completions. is\_function\_calling\_model=True pozwala agentom korzystać z narzędzi. Ustaw context\_window zgodnie z kartą modelu w katalogu Ailoot.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/llamaindex/)[Dokumentacja aplikacji ↗](https://developers.llamaindex.ai/python/framework-api-reference/llms/openai_like/)

Ma

### [Mastra](https://ailoot.ai/docs/pl/integrations/mastra/)

Framework agentów

OpenAI ChatOpenAI Responses

Framework TypeScript do agentów i przepływów pracy.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/mastra/)

#### Gdzie skonfigurować

W Agent: model: { id: "\<provider\>/\<model\>", url: "\<base-url\>", apiKey, api?: "chat" | "responses" }

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```js
import { Agent } from "@mastra/core/agent";
const agent = new Agent({
  id: "ailoot-agent",
  name: "Ailoot Agent",
  instructions: "Odpowiadaj po rosyjsku",
  model: {
    id: "ailoot/claude-sonnet-5-5",
    url: "https://api.ailoot.ai/v1",
    apiKey: process.env.AILOOT_API_KEY
    // api: "responses"  // tylko dla modeli z metodą responses
  }
});
```

Klucz jest odczytywany ze zmiennej `AILOOT_API_KEY` — ustaw ją przed uruchomieniem:

```bash
export AILOOT_API_KEY="sk-..."   # dodaj do ~/.zshrc lub ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # następnie uruchom terminal ponownie
```

Przykładowy model: `ailoot/claude-sonnet-5-5, ailoot/gpt-6.1-sol`

#### Ważne

W url podaje się adres bazowy z /v1, a nie pełną ścieżkę do /chat/completions. Domyślnie używa się Chat Completions; api: "responses" przełącza na Responses API. Postać id "провайдер/модель" wysyła do bramy sam id modelu. Pole apiKey w obiekcie model pokazano w dokumentacji na przykładzie z nagłówkami; nie opisano go osobno razem z url.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/mastra/)[Dokumentacja aplikacji ↗](https://mastra.ai/models)

OA

### [OpenAI Agents SDK](https://ailoot.ai/docs/pl/integrations/openai-agents-sdk/)

Framework agentów

OpenAI ChatOpenAI Responses

Biblioteka OpenAI do scenariuszy z wieloma agentami.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/openai-agents-sdk/)

#### Gdzie skonfigurować

AsyncOpenAI(base\_url=..., api\_key=...) + OpenAIChatCompletionsModel(model=..., openai\_client=client) albo globalnie set\_default\_openai\_client(client)

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```python
import os
from agents import Agent, Runner, AsyncOpenAI, OpenAIChatCompletionsModel, set_tracing_disabled
set_tracing_disabled(disabled=True)
client = AsyncOpenAI(max_retries=0, base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"])
model = OpenAIChatCompletionsModel(model="claude-sonnet-5-5", openai_client=client)
agent = Agent(name="Asystent", instructions="Odpowiadaj po rosyjsku", model=model)
print(Runner.run_sync(agent, "Cześć").final_output)
```

Przykładowy model: `claude-sonnet-5-5, gpt-6.1-sol`

#### Ważne

Adres z /v1. Wyłącz śledzenie przez set\_tracing\_disabled(True): w przeciwnym razie SDK spróbuje wysyłać ślady do OpenAI bez podanego klucza OpenAI. Chat Completions jest dostępne tylko dla modeli, dla których ta metoda jest wskazana w katalogu i dostępna dla Twojego klucza; Responses (domyślne w SDK) tylko dla modeli z metodą responses w katalogu. Wbudowane narzędzia OpenAI (wyszukiwanie w sieci, pliki) nie są gwarantowane przez zewnętrzną bramę.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/openai-agents-sdk/)[Dokumentacja aplikacji ↗](https://openai.github.io/openai-agents-python/models/)

PA

### [Pydantic AI](https://ailoot.ai/docs/pl/integrations/pydantic-ai/)

Framework agentów

OpenAI ChatOpenAI Responses

Framework agentów z typowaniem w Pythonie.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/pydantic-ai/)

#### Gdzie skonfigurować

OpenAIProvider(base\_url=..., api\_key=...) z modelem OpenAIChatModel (Chat Completions) lub OpenAIResponsesModel (Responses) albo zmienna OPENAI\_BASE\_URL

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```python
import os
from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIChatModel
from pydantic_ai.providers.openai import OpenAIProvider
model = OpenAIChatModel("deepseek-v4-pro",
    provider=OpenAIProvider(base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"]))
agent = Agent(model)
print(agent.run_sync("Cześć").output)
```

Przykładowy model: `deepseek-v4-pro, gpt-6.1-sol (dla OpenAIResponsesModel)`

#### Ważne

Adres z /v1. Dokumentacja domyślnie używa OpenAIResponsesModel: wybieraj go wyłącznie dla modeli z metodą responses; dla pozostałych — OpenAIChatModel.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/pydantic-ai/)[Dokumentacja aplikacji ↗](https://pydantic.dev/docs/ai/models/openai/)

## Automatyzacja

Scenariusze no-code, kreatory łańcuchów, boty i inteligentny dom.

N8

### [n8n](https://ailoot.ai/docs/pl/integrations/n8n/)

Automatyzacja no-code

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Automatyzacja scenariuszy z węzłami agentów AI.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/n8n/)

#### Gdzie skonfigurować

Credentials → OpenAI → pole Base URL (domyślnie https://api.openai.com/v1); Credentials → Anthropic → Base URL (domyślnie https://api.anthropic.com); Credentials → Google Gemini(PaLM) Api → Host (domyślnie https://generativelanguage.googleapis.com). Następnie węzły OpenAI Chat Model / Anthropic Chat Model / Google Gemini Chat Model

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
OpenAI credential:
  API Key: sk-...
  Base URL: https://api.ailoot.ai/v1
Anthropic credential:
  API Key: sk-...
  Base URL: https://api.ailoot.ai
Google Gemini(PaLM) Api credential:
  Host: https://api.ailoot.ai
  API Key: sk-...
Węzeł OpenAI Chat Model → Model: By ID → gpt-6.1-sol (przełącznik Use Responses API — tylko dla modeli z metodą responses)
```

Przykładowy model: `gpt-6.1-sol / deepseek-v4-pro (OpenAI), claude-sonnet-5-5 (Anthropic), gemini-3.6-flash (Gemini)`

#### Ważne

Weryfikacja danych uwierzytelniających wywołuje /models (OpenAI), /v1/models (Anthropic) i /v1beta/models (Gemini); Ailoot udostępnia wszystkie trzy ścieżki. Strony dokumentacji n8n nie opisują pola Base URL: znajduje się ono w samych danych uwierzytelniających (kod źródłowy OpenAiApi.credentials.ts i AnthropicApi.credentials.ts, etykieta „Override the default base URL for the API”). W n8n Cloud nie wybieraj „Use Gateway credits”, inaczej żądania nie przejdą przez Ailoot.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/n8n/)[Dokumentacja aplikacji ↗](https://github.com/n8n-io/n8n/blob/master/packages/nodes-base/credentials/OpenAiApi.credentials.ts)

Di

### [Dify](https://ailoot.ai/docs/pl/integrations/dify/)

Platforma aplikacji LLM

OpenAI Chat

Platforma aplikacji AI: chatboty, agenci, bazy wiedzy.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/dify/)

#### Gdzie skonfigurować

Integrations → Model Provider → zainstaluj wtyczkę OpenAI-API-compatible → Add Model (pola: Model Type, Model Name, API Key, API Base URL, Completion mode, Model context size)

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Model Type: LLM
Model Name: claude-sonnet-5-5
API Key: sk-...
API Base URL: https://api.ailoot.ai/v1
Completion mode: Chat
Model context size: zgodnie z kartą modelu w katalogu Ailoot

Dla Text Embedding:
Model Name: nemotron-3-embed
API Base URL: https://api.ailoot.ai
```

Przykładowy model: `claude-sonnet-5-5, gpt-6.1-sol, qwen3.8-max; nemotron-3-embed (embeddingi)`

#### Ważne

Dostawcami mogą zarządzać wyłącznie właściciel i administratorzy obszaru roboczego. Zgodnie z README wtyczki: dla LLM adres zawiera /v1, natomiast dla osadzeń, rerank, STT i TTS wtyczka samodzielnie dodaje wersję API, dlatego adres podaje się bez /v1 (inaczej powstałoby /v1/v1). Każdy model Ailoot dodawaj jako osobny wpis; obsługę obrazów wejściowych i strumieniowania włączaj w ustawieniach modelu.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/dify/)[Dokumentacja aplikacji ↗](https://github.com/langgenius/dify-official-plugins/tree/main/models/openai_api_compatible)

Fl

### [Flowise](https://ailoot.ai/docs/pl/integrations/flowise/)

Kreator łańcuchów

OpenAI Chat

Wizualny kreator łańcuchów i agentów.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/flowise/)

#### Gdzie skonfigurować

Węzeł ChatOpenAI lub ChatOpenAI Custom → Connect Credential (klucz) → Additional Parameters → Base Path (oraz Base Options dla nagłówków)

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Credential (OpenAI API): sk-...
Węzeł ChatOpenAI Custom:
  Model Name: deepseek-v4-pro
  Additional Parameters → Base Path: https://api.ailoot.ai/v1
```

Przykładowy model: `deepseek-v4-pro, claude-sonnet-5-5, gpt-6.1-sol`

#### Ważne

W ChatOpenAI lista modeli jest stała, dlatego dla dowolnych id Ailoot używaj ChatOpenAI Custom, gdzie nazwę modelu wpisuje się ręcznie. Base Path zawiera /v1. Dla osadzeń dostępny jest węzeł OpenAI Embeddings Custom.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/flowise/)[Dokumentacja aplikacji ↗](https://docs.flowiseai.com/integrations/langchain/chat-models/azure-chatopenai)

HA

### [Home Assistant](https://ailoot.ai/docs/pl/integrations/home-assistant/)

Inteligentny dom

OpenAI Chat

Asystent głosowy inteligentnego domu przez Extended OpenAI Conversation.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/home-assistant/)

#### Gdzie skonfigurować

Zainstaluj przez HACS (Custom repository) lub skopiuj custom\_components/extended\_openai\_conversation → uruchom ponownie → Settings → Devices & Services → Add Integration → Extended OpenAI Conversation (API Key, Base Url) → Settings → Voice Assistants → Conversation agent

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
API Key: sk-...
Base Url: https://api.ailoot.ai/v1
Options → Chat Model: gpt-6.1-sol
Voice Assistants → Conversation agent: Extended OpenAI Conversation
```

Przykładowy model: `gpt-6.1-sol, claude-sonnet-5-5`

#### Ważne

To komponent zewnętrzny, a nie oficjalna integracja. Urządzeniami steruje się przez wywoływanie funkcji (tools) w Chat Completions, dlatego wybieraj modele obsługujące narzędzia. Oficjalna integracja OpenAI Conversation nie obsługuje własnego adresu.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/home-assistant/)[Dokumentacja aplikacji ↗](https://github.com/jekalmin/extended_openai_conversation)

La

### [Langflow](https://ailoot.ai/docs/pl/integrations/langflow/)

Kreator łańcuchów

OpenAI Chat

Wizualny kreator agentów i RAG.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/langflow/)

#### Gdzie skonfigurować

Profil → Settings → Model Providers → OpenAI Compatible (pola Base URL i API Key; zmienne OPENAI\_COMPATIBLE\_BASE\_URL i OPENAI\_COMPATIBLE\_API\_KEY). Alternatywa: komponent OpenAI → pole OpenAI API Base

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Settings → Model Providers → OpenAI Compatible:
  Base URL: https://api.ailoot.ai/v1
  API Key: sk-...
lub przez zmienne środowiskowe:
```

```bash
export OPENAI_COMPATIBLE_BASE_URL="https://api.ailoot.ai/v1"
export OPENAI_COMPATIBLE_API_KEY="sk-..."
Następnie w komponentach Language Model / Agent wybierz OpenAI Compatible → claude-sonnet-5-5
```

Przykładowy model: `claude-sonnet-5-5, gpt-6.1-sol, nemotron-3-embed (Embedding Model)`

#### Ważne

Langflow sprawdza połączenie i pobiera listę modeli z /v1/models; modele pojawiają się w sekcjach Language Models i Embedding Models. Następnie trzeba ręcznie włączyć potrzebne modele. Dostawca jest instalowany razem z langflow.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/langflow/)[Dokumentacja aplikacji ↗](https://docs.langflow.org/bundles-openai-compatible)

Ma

### [Make](https://ailoot.ai/docs/pl/integrations/make/)

Automatyzacja no-code

Żądanie HTTP

Automatyzacja no-code: żądanie do Ailoot przez moduł HTTP.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/make/)

#### Gdzie skonfigurować

Wbudowany moduł OpenAI działa wyłącznie z kontem OpenAI. Użyj HTTP → Make a request: URL, Method, Headers, Body type Raw / JSON

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Moduł: HTTP → Make a request
URL: https://api.ailoot.ai/v1/chat/completions
Method: POST
Headers:
  Authorization: Bearer sk-...
  Content-Type: application/json
Body (JSON):
{"model":"gpt-6.1-sol","messages":[{"role":"user","content":"{{1.text}}"}]}
Parse response: Yes → odpowiedź w choices[].message.content
```

Przykładowy model: `gpt-6.1-sol, claude-sonnet-5-5`

#### Ważne

To uniwersalny moduł HTTP, a nie osobny dostawca dla Ailoot: dokumentacja opisuje dowolny adres HTTPS. Klucz najlepiej przechowywać w połączeniu z kluczem API (Make zaleca ten sposób zamiast przekazywania go w nagłówkach). Strumieniowanie nie jest potrzebne w Make; wysyłaj żądania bez stream.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/make/)[Dokumentacja aplikacji ↗](https://apps.make.com/http)

T

### [Bot Telegram](https://ailoot.ai/docs/pl/integrations/telegram-bot/)

Boty

OpenAI Chat

Własny bot w Telegramie, oparty na OpenAI SDK.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/telegram-bot/)

#### Gdzie skonfigurować

Frameworki Telegram nie mają własnej warstwy LLM: w obsłudze wiadomości wywołuje się OpenAI SDK z base\_url Ailoot (lub Anthropic SDK z base\_url bez /v1)

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

Zapisz kod Python jako ailoot-telegram-bot.py. Zainstaluj zależności, ustaw obie zmienne środowiskowe i uruchom plik. Wyślij Hello do bota i sprawdź odpowiedź tekstową. W razie błędu zachowaj Request ID i sprawdź pierwotny wynik przed kolejnym generowaniem.

```bash
python3 -m pip install "aiogram>=3,<4" openai
```

`ailoot-telegram-bot.py`

```python
import asyncio
import os
from aiogram import Bot, Dispatcher, F
from aiogram.types import Message
from openai import AsyncOpenAI, APIError

async def main():
    dp = Dispatcher()
    async with AsyncOpenAI(
        base_url="https://api.ailoot.ai/v1",
        api_key=os.environ["AILOOT_API_KEY"],
        max_retries=0,
    ) as llm:
        @dp.message(F.text)
        async def reply(message: Message):
            try:
                result = await llm.chat.completions.create(
                    model="claude-sonnet-5-5",
                    messages=[{"role": "user", "content": message.text}],
                )
                content = result.choices[0].message.content or "—"
                for start in range(0, len(content), 4000):
                    await message.answer(content[start:start + 4000])
            except APIError as error:
                await message.answer(
                    f"{type(error).__name__}; Request ID: "
                    f"{getattr(error, 'request_id', None) or '—'}"
                )
        bot = Bot(token=os.environ["TELEGRAM_BOT_TOKEN"])
        await dp.start_polling(bot)

if __name__ == "__main__":
    asyncio.run(main())
```

```bash
export AILOOT_API_KEY="sk-..."
export TELEGRAM_BOT_TOKEN="<TELEGRAM_BOT_TOKEN>"
python3 ailoot-telegram-bot.py
```

Przykładowy model: `claude-sonnet-5-5, deepseek-v4-pro, qwen3.8-flash`

#### Ważne

Frameworki Telegram nie mają własnej warstwy obsługi sieci neuronowych: adres Ailoot ustawia się w OpenAI SDK wewnątrz bota. Przy zerowym saldzie Ailoot zwróci czytelny błąd 402 z Request ID — pokaż go użytkownikowi bota zamiast doprowadzać do awarii.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/telegram-bot/)[Dokumentacja aplikacji ↗](https://github.com/openai/openai-python)

Za

### [Zapier](https://ailoot.ai/docs/pl/integrations/zapier/)

Automatyzacja no-code

Żądanie HTTP

Automatyzacja: żądanie do Ailoot przez Webhooks by Zapier.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/zapier/)

#### Gdzie skonfigurować

Aplikacja ChatGPT (OpenAI) w Zapier działa wyłącznie z OpenAI. Użyj Webhooks by Zapier → Custom Request (Method, URL, Data, Headers)

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Akcja: Webhooks by Zapier → Custom Request
Method: POST
URL: https://api.ailoot.ai/v1/chat/completions
Data (raw JSON):
{"model":"claude-sonnet-5-5","messages":[{"role":"user","content":"Cześć"}]}
Headers:
  Authorization | Bearer sk-...
  Content-Type | application/json
```

Przykładowy model: `claude-sonnet-5-5, gpt-6.1-sol`

#### Ważne

To uniwersalne żądanie HTTP; Zapier nie ma gotowego dostawcy z polem adresu bazowego. Custom Request wysyła pole Data bez zmian i bez analizy, dlatego JSON należy sprawdzić wcześniej. Webhooks by Zapier jest dostępne w płatnych planach Zapier.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/zapier/)[Dokumentacja aplikacji ↗](https://help.zapier.com/hc/en-us/articles/8496326446989-Send-webhooks-in-Zap-workflows)

## W trakcie weryfikacji

Konfiguracje z niepotwierdzonymi szczegółami — porównaj je z oknem aplikacji.

AC

### [Antigravity CLI](https://ailoot.ai/docs/pl/integrations/antigravity-cli/)

Agent w terminalu

W trakcie weryfikacji

Gemini

Agent konsolowy Google Antigravity w formacie Gemini.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/antigravity-cli/)

#### Gdzie skonfigurować

~/.gemini/antigravity-cli/settings.json → "modelProvider": "gemini"; zmienne GEMINI\_API\_KEY i GOOGLE\_GEMINI\_BASE\_URL

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1beta/models/{model}:generateContent, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

`~/.gemini/antigravity-cli/settings.json`

```json
{
  "modelProvider": "gemini"
}
```

```bash
export AILOOT_API_KEY="sk-..."
# w terminalu:
export GEMINI_API_KEY="$AILOOT_API_KEY"
export GOOGLE_GEMINI_BASE_URL=https://api.ailoot.ai
agy --model gemini-3.8-flash
```

Przykładowy model: `gemini-3.8-flash`

#### Ważne

Protokół to natywny Gemini REST (streamGenerateContent, klucz w X-Goog-Api-Key), ścieżka https://api.ailoot.ai/v1beta/... Na jedno pytanie agy wysyła dwa żądania: tytuł rozmowy i właściwą odpowiedź. Agent rezerwuje na każdy krok znacznie więcej niż zwykły czat, dlatego utrzymuj zapas środków na saldzie. Karta znajduje się w sekcji „W trakcie weryfikacji”: konfigurację opracowano na podstawie dokumentacji, ale nie przeprowadzono jeszcze rzeczywistego testu klienta przez Ailoot. Jeśli modelProvider = gemini, a GEMINI\_API\_KEY jest puste, CLI się nie uruchomi.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/antigravity-cli/)[Dokumentacja aplikacji ↗](https://antigravity.google/docs/cli/install/)

CC

### [Cline CLI](https://ailoot.ai/docs/pl/integrations/cline-cli/)

Agent w terminalu

W trakcie weryfikacji

OpenAI Chat

Konsolowa wersja agenta Cline.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/cline-cli/)

#### Gdzie skonfigurować

cline auth → własni dostawcy API → OpenAI Compatible: Base URL, API Key, Model ID; flaga -P/--provider wybiera dostawcę

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```bash
cline auth
# API Provider: OpenAI Compatible
# Base URL:     https://api.ailoot.ai/v1
# API Key:      sk-...
# Model ID:     claude-sonnet-5-5
cline "Uruchom testy i napraw błędy"
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Pola Base URL / API Key / Model ID opisano w dokumentacji Cline dla OpenAI Compatible. Dokładnych nazw opcji kreatora cline auth nie podano w dokumentacji CLI — porównaj je z ekranem.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/cline-cli/)[Dokumentacja aplikacji ↗](https://docs.cline.bot/provider-config/openai-compatible)

CJ

### [Copilot dla JetBrains](https://ailoot.ai/docs/pl/integrations/copilot-jetbrains-byok/)

Rozszerzenie edytora

W trakcie weryfikacji

OpenAI Chat

Własny adres modelu w Copilot dla IDE JetBrains.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/copilot-jetbrains-byok/)

#### Gdzie skonfigurować

Language Models → Add Models… → Add Custom Endpoint Provider: Provider Name, API Key, API Type (Chat Completions)

#### Konfiguracja

[JetBrains AI Assistant](https://ailoot.ai/docs/pl/integrations/jetbrains-ai-assistant/)

#### Ważne

GitHub potwierdza obsługę własnych endpointów. Oficjalny zrzut ekranu pokazuje Provider Name, API Key i API Type: Chat Completions, ale nie zawiera przykładu URL. Dlatego nie podajemy tutaj gotowej konfiguracji Ailoot do skopiowania. Udokumentowaną alternatywą w tym IDE jest JetBrains AI Assistant. Wymagania dotyczące URL wyjaśnij z oficjalną pomocą techniczną wtyczki.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/copilot-jetbrains-byok/)[Dokumentacja aplikacji ↗](https://github.blog/changelog/2026-07-14-github-copilot-for-jetbrains-expands-byok-capabilities/)

Cu

### [Cursor](https://ailoot.ai/docs/pl/integrations/cursor/)

Edytor kodu

W trakcie weryfikacji

OpenAI Chat

Edytor Cursor: własny adres OpenAI dla czatu.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/cursor/)

#### Gdzie skonfigurować

Cursor Settings → Models → API Keys → OpenAI API Key + przełącznik „Override OpenAI Base URL”; następnie dodaj ID modelu do własnych modeli.

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
OpenAI API Key:            sk-...
Override OpenAI Base URL:  https://api.ailoot.ai/v1
Własny model:               gpt-6.1-sol  (dodaj, włącz, wybierz na czacie)
```

Przykładowy model: `gpt-6.1-sol`

#### Ważne

Aktualna oficjalna dokumentacja Cursor nie opisuje własnego adresu: wymienia wyłącznie klucze OpenAI/Anthropic/Google/Azure/Bedrock, stwierdza, że własne klucze działają tylko w czacie (Tab nadal korzysta z modeli Cursor) i że wszystkie żądania przechodzą przez serwery Cursor (adres musi być publiczny — api.ailoot.ai jest publiczny). Przełącznik adresu jest dostępny w interfejsie, ale na forum Cursor zgłaszane są błędy: dotyczy on wszystkich modeli, tryb Agent może nie używać własnego klucza, a w niektórych wersjach 3.15.x pole nie przyjmuje wpisywanego tekstu.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/cursor/)[Dokumentacja aplikacji ↗](https://cursor.com/help/models-and-usage/api-keys)

OT

### [Obsidian Text Generator](https://ailoot.ai/docs/pl/integrations/obsidian-text-generator/)

Wtyczka Obsidian

W trakcie weryfikacji

OpenAI Chat

Generowanie tekstu w notatkach Obsidian według szablonów.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/obsidian-text-generator/)

#### Gdzie skonfigurować

Settings \> Text Generator \> LLM Provider: OpenAI Chat (lub Custom)

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Provider: OpenAI Chat
API Key: sk-...
Base Path: https://api.ailoot.ai/v1
Model: gpt-6.1-sol
```

Przykładowy model: `gpt-6.1-sol`

#### Ważne

Dokumentacja wtyczki wspomina dostawcę Custom, ale nie opisuje pola adresu ani jego formatu; konfigurację podano na podstawie interfejsu wtyczki — porównaj ją z oknem ustawień.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/obsidian-text-generator/)[Dokumentacja aplikacji ↗](https://docs.text-gen.com/)

Pe

### [PearAI](https://ailoot.ai/docs/pl/integrations/pearai/)

Edytor kodu

W trakcie weryfikacji

OpenAI Chat

Edytor PearAI oparty na VS Code.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/pearai/)

#### Gdzie skonfigurować

Cmd/Ctrl+Shift+P → Open config.json → wpis w models\[\] (PearAI jest odgałęzieniem Continue).

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```json
{
  "models": [
    {
      "title": "Ailoot Claude Sonnet 5.5",
      "provider": "openai",
      "model": "claude-sonnet-5-5",
      "apiBase": "https://api.ailoot.ai/v1",
      "apiKey": "sk-..."
    }
  ]
}
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Nie udało się zweryfikować oficjalnej dokumentacji PearAI (strona dokumentacji jest niedostępna), a repozytorium od dawna nie było aktualizowane. Format konfiguracji oparto na przykładzie Continue — sprawdź go w aplikacji.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/pearai/)[Dokumentacja aplikacji ↗](https://github.com/trypear/pearai-app/issues/122)

VS

### [Visual Studio 2026](https://ailoot.ai/docs/pl/integrations/visual-studio-2026/)

Edytor kodu

W trakcie weryfikacji

OpenAI Chat

Własny dostawca w Copilot Chat dla Visual Studio.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/visual-studio-2026/)

#### Gdzie skonfigurować

Chat → wybór modelu → Manage models → Add custom model → dostawca OpenAI (custom endpoint) → adres, klucz, model.

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Provider: OpenAI (custom endpoint)
Endpoint: https://api.ailoot.ai/v1
API key:  sk-...
Model:    gpt-6.1-sol
```

Przykładowy model: `gpt-6.1-sol`

#### Ważne

Blog Visual Studio (29.09.2026) ogłosił własne adresy dla OpenAI i Ollama w VS 2026 Stable, ale strona dokumentacji nadal opisuje tylko klucze OpenAI/Anthropic/Google bez pola adresu, dlatego nazwy pól i format adresu nie są jeszcze potwierdzone. Wyłącznie czat; niedostępne w planach Copilot Business/Enterprise.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/visual-studio-2026/)[Dokumentacja aplikacji ↗](https://devblogs.microsoft.com/visualstudio/visual-studio-september-update-power-your-workflow-with-your-model/)

Vo

### [Void](https://ailoot.ai/docs/pl/integrations/void/)

Edytor kodu

W trakcie weryfikacji

OpenAI Chat

Otwarty edytor oparty na VS Code; rozwój został wstrzymany.

[Więcej informacji →](https://ailoot.ai/docs/pl/integrations/void/)

#### Gdzie skonfigurować

Void Settings → Providers → OpenAI-Compatible → baseURL, API key, model.

#### Konfiguracja

Przed uruchomieniem wywołaj GET /v1/models ze swoim kluczem Ailoot. Wybierz dokładny identyfikator modelu, którego metody obejmują POST /v1/chat/completions, i użyj go w konfiguracji. Dla agentów sprawdź także obsługę narzędzi i funkcje wymagane przez twoją wersję klienta.

```text
Provider: OpenAI-Compatible
baseURL:  https://api.ailoot.ai/v1   (bez /chat/completions)
API key:  sk-...
Model:    claude-sonnet-5-5
```

Przykładowy model: `claude-sonnet-5-5`

#### Ważne

Konfigurację zaczerpnięto z kodu źródłowego Void, a nie z dokumentacji użytkownika. Repozytorium Void jest zarchiwizowane, a edytor nie jest już rozwijany — nadaje się tylko dla osób, które już go używają.

[Pełna instrukcja →](https://ailoot.ai/docs/pl/integrations/void/)[Dokumentacja aplikacji ↗](https://github.com/voideditor/void/blob/main/src/vs/workbench/contrib/void/common/voidSettingsTypes.ts)

Nic nie znaleziono. Jeśli aplikacja obsługuje własny adres OpenAI lub Anthropic API, prawdopodobnie zadziała — [oto, co należy wpisać](https://ailoot.ai/docs/pl/keys/).

## Na razie nie są odpowiednie

W tych aplikacjach nie można ustawić własnego adresu API. Obok podano alternatywy.

| Aplikacja | Dlaczego nie jest odpowiednia | Czym zastąpić |
| --- | --- | --- |
| **Cursor CLI (cursor-agent)** | Działa wyłącznie z modelami Cursor; nie można ustawić własnego adresu API. | Claude Code, Codex CLI lub opencode |
| **Auggie CLI (Augment Code)** | Logowanie przez konto Augment; nie można wskazać zewnętrznego dostawcy. | Claude Code lub opencode |
| **Windsurf / Devin Desktop** | Przyjmuje wyłącznie klucz Anthropic dla wybranych modeli Claude; nie można ustawić własnego adresu. | Cline, Roo Code lub Kilo Code w VS Code |
| **Kiro** | Nie ma opcji własnego klucza ani adresu API. | Cline lub Roo Code |
| **Google Antigravity (IDE)** | Nie ma oficjalnej konfiguracji własnego dostawcy; nie zalecamy zewnętrznych poprawek. | Antigravity CLI lub Gemini CLI |
| **Visual Studio z Copilot Business lub Enterprise** | W tych planach Copilot własne modele nie są dostępne. | Indywidualny plan Copilot — karta Visual Studio 2026 |
| **Autouzupełnianie Cursor Tab** | Zawsze korzysta z modeli Cursor, nawet z własnym kluczem. | Czat Cursor konfiguruje się osobno — karta Cursor |
| **Enchanted** | Działa wyłącznie z API Ollama. | Open WebUI lub Chatbox |
| **Smart Connections (Obsidian)** | Zewnętrzne API są dostępne wyłącznie w płatnym Smart Chat Pro. | Obsidian Copilot |
| **Witsy, 5ire** | Nie znaleźliśmy oficjalnego opisu własnego adresu API. | Cherry Studio lub Jan |
| **Make: wbudowany moduł OpenAI** | Łączy się wyłącznie z kontem OpenAI. | Moduł HTTP → Make a request — karta Make |
| **Zapier: aplikacja ChatGPT (OpenAI)** | Nie ma pola na własny adres. | Webhooks by Zapier → Custom Request — karta Zapier |
| **Home Assistant: OpenAI Conversation** | Wbudowana integracja działa wyłącznie z adresem OpenAI. | Extended OpenAI Conversation z HACS — karta Home Assistant |
| **aiogram, python-telegram-bot, grammY, Telegraf** | Frameworki botów nie łączą się samodzielnie z modelami. | SDK OpenAI lub Anthropic w bocie — karta bota Telegram |

## Klucz API Ailoot i konfiguracja klientów

### Gdzie wpisać adres API i klucz w kliencie?

Agenci, edytory, czaty i SDK przyjmujące klucz Ailoot. Przycisk „Skonfiguruj” pokaże, gdzie wpisać adres i klucz, oraz gotową konfigurację do skopiowania.

Połącz Ailoot z Claude Code, OpenCode, Hermes albo własną aplikacją.

## Firma i jej portfel projektów

Firma i jej portfel projektów: miliony klientów; miesięczna sprzedaż liczona w miliardach.

## Kupuj tokeny z rabatem.

Rabat subskrypcji do regularnej pracy. Kody promocyjne — do 50% na tokeny.

Subskrypcja

Wybierz plan z rabatem do regularnych żądań.

Kod promocyjny do 50%

Wpisz kod przy zakupie. Cena zostanie przeliczona według aktualnej promocji.

Koszty w historii

Model, tokeny i kwota są zapisywane dla każdego żądania.

[Wybierz subskrypcję](https://ailoot.ai/docs/pl/billing/subscriptions/) · [Sprawdź ceny modeli](https://ailoot.ai/models/pl/)

## Połącz API z produktem, który sprzedajesz.

SaaS, aplikacje i boty na warunkach oferty i umowy licencyjnej Ailoot. Do odsprzedaży poproś o licencję resellerską.

Aplikacja komercyjna

Wbuduj generowanie tekstu, obrazów, wideo i dźwięku w płatne funkcje usługi.

Licencja resellerska

Prześlij opis projektu i schemat dostępu. Poproś o pisemne warunki używania i odsprzedaży.

Dokumenty na stronie

Oferta, umowa licencyjna i polityka przetwarzania danych są dostępne przed połączeniem.

[Poproś o licencję resellerską](mailto:support@ailoot.ai) · [Oferta i umowa licencyjna](https://ailoot.ai/legal/offer?lang=pl)

## Pytania

Który format klienta wybrać?

Wybierz format OpenAI, Anthropic lub Gemini obsługiwany przez Twojego klienta. Na karcie modelu Ailoot sprawdź zgodną metodę API i ID modelu; obsługa jednego formatu nie oznacza, że każdy model obsługuje wszystkie formaty.

Co trzeba skonfigurować w kliencie?

Ustaw klucz API Ailoot, adres API i ID modelu zgodny z metodą klienta. SDK OpenAI używa https://api.ailoot.ai/v1; SDK Anthropic i Gemini używają https://api.ailoot.ai. Zachowaj pola żądania z przykładu dla danego formatu.

Jak wysłać pierwsze żądanie API?

Utwórz klucz API Ailoot. Ustaw https://api.ailoot.ai/v1 dla SDK OpenAI lub https://api.ailoot.ai dla SDK Anthropic i Gemini. GET /v1/models jest bezpłatne i zwraca listę modeli dostępnych dla Twojego klucza; następnie skorzystaj z przykładu dla wybranego modelu i metody API.

Co sprawdzić, gdy podłączony klient nie działa?

Sprawdź, czy klient wysyła oczekiwany format OpenAI, Anthropic lub Gemini na odpowiedni adres API z Twoim kluczem API Ailoot. Potwierdź ID modelu i metodę, a następnie porównaj zwrócony błąd z instrukcją klienta. Wyślij błąd i ID żądania na support@ailoot.ai bez udostępniania klucza.

Czy mogę używać Ailoot w płatnym produkcie?

Tak. Połącz API z SaaS, aplikacją lub botem na warunkach oferty i umowy licencyjnej Ailoot. Do odsprzedaży poproś o pisemne warunki i licencję resellerską projektu.

Jak wystąpić o licencję dla odsprzedawcy?

Napisz na support@ailoot.ai, opisz działanie produktu, jego użytkowników i sposób, w jaki zapewniasz do niego dostęp. Poproś o licencję dla odsprzedawcy i pisemne warunki dla swojego projektu.

## Ailoot · Firma i jej portfel projektów





Ailoot opiera się na zgromadzonym doświadczeniu operacyjnym, szerokiej bazie klientów, stabilnej usłudze i stałej kontroli KPI.





Firma i jej portfel projektów: miliony klientów; miesięczna sprzedaż liczona w miliardach.





Ailoot wykorzystuje to doświadczenie operacyjne, zapewniając dostęp przez API do funkcji AI w produktach klientów, agentach, aplikacjach i automatyzacjach.
