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

[Integracijos](https://ailoot.ai/docs/lt/integrations/) 

# Prijunkite Ailoot prie mėgstamų įrankių — API prijungimas prie programavimo įrankių

Agentai, redaktoriai, pokalbių programos ir SDK, priimantys Ailoot raktą. Mygtukas „Nustatyti“ parodys, kur įrašyti adresą ir raktą, bei paruoštą konfigūraciją, kurią galima nukopijuoti.

**85**programos

**77**paruoštos

**8**tikrinamos

 Programos paieška 

## Agentai terminale

Programavimo agentai ir CLI: rašo kodą, vykdo komandas, taiso failus.

CC

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

Agentas terminale

Anthropic Messages

Anthropic agentas terminale: rašo kodą, taiso failus ir vykdo komandas.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/claude-code/)

#### Kur nustatyti

Aplinkos kintamieji arba "env" blokas ~/.claude/settings.json (vienam projektui — .claude/settings.local.json); VS Code plėtinys — claudeCode.environmentVariables; patikra — komanda /status

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

`~/.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
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Adresas be /v1: Claude Code pats prideda /v1/messages. ANTHROPIC\_AUTH\_TOKEN siunčiamas kaip Authorization: Bearer, ANTHROPIC\_API\_KEY — kaip x-api-key; Ailoot priima abu. CLAUDE\_CODE\_ENABLE\_GATEWAY\_MODEL\_DISCOVERY=1 įkelia mūsų modelius į /model per /v1/models. Gavus 400 klaidas dėl nežinomų laukų — CLAUDE\_CODE\_DISABLE\_EXPERIMENTAL\_BETAS=1. Anthropic dokumentacija nepalaiko Claude Code naudojimo su ne Claude modeliais per šliuzą, nors mūsų /v1/messages juos aptarnauja; rekomenduojame Claude modelius. Remote Control ir balso įvestis per šliuzą neprieinami.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/claude-code/)[Programos dokumentacija ↗](https://code.claude.com/docs/en/llm-gateway-connect)

OC

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

Agentas terminale

OpenAI Responses

OpenAI agentas terminalui, veikiantis Responses formatu.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/openai-codex-cli/)

#### Kur nustatyti

~/.codex/config.toml (tik vartotojo failas: projekto .codex/config.toml model\_provider/model\_providers raktai ignoruojami); raktas — env\_key nurodytame kintamajame

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/responses, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

`~/.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
```

Modelio pavyzdys: `gpt-6.1-sol`

#### Svarbu

Codex veikia tik per OpenAI Responses API (dokumentacijoje nurodytas tik wire\_api = "responses"), todėl reikia mūsų /v1/responses. Tiekėjų ID openai, ollama, lmstudio rezervuoti. Alternatyva — openai\_base\_url = "https://api.ailoot.ai/v1" integruotam openai tiekėjui. Ailoot pateikia Codex modelių sąrašą Codex manifesto formatu (GET /v1/models su client\_version). Rinkitės konkretų modelį, kurio katalogo kortelėje yra OpenAI Responses formatas. 2026-09-30 momentinėje kopijoje gemini-3.6-flash turi OpenAI Chat, Anthropic Messages ir Gemini, tačiau neturi Responses, todėl šis modelis Codex netinka. Formatų rinkinį tikrinkite pagal modelio kortelę, o ne šeimos pavadinimą.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/openai-codex-cli/)[Programos dokumentacija ↗](https://learn.chatgpt.com/docs/config-file/config-advanced)

HA

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

Agentas terminale

OpenAI ChatOpenAI ResponsesAnthropic Messages

Nous Research agentas terminalui su atmintimi ir įgūdžiais.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/hermes-agent/)

#### Kur nustatyti

hermes model → „Custom endpoint (self-hosted / VLLM / etc.)“ arba ~/.hermes/config.yaml (model skyrius arba providers žodynas)

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

`~/.hermes/config.yaml`

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

# keli formatai vienu metu — vardiniai tiekėjai:
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

# sesijoje: /model custom:claude-sonnet-5-5
```

Raktas skaitomas iš kintamojo `AILOOT_API_KEY` — nustatykite jį prieš paleisdami:

```bash
export AILOOT_API_KEY="sk-..."   # pridėkite į ~/.zshrc arba ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # tada paleiskite terminalą iš naujo
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

transport: chat\_completions (OpenAI Chat), anthropic\_messages (Anthropic Messages) arba codex\_responses (OpenAI Responses). LLM\_MODEL faile .env nebenaudojamas; OPENAI\_BASE\_URL taikomas tik openai-api tiekėjui. anthropic\_messages atveju adresą nurodykite be /v1 — Anthropic SDK pats pridės /v1/messages. Pagalbinės užduotys (vaizdų atpažinimas, istorijos glaudinimas) pagal numatytuosius nustatymus siunčiamos tam pačiam pagrindiniam modeliui.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/hermes-agent/)[Programos dokumentacija ↗](https://hermes-agent.nousresearch.com/docs/integrations/providers)

Op

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

Agentas terminale

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Asmeninis DI asistentas savo kompiuteryje: pokalbiai, susirašinėjimo programos, užduotys.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/openclaw/)

#### Kur nustatyti

OpenClaw konfigūracija (~/.openclaw/openclaw.json) → models.providers.\<id\>; numatytasis modelis — agents.defaults.model.primary; saugus keitimas — openclaw config set models.providers.\<id\> '\<json\>' --strict-json --merge

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Raktas skaitomas iš kintamojo `AILOOT_API_KEY` — nustatykite jį prieš paleisdami:

```bash
export AILOOT_API_KEY="sk-..."   # pridėkite į ~/.zshrc arba ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # tada paleiskite terminalą iš naujo
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

api adapteriai: openai-completions (numatytasis, kai nustatytas baseUrl), openai-responses (tik jei serveris palaiko /v1/responses — Ailoot palaiko), anthropic-messages, google-generative-ai ir kiti. anthropic-messages OpenClaw pavyzdžiuose baseUrl nurodytas be /v1. OpenClaw gali perduoti vaizdus, kai modelio input apima "image". Claude pavyzdžiuose paliktas tik tekstas: 2026-09-30 katalogo momentinėje kopijoje šie metodai nedeklaruoja image įvesties. Pridėkite "image" tik konkrečiam modeliui, kurio dabartinė katalogo kortelė deklaruoja vaizdo įvestį ir pasirinktą API formatą. Pavyzdžiui, šioje kopijoje gemini-3.6-flash deklaruoja image įvestį OpenAI Chat formatu; faktinis palaikymas priklauso nuo modelio kortelės ir formato. Pagrindinio konfigūracijos failo kelias paimtas iš įprastos OpenClaw praktikos, perskaitytame puslapyje taip pat minimas ~/.openclaw/agents/\<agentId\>/agent/models.json.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/openclaw/)[Programos dokumentacija ↗](https://docs.openclaw.ai/gateway/config-tools/custom-providers)

Op

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

Agentas terminale

OpenAI Chat

Atvirojo kodo agentas terminale su bet kuriuo su OpenAI suderinamu tiekėju.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/opencode/)

#### Kur nustatyti

opencode.json (projekte arba ~/.config/opencode/opencode.json) → provider.\<id\>; raktas — per /connect arba "apiKey": "{env:VAR}"

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Raktas skaitomas iš kintamojo `AILOOT_API_KEY` — nustatykite jį prieš paleisdami:

```bash
export AILOOT_API_KEY="sk-..."   # pridėkite į ~/.zshrc arba ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # tada paleiskite terminalą iš naujo
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Paketas @ai-sdk/openai-compatible kreipiasi į /v1/chat/completions. Modeliams, kuriems reikia /v1/responses, opencode dokumentacija nurodo @ai-sdk/openai paketą. Su Anthropic suderinamas tiekėjas su savu baseURL opencode dokumentacijoje neaprašytas. Rinkitės modelius, kuriems dabartinis katalogas deklaruoja OpenAI Chat formatą. 2026-09-30 momentinėje kopijoje gemini-3.6-flash turi šį formatą; kitus Gemini modelius tikrinkite pagal jų korteles. Šis kelias nenaudoja savojo Gemini formato. Metodo buvimas kataloge nereiškia tikro konkrečios kliento versijos bandymo.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/opencode/)[Programos dokumentacija ↗](https://opencode.ai/docs/providers/)

QC

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

Agentas terminale

OpenAI ChatAnthropic MessagesGemini

Qwen komandos konsolės agentas: OpenAI, Anthropic ir Gemini formatai.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/qwen-code/)

#### Kur nustatyti

Kintamieji OPENAI\_API\_KEY / OPENAI\_BASE\_URL / OPENAI\_MODEL, komanda /auth seanse arba ~/.qwen/settings.json (modelProviders + security.auth.selectedType)

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```bash
export AILOOT_API_KEY="sk-..."
# greitas būdas
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"
  }
}
```

Raktas skaitomas iš kintamojo `AILOOT_API_KEY` — nustatykite jį prieš paleisdami:

```bash
export AILOOT_API_KEY="sk-..."   # pridėkite į ~/.zshrc arba ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # tada paleiskite terminalą iš naujo
```

Modelio pavyzdys: `qwen3.8-max`

#### Svarbu

Protokolų tipai: openai (Chat Completions), anthropic, gemini, vertex-ai. openai atveju baseUrl su /v1. Dokumentacijos anthropic ir gemini pavyzdyje baseUrl nėra, todėl rekomenduojame openai variantą. openai tipui kataloge rinkitės OpenAI Chat formato modelį: gemini-3.6-flash jį turi. Kitų Gemini modelių formatų rinkinys gali skirtis — patikrinkite konkretaus modelio kortelę. settings.json variantas skaito raktą iš AILOOT\_API\_KEY kintamojo (laukas envKey): nustatykite jį komanda export AILOOT\_API\_KEY=sk-... arba eilute AILOOT\_API\_KEY=sk-... faile ~/.qwen/.env, kitaip Qwen Code pradės su tuščiu raktu ir gaus 401.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/qwen-code/)[Programos dokumentacija ↗](https://qwenlm.github.io/qwen-code-docs/en/users/configuration/auth/)

GC

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

Agentas terminale

Gemini

Google agentas terminale, naudojantis savąjį Gemini formatą.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/gemini-cli/)

#### Kur nustatyti

Aplinkos kintamieji GEMINI\_API\_KEY ir GOOGLE\_GEMINI\_BASE\_URL; prisijungimo būdas — ~/.gemini/settings.json → security.auth.selectedType = "gemini-api-key"; modelis — GEMINI\_MODEL arba parametras -m

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1beta/models/{model}:generateContent, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `gemini-3.8-flash`

#### Svarbu

Adresas be /v1beta: SDK pats prideda /v1beta/models/{model}:generateContent. Adresas privalo būti HTTPS. Raktas siunčiamas x-goog-api-key antraštėje — Ailoot jį priima. Tinka tik modeliai, kurių kataloge nurodytas Gemini formatas. Prieš paleisdami patikrinkite, ar tikslus ID ir šis metodas prieinami jūsų raktui. Mokamą Gemini atsakymą Ailoot pateikia visą apskaičiavus kainą, o ne po žodį, todėl ilgų atsakymų tekstas pasirodo ne iškart.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/gemini-cli/)[Programos dokumentacija ↗](https://geminicli.com/docs/reference/configuration/)

KC

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

Agentas terminale

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Moonshot konsolės agentas darbui su kodu.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/kimi-cli/)

#### Kur nustatyti

~/.kimi/config.toml (providers ir models skyriai, default\_model); /login palaiko tik Moonshot platformas — savas adresas nustatomas ranka faile

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

`~/.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"]
```

Modelio pavyzdys: `kimi-k3`

#### Svarbu

Tipai: openai\_legacy (Chat Completions, base\_url su /v1), openai\_responses (Responses, su /v1), anthropic (be /v1), gemini (base\_url — Google šakninis adresas, mūsų atveju https://api.ailoot.ai). SearchWeb įrankis veikia tik su sava Moonshot platforma; FetchURL su kitu API adresu pereina prie vietinio atsisiuntimo.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/kimi-cli/)[Programos dokumentacija ↗](https://moonshotai.github.io/kimi-cli/en/configuration/providers.html)

Cr

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

Agentas terminale

OpenAI ChatAnthropic Messages

Charm agentas terminale, nustatomas crushrc faile.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/crush/)

#### Kur nustatyti

crushrc (Bash konfigūracija): ./.crushrc, ./crushrc arba ~/.config/crush/crushrc; senasis crush.json formatas pasenęs, tačiau veikia

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

`~/.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

