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

[Integrace](https://ailoot.ai/docs/cs/integrations/) 

# Připojte Ailoot ke svým oblíbeným nástrojům — Připojení API k nástrojům

Nástroje – agenti, editory, chaty a SDK – které přijímají klíč Ailoot. Tlačítko „Nastavit“ ukáže, kam vložit adresu a klíč, a připravenou konfiguraci, kterou můžete zkopírovat.

**85**aplikací

**77**připraveno

**8**ověřuje se

 Hledání aplikace 

## Agenti v terminálu

Agenti pro programování a CLI: píší kód, spouštějí příkazy a upravují soubory.

CC

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

Agent v terminálu

Anthropic Messages

Agent Anthropic v terminálu: píše kód, upravuje soubory a spouští příkazy.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/claude-code/)

#### Kde nastavit

Proměnné prostředí nebo blok "env" v ~/.claude/settings.json (pro jeden projekt – .claude/settings.local.json); rozšíření pro VS Code – claudeCode.environmentVariables; ověření – příkaz /status

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Adresa bez /v1: Claude Code samo přidává /v1/messages. ANTHROPIC\_AUTH\_TOKEN se odesílá jako Authorization: Bearer, ANTHROPIC\_API\_KEY jako x-api-key; Ailoot přijímá obě varianty. CLAUDE\_CODE\_ENABLE\_GATEWAY\_MODEL\_DISCOVERY=1 načítá naše modely do /model přes /v1/models. Při chybách 400 týkajících se neznámých polí použijte CLAUDE\_CODE\_DISABLE\_EXPERIMENTAL\_BETAS=1. Dokumentace Anthropic nepodporuje používání Claude Code s modely jinými než Claude přes bránu, přestože naše /v1/messages je obsluhuje; doporučujeme modely Claude. Remote Control a hlasový vstup nejsou při použití brány dostupné.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/claude-code/)[Dokumentace aplikace ↗](https://code.claude.com/docs/en/llm-gateway-connect)

OC

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

Agent v terminálu

OpenAI Responses

Agent OpenAI pro terminál, používá formát Responses.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/openai-codex-cli/)

#### Kde nastavit

~/.codex/config.toml (pouze uživatelský soubor: v projektovém .codex/config.toml jsou klíče model\_provider/model\_providers ignorovány); klíč – v proměnné určené pomocí env\_key

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/responses, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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
```

Příklad modelu: `gpt-6.1-sol`

#### Důležité

Codex funguje pouze přes OpenAI Responses API (dokumentace uvádí jen wire\_api = "responses"), proto je potřeba naše /v1/responses. ID poskytovatelů openai, ollama, lmstudio jsou rezervována. Alternativa – openai\_base\_url = "https://api.ailoot.ai/v1" pro vestavěného poskytovatele openai. Ailoot poskytuje Codex seznam modelů ve formátu manifestu Codex (GET /v1/models s client\_version). Vybírejte konkrétní model, který má v katalogu formát OpenAI Responses. Ve snímku z 2026-09-30 má gemini-3.6-flash OpenAI Chat, Anthropic Messages a Gemini, ale nemá Responses, proto se tento model pro Codex nehodí. Sadu formátů ověřujte podle karty modelu, nikoli podle názvu rodiny.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/openai-codex-cli/)[Dokumentace aplikace ↗](https://learn.chatgpt.com/docs/config-file/config-advanced)

HA

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

Agent v terminálu

OpenAI ChatOpenAI ResponsesAnthropic Messages

Agent Nous Research s pamětí a dovednostmi pro terminál.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/hermes-agent/)

#### Kde nastavit

hermes model → „Custom endpoint (self-hosted / VLLM / etc.)“ nebo ~/.hermes/config.yaml (sekce model nebo slovník providers)

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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

# více formátů současně — pojmenovaní poskytovatelé:
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

# v relaci: /model custom:claude-sonnet-5-5
```

Klíč se načítá z proměnné `AILOOT_API_KEY` – nastavte ji před spuštěním:

```bash
export AILOOT_API_KEY="sk-..."   # přidejte do ~/.zshrc nebo ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poté restartujte terminál
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

transport: chat\_completions (OpenAI Chat), anthropic\_messages (Anthropic Messages) nebo codex\_responses (OpenAI Responses). LLM\_MODEL v .env se již nepoužívá; OPENAI\_BASE\_URL platí pouze pro poskytovatele openai-api. Pro anthropic\_messages uvádějte adresu bez /v1 – SDK Anthropic samo přidá /v1/messages. Pomocné úlohy (rozpoznávání obrázků, komprese historie) se ve výchozím nastavení posílají stejnému hlavnímu modelu.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/hermes-agent/)[Dokumentace aplikace ↗](https://hermes-agent.nousresearch.com/docs/integrations/providers)

Op

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

Agent v terminálu

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Osobní AI asistent na vlastním počítači: chaty, messengery, úkoly.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/openclaw/)

#### Kde nastavit

Konfigurace OpenClaw (~/.openclaw/openclaw.json) → models.providers.\<id\>; výchozí model – agents.defaults.model.primary; bezpečná úprava – openclaw config set models.providers.\<id\> '\<json\>' --strict-json --merge

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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
          }
        ]
      }
    }
  }
}
```

Klíč se načítá z proměnné `AILOOT_API_KEY` – nastavte ji před spuštěním:

```bash
export AILOOT_API_KEY="sk-..."   # přidejte do ~/.zshrc nebo ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poté restartujte terminál
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Adaptéry api: openai-completions (výchozí při nastaveném baseUrl), openai-responses (pouze pokud server podporuje /v1/responses – Ailoot jej podporuje), anthropic-messages, google-generative-ai a další. Pro anthropic-messages je v příkladech OpenClaw baseUrl bez /v1. OpenClaw umí předávat obrázky, pokud input modelu obsahuje "image". V příkladech Claude je ponechán pouze text: ve snímku katalogu z 2026-09-30 tyto metody neuvádějí vstup image. Přidávejte "image" pouze pro konkrétní model, jehož karta v aktuálním katalogu uvádí obrázek na vstupu a zvolený formát API. Například gemini-3.6-flash v tomto snímku uvádí vstup image pro OpenAI Chat; skutečná podpora závisí na kartě modelu a formátu. Cesta k hlavnímu konfiguračnímu souboru vychází z běžné praxe OpenClaw, na přečtené stránce je uvedeno také ~/.openclaw/agents/\<agentId\>/agent/models.json.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/openclaw/)[Dokumentace aplikace ↗](https://docs.openclaw.ai/gateway/config-tools/custom-providers)

Op

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

Agent v terminálu

OpenAI Chat

Otevřený agent v terminálu s libovolným poskytovatelem kompatibilním s OpenAI.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/opencode/)

#### Kde nastavit

opencode.json (v projektu nebo ~/.config/opencode/opencode.json) → provider.\<id\>; klíč – přes /connect nebo "apiKey": "{env:VAR}"

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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"
        }
      }
    }
  }
}
```

Klíč se načítá z proměnné `AILOOT_API_KEY` – nastavte ji před spuštěním:

```bash
export AILOOT_API_KEY="sk-..."   # přidejte do ~/.zshrc nebo ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poté restartujte terminál
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Balíček @ai-sdk/openai-compatible používá /v1/chat/completions. Pro modely vyžadující /v1/responses uvádí dokumentace opencode balíček @ai-sdk/openai. Poskytovatel kompatibilní s Anthropic s vlastním baseURL není v dokumentaci opencode popsán. Vybírejte modely, pro které aktuální katalog uvádí formát OpenAI Chat. Ve snímku z 2026-09-30 má gemini-3.6-flash tento formát; ostatní modely Gemini ověřujte podle jejich karet. Nativní formát Gemini tuto cestu nepoužívá. Přítomnost metody v katalogu neznamená, že proběhl skutečný test konkrétní verze klienta.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/opencode/)[Dokumentace aplikace ↗](https://opencode.ai/docs/providers/)

QC

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

Agent v terminálu

OpenAI ChatAnthropic MessagesGemini

Konzolový agent týmu Qwen: formáty OpenAI, Anthropic a Gemini.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/qwen-code/)

#### Kde nastavit

Proměnné OPENAI\_API\_KEY / OPENAI\_BASE\_URL / OPENAI\_MODEL, příkaz /auth v relaci nebo ~/.qwen/settings.json (modelProviders + security.auth.selectedType)

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```bash
export AILOOT_API_KEY="sk-..."
# rychlý způsob
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"
  }
}
```

Klíč se načítá z proměnné `AILOOT_API_KEY` – nastavte ji před spuštěním:

```bash
export AILOOT_API_KEY="sk-..."   # přidejte do ~/.zshrc nebo ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poté restartujte terminál
```

Příklad modelu: `qwen3.8-max`

#### Důležité

Typy protokolu: openai (Chat Completions), anthropic, gemini, vertex-ai. Pro openai je baseUrl s /v1. Příklad v dokumentaci pro anthropic a gemini je uveden bez baseUrl, proto doporučujeme variantu openai. Pro typ openai vybírejte v katalogu model s formátem OpenAI Chat: gemini-3.6-flash jej má. U ostatních modelů Gemini se sada formátů může lišit – ověřte kartu konkrétního modelu. Varianta se settings.json čte klíč z proměnné AILOOT\_API\_KEY (pole envKey): nastavte ji příkazem export AILOOT\_API\_KEY=sk-... nebo řádkem AILOOT\_API\_KEY=sk-... v ~/.qwen/.env, jinak Qwen Code začne s prázdným klíčem a obdrží 401.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/qwen-code/)[Dokumentace aplikace ↗](https://qwenlm.github.io/qwen-code-docs/en/users/configuration/auth/)

GC

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

Agent v terminálu

Gemini

Agent Google v terminálu s nativním formátem Gemini.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/gemini-cli/)

#### Kde nastavit

Proměnné prostředí GEMINI\_API\_KEY a GOOGLE\_GEMINI\_BASE\_URL; způsob přihlášení – ~/.gemini/settings.json → security.auth.selectedType = "gemini-api-key"; model – GEMINI\_MODEL nebo přepínač -m

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1beta/models/{model}:generateContent, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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"
    }
  }
}
```

Příklad modelu: `gemini-3.8-flash`

#### Důležité

Adresa bez /v1beta: SDK sám přidává /v1beta/models/{model}:generateContent. Adresa musí používat HTTPS. Klíč se odesílá v hlavičce x-goog-api-key – Ailoot ji přijímá. Vhodné jsou pouze modely, u kterých katalog uvádí formát Gemini. Před spuštěním ověřte, že je pro váš klíč dostupné přesné ID a tato metoda. Ailoot předává placenou odpověď Gemini celou po výpočtu ceny, nikoli slovo po slovu, takže se u dlouhých odpovědí text nezobrazí okamžitě.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/gemini-cli/)[Dokumentace aplikace ↗](https://geminicli.com/docs/reference/configuration/)

KC

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

Agent v terminálu

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Konzolový agent Moonshot pro práci s kódem.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/kimi-cli/)

#### Kde nastavit

~/.kimi/config.toml (sekce providers a models, default\_model); /login podporuje pouze platformy Moonshot – vlastní adresa se nastavuje ručně v souboru

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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"]
```

Příklad modelu: `kimi-k3`

#### Důležité

Typy: openai\_legacy (Chat Completions, base\_url s /v1), openai\_responses (Responses, s /v1), anthropic (bez /v1), gemini (base\_url je kořen Google, u nás https://api.ailoot.ai). Nástroj SearchWeb funguje pouze s vlastní platformou Moonshot; FetchURL s jinou adresou API přechází na lokální načítání.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/kimi-cli/)[Dokumentace aplikace ↗](https://moonshotai.github.io/kimi-cli/en/configuration/providers.html)

Cr

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

Agent v terminálu

OpenAI ChatAnthropic Messages

Agent v terminálu od Charm s nastavením v souboru crushrc.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/crush/)

#### Kde nastavit

crushrc (konfigurace v Bash): ./.crushrc, ./crushrc nebo ~/.config/crush/crushrc; starý formát crush.json je zastaralý, ale funguje

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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

# formát Anthropic pro Claude: adresa 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
```

Klíč se načítá z proměnné `AILOOT_API_KEY` – nastavte ji před spuštěním:

```bash
export AILOOT_API_KEY="sk-..."   # přidejte do ~/.zshrc nebo ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poté restartujte terminál
```

Příklad modelu: `deepseek-v4-pro`

#### Důležité