# Anthropic formatas Claude modeliui: adresas be /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
```

Raktas skaitomas iš kintamojo `AILOOT_API_KEY` — nustatykite jį prieš paleisdami:

```bash
export AILOOT_API_KEY="sk-..."   # pridėkite į ~/.zshrc arba ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # tada paleiskite terminalą iš naujo
```

Modelio pavyzdys: `deepseek-v4-pro`

#### Svarbu

Tipas openai-compat — OpenAI Chat formatas, adresas su /v1. Tipas anthropic — Messages formatas, adresas be /v1: Crush perduoda jį anthropic-sdk-go, o šis pats prideda /v1/messages. Crush README pavyzdys su /v1 sudarytų /v1/v1/messages kelią ir sukeltų 404 klaidą. Raktas siunčiamas x-api-key antraštėje, Ailoot jį priima. Jei modelių sąrašas tuščias, openai-compat tiekėjas pats juos gauna iš /v1/models. crushrc vykdomas kaip kodas: nepaleiskite Crush svetimuose kataloguose su tokiu failu. Šiame pavyzdyje Claude supports-images = false: 2026-09-30 katalogo momentinė kopija pasirinktu Messages formatu deklaruoja tik tekstą. Jei jūsų Crush versija palaiko šį parametrą, įjunkite jį tik modeliui, kurio dabartinė katalogo kortelė pasirinktu API formatu deklaruoja image įvestį; vien kliento parametras nesuteikia modeliui vaizdų palaikymo.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/crush/)[Programos dokumentacija ↗](https://github.com/charmbracelet/crush#custom-providers)

Ai

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

Agentas terminale

OpenAI Chat

Porinis programavimas su DI tiesiai git saugykloje.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/aider/)

#### Kur nustatyti

Kintamieji OPENAI\_API\_BASE ir OPENAI\_API\_KEY, parametras --model openai/\<modelis\>

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `openai/deepseek-v4-pro`

#### Svarbu

Prefiksas openai/ privalomas: taip Aider (per LiteLLM) siunčia užklausas į su OpenAI suderinamą /v1/chat/completions. Aider nepažįstamų modelių atveju jis įspės apie nežinomą kontekstą — tai nėra klaida. Anthropic adresas su savu base URL šiame dokumentacijos puslapyje neaprašytas.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/aider/)[Programos dokumentacija ↗](https://aider.chat/docs/llms/openai-compat.html)

Go

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

Agentas terminale

OpenAI ChatAnthropic Messages

Atvirojo kodo agentas terminalui ir kompiuteriui su MCP plėtiniais.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/goose/)

#### Kur nustatyti

goose configure → Custom Providers → Add A Custom Provider, arba JSON kataloge ~/.config/goose/custom\_providers/ (Windows: %APPDATA%\\Block\\goose\\config\\custom\_providers\\); alternatyva — integruotas OpenAI tiekėjas su OPENAI\_HOST/OPENAI\_BASE\_PATH

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

`~/.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

# variantas per integruotą OpenAI tiekėją:
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"
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Savo tiekėjo varikliai: openai, anthropic, ollama. Goose pavyzdyje engine openai base\_url nurodytas visu keliu iki /v1/chat/completions. Integruotam tiekėjui OPENAI\_HOST — šakninis adresas be kelio, OPENAI\_BASE\_PATH — kelias (numatytasis v1/chat/completions). Raktą config.yaml faile Goose ignoruoja — naudoja tik kintamąjį arba raktinę. Saugykla perkelta į aaif-goose/goose.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/goose/)[Programos dokumentacija ↗](https://github.com/aaif-goose/goose/blob/main/documentation/docs/getting-started/providers.md)

FD

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

Agentas terminale

OpenAI ChatOpenAI ResponsesAnthropic Messages

Factory agentas terminalui su savais modeliais.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/factory-droid/)

#### Kur nustatyti

~/.factory/settings.json → customModels masyvas; modelio pasirinkimas — komanda /model, skiltis „Custom models“

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Raktas skaitomas iš kintamojo `AILOOT_API_KEY` — nustatykite jį prieš paleisdami:

```bash
export AILOOT_API_KEY="sk-..."   # pridėkite į ~/.zshrc arba ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # tada paleiskite terminalą iš naujo
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

provider: anthropic = Messages API (baseUrl kaip Anthropic, be /v1), openai = Responses API (su /v1), generic-chat-completion-api = Chat Completions (su /v1). anthropic atveju raktas pagal numatytuosius nustatymus siunčiamas x-api-key antraštėje (Ailoot priima); "authMode": "bearer" perjungia į Authorization. Raktai lieka vietoje. Factory išsamiai testuoja tik oficialius Anthropic ir OpenAI API.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/factory-droid/)[Programos dokumentacija ↗](https://docs.factory.com/model-independence/byok)

Am

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

Agentas terminale

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Amp programavimo agentas su lanksčiu modelių nukreipimu.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/amp/)

#### Kur nustatyti

Nustatymai → Model Routing → Add → Custom URL (arba komandos workspace Model Routing); terminale — amp config model-providers (list, test, set-priority, edit-router…)

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Antras GPT prijungimas:
  Format:   responses
  Base URL: https://api.ailoot.ai/v1
  API key:  sk-...
  Model mapping:
    openai/gpt-5.6-sol -> gpt-5.6-sol

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

Modelio pavyzdys: `claude-fable-5`

#### Svarbu

Custom URL formatai: chat-completions (\<base\>/chat/completions), responses (\<base\>/responses), anthropic-messages (\<base\>/v1/messages, /v1 nedubliuojamas), google-genai (\<base\>/models/\<model\>:streamGenerateContent). Raktas siunčiamas kaip Authorization: Bearer. Susiejimui naudojami kanoniniai Amp ID formatu provider/model; rodyklė nustato mums siunčiamą ID. Modelius, kurių prijungimas neapima, Amp aptarnauja pats už savo kreditus. Dokumente reikalaujama, kad savasis serveris būtų pasiekiamas iš Amp — adresas viešas, ši sąlyga įvykdyta.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/amp/)[Programos dokumentacija ↗](https://ampcode.com/docs/markdown/customize/model-routing)

AI

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

Agentas terminale

OpenAI ChatAnthropic MessagesGemini

Universalus pokalbis terminale su vaidmenimis, seansais ir RAG.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/aichat/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `deepseek-v4-pro`

#### Svarbu

AIChat konfigūracijos pavyzdyje claude api\_base nurodytas su /v1, gemini — su /v1beta; Ailoot atveju taip pat. Trys klientai suteikia prieigą prie visų trijų Ailoot formatų: OpenAI, Anthropic ir Gemini.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/aichat/)[Programos dokumentacija ↗](https://github.com/sigoden/aichat/blob/main/config.example.yaml)

CC

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

Agentas terminale

OpenAI Chat

Continue konsolės versija agentams ir automatizavimui.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/continue-cli/)

#### Kur nustatyti

Continue YAML konfigūracija (config.yaml), perduodama CLI parametru --config \<path\>

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

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

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Su OpenAI suderinamoms paslaugoms Continue naudoja provider: openai ir apiBase su /v1. Konfigūracijos formatas bendras plėtiniui ir CLI, failas perduodamas parametru --config.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/continue-cli/)[Programos dokumentacija ↗](https://docs.continue.dev/customize/model-providers/top-level/openai)

Fo

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

Agentas terminale

OpenAI Chat

Agentas terminale su konfigūruojamais tiekėjais.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/forge/)

#### Kur nustatyti

forge provider login → OpenAI-compatible (rekomenduojamas būdas); pasenęs būdas — .env su OPENAI\_URL ir OPENAI\_API\_KEY bei model faile forge.yaml

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```bash
# rekomenduojama:
forge provider login   # pasirinkti OpenAI-compatible, įvesti https://api.ailoot.ai/v1 ir sk-...

# pasenęs būdas (.env):
OPENAI_API_KEY=sk-...
OPENAI_URL=https://api.ailoot.ai/v1

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

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Nustatymas per .env pažymėtas kaip pasenęs: pirmą kartą paleidus Forge kintamieji perkeliami į jo failų saugyklą. Tikslūs provider login vediklio punktų pavadinimai README nepateikti.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/forge/)[Programos dokumentacija ↗](https://github.com/tailcallhq/forgecode)

GC

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

Agentas terminale

OpenAI ChatAnthropic Messages

Copilot terminale su savais modeliais.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/github-copilot-cli/)

#### Kur nustatyti

Aplinkos kintamieji COPILOT\_PROVIDER\_BASE\_URL, COPILOT\_PROVIDER\_TYPE, COPILOT\_PROVIDER\_API\_KEY, COPILOT\_MODEL (arba parametras --model)

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```bash
export AILOOT_API_KEY="sk-..."
unset COPILOT_PROVIDER_TYPE
# Su OpenAI suderinamas režimas
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

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

Modelio pavyzdys: `gpt-6.1-sol`

#### Svarbu

Tipai: openai (numatytasis, bet kuris su OpenAI suderinamas serveris), azure, anthropic. Modelis privalo palaikyti įrankių iškvietimą ir srautinę išvestį. Protokolui pasirinkti yra COPILOT\_PROVIDER\_WIRE\_API, jo reikšmės puslapyje neišvardytos. Limitus galima nustatyti per COPILOT\_PROVIDER\_MAX\_PROMPT\_TOKENS / MAX\_OUTPUT\_TOKENS.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/github-copilot-cli/)[Programos dokumentacija ↗](https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/use-byok-models)

Gp

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

Agentas terminale

OpenAI Chat

Asmeninis agentas terminale: kodas, failai, naršyklė.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/gptme/)

#### Kur nustatyti

~/.config/gptme/config.toml → \[\[providers\]\]; modelis pasirenkamas kaip \<provider\>/\<model\>

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

`~/.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 'labas' -m ailoot/claude-sonnet-5-5
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Bet kuris su OpenAI suderinamas serveris; rakto ieškoma api\_key, tada api\_key\_env, tada \<NAME\>\_API\_KEY. Tiekėjų sąrašas — gptme-util providers list.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/gptme/)[Programos dokumentacija ↗](https://github.com/gptme/gptme/blob/master/docs/providers-custom.rst)

KC

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

Agentas terminale

OpenAI ChatOpenAI ResponsesAnthropic Messages

Kilo Code konsolės agentas.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/kilo-code-cli/)

#### Kur nustatyti

~/.config/kilo/kilo.jsonc (arba ./kilo.jsonc; taip pat KILO\_CONFIG) → provider.\<id\>.options.baseURL; plėtinyje — Settings → Providers → Custom provider

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Raktas skaitomas iš kintamojo `AILOOT_API_KEY` — nustatykite jį prieš paleisdami:

```bash
export AILOOT_API_KEY="sk-..."   # pridėkite į ~/.zshrc arba ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # tada paleiskite terminalą iš naujo
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Custom provider lange galima pasirinkti protokolą: OpenAI Compatible (Chat Completions), OpenAI Responses, Anthropic Messages. {env:VAR} veikia tik patikimoje visuotinėje konfigūracijoje (~/.config/kilo); projekto kilo.json faile raktas iš kintamojo neįterpiamas.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/kilo-code-cli/)[Programos dokumentacija ↗](https://kilo.ai/docs/code-with-ai/agents/custom-models)

LL

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

Agentas terminale

OpenAI ChatOpenAI Responses

Įrankis užklausoms modeliams iš komandų eilutės.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/llm-cli/)

#### Kur nustatyti

Failas extra-openai-models.yaml llm nustatymų kataloge; raktas — llm keys set \<vardas\>

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Pagal numatytuosius nustatymus — Chat Completions; responses: true perjungia modelį į /responses. Kai nustatytas api\_base, OpenAI raktas nesiunčiamas — reikia api\_key\_name. Tai CLI įrankis užklausoms, o ne agentas.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/llm-cli/)[Programos dokumentacija ↗](https://llm.datasette.io/en/stable/other-models.html)

MS

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

Agentas terminale

OpenAI Chat

Minimalistinis agentas užduotims saugykloje.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/mini-swe-agent/)

#### Kur nustatyti

Agento YAML konfigūracija → model skyrius (model\_name, model\_kwargs); numatytasis konfigūracijos kelias keičiamas nustatymu MSWEA\_MINI\_CONFIG\_PATH

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```yaml
# agento konfigūracijos fragmentas
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"
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Veikia per LiteLLM: model\_kwargs tiesiogiai perduodami į litellm.completion. Be kainų registro LiteLLM praneša apie nežinomą kainą — išjungiame per cost\_tracking: "ignore\_errors" (arba MSWEA\_COST\_TRACKING=ignore\_errors). Rakto perdavimas per OPENAI\_API\_KEY yra LiteLLM standartas, pačiame mini-SWE-agent puslapyje neparodytas.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/mini-swe-agent/)[Programos dokumentacija ↗](https://github.com/SWE-agent/mini-swe-agent/blob/main/docs/models/local_models.md)

OC

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

Agentas terminale

OpenAI Chat

Autonominis kūrimo agentas komandų eilutėje.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/openhands-cli/)