Typ openai-compat používá formát OpenAI Chat a adresu s /v1. Typ anthropic používá formát Messages a adresu bez /v1: Crush ji předává do anthropic-sdk-go, které samo přidává /v1/messages. Příklad z README Crush s /v1 by vedl k cestě /v1/v1/messages a chybě 404. Klíč se odesílá v hlavičce x-api-key, Ailoot jej přijímá. Pokud je seznam modelů prázdný, poskytovatel openai-compat je sám načte z /v1/models. crushrc se spouští jako kód: nespouštějte Crush v cizích složkách s tímto souborem. V tomto příkladu má Claude supports-images = false: snímek katalogu z 2026-09-30 uvádí pro zvolený formát Messages pouze text. Pokud vaše verze Crush podporuje tento přepínač, zapínejte jej pouze u modelu, jehož aktuální karta v katalogu uvádí vstup image ve zvoleném formátu API; samotný přepínač klienta modelu podporu obrázků nepřidává.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/crush/)[Dokumentace aplikace ↗](https://github.com/charmbracelet/crush#custom-providers)

Ai

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

Agent v terminálu

OpenAI Chat

Párové programování s AI přímo v repozitáři git.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/aider/)

#### Kde nastavit

Proměnné OPENAI\_API\_BASE a OPENAI\_API\_KEY, přepínač --model openai/\<model\>

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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
```

Příklad modelu: `openai/deepseek-v4-pro`

#### Důležité

Prefix openai/ je povinný: Aider tak (přes LiteLLM) posílá požadavky na endpoint /v1/chat/completions kompatibilní s OpenAI. U modelů, které Aider nezná, upozorní na neznámý kontext – nejde o chybu. Adresa Anthropic s vlastním base URL není na této stránce dokumentace popsána.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/aider/)[Dokumentace aplikace ↗](https://aider.chat/docs/llms/openai-compat.html)

Go

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

Agent v terminálu

OpenAI ChatAnthropic Messages

Otevřený agent pro terminál a počítač s rozšířeními MCP.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/goose/)

#### Kde nastavit

goose configure → Custom Providers → Add A Custom Provider, nebo JSON v ~/.config/goose/custom\_providers/ (Windows: %APPDATA%\\Block\\goose\\config\\custom\_providers\\); alternativa – vestavěný poskytovatel OpenAI s OPENAI\_HOST/OPENAI\_BASE\_PATH

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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

# varianta s vestavěným poskytovatelem 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"
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Enginy vlastního poskytovatele: openai, anthropic, ollama. V příkladu Goose je base\_url pro engine openai uvedeno jako úplná cesta až k /v1/chat/completions. Pro vestavěného poskytovatele je OPENAI\_HOST kořen bez cesty, OPENAI\_BASE\_PATH cesta (ve výchozím nastavení v1/chat/completions). Klíč v config.yaml Goose ignoruje – používá pouze proměnnou nebo úložiště klíčů. Repozitář byl přesunut do aaif-goose/goose.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/goose/)[Dokumentace aplikace ↗](https://github.com/aaif-goose/goose/blob/main/documentation/docs/getting-started/providers.md)

FD

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

Agent v terminálu

OpenAI ChatOpenAI ResponsesAnthropic Messages

Agent Factory pro terminál s vlastními modely.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/factory-droid/)

#### Kde nastavit

~/.factory/settings.json → pole customModels; výběr modelu – příkaz /model, sekce „Custom models“

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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
    }
  ]
}
```

Klíč se načítá z proměnné `AILOOT_API_KEY` – nastavte ji před spuštěním:

```bash
export AILOOT_API_KEY="sk-..."   # přidejte do ~/.zshrc nebo ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poté restartujte terminál
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

provider: anthropic = Messages API (baseUrl jako u Anthropic, bez /v1), openai = Responses API (s /v1), generic-chat-completion-api = Chat Completions (s /v1). Pro anthropic se klíč ve výchozím nastavení odesílá v x-api-key (Ailoot jej přijímá); "authMode": "bearer" přepne na Authorization. Klíče zůstávají uložené lokálně. Factory plně testuje pouze oficiální API Anthropic a OpenAI.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/factory-droid/)[Dokumentace aplikace ↗](https://docs.factory.com/model-independence/byok)

Am

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

Agent v terminálu

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Programovací agent Amp s flexibilním směrováním mezi modely.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/amp/)

#### Kde nastavit

Nastavení → Model Routing → Add → Custom URL (nebo Model Routing pracovního prostoru pro tým); z terminálu – amp config model-providers (list, test, set-priority, edit-router…)

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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

Druhé připojení pro GPT:
  Format:   responses
  Base URL: https://api.ailoot.ai/v1
  API key:  sk-...
  Model mapping:
    openai/gpt-5.6-sol -> gpt-5.6-sol

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

Příklad modelu: `claude-fable-5`

#### Důležité

Formáty Custom URL: chat-completions (\<base\>/chat/completions), responses (\<base\>/responses), anthropic-messages (\<base\>/v1/messages, /v1 se neduplikuje), google-genai (\<base\>/models/\<model\>:streamGenerateContent). Klíč se odesílá jako Authorization: Bearer. Při mapování se používají kanonická ID Amp ve tvaru provider/model; šipka určuje ID odesílané k nám. Modely, které připojení nepokrývá, obsluhuje Amp sám za své kredity. Dokumentace vyžaduje, aby byl vlastní host dostupný ze služby Amp – adresa je veřejná, tato podmínka je splněna.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/amp/)[Dokumentace aplikace ↗](https://ampcode.com/docs/markdown/customize/model-routing)

AI

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

Agent v terminálu

OpenAI ChatAnthropic MessagesGemini

Univerzální chat v terminálu s rolemi, relacemi a RAG.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/aichat/)

#### Kde nastavit

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

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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 'Ahoj'
```

Příklad modelu: `deepseek-v4-pro`

#### Důležité

V ukázkové konfiguraci AIChat je api\_base pro claude uvedeno s /v1, pro gemini s /v1beta; pro Ailoot platí totéž. Tři klienti poskytují přístup ke všem třem formátům Ailoot: OpenAI, Anthropic a Gemini.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/aichat/)[Dokumentace aplikace ↗](https://github.com/sigoden/aichat/blob/main/config.example.yaml)

CC

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

Agent v terminálu

OpenAI Chat

Konzolová verze Continue pro agenty a automatizaci.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/continue-cli/)

#### Kde nastavit

Konfigurace Continue v YAML (config.yaml), předává se CLI přepínačem --config \<path\>

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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-...

# spuštění:
cn --config ./ailoot.yaml
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Pro služby kompatibilní s OpenAI používá Continue provider: openai a apiBase s /v1. Formát konfigurace je společný pro rozšíření i CLI, soubor se předává přepínačem --config.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/continue-cli/)[Dokumentace aplikace ↗](https://docs.continue.dev/customize/model-providers/top-level/openai)

Fo

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

Agent v terminálu

OpenAI Chat

Agent v terminálu s nastavitelnými poskytovateli.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/forge/)

#### Kde nastavit

forge provider login → OpenAI-compatible (doporučený postup); zastaralý postup – .env s OPENAI\_URL a OPENAI\_API\_KEY plus model ve forge.yaml

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```bash
# doporučeno:
forge provider login   # vyberte OpenAI-compatible, zadejte https://api.ailoot.ai/v1 a sk-...

# zastaralý způsob (.env):
OPENAI_API_KEY=sk-...
OPENAI_URL=https://api.ailoot.ai/v1

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

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Nastavení přes .env je označeno jako zastaralé: při prvním spuštění Forge přesune proměnné do svého souborového úložiště. Přesné popisky položek průvodce provider login nejsou v README uvedeny.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/forge/)[Dokumentace aplikace ↗](https://github.com/tailcallhq/forgecode)

GC

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

Agent v terminálu

OpenAI ChatAnthropic Messages

Copilot v terminálu s vlastními modely.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/github-copilot-cli/)

#### Kde nastavit

Proměnné prostředí COPILOT\_PROVIDER\_BASE\_URL, COPILOT\_PROVIDER\_TYPE, COPILOT\_PROVIDER\_API\_KEY, COPILOT\_MODEL (nebo přepínač --model)

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```bash
export AILOOT_API_KEY="sk-..."
unset COPILOT_PROVIDER_TYPE
# režim kompatibilní s 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

# režim 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
```

Příklad modelu: `gpt-6.1-sol`

#### Důležité

Typy: openai (výchozí, libovolný server kompatibilní s OpenAI), azure, anthropic. Model musí podporovat volání nástrojů a streamovaný výstup. Pro výběr protokolu existuje COPILOT\_PROVIDER\_WIRE\_API, jeho hodnoty ale na stránce nejsou vyjmenovány. Limity lze nastavit pomocí COPILOT\_PROVIDER\_MAX\_PROMPT\_TOKENS / MAX\_OUTPUT\_TOKENS.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/github-copilot-cli/)[Dokumentace aplikace ↗](https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/use-byok-models)

Gp

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

Agent v terminálu

OpenAI Chat

Osobní agent v terminálu: kód, soubory, prohlížeč.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/gptme/)

#### Kde nastavit

~/.config/gptme/config.toml → \[\[providers\]\]; model se vybírá jako \<provider\>/\<model\>

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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 'ahoj' -m ailoot/claude-sonnet-5-5
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Libovolný server kompatibilní s OpenAI; klíč se hledá v api\_key, poté v api\_key\_env a následně v \<NAME\>\_API\_KEY. Seznam poskytovatelů – gptme-util providers list.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/gptme/)[Dokumentace aplikace ↗](https://github.com/gptme/gptme/blob/master/docs/providers-custom.rst)

KC

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

Agent v terminálu

OpenAI ChatOpenAI ResponsesAnthropic Messages

Konzolový agent Kilo Code.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/kilo-code-cli/)

#### Kde nastavit

~/.config/kilo/kilo.jsonc (nebo ./kilo.jsonc; také KILO\_CONFIG) → provider.\<id\>.options.baseURL; v rozšíření – Settings → Providers → Custom provider

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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
          }
        }
      }
    }
  }
}
```

Klíč se načítá z proměnné `AILOOT_API_KEY` – nastavte ji před spuštěním:

```bash
export AILOOT_API_KEY="sk-..."   # přidejte do ~/.zshrc nebo ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poté restartujte terminál
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

V dialogu Custom provider lze vybrat protokol: OpenAI Compatible (Chat Completions), OpenAI Responses, Anthropic Messages. {env:VAR} funguje pouze v důvěryhodné globální konfiguraci (~/.config/kilo), v projektovém kilo.json se klíč z proměnné nedosadí.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/kilo-code-cli/)[Dokumentace aplikace ↗](https://kilo.ai/docs/code-with-ai/agents/custom-models)

LL

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

Agent v terminálu

OpenAI ChatOpenAI Responses

Nástroj pro odesílání požadavků modelům z příkazového řádku.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/llm-cli/)

#### Kde nastavit

Soubor extra-openai-models.yaml v adresáři nastavení llm; klíč – llm keys set \<název\>

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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 'Ahoj'
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Ve výchozím nastavení Chat Completions; responses: true přepíná model na /responses. Při nastaveném api\_base se klíč OpenAI neodesílá – je potřeba api\_key\_name. Jde o CLI nástroj pro požadavky, nikoli o agenta.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/llm-cli/)[Dokumentace aplikace ↗](https://llm.datasette.io/en/stable/other-models.html)

MS

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

Agent v terminálu

OpenAI Chat

Minimalistický agent pro úkoly v repozitáři.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/mini-swe-agent/)

#### Kde nastavit

Konfigurace agenta v YAML → sekce model (model\_name, model\_kwargs); výchozí cestu ke konfiguraci mění nastavení MSWEA\_MINI\_CONFIG\_PATH

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```yaml
# část konfigurace 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"
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Funguje přes LiteLLM: model\_kwargs se předávají přímo do litellm.completion. Bez registru cen hlásí LiteLLM chybu kvůli neznámé ceně – vypínáme cost\_tracking: "ignore\_errors" (nebo MSWEA\_COST\_TRACKING=ignore\_errors). Předávání klíče přes OPENAI\_API\_KEY je standard LiteLLM, na samotné stránce mini-SWE-agent není ukázáno.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/mini-swe-agent/)[Dokumentace aplikace ↗](https://github.com/SWE-agent/mini-swe-agent/blob/main/docs/models/local_models.md)

OC

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

Agent v terminálu

OpenAI Chat

Autonomní agent pro vývoj v příkazovém řádku.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/openhands-cli/)

#### Kde nastavit