#### Kur nustatyti

Ctrl+P → Settings (tiekėjas ir modelis), failas ~/.openhands/agent\_settings.json (llm.model / llm.api\_key / llm.base\_url) arba kintamieji LLM\_MODEL, LLM\_API\_KEY, LLM\_BASE\_URL su parametru --override-with-envs

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

`~/.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-..."
# vienkartinai per kintamuosius:
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
```

Modelio pavyzdys: `openai/claude-sonnet-5-5`

#### Svarbu

OpenHands veikia per LiteLLM; OpenAI tarpiniam serveriui dokumentacija nurodo Custom Model formatu openai/\<modelis\> ir tarpinio serverio Base URL. Pakeitimai per --override-with-envs neišsaugomi. Žiniatinklio sąsajoje: Settings → LLM → Advanced → Custom Model, Base URL, API Key.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/openhands-cli/)[Programos dokumentacija ↗](https://docs.openhands.dev/openhands/usage/cli/command-reference)

Pi

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

Agentas terminale

OpenAI ChatAnthropic MessagesGemini

Minimalistinis programavimo agentas terminalui.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/pi/)

#### Kur nustatyti

~/.pi/agent/models.json (arba projekto .pi/models.json, patvirtinus pasitikėjimą projektu); pasirinkimas — /model

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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"
        }
      ]
    }
  }
}
```

Raktas skaitomas iš kintamojo `AILOOT_API_KEY` — nustatykite jį prieš paleisdami:

```bash
export AILOOT_API_KEY="sk-..."   # pridėkite į ~/.zshrc arba ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # tada paleiskite terminalą iš naujo
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Pi dokumentacija aiškiai leidžia su OpenAI, Anthropic ir Google suderinamus adresus per models.json; pavyzdys pateiktas api: openai-completions. apiKey supranta $NAME/${NAME}, tiesioginę reikšmę arba !komandą. Failas perskaitomas iš naujo atveriant /model.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/pi/)[Programos dokumentacija ↗](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/models.md)

Pl

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

Agentas terminale

OpenAI Chat

Agentas didelėms užduotims: planas, pakeitimai izoliuotoje aplinkoje, pritaikymas.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/plandex/)

#### Kur nustatyti

plandex models custom (arba \\models custom REPL aplinkoje) — atveria savų modelių ir tiekėjų JSON failą

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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"
        }
      ]
    }
  ]
}
```

Raktas skaitomas iš kintamojo `AILOOT_API_KEY` — nustatykite jį prieš paleisdami:

```bash
export AILOOT_API_KEY="sk-..."   # pridėkite į ~/.zshrc arba ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # tada paleiskite terminalą iš naujo
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Savi tiekėjai veikia tik savame serveryje įdiegtame Plandex; debesijoje su BYO raktais leidžiami tik integruoti tiekėjai. Visi savi tiekėjai turi būti suderinami su OpenAI (Chat Completions). Tada modelis įtraukiamas į savą model pack.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/plandex/)[Programos dokumentacija ↗](https://github.com/plandex-ai/plandex/blob/main/docs/docs/models/custom-models.md)

TA

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

Agentas terminale

OpenAI ChatAnthropic Messages

ByteDance tyrimų agentas kūrimo užduotims.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/trae-agent/)

#### Kur nustatyti

trae\_config.yaml → model\_providers.\<pavadinimas\>.base\_url; alternatyva — kintamieji OPENAI\_BASE\_URL / ANTHROPIC\_BASE\_URL faile .env

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `gpt-6.1-sol`

#### Svarbu

YAML naudokite tik tarpus, be tabuliacijos. Anthropic formatui — provider: anthropic ir ANTHROPIC\_BASE\_URL (tikslus /v1 reikalavimas anthropic atveju README nenurodytas; naudokite https://api.ailoot.ai).

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/trae-agent/)[Programos dokumentacija ↗](https://github.com/bytedance/trae-agent#using-base-url)

Wa

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

Agentas terminale

OpenAI Chat

Terminalas su integruotu agentu ir savu modelio adresu.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/warp/)

#### Kur nustatyti

Settings → ieškoti „inference endpoint“ → Custom inference endpoint: bazinis URL, raktas, modelių ID; tada pasirinkti modelį pasirinkimo lauke

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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
Tada modelių sąraše pasirinkite, pavyzdžiui, claude-sonnet-5-5 (ne Auto).
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Tik OpenAI Chat Completions (POST /v1/chat/completions). Užklausos siunčiamos per Warp serverius: raktas saugomas vietoje, tačiau su kiekviena užklausa perduodamas Warp serveriui. Auto režimai ir savi maršrutizatoriai visada naudoja Warp kreditus; debesijos agentai šio endpoint nenaudoja. Prieinama Free ir mokamuose planuose asmenims bei komandoms iki 10 žmonių. Rinkitės modelius, kuriems dabartinis katalogas deklaruoja OpenAI Chat formatą. 2026-09-30 momentinėje kopijoje gemini-3.6-flash turi šį formatą; kitus Gemini modelius tikrinkite pagal jų korteles. Šis kelias nenaudoja savojo Gemini formato. Metodo buvimas kataloge nereiškia tikro konkrečios kliento versijos bandymo.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/warp/)[Programos dokumentacija ↗](https://docs.warp.dev/agents/inference/custom-inference-endpoint/)

## Redaktoriai ir IDE

Kodo redaktorių plėtiniai ir integruoti asistentai.

Cl

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

Redaktoriaus plėtinys

OpenAI ChatAnthropic Messages

Autonominis agentas VS Code ir JetBrains: planas, pataisos, komandos.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/cline/)

#### Kur nustatyti

Cline skydelis → krumpliaračio piktograma (Settings) → API Provider = „OpenAI Compatible“ → laukai Base URL, API Key, Model ID. Antras variantas: API Provider = „Anthropic“ → pažymėti „Use custom base URL“.

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```text
OpenAI Compatible (rekomenduojame):
  API Provider: OpenAI Compatible
  Base URL:     https://api.ailoot.ai/v1
  API Key:      sk-...
  Model ID:     claude-sonnet-5-5   (arba gpt-6.1-sol, deepseek-v4-pro, qwen3.8-max)
  Model Configuration: Context Window ir Max Output Tokens — pagal modelį; Image Support — tik modeliams, kurie priima vaizdus.

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

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

OpenAI Compatible kreipiasi į /v1/chat/completions, todėl adresas su /v1. Anthropic variantas kreipiasi į /v1/messages, adresas be /v1, tačiau jo modelių sąraše yra tik Anthropic pavadinimai — kiti Ailoot modeliai prieinami per OpenAI Compatible. Agento režimui reikia modelio, galinčio iškviesti įrankius. Gemini 3.1 Pro modeliai per chat/completions neprieinami (jie palaiko tik Gemini ir Anthropic formatus) — čia rinkitės gemini-3.6-flash.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/cline/)[Programos dokumentacija ↗](https://docs.cline.bot/provider-config/openai-compatible)

RC

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

Redaktoriaus plėtinys

OpenAI ChatAnthropic Messages

VS Code agentas su kodo, architektūros ir derinimo režimais.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/roo-code/)

#### Kur nustatyti

Roo Code skydelis → krumpliaratis → API Provider = „OpenAI Compatible“ → Base URL, API Key, Model; pasirinktinai Model Configuration (Max Output Tokens, Context Window, Image Support, Computer Use, kainos). Anthropic tiekėjas turi žymimąjį langelį „Use custom base URL“.

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

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

Modelio pavyzdys: `gpt-6.1-sol`

#### Svarbu

Roo Code iškviečia įrankius tik OpenAI formatu, todėl modelis turi palaikyti tools per /v1/chat/completions. Anthropic variantas kreipiasi į /v1/messages, adresas be /v1.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/roo-code/)[Programos dokumentacija ↗](https://roocodeinc.github.io/Roo-Code/providers/openai-compatible/)

KC

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

Redaktoriaus plėtinys

OpenAI Chat

VS Code agentas su režimais ir savais modeliais.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/kilo-code/)

#### Kur nustatyti

Settings (krumpliaratis) → kortelė Providers → apačioje „Custom provider“ → Provider ID, Display name, Provider API = „OpenAI Compatible“, Base URL, API key, Models (sąrašas gaunamas iš /v1/models). Nustatymai išsaugomi kilo.json.

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```text
Provider ID:   ailoot
Display name:  Ailoot
Provider API:  OpenAI Compatible
Base URL:      https://api.ailoot.ai/v1
API key:       sk-...
Models:        pasirinkite iš sąrašo, pavyzdžiui, claude-sonnet-5-5, gpt-6.1-sol, deepseek-v4-pro
```

Modelio pavyzdys: `deepseek-v4-pro`

#### Svarbu

Kilo užklausia {Base URL}/models ir pats rodo modelių sąrašą — mūsų GET /v1/models pateikia visą katalogą. Galima nurodyti ir visą adresą .../v1/chat/completions. Palaikomos savos antraštės.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/kilo-code/)[Programos dokumentacija ↗](https://kilo.ai/docs/ai-providers/openai-compatible)

Co

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

Redaktoriaus plėtinys

OpenAI Chat

VS Code ir JetBrains asistentas: pokalbis, pataisos, agentas.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/continue/)

#### Kur nustatyti

Failas ~/.continue/config.yaml (arba Continue konfigūracijos redaktorius): įrašas models\[\] su provider: openai ir apiBase.

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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   # tik jei reikia priverstinai naudoti /chat/completions
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

apiBase turi baigtis /v1. gpt-5/o serijos tipo pavadinimams Continue gali pats pasirinkti /v1/responses; mūsų gpt-\* palaiko ir /v1/responses, ir /v1/chat/completions, o useResponsesApi: false priverstinai įjungia chat/completions. useLegacyCompletionsEndpoint nereikalingas.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/continue/)[Programos dokumentacija ↗](https://docs.continue.dev/customize/model-providers/top-level/openai)

Ze

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

Kodo redaktorius

OpenAI ChatOpenAI ResponsesAnthropic Messages

Spartus kodo redaktorius su integruotu agentu.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/zed/)

#### Kur nustatyti

Agent Settings (agent::OpenSettings) → LLM Providers → Add Provider; arba settings.json → language\_models.openai\_compatible / language\_models.anthropic\_compatible. Raktas — nustatymų lange (saugomas sistemos raktinėje) arba kintamajame \<TIEKĖJO ID DIDŽIOSIOMIS RAIDĖMIS\>\_API\_KEY.

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `gpt-6.1-sol`

#### Svarbu

openai\_compatible adresas su /v1 (kreipiasi į /v1/chat/completions; capabilities.chat\_completions = false perjungia modelį į /v1/responses). anthropic\_compatible adresas be /v1 (kreipiasi į /v1/messages; Zed siunčia raktą x-api-key antraštėje — Ailoot jį priima). Pagal numatytuosius nustatymus images = false ir parallel\_tool\_calls = false. Zed gali perduoti vaizdus, tačiau images įjunkite tik konkrečiam modeliui, kurio dabartinė katalogo kortelė pasirinktu API formatu deklaruoja image įvestį. GPT ir Claude pavyzdžiuose images = false: 2026-09-30 momentinė kopija jiems deklaruoja tik tekstą. Pavyzdžiui, šioje kopijoje gemini-3.6-flash deklaruoja image įvestį OpenAI Chat formatu; faktinis palaikymas priklauso nuo modelio kortelės ir formato. Samprotavimo modeliams yra reasoning\_effort laukas. Pavyzdžio max\_tokens reikšmės yra konteksto dydis; tikslius limitus žiūrėkite modelių kataloge.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/zed/)[Programos dokumentacija ↗](https://zed.dev/docs/ai/use-api-access)

VC

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

Redaktoriaus plėtinys

OpenAI ChatOpenAI ResponsesAnthropic Messages

Savas tiekėjas VS Code Copilot Chat.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/vscode-copilot-byok/)

#### Kur nustatyti

Modelio pasirinkimas pokalbyje → Manage Language Models (krumpliaratis) → Add Models → Custom Endpoint → VS Code atvers chatLanguageModels.json. (Senasis github.copilot.chat.customOAIModels nustatymas pasenęs.)

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `gpt-6.1-sol`

#### Svarbu

url yra VISAS endpoint kelias. apiType reikšmės: chat-completions, responses (url .../v1/responses), messages (url .../v1/messages). BYOK veikia be Copilot plano ar prisijungimo prie GitHub, tačiau tik pokalbiui / agentui — įterptieji pasiūlymai lieka Copilot. Organizacijos administratoriai (Business/Enterprise) gali išjungti BYOK politiką. Aukščiau pateikti žetonų limitai yra pavyzdžiai; naudokite katalogo reikšmes. Šiuose pavyzdžiuose vision = false: 2026-09-30 katalogo momentinė kopija GPT/OpenAI Chat ir Claude/Anthropic Messages deklaruoja tik tekstą. Jei jūsų VS Code versija siūlo vision, įjunkite jį tik modeliui, kurio dabartinė katalogo kortelė pasirinktu API formatu deklaruoja image įvestį; lauko buvimas kliente nepatvirtina pasirinkto modelio vaizdų palaikymo.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/vscode-copilot-byok/)[Programos dokumentacija ↗](https://code.visualstudio.com/docs/agent-customization/language-models)

JA

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

Kodo redaktorius

OpenAI Chat

Integruotas JetBrains IDE asistentas su savu raktu.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/jetbrains-ai-assistant/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Pasirinkite OpenAI-compatible, lauke URL įrašykite https://api.ailoot.ai/v1 ir pateikite savo API Key. Spustelėkite Test Connection, tada Apply ir pasirinkite modelį AI Chat. IDE funkcijoms jį priskirkite per Models Assignment. Tool calling įjunkite tik modeliui, palaikančiam įrankius; kodo užbaigimas nustatomas atskirai.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/jetbrains-ai-assistant/)[Programos dokumentacija ↗](https://www.jetbrains.com/help/ai-assistant/use-custom-models.html)

Xc

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

Kodo redaktorius

OpenAI Chat

Coding Intelligence Xcode aplinkoje su išoriniu tiekėju.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/xcode/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```text
Type:           Internet Hosted
URL:            https://api.ailoot.ai        (BE /v1 — Xcode pats pridės /v1/models ir /v1/chat/completions)
API Key:        sk-...
API Key Header: x-api-key
Description:    Ailoot
→ tada pasirinkite modelius sąraše (pavyzdžiui, claude-sonnet-5-5, gpt-6.1-sol)
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Apple reikalauja, kad tiekėjas palaikytų Chat Completions ir atsakytų į {URL}/v1/models bei {URL}/v1/chat/completions. Ailoot priima raktą x-api-key ir Authorization: Bearer antraštėse (pasirinkus Authorization antraštę, pagal atsiliepimus Xcode pats prideda Bearer prefiksą). Xcode agentai nustatomi atskirai ir į šią instrukciją neįtraukti.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/xcode/)[Programos dokumentacija ↗](https://developer.apple.com/documentation/xcode/setting-up-coding-intelligence)

AN

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

Neovim papildinys

OpenAI ChatAnthropic Messages

Neovim papildinys: pokalbis ir pataisos tiesiai buferyje.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/avante-nvim/)

#### Kur nustatyti

opts yetone/avante.nvim papildiniui lazy.nvim: opts.providers.\<pavadinimas\> su \_\_inherited\_from = 'openai' (savas su OpenAI suderinamas tiekėjas) arba providers.claude.endpoint pakeitimas; raktas — iš api\_key\_name nurodyto kintamojo (palaikomi AVANTE\_\* pavadinimai).

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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, be /v1
      model = "claude-sonnet-5-5",
    },
  },
}
-- terminale: export AILOOT_API_KEY=sk-...
-- claude tiekėjas skaito AVANTE_ANTHROPIC_API_KEY arba ANTHROPIC_API_KEY
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Papildinio vikyje su OpenAI suderinamas adresas baigiasi /v1 (papildinys prideda /chat/completions). Integruotas claude tiekėjas naudoja https://api.anthropic.com tipo adresą, todėl Ailoot atveju — be /v1. Savi tiekėjai be \_\_inherited\_from reikalauja viso adreso ir savų atsakymo analizės funkcijų.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/avante-nvim/)[Programos dokumentacija ↗](https://github.com/avante-corp/avante.nvim/wiki/Custom-providers)

CN

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

Neovim papildinys

OpenAI ChatAnthropic Messages

Pokalbis ir įterptosios pataisos Neovim aplinkoje.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/codecompanion-nvim/)

#### Kur nustatyti

require('codecompanion').setup({ adapters = { http = { ... } } }) per adapters.extend('openai\_compatible', ...) arba extend('anthropic', ...); tada interactions.chat/inline.adapter.

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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",        -- aplinkos kintamojo, kuriame laikomas sk-..., pavadinimas
            chat_url = "/v1/chat/completions",
          },
          schema = { model = { default = "gpt-6.1-sol" } },
        })
      end,
    },
  },
  interactions = {
    chat = { adapter = "ailoot" },
    inline = { adapter = "ailoot" },
  },
})
```

Raktas skaitomas iš kintamojo `AILOOT_API_KEY` — nustatykite jį prieš paleisdami:

```bash
export AILOOT_API_KEY="sk-..."   # pridėkite į ~/.zshrc arba ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # tada paleiskite terminalą iš naujo
```

Modelio pavyzdys: `gpt-6.1-sol`

#### Svarbu

openai\_compatible atskiria serverį (env.url, be /v1) ir kelią (env.chat\_url). env reikšmės gali būti aplinkos kintamojo pavadinimas, cmd:..., file:... arba Lua funkcija. anthropic adapteris taip pat išplečiamas savu url, skirtu /v1/messages.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/codecompanion-nvim/)[Programos dokumentacija ↗](https://codecompanion.olimorris.dev/configuration/adapters-http)

Gp

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

Emacs paketas

OpenAI ChatAnthropic MessagesGemini

Paprastas kalbos modelių klientas Emacs aplinkai.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/gptel/)

#### Kur nustatyti

init.el: užregistruokite posistemę per gptel-make-openai (OpenAI Chat), gptel-make-anthropic (Messages) arba gptel-make-gemini — kiekviena turi :host, :endpoint, :key, :stream, :models; tada nustatykite gptel-backend ir gptel-model.

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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")               ; arba (gptel-api-key-from-environment "AILOOT_API_KEY")
        :models '(claude-sonnet-5-5 gpt-6.1-sol deepseek-v4-pro qwen3.8-max)))

;; Anthropic Messages variantas
(gptel-make-anthropic "Ailoot-Claude"
  :host "api.ailoot.ai"          ; numatytasis kelias /v1/messages
  :stream t
  :key (getenv "AILOOT_API_KEY")
  :models '(claude-sonnet-5-5 claude-opus-5-5))
```

Raktas skaitomas iš kintamojo `AILOOT_API_KEY` — nustatykite jį prieš paleisdami:

```bash
export AILOOT_API_KEY="sk-..."   # pridėkite į ~/.zshrc arba ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # tada paleiskite terminalą iš naujo
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

:host — tik serverio vardas (be https:// ir kelio), kelias nustatomas per :endpoint. gptel-make-anthropic siunčia x-api-key ir anthropic-version antraštes — Ailoot jas priima.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/gptel/)[Programos dokumentacija ↗](https://github.com/karthink/gptel)

TI

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

Kodo redaktorius

OpenAI Chat

Atvirojo kodo IDE su Theia AI moduliu.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/theia/)

#### Kur nustatyti

Preferences → AI-features → OpenAiCustom (arba settings.json raktas ai-features.openAiCustom.customOpenAiModels; AI Configuration langas — Alt+A).

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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"
    }
  ]
}
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

url — bazinis adresas, baigiasi /v1. Ne OpenAI modeliams saugus pasirinkimas — developerMessageSettings: "system".

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/theia/)[Programos dokumentacija ↗](https://theia-ide.org/docs/user_ai/)

TI

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

Kodo redaktorius

OpenAI ChatAnthropic Messages

Trae kodo redaktorius su savais modeliais.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/trae/)

#### Kur nustatyti

Settings → Models → Add Model → Custom Model → API Format, Request URL (jungiklis Full URL), Model ID, Display Name, API Key; pasirinktinai Advanced Settings.

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

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

Modelio pavyzdys: `gpt-6.1-sol`

#### Svarbu

Kai Full URL išjungtas, Trae pats prideda pasirinkto formato kelią (OpenAI adresas su /v1, Anthropic — be /v1). Kai Full URL įjungtas, įveskite https://api.ailoot.ai/v1/chat/completions arba https://api.ailoot.ai/v1/messages. Laukas Model Series pritaiko užuominas modelio šeimai.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/trae/)[Programos dokumentacija ↗](https://docs.trae.ai/ide/models)

## Pokalbių programos

Pokalbių programos kompiuteriui, telefonui ir naršyklei, užrašai ir paleidyklės.

OW

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

Žiniatinklio pokalbis, savas serveris

OpenAI Chat

Populiarus žiniatinklio pokalbis savame serveryje.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/open-webui/)

#### Kur nustatyti

Settings \> Admin \> Connections \> Manage OpenAI API Connections \> + Add Connection (arba aplinkos kintamieji OPENAI\_API\_BASE\_URL / OPENAI\_API\_KEY paleidžiant konteinerį)

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```text
UI: URL = https://api.ailoot.ai/v1
API Key = sk-...
Model IDs: tuščia (bus įkelti iš /v1/models) arba pridėkite rankiniu būdu claude-sonnet-5-5, gpt-6.1-sol

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

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

OpenAI Chat Completions formatas; URL privalo būti su /v1 ir be galinio pasvirojo brūkšnio. Modelių sąrašas gaunamas iš /v1/models; esant dideliam katalogui (252 modeliai) patogiau apriboti Model IDs ir įjungti modelių sąrašo podėlį (Cache Base Model List / ENABLE\_BASE\_MODELS\_CACHE=True). RAG vektoriniams atvaizdams yra atskiri RAG\_OPENAI\_API\_BASE\_URL.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/open-webui/)[Programos dokumentacija ↗](https://docs.openwebui.com/getting-started/quick-start/connect-a-provider/starting-with-openai-compatible/)

Li

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

Žiniatinklio pokalbis, savas serveris

OpenAI ChatAnthropic Messages

Žiniatinklio pokalbis savame serveryje su agentais ir keliais tiekėjais.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/librechat/)

#### Kur nustatyti

Failas librechat.yaml → endpoints.custom (raktas faile .env per ${VAR}); Anthropic formatui — laukas provider: 'anthropic'

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `gpt-6.1-sol`

#### Svarbu

Įprastas custom endpoint = OpenAI Chat Completions (baseURL su /v1). provider: 'anthropic' įjungia savąjį /v1/messages klientą; dokumentacijos pavyzdyje Anthropic baseURL nurodytas be /v1 (https://api.anthropic.com), todėl mūsų atveju https://api.ailoot.ai. fetch: true gauna sąrašą iš /v1/models.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/librechat/)[Programos dokumentacija ↗](https://www.librechat.ai/docs/configuration/librechat_yaml/object_structure/custom_endpoint)

CS

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

Kompiuterio programa

OpenAI ChatOpenAI ResponsesAnthropic Messages

Darbalaukio klientas su asistentais ir žinių baze.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/cherry-studio/)

#### Kur nustatyti