Ctrl+P → Settings (poskytovatel a model), soubor ~/.openhands/agent\_settings.json (llm.model / llm.api\_key / llm.base\_url) nebo proměnné LLM\_MODEL, LLM\_API\_KEY, LLM\_BASE\_URL s přepínačem --override-with-envs

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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-..."
# jednorázově pomocí proměnných:
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
```

Příklad modelu: `openai/claude-sonnet-5-5`

#### Důležité

OpenHands používá LiteLLM; pro proxy OpenAI dokumentace požaduje Custom Model ve tvaru openai/\<model\> a Base URL proxy. Změny přes --override-with-envs se neukládají. Ve webovém rozhraní: Settings → LLM → Advanced → Custom Model, Base URL, API Key.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/openhands-cli/)[Dokumentace aplikace ↗](https://docs.openhands.dev/openhands/usage/cli/command-reference)

Pi

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

Agent v terminálu

OpenAI ChatAnthropic MessagesGemini

Minimalistický programovací agent pro terminál.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/pi/)

#### Kde nastavit

~/.pi/agent/models.json (nebo projektový .pi/models.json po označení projektu za důvěryhodný); výběr – /model

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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"
        }
      ]
    }
  }
}
```

Klíč se načítá z proměnné `AILOOT_API_KEY` – nastavte ji před spuštěním:

```bash
export AILOOT_API_KEY="sk-..."   # přidejte do ~/.zshrc nebo ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poté restartujte terminál
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Dokumentace Pi výslovně umožňuje endpointy kompatibilní s OpenAI, Anthropic a Google přes models.json; příklad je uveden pro api: openai-completions. apiKey rozumí $NAME/${NAME}, literálu nebo !příkazu. Soubor se znovu načítá při otevření /model.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/pi/)[Dokumentace aplikace ↗](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/models.md)

Pl

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

Agent v terminálu

OpenAI Chat

Agent pro rozsáhlé úkoly: plán, změny v sandboxu, aplikování změn.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/plandex/)

#### Kde nastavit

plandex models custom (nebo \\models custom v REPL) – otevře soubor JSON s vlastními modely a poskytovateli

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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"
        }
      ]
    }
  ]
}
```

Klíč se načítá z proměnné `AILOOT_API_KEY` – nastavte ji před spuštěním:

```bash
export AILOOT_API_KEY="sk-..."   # přidejte do ~/.zshrc nebo ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poté restartujte terminál
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Vlastní poskytovatelé fungují pouze v Plandex na vlastním serveru; v cloudu s klíči BYO jsou povoleni jen vestavění poskytovatelé. Všichni vlastní poskytovatelé musí být kompatibilní s OpenAI (Chat Completions). Model se následně zařadí do vlastního model pack.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/plandex/)[Dokumentace aplikace ↗](https://github.com/plandex-ai/plandex/blob/main/docs/docs/models/custom-models.md)

TA

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

Agent v terminálu

OpenAI ChatAnthropic Messages

Výzkumný agent ByteDance pro vývojové úkoly.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/trae-agent/)

#### Kde nastavit

trae\_config.yaml → model\_providers.\<název\>.base\_url; alternativně proměnné OPENAI\_BASE\_URL / ANTHROPIC\_BASE\_URL v .env

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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
```

Příklad modelu: `gpt-6.1-sol`

#### Důležité

V YAML používejte pouze mezery, žádné tabulátory. Pro formát Anthropic – provider: anthropic a ANTHROPIC\_BASE\_URL (README neuvádí, zda anthropic přesně vyžaduje /v1; použijte https://api.ailoot.ai).

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/trae-agent/)[Dokumentace aplikace ↗](https://github.com/bytedance/trae-agent#using-base-url)

Wa

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

Agent v terminálu

OpenAI Chat

Terminál s vestavěným agentem a vlastní adresou modelu.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/warp/)

#### Kde nastavit

Settings → vyhledejte „inference endpoint“ → Custom inference endpoint: základní URL, klíč, ID modelů; poté vyberte model v nabídce

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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
Poté vyberte v seznamu modelů například claude-sonnet-5-5 (nikoli Auto).
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Pouze OpenAI Chat Completions (POST /v1/chat/completions). Požadavky procházejí servery Warp: klíč se ukládá lokálně, ale při každém požadavku se předává backendu Warp. Režim Auto a vlastní routery vždy spotřebovávají kredity Warp; cloudoví agenti tento endpoint nepoužívají. Dostupné v plánu Free i v placených plánech pro jednotlivce a týmy do 10 lidí. Vybírejte modely, u nichž aktuální katalog uvádí formát OpenAI Chat. Ve snímku 2026-09-30 má tento formát gemini-3.6-flash; ostatní modely Gemini ověřte podle jejich karet. Tento postup nepoužívá nativní formát Gemini. Přítomnost metody v katalogu neznamená, že proběhlo živé ověření konkrétní verze klienta.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/warp/)[Dokumentace aplikace ↗](https://docs.warp.dev/agents/inference/custom-inference-endpoint/)

## Editory a IDE

Rozšíření a vestavění asistenti editorů kódu.

Cl

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

Rozšíření editoru

OpenAI ChatAnthropic Messages

Autonomní agent ve VS Code a JetBrains: plán, úpravy, příkazy.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/cline/)

#### Kde nastavit

Panel Cline → ikona ozubeného kolečka (Settings) → API Provider = „OpenAI Compatible“ → pole Base URL, API Key, Model ID. Druhá možnost: API Provider = „Anthropic“ → zaškrtnout „Use custom base URL“.

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```text
OpenAI Compatible (doporučujeme):
  API Provider: OpenAI Compatible
  Base URL:     https://api.ailoot.ai/v1
  API Key:      sk-...
  Model ID:     claude-sonnet-5-5   (nebo gpt-6.1-sol, deepseek-v4-pro, qwen3.8-max)
  Model Configuration: Context Window a Max Output Tokens podle modelu; Image Support pouze pro modely, které rozumějí obrázkům.

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

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

OpenAI Compatible používá /v1/chat/completions, proto je adresa s /v1. Varianta Anthropic používá /v1/messages, adresa je bez /v1, v jejím seznamu modelů jsou ale pouze názvy Anthropic – ostatní modely Ailoot jsou dostupné přes OpenAI Compatible. Režim agenta vyžaduje model s voláním nástrojů. Modely Gemini 3.1 Pro nejsou přes chat/completions dostupné (mají pouze formáty Gemini a Anthropic) – zde použijte gemini-3.6-flash.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/cline/)[Dokumentace aplikace ↗](https://docs.cline.bot/provider-config/openai-compatible)

RC

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

Rozšíření editoru

OpenAI ChatAnthropic Messages

Agent ve VS Code s režimy pro kód, architekturu a ladění.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/roo-code/)

#### Kde nastavit

Panel Roo Code → ozubené kolečko → API Provider = „OpenAI Compatible“ → Base URL, API Key, Model; volitelně Model Configuration (Max Output Tokens, Context Window, Image Support, Computer Use, ceny). Poskytovatel Anthropic má zaškrtávací pole „Use custom base URL“.

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

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

Varianta přes Anthropic:
API Provider: Anthropic, API key sk-..., [x] Use custom base URL → https://api.ailoot.ai
```

Příklad modelu: `gpt-6.1-sol`

#### Důležité

Roo Code volá nástroje pouze ve formátu OpenAI, proto musí model podporovat tools v /v1/chat/completions. Varianta Anthropic používá /v1/messages, adresa je bez /v1.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/roo-code/)[Dokumentace aplikace ↗](https://roocodeinc.github.io/Roo-Code/providers/openai-compatible/)

KC

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

Rozšíření editoru

OpenAI Chat

Agent ve VS Code s režimy a vlastními modely.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/kilo-code/)

#### Kde nastavit

Settings (ozubené kolečko) → záložka Providers → dole „Custom provider“ → Provider ID, Display name, Provider API = „OpenAI Compatible“, Base URL, API key, Models (seznam se načítá z /v1/models). Nastavení se ukládá do kilo.json.

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```text
Provider ID:   ailoot
Display name:  Ailoot
Provider API:  OpenAI Compatible
Base URL:      https://api.ailoot.ai/v1
API key:       sk-...
Models:        vyberte ze seznamu, například claude-sonnet-5-5, gpt-6.1-sol, deepseek-v4-pro
```

Příklad modelu: `deepseek-v4-pro`

#### Důležité

Kilo posílá požadavek na {Base URL}/models a samo zobrazuje seznam modelů – naše GET /v1/models vrací celý katalog. Lze zadat i úplnou adresu .../v1/chat/completions. Podporovány jsou vlastní hlavičky.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/kilo-code/)[Dokumentace aplikace ↗](https://kilo.ai/docs/ai-providers/openai-compatible)

Co

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

Rozšíření editoru

OpenAI Chat

Asistent pro VS Code a JetBrains: chat, úpravy, agent.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/continue/)

#### Kde nastavit

Soubor ~/.continue/config.yaml (nebo editor konfigurace Continue): položka v models\[\] s provider: openai a apiBase.

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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   # pouze pokud potřebujete vynutit /chat/completions
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

apiBase musí končit na /v1. Pro názvy ve tvaru gpt-5 / řady o může Continue samo zvolit /v1/responses; naše gpt-\* podporují /v1/responses i /v1/chat/completions a useResponsesApi: false vynutí chat/completions. useLegacyCompletionsEndpoint není potřeba.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/continue/)[Dokumentace aplikace ↗](https://docs.continue.dev/customize/model-providers/top-level/openai)

Ze

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

Editor kódu

OpenAI ChatOpenAI ResponsesAnthropic Messages

Rychlý editor kódu s vestavěným agentem.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/zed/)

#### Kde nastavit

Agent Settings (agent::OpenSettings) → LLM Providers → Add Provider; nebo settings.json → language\_models.openai\_compatible / language\_models.anthropic\_compatible. Klíč – v okně nastavení (ukládá se v systémové klíčence) nebo v proměnné \<ID poskytovatele VELKÝMI PÍSMENY\>\_API\_KEY.

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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"
```

Příklad modelu: `gpt-6.1-sol`

#### Důležité

U openai\_compatible se používá adresa s /v1 (volá /v1/chat/completions; capabilities.chat\_completions = false přepne model na /v1/responses). U anthropic\_compatible se používá adresa bez /v1 (volá /v1/messages; Zed posílá klíč v x-api-key – Ailoot jej přijímá). Výchozí hodnoty jsou images = false a parallel\_tool\_calls = false. Zed umí předávat obrázky, ale images zapínejte pouze pro konkrétní model, jehož aktuální karta v katalogu uvádí vstup image ve zvoleném formátu API. V příkladech GPT a Claude je images = false: snímek 2026-09-30 u nich uvádí pouze text. Například gemini-3.6-flash v tomto snímku uvádí vstup image pro OpenAI Chat; skutečná podpora závisí na kartě modelu a formátu. Pro modely s uvažováním je k dispozici pole reasoning\_effort. Hodnoty max\_tokens v příkladu představují velikost kontextu; přesné limity najdete v katalogu modelů.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/zed/)[Dokumentace aplikace ↗](https://zed.dev/docs/ai/use-api-access)

VC

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

Rozšíření editoru

OpenAI ChatOpenAI ResponsesAnthropic Messages

Vlastní poskytovatel v Copilot Chat pro VS Code.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/vscode-copilot-byok/)

#### Kde nastavit

Výběr modelu v chatu → Manage Language Models (ozubené kolečko) → Add Models → Custom Endpoint → VS Code otevře chatLanguageModels.json. (Staré nastavení github.copilot.chat.customOAIModels je zastaralé.)

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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
      }
    ]
  }
]
```

Příklad modelu: `gpt-6.1-sol`

#### Důležité

url je ÚPLNÁ cesta endpointu. Hodnoty apiType: chat-completions, responses (url .../v1/responses), messages (url .../v1/messages). BYOK funguje bez plánu Copilot i bez přihlášení ke GitHubu, ale pouze pro chat/agent – průběžné návrhy v editoru zůstávají na Copilotu. Správci organizací (Business/Enterprise) mohou zásadu BYOK vypnout. Výše uvedené limity tokenů jsou příklady; použijte hodnoty z katalogu. V těchto příkladech je vision = false: snímek katalogu 2026-09-30 uvádí pouze text pro GPT/OpenAI Chat a Claude/Anthropic Messages. Pokud vaše verze VS Code nabízí vision, zapínejte jej pouze u modelu, jehož aktuální karta v katalogu uvádí vstup image ve vybraném formátu API; přítomnost pole v klientovi nepotvrzuje podporu obrázků vybraným modelem.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/vscode-copilot-byok/)[Dokumentace aplikace ↗](https://code.visualstudio.com/docs/agent-customization/language-models)

JA

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

Editor kódu

OpenAI Chat

Vestavěný asistent IDE JetBrains s vlastním klíčem.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/jetbrains-ai-assistant/)

#### Kde nastavit

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

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

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

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Vyberte OpenAI-compatible, zadejte URL https://api.ailoot.ai/v1 a svůj API Key. Klikněte na Test Connection a potom Apply; zvolte model v AI Chat. Pro funkce IDE jej přiřaďte v Models Assignment. Tool calling zapínejte jen u modelu s podporou nástrojů; doplňování kódu má samostatné nastavení.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/jetbrains-ai-assistant/)[Dokumentace aplikace ↗](https://www.jetbrains.com/help/ai-assistant/use-custom-models.html)

Xc

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

Editor kódu

OpenAI Chat

Coding Intelligence v Xcode s externím poskytovatelem.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/xcode/)

#### Kde nastavit

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

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```text
Type:           Internet Hosted
URL:            https://api.ailoot.ai        (BEZ /v1 — Xcode samo přidá /v1/models a /v1/chat/completions)
API Key:        sk-...
API Key Header: x-api-key
Description:    Ailoot
→ poté vyberte modely ze seznamu (například claude-sonnet-5-5, gpt-6.1-sol)
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Apple vyžaduje, aby poskytovatel podporoval Chat Completions a odpovídal na {URL}/v1/models a {URL}/v1/chat/completions. Ailoot přijímá klíč v x-api-key i v Authorization: Bearer (při výběru hlavičky Authorization Xcode podle uživatelských ohlasů sám přidá předponu Bearer). Agenti Xcode se nastavují samostatně a tento návod je nezahrnuje.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/xcode/)[Dokumentace aplikace ↗](https://developer.apple.com/documentation/xcode/setting-up-coding-intelligence)

AN

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

Plugin pro Neovim

OpenAI ChatAnthropic Messages

Plugin pro Neovim: chat a úpravy přímo v bufferu.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/avante-nvim/)

#### Kde nastavit

opts pro yetone/avante.nvim v lazy.nvim: opts.providers.\<název\> s \_\_inherited\_from = 'openai' (vlastní poskytovatel kompatibilní s OpenAI) nebo přepsání providers.claude.endpoint; klíč se bere z proměnné uvedené v api\_key\_name (podporovány jsou názvy AVANTE\_\*).

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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",
    },
  },
}
-- v terminálu: export AILOOT_API_KEY=sk-...
-- poskytovatel claude čte AVANTE_ANTHROPIC_API_KEY nebo ANTHROPIC_API_KEY
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Ve wiki pluginu končí adresa kompatibilní s OpenAI na /v1 (plugin připojuje /chat/completions). Vestavěný poskytovatel claude používá adresu ve tvaru https://api.anthropic.com, proto pro Ailoot použijte adresu bez /v1. Vlastní poskytovatelé bez \_\_inherited\_from vyžadují úplnou adresu a vlastní funkce pro zpracování odpovědi.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/avante-nvim/)[Dokumentace aplikace ↗](https://github.com/avante-corp/avante.nvim/wiki/Custom-providers)

CN

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

Plugin pro Neovim

OpenAI ChatAnthropic Messages

Chat a úpravy přímo v Neovimu.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/codecompanion-nvim/)

#### Kde nastavit

require('codecompanion').setup({ adapters = { http = { ... } } }) přes adapters.extend('openai\_compatible', ...) nebo extend('anthropic', ...); poté interactions.chat/inline.adapter.

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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",        -- název proměnné prostředí obsahující sk-...
            chat_url = "/v1/chat/completions",
          },
          schema = { model = { default = "gpt-6.1-sol" } },
        })
      end,
    },
  },
  interactions = {
    chat = { adapter = "ailoot" },
    inline = { adapter = "ailoot" },
  },
})
```

Klíč se načítá z proměnné `AILOOT_API_KEY` – nastavte ji před spuštěním:

```bash
export AILOOT_API_KEY="sk-..."   # přidejte do ~/.zshrc nebo ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poté restartujte terminál
```

Příklad modelu: `gpt-6.1-sol`

#### Důležité

openai\_compatible odděluje host (env.url, bez /v1) a cestu (env.chat\_url). Hodnoty env mohou být názvem proměnné prostředí, cmd:..., file:... nebo funkcí Lua. Adaptér anthropic se obdobně rozšiřuje vlastním url pro /v1/messages.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/codecompanion-nvim/)[Dokumentace aplikace ↗](https://codecompanion.olimorris.dev/configuration/adapters-http)

Gp

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

Balíček pro Emacs

OpenAI ChatAnthropic MessagesGemini

Jednoduchý klient jazykových modelů pro Emacs.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/gptel/)

#### Kde nastavit

init.el: zaregistrujte backend přes gptel-make-openai (OpenAI Chat), gptel-make-anthropic (Messages) nebo gptel-make-gemini – každý má :host, :endpoint, :key, :stream, :models; poté nastavte gptel-backend a gptel-model.

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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")               ; nebo (gptel-api-key-from-environment "AILOOT_API_KEY")
        :models '(claude-sonnet-5-5 gpt-6.1-sol deepseek-v4-pro qwen3.8-max)))

;; varianta Anthropic Messages
(gptel-make-anthropic "Ailoot-Claude"
  :host "api.ailoot.ai"          ; výchozí cesta /v1/messages
  :stream t
  :key (getenv "AILOOT_API_KEY")
  :models '(claude-sonnet-5-5 claude-opus-5-5))
```

Klíč se načítá z proměnné `AILOOT_API_KEY` – nastavte ji před spuštěním:

```bash
export AILOOT_API_KEY="sk-..."   # přidejte do ~/.zshrc nebo ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poté restartujte terminál
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

:host – pouze název hostu (bez https:// a cesty), cesta se nastavuje v :endpoint. gptel-make-anthropic odesílá hlavičky x-api-key a anthropic-version – Ailoot je přijímá.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/gptel/)[Dokumentace aplikace ↗](https://github.com/karthink/gptel)

TI

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

Editor kódu

OpenAI Chat

Otevřené IDE s modulem Theia AI.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/theia/)

#### Kde nastavit

Preferences → AI-features → OpenAiCustom (nebo klíč ai-features.openAiCustom.customOpenAiModels v settings.json; okno AI Configuration – Alt+A).

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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"
    }
  ]
}
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

url – základní adresa zakončená /v1. Pro modely jiných výrobců než OpenAI je bezpečnou volbou developerMessageSettings: "system".

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/theia/)[Dokumentace aplikace ↗](https://theia-ide.org/docs/user_ai/)

TI

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

Editor kódu

OpenAI ChatAnthropic Messages

Editor kódu Trae s vlastními modely.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/trae/)

#### Kde nastavit

Settings → Models → Add Model → Custom Model → API Format, Request URL (přepínač Full URL), Model ID, Display Name, API Key; volitelně Advanced Settings.

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```text
Formát 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-...

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

Příklad modelu: `gpt-6.1-sol`

#### Důležité

Při vypnutém Full URL Trae sám doplní cestu podle zvoleného formátu (pro OpenAI – adresa s /v1, pro Anthropic – bez /v1). Při zapnutém Full URL zadejte https://api.ailoot.ai/v1/chat/completions nebo https://api.ailoot.ai/v1/messages. Pole Model Series přizpůsobuje nápovědu rodině modelu.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/trae/)[Dokumentace aplikace ↗](https://docs.trae.ai/ide/models)

## Chatovací aplikace

Chaty pro počítač, telefon a prohlížeč, poznámky a spouštěče aplikací.

OW

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

Webový chat, vlastní server

OpenAI Chat

Oblíbený webový chat na vlastním serveru.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/open-webui/)

#### Kde nastavit

Settings \> Admin \> Connections \> Manage OpenAI API Connections \> + Add Connection (nebo proměnné prostředí OPENAI\_API\_BASE\_URL / OPENAI\_API\_KEY při spuštění kontejneru)

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```text
UI: URL = https://api.ailoot.ai/v1
API Key = sk-...
Model IDs: prázdné (načtou se z /v1/models) nebo ručně přidejte claude-sonnet-5-5, gpt-6.1-sol

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

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Formát OpenAI Chat Completions; URL musí být s /v1 a bez koncového lomítka. Seznam modelů se načítá z /v1/models, u rozsáhlého katalogu (252 modelů) je praktičtější omezit Model IDs a zapnout mezipaměť seznamu modelů (Cache Base Model List / ENABLE\_BASE\_MODELS\_CACHE=True). Pro embeddingy RAG existuje samostatné RAG\_OPENAI\_API\_BASE\_URL.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/open-webui/)[Dokumentace aplikace ↗](https://docs.openwebui.com/getting-started/quick-start/connect-a-provider/starting-with-openai-compatible/)

Li

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

Webový chat, vlastní server

OpenAI ChatAnthropic Messages

Webový chat na vlastním serveru s agenty a více poskytovateli.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/librechat/)

#### Kde nastavit

Soubor librechat.yaml → endpoints.custom (klíč v .env přes ${VAR}); pro formát Anthropic pole provider: 'anthropic'

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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-...
```

Příklad modelu: `gpt-6.1-sol`

#### Důležité

Běžný vlastní endpoint = OpenAI Chat Completions (baseURL s /v1). provider: 'anthropic' zapíná nativního klienta /v1/messages; v příkladu dokumentace je baseURL pro Anthropic uvedeno bez /v1 (https://api.anthropic.com), proto pro nás použijte https://api.ailoot.ai. fetch: true načítá seznam z /v1/models.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/librechat/)[Dokumentace aplikace ↗](https://www.librechat.ai/docs/configuration/librechat_yaml/object_structure/custom_endpoint)

CS

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

Aplikace pro počítač

OpenAI ChatOpenAI ResponsesAnthropic Messages

Desktopový klient s asistenty a znalostní bází.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/cherry-studio/)

#### Kde nastavit

Settings (ozubené kolečko) \> Model Provider \> + Add Provider \> typ protokolu OpenAI / OpenAI Responses / Anthropic / Gemini

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```text
Provider Name: Ailoot
Typ: OpenAI (nebo OpenAI Responses / Anthropic)
API Key: sk-...
Base URL: https://api.ailoot.ai
→ Zkontrolujte náhled výsledné adresy pod polem: měla by vypadat takto https://api.ailoot.ai/v1/chat/completions (pro Anthropic — https://api.ailoot.ai/v1/messages)
Models: + claude-sonnet-5-5, gpt-6.1-sol
Poté tlačítko Model Check
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Dokumentace potvrzuje protokoly OpenAI, Anthropic, OpenAI Responses a Gemini i náhled výsledné cesty pod polem, pravidla připojování /v1 ale nepopisuje – řiďte se náhledem. Všechny tři naše formáty (Chat Completions, Responses, Messages) jsou vhodné.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/cherry-studio/)[Dokumentace aplikace ↗](https://cherryai.com/docs/en/pre-basic/providers/zi-ding-yi-fu-wu-shang/)

Ch

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

Počítač a telefon

OpenAI Chat

Chat pro počítač a telefon.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/chatbox/)

#### Kde nastavit

Nastavení (tlačítko v postranním panelu) \> Model Provider \> Add (dole) \> typ OpenAI API Compatible

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```text
Name: Ailoot
API Mode: OpenAI API Compatible
API Key: sk-...
API Host: https://api.ailoot.ai
API Path: (prázdné, výchozí /v1/chat/completions)
Models: + gpt-6.1-sol, claude-sonnet-5-5 (vision je v těchto příkladech vypnuté; tool_use závisí na možnostech vybraného modelu)
```

Příklad modelu: `gpt-6.1-sol`

#### Důležité

V dokumentaci je API Host uveden bez /v1 (například https://api.openai.com), výchozí cesta je /v1/chat/completions. Existuje také typ Google Gemini compatible, pro naše /v1beta ale nebyl ověřen. Import konfigurace JSON (type: 'openai', apiHost, apiPath) je dostupný od 1.15.1 přes chatbox://provider/import?config=\<base64\>. U uvedených modelů GPT a Claude je vision vypnuto: snímek katalogu z 2026-09-30 uvádí pro formát OpenAI Chat pouze text. Pokud vaše verze Chatbox nabízí vision, zapínejte jej pouze u modelu, jehož aktuální karta v katalogu uvádí vstup image ve zvoleném formátu API; možnost klienta připojit obrázek nedokazuje, že jej model podporuje.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/chatbox/)[Dokumentace aplikace ↗](https://docs.chatboxai.app/en/guides/providers)

Lo

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

Webový chat, vlastní server

OpenAI ChatAnthropic Messages

Moderní chat s pluginy a znalostní bází.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/lobechat/)