Settings (krumpliaratis) \> Model Provider \> + Add Provider \> protokolo tipas OpenAI / OpenAI Responses / Anthropic / Gemini

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```text
Provider Name: Ailoot
Tipas: OpenAI (arba OpenAI Responses / Anthropic)
API Key: sk-...
Base URL: https://api.ailoot.ai
→ Patikrinkite galutinio adreso peržiūrą po lauku: turi būti rodoma https://api.ailoot.ai/v1/chat/completions (Anthropic atveju — https://api.ailoot.ai/v1/messages)
Models: + claude-sonnet-5-5, gpt-6.1-sol
Tada mygtukas Model Check
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Dokumentacija patvirtina OpenAI, Anthropic, OpenAI Responses ir Gemini protokolus bei galutinio kelio peržiūrą po lauku, tačiau neaprašo /v1 pridėjimo taisyklių — remkitės peržiūra. Visi trys mūsų formatai (Chat Completions, Responses, Messages) tinka.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/cherry-studio/)[Programos dokumentacija ↗](https://cherryai.com/docs/en/pre-basic/providers/zi-ding-yi-fu-wu-shang/)

Ch

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

Kompiuteris ir telefonas

OpenAI Chat

Pokalbis kompiuteriui ir telefonui.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/chatbox/)

#### Kur nustatyti

Nustatymai (mygtukas šoninėje juostoje) \> Model Provider \> Add (apačioje) \> tipas OpenAI API Compatible

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```text
Name: Ailoot
API Mode: OpenAI API Compatible
API Key: sk-...
API Host: https://api.ailoot.ai
API Path: (tuščia, numatytasis /v1/chat/completions)
Models: + gpt-6.1-sol, claude-sonnet-5-5 (vision šiuose pavyzdžiuose išjungtas; tool_use — pagal pasirinkto modelio galimybes)
```

Modelio pavyzdys: `gpt-6.1-sol`

#### Svarbu

Dokumentacijoje API Host nurodytas be /v1 (pavyzdys https://api.openai.com), o numatytasis kelias — /v1/chat/completions. Taip pat yra Google Gemini compatible tipas, tačiau su mūsų /v1beta jis netikrintas. JSON konfigūracijos importas (type: 'openai', apiHost, apiPath) prieinamas nuo 1.15.1 per chatbox://provider/import?config=\<base64\>. Pateiktuose GPT ir Claude pavyzdžiuose vision išjungtas: 2026-09-30 katalogo momentinė kopija OpenAI Chat formatu deklaruoja tik tekstą. Jei jūsų Chatbox versija siūlo vision, įjunkite jį tik modeliui, kurio dabartinė katalogo kortelė pasirinktu API formatu deklaruoja image įvestį; kliento galimybė pridėti vaizdą neįrodo modelio palaikymo.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/chatbox/)[Programos dokumentacija ↗](https://docs.chatboxai.app/en/guides/providers)

Lo

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

Žiniatinklio pokalbis, savas serveris

OpenAI ChatAnthropic Messages

Šiuolaikiškas pokalbis su papildiniais ir žinių baze.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/lobechat/)

#### Kur nustatyti

Savas serveris: aplinkos kintamieji OPENAI\_PROXY\_URL / OPENAI\_API\_KEY / OPENAI\_MODEL\_LIST, ANTHROPIC\_PROXY\_URL, GOOGLE\_PROXY\_URL

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

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

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Numatytoji OPENAI\_PROXY\_URL reikšmė — https://api.openai.com/v1, todėl nurodome su /v1. Numatytoji ANTHROPIC\_PROXY\_URL reikšmė — https://api.anthropic.com (be /v1). Per GOOGLE\_PROXY\_URL teoriškai galima prijungti Gemini formatą (https://api.ailoot.ai), tačiau šio varianto netikrinome. Naudokite serverio režimą: jei užklausos siunčiamos tiesiai iš naršyklės, Ailoot API kol kas gali jas atmesti pagal CORS taisykles.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/lobechat/)[Programos dokumentacija ↗](https://lobehub.com/docs/self-hosting/environment-variables/model-provider)

Ja

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

Kompiuterio programa

OpenAI ChatAnthropic Messages

Atvirojo kodo pokalbis kompiuteriui su vietiniais ir debesijos modeliais.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/jan/)

#### Kur nustatyti

Settings \> Model Providers \> Add Provider → pasirinkti OpenAI-compatible arba Anthropic-compatible formatą

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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: bus įkelti iš {base_url}/models arba + pridėkite rankiniu būdu: claude-sonnet-5-5
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Dokumentacija: su OpenAI suderinamų tiekėjų Base URL privalo būti su /v1 (kitaip 404), galinis pasvirasis brūkšnys pašalinamas; Anthropic režimui pateiktas LiteLLM pavyzdys be /v1. Saviems tiekėjams modelio galimybės (tools, vision) nustatomos ranka. Palaiko atsarginius raktus (kartojama tik gavus 401/403/429).

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/jan/)[Programos dokumentacija ↗](https://www.jan.ai/docs/desktop/remote-models/custom-endpoint)

Si

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

Vaidmenų pokalbis

OpenAI Chat

Sąsaja vaidmenų pokalbiams ir veikėjams.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/sillytavern/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```text
Custom Endpoint (Base URL): https://api.ailoot.ai/v1
Custom API Key: sk-...
Model: pasirinkite iš sąrašo (/v1/models) arba įveskite claude-sonnet-5-5
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Dokumentacija: kilus ryšio problemų pridėti /v1 ir NEPRIDĖTI /chat/completions. Modelių sąrašas gaunamas, jei serveris pateikia /v1/models (mūsų serveris pateikia).

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/sillytavern/)[Programos dokumentacija ↗](https://docs.sillytavern.app/usage/api-connections/openai/)

An

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

Pokalbis su dokumentais

OpenAI Chat

Pokalbis su jūsų dokumentais kompiuteryje arba serveryje.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/anythingllm/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

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

Modelio pavyzdys: `deepseek-v4-pro`

#### Svarbu

Dokumentacijoje tiekėjas pažymėtas kaip „skirtas kūrėjams“. Prireikus GENERIC\_OPEN\_AI\_MODEL\_MAX\_TOKEN\_KEY='max\_completion\_tokens'. Vektoriniams atvaizdams yra atskiras generic-openai embedder (EMBEDDING\_BASE\_PATH + GENERIC\_OPEN\_AI\_EMBEDDING\_API\_KEY) — modelis nemotron-3-embed per /v1/embeddings.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/anythingllm/)[Programos dokumentacija ↗](https://docs.anythingllm.com/setup/llm-configuration/cloud/openai-generic)

BA

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

Žiniatinklio pokalbis, savas serveris

OpenAI ChatAnthropic Messages

Išplėstinė žiniatinklio sąsaja darbui su keliais modeliais.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/big-agi/)

#### Kur nustatyti

Diegimo aplinkos kintamieji: OPENAI\_API\_KEY / OPENAI\_API\_HOST, ANTHROPIC\_API\_KEY / ANTHROPIC\_API\_HOST; sąsajoje — Models \> Add OpenAI-compatible

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Dokumentacijoje kintamieji aprašyti kaip OpenAI ir Anthropic backend host pakeitimas (tarpiniams serveriams ir saviems endpoint); parašyta „host“, todėl nurodome be /v1, tačiau tikslus kelio formatas dokumentacijoje neišdėstytas — patikrinkite pagal pirmą užklausą.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/big-agi/)[Programos dokumentacija ↗](https://github.com/enricoros/big-AGI/blob/main/docs/environment-variables.md)

Bo

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

Mac programa

OpenAI Chat

Savasis DI klientas macOS aplinkai.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/boltai/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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: pagal modelį
Streaming: įjungti
```

Modelio pavyzdys: `gpt-6.1-sol`

#### Svarbu

Reikia viso chat completions adreso. Kad jį naudotų AI Command, nustatykite šią paslaugą kaip pagrindinę. Instrukcija parengta pagal BoltAI žinyną; BoltAI 2 langai gali skirtis.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/boltai/)[Programos dokumentacija ↗](https://boltai.com/help/how-to-setup-custom-openai-server)

HF

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

Žiniatinklio pokalbis, savas serveris

OpenAI Chat

Atvirojo kodo Hugging Face žiniatinklio pokalbis savame serveryje.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/hugging-face-chat-ui/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `deepseek-v4-pro`

#### Svarbu

Chat UI veikia tik su OpenAI suderinamais API per OPENAI\_BASE\_URL ir modelių sąrašą gauna iš /models.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/hugging-face-chat-ui/)[Programos dokumentacija ↗](https://github.com/huggingface/chat-ui)

MS

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

Kompiuterio programa

OpenAI Chat

Darbalaukio pokalbis su vietiniais ir debesijos modeliais.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/msty-studio/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `gpt-6.1-sol`

#### Svarbu

Dokumentacija patvirtina savą su OpenAI suderinamą tiekėją, tačiau nenurodo adreso formato; /v1 yra standartinis OpenAI API šakninis kelias, gavę 404 klaidą patikrinkite variantą be /v1. Savas su Anthropic suderinamas endpoint dokumentacijoje neaprašytas.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/msty-studio/)[Programos dokumentacija ↗](https://docs.msty.ai/studio/managing-models/online-providers)

Ne

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

Žiniatinklio pokalbis, savas serveris

OpenAI Chat

Lengvas, greitai įdiegiamas žiniatinklio pokalbis.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/nextchat/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `gpt-6.1-sol`

#### Svarbu

Šiai konfigūracijai naudokite OpenAI Chat per NextChat serverį. Diegdami Vercel arba Docker nustatykite BASE\_URL=https://api.ailoot.ai be /v1, OPENAI\_API\_KEY, CUSTOM\_MODELS ir DEFAULT\_MODEL. Pakeitę šiuos kintamuosius serverį įdiekite iš naujo.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/nextchat/)[Programos dokumentacija ↗](https://github.com/ChatGPTNextWeb/NextChat#environment-variables)

OC

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

Obsidian papildinys

OpenAI Chat

Pokalbis su Obsidian užrašais.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/obsidian-copilot/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```text
Base URL: https://api.ailoot.ai/v1
API key: sk-...
Model ID: claude-sonnet-5-5 (arba pasirinkite iš /v1/models sąrašo)
Tada Test; modelį įjunkite Basic > Agents > Quick Chat
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Modelių sąrašas gaunamas iš /v1/models, modelį galima įvesti ranka. Jei Test sėkmingas, o Quick Chat nesiunčia pranešimų, tiekėjui įjunkite Enable CORS (atsakymas bus pateiktas visas, be srauto). Raktai saugomi Obsidian Keychain.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/obsidian-copilot/)[Programos dokumentacija ↗](https://github.com/logancyang/obsidian-copilot/blob/master/docs/llm-providers.md)

PA

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

Naršyklės plėtinys

OpenAI Chat

Naršyklės plėtinys: pokalbis apie atvertą puslapį.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/page-assist/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```text
Provider: Custom
Name: Ailoot
Base URL: https://api.ailoot.ai/v1
API Key: sk-...
Tada rankiniu būdu pridėkite modelius: gpt-6.1-sol, claude-sonnet-5-5
```

Modelio pavyzdys: `gpt-6.1-sol`

#### Svarbu

Dokumentacija patvirtina Custom su API URL ir raktu; URL formatas neišdėstytas, /v1 — standartinis OpenAI API šakninis kelias. Automatinis modelių gavimas garantuotas tik Ollama, LM Studio ir Llamafile — kitiems modeliai pridedami ranka.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/page-assist/)[Programos dokumentacija ↗](https://docs.pageassist.xyz/providers/openai)

RA

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

Paleidyklė

OpenAI Chat

DI Raycast paleidyklėje: sparčiosios komandos ir pokalbis.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/raycast-ai/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

base\_url — su OpenAI suderinamas endpoint be /chat/completions priesagos. Raycast iš naujo perskaito failą be paleidimo iš naujo. Jei abilities nenustatytos, laikoma, kad tools ir vision nepalaikomi. Modeliai pasirodo Quick AI, AI Chat ir AI Commands. Šiame pavyzdyje vision.supported = false: 2026-09-30 katalogo momentinė kopija Claude/OpenAI Chat deklaruoja tik tekstą. Jei jūsų Raycast versija palaiko šį nustatymą, vision įjunkite tik modeliui, kurio dabartinė katalogo kortelė OpenAI Chat formatu deklaruoja image įvestį; vien kliento parametras nepatvirtina API vaizdų palaikymo.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/raycast-ai/)[Programos dokumentacija ↗](https://manual.raycast.com/ai/custom-providers)

Ty

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

Žiniatinklio programa

OpenAI Chat

Patogi pokalbio sąsaja naršyklėje ir kompiuteryje.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/typingmind/)

#### Kur nustatyti

Models (kairėje šoninėje juostoje) \> + Add Custom Model

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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: pagal modelį
Test → Save
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Endpoint įvedamas visu keliu. Raktas perduodamas sava antrašte Authorization: Bearer sk-... — Ailoot jį priima. TypingMind žiniatinklio versija kreipiasi į API tiesiai iš naršyklės, ir šiuo metu tokias užklausas gali sustabdyti CORS; darbalaukio versija patikimesnė. Gemini tipas TypingMind aplinkoje siunčia raktą apiKey antraštėje, kurios Ailoot nepriima — naudokite OpenAI Chat Completions tipą.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/typingmind/)[Programos dokumentacija ↗](https://docs.typingmind.com/manage-and-connect-ai-models/ollama)

## SDK ir karkasai

Bibliotekos savoms programoms, agentams ir RAG.

OS

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

SDK

OpenAI ChatOpenAI Responses

Oficiali OpenAI biblioteka Python kalbai.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/openai-python-sdk/)

#### Kur nustatyti

Konstruktoriaus parametras OpenAI(base\_url=..., api\_key=...) arba aplinkos kintamieji OPENAI\_BASE\_URL ir OPENAI\_API\_KEY

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