#### Kde nastavit

Vlastní hosting: proměnné prostředí OPENAI\_PROXY\_URL / OPENAI\_API\_KEY / OPENAI\_MODEL\_LIST, ANTHROPIC\_PROXY\_URL, GOOGLE\_PROXY\_URL

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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

# formát Anthropic (volitelně)
ANTHROPIC_API_KEY=sk-...
ANTHROPIC_PROXY_URL=https://api.ailoot.ai
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Výchozí OPENAI\_PROXY\_URL je https://api.openai.com/v1, proto uvádíme adresu s /v1. Výchozí ANTHROPIC\_PROXY\_URL je https://api.anthropic.com (bez /v1). Přes GOOGLE\_PROXY\_URL lze formálně připojit formát Gemini (https://api.ailoot.ai), tuto variantu jsme ale neověřovali. Používejte serverový režim: pokud požadavky přicházejí přímo z prohlížeče, API Ailoot je zatím může odmítnout podle pravidel CORS.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/lobechat/)[Dokumentace aplikace ↗](https://lobehub.com/docs/self-hosting/environment-variables/model-provider)

Ja

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

Aplikace pro počítač

OpenAI ChatAnthropic Messages

Otevřený chat pro počítač s lokálními a cloudovými modely.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/jan/)

#### Kde nastavit

Settings \> Model Providers \> Add Provider → vybrat formát OpenAI-compatible nebo Anthropic-compatible

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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: načtou se z {base_url}/models nebo + ručně: claude-sonnet-5-5
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Dokumentace: pro poskytovatele kompatibilní s OpenAI musí být Base URL s /v1 (jinak 404), koncové lomítko se odstraňuje; pro režim Anthropic je příklad LiteLLM bez /v1. Schopnosti modelu (tools, vision) se u vlastních poskytovatelů nastavují ručně. Podporuje záložní klíče (opakovaný pokus pouze při 401/403/429).

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/jan/)[Dokumentace aplikace ↗](https://www.jan.ai/docs/desktop/remote-models/custom-endpoint)

Si

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

Chat s hraním rolí

OpenAI Chat

Rozhraní pro chaty s hraním rolí a postavami.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/sillytavern/)

#### Kde nastavit

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

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```text
Custom Endpoint (Base URL): https://api.ailoot.ai/v1
Custom API Key: sk-...
Model: vyberte ze seznamu (/v1/models) nebo zadejte claude-sonnet-5-5
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Dokumentace: při potížích s připojením přidejte /v1 a NEPŘIDÁVEJTE /chat/completions. Seznam modelů se načte, pokud server poskytuje /v1/models (náš server jej poskytuje).

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/sillytavern/)[Dokumentace aplikace ↗](https://docs.sillytavern.app/usage/api-connections/openai/)

An

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

Chat s dokumenty

OpenAI Chat

Chat s vašimi dokumenty na počítači nebo serveru.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/anythingllm/)

#### Kde nastavit

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

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

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

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-...'
```

Příklad modelu: `deepseek-v4-pro`

#### Důležité

Poskytovatel je v dokumentaci označen jako „pro vývojáře“. Podle potřeby nastavte GENERIC\_OPEN\_AI\_MODEL\_MAX\_TOKEN\_KEY='max\_completion\_tokens'. Pro embeddingy existuje samostatný embedder generic-openai (EMBEDDING\_BASE\_PATH + GENERIC\_OPEN\_AI\_EMBEDDING\_API\_KEY) – model nemotron-3-embed přes /v1/embeddings.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/anythingllm/)[Dokumentace aplikace ↗](https://docs.anythingllm.com/setup/llm-configuration/cloud/openai-generic)

BA

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

Webový chat, vlastní server

OpenAI ChatAnthropic Messages

Pokročilé webové rozhraní pro práci s více modely.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/big-agi/)

#### Kde nastavit

Proměnné prostředí při nasazení: OPENAI\_API\_KEY / OPENAI\_API\_HOST, ANTHROPIC\_API\_KEY / ANTHROPIC\_API\_HOST; v rozhraní – Models \> Add OpenAI-compatible

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

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

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

V dokumentaci jsou proměnné popsány jako náhrada backendového hostu pro OpenAI a Anthropic (pro proxy a vlastní endpointy); používá se výraz „host“, proto jej uvádíme bez /v1, přesný formát cesty ale dokumentace nerozepisuje – je třeba jej ověřit prvním požadavkem.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/big-agi/)[Dokumentace aplikace ↗](https://github.com/enricoros/big-AGI/blob/main/docs/environment-variables.md)

Bo

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

Aplikace pro Mac

OpenAI Chat

Nativní AI klient pro macOS.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/boltai/)

#### Kde nastavit

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

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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: podle modelu
Streaming: zapnout
```

Příklad modelu: `gpt-6.1-sol`

#### Důležité

Je potřeba úplná adresa chat completions. Aby ji používala funkce AI Command, nastavte tuto službu jako výchozí. Návod vychází z nápovědy BoltAI; v BoltAI 2 se mohou okna lišit.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/boltai/)[Dokumentace aplikace ↗](https://boltai.com/help/how-to-setup-custom-openai-server)

HF

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

Webový chat, vlastní server

OpenAI Chat

Otevřený webový chat Hugging Face na vlastním serveru.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/hugging-face-chat-ui/)

#### Kde nastavit

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

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

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

Příklad modelu: `deepseek-v4-pro`

#### Důležité

Chat UI funguje pouze s API kompatibilními s OpenAI přes OPENAI\_BASE\_URL a načítá seznam modelů z /models.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/hugging-face-chat-ui/)[Dokumentace aplikace ↗](https://github.com/huggingface/chat-ui)

MS

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

Aplikace pro počítač

OpenAI Chat

Desktopový chat s lokálními a cloudovými modely.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/msty-studio/)

#### Kde nastavit

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

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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
```

Příklad modelu: `gpt-6.1-sol`

#### Důležité

Dokumentace potvrzuje vlastního poskytovatele kompatibilního s OpenAI, formát adresy ale neuvádí; /v1 je standardní kořen OpenAI API, při chybě 404 ověřte variantu bez /v1. Vlastní endpoint kompatibilní s Anthropic není v dokumentaci popsán.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/msty-studio/)[Dokumentace aplikace ↗](https://docs.msty.ai/studio/managing-models/online-providers)

Ne

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

Webový chat, vlastní server

OpenAI Chat

Lehký webový chat, který lze rychle nasadit.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/nextchat/)

#### Kde nastavit

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

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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
```

Příklad modelu: `gpt-6.1-sol`

#### Důležité

Pro toto nastavení používejte OpenAI Chat přes server NextChat. Při nasazení na Vercel nebo Docker nastavte BASE\_URL=https://api.ailoot.ai bez /v1 a dále OPENAI\_API\_KEY, CUSTOM\_MODELS a DEFAULT\_MODEL. Po změně těchto proměnných server znovu nasaďte.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/nextchat/)[Dokumentace aplikace ↗](https://github.com/ChatGPTNextWeb/NextChat#environment-variables)

OC

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

Plugin pro Obsidian

OpenAI Chat

Chat s poznámkami v Obsidianu.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/obsidian-copilot/)

#### Kde nastavit

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

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```text
Base URL: https://api.ailoot.ai/v1
API key: sk-...
Model ID: claude-sonnet-5-5 (nebo vyberte ze seznamu /v1/models)
Poté Test; model zapněte v Basic > Agents > Quick Chat
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Seznam modelů se načítá z /v1/models, model lze zadat ručně. Pokud Test prochází, ale Quick Chat neodesílá zprávy, zapněte u poskytovatele Enable CORS (odpověď přijde vcelku, bez streamování). Klíče se ukládají do Obsidian Keychain.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/obsidian-copilot/)[Dokumentace aplikace ↗](https://github.com/logancyang/obsidian-copilot/blob/master/docs/llm-providers.md)

PA

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

Rozšíření prohlížeče

OpenAI Chat

Rozšíření prohlížeče: chat s otevřenou stránkou.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/page-assist/)

#### Kde nastavit

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

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```text
Provider: Custom
Name: Ailoot
Base URL: https://api.ailoot.ai/v1
API Key: sk-...
Poté ručně přidejte modely: gpt-6.1-sol, claude-sonnet-5-5
```

Příklad modelu: `gpt-6.1-sol`

#### Důležité

Dokumentace potvrzuje Custom s API URL a klíčem; formát URL není rozepsán, /v1 je standardní kořen OpenAI API. Automatické načítání modelů je zaručeno pouze pro Ollama, LM Studio a Llamafile – u ostatních se modely přidávají ručně.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/page-assist/)[Dokumentace aplikace ↗](https://docs.pageassist.xyz/providers/openai)

RA

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

Spouštěč

OpenAI Chat

AI ve spouštěči Raycast: rychlé příkazy a chat.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/raycast-ai/)

#### Kde nastavit

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

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

base\_url je endpoint kompatibilní s OpenAI bez přípony /chat/completions. Raycast načítá soubor znovu bez restartu. Pokud abilities nejsou nastaveny, považují se tools a vision za nepodporované. Modely se zobrazují v Quick AI, AI Chat a AI Commands. V tomto příkladu je vision.supported = false: snímek katalogu z 2026-09-30 uvádí pro Claude/OpenAI Chat pouze text. Pokud vaše verze Raycast podporuje toto nastavení, zapínejte vision pouze u modelu, jehož aktuální karta v katalogu uvádí vstup image ve formátu OpenAI Chat; samotný přepínač klienta nepotvrzuje podporu obrázků v API.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/raycast-ai/)[Dokumentace aplikace ↗](https://manual.raycast.com/ai/custom-providers)

Ty

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

Webová aplikace

OpenAI Chat

Pohodlné rozhraní chatu v prohlížeči i na počítači.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/typingmind/)

#### Kde nastavit

Models (levý postranní panel) \> + Add Custom Model

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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: podle modelu
Test → Save
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Endpoint se zadává jako úplná cesta. Klíč se posílá ve vlastní hlavičce Authorization: Bearer sk-... – Ailoot ji přijímá. Webová verze TypingMind volá API přímo z prohlížeče a tyto požadavky může v současnosti zablokovat CORS; spolehlivější je desktopová verze. Typ Gemini v TypingMind posílá klíč v hlavičce apiKey, kterou Ailoot nepřijímá – použijte typ OpenAI Chat Completions.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/typingmind/)[Dokumentace aplikace ↗](https://docs.typingmind.com/manage-and-connect-ai-models/ollama)

## SDK a frameworky

Knihovny pro vlastní aplikace, agenty a RAG.

OS

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

SDK

OpenAI ChatOpenAI Responses

Oficiální knihovna OpenAI pro Python.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/openai-python-sdk/)

#### Kde nastavit

Parametr konstruktoru OpenAI(base\_url=..., api\_key=...) nebo proměnné prostředí OPENAI\_BASE\_URL a OPENAI\_API\_KEY

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```bash
export AILOOT_API_KEY="sk-..."
# proměnné prostředí
export OPENAI_BASE_URL="https://api.ailoot.ai/v1"
export OPENAI_API_KEY="$AILOOT_API_KEY"

# nebo v kódu
```

`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":"Ahoj"}])
print(r.choices[0].message.content)
# Responses API: client.responses.create(model="gpt-6.1-sol", input="Ahoj")
# Embeddingy: client.embeddings.create(model="nemotron-3-embed", input=["text"])
```

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

Příklad modelu: `gpt-6.1-sol, claude-sonnet-5-5, deepseek-v4-pro, qwen3.8-max (chat); nemotron-3-embed (embeddingy)`

#### Důležité

Adresa s /v1: SDK samo přidává /chat/completions, /responses, /embeddings, /images/\*, /audio/\*. Fungují Chat Completions a Responses (Responses u modelů, které mají tento formát v katalogu). Streamovaný výstup a nástroje jsou standardní. Chyby Ailoot přicházejí v JSON s Request ID a zachytávají se jako openai.APIStatusError.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/openai-python-sdk/)[Dokumentace aplikace ↗](https://github.com/openai/openai-python)

OS

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

SDK

OpenAI ChatOpenAI Responses

Oficiální knihovna OpenAI pro JavaScript a TypeScript.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/openai-node-js-sdk/)

#### Kde nastavit

Volba konstruktoru new OpenAI({ baseURL, apiKey }); SDK ve výchozím nastavení čte proměnnou prostředí OPENAI\_BASE\_URL

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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: "Ahoj" }]
});
console.log(r.choices[0].message.content);
```

Klíč se načítá z proměnné `AILOOT_API_KEY` – nastavte ji před spuštěním:

```bash
export AILOOT_API_KEY="sk-..."   # přidejte do ~/.zshrc nebo ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poté restartujte terminál
```

Příklad modelu: `claude-sonnet-5-5, gpt-6.1-sol, grok-4.7`

#### Důležité

README ukazuje volbu baseURL; čtení OPENAI\_BASE\_URL je vidět ve zdrojovém kódu klienta (src/client.ts), výchozí hodnota je https://api.openai.com/v1. Adresu Ailoot uvádějte s /v1. Dostupné jsou chat.completions i responses.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/openai-node-js-sdk/)[Dokumentace aplikace ↗](https://github.com/openai/openai-node)

AS

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

SDK

Anthropic Messages

Oficiální knihovna Anthropic pro Python.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/anthropic-python-sdk/)

#### Kde nastavit

Parametr Anthropic(base\_url=...) nebo proměnná prostředí ANTHROPIC\_BASE\_URL; klíč: api\_key nebo ANTHROPIC\_API\_KEY

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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": "Ahoj"}])
print(msg.content[0].text)
```

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

Příklad modelu: `claude-sonnet-5-5, claude-opus-5-5; také přes /v1/messages gpt-6.1-sol, deepseek-v4-pro, gemini-3.6-flash`

#### Důležité

Adresa BEZ /v1: SDK samo přidává /v1/messages. Brána přijímá klíč v x-api-key (tak jej odesílá SDK) i v Authorization: Bearer. Fungují streamovaný výstup, nástroje a /v1/messages/count\_tokens. Dávkové zpracování (Batches) a Files API nejsou v katalogu Ailoot deklarovány.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/anthropic-python-sdk/)[Dokumentace aplikace ↗](https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/python)

VA

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

SDK

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Framework v TypeScriptu pro AI aplikace s libovolnými poskytovateli.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/vercel-ai-sdk/)

#### Kde nastavit

Poskytovatelé: 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 }) nebo OPENAI\_BASE\_URL

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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: "Ahoj" });
// claude("claude-sonnet-5-5"), gemini("gemini-3.6-flash")
```

Klíč se načítá z proměnné `AILOOT_API_KEY` – nastavte ji před spuštěním:

```bash
export AILOOT_API_KEY="sk-..."   # přidejte do ~/.zshrc nebo ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poté restartujte terminál
```

Příklad modelu: `deepseek-v4-pro (kompatibilní s OpenAI), claude-sonnet-5-5 (Anthropic), gemini-3.6-flash (Gemini)`

#### Důležité

Poskytovatelé používají různé adresy: poskytovatel kompatibilní s OpenAI a Anthropic – s /v1 (výchozí adresa Anthropic je https://api.anthropic.com/v1), Google – s /v1beta (výchozí adresa je https://generativelanguage.googleapis.com/v1beta). Poskytovatel @ai-sdk/openai ve výchozím nastavení volá Responses API; pro modely bez metody responses použijte openai.chat("id") nebo createOpenAICompatible.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/vercel-ai-sdk/)[Dokumentace aplikace ↗](https://ai-sdk.dev/providers/openai-compatible-providers)

La

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

Framework

OpenAI ChatOpenAI ResponsesAnthropic Messages

Framework pro řetězce, agenty a RAG.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/langchain/)

#### Kde nastavit

ChatOpenAI(base\_url=...) nebo proměnné OPENAI\_API\_BASE / OPENAI\_BASE\_URL; ChatAnthropic(base\_url=...) nebo ANTHROPIC\_API\_URL / ANTHROPIC\_BASE\_URL

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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("Ahoj").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"])
```

Příklad modelu: `gpt-6.1-sol, qwen3.8-max (ChatOpenAI); claude-sonnet-5-5 (ChatAnthropic)`

#### Důležité

ChatOpenAI: adresa s /v1. Podle dokumentace podporuje ChatOpenAI pouze oficiální specifikaci OpenAI: nestandardní pole jako reasoning\_content u modelů třetích stran se neuchovávají. Pro Claude je vhodnější ChatAnthropic: adresa bez /v1, SDK samo přidává /v1/messages. Parametr base\_url a proměnné ANTHROPIC\_API\_URL/ANTHROPIC\_BASE\_URL pro ChatAnthropic jsou popsány v dokumentaci třídy ve zdrojovém kódu (langchain\_anthropic/chat\_models.py), na stránce integrace nejsou. Přepínač use\_responses\_api zapíná u ChatOpenAI režim Responses.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/langchain/)[Dokumentace aplikace ↗](https://docs.langchain.com/oss/python/integrations/chat/openai)

Cr

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

Framework pro agenty

OpenAI ChatAnthropic Messages

Týmy agentů s rolemi a úkoly.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/crewai/)

#### Kde nastavit

crewai.LLM(model=..., base\_url=..., api\_key=...); proměnné OPENAI\_API\_KEY a OPENAI\_BASE\_URL; pro Claude – nativní poskytovatel anthropic/ s base\_url

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/messages, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```python
import os
from crewai import LLM
# formát kompatibilní s 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)
```

Příklad modelu: `openai/gpt-6.1-sol, anthropic/claude-sonnet-5-5`

#### Důležité

Prefix openai/ nebo anthropic/ vybírá poskytovatele v CrewAI, do požadavku se odesílá id bez prefixu. Pro OpenAI je adresa s /v1, pro Anthropic bez /v1. Dokumentace také popisuje přepínač custom\_openai=True pro libovolnou bránu kompatibilní s OpenAI. U Anthropic je max\_tokens povinné.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/crewai/)[Dokumentace aplikace ↗](https://docs.crewai.com/en/concepts/llms)

GG

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

SDK

Gemini

Oficiální knihovna Google pro Gemini API.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/google-genai-python/)

#### Kde nastavit

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

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1beta/models/{model}:generateContent, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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="Ahoj")
print(r.text)
```

Příklad modelu: `gemini-3.6-flash, gemini-3.1-pro`

#### Důležité

Adresa bez /v1beta: SDK samo sestavuje /v1beta/models/{model}:generateContent. Klíč se odesílá v hlavičce x-goog-api-key – Ailoot jej přijímá. Dostupné jsou pouze modely s formátem Gemini. Pro verzi v JavaScriptu (@google/genai) není vlastní adresa v dokumentaci popsána, proto ji zde neuvádíme.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/google-genai-python/)[Dokumentace aplikace ↗](https://github.com/googleapis/python-genai#custom-base-url)

Li

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

SDK

OpenAI Chat

Jednotné rozhraní v Pythonu pro desítky poskytovatelů.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/litellm/)

#### Kde nastavit

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

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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": "Ahoj"}])
print(r.choices[0].message.content)
# embeddingy: litellm.embedding(model="openai/nemotron-3-embed", api_base="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], input=["text"])
```

Příklad modelu: `openai/claude-sonnet-5-5, openai/qwen3.8-max, openai/nemotron-3-embed`

#### Důležité

Prefix openai/ označuje protokol kompatibilní s OpenAI, do Ailoot se odesílá id bez prefixu. LiteLLM samo přidává /chat/completions a /embeddings; podle dokumentace má při chybě Not Found adresa končit na /v1.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/litellm/)[Dokumentace aplikace ↗](https://docs.litellm.ai/docs/providers/openai_compatible)

LP

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

Vlastní brána

OpenAI Chat

Vlastní brána s klíči, limity a logy nad Ailoot.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/litellm-proxy/)

#### Kde nastavit

config.yaml → model\_list → litellm\_params (model, api\_base, api\_key); spuštění litellm --config config.yaml

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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

# spuštění: litellm --config config.yaml
```

Klíč se načítá z proměnné `AILOOT_API_KEY` – nastavte ji před spuštěním:

```bash
export AILOOT_API_KEY="sk-..."   # přidejte do ~/.zshrc nebo ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poté restartujte terminál
```

Příklad modelu: `openai/claude-sonnet-5-5, openai/gpt-6.1-sol`

#### Důležité

Proxy se hodí, pokud potřebujete týmu rozdat vlastní interní klíče nad jedním klíčem Ailoot. Účtování v Ailoot probíhá na klíč uvedený v api\_key. Adresa je s /v1.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/litellm-proxy/)[Dokumentace aplikace ↗](https://docs.litellm.ai/docs/providers/openai_compatible)

Ll

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

Framework

OpenAI Chat

Framework pro vyhledávání ve vlastních datech a RAG.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/llamaindex/)

#### Kde nastavit

Balíček llama-index-llms-openai-like, třída OpenAILike(api\_base=..., api\_key=..., model=..., is\_chat\_model=True)

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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("Ahoj"))
```

Příklad modelu: `deepseek-v4-pro, claude-sonnet-5-5, gpt-6.1-sol`

#### Důležité

Adresa s /v1. Nastavení is\_chat\_model=True je povinné, jinak třída použije zastaralé /completions. is\_function\_calling\_model=True umožní agentům používat nástroje. context\_window nastavte podle karty modelu v katalogu Ailoot.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/llamaindex/)[Dokumentace aplikace ↗](https://developers.llamaindex.ai/python/framework-api-reference/llms/openai_like/)

Ma

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

Framework pro agenty

OpenAI ChatOpenAI Responses

Framework v TypeScriptu pro agenty a pracovní postupy.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/mastra/)

#### Kde nastavit

V Agent: model: { id: "\<poskytovatel\>/\<model\>", url: "\<základní adresa\>", apiKey, api?: "chat" | "responses" }

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```js
import { Agent } from "@mastra/core/agent";
const agent = new Agent({
  id: "ailoot-agent",
  name: "Ailoot Agent",
  instructions: "Odpovídej rusky",
  model: {
    id: "ailoot/claude-sonnet-5-5",
    url: "https://api.ailoot.ai/v1",
    apiKey: process.env.AILOOT_API_KEY
    // api: "responses"  // pouze pro modely s metodou responses
  }
});
```

Klíč se načítá z proměnné `AILOOT_API_KEY` – nastavte ji před spuštěním:

```bash
export AILOOT_API_KEY="sk-..."   # přidejte do ~/.zshrc nebo ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poté restartujte terminál
```

Příklad modelu: `ailoot/claude-sonnet-5-5, ailoot/gpt-6.1-sol`

#### Důležité

V url se uvádí základní adresa s /v1, nikoli úplná cesta k /chat/completions. Ve výchozím nastavení se používá Chat Completions, api: "responses" přepíná na Responses API. Tvar id "poskytovatel/model" odesílá do brány samotné id modelu. Pole apiKey v objektu model je v dokumentaci ukázáno na příkladu s hlavičkami; společně s url není samostatně popsáno.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/mastra/)[Dokumentace aplikace ↗](https://mastra.ai/models)

OA

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

Framework pro agenty

OpenAI ChatOpenAI Responses

Knihovna OpenAI pro scénáře s více agenty.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/openai-agents-sdk/)

#### Kde nastavit

AsyncOpenAI(base\_url=..., api\_key=...) + OpenAIChatCompletionsModel(model=..., openai\_client=client), nebo globálně set\_default\_openai\_client(client)

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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="Pomocník", instructions="Odpovídej rusky", model=model)
print(Runner.run_sync(agent, "Ahoj").final_output)
```

Příklad modelu: `claude-sonnet-5-5, gpt-6.1-sol`

#### Důležité

Adresa s /v1. Vypněte trasování pomocí set\_tracing\_disabled(True): jinak se SDK pokusí odesílat trasovací záznamy do OpenAI s chybějícím klíčem OpenAI. Chat Completions je dostupné pouze pro modely, u kterých je tato metoda uvedena v katalogu a dostupná pro váš klíč; Responses (výchozí v SDK) pouze pro modely s metodou responses v katalogu. Vestavěné nástroje OpenAI (webové vyhledávání, soubory) nejsou přes bránu třetí strany zaručeny.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/openai-agents-sdk/)[Dokumentace aplikace ↗](https://openai.github.io/openai-agents-python/models/)

PA

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

Framework pro agenty

OpenAI ChatOpenAI Responses

Typovaný framework pro agenty v Pythonu.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/pydantic-ai/)

#### Kde nastavit

OpenAIProvider(base\_url=..., api\_key=...) s modelem OpenAIChatModel (Chat Completions) nebo OpenAIResponsesModel (Responses); nebo proměnná OPENAI\_BASE\_URL

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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("Ahoj").output)
```