# arba kode
```

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

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

Modelio pavyzdys: `gpt-6.1-sol, claude-sonnet-5-5, deepseek-v4-pro, qwen3.8-max (pokalbis); nemotron-3-embed (įterpiniai)`

#### Svarbu

Adresas su /v1: SDK pats prideda /chat/completions, /responses, /embeddings, /images/\*, /audio/\*. Veikia Chat Completions ir Responses (Responses — modeliams, kurių kataloge yra šis formatas). Srautinė išvestis ir įrankiai standartiniai. Ailoot klaidos pateikiamos JSON formatu su Request ID ir pagaunamos kaip openai.APIStatusError.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/openai-python-sdk/)[Programos dokumentacija ↗](https://github.com/openai/openai-python)

OS

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

SDK

OpenAI ChatOpenAI Responses

Oficiali OpenAI biblioteka JavaScript ir TypeScript kalboms.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/openai-node-js-sdk/)

#### Kur nustatyti

Konstruktoriaus parinktis new OpenAI({ baseURL, apiKey }); pagal numatytuosius nustatymus SDK skaito aplinkos kintamąjį OPENAI\_BASE\_URL

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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: "Labas" }]
});
console.log(r.choices[0].message.content);
```

Raktas skaitomas iš kintamojo `AILOOT_API_KEY` — nustatykite jį prieš paleisdami:

```bash
export AILOOT_API_KEY="sk-..."   # pridėkite į ~/.zshrc arba ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # tada paleiskite terminalą iš naujo
```

Modelio pavyzdys: `claude-sonnet-5-5, gpt-6.1-sol, grok-4.7`

#### Svarbu

README rodo baseURL parinktį; OPENAI\_BASE\_URL skaitymas matomas kliento pradiniame kode (src/client.ts), numatytoji reikšmė — https://api.openai.com/v1. Ailoot adresą nurodykite su /v1. Prieinami ir chat.completions, ir responses.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/openai-node-js-sdk/)[Programos dokumentacija ↗](https://github.com/openai/openai-node)

AS

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

SDK

Anthropic Messages

Oficiali Anthropic biblioteka Python kalbai.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/anthropic-python-sdk/)

#### Kur nustatyti

Parametras Anthropic(base\_url=...) arba aplinkos kintamasis ANTHROPIC\_BASE\_URL; raktas: api\_key arba ANTHROPIC\_API\_KEY

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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": "Labas"}])
print(msg.content[0].text)
```

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

Modelio pavyzdys: `claude-sonnet-5-5, claude-opus-5-5; taip pat per /v1/messages gpt-6.1-sol, deepseek-v4-pro, gemini-3.6-flash`

#### Svarbu

Adresas BE /v1: SDK pats prideda /v1/messages. Šliuzas priima raktą x-api-key antraštėje (taip siunčia SDK) ir Authorization: Bearer. Veikia srautinė išvestis, įrankiai ir /v1/messages/count\_tokens. Paketinis apdorojimas (Batches) ir Files API Ailoot kataloge nedeklaruoti.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/anthropic-python-sdk/)[Programos dokumentacija ↗](https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/python)

VA

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

SDK

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

TypeScript karkasas DI programoms su bet kuriais tiekėjais.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/vercel-ai-sdk/)

#### Kur nustatyti

Tiekėjai: createOpenAICompatible({ name, baseURL, apiKey }) iš @ai-sdk/openai-compatible; createAnthropic({ baseURL, apiKey }) iš @ai-sdk/anthropic; createGoogleGenerativeAI({ baseURL, apiKey }) iš @ai-sdk/google; createOpenAI({ baseURL }) arba OPENAI\_BASE\_URL

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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: "Labas" });
// claude("claude-sonnet-5-5"), gemini("gemini-3.6-flash")
```

Raktas skaitomas iš kintamojo `AILOOT_API_KEY` — nustatykite jį prieš paleisdami:

```bash
export AILOOT_API_KEY="sk-..."   # pridėkite į ~/.zshrc arba ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # tada paleiskite terminalą iš naujo
```

Modelio pavyzdys: `deepseek-v4-pro (suderinamas su OpenAI), claude-sonnet-5-5 (Anthropic), gemini-3.6-flash (Gemini)`

#### Svarbu

Tiekėjų adresai skiriasi: su OpenAI suderinamas ir Anthropic — su /v1 (numatytasis Anthropic adresas https://api.anthropic.com/v1), Google — su /v1beta (numatytasis https://generativelanguage.googleapis.com/v1beta). Tiekėjas @ai-sdk/openai pagal numatytuosius nustatymus kreipiasi į Responses API; modeliams be responses metodo naudokite openai.chat("id") arba createOpenAICompatible.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/vercel-ai-sdk/)[Programos dokumentacija ↗](https://ai-sdk.dev/providers/openai-compatible-providers)

La

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

Karkasas

OpenAI ChatOpenAI ResponsesAnthropic Messages

Karkasas grandinėms, agentams ir RAG.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/langchain/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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("Labas").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"])
```

Modelio pavyzdys: `gpt-6.1-sol, qwen3.8-max (ChatOpenAI); claude-sonnet-5-5 (ChatAnthropic)`

#### Svarbu

ChatOpenAI: adresas su /v1. Pagal dokumentaciją ChatOpenAI palaiko tik oficialią OpenAI specifikaciją: nestandartiniai išorinių modelių laukai, pavyzdžiui, reasoning\_content, neišsaugomi. Claude geriau naudoti ChatAnthropic: adresas be /v1, SDK pats prideda /v1/messages. ChatAnthropic parametras base\_url ir kintamieji ANTHROPIC\_API\_URL/ANTHROPIC\_BASE\_URL aprašyti klasės dokumentacijoje pradiniame kode (langchain\_anthropic/chat\_models.py), integracijos puslapyje jų nėra. Parametras use\_responses\_api įjungia ChatOpenAI Responses režimą.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/langchain/)[Programos dokumentacija ↗](https://docs.langchain.com/oss/python/integrations/chat/openai)

Cr

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

Agentų karkasas

OpenAI ChatAnthropic Messages

Agentų komandos su vaidmenimis ir užduotimis.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/crewai/)

#### Kur nustatyti

crewai.LLM(model=..., base\_url=..., api\_key=...); kintamieji OPENAI\_API\_KEY ir OPENAI\_BASE\_URL; Claude atveju — savasis anthropic/ tiekėjas su base\_url

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/messages, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```python
import os
from crewai import LLM
# Su OpenAI suderinamas formatas
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)
```

Modelio pavyzdys: `openai/gpt-6.1-sol, anthropic/claude-sonnet-5-5`

#### Svarbu

Prefiksas openai/ arba anthropic/ parenka CrewAI tiekėją, užklausoje siunčiamas id be prefikso. OpenAI adresas su /v1, Anthropic — be /v1. Dokumentacijoje taip pat aprašytas parametras custom\_openai=True bet kuriam su OpenAI suderinamam šliuzui. Anthropic atveju max\_tokens privalomas.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/crewai/)[Programos dokumentacija ↗](https://docs.crewai.com/en/concepts/llms)

GG

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

SDK

Gemini

Oficiali Google biblioteka Gemini API.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/google-genai-python/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1beta/models/{model}:generateContent, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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="Labas")
print(r.text)
```

Modelio pavyzdys: `gemini-3.6-flash, gemini-3.1-pro`

#### Svarbu

Adresas be /v1beta: SDK pats sudaro /v1beta/models/{model}:generateContent. Raktas siunčiamas x-goog-api-key antraštėje — Ailoot jį priima. Prieinami tik Gemini formato modeliai. JavaScript versijos (@google/genai) savas adresas dokumentacijoje neaprašytas, todėl jos čia nepateikiame.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/google-genai-python/)[Programos dokumentacija ↗](https://github.com/googleapis/python-genai#custom-base-url)

Li

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

SDK

OpenAI Chat

Bendra Python sąsaja dešimtims tiekėjų.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/litellm/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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": "Labas"}])
print(r.choices[0].message.content)
# vektoriniai atvaizdai: litellm.embedding(model="openai/nemotron-3-embed", api_base="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], input=["tekstas"])
```

Modelio pavyzdys: `openai/claude-sonnet-5-5, openai/qwen3.8-max, openai/nemotron-3-embed`

#### Svarbu

Prefiksas openai/ reiškia su OpenAI suderinamą protokolą, į Ailoot siunčiamas id be prefikso. LiteLLM pats prideda /chat/completions ir /embeddings; pagal dokumentaciją gavus Not Found klaidą adresas turi baigtis /v1.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/litellm/)[Programos dokumentacija ↗](https://docs.litellm.ai/docs/providers/openai_compatible)

LP

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

Savas šliuzas

OpenAI Chat

Savas šliuzas su raktais, limitais ir žurnalais virš Ailoot.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/litellm-proxy/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

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

Raktas skaitomas iš kintamojo `AILOOT_API_KEY` — nustatykite jį prieš paleisdami:

```bash
export AILOOT_API_KEY="sk-..."   # pridėkite į ~/.zshrc arba ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # tada paleiskite terminalą iš naujo
```

Modelio pavyzdys: `openai/claude-sonnet-5-5, openai/gpt-6.1-sol`

#### Svarbu

Tarpinis serveris pravers, jei komandai reikia išdalyti savus vidinius raktus, naudojant vieną Ailoot raktą. Ailoot nurašymai priskiriami raktui, nurodytam api\_key. Adresas su /v1.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/litellm-proxy/)[Programos dokumentacija ↗](https://docs.litellm.ai/docs/providers/openai_compatible)

Ll

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

Karkasas

OpenAI Chat

Karkasas paieškai savuose duomenyse ir RAG.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/llamaindex/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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("Labas"))
```

Modelio pavyzdys: `deepseek-v4-pro, claude-sonnet-5-5, gpt-6.1-sol`

#### Svarbu

Adresas su /v1. Būtina is\_chat\_model=True, kitaip klasė kreipsis į pasenusį /completions. is\_function\_calling\_model=True — kad agentai naudotų įrankius. context\_window nustatykite pagal modelio kortelę Ailoot kataloge.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/llamaindex/)[Programos dokumentacija ↗](https://developers.llamaindex.ai/python/framework-api-reference/llms/openai_like/)

Ma

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

Agentų karkasas

OpenAI ChatOpenAI Responses

TypeScript karkasas agentams ir darbo eigoms.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/mastra/)

#### Kur nustatyti

Agent objekte: model: { id: "\<tiekėjas\>/\<modelis\>", url: "\<bazinis adresas\>", apiKey, api?: "chat" | "responses" }

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```js
import { Agent } from "@mastra/core/agent";
const agent = new Agent({
  id: "ailoot-agent",
  name: "Ailoot Agent",
  instructions: "Atsakyk rusų kalba",
  model: {
    id: "ailoot/claude-sonnet-5-5",
    url: "https://api.ailoot.ai/v1",
    apiKey: process.env.AILOOT_API_KEY
    // api: "responses"  // tik modeliams, turintiems responses metodą
  }
});
```

Raktas skaitomas iš kintamojo `AILOOT_API_KEY` — nustatykite jį prieš paleisdami:

```bash
export AILOOT_API_KEY="sk-..."   # pridėkite į ~/.zshrc arba ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # tada paleiskite terminalą iš naujo
```

Modelio pavyzdys: `ailoot/claude-sonnet-5-5, ailoot/gpt-6.1-sol`

#### Svarbu

Lauke url nurodomas bazinis adresas su /v1, o ne visas kelias į /chat/completions. Pagal numatytuosius nustatymus naudojamas Chat Completions, api: "responses" perjungia į Responses API. id forma "tiekėjas/modelis" siunčia šliuzui modelio id be prefikso. Laukas apiKey model objekte dokumentacijoje parodytas pavyzdyje su antraštėmis; atskirai kartu su url neaprašytas.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/mastra/)[Programos dokumentacija ↗](https://mastra.ai/models)

OA

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

Agentų karkasas

OpenAI ChatOpenAI Responses

OpenAI biblioteka kelių agentų scenarijams.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/openai-agents-sdk/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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="Pagalbininkas", instructions="Atsakyk rusų kalba", model=model)
print(Runner.run_sync(agent, "Labas").final_output)
```

Modelio pavyzdys: `claude-sonnet-5-5, gpt-6.1-sol`

#### Svarbu

Adresas su /v1. Sekimą išjunkite per set\_tracing\_disabled(True): kitaip SDK bandys siųsti sekimo duomenis į OpenAI be OpenAI rakto. Chat Completions galima naudoti tik su modeliais, kuriems kataloge nurodytas šis metodas ir kuriems jis prieinamas su jūsų raktu; Responses (numatytasis SDK) — tik modeliams, kurių kataloge yra responses metodas. Integruoti OpenAI įrankiai (žiniatinklio paieška, failai) per išorinį šliuzą negarantuojami.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/openai-agents-sdk/)[Programos dokumentacija ↗](https://openai.github.io/openai-agents-python/models/)

PA

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

Agentų karkasas

OpenAI ChatOpenAI Responses

Tipizuotas agentų karkasas Python kalba.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/pydantic-ai/)

#### Kur nustatyti

OpenAIProvider(base\_url=..., api\_key=...) su OpenAIChatModel (Chat Completions) arba OpenAIResponsesModel (Responses) modeliu; arba kintamasis OPENAI\_BASE\_URL

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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("Labas").output)
```

Modelio pavyzdys: `deepseek-v4-pro, gpt-6.1-sol (skirta OpenAIResponsesModel)`

#### Svarbu

Adresas su /v1. Dokumentacijoje pagal numatytuosius nustatymus naudojamas OpenAIResponsesModel: rinkitės jį tik modeliams su responses metodu; kitiems — OpenAIChatModel.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/pydantic-ai/)[Programos dokumentacija ↗](https://pydantic.dev/docs/ai/models/openai/)

## Automatizavimas

Scenarijai be kodo, grandinių kūrimo įrankiai, robotai ir išmanieji namai.

N8

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

Automatizavimas be kodo

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Scenarijų automatizavimas su DI agentų mazgais.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/n8n/)

#### Kur nustatyti

Credentials → OpenAI → laukas Base URL (numatytasis https://api.openai.com/v1); Credentials → Anthropic → Base URL (numatytasis https://api.anthropic.com); Credentials → Google Gemini(PaLM) Api → Host (numatytasis https://generativelanguage.googleapis.com). Tada mazgai OpenAI Chat Model / Anthropic Chat Model / Google Gemini Chat Model

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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-...
OpenAI Chat Model mazgas → Model: By ID → gpt-6.1-sol (jungiklis Use Responses API — tik modeliams, turintiems responses metodą)
```

Modelio pavyzdys: `gpt-6.1-sol / deepseek-v4-pro (OpenAI), claude-sonnet-5-5 (Anthropic), gemini-3.6-flash (Gemini)`

#### Svarbu

Prisijungimo duomenų patikra iškviečia /models (OpenAI), /v1/models (Anthropic) ir /v1beta/models (Gemini); Ailoot turi visus tris kelius. n8n dokumentacijos puslapiuose Base URL laukas neaprašytas: jis yra pačiuose prisijungimo duomenyse (pradinis kodas OpenAiApi.credentials.ts ir AnthropicApi.credentials.ts, užrašas „Override the default base URL for the API“). n8n Cloud nesirinkite „Use Gateway credits“, kitaip užklausos nebus siunčiamos per Ailoot.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/n8n/)[Programos dokumentacija ↗](https://github.com/n8n-io/n8n/blob/master/packages/nodes-base/credentials/OpenAiApi.credentials.ts)

Di

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

LLM programų platforma

OpenAI Chat

DI programų platforma: pokalbių robotai, agentai, žinių bazės.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/dify/)

#### Kur nustatyti

Integrations → Model Provider → įdiegti OpenAI-API-compatible papildinį → Add Model (laukai: Model Type, Model Name, API Key, API Base URL, Completion mode, Model context size)

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```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: pagal modelio kortelę Ailoot kataloge

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

Modelio pavyzdys: `claude-sonnet-5-5, gpt-6.1-sol, qwen3.8-max; nemotron-3-embed (įterpiniai)`

#### Svarbu

Tiekėjus gali valdyti tik darbo srities savininkas ir administratoriai. Pagal papildinio README: LLM adresas su /v1, o vektoriniams atvaizdams, rerank, STT ir TTS papildinys pats prideda API versiją, todėl adresas be /v1 (kitaip susidarys /v1/v1). Kiekvieną Ailoot modelį pridėkite atskiru įrašu; vaizdų įvesties ir srautinės išvesties palaikymą įjunkite modelio nustatymuose.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/dify/)[Programos dokumentacija ↗](https://github.com/langgenius/dify-official-plugins/tree/main/models/openai_api_compatible)

Fl

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

Grandinių kūrimo įrankis

OpenAI Chat

Vizualus grandinių ir agentų kūrimo įrankis.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/flowise/)

#### Kur nustatyti

Mazgas ChatOpenAI arba ChatOpenAI Custom → Connect Credential (raktas) → Additional Parameters → Base Path (ir Base Options antraštėms)

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `deepseek-v4-pro, claude-sonnet-5-5, gpt-6.1-sol`

#### Svarbu

ChatOpenAI modelių sąrašas fiksuotas, todėl bet kuriems Ailoot id naudokite ChatOpenAI Custom, kuriame modelio pavadinimas įvedamas ranka. Base Path su /v1. Vektoriniams atvaizdams yra OpenAI Embeddings Custom mazgas.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/flowise/)[Programos dokumentacija ↗](https://docs.flowiseai.com/integrations/langchain/chat-models/azure-chatopenai)

HA

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

Išmanieji namai

OpenAI Chat

Išmaniųjų namų balso asistentas per Extended OpenAI Conversation.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/home-assistant/)

#### Kur nustatyti

Įdiegti per HACS (Custom repository) arba nukopijuoti custom\_components/extended\_openai\_conversation → paleisti iš naujo → Settings → Devices & Services → Add Integration → Extended OpenAI Conversation (API Key, Base Url) → Settings → Voice Assistants → Conversation agent

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `gpt-6.1-sol, claude-sonnet-5-5`

#### Svarbu

Tai trečiosios šalies komponentas, o ne oficiali integracija. Įrenginiai valdomi iškviečiant funkcijas (tools) per Chat Completions, todėl rinkitės įrankius palaikančius modelius. Oficiali OpenAI Conversation integracija nepalaiko savo adreso.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/home-assistant/)[Programos dokumentacija ↗](https://github.com/jekalmin/extended_openai_conversation)

La

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

Grandinių kūrimo įrankis

OpenAI Chat

Vizualus agentų ir RAG kūrimo įrankis.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/langflow/)

#### Kur nustatyti

Profilis → Settings → Model Providers → OpenAI Compatible (laukai Base URL ir API Key; kintamieji OPENAI\_COMPATIBLE\_BASE\_URL ir OPENAI\_COMPATIBLE\_API\_KEY). Alternatyva: OpenAI komponentas → laukas OpenAI API Base

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```text
Settings → Model Providers → OpenAI Compatible:
  Base URL: https://api.ailoot.ai/v1
  API Key: sk-...
arba per aplinkos kintamuosius:
```

```bash
export OPENAI_COMPATIBLE_BASE_URL="https://api.ailoot.ai/v1"
export OPENAI_COMPATIBLE_API_KEY="sk-..."
Tada komponentuose Language Model / Agent pasirinkite OpenAI Compatible → claude-sonnet-5-5
```

Modelio pavyzdys: `claude-sonnet-5-5, gpt-6.1-sol, nemotron-3-embed (Embedding Model)`

#### Svarbu

Langflow tikrina ryšį ir gauna modelių sąrašą iš /v1/models; modeliai atsiranda Language Models ir Embedding Models skyriuose. Reikiamus modelius paskui reikia įjungti ranka. Tiekėjas įdiegiamas kartu su langflow.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/langflow/)[Programos dokumentacija ↗](https://docs.langflow.org/bundles-openai-compatible)

Ma

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

Automatizavimas be kodo

HTTP užklausa

Automatizavimas be kodo: užklausa į Ailoot per HTTP modulį.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/make/)

#### Kur nustatyti

Integruotas OpenAI modulis veikia tik su OpenAI paskyra. Naudokite HTTP → Make a request: URL, Method, Headers, Body type Raw / JSON

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```text
Modulis: 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 → atsakymas choices[].message.content lauke
```

Modelio pavyzdys: `gpt-6.1-sol, claude-sonnet-5-5`

#### Svarbu

Tai universalus HTTP modulis, o ne atskiras Ailoot tiekėjas: dokumentacijoje aprašytas bet kuris HTTPS adresas. Raktą geriau saugoti API rakto ryšyje (Make rekomenduoja tai vietoj perdavimo antraštėse). Srautinė išvestis Make nereikalinga, siųskite be stream.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/make/)[Programos dokumentacija ↗](https://apps.make.com/http)

T

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

Robotai

OpenAI Chat

Savas Telegram robotas, naudojantis OpenAI SDK.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/telegram-bot/)

#### Kur nustatyti

Telegram karkasai neturi savo LLM sluoksnio: pranešimų apdorojimo funkcijoje iškviečiamas OpenAI SDK su Ailoot base\_url (arba Anthropic SDK su base\_url be /v1)

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

Išsaugokite Python kodą kaip ailoot-telegram-bot.py. Įdiekite priklausomybes, nustatykite abu aplinkos kintamuosius ir paleiskite failą. Nusiųskite botui Hello ir patikrinkite tekstinį atsakymą. Klaidos atveju išsaugokite Request ID ir prieš kitą generavimą patikrinkite pradinį rezultatą.

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

Modelio pavyzdys: `claude-sonnet-5-5, deepseek-v4-pro, qwen3.8-flash`

#### Svarbu

Telegram karkasai neturi savo neuroninių tinklų sluoksnio: Ailoot adresas nustatomas OpenAI SDK roboto viduje. Esant nuliniam balansui Ailoot grąžins aiškią 402 klaidą su Request ID — parodykite ją roboto vartotojui, užuot leidę programai nutrūkti.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/telegram-bot/)[Programos dokumentacija ↗](https://github.com/openai/openai-python)

Za

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

Automatizavimas be kodo

HTTP užklausa

Automatizavimas: užklausa į Ailoot per Webhooks by Zapier.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/zapier/)

#### Kur nustatyti

Zapier ChatGPT (OpenAI) programa veikia tik su OpenAI. Naudokite Webhooks by Zapier → Custom Request (Method, URL, Data, Headers)

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `claude-sonnet-5-5, gpt-6.1-sol`

#### Svarbu

Tai universali HTTP užklausa, Zapier neturi paruošto tiekėjo su bazinio adreso lauku. Custom Request siunčia Data lauką nepakeistą, jo neanalizuodamas, todėl JSON reikia patikrinti iš anksto. Webhooks by Zapier prieinamas mokamuose Zapier planuose.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/zapier/)[Programos dokumentacija ↗](https://help.zapier.com/hc/en-us/articles/8496326446989-Send-webhooks-in-Zap-workflows)

## Tikrinama

Nustatymai su nepatvirtintomis detalėmis — tikrinkite pagal programos langą.

AC

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

Agentas terminale

Tikrinama

Gemini

Google Antigravity konsolės agentas Gemini formatu.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/antigravity-cli/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1beta/models/{model}:generateContent, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

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

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

Modelio pavyzdys: `gemini-3.8-flash`

#### Svarbu

Protokolas — savasis Gemini REST (streamGenerateContent, raktas X-Goog-Api-Key antraštėje), kelias https://api.ailoot.ai/v1beta/... Vienam klausimui agy siunčia dvi užklausas: pokalbio antraštei ir pačiam atsakymui. Agentas kiekvienam žingsniui rezervuoja gerokai daugiau nei įprastas pokalbis, todėl turėkite balanso atsargą. Kortelė yra skiltyje „Tikrinama“: nustatymai parengti pagal dokumentaciją, tikras kliento bandymas per Ailoot dar neatliktas. Jei modelProvider = gemini, o GEMINI\_API\_KEY tuščias, CLI nepasileis.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/antigravity-cli/)[Programos dokumentacija ↗](https://antigravity.google/docs/cli/install/)

CC

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

Agentas terminale

Tikrinama

OpenAI Chat

Cline agento konsolės versija.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/cline-cli/)

#### Kur nustatyti

cline auth → savi API tiekėjai → OpenAI Compatible: Base URL, API Key, Model ID; parametras -P/--provider parenka tiekėją

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```bash
cline auth
# API Provider: OpenAI Compatible
# Base URL:     https://api.ailoot.ai/v1
# API Key:      sk-...
# Model ID:     claude-sonnet-5-5
cline "Paleisk testus ir ištaisyk klaidas"
```

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Base URL / API Key / Model ID laukai aprašyti Cline dokumentacijoje, skirtoje OpenAI Compatible. Tikslūs cline auth vediklio punktų pavadinimai CLI dokumentacijoje nepateikti — tikrinkite ekrane.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/cline-cli/)[Programos dokumentacija ↗](https://docs.cline.bot/provider-config/openai-compatible)

CJ

### [Copilot, skirtas JetBrains](https://ailoot.ai/docs/lt/integrations/copilot-jetbrains-byok/)

Redaktoriaus plėtinys

Tikrinama

OpenAI Chat

Savas modelio adresas JetBrains IDE Copilot aplinkoje.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/copilot-jetbrains-byok/)

#### Kur nustatyti

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

#### Konfigūracija

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

#### Svarbu