Příklad modelu: `deepseek-v4-pro, gpt-6.1-sol (pro OpenAIResponsesModel)`

#### Důležité

Adresa s /v1. Dokumentace ve výchozím nastavení používá OpenAIResponsesModel: použijte jej pouze pro modely s metodou responses; pro ostatní použijte OpenAIChatModel.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/pydantic-ai/)[Dokumentace aplikace ↗](https://pydantic.dev/docs/ai/models/openai/)

## Automatizace

Scénáře bez programování, nástroje pro tvorbu řetězců, boti a chytrá domácnost.

N8

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

No-code automatizace

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Automatizace scénářů s uzly AI agentů.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/n8n/)

#### Kde nastavit

Credentials → OpenAI → pole Base URL (výchozí https://api.openai.com/v1); Credentials → Anthropic → Base URL (výchozí https://api.anthropic.com); Credentials → Google Gemini(PaLM) Api → Host (výchozí https://generativelanguage.googleapis.com). Poté uzly OpenAI Chat Model / Anthropic Chat Model / Google Gemini Chat Model

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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-...
Uzel OpenAI Chat Model → Model: By ID → gpt-6.1-sol (přepínač Use Responses API pouze pro modely s metodou responses)
```

Příklad modelu: `gpt-6.1-sol / deepseek-v4-pro (OpenAI), claude-sonnet-5-5 (Anthropic), gemini-3.6-flash (Gemini)`

#### Důležité

Ověření přihlašovacích údajů volá /models (OpenAI), /v1/models (Anthropic) a /v1beta/models (Gemini); všechny tři cesty v Ailoot existují. Na stránkách dokumentace n8n není pole Base URL popsáno: je přímo v definicích přihlašovacích údajů (zdrojové soubory OpenAiApi.credentials.ts a AnthropicApi.credentials.ts, popisek „Override the default base URL for the API“). Na n8n Cloud nevybírejte „Use Gateway credits“, jinak požadavky nebudou procházet přes Ailoot.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/n8n/)[Dokumentace aplikace ↗](https://github.com/n8n-io/n8n/blob/master/packages/nodes-base/credentials/OpenAiApi.credentials.ts)

Di

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

Platforma aplikací s LLM

OpenAI Chat

Platforma AI aplikací: chatboti, agenti, znalostní báze.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/dify/)

#### Kde nastavit

Integrations → Model Provider → nainstalovat plugin OpenAI-API-compatible → Add Model (pole: Model Type, Model Name, API Key, API Base URL, Completion mode, Model context size)

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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: podle karty modelu v katalogu Ailoot

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

Příklad modelu: `claude-sonnet-5-5, gpt-6.1-sol, qwen3.8-max; nemotron-3-embed (embeddingy)`

#### Důležité

Spravovat poskytovatele mohou pouze vlastník a správci pracovního prostoru. Podle README pluginu: pro LLM je adresa s /v1, pro embeddingy, rerank, STT a TTS přidává verzi API plugin sám, proto je adresa bez /v1 (jinak vznikne /v1/v1). Každý model Ailoot přidávejte jako samostatnou položku; podporu obrázků na vstupu a streamovaného výstupu zapínejte v nastavení modelu.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/dify/)[Dokumentace aplikace ↗](https://github.com/langgenius/dify-official-plugins/tree/main/models/openai_api_compatible)

Fl

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

Nástroj pro tvorbu řetězců

OpenAI Chat

Vizuální nástroj pro tvorbu řetězců a agentů.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/flowise/)

#### Kde nastavit

Uzel ChatOpenAI nebo ChatOpenAI Custom → Connect Credential (klíč) → Additional Parameters → Base Path (a Base Options pro hlavičky)

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

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

Příklad modelu: `deepseek-v4-pro, claude-sonnet-5-5, gpt-6.1-sol`

#### Důležité

V ChatOpenAI je seznam modelů pevně daný, proto pro libovolná id Ailoot použijte ChatOpenAI Custom, kde se název modelu zadává ručně. Base Path je s /v1. Pro embeddingy existuje uzel OpenAI Embeddings Custom.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/flowise/)[Dokumentace aplikace ↗](https://docs.flowiseai.com/integrations/langchain/chat-models/azure-chatopenai)

HA

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

Chytrá domácnost

OpenAI Chat

Hlasový asistent chytré domácnosti přes Extended OpenAI Conversation.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/home-assistant/)

#### Kde nastavit

Nainstalovat přes HACS (Custom repository) nebo zkopírovat custom\_components/extended\_openai\_conversation → restart → Settings → Devices & Services → Add Integration → Extended OpenAI Conversation (API Key, Base Url) → Settings → Voice Assistants → Conversation agent

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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
```

Příklad modelu: `gpt-6.1-sol, claude-sonnet-5-5`

#### Důležité

Jde o komponentu třetí strany, nikoli o oficiální integraci. Ovládání zařízení probíhá prostřednictvím volání funkcí (tools) v Chat Completions, proto vybírejte modely s podporou nástrojů. Oficiální integrace OpenAI Conversation vlastní adresu nepodporuje.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/home-assistant/)[Dokumentace aplikace ↗](https://github.com/jekalmin/extended_openai_conversation)

La

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

Nástroj pro tvorbu řetězců

OpenAI Chat

Vizuální nástroj pro tvorbu agentů a RAG.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/langflow/)

#### Kde nastavit

Profil → Settings → Model Providers → OpenAI Compatible (pole Base URL a API Key; proměnné OPENAI\_COMPATIBLE\_BASE\_URL a OPENAI\_COMPATIBLE\_API\_KEY). Alternativa: komponenta OpenAI → pole OpenAI API Base

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```text
Settings → Model Providers → OpenAI Compatible:
  Base URL: https://api.ailoot.ai/v1
  API Key: sk-...
nebo pomocí prostředí:
```

```bash
export OPENAI_COMPATIBLE_BASE_URL="https://api.ailoot.ai/v1"
export OPENAI_COMPATIBLE_API_KEY="sk-..."
Poté v komponentách Language Model / Agent vyberte OpenAI Compatible → claude-sonnet-5-5
```

Příklad modelu: `claude-sonnet-5-5, gpt-6.1-sol, nemotron-3-embed (Embedding Model)`

#### Důležité

Langflow ověřuje připojení a načítá seznam modelů z /v1/models, modely se zobrazují v sekcích Language Models a Embedding Models. Potřebné modely je následně nutné ručně zapnout. Poskytovatel se instaluje spolu s langflow.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/langflow/)[Dokumentace aplikace ↗](https://docs.langflow.org/bundles-openai-compatible)

Ma

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

No-code automatizace

HTTP požadavek

No-code automatizace: požadavek do Ailoot přes modul HTTP.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/make/)

#### Kde nastavit

Vestavěný modul OpenAI funguje pouze s účtem OpenAI. Použijte HTTP → Make a request: URL, Method, Headers, Body type Raw / JSON

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```text
Modul: 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 → odpověď v choices[].message.content
```

Příklad modelu: `gpt-6.1-sol, claude-sonnet-5-5`

#### Důležité

Jde o univerzální modul HTTP, nikoli o samostatného poskytovatele pro Ailoot: dokumentace popisuje libovolnou adresu HTTPS. Klíč je lepší uložit v připojení s API klíčem (Make to doporučuje místo předávání v hlavičkách). Streamovaný výstup není v Make potřeba, odesílejte bez stream.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/make/)[Dokumentace aplikace ↗](https://apps.make.com/http)

T

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

Boti

OpenAI Chat

Vlastní bot v Telegramu s OpenAI SDK.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/telegram-bot/)

#### Kde nastavit

Telegramové frameworky nemají vlastní vrstvu LLM: v obsluze zpráv se volá OpenAI SDK s base\_url Ailoot (nebo Anthropic SDK s base\_url bez /v1)

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

Uložte kód Python jako ailoot-telegram-bot.py. Nainstalujte závislosti, nastavte obě proměnné prostředí a spusťte soubor. Pošlete botovi Hello a ověřte textovou odpověď. Při chybě uložte Request ID a před dalším generováním ověřte původní výsledek.

```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
```

Příklad modelu: `claude-sonnet-5-5, deepseek-v4-pro, qwen3.8-flash`

#### Důležité

Telegramové frameworky nemají vlastní vrstvu pro neuronové sítě: adresa Ailoot se nastavuje v OpenAI SDK uvnitř bota. Při nulovém zůstatku Ailoot vrátí srozumitelnou chybu 402 s Request ID – zobrazte ji uživateli bota místo toho, aby bot spadl.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/telegram-bot/)[Dokumentace aplikace ↗](https://github.com/openai/openai-python)

Za

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

No-code automatizace

HTTP požadavek

Automatizace: požadavek do Ailoot přes Webhooks by Zapier.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/zapier/)

#### Kde nastavit

Aplikace ChatGPT (OpenAI) v Zapier funguje pouze s OpenAI. Použijte Webhooks by Zapier → Custom Request (Method, URL, Data, Headers)

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```text
Akce: 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":"Ahoj"}]}
Headers:
  Authorization | Bearer sk-...
  Content-Type | application/json
```

Příklad modelu: `claude-sonnet-5-5, gpt-6.1-sol`

#### Důležité

Jde o univerzální HTTP požadavek; Zapier nemá připraveného poskytovatele s polem pro základní adresu. Custom Request odešle pole Data beze změny a bez parsování, proto JSON ověřte předem. Webhooks by Zapier je dostupný v placených tarifech Zapier.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/zapier/)[Dokumentace aplikace ↗](https://help.zapier.com/hc/en-us/articles/8496326446989-Send-webhooks-in-Zap-workflows)

## Probíhá ověřování

Nastavení s nepotvrzenými podrobnostmi – porovnejte je s oknem aplikace.

AC

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

Agent v terminálu

Probíhá ověřování

Gemini

Konzolový agent Google Antigravity ve formátu Gemini.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/antigravity-cli/)

#### Kde nastavit

~/.gemini/antigravity-cli/settings.json → "modelProvider": "gemini"; proměnné GEMINI\_API\_KEY a GOOGLE\_GEMINI\_BASE\_URL

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1beta/models/{model}:generateContent, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

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

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

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

Příklad modelu: `gemini-3.8-flash`

#### Důležité

Protokol je nativní Gemini REST (streamGenerateContent, klíč v X-Goog-Api-Key), cesta https://api.ailoot.ai/v1beta/... Na jednu otázku odesílá agy dva požadavky: nadpis konverzace a samotnou odpověď. Agent pro každý krok rezervuje výrazně více než běžný chat, proto udržujte dostatečný zůstatek. Karta je v sekci „Probíhá ověřování“: nastavení bylo sestaveno podle dokumentace, skutečný test klienta přes Ailoot ještě neproběhl. Pokud modelProvider = gemini a GEMINI\_API\_KEY je prázdný, CLI se nespustí.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/antigravity-cli/)[Dokumentace aplikace ↗](https://antigravity.google/docs/cli/install/)

CC

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

Agent v terminálu

Probíhá ověřování

OpenAI Chat

Konzolová verze agenta Cline.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/cline-cli/)

#### Kde nastavit

cline auth → vlastní poskytovatelé API → OpenAI Compatible: Base URL, API Key, Model ID; přepínač -P/--provider vybírá poskytovatele

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi 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 "Spusť testy a oprav chyby"
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Pole Base URL / API Key / Model ID jsou popsána v dokumentaci Cline pro OpenAI Compatible. Přesné popisky položek průvodce cline auth nejsou v dokumentaci CLI uvedeny – řiďte se obrazovkou.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/cline-cli/)[Dokumentace aplikace ↗](https://docs.cline.bot/provider-config/openai-compatible)

CJ

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

Rozšíření editoru

Probíhá ověřování

OpenAI Chat

Vlastní adresa modelu v Copilotu pro IDE JetBrains.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/copilot-jetbrains-byok/)

#### Kde nastavit

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

#### Konfigurace

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

#### Důležité

GitHub potvrzuje podporu vlastních endpointů. Oficiální snímek ukazuje Provider Name, API Key a API Type: Chat Completions, ale neuvádí příklad URL. Proto zde není připravená konfigurace Ailoot ke kopírování. Zdokumentovanou alternativou v tomto IDE je JetBrains AI Assistant. Požadavky na URL si ověřte u oficiální podpory pluginu.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/copilot-jetbrains-byok/)[Dokumentace aplikace ↗](https://github.blog/changelog/2026-07-14-github-copilot-for-jetbrains-expands-byok-capabilities/)

Cu

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

Editor kódu

Probíhá ověřování

OpenAI Chat

Editor Cursor: vlastní adresa OpenAI pro chat.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/cursor/)