GitHub patvirtina pasirinktinių galinių taškų palaikymą. Oficialioje ekrano nuotraukoje matomi Provider Name, API Key ir API Type: Chat Completions, tačiau nėra URL pavyzdžio. Todėl čia nepateikiama paruošta kopijuoti Ailoot konfigūracija. Dokumentuota alternatyva šioje IDE yra JetBrains AI Assistant. URL reikalavimus išsiaiškinkite su oficialia papildinio pagalba.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/copilot-jetbrains-byok/)[Programos dokumentacija ↗](https://github.blog/changelog/2026-07-14-github-copilot-for-jetbrains-expands-byok-capabilities/)

Cu

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

Kodo redaktorius

Tikrinama

OpenAI Chat

Cursor redaktorius: savas OpenAI adresas pokalbiui.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/cursor/)

#### Kur nustatyti

Cursor Settings → Models → API Keys → OpenAI API Key + jungiklis „Override OpenAI Base URL“; tada pridėkite modelio ID prie savų modelių.

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

```text
OpenAI API Key:            sk-...
Override OpenAI Base URL:  https://api.ailoot.ai/v1
Savas modelis:               gpt-6.1-sol  (pridėti, įjungti, pasirinkti pokalbyje)
```

Modelio pavyzdys: `gpt-6.1-sol`

#### Svarbu

Dabartinėje oficialioje Cursor dokumentacijoje savas adresas neaprašytas: išvardyti tik OpenAI/Anthropic/Google/Azure/Bedrock raktai, nurodyta, kad savi raktai veikia tik pokalbyje (Tab lieka su Cursor modeliais) ir visos užklausos siunčiamos per Cursor serverius (adresas turi būti viešas — api.ailoot.ai yra viešas). Adreso jungiklis yra sąsajoje, tačiau Cursor forume pranešama apie klaidas: jis taikomas visiems modeliams, Agent režimas gali nenaudoti savo rakto, kai kuriose 3.15.x versijose laukas nepriima įvesties.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/cursor/)[Programos dokumentacija ↗](https://cursor.com/help/models-and-usage/api-keys)

OT

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

Obsidian papildinys

Tikrinama

OpenAI Chat

Teksto generavimas Obsidian užrašuose pagal šablonus.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/obsidian-text-generator/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `gpt-6.1-sol`

#### Svarbu

Papildinio dokumentacijoje minimas Custom tiekėjas, tačiau neaprašytas adreso laukas ir jo formatas; nustatymai pateikti pagal papildinio sąsają — palyginkite su nustatymų langu.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/obsidian-text-generator/)[Programos dokumentacija ↗](https://docs.text-gen.com/)

Pe

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

Kodo redaktorius

Tikrinama

OpenAI Chat

PearAI redaktorius, paremtas VS Code.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/pearai/)

#### Kur nustatyti

Cmd/Ctrl+Shift+P → Open config.json → įrašas models\[\] (PearAI — Continue atšaka).

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Oficialios PearAI dokumentacijos patikrinti nepavyko (dokumentacijos svetainė neprieinama), saugykla seniai neatnaujinta. Konfigūracijos forma paimta pagal Continue pavyzdį — patikrinkite programoje.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/pearai/)[Programos dokumentacija ↗](https://github.com/trypear/pearai-app/issues/122)

VS

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

Kodo redaktorius

Tikrinama

OpenAI Chat

Savas tiekėjas Visual Studio Copilot Chat aplinkoje.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/visual-studio-2026/)

#### Kur nustatyti

Chat → modelio pasirinkimas → Manage models → Add custom model → OpenAI (custom endpoint) tiekėjas → adresas, raktas, modelis.

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `gpt-6.1-sol`

#### Svarbu

Visual Studio tinklaraštis (29.09.2026) paskelbė savus OpenAI ir Ollama adresus VS 2026 Stable, tačiau dokumentacijos puslapyje vis dar aprašomi tik OpenAI/Anthropic/Google raktai be adreso lauko, todėl laukų pavadinimai ir adreso forma dar nepatvirtinti. Tik pokalbis; neprieinama Copilot Business/Enterprise planuose.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/visual-studio-2026/)[Programos dokumentacija ↗](https://devblogs.microsoft.com/visualstudio/visual-studio-september-update-power-your-workflow-with-your-model/)

Vo

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

Kodo redaktorius

Tikrinama

OpenAI Chat

Atvirojo kodo redaktorius, paremtas VS Code; kūrimas sustabdytas.

[Plačiau →](https://ailoot.ai/docs/lt/integrations/void/)

#### Kur nustatyti

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

#### Konfigūracija

Prieš paleisdami iškvieskite GET /v1/models su savo Ailoot raktu. Pasirinkite tikslų modelio ID, kurio metodai apima POST /v1/chat/completions, ir naudokite jį konfigūracijoje. Agentams taip pat patikrinkite įrankių palaikymą ir jūsų kliento versijai reikalingas funkcijas.

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

Modelio pavyzdys: `claude-sonnet-5-5`

#### Svarbu

Nustatymas paimtas iš Void pradinio kodo, o ne vartotojo dokumentacijos. Void saugykla archyvuota, redaktorius nebekuriamas — tiks tik tiems, kurie jau jį naudoja.

[Visa instrukcija →](https://ailoot.ai/docs/lt/integrations/void/)[Programos dokumentacija ↗](https://github.com/voideditor/void/blob/main/src/vs/workbench/contrib/void/common/voidSettingsTypes.ts)

Nieko nerasta. Jei programa leidžia naudoti savą OpenAI arba Anthropic API adresą, greičiausiai ji veiks — [štai ką nurodyti](https://ailoot.ai/docs/lt/keys/).

## Kol kas netinka

Šiose programose negalima nurodyti savo API adreso. Šalia pateiktos alternatyvos.

| Programa | Kodėl netinka | Kuo pakeisti |
| --- | --- | --- |
| **Cursor CLI (cursor-agent)** | Veikia tik su Cursor modeliais, savo API adreso nustatyti negalima. | Claude Code, Codex CLI arba opencode |
| **Auggie CLI (Augment Code)** | Prisijungiama per Augment paskyrą, išorinio tiekėjo nurodyti negalima. | Claude Code arba opencode |
| **Windsurf / Devin Desktop** | Priima tik Anthropic raktą atskiriems Claude modeliams, savo adreso nustatyti negalima. | Cline, Roo Code arba Kilo Code VS Code aplinkoje |
| **Kiro** | Nėra savo rakto ir API adreso nustatymo. | Cline arba Roo Code |
| **Google Antigravity (IDE)** | Nėra oficialaus savo tiekėjo nustatymo; trečiųjų šalių pataisų nerekomenduojame. | Antigravity CLI arba Gemini CLI |
| **Visual Studio su Copilot Business arba Enterprise** | Šiuose Copilot planuose savi modeliai neprieinami. | Asmeninis Copilot planas — Visual Studio 2026 kortelė |
| **Cursor Tab automatinis užbaigimas** | Visada veikia su Cursor modeliais, net naudojant savo raktą. | Cursor pokalbis nustatomas atskirai — Cursor kortelė |
| **Enchanted** | Veikia tik su Ollama API. | Open WebUI arba Chatbox |
| **Smart Connections (Obsidian)** | Išoriniai API prieinami tik mokamame Smart Chat Pro. | Obsidian Copilot |
| **Witsy, 5ire** | Neradome oficialaus savo API adreso aprašymo. | Cherry Studio arba Jan |
| **Make: integruotas OpenAI modulis** | Jungiasi tik prie OpenAI paskyros. | HTTP modulis → Make a request — Make kortelė |
| **Zapier: ChatGPT (OpenAI) programa** | Nėra lauko savam adresui. | Webhooks by Zapier → Custom Request — Zapier kortelė |
| **Home Assistant: OpenAI Conversation** | Integruota integracija veikia tik su OpenAI adresu. | Extended OpenAI Conversation iš HACS — Home Assistant kortelė |
| **aiogram, python-telegram-bot, grammY, Telegraf** | Robotų karkasai patys nesijungia prie modelių. | OpenAI arba Anthropic SDK roboto viduje — Telegram roboto kortelė |

## API prijungimas prie programavimo įrankių

### Kur kliento programoje įvesti API adresą ir raktą?

Agentai, redaktoriai, pokalbių programos ir SDK, priimantys Ailoot raktą. Mygtukas „Nustatyti“ parodys, kur įrašyti adresą ir raktą, bei paruoštą konfigūraciją, kurią galima nukopijuoti.

Prijunkite Ailoot prie Claude Code, OpenCode, Hermes arba savo programos.

## Įmonė ir jos projektų portfelis

Įmonė ir jos projektų portfelis: milijonai klientų; mėnesio pardavimai siekia milijardus.

## Pirkite žetonus su nuolaida.

Prenumeratos nuolaida reguliariam darbui. Kodai — iki 50% žetonų pirkimui.

Prenumerata

Pasirinkite planą su nuolaida reguliarioms užklausoms.

Nuolaidos kodas iki 50%

Įveskite kodą perkant. Kaina perskaičiuojama pagal galiojančios akcijos sąlygas.

Išlaidos istorijoje

Kiekvienai užklausai išsaugomi modelis, žetonai ir suma.

[Pasirinkti prenumeratą](https://ailoot.ai/docs/lt/billing/subscriptions/) · [Peržiūrėti modelių kainas](https://ailoot.ai/models/lt/)

## Prijunkite API prie produkto, kurį parduodate.

SaaS, programos ir botai pagal Ailoot ofertą bei licencijos sutartį. Perpardavimui paprašykite perpardavėjo licencijos.

Komercinė programa

Teksto, vaizdų, video ir garso kūrimą integruokite į mokamas paslaugos funkcijas.

Perpardavėjo licencija

Atsiųskite projekto aprašymą ir prieigos schemą. Paprašykite rašytinių naudojimo ir perpardavimo sąlygų.

Dokumentai svetainėje

Oferta, licencijos sutartis ir duomenų tvarkymo politika prieinamos prieš prisijungiant.

[Paprašyti perpardavėjo licencijos](mailto:support@ailoot.ai) · [Oferta ir licencijos sutartis](https://ailoot.ai/legal/offer?lang=lt)

## Klausimai

Kokį kliento formatą pasirinkti?

Pasirinkite jūsų kliento palaikomą OpenAI, Anthropic arba Gemini formatą. Ailoot modelio kortelėje patikrinkite suderinamą API metodą ir modelio ID; vieno formato palaikymas nereiškia, kad kiekvienas modelis palaiko visus formatus.

Ką reikia nustatyti kliente?

Nustatykite Ailoot API raktą, API adresą ir su kliento metodu suderinamą modelio ID. OpenAI SDK naudoja https://api.ailoot.ai/v1, o Anthropic ir Gemini SDK naudoja https://api.ailoot.ai. Išlaikykite užklausos laukus, nurodytus to formato pavyzdyje.

Kaip išsiųsti pirmąją API užklausą?

Sukurkite Ailoot API raktą. OpenAI SDK nustatykite adresą https://api.ailoot.ai/v1, o Anthropic ir Gemini SDK – https://api.ailoot.ai. GET /v1/models yra nemokama užklausa, pateikianti jūsų raktui prieinamų modelių sąrašą; tada naudokite pasirinkto modelio ir API metodo pavyzdį.

Ką patikrinti, jei prijungtas klientas neveikia?

Patikrinkite, ar klientas siunčia numatytą OpenAI, Anthropic arba Gemini formatą į atitinkamą API adresą su jūsų Ailoot API raktu. Patikrinkite modelio ID ir metodą, tada palyginkite gautą klaidą su kliento vadovu. Išsiųskite klaidą ir užklausos ID adresu support@ailoot.ai, neatskleisdami savo rakto.

Ar Ailoot galima naudoti mokamame produkte?

Taip. Prijunkite API prie SaaS, programos ar boto pagal Ailoot ofertą ir licencijos sutartį. Perpardavimui paprašykite rašytinių sąlygų ir projekto perpardavėjo licencijos.

Kaip pateikti prašymą dėl perpardavėjo licencijos?

Parašykite adresu support@ailoot.ai, ką daro jūsų produktas, kas juo naudojasi ir kaip suteikiate prieigą. Paprašykite perpardavėjo licencijos ir rašytinių sąlygų jūsų projektui.

## Ailoot · Įmonė ir jos projektų portfelis





Ailoot remiasi sukaupta veiklos patirtimi, plačia klientų baze, stabiliomis paslaugomis ir nuolatine KPI kontrole.





Įmonė ir jos projektų portfelis: milijonai klientų; mėnesio pardavimai siekia milijardus.





Ailoot šią veiklos patirtį pritaiko teikdama API prieigą prie DI funkcijų klientų produktuose, agentuose, programose ir automatizavimo sprendimuose.