#### Kde nastavit

Cursor Settings → Models → API Keys → OpenAI API Key + přepínač „Override OpenAI Base URL“; poté přidejte ID modelu do vlastních modelů.

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```text
OpenAI API Key:            sk-...
Override OpenAI Base URL:  https://api.ailoot.ai/v1
Vlastní model:               gpt-6.1-sol  (přidat, zapnout, vybrat v chatu)
```

Příklad modelu: `gpt-6.1-sol`

#### Důležité

V aktuální oficiální dokumentaci Cursor není vlastní adresa popsána: uvádí pouze klíče OpenAI/Anthropic/Google/Azure/Bedrock, říká, že vlastní klíče fungují jen v chatu (Tab zůstává na modelech Cursor) a že všechny požadavky procházejí servery Cursor (adresa musí být veřejná – api.ailoot.ai je veřejná). Přepínač adresy je v rozhraní dostupný, na fóru Cursor ale uživatelé hlásí chyby: vztahuje se na všechny modely, režim Agent nemusí používat vlastní klíč a v některých sestaveních 3.15.x pole nepřijímá vstup.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/cursor/)[Dokumentace aplikace ↗](https://cursor.com/help/models-and-usage/api-keys)

OT

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

Plugin pro Obsidian

Probíhá ověřování

OpenAI Chat

Generování textu v poznámkách Obsidian podle šablon.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/obsidian-text-generator/)

#### Kde nastavit

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

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

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

Příklad modelu: `gpt-6.1-sol`

#### Důležité

Dokumentace pluginu zmiňuje poskytovatele Custom, nepopisuje ale pole adresy ani její formát; nastavení vychází z rozhraní pluginu – porovnejte jej s oknem nastavení.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/obsidian-text-generator/)[Dokumentace aplikace ↗](https://docs.text-gen.com/)

Pe

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

Editor kódu

Probíhá ověřování

OpenAI Chat

Editor PearAI založený na VS Code.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/pearai/)

#### Kde nastavit

Cmd/Ctrl+Shift+P → Open config.json → položka v models\[\] (PearAI je fork Continue).

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```json
{
  "models": [
    {
      "title": "Ailoot Claude Sonnet 5.5",
      "provider": "openai",
      "model": "claude-sonnet-5-5",
      "apiBase": "https://api.ailoot.ai/v1",
      "apiKey": "sk-..."
    }
  ]
}
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Oficiální dokumentaci PearAI se nepodařilo ověřit (web dokumentace je nedostupný), repozitář nebyl dlouho aktualizován. Tvar konfigurace vychází ze vzoru Continue – ověřte jej v aplikaci.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/pearai/)[Dokumentace aplikace ↗](https://github.com/trypear/pearai-app/issues/122)

VS

### [Visual Studio 2026](https://ailoot.ai/docs/cs/integrations/visual-studio-2026/)

Editor kódu

Probíhá ověřování

OpenAI Chat

Vlastní poskytovatel v Copilot Chat pro Visual Studio.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/visual-studio-2026/)

#### Kde nastavit

Chat → výběr modelu → Manage models → Add custom model → poskytovatel OpenAI (custom endpoint) → adresa, klíč, model.

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```text
Provider: OpenAI (custom endpoint)
Endpoint: https://api.ailoot.ai/v1
API key:  sk-...
Model:    gpt-6.1-sol
```

Příklad modelu: `gpt-6.1-sol`

#### Důležité

Blog Visual Studio (29.09.2026) oznámil vlastní adresy pro OpenAI a Ollama ve VS 2026 Stable, ale stránka dokumentace zatím popisuje pouze klíče OpenAI/Anthropic/Google bez pole pro adresu, takže názvy polí a podoba adresy dosud nejsou potvrzené. Pouze chat; není dostupné v plánech Copilot Business/Enterprise.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/visual-studio-2026/)[Dokumentace aplikace ↗](https://devblogs.microsoft.com/visualstudio/visual-studio-september-update-power-your-workflow-with-your-model/)

Vo

### [Void](https://ailoot.ai/docs/cs/integrations/void/)

Editor kódu

Probíhá ověřování

OpenAI Chat

Otevřený editor založený na VS Code, jeho vývoj byl zastaven.

[Podrobnosti →](https://ailoot.ai/docs/cs/integrations/void/)

#### Kde nastavit

Void Settings → Providers → OpenAI-Compatible → baseURL, API key, model.

#### Konfigurace

Před spuštěním zavolejte GET /v1/models se svým klíčem Ailoot. Vyberte přesné ID modelu, jehož metody zahrnují POST /v1/chat/completions, a použijte je v konfiguraci. U agentů ověřte také podporu nástrojů a funkce potřebné pro vaši verzi klienta.

```text
Provider: OpenAI-Compatible
baseURL:  https://api.ailoot.ai/v1   (bez /chat/completions)
API key:  sk-...
Model:    claude-sonnet-5-5
```

Příklad modelu: `claude-sonnet-5-5`

#### Důležité

Nastavení vychází ze zdrojového kódu Void, nikoli z uživatelské dokumentace. Repozitář Void je archivovaný a editor se již nevyvíjí – hodí se jen pro ty, kteří jej už používají.

[Úplný návod →](https://ailoot.ai/docs/cs/integrations/void/)[Dokumentace aplikace ↗](https://github.com/voideditor/void/blob/main/src/vs/workbench/contrib/void/common/voidSettingsTypes.ts)

Nic se nenašlo. Pokud aplikace umožňuje vlastní adresu OpenAI nebo Anthropic API, pravděpodobně bude fungovat – [zde je návod, co zadat](https://ailoot.ai/docs/cs/keys/).

## Zatím se nehodí

V těchto aplikacích nelze nastavit vlastní adresu API. Vedle najdete jejich alternativy.

| Aplikace | Proč se nehodí | Čím nahradit |
| --- | --- | --- |
| **Cursor CLI (cursor-agent)** | Funguje pouze s modely Cursor, vlastní adresu API nelze nastavit. | Claude Code, Codex CLI nebo opencode |
| **Auggie CLI (Augment Code)** | Přihlášení přes účet Augment, poskytovatele třetí strany nelze zadat. | Claude Code nebo opencode |
| **Windsurf / Devin Desktop** | Přijímá pouze klíč Anthropic pro vybrané modely Claude, vlastní adresu nelze nastavit. | Cline, Roo Code nebo Kilo Code ve VS Code |
| **Kiro** | Nepodporuje vlastní klíč ani adresu API. | Cline nebo Roo Code |
| **Google Antigravity (IDE)** | Oficiální nastavení vlastního poskytovatele neexistuje; úpravy třetích stran nedoporučujeme. | Antigravity CLI nebo Gemini CLI |
| **Visual Studio s Copilot Business nebo Enterprise** | V těchto tarifech Copilot nejsou vlastní modely dostupné. | Osobní tarif Copilot – karta Visual Studio 2026 |
| **Automatické doplňování Cursor Tab** | Vždy používá modely Cursor, i s vlastním klíčem. | Chat Cursor se nastavuje samostatně – karta Cursor |
| **Enchanted** | Funguje pouze s API Ollama. | Open WebUI nebo Chatbox |
| **Smart Connections (Obsidian)** | Externí API jsou dostupná pouze v placeném Smart Chat Pro. | Obsidian Copilot |
| **Witsy, 5ire** | Nenašli jsme oficiální popis vlastní adresy API. | Cherry Studio nebo Jan |
| **Make: vestavěný modul OpenAI** | Připojuje se pouze k účtu OpenAI. | Modul HTTP → Make a request – karta Make |
| **Zapier: aplikace ChatGPT (OpenAI)** | Chybí pole pro vlastní adresu. | Webhooks by Zapier → Custom Request – karta Zapier |
| **Home Assistant: OpenAI Conversation** | Vestavěná integrace funguje pouze s adresou OpenAI. | Extended OpenAI Conversation z HACS – karta Home Assistant |
| **aiogram, python-telegram-bot, grammY, Telegraf** | Frameworky pro boty se samy k modelům nepřipojují. | OpenAI nebo Anthropic SDK uvnitř bota – karta Bot pro Telegram |

## Připojení API k nástrojům

### Kam v klientovi zadám adresu API a klíč?

Nástroje – agenti, editory, chaty a SDK – které přijímají klíč Ailoot. Tlačítko „Nastavit“ ukáže, kam vložit adresu a klíč, a připravenou konfiguraci, kterou můžete zkopírovat.

Připojte Ailoot k Claude Code, OpenCode, Hermes nebo vlastní aplikaci.

## Společnost a její portfolio projektů

Společnost a její portfolio projektů: miliony zákazníků; měsíční tržby v miliardách.

## Nakupujte tokeny se slevou.

Sleva předplatného pro pravidelnou práci. Promo kódy až 50% na nákup tokenů.

Předplatné

Pro pravidelné požadavky vyberte tarif se slevou.

Promo kód až 50%

Při nákupu zadejte kód. Cena se přepočítá podle probíhající akce.

Výdaje v historii

U každého požadavku se uloží model, tokeny a částka.

[Vybrat předplatné](https://ailoot.ai/docs/cs/billing/subscriptions/) · [Zobrazit ceny modelů](https://ailoot.ai/models/cs/)

## Připojte API k produktu, který prodáváte.

SaaS, aplikace a boti podle nabídky a licenční smlouvy Ailoot. Pro přeprodej požádejte o licenci přeprodejce.

Komerční aplikace

Začleňte generování textu, obrázků, videa a zvuku do placených funkcí své služby.

Licence pro přeprodejce

Pošlete popis projektu a způsob poskytování přístupu. Vyžádejte písemné podmínky použití a přeprodeje.

Dokumenty na webu

Nabídka, licenční smlouva a zásady zpracování dat jsou dostupné před připojením.

[Požádat o licenci přeprodejce](mailto:support@ailoot.ai) · [Nabídka a licenční smlouva](https://ailoot.ai/legal/offer?lang=cs)

## Otázky

Který formát zvolit pro klienta?

Zvolte formát OpenAI, Anthropic nebo Gemini, který váš klient podporuje. Na kartě modelu Ailoot ověřte kompatibilní metodu API a ID modelu; podpora jednoho formátu neznamená, že každý model podporuje všechny formáty.

Co je potřeba nastavit v klientovi?

Nastavte klíč API Ailoot, adresu API a ID modelu kompatibilního s metodou klienta. OpenAI SDK používá https://api.ailoot.ai/v1; Anthropic a Gemini SDK používají https://api.ailoot.ai. Zachovejte pole požadavku z příkladu pro daný formát.

Jak odeslat první požadavek API?

Vytvořte si klíč API Ailoot. Pro OpenAI SDK nastavte https://api.ailoot.ai/v1, pro Anthropic a Gemini SDK pak https://api.ailoot.ai. GET /v1/models je zdarma a vypíše modely dostupné vašemu klíči; poté použijte příklad pro vybraný model a metodu API.

Co zkontrolovat, když připojený klient selže?

Ověřte, že klient odesílá očekávaný formát OpenAI, Anthropic nebo Gemini na odpovídající adresu API s vaším klíčem API Ailoot. Zkontrolujte ID modelu a metodu a poté porovnejte vrácenou chybu s příručkou klienta. Chybu a ID požadavku pošlete na support@ailoot.ai bez sdílení klíče.

Mohu Ailoot použít v placeném produktu?

Ano. Připojte API k SaaS, aplikaci nebo botu podle nabídky a licenční smlouvy Ailoot. Pro přeprodej požádejte o písemné podmínky a licenci přeprodejce pro svůj projekt.

Jak požádat o licenci pro další prodej?

Napište na support@ailoot.ai, co váš produkt dělá, kdo ho používá a jak k němu poskytujete přístup. Požádejte o licenci pro další prodej a písemné podmínky pro svůj projekt.

## Ailoot · Společnost a její portfolio projektů





Ailoot staví na dlouhodobých provozních zkušenostech, široké klientské základně, stabilních službách a průběžném sledování KPI.





Společnost a její portfolio projektů: miliony zákazníků; měsíční tržby v miliardách.





Ailoot využívá tyto provozní zkušenosti k poskytování přístupu přes API k funkcím AI v produktech zákazníků, agentech, aplikacích a automatizacích.