Source: https://ailoot.ai/integrations/de-ch/
Canonical: https://ailoot.ai/integrations/de-ch/
Language: de-ch

[Integrationen](https://ailoot.ai/docs/de-ch/integrations/) 

# Verbinden Sie Ailoot mit Ihren bevorzugten Werkzeugen — API-Preise und Client-Einrichtung — Deutsch (Schweiz)

Agenten, Editoren, Chats und SDKs, die den Ailoot-Schlüssel akzeptieren. «Einrichten» zeigt, wo Sie Adresse und Schlüssel eingeben, und eine fertige Konfiguration zum Kopieren.

**85**Anwendungen

**77**bereit

**8**werden geprüft

 Anwendungssuche 

## Agenten im Terminal

Coding-Agenten und CLIs: schreiben Code, führen Befehle aus und bearbeiten Dateien.

CC

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

Terminalagent

Anthropic Messages

Anthropic-Agent im Terminal: schreibt Code, bearbeitet Dateien und führt Befehle aus.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/claude-code/)

#### Konfigurationsort

Umgebungsvariablen oder "env"-Block in ~/.claude/settings.json (für ein einzelnes Projekt: .claude/settings.local.json); VS-Code-Erweiterung: claudeCode.environmentVariables; Prüfung: Befehl /status

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Adresse ohne /v1: Claude Code ergänzt /v1/messages selbst. ANTHROPIC\_AUTH\_TOKEN wird als Authorization: Bearer gesendet, ANTHROPIC\_API\_KEY als x-api-key; Ailoot akzeptiert beides. CLAUDE\_CODE\_ENABLE\_GATEWAY\_MODEL\_DISCOVERY=1 lädt unsere Modelle über /v1/models in /model. Bei 400-Fehlern wegen unbekannter Felder: CLAUDE\_CODE\_DISABLE\_EXPERIMENTAL\_BETAS=1. Die Anthropic-Dokumentation unterstützt den Einsatz von Claude Code mit Nicht-Claude-Modellen über ein Gateway nicht, obwohl unser /v1/messages diese bedient; wir empfehlen Claude-Modelle. Remote Control und Spracheingabe sind bei Verwendung eines Gateways nicht verfügbar.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/claude-code/)[Anwendungsdokumentation ↗](https://code.claude.com/docs/en/llm-gateway-connect)

OC

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

Terminalagent

OpenAI Responses

OpenAI-Agent für das Terminal, verwendet das Responses-Format.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/openai-codex-cli/)

#### Konfigurationsort

~/.codex/config.toml (nur die Benutzerdatei: In projektbezogenen .codex/config.toml werden model\_provider/model\_providers ignoriert); Schlüssel: Variable aus env\_key

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/responses und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

Codex verwendet ausschliesslich die OpenAI Responses API (die Dokumentation nennt nur wire\_api = "responses"); deshalb ist unser /v1/responses erforderlich. Die Anbieter-IDs openai, ollama und lmstudio sind reserviert. Alternative: openai\_base\_url = "https://api.ailoot.ai/v1" für den integrierten Anbieter openai. Ailoot liefert Codex die Modellliste als Codex-Manifest (GET /v1/models mit client\_version). Wählen Sie ein bestimmtes Modell, für das der Katalog das Format OpenAI Responses ausweist. Im Snapshot vom 2026-09-30 unterstützt gemini-3.6-flash OpenAI Chat, Anthropic Messages und Gemini, aber kein Responses; dieses Modell eignet sich daher nicht für Codex. Prüfen Sie die Formate auf der Modellkarte, nicht anhand des Familiennamens.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/openai-codex-cli/)[Anwendungsdokumentation ↗](https://learn.chatgpt.com/docs/config-file/config-advanced)

HA

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

Terminalagent

OpenAI ChatOpenAI ResponsesAnthropic Messages

Nous-Research-Agent mit Gedächtnis und Skills für das Terminal.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/hermes-agent/)

#### Konfigurationsort

hermes model → «Custom endpoint (self-hosted / VLLM / etc.)» oder ~/.hermes/config.yaml (Abschnitt model oder Wörterbuch providers)

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

`~/.hermes/config.yaml`

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

# mehrere Formate gleichzeitig — benannte Provider:
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

# in der Sitzung: /model custom:claude-sonnet-5-5
```

Der Schlüssel wird aus der Variablen gelesen: `AILOOT_API_KEY` — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # in ~/.zshrc oder ~/.bashrc eintragen
```

```powershell
setx AILOOT_API_KEY "sk-..."   # anschliessend das Terminal neu starten
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

transport: chat\_completions (OpenAI Chat), anthropic\_messages (Anthropic Messages) oder codex\_responses (OpenAI Responses). LLM\_MODEL in .env wird nicht mehr verwendet; OPENAI\_BASE\_URL gilt nur für den Anbieter openai-api. Bei anthropic\_messages geben Sie die Adresse ohne /v1 an — das Anthropic SDK ergänzt /v1/messages selbst. Hilfsaufgaben (Bilderkennung, Verlaufskomprimierung) gehen standardmässig an dasselbe Hauptmodell.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/hermes-agent/)[Anwendungsdokumentation ↗](https://hermes-agent.nousresearch.com/docs/integrations/providers)

Op

### [OpenClaw](https://ailoot.ai/docs/de-ch/integrations/openclaw/)

Terminalagent

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Persönlicher KI-Assistent auf dem eigenen Computer: Chats, Messenger, Aufgaben.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/openclaw/)

#### Konfigurationsort

OpenClaw-Konfiguration (~/.openclaw/openclaw.json) → models.providers.\<id\>; Standardmodell: agents.defaults.model.primary; sichere Änderung: openclaw config set models.providers.\<id\> '\<json\>' --strict-json --merge

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Der Schlüssel wird aus der Variablen gelesen: `AILOOT_API_KEY` — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # in ~/.zshrc oder ~/.bashrc eintragen
```

```powershell
setx AILOOT_API_KEY "sk-..."   # anschliessend das Terminal neu starten
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

api-Adapter: openai-completions (Standard bei gesetztem baseUrl), openai-responses (nur wenn der Server /v1/responses unterstützt — Ailoot unterstützt es), anthropic-messages, google-generative-ai und weitere. In OpenClaw-Beispielen hat baseUrl für anthropic-messages kein /v1. OpenClaw kann Bilder übermitteln, wenn input des Modells "image" enthält. In den Claude-Beispielen bleibt es bei Text: Im Katalogsnapshot vom 2026-09-30 weisen diese Methoden keine image-Eingaben aus. Fügen Sie "image" nur für ein bestimmtes Modell hinzu, dessen aktuelle Katalogkarte Bildeingaben im gewählten API-Format ausweist. gemini-3.6-flash weist in diesem Snapshot beispielsweise image-Eingaben für OpenAI Chat aus; die tatsächliche Unterstützung hängt von Modellkarte und Format ab. Der Hauptkonfigurationspfad stammt aus der allgemeinen OpenClaw-Praxis; die gelesene Seite nennt auch ~/.openclaw/agents/\<agentId\>/agent/models.json.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/openclaw/)[Anwendungsdokumentation ↗](https://docs.openclaw.ai/gateway/config-tools/custom-providers)

Op

### [opencode](https://ailoot.ai/docs/de-ch/integrations/opencode/)

Terminalagent

OpenAI Chat

Offener Terminalagent mit beliebigen OpenAI-kompatiblen Anbietern.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/opencode/)

#### Konfigurationsort

opencode.json (im Projekt oder ~/.config/opencode/opencode.json) → provider.\<id\>; Schlüssel über /connect oder "apiKey": "{env:VAR}"

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Der Schlüssel wird aus der Variablen gelesen: `AILOOT_API_KEY` — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # in ~/.zshrc oder ~/.bashrc eintragen
```

```powershell
setx AILOOT_API_KEY "sk-..."   # anschliessend das Terminal neu starten
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Das Paket @ai-sdk/openai-compatible verwendet /v1/chat/completions. Für Modelle, die /v1/responses benötigen, nennt die opencode-Dokumentation das Paket @ai-sdk/openai. Ein Anthropic-kompatibler Anbieter mit eigenem baseURL ist dort nicht beschrieben. Wählen Sie Modelle, für die der aktuelle Katalog OpenAI Chat ausweist. Im Snapshot vom 2026-09-30 unterstützt gemini-3.6-flash dieses Format; prüfen Sie andere Gemini-Modelle auf ihren Karten. Dieser Weg verwendet nicht das native Gemini-Format. Eine Methode im Katalog belegt keinen Live-Test einer bestimmten Client-Version.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/opencode/)[Anwendungsdokumentation ↗](https://opencode.ai/docs/providers/)

QC

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

Terminalagent

OpenAI ChatAnthropic MessagesGemini

Konsolenagent des Qwen-Teams: OpenAI-, Anthropic- und Gemini-Formate.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/qwen-code/)

#### Konfigurationsort

Variablen OPENAI\_API\_KEY / OPENAI\_BASE\_URL / OPENAI\_MODEL, Befehl /auth innerhalb der Sitzung oder ~/.qwen/settings.json (modelProviders + security.auth.selectedType)

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```bash
export AILOOT_API_KEY="sk-..."
# schneller Weg
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"
  }
}
```

Der Schlüssel wird aus der Variablen gelesen: `AILOOT_API_KEY` — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # in ~/.zshrc oder ~/.bashrc eintragen
```

```powershell
setx AILOOT_API_KEY "sk-..."   # anschliessend das Terminal neu starten
```

Beispielmodell: `qwen3.8-max`

#### Wichtig

Protokolltypen: openai (Chat Completions), anthropic, gemini, vertex-ai. Bei openai enthält baseUrl /v1. Das Dokumentationsbeispiel für anthropic und gemini enthält kein baseUrl; daher empfehlen wir die openai-Variante. Wählen Sie für den openai-Typ ein Modell mit OpenAI-Chat-Format im Katalog: gemini-3.6-flash unterstützt es. Andere Gemini-Modelle können andere Formate haben — prüfen Sie die Karte des genauen Modells. Die settings.json-Variante liest den Schlüssel aus AILOOT\_API\_KEY (Feld envKey): Setzen Sie die Variable mit export AILOOT\_API\_KEY=sk-... oder mit der Zeile AILOOT\_API\_KEY=sk-... in ~/.qwen/.env; sonst startet Qwen Code mit leerem Schlüssel und erhält 401.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/qwen-code/)[Anwendungsdokumentation ↗](https://qwenlm.github.io/qwen-code-docs/en/users/configuration/auth/)

GC

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

Terminalagent

Gemini

Google-Agent im Terminal mit nativem Gemini-Format.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/gemini-cli/)

#### Konfigurationsort

Umgebungsvariablen GEMINI\_API\_KEY und GOOGLE\_GEMINI\_BASE\_URL; Anmeldemethode: ~/.gemini/settings.json → security.auth.selectedType = "gemini-api-key"; Modell: GEMINI\_MODEL oder Schalter -m

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1beta/models/{model}:generateContent und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `gemini-3.8-flash`

#### Wichtig

Adresse ohne /v1beta: Das SDK ergänzt /v1beta/models/{model}:generateContent selbst. Die Adresse muss HTTPS verwenden. Der Schlüssel wird im Header x-goog-api-key gesendet — Ailoot akzeptiert ihn. Geeignet sind nur Modelle, für die im Katalog das Gemini-Format angegeben ist. Prüfen Sie vor dem Start, ob die genaue ID und diese Methode für Ihren Schlüssel verfügbar sind. Eine kostenpflichtige Gemini-Antwort liefert Ailoot nach der Kostenberechnung vollständig, nicht Wort für Wort; bei langen Antworten erscheint der Text deshalb nicht sofort.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/gemini-cli/)[Anwendungsdokumentation ↗](https://geminicli.com/docs/reference/configuration/)

KC

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

Terminalagent

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Moonshot-Konsolenagent für die Arbeit mit Code.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/kimi-cli/)

#### Konfigurationsort

~/.kimi/config.toml (Abschnitte providers und models, default\_model); /login unterstützt nur Moonshot-Plattformen — eine eigene Adresse wird manuell in der Datei festgelegt

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `kimi-k3`

#### Wichtig

Typen: openai\_legacy (Chat Completions, base\_url mit /v1), openai\_responses (Responses, mit /v1), anthropic (ohne /v1), gemini (base\_url als Google-Wurzeladresse, bei uns https://api.ailoot.ai). Das Werkzeug SearchWeb funktioniert nur mit Moonshots eigener Plattform; FetchURL wechselt bei einer anderen API-Adresse auf lokales Laden.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/kimi-cli/)[Anwendungsdokumentation ↗](https://moonshotai.github.io/kimi-cli/en/configuration/providers.html)

Cr

### [Crush](https://ailoot.ai/docs/de-ch/integrations/crush/)

Terminalagent

OpenAI ChatAnthropic Messages

Terminalagent von Charm mit Konfiguration in crushrc.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/crush/)

#### Konfigurationsort

crushrc (Bash-Konfiguration): ./.crushrc, ./crushrc oder ~/.config/crush/crushrc; das alte Format crush.json ist veraltet, funktioniert aber noch

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

`~/.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-Format für Claude: Adresse ohne /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
```

Der Schlüssel wird aus der Variablen gelesen: `AILOOT_API_KEY` — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # in ~/.zshrc oder ~/.bashrc eintragen
```

```powershell
setx AILOOT_API_KEY "sk-..."   # anschliessend das Terminal neu starten
```

Beispielmodell: `deepseek-v4-pro`

#### Wichtig

Typ openai-compat: OpenAI-Chat-Format, Adresse mit /v1. Typ anthropic: Messages-Format, Adresse ohne /v1 — Crush übergibt sie an anthropic-sdk-go, das /v1/messages selbst ergänzt. Das Beispiel im Crush-README mit /v1 würde /v1/v1/messages und den Fehler 404 ergeben. Der Schlüssel wird im Header x-api-key gesendet; Ailoot akzeptiert ihn. Ist die Modellliste leer, lädt der Anbieter openai-compat sie selbst aus /v1/models. crushrc wird als Code ausgeführt: Starten Sie Crush nicht in fremden Ordnern mit dieser Datei. Im Beispiel hat Claude supports-images = false: Der Katalogsnapshot vom 2026-09-30 weist für das gewählte Messages-Format nur Text aus. Unterstützt Ihre Crush-Version dieses Flag, aktivieren Sie es nur für ein Modell, dessen aktuelle Katalogkarte image-Eingaben im gewählten API-Format ausweist; ein Client-Flag allein verleiht dem Modell keine Bildunterstützung.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/crush/)[Anwendungsdokumentation ↗](https://github.com/charmbracelet/crush#custom-providers)

Ai

### [Aider](https://ailoot.ai/docs/de-ch/integrations/aider/)

Terminalagent

OpenAI Chat

Pair Programming mit KI direkt im Git-Repository.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/aider/)

#### Konfigurationsort

Variablen OPENAI\_API\_BASE und OPENAI\_API\_KEY, Schalter --model openai/\<Modell\>

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `openai/deepseek-v4-pro`

#### Wichtig

Das Präfix openai/ ist erforderlich: Damit sendet Aider (über LiteLLM) Anfragen an das OpenAI-kompatible /v1/chat/completions. Bei Aider unbekannten Modellen warnt es vor einem unbekannten Kontextfenster — dies ist kein Fehler. Eine Anthropic-Adresse mit eigener base URL wird auf dieser Dokumentationsseite nicht beschrieben.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/aider/)[Anwendungsdokumentation ↗](https://aider.chat/docs/llms/openai-compat.html)

Go

### [Goose](https://ailoot.ai/docs/de-ch/integrations/goose/)

Terminalagent

OpenAI ChatAnthropic Messages

Offener Agent für Terminal und Computer mit MCP-Erweiterungen.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/goose/)

#### Konfigurationsort

goose configure → Custom Providers → Add A Custom Provider oder JSON in ~/.config/goose/custom\_providers/ (Windows: %APPDATA%\\Block\\goose\\config\\custom\_providers\\); alternativ integrierter OpenAI-Anbieter mit OPENAI\_HOST/OPENAI\_BASE\_PATH

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

# Variante mit dem integrierten OpenAI-Provider:
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"
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Engines eigener Anbieter: openai, anthropic, ollama. Im Goose-Beispiel ist base\_url für engine openai der vollständige Pfad bis /v1/chat/completions. Beim integrierten Anbieter ist OPENAI\_HOST die Wurzel ohne Pfad, OPENAI\_BASE\_PATH der Pfad (standardmässig v1/chat/completions). Einen Schlüssel in config.yaml ignoriert Goose — verwenden Sie eine Variable oder den Schlüsselbund. Das Repository ist nach aaif-goose/goose umgezogen.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/goose/)[Anwendungsdokumentation ↗](https://github.com/aaif-goose/goose/blob/main/documentation/docs/getting-started/providers.md)

FD

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

Terminalagent

OpenAI ChatOpenAI ResponsesAnthropic Messages

Factory-Agent für das Terminal mit eigenen Modellen.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/factory-droid/)

#### Konfigurationsort

~/.factory/settings.json → Array customModels; Modellauswahl: Befehl /model, Bereich «Custom models»

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Der Schlüssel wird aus der Variablen gelesen: `AILOOT_API_KEY` — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # in ~/.zshrc oder ~/.bashrc eintragen
```

```powershell
setx AILOOT_API_KEY "sk-..."   # anschliessend das Terminal neu starten
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

provider: anthropic = Messages API (baseUrl wie bei Anthropic, ohne /v1), openai = Responses API (mit /v1), generic-chat-completion-api = Chat Completions (mit /v1). Bei anthropic wird der Schlüssel standardmässig in x-api-key gesendet (Ailoot akzeptiert ihn); "authMode": "bearer" wechselt auf Authorization. Die Schlüssel bleiben lokal. Factory testet nur die offiziellen APIs von Anthropic und OpenAI vollständig.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/factory-droid/)[Anwendungsdokumentation ↗](https://docs.factory.com/model-independence/byok)

Am

### [Amp](https://ailoot.ai/docs/de-ch/integrations/amp/)

Terminalagent

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Coding-Agent Amp mit flexiblem Modellrouting.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/amp/)

#### Konfigurationsort

Einstellungen → Model Routing → Add → Custom URL (oder workspace Model Routing für Teams); im Terminal: amp config model-providers (list, test, set-priority, edit-router…)

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Zweite Verbindung für GPT:
  Format:   responses
  Base URL: https://api.ailoot.ai/v1
  API key:  sk-...
  Model mapping:
    openai/gpt-5.6-sol -> gpt-5.6-sol

Prüfung: amp config model-providers check-access --provider-model anthropic/claude-fable-5
```

Beispielmodell: `claude-fable-5`

#### Wichtig

Custom-URL-Formate: chat-completions (\<base\>/chat/completions), responses (\<base\>/responses), anthropic-messages (\<base\>/v1/messages, /v1 wird nicht doppelt angefügt), google-genai (\<base\>/models/\<model\>:streamGenerateContent). Der Schlüssel wird als Authorization: Bearer übermittelt. Das Mapping verwendet kanonische Amp-IDs im Format provider/model; der Pfeil bestimmt die an uns gesendete ID. Modelle, die die Verbindung nicht abdeckt, bedient Amp selbst mit seinen eigenen Credits. Die Dokumentation verlangt, dass der eigene Host von Amp aus erreichbar ist — die Adresse ist öffentlich, diese Bedingung ist erfüllt.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/amp/)[Anwendungsdokumentation ↗](https://ampcode.com/docs/markdown/customize/model-routing)

AI

### [AIChat](https://ailoot.ai/docs/de-ch/integrations/aichat/)

Terminalagent

OpenAI ChatAnthropic MessagesGemini

Universeller Terminalchat mit Rollen, Sitzungen und RAG.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/aichat/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `deepseek-v4-pro`

#### Wichtig

Im AIChat-Konfigurationsbeispiel wird api\_base für claude mit /v1, für gemini mit /v1beta angegeben; dasselbe gilt für Ailoot. Die drei Clients bieten Zugriff auf alle drei Ailoot-Formate: OpenAI, Anthropic und Gemini.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/aichat/)[Anwendungsdokumentation ↗](https://github.com/sigoden/aichat/blob/main/config.example.yaml)

CC

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

Terminalagent

OpenAI Chat

Continue-Konsolenversion für Agenten und Automatisierung.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/continue-cli/)

#### Konfigurationsort

Continue-YAML-Konfiguration (config.yaml), per Schalter --config \<path\> an die CLI übergeben

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

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

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Für OpenAI-kompatible Dienste verwendet Continue provider: openai und apiBase mit /v1. Erweiterung und CLI verwenden dasselbe Konfigurationsformat; die Datei wird mit --config übergeben.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/continue-cli/)[Anwendungsdokumentation ↗](https://docs.continue.dev/customize/model-providers/top-level/openai)

Fo

### [ForgeCode](https://ailoot.ai/docs/de-ch/integrations/forge/)

Terminalagent

OpenAI Chat

Terminalagent mit konfigurierbaren Anbietern.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/forge/)

#### Konfigurationsort

forge provider login → OpenAI-compatible (empfohlener Weg); veralteter Weg: .env mit OPENAI\_URL und OPENAI\_API\_KEY sowie model in forge.yaml

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```bash
# empfohlen:
forge provider login   # OpenAI-compatible auswählen, https://api.ailoot.ai/v1 und sk-... eingeben

# veralteter Weg (.env):
OPENAI_API_KEY=sk-...
OPENAI_URL=https://api.ailoot.ai/v1

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

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Die Einrichtung über .env ist als veraltet gekennzeichnet: Beim ersten Start übernimmt Forge die Variablen in seinen eigenen Dateispeicher. Die genauen Beschriftungen des Assistenten provider login stehen nicht im README.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/forge/)[Anwendungsdokumentation ↗](https://github.com/tailcallhq/forgecode)

GC

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

Terminalagent

OpenAI ChatAnthropic Messages

Copilot im Terminal mit eigenen Modellen.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/github-copilot-cli/)

#### Konfigurationsort

Umgebungsvariablen COPILOT\_PROVIDER\_BASE\_URL, COPILOT\_PROVIDER\_TYPE, COPILOT\_PROVIDER\_API\_KEY, COPILOT\_MODEL (oder Schalter --model)

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```bash
export AILOOT_API_KEY="sk-..."
unset COPILOT_PROVIDER_TYPE
# OpenAI-kompatibler Modus
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-Modus
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
```

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

Typen: openai (Standard, jeder OpenAI-kompatible Server), azure, anthropic. Das Modell muss Werkzeugaufrufe und Streaming unterstützen. COPILOT\_PROVIDER\_WIRE\_API dient der Protokollauswahl; mögliche Werte werden auf der Seite nicht genannt. Limits können über COPILOT\_PROVIDER\_MAX\_PROMPT\_TOKENS / MAX\_OUTPUT\_TOKENS gesetzt werden.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/github-copilot-cli/)[Anwendungsdokumentation ↗](https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/use-byok-models)

Gp

### [gptme](https://ailoot.ai/docs/de-ch/integrations/gptme/)

Terminalagent

OpenAI Chat

Persönlicher Terminalagent: Code, Dateien, Browser.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/gptme/)

#### Konfigurationsort

~/.config/gptme/config.toml → \[\[providers\]\]; das Modell wird als \<provider\>/\<model\> gewählt

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Jeder OpenAI-kompatible Server; der Schlüssel wird zuerst in api\_key gesucht, danach in api\_key\_env, danach in \<NAME\>\_API\_KEY. Anbieterliste: gptme-util providers list.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/gptme/)[Anwendungsdokumentation ↗](https://github.com/gptme/gptme/blob/master/docs/providers-custom.rst)

KC

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

Terminalagent

OpenAI ChatOpenAI ResponsesAnthropic Messages

Kilo-Code-Konsolenagent.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/kilo-code-cli/)

#### Konfigurationsort

~/.config/kilo/kilo.jsonc (oder ./kilo.jsonc; auch KILO\_CONFIG) → provider.\<id\>.options.baseURL; in der Erweiterung: Settings → Providers → Custom provider

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Der Schlüssel wird aus der Variablen gelesen: `AILOOT_API_KEY` — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # in ~/.zshrc oder ~/.bashrc eintragen
```

```powershell
setx AILOOT_API_KEY "sk-..."   # anschliessend das Terminal neu starten
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Der Dialog Custom provider bietet eine Protokollauswahl: OpenAI Compatible (Chat Completions), OpenAI Responses, Anthropic Messages. {env:VAR} funktioniert nur in der vertrauenswürdigen globalen Konfiguration (~/.config/kilo); in der projektbezogenen kilo.json wird der Schlüssel aus der Variablen nicht eingesetzt.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/kilo-code-cli/)[Anwendungsdokumentation ↗](https://kilo.ai/docs/code-with-ai/agents/custom-models)

LL

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

Terminalagent

OpenAI ChatOpenAI Responses

Werkzeug für Modellanfragen über die Befehlszeile.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/llm-cli/)

#### Konfigurationsort

Datei extra-openai-models.yaml im llm-Konfigurationsverzeichnis; Schlüssel: llm keys set \<Name\>

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Standardmässig Chat Completions; responses: true stellt das Modell auf /responses um. Bei gesetztem api\_base wird der OpenAI-Schlüssel nicht gesendet — api\_key\_name ist nötig. Dies ist eine CLI für Anfragen, kein Agent.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/llm-cli/)[Anwendungsdokumentation ↗](https://llm.datasette.io/en/stable/other-models.html)

MS

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

Terminalagent

OpenAI Chat

Minimalistischer Agent für Aufgaben im Repository.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/mini-swe-agent/)

#### Konfigurationsort

YAML-Konfiguration des Agenten → Abschnitt model (model\_name, model\_kwargs); der Standardpfad der Konfiguration wird über MSWEA\_MINI\_CONFIG\_PATH geändert

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```yaml
# Ausschnitt der Agentenkonfiguration
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"
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Verwendet LiteLLM: model\_kwargs werden direkt an litellm.completion übergeben. Ohne LiteLLM-Preisregister führt die unbekannte Kostenangabe zu einem Fehler — wir deaktivieren die Kostenverfolgung mit cost\_tracking: "ignore\_errors" (oder MSWEA\_COST\_TRACKING=ignore\_errors). Die Schlüsselübergabe über OPENAI\_API\_KEY ist LiteLLM-Standard; auf der mini-SWE-agent-Seite selbst wird sie nicht gezeigt.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/mini-swe-agent/)[Anwendungsdokumentation ↗](https://github.com/SWE-agent/mini-swe-agent/blob/main/docs/models/local_models.md)

OC

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

Terminalagent

OpenAI Chat

Autonomer Entwicklungsagent für die Befehlszeile.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/openhands-cli/)

#### Konfigurationsort

Ctrl+P → Settings (Anbieter und Modell), Datei ~/.openhands/agent\_settings.json (llm.model / llm.api\_key / llm.base\_url) oder Variablen LLM\_MODEL, LLM\_API\_KEY, LLM\_BASE\_URL mit dem Schalter --override-with-envs

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

`~/.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-..."
# einmalig über Variablen:
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
```

Beispielmodell: `openai/claude-sonnet-5-5`

#### Wichtig

OpenHands verwendet LiteLLM; für einen OpenAI-Proxy verlangt die Dokumentation ein Custom Model im Format openai/\<Modell\> und die Base URL des Proxys. Änderungen über --override-with-envs werden nicht gespeichert. In der Web-Oberfläche: Settings → LLM → Advanced → Custom Model, Base URL, API Key.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/openhands-cli/)[Anwendungsdokumentation ↗](https://docs.openhands.dev/openhands/usage/cli/command-reference)

Pi

### [Pi](https://ailoot.ai/docs/de-ch/integrations/pi/)

Terminalagent

OpenAI ChatAnthropic MessagesGemini

Minimalistischer Coding-Agent für das Terminal.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/pi/)

#### Konfigurationsort

~/.pi/agent/models.json (oder projektbezogene .pi/models.json, nachdem das Projekt als vertrauenswürdig bestätigt wurde); Auswahl: /model

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Der Schlüssel wird aus der Variablen gelesen: `AILOOT_API_KEY` — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # in ~/.zshrc oder ~/.bashrc eintragen
```

```powershell
setx AILOOT_API_KEY "sk-..."   # anschliessend das Terminal neu starten
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Die Pi-Dokumentation erlaubt ausdrücklich OpenAI-, Anthropic- und Google-kompatible Endpoints über models.json; das Beispiel verwendet api: openai-completions. apiKey akzeptiert $NAME/${NAME}, einen Literalwert oder !Befehl. Die Datei wird beim Öffnen von /model neu gelesen.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/pi/)[Anwendungsdokumentation ↗](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/models.md)

Pl

### [Plandex](https://ailoot.ai/docs/de-ch/integrations/plandex/)

Terminalagent

OpenAI Chat

Agent für grosse Aufgaben: Planung, Änderungen in der Sandbox, Übernahme.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/plandex/)

#### Konfigurationsort

plandex models custom (oder \\models custom im REPL) — öffnet die JSON-Datei eigener Modelle und Anbieter

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Der Schlüssel wird aus der Variablen gelesen: `AILOOT_API_KEY` — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # in ~/.zshrc oder ~/.bashrc eintragen
```

```powershell
setx AILOOT_API_KEY "sk-..."   # anschliessend das Terminal neu starten
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Eigene Anbieter funktionieren nur in selbst gehostetem Plandex; in der Cloud sind mit BYO-Schlüsseln nur integrierte Anbieter zulässig. Alle eigenen Anbieter müssen OpenAI-kompatibel sein (Chat Completions). Anschliessend wird das Modell in die eigene model pack aufgenommen.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/plandex/)[Anwendungsdokumentation ↗](https://github.com/plandex-ai/plandex/blob/main/docs/docs/models/custom-models.md)

TA

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

Terminalagent

OpenAI ChatAnthropic Messages

ByteDance-Forschungsagent für Entwicklungsaufgaben.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/trae-agent/)

#### Konfigurationsort

trae\_config.yaml → model\_providers.\<Name\>.base\_url; alternativ Variablen OPENAI\_BASE\_URL / ANTHROPIC\_BASE\_URL in .env

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

In YAML nur Leerzeichen, keine Tabulatoren verwenden. Für das Anthropic-Format: provider: anthropic und ANTHROPIC\_BASE\_URL (das README erklärt nicht genau, ob anthropic /v1 erwartet; verwenden Sie https://api.ailoot.ai).

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/trae-agent/)[Anwendungsdokumentation ↗](https://github.com/bytedance/trae-agent#using-base-url)

Wa

### [Warp](https://ailoot.ai/docs/de-ch/integrations/warp/)

Terminalagent

OpenAI Chat

Terminal mit integriertem Agenten und eigener Modelladresse.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/warp/)

#### Konfigurationsort

Settings → nach «inference endpoint» suchen → Custom inference endpoint: Basis-URL, Schlüssel, Modell-IDs; danach Modell in der Auswahl wählen

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```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
Anschliessend zum Beispiel claude-sonnet-5-5 in der Modellliste auswählen (nicht Auto).
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Nur OpenAI Chat Completions (POST /v1/chat/completions). Die Anfragen laufen über Warp-Server: Der Schlüssel wird lokal gespeichert, aber bei jeder Anfrage an das Warp-Backend übertragen. Auto-Modi und eigene Router verbrauchen immer Warp-Credits; Cloud-Agenten verwenden diesen Endpoint nicht. Verfügbar mit Free und kostenpflichtigen Tarifen für Einzelpersonen und Teams bis zu 10 Personen. Wählen Sie Modelle, für die der aktuelle Katalog OpenAI Chat ausweist. Im Snapshot vom 2026-09-30 unterstützt gemini-3.6-flash dieses Format; prüfen Sie andere Gemini-Modelle auf ihren Karten. Dieser Weg verwendet nicht das native Gemini-Format. Eine Methode im Katalog belegt keinen Live-Test einer bestimmten Client-Version.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/warp/)[Anwendungsdokumentation ↗](https://docs.warp.dev/agents/inference/custom-inference-endpoint/)

## Editoren und IDEs

Erweiterungen und integrierte Assistenten für Codeeditoren.

Cl

### [Cline](https://ailoot.ai/docs/de-ch/integrations/cline/)

Editorerweiterung

OpenAI ChatAnthropic Messages

Autonomer Agent in VS Code und JetBrains: Planung, Änderungen, Befehle.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/cline/)

#### Konfigurationsort

Cline-Panel → Zahnrad (Settings) → API Provider = «OpenAI Compatible» → Felder Base URL, API Key, Model ID. Alternative: API Provider = «Anthropic» → «Use custom base URL» aktivieren.

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```text
OpenAI Compatible (empfohlen):
  API Provider: OpenAI Compatible
  Base URL:     https://api.ailoot.ai/v1
  API Key:      sk-...
  Model ID:     claude-sonnet-5-5   (oder gpt-6.1-sol, deepseek-v4-pro, qwen3.8-max)
  Model Configuration: Context Window und Max Output Tokens — gemäss Modell; Image Support — nur für Modelle, die Bilder erkennen können.

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

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

OpenAI Compatible verwendet /v1/chat/completions, daher die Adresse mit /v1. Die Variante Anthropic verwendet /v1/messages und eine Adresse ohne /v1; ihre Modellliste enthält aber nur Anthropic-Namen — andere Ailoot-Modelle sind über OpenAI Compatible verfügbar. Der Agentenmodus benötigt ein Modell mit Werkzeugaufrufen. Gemini-3.1-Pro-Modelle sind über chat/completions nicht verfügbar (sie unterstützen nur Gemini- und Anthropic-Formate) — wählen Sie hier gemini-3.6-flash.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/cline/)[Anwendungsdokumentation ↗](https://docs.cline.bot/provider-config/openai-compatible)

RC

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

Editorerweiterung

OpenAI ChatAnthropic Messages

Agent in VS Code mit Modi für Code, Architektur und Fehlersuche.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/roo-code/)

#### Konfigurationsort

Roo-Code-Panel → Zahnrad → API Provider = «OpenAI Compatible» → Base URL, API Key, Model; optional Model Configuration (Max Output Tokens, Context Window, Image Support, Computer Use, Preise). Beim Anbieter Anthropic gibt es «Use custom base URL».

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

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

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

Roo Code ruft Werkzeuge nur im OpenAI-Format auf; das Modell muss daher tools in /v1/chat/completions unterstützen. Die Anthropic-Variante verwendet /v1/messages, Adresse ohne /v1.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/roo-code/)[Anwendungsdokumentation ↗](https://roocodeinc.github.io/Roo-Code/providers/openai-compatible/)

KC

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

Editorerweiterung

OpenAI Chat

Agent in VS Code mit Modi und eigenen Modellen.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/kilo-code/)

#### Konfigurationsort

Settings (Zahnrad) → Tab Providers → unten «Custom provider» → Provider ID, Display name, Provider API = «OpenAI Compatible», Base URL, API key, Models (Liste wird aus /v1/models geladen). Die Einstellungen werden in kilo.json gespeichert.

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```text
Provider ID:   ailoot
Display name:  Ailoot
Provider API:  OpenAI Compatible
Base URL:      https://api.ailoot.ai/v1
API key:       sk-...
Models:        aus der Liste auswählen, zum Beispiel claude-sonnet-5-5, gpt-6.1-sol, deepseek-v4-pro
```

Beispielmodell: `deepseek-v4-pro`

#### Wichtig

Kilo fragt {Base URL}/models ab und zeigt die Modellliste selbst an — unser GET /v1/models liefert den gesamten Katalog. Auch die vollständige Adresse .../v1/chat/completions ist möglich. Eigene Header werden unterstützt.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/kilo-code/)[Anwendungsdokumentation ↗](https://kilo.ai/docs/ai-providers/openai-compatible)

Co

### [Continue](https://ailoot.ai/docs/de-ch/integrations/continue/)

Editorerweiterung

OpenAI Chat

Assistent für VS Code und JetBrains: Chat, Änderungen, Agent.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/continue/)

#### Konfigurationsort

Datei ~/.continue/config.yaml (oder Continue-Konfigurationseditor): Eintrag in models\[\] mit provider: openai und apiBase.

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```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   # nur wenn /chat/completions ausdrücklich erzwungen werden soll
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

apiBase muss auf /v1 enden. Bei Namen wie gpt-5 bzw. der o-Serie kann Continue selbst /v1/responses wählen; unsere gpt-\* unterstützen sowohl /v1/responses als auch /v1/chat/completions. useResponsesApi: false erzwingt chat/completions. useLegacyCompletionsEndpoint ist nicht nötig.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/continue/)[Anwendungsdokumentation ↗](https://docs.continue.dev/customize/model-providers/top-level/openai)

Ze

### [Zed](https://ailoot.ai/docs/de-ch/integrations/zed/)

Codeeditor

OpenAI ChatOpenAI ResponsesAnthropic Messages

Schneller Codeeditor mit integriertem Agenten.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/zed/)

#### Konfigurationsort

Agent Settings (agent::OpenSettings) → LLM Providers → Add Provider; oder settings.json → language\_models.openai\_compatible / language\_models.anthropic\_compatible. Schlüssel im Einstellungsfenster (im Systemschlüsselbund gespeichert) oder in der Variablen \<ANBIETER-ID IN GROSSBUCHSTABEN\>\_API\_KEY.

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

Bei openai\_compatible enthält die Adresse /v1 (verwendet /v1/chat/completions; capabilities.chat\_completions = false stellt das Modell auf /v1/responses um). Bei anthropic\_compatible enthält sie kein /v1 (verwendet /v1/messages; Zed sendet den Schlüssel in x-api-key — Ailoot akzeptiert ihn). Standardmässig gelten images = false und parallel\_tool\_calls = false. Zed kann Bilder übermitteln; aktivieren Sie images aber nur für ein bestimmtes Modell, dessen aktuelle Katalogkarte image-Eingaben im gewählten API-Format ausweist. In den GPT- und Claude-Beispielen gilt images = false: Der Snapshot vom 2026-09-30 weist für sie nur Text aus. gemini-3.6-flash weist darin beispielsweise image-Eingaben für OpenAI Chat aus; die tatsächliche Unterstützung hängt von Modellkarte und Format ab. Für Reasoning-Modelle gibt es reasoning\_effort. Die max\_tokens-Werte im Beispiel bezeichnen die Kontextgrösse; genaue Limits stehen im Modellkatalog.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/zed/)[Anwendungsdokumentation ↗](https://zed.dev/docs/ai/use-api-access)

VC

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

Editorerweiterung

OpenAI ChatOpenAI ResponsesAnthropic Messages

Eigener Anbieter in Copilot Chat für VS Code.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/vscode-copilot-byok/)

#### Konfigurationsort

Modellauswahl im Chat → Manage Language Models (Zahnrad) → Add Models → Custom Endpoint → VS Code öffnet chatLanguageModels.json. (Die alte Einstellung github.copilot.chat.customOAIModels ist veraltet.)

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

url ist der VOLLSTÄNDIGE Endpoint-Pfad. apiType-Werte: chat-completions, responses (url .../v1/responses), messages (url .../v1/messages). BYOK funktioniert ohne Copilot-Tarif und ohne GitHub-Anmeldung, aber nur für Chat/Agenten — Inline-Vorschläge bleiben bei Copilot. Organisationsadministratoren (Business/Enterprise) können die BYOK-Richtlinie deaktivieren. Die obigen Tokenlimits sind Beispiele; verwenden Sie Katalogwerte. In diesen Beispielen gilt vision = false: Der Katalogsnapshot vom 2026-09-30 weist für GPT/OpenAI Chat und Claude/Anthropic Messages nur Text aus. Bietet Ihre VS-Code-Version vision an, aktivieren Sie es nur für ein Modell, dessen aktuelle Katalogkarte image-Eingaben im gewählten API-Format ausweist; das Vorhandensein des Client-Felds bestätigt keine Bildunterstützung durch das gewählte Modell.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/vscode-copilot-byok/)[Anwendungsdokumentation ↗](https://code.visualstudio.com/docs/agent-customization/language-models)

JA

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

Codeeditor

OpenAI Chat

Integrierter Assistent der JetBrains-IDEs mit eigenem Schlüssel.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/jetbrains-ai-assistant/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Wählen Sie OpenAI-compatible und tragen Sie https://api.ailoot.ai/v1 als URL sowie Ihren API Key ein. Klicken Sie auf Test Connection, dann auf Apply, und wählen Sie ein Modell in AI Chat. Weisen Sie es für IDE-Funktionen unter Models Assignment zu. Aktivieren Sie Tool calling nur bei einem Modell mit Werkzeugunterstützung; die Codevervollständigung wird separat eingerichtet.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/jetbrains-ai-assistant/)[Anwendungsdokumentation ↗](https://www.jetbrains.com/help/ai-assistant/use-custom-models.html)

Xc

### [Xcode](https://ailoot.ai/docs/de-ch/integrations/xcode/)

Codeeditor

OpenAI Chat

Coding Intelligence in Xcode mit externem Anbieter.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/xcode/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```text
Type:           Internet Hosted
URL:            https://api.ailoot.ai        (OHNE /v1 — Xcode ergänzt /v1/models und /v1/chat/completions selbst)
API Key:        sk-...
API Key Header: x-api-key
Description:    Ailoot
→ anschliessend die Modelle aus der Liste auswählen (zum Beispiel claude-sonnet-5-5, gpt-6.1-sol)
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Apple verlangt, dass der Anbieter Chat Completions unterstützt und auf {URL}/v1/models sowie {URL}/v1/chat/completions antwortet. Ailoot akzeptiert den Schlüssel in x-api-key und Authorization: Bearer (bei gewähltem Header Authorization ergänzt Xcode laut Rückmeldungen das Präfix Bearer selbst). Xcode-Agenten werden separat eingerichtet und sind nicht Teil dieser Anleitung.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/xcode/)[Anwendungsdokumentation ↗](https://developer.apple.com/documentation/xcode/setting-up-coding-intelligence)

AN

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

Neovim-Plugin

OpenAI ChatAnthropic Messages

Neovim-Plugin: Chat und Änderungen direkt im Puffer.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/avante-nvim/)

#### Konfigurationsort

opts für yetone/avante.nvim in lazy.nvim: opts.providers.\<Name\> mit \_\_inherited\_from = 'openai' (eigener OpenAI-kompatibler Anbieter) oder providers.claude.endpoint überschreiben; der Schlüssel stammt aus der in api\_key\_name angegebenen Variablen (AVANTE\_\*-Namen werden unterstützt).

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```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, ohne /v1
      model = "claude-sonnet-5-5",
    },
  },
}
-- im Terminal: export AILOOT_API_KEY=sk-...
-- Der Provider claude liest AVANTE_ANTHROPIC_API_KEY oder ANTHROPIC_API_KEY
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Im Plugin-Wiki endet die OpenAI-kompatible Adresse auf /v1 (das Plugin ergänzt /chat/completions). Der integrierte Anbieter claude verwendet eine Adresse wie https://api.anthropic.com, für Ailoot daher ohne /v1. Eigene Anbieter ohne \_\_inherited\_from benötigen eine vollständige Adresse und eigene Funktionen zum Auswerten der Antwort.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/avante-nvim/)[Anwendungsdokumentation ↗](https://github.com/avante-corp/avante.nvim/wiki/Custom-providers)

CN

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

Neovim-Plugin

OpenAI ChatAnthropic Messages

Chat und Inline-Änderungen in Neovim.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/codecompanion-nvim/)

#### Konfigurationsort

require('codecompanion').setup({ adapters = { http = { ... } } }) über adapters.extend('openai\_compatible', ...) oder extend('anthropic', ...); danach interactions.chat/inline.adapter.

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```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",        -- Name der Umgebungsvariable, die sk-... enthält
            chat_url = "/v1/chat/completions",
          },
          schema = { model = { default = "gpt-6.1-sol" } },
        })
      end,
    },
  },
  interactions = {
    chat = { adapter = "ailoot" },
    inline = { adapter = "ailoot" },
  },
})
```

Der Schlüssel wird aus der Variablen gelesen: `AILOOT_API_KEY` — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # in ~/.zshrc oder ~/.bashrc eintragen
```

```powershell
setx AILOOT_API_KEY "sk-..."   # anschliessend das Terminal neu starten
```

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

openai\_compatible trennt Host (env.url, ohne /v1) und Pfad (env.chat\_url). env-Werte können Namen von Umgebungsvariablen, cmd:..., file:... oder Lua-Funktionen sein. Auch der Adapter anthropic lässt sich mit einem eigenen url für /v1/messages erweitern.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/codecompanion-nvim/)[Anwendungsdokumentation ↗](https://codecompanion.olimorris.dev/configuration/adapters-http)

Gp

### [gptel](https://ailoot.ai/docs/de-ch/integrations/gptel/)

Emacs-Paket

OpenAI ChatAnthropic MessagesGemini

Einfacher Client für Sprachmodelle in Emacs.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/gptel/)

#### Konfigurationsort

init.el: Backend mit gptel-make-openai (OpenAI Chat), gptel-make-anthropic (Messages) oder gptel-make-gemini registrieren — jeweils mit :host, :endpoint, :key, :stream, :models; danach gptel-backend und gptel-model festlegen.

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

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

Der Schlüssel wird aus der Variablen gelesen: `AILOOT_API_KEY` — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # in ~/.zshrc oder ~/.bashrc eintragen
```

```powershell
setx AILOOT_API_KEY "sk-..."   # anschliessend das Terminal neu starten
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

:host enthält nur den Hostnamen (ohne https:// und Pfad); der Pfad steht in :endpoint. gptel-make-anthropic sendet die Header x-api-key und anthropic-version — Ailoot akzeptiert sie.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/gptel/)[Anwendungsdokumentation ↗](https://github.com/karthink/gptel)

TI

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

Codeeditor

OpenAI Chat

Offene IDE mit dem Modul Theia AI.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/theia/)

#### Konfigurationsort

Preferences → AI-features → OpenAiCustom (oder in settings.json der Schlüssel ai-features.openAiCustom.customOpenAiModels; Fenster AI Configuration: Alt+A).

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

url ist die Basisadresse und endet auf /v1. Für Modelle anderer Anbieter als OpenAI ist developerMessageSettings: "system" eine sichere Wahl.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/theia/)[Anwendungsdokumentation ↗](https://theia-ide.org/docs/user_ai/)

TI

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

Codeeditor

OpenAI ChatAnthropic Messages

Codeeditor Trae mit eigenen Modellen.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/trae/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```text
OpenAI-Format:
  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-Format:
  API Format:  Anthropic Messages
  Full URL:    OFF
  Request URL: https://api.ailoot.ai
  Model ID:    claude-sonnet-5-5
  API Key:     sk-...
```

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

Bei deaktiviertem Full URL ergänzt Trae den Pfad des gewählten Formats selbst (OpenAI-Adresse mit /v1, Anthropic-Adresse ohne /v1). Bei aktiviertem Full URL geben Sie https://api.ailoot.ai/v1/chat/completions oder https://api.ailoot.ai/v1/messages ein. Model Series passt die Hinweise an die Modellfamilie an.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/trae/)[Anwendungsdokumentation ↗](https://docs.trae.ai/ide/models)

## Chat-Anwendungen

Chats für Computer, Mobiltelefon und Browser, Notizen und Launcher.

OW

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

Web-Chat auf eigenem Server

OpenAI Chat

Beliebter Web-Chat auf eigenem Server.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/open-webui/)

#### Konfigurationsort

Settings \> Admin \> Connections \> Manage OpenAI API Connections \> + Add Connection (oder env OPENAI\_API\_BASE\_URL / OPENAI\_API\_KEY beim Containerstart)

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```text
UI: URL = https://api.ailoot.ai/v1
API Key = sk-...
Model IDs: leer (werden aus /v1/models geladen) oder claude-sonnet-5-5, gpt-6.1-sol manuell hinzufügen

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

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Format OpenAI Chat Completions; die URL muss /v1 enthalten und darf keinen abschliessenden Schrägstrich haben. Die Modellliste stammt aus /v1/models; bei einem grossen Katalog (252 Modelle) ist es praktischer, Model IDs einzuschränken und das Caching der Modellliste zu aktivieren (Cache Base Model List / ENABLE\_BASE\_MODELS\_CACHE=True). Für RAG-Embeddings gibt es separate RAG\_OPENAI\_API\_BASE\_URL.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/open-webui/)[Anwendungsdokumentation ↗](https://docs.openwebui.com/getting-started/quick-start/connect-a-provider/starting-with-openai-compatible/)

Li

### [LibreChat](https://ailoot.ai/docs/de-ch/integrations/librechat/)

Web-Chat auf eigenem Server

OpenAI ChatAnthropic Messages

Web-Chat auf eigenem Server mit Agenten und mehreren Anbietern.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/librechat/)

#### Konfigurationsort

Datei librechat.yaml → endpoints.custom (Schlüssel in .env über ${VAR}); für das Anthropic-Format das Feld provider: 'anthropic'

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

Normaler custom endpoint = OpenAI Chat Completions (baseURL mit /v1). provider: 'anthropic' aktiviert den nativen Client /v1/messages; im Dokumentationsbeispiel steht baseURL für Anthropic ohne /v1 (https://api.anthropic.com), bei uns daher https://api.ailoot.ai. fetch: true lädt die Liste aus /v1/models.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/librechat/)[Anwendungsdokumentation ↗](https://www.librechat.ai/docs/configuration/librechat_yaml/object_structure/custom_endpoint)

CS

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

Desktopanwendung

OpenAI ChatOpenAI ResponsesAnthropic Messages

Desktopclient mit Assistenten und Wissensdatenbank.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/cherry-studio/)

#### Konfigurationsort

Settings (Zahnrad) \> Model Provider \> + Add Provider \> Protokolltyp OpenAI / OpenAI Responses / Anthropic / Gemini

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```text
Provider Name: Ailoot
Typ: OpenAI (oder OpenAI Responses / Anthropic)
API Key: sk-...
Base URL: https://api.ailoot.ai
→ Kontrollieren Sie die Vorschau der endgültigen Adresse unter dem Feld: sie muss lauten https://api.ailoot.ai/v1/chat/completions (für Anthropic — https://api.ailoot.ai/v1/messages)
Models: + claude-sonnet-5-5, gpt-6.1-sol
Anschliessend auf Model Check klicken
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Die Dokumentation bestätigt die Protokolle OpenAI, Anthropic, OpenAI Responses und Gemini sowie eine Vorschau des endgültigen Pfads unter dem Feld, beschreibt aber keine Regeln zum Ergänzen von /v1 — orientieren Sie sich an der Vorschau. Alle drei unserer Formate (Chat Completions, Responses, Messages) sind geeignet.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/cherry-studio/)[Anwendungsdokumentation ↗](https://cherryai.com/docs/en/pre-basic/providers/zi-ding-yi-fu-wu-shang/)

Ch

### [Chatbox](https://ailoot.ai/docs/de-ch/integrations/chatbox/)

Computer und Mobiltelefon

OpenAI Chat

Chat für Computer und Mobiltelefon.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/chatbox/)

#### Konfigurationsort

Einstellungen (Schaltfläche in der Seitenleiste) \> Model Provider \> Add (unten) \> Typ OpenAI API Compatible

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```text
Name: Ailoot
API Mode: OpenAI API Compatible
API Key: sk-...
API Host: https://api.ailoot.ai
API Path: (leer, standardmässig /v1/chat/completions)
Models: + gpt-6.1-sol, claude-sonnet-5-5 (vision ist in diesen Beispielen deaktiviert; tool_use — entsprechend den Fähigkeiten des gewählten Modells)
```

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

Die Dokumentation gibt API Host ohne /v1 an (Beispiel https://api.openai.com); der Standardpfad ist /v1/chat/completions. Es gibt auch den Typ Google Gemini compatible, der für unser /v1beta jedoch nicht geprüft wurde. Der JSON-Konfigurationsimport (type: 'openai', apiHost, apiPath) ist ab 1.15.1 über chatbox://provider/import?config=\<base64\> verfügbar. Für die gezeigten GPT- und Claude-Modelle ist vision deaktiviert: Der Katalogsnapshot vom 2026-09-30 weist im OpenAI-Chat-Format nur Text aus. Bietet Ihre Chatbox-Version vision an, aktivieren Sie es nur bei einem Modell, dessen aktuelle Katalogkarte image-Eingaben im gewählten API-Format ausweist; die Möglichkeit, im Client ein Bild anzuhängen, belegt keine Unterstützung durch das Modell.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/chatbox/)[Anwendungsdokumentation ↗](https://docs.chatboxai.app/en/guides/providers)

Lo

### [LobeChat](https://ailoot.ai/docs/de-ch/integrations/lobechat/)

Web-Chat auf eigenem Server

OpenAI ChatAnthropic Messages

Moderner Chat mit Plugins und Wissensdatenbank.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/lobechat/)

#### Konfigurationsort

Self-hosting: Umgebungsvariablen OPENAI\_PROXY\_URL / OPENAI\_API\_KEY / OPENAI\_MODEL\_LIST, ANTHROPIC\_PROXY\_URL, GOOGLE\_PROXY\_URL

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```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-Format (optional)
ANTHROPIC_API_KEY=sk-...
ANTHROPIC_PROXY_URL=https://api.ailoot.ai
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

OPENAI\_PROXY\_URL ist standardmässig https://api.openai.com/v1, daher mit /v1 angeben. ANTHROPIC\_PROXY\_URL ist standardmässig https://api.anthropic.com (ohne /v1). Über GOOGLE\_PROXY\_URL liesse sich grundsätzlich das Gemini-Format (https://api.ailoot.ai) verbinden; diese Variante haben wir jedoch nicht geprüft. Verwenden Sie den Servermodus: Bei direkten Browseranfragen kann die Ailoot API sie derzeit aufgrund der CORS-Regeln ablehnen.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/lobechat/)[Anwendungsdokumentation ↗](https://lobehub.com/docs/self-hosting/environment-variables/model-provider)

Ja

### [Jan](https://ailoot.ai/docs/de-ch/integrations/jan/)

Desktopanwendung

OpenAI ChatAnthropic Messages

Offener Desktopchat mit lokalen und Cloud-Modellen.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/jan/)

#### Konfigurationsort

Settings \> Model Providers \> Add Provider → Format OpenAI-compatible oder Anthropic-compatible wählen

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```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: werden aus {base_url}/models geladen oder mit + manuell hinzugefügt: claude-sonnet-5-5
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Dokumentation: Bei OpenAI-kompatiblen Anbietern muss Base URL /v1 enthalten (sonst 404); ein abschliessender Schrägstrich wird entfernt. Für den Anthropic-Modus zeigt das LiteLLM-Beispiel eine Adresse ohne /v1. Modellfähigkeiten (tools, vision) werden bei eigenen Anbietern manuell festgelegt. Ersatzschlüssel werden unterstützt (Wiederholung nur bei 401/403/429).

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/jan/)[Anwendungsdokumentation ↗](https://www.jan.ai/docs/desktop/remote-models/custom-endpoint)

Si

### [SillyTavern](https://ailoot.ai/docs/de-ch/integrations/sillytavern/)

Rollenspiel-Chat

OpenAI Chat

Oberfläche für Rollenspiel-Chats und Charaktere.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/sillytavern/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```text
Custom Endpoint (Base URL): https://api.ailoot.ai/v1
Custom API Key: sk-...
Model: aus der Liste (/v1/models) auswählen oder claude-sonnet-5-5 eingeben
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Laut Dokumentation bei Verbindungsproblemen /v1 ergänzen und /chat/completions NICHT ergänzen. Die Modellliste wird geladen, wenn der Server /v1/models bereitstellt (bei uns der Fall).

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/sillytavern/)[Anwendungsdokumentation ↗](https://docs.sillytavern.app/usage/api-connections/openai/)

An

### [AnythingLLM](https://ailoot.ai/docs/de-ch/integrations/anythingllm/)

Chat mit Dokumenten

OpenAI Chat

Chat mit Ihren Dokumenten auf Computer oder Server.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/anythingllm/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

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

Beispielmodell: `deepseek-v4-pro`

#### Wichtig

Der Anbieter wird in der Dokumentation als «für Entwickler» gekennzeichnet. Falls nötig, GENERIC\_OPEN\_AI\_MODEL\_MAX\_TOKEN\_KEY='max\_completion\_tokens'. Für Embeddings gibt es einen separaten generic-openai embedder (EMBEDDING\_BASE\_PATH + GENERIC\_OPEN\_AI\_EMBEDDING\_API\_KEY) — Modell nemotron-3-embed über /v1/embeddings.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/anythingllm/)[Anwendungsdokumentation ↗](https://docs.anythingllm.com/setup/llm-configuration/cloud/openai-generic)

BA

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

Web-Chat auf eigenem Server

OpenAI ChatAnthropic Messages

Erweiterte Web-Oberfläche für die Arbeit mit mehreren Modellen.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/big-agi/)

#### Konfigurationsort

Umgebungsvariablen beim Deployment: OPENAI\_API\_KEY / OPENAI\_API\_HOST, ANTHROPIC\_API\_KEY / ANTHROPIC\_API\_HOST; in der Oberfläche: Models \> Add OpenAI-compatible

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Die Dokumentation beschreibt die Variablen als Ersatz des Backend-Hosts für OpenAI und Anthropic (für Proxys und eigene Endpoints). Da dort «host» steht, geben wir die Adresse ohne /v1 an; das genaue Pfadformat wird jedoch nicht erläutert — prüfen Sie es anhand der ersten Anfrage.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/big-agi/)[Anwendungsdokumentation ↗](https://github.com/enricoros/big-AGI/blob/main/docs/environment-variables.md)

Bo

### [BoltAI](https://ailoot.ai/docs/de-ch/integrations/boltai/)

Mac-Anwendung

OpenAI Chat

Nativer KI-Client für macOS.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/boltai/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```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: gemäss Modell
Streaming: aktivieren
```

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

Die vollständige Chat-Completions-Adresse ist erforderlich. Damit AI Command sie verwendet, legen Sie diesen Dienst als Standard fest. Die Anleitung basiert auf der BoltAI-Hilfe; in BoltAI 2 können die Fenster abweichen.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/boltai/)[Anwendungsdokumentation ↗](https://boltai.com/help/how-to-setup-custom-openai-server)

HF

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

Web-Chat auf eigenem Server

OpenAI Chat

Offener Hugging-Face-Web-Chat auf eigenem Server.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/hugging-face-chat-ui/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `deepseek-v4-pro`

#### Wichtig

Chat UI funktioniert ausschliesslich mit OpenAI-kompatiblen APIs über OPENAI\_BASE\_URL und lädt die Modellliste aus /models.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/hugging-face-chat-ui/)[Anwendungsdokumentation ↗](https://github.com/huggingface/chat-ui)

MS

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

Desktopanwendung

OpenAI Chat

Desktopchat mit lokalen und Cloud-Modellen.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/msty-studio/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

Die Dokumentation bestätigt einen eigenen OpenAI-kompatiblen Anbieter, nennt aber kein Adressformat; /v1 ist die Standardwurzel der OpenAI API. Prüfen Sie bei Fehler 404 die Variante ohne /v1. Ein eigener Anthropic-kompatibler endpoint wird in der Dokumentation nicht beschrieben.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/msty-studio/)[Anwendungsdokumentation ↗](https://docs.msty.ai/studio/managing-models/online-providers)

Ne

### [NextChat](https://ailoot.ai/docs/de-ch/integrations/nextchat/)

Web-Chat auf eigenem Server

OpenAI Chat

Schlanker Web-Chat, der sich rasch bereitstellen lässt.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/nextchat/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

Verwenden Sie für diese Einrichtung OpenAI Chat über den NextChat-Server. Setzen Sie bei der Bereitstellung mit Vercel oder Docker BASE\_URL=https://api.ailoot.ai ohne /v1 sowie OPENAI\_API\_KEY, CUSTOM\_MODELS und DEFAULT\_MODEL. Stellen Sie den Server nach Änderungen dieser Variablen erneut bereit.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/nextchat/)[Anwendungsdokumentation ↗](https://github.com/ChatGPTNextWeb/NextChat#environment-variables)

OC

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

Obsidian-Plugin

OpenAI Chat

Chat mit Obsidian-Notizen.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/obsidian-copilot/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```text
Base URL: https://api.ailoot.ai/v1
API key: sk-...
Model ID: claude-sonnet-5-5 (oder aus der Liste /v1/models auswählen)
Anschliessend Test; das Modell unter Basic > Agents > Quick Chat aktivieren
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Die Modellliste wird aus /v1/models geladen; das Modell kann manuell eingegeben werden. Ist Test erfolgreich, Quick Chat sendet aber keine Nachrichten, aktivieren Sie beim Anbieter Enable CORS (die Antwort kommt vollständig ohne Stream). Schlüssel werden im Obsidian Keychain gespeichert.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/obsidian-copilot/)[Anwendungsdokumentation ↗](https://github.com/logancyang/obsidian-copilot/blob/master/docs/llm-providers.md)

PA

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

Browsererweiterung

OpenAI Chat

Browsererweiterung: Chat mit der geöffneten Seite.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/page-assist/)

#### Konfigurationsort

Page-Assist-Symbol \> Settings \> OpenAI Compatible API \> Add Provider \> Custom

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```text
Provider: Custom
Name: Ailoot
Base URL: https://api.ailoot.ai/v1
API Key: sk-...
Anschliessend die Modelle manuell hinzufügen: gpt-6.1-sol, claude-sonnet-5-5
```

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

Die Dokumentation bestätigt Custom mit API URL und Schlüssel, beschreibt aber kein URL-Format; /v1 ist die Standardwurzel der OpenAI API. Automatisches Laden von Modellen ist nur für Ollama, LM Studio und Llamafile garantiert — bei anderen Anbietern werden Modelle manuell hinzugefügt.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/page-assist/)[Anwendungsdokumentation ↗](https://docs.pageassist.xyz/providers/openai)

RA

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

Launcher

OpenAI Chat

KI im Raycast-Launcher: Schnellbefehle und Chat.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/raycast-ai/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

base\_url ist ein OpenAI-kompatibler endpoint ohne Suffix /chat/completions. Raycast liest die Datei ohne Neustart neu. Ohne abilities gelten tools und vision als nicht unterstützt. Modelle erscheinen in Quick AI, AI Chat und AI Commands. Dieses Beispiel setzt vision.supported = false: Der Katalogsnapshot vom 2026-09-30 weist für Claude/OpenAI Chat nur Text aus. Unterstützt Ihre Raycast-Version diese Einstellung, aktivieren Sie vision nur für ein Modell, dessen aktuelle Katalogkarte image-Eingaben im OpenAI-Chat-Format ausweist; das Client-Flag allein bestätigt keine Bildunterstützung durch die API.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/raycast-ai/)[Anwendungsdokumentation ↗](https://manual.raycast.com/ai/custom-providers)

Ty

### [TypingMind](https://ailoot.ai/docs/de-ch/integrations/typingmind/)

Web-Anwendung

OpenAI Chat

Komfortable Chat-Oberfläche im Browser und auf dem Computer.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/typingmind/)

#### Konfigurationsort

Models (linke Seitenleiste) \> + Add Custom Model

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```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: gemäss Modell
Test → Save
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Der Endpoint wird als vollständiger Pfad eingegeben. Der Schlüssel wird im eigenen Header Authorization: Bearer sk-... übermittelt — Ailoot akzeptiert ihn. Die Web-Version von TypingMind greift direkt aus dem Browser auf die API zu; CORS kann solche Anfragen derzeit blockieren. Die Desktopversion ist zuverlässiger. Der Gemini-Typ in TypingMind sendet den Schlüssel im Header apiKey, den Ailoot nicht akzeptiert — verwenden Sie OpenAI Chat Completions.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/typingmind/)[Anwendungsdokumentation ↗](https://docs.typingmind.com/manage-and-connect-ai-models/ollama)

## SDKs und Frameworks

Bibliotheken für eigene Anwendungen, Agenten und RAG.

OS

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

SDK

OpenAI ChatOpenAI Responses

Offizielle OpenAI-Bibliothek für Python.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/openai-python-sdk/)

#### Konfigurationsort

Konstruktorparameter OpenAI(base\_url=..., api\_key=...) oder Umgebungsvariablen OPENAI\_BASE\_URL und OPENAI\_API\_KEY

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

# oder im Code
```

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

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

Beispielmodell: `gpt-6.1-sol, claude-sonnet-5-5, deepseek-v4-pro, qwen3.8-max (Chat); nemotron-3-embed (Embeddings)`

#### Wichtig

Adresse mit /v1: Das SDK ergänzt /chat/completions, /responses, /embeddings, /images/\* und /audio/\* selbst. Chat Completions und Responses funktionieren (Responses bei Modellen, für die der Katalog dieses Format ausweist). Streaming und Werkzeuge entsprechen dem Standard. Ailoot-Fehler kommen als JSON mit Request ID und werden als openai.APIStatusError erfasst.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/openai-python-sdk/)[Anwendungsdokumentation ↗](https://github.com/openai/openai-python)

OS

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

SDK

OpenAI ChatOpenAI Responses

Offizielle OpenAI-Bibliothek für JavaScript und TypeScript.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/openai-node-js-sdk/)

#### Konfigurationsort

Konstruktoroption new OpenAI({ baseURL, apiKey }); standardmässig liest das SDK die Umgebungsvariable OPENAI\_BASE\_URL

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Der Schlüssel wird aus der Variablen gelesen: `AILOOT_API_KEY` — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # in ~/.zshrc oder ~/.bashrc eintragen
```

```powershell
setx AILOOT_API_KEY "sk-..."   # anschliessend das Terminal neu starten
```

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

#### Wichtig

Das README zeigt die Option baseURL; das Lesen von OPENAI\_BASE\_URL ist im Client-Quellcode (src/client.ts) ersichtlich, Standardwert https://api.openai.com/v1. Geben Sie die Ailoot-Adresse mit /v1 an. chat.completions und responses sind verfügbar.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/openai-node-js-sdk/)[Anwendungsdokumentation ↗](https://github.com/openai/openai-node)

AS

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

SDK

Anthropic Messages

Offizielle Anthropic-Bibliothek für Python.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/anthropic-python-sdk/)

#### Konfigurationsort

Parameter Anthropic(base\_url=...) oder Umgebungsvariable ANTHROPIC\_BASE\_URL; Schlüssel: api\_key oder ANTHROPIC\_API\_KEY

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

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

Beispielmodell: `claude-sonnet-5-5, claude-opus-5-5; auch über /v1/messages gpt-6.1-sol, deepseek-v4-pro, gemini-3.6-flash`

#### Wichtig

Adresse OHNE /v1: Das SDK ergänzt /v1/messages selbst. Das Gateway akzeptiert den Schlüssel in x-api-key (so sendet ihn das SDK) und in Authorization: Bearer. Streaming, Werkzeuge und /v1/messages/count\_tokens funktionieren. Stapelverarbeitung (Batches) und Files API sind im Ailoot-Katalog nicht ausgewiesen.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/anthropic-python-sdk/)[Anwendungsdokumentation ↗](https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/python)

VA

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

SDK

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

TypeScript-Framework für KI-Anwendungen mit beliebigen Anbietern.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/vercel-ai-sdk/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Der Schlüssel wird aus der Variablen gelesen: `AILOOT_API_KEY` — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # in ~/.zshrc oder ~/.bashrc eintragen
```

```powershell
setx AILOOT_API_KEY "sk-..."   # anschliessend das Terminal neu starten
```

Beispielmodell: `deepseek-v4-pro (OpenAI-kompatibel), claude-sonnet-5-5 (Anthropic), gemini-3.6-flash (Gemini)`

#### Wichtig

Unterschiedliche Anbieteradressen: OpenAI-kompatibel und Anthropic mit /v1 (Anthropic-Standard https://api.anthropic.com/v1), Google mit /v1beta (Standard https://generativelanguage.googleapis.com/v1beta). Der Anbieter @ai-sdk/openai verwendet standardmässig die Responses API; für Modelle ohne Methode responses verwenden Sie openai.chat("id") oder createOpenAICompatible.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/vercel-ai-sdk/)[Anwendungsdokumentation ↗](https://ai-sdk.dev/providers/openai-compatible-providers)

La

### [LangChain](https://ailoot.ai/docs/de-ch/integrations/langchain/)

Framework

OpenAI ChatOpenAI ResponsesAnthropic Messages

Framework für Chains, Agenten und RAG.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/langchain/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

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

#### Wichtig

ChatOpenAI: Adresse mit /v1. Laut Dokumentation unterstützt ChatOpenAI nur die offizielle OpenAI-Spezifikation: Nicht standardisierte Felder wie reasoning\_content von Drittanbietermodellen bleiben nicht erhalten. Für Claude eignet sich ChatAnthropic besser: Adresse ohne /v1, das SDK ergänzt /v1/messages selbst. Der Parameter base\_url und die Variablen ANTHROPIC\_API\_URL/ANTHROPIC\_BASE\_URL von ChatAnthropic sind in der Klassendokumentation im Quellcode (langchain\_anthropic/chat\_models.py) beschrieben, fehlen aber auf der Integrationsseite. Der Schalter use\_responses\_api aktiviert bei ChatOpenAI den Responses-Modus.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/langchain/)[Anwendungsdokumentation ↗](https://docs.langchain.com/oss/python/integrations/chat/openai)

Cr

### [CrewAI](https://ailoot.ai/docs/de-ch/integrations/crewai/)

Agentenframework

OpenAI ChatAnthropic Messages

Agententeams mit Rollen und Aufgaben.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/crewai/)

#### Konfigurationsort

crewai.LLM(model=..., base\_url=..., api\_key=...); Variablen OPENAI\_API\_KEY und OPENAI\_BASE\_URL; für Claude: nativer Anbieter anthropic/ mit base\_url

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/messages und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```python
import os
from crewai import LLM
# OpenAI-kompatibles Format
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)
```

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

#### Wichtig

Das Präfix openai/ oder anthropic/ wählt den Anbieter in CrewAI; die Anfrage enthält die id ohne Präfix. OpenAI-Adresse mit /v1, Anthropic-Adresse ohne /v1. Die Dokumentation beschreibt ausserdem den Schalter custom\_openai=True für beliebige OpenAI-kompatible Gateways. Bei Anthropic ist max\_tokens erforderlich.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/crewai/)[Anwendungsdokumentation ↗](https://docs.crewai.com/en/concepts/llms)

GG

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

SDK

Gemini

Offizielle Google-Bibliothek für die Gemini API.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/google-genai-python/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1beta/models/{model}:generateContent und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `gemini-3.6-flash, gemini-3.1-pro`

#### Wichtig

Adresse ohne /v1beta: Das SDK setzt /v1beta/models/{model}:generateContent selbst zusammen. Der Schlüssel wird im Header x-goog-api-key gesendet — Ailoot akzeptiert ihn. Verfügbar sind nur Modelle mit Gemini-Format. Für die JavaScript-Version (@google/genai) beschreibt die Dokumentation keine eigene Adresse; deshalb zeigen wir sie hier nicht.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/google-genai-python/)[Anwendungsdokumentation ↗](https://github.com/googleapis/python-genai#custom-base-url)

Li

### [LiteLLM](https://ailoot.ai/docs/de-ch/integrations/litellm/)

SDK

OpenAI Chat

Einheitliche Python-Schnittstelle zu Dutzenden Anbietern.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/litellm/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

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

#### Wichtig

Das Präfix openai/ bezeichnet das OpenAI-kompatible Protokoll; Ailoot erhält die id ohne Präfix. LiteLLM ergänzt /chat/completions und /embeddings selbst; laut Dokumentation muss die Adresse bei einem Not-Found-Fehler auf /v1 enden.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/litellm/)[Anwendungsdokumentation ↗](https://docs.litellm.ai/docs/providers/openai_compatible)

LP

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

Eigenes Gateway

OpenAI Chat

Eigenes Gateway mit Schlüsseln, Limits und Protokollen vor Ailoot.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/litellm-proxy/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

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

Der Schlüssel wird aus der Variablen gelesen: `AILOOT_API_KEY` — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # in ~/.zshrc oder ~/.bashrc eintragen
```

```powershell
setx AILOOT_API_KEY "sk-..."   # anschliessend das Terminal neu starten
```

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

#### Wichtig

Der Proxy ist nützlich, wenn Sie einem Team eigene interne Schlüssel über einem einzigen Ailoot-Schlüssel bereitstellen möchten. Ailoot bucht über den in api\_key angegebenen Schlüssel ab. Adresse mit /v1.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/litellm-proxy/)[Anwendungsdokumentation ↗](https://docs.litellm.ai/docs/providers/openai_compatible)

Ll

### [LlamaIndex](https://ailoot.ai/docs/de-ch/integrations/llamaindex/)

Framework

OpenAI Chat

Framework für die Suche in eigenen Daten und RAG.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/llamaindex/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

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

#### Wichtig

Adresse mit /v1. is\_chat\_model=True ist erforderlich, sonst verwendet die Klasse das veraltete /completions. is\_function\_calling\_model=True ermöglicht Agenten die Werkzeugnutzung. Legen Sie context\_window anhand der Modellkarte im Ailoot-Katalog fest.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/llamaindex/)[Anwendungsdokumentation ↗](https://developers.llamaindex.ai/python/framework-api-reference/llms/openai_like/)

Ma

### [Mastra](https://ailoot.ai/docs/de-ch/integrations/mastra/)

Agentenframework

OpenAI ChatOpenAI Responses

TypeScript-Framework für Agenten und Workflows.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/mastra/)

#### Konfigurationsort

In Agent: model: { id: "\<Anbieter\>/\<Modell\>", url: "\<Basisadresse\>", apiKey, api?: "chat" | "responses" }

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```js
import { Agent } from "@mastra/core/agent";
const agent = new Agent({
  id: "ailoot-agent",
  name: "Ailoot Agent",
  instructions: "Antworte auf Russisch",
  model: {
    id: "ailoot/claude-sonnet-5-5",
    url: "https://api.ailoot.ai/v1",
    apiKey: process.env.AILOOT_API_KEY
    // api: "responses"  // nur für Modelle mit der Methode responses
  }
});
```

Der Schlüssel wird aus der Variablen gelesen: `AILOOT_API_KEY` — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # in ~/.zshrc oder ~/.bashrc eintragen
```

```powershell
setx AILOOT_API_KEY "sk-..."   # anschliessend das Terminal neu starten
```

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

#### Wichtig

url enthält die Basisadresse mit /v1, nicht den vollständigen Pfad zu /chat/completions. Standardmässig wird Chat Completions verwendet; api: "responses" wechselt zur Responses API. Das id-Muster "Anbieter/Modell" sendet die reine Modell-id an das Gateway. Die Dokumentation zeigt apiKey im Objekt model anhand eines Beispiels mit Headern; die gemeinsame Verwendung mit url wird nicht separat beschrieben.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/mastra/)[Anwendungsdokumentation ↗](https://mastra.ai/models)

OA

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

Agentenframework

OpenAI ChatOpenAI Responses

OpenAI-Bibliothek für Multi-Agent-Szenarien.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/openai-agents-sdk/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```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="Assistent", instructions="Antworte auf Russisch", model=model)
print(Runner.run_sync(agent, "Hallo").final_output)
```

Beispielmodell: `claude-sonnet-5-5, gpt-6.1-sol`

#### Wichtig

Adresse mit /v1. Deaktivieren Sie Tracing mit set\_tracing\_disabled(True): Sonst versucht das SDK, Traces ohne vorhandenen OpenAI-Schlüssel an OpenAI zu senden. Chat Completions ist nur für Modelle verfügbar, bei denen diese Methode im Katalog aufgeführt und für Ihren Schlüssel verfügbar ist; Responses (SDK-Standard) nur für Modelle mit der Methode responses im Katalog. Integrierte OpenAI-Werkzeuge (Websuche, Dateien) sind über ein Drittanbieter-Gateway nicht garantiert.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/openai-agents-sdk/)[Anwendungsdokumentation ↗](https://openai.github.io/openai-agents-python/models/)

PA

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

Agentenframework

OpenAI ChatOpenAI Responses

Typisiertes Agentenframework in Python.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/pydantic-ai/)

#### Konfigurationsort

OpenAIProvider(base\_url=..., api\_key=...) mit OpenAIChatModel (Chat Completions) oder OpenAIResponsesModel (Responses); alternativ Variable OPENAI\_BASE\_URL

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `deepseek-v4-pro, gpt-6.1-sol (für OpenAIResponsesModel)`

#### Wichtig

Adresse mit /v1. Die Dokumentation verwendet standardmässig OpenAIResponsesModel: Nutzen Sie es nur bei Modellen mit der Methode responses; für die übrigen OpenAIChatModel.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/pydantic-ai/)[Anwendungsdokumentation ↗](https://pydantic.dev/docs/ai/models/openai/)

## Automatisierung

No-Code-Abläufe, Chain-Builder, Bots und Smart Home.

N8

### [n8n](https://ailoot.ai/docs/de-ch/integrations/n8n/)

No-Code-Automatisierung

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Automatisierung von Abläufen mit KI-Agenten-Knoten.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/n8n/)

#### Konfigurationsort

Credentials → OpenAI → Feld Base URL (Standard https://api.openai.com/v1); Credentials → Anthropic → Base URL (Standard https://api.anthropic.com); Credentials → Google Gemini(PaLM) Api → Host (Standard https://generativelanguage.googleapis.com). Danach die Knoten OpenAI Chat Model / Anthropic Chat Model / Google Gemini Chat Model

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```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-...
Node OpenAI Chat Model → Model: By ID → gpt-6.1-sol (Schalter Use Responses API — nur für Modelle mit der Methode responses)
```

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

#### Wichtig

Die Zugangsdatenprüfung ruft /models (OpenAI), /v1/models (Anthropic) und /v1beta/models (Gemini) auf; alle drei Pfade sind bei Ailoot vorhanden. Die n8n-Dokumentationsseiten beschreiben das Feld Base URL nicht; es steht in den Zugangsdaten selbst (Quellcode OpenAiApi.credentials.ts und AnthropicApi.credentials.ts, Beschriftung «Override the default base URL for the API»). Wählen Sie bei n8n Cloud nicht «Use Gateway credits», sonst laufen die Anfragen nicht über Ailoot.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/n8n/)[Anwendungsdokumentation ↗](https://github.com/n8n-io/n8n/blob/master/packages/nodes-base/credentials/OpenAiApi.credentials.ts)

Di

### [Dify](https://ailoot.ai/docs/de-ch/integrations/dify/)

Plattform für LLM-Anwendungen

OpenAI Chat

Plattform für KI-Anwendungen: Chatbots, Agenten, Wissensdatenbanken.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/dify/)

#### Konfigurationsort

Integrations → Model Provider → Plugin OpenAI-API-compatible installieren → Add Model (Felder: Model Type, Model Name, API Key, API Base URL, Completion mode, Model context size)

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```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: gemäss Modellkarte im Ailoot-Katalog

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

Beispielmodell: `claude-sonnet-5-5, gpt-6.1-sol, qwen3.8-max; nemotron-3-embed (Embeddings)`

#### Wichtig

Nur Eigentümer und Administratoren des Arbeitsbereichs dürfen Anbieter verwalten. Laut Plugin-README gilt für LLM die Adresse mit /v1; bei Embeddings, rerank, STT und TTS ergänzt das Plugin die API-Version selbst, daher die Adresse ohne /v1 (sonst entsteht /v1/v1). Fügen Sie jedes Ailoot-Modell als separaten Eintrag hinzu; aktivieren Sie Bildeingaben und Streaming in den Modelleinstellungen.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/dify/)[Anwendungsdokumentation ↗](https://github.com/langgenius/dify-official-plugins/tree/main/models/openai_api_compatible)

Fl

### [Flowise](https://ailoot.ai/docs/de-ch/integrations/flowise/)

Chain-Builder

OpenAI Chat

Visueller Builder für Chains und Agenten.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/flowise/)

#### Konfigurationsort

Knoten ChatOpenAI oder ChatOpenAI Custom → Connect Credential (Schlüssel) → Additional Parameters → Base Path (und Base Options für Header)

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

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

#### Wichtig

In ChatOpenAI ist die Modellliste fest vorgegeben; verwenden Sie für beliebige Ailoot-IDs daher ChatOpenAI Custom, wo der Modellname manuell eingegeben wird. Base Path mit /v1. Für Embeddings gibt es den Knoten OpenAI Embeddings Custom.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/flowise/)[Anwendungsdokumentation ↗](https://docs.flowiseai.com/integrations/langchain/chat-models/azure-chatopenai)

HA

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

Smart Home

OpenAI Chat

Smart-Home-Sprachassistent über Extended OpenAI Conversation.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/home-assistant/)

#### Konfigurationsort

Über HACS (Custom repository) installieren oder custom\_components/extended\_openai\_conversation kopieren → Neustart → Settings → Devices & Services → Add Integration → Extended OpenAI Conversation (API Key, Base Url) → Settings → Voice Assistants → Conversation agent

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `gpt-6.1-sol, claude-sonnet-5-5`

#### Wichtig

Dies ist eine Drittanbieterkomponente, keine offizielle Integration. Die Gerätesteuerung erfolgt über Funktionsaufrufe (tools) in Chat Completions; wählen Sie daher Modelle mit Werkzeugunterstützung. Die offizielle Integration OpenAI Conversation unterstützt keine eigene Adresse.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/home-assistant/)[Anwendungsdokumentation ↗](https://github.com/jekalmin/extended_openai_conversation)

La

### [Langflow](https://ailoot.ai/docs/de-ch/integrations/langflow/)

Chain-Builder

OpenAI Chat

Visueller Builder für Agenten und RAG.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/langflow/)

#### Konfigurationsort

Profil → Settings → Model Providers → OpenAI Compatible (Felder Base URL und API Key; Variablen OPENAI\_COMPATIBLE\_BASE\_URL und OPENAI\_COMPATIBLE\_API\_KEY). Alternative: Komponente OpenAI → Feld OpenAI API Base

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```text
Settings → Model Providers → OpenAI Compatible:
  Base URL: https://api.ailoot.ai/v1
  API Key: sk-...
oder über Umgebungsvariablen:
```

```bash
export OPENAI_COMPATIBLE_BASE_URL="https://api.ailoot.ai/v1"
export OPENAI_COMPATIBLE_API_KEY="sk-..."
Anschliessend in den Komponenten Language Model / Agent OpenAI Compatible → claude-sonnet-5-5 auswählen
```

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

#### Wichtig

Langflow prüft die Verbindung und lädt die Modellliste aus /v1/models; die Modelle erscheinen unter Language Models und Embedding Models. Die benötigten Modelle müssen danach manuell aktiviert werden. Der Anbieter wird zusammen mit langflow installiert.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/langflow/)[Anwendungsdokumentation ↗](https://docs.langflow.org/bundles-openai-compatible)

Ma

### [Make](https://ailoot.ai/docs/de-ch/integrations/make/)

No-Code-Automatisierung

HTTP-Anfrage

No-Code-Automatisierung: Ailoot-Anfrage über das HTTP-Modul.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/make/)

#### Konfigurationsort

Das integrierte OpenAI-Modul funktioniert nur mit einem OpenAI-Konto. Verwenden Sie HTTP → Make a request: URL, Method, Headers, Body type Raw / JSON

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `gpt-6.1-sol, claude-sonnet-5-5`

#### Wichtig

Dies ist ein allgemeines HTTP-Modul, kein separater Ailoot-Anbieter: Die Dokumentation beschreibt eine beliebige HTTPS-Adresse. Speichern Sie den Schlüssel möglichst in einer Verbindung mit API-Schlüssel (Make empfiehlt dies statt einer Übergabe in Headern). Streaming ist in Make nicht nötig; senden Sie die Anfrage ohne stream.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/make/)[Anwendungsdokumentation ↗](https://apps.make.com/http)

T

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

Bots

OpenAI Chat

Eigener Telegram-Bot mit OpenAI SDK.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/telegram-bot/)

#### Konfigurationsort

Telegram-Frameworks haben keine eigene LLM-Schicht: Im Nachrichtenhandler wird das OpenAI SDK mit Ailoot-base\_url aufgerufen (oder das Anthropic SDK mit base\_url ohne /v1)

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

Speichern Sie den Python-Code als ailoot-telegram-bot.py. Installieren Sie die Abhängigkeiten, setzen Sie beide Umgebungsvariablen und starten Sie die Datei. Senden Sie Hello an Ihren Bot und prüfen Sie die Textantwort. Bewahren Sie bei Fehlern die Request ID auf und prüfen Sie das ursprüngliche Ergebnis vor einer weiteren Generierung.

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

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

#### Wichtig

Telegram-Frameworks haben keine eigene KI-Modellschicht: Die Ailoot-Adresse wird im OpenAI SDK innerhalb des Bots festgelegt. Ohne Guthaben gibt Ailoot einen verständlichen Fehler 402 mit Request ID zurück — zeigen Sie ihn dem Bot-Benutzer, statt die Anwendung abstürzen zu lassen.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/telegram-bot/)[Anwendungsdokumentation ↗](https://github.com/openai/openai-python)

Za

### [Zapier](https://ailoot.ai/docs/de-ch/integrations/zapier/)

No-Code-Automatisierung

HTTP-Anfrage

Automatisierung: Ailoot-Anfrage über Webhooks by Zapier.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/zapier/)

#### Konfigurationsort

Die Zapier-App ChatGPT (OpenAI) funktioniert nur mit OpenAI. Verwenden Sie Webhooks by Zapier → Custom Request (Method, URL, Data, Headers)

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `claude-sonnet-5-5, gpt-6.1-sol`

#### Wichtig

Dies ist eine allgemeine HTTP-Anfrage; Zapier bietet keinen fertigen Anbieter mit einem Feld für die Basisadresse. Custom Request sendet Data unverändert und ohne Auswertung; prüfen Sie das JSON daher vorher. Webhooks by Zapier ist mit kostenpflichtigen Zapier-Tarifen verfügbar.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/zapier/)[Anwendungsdokumentation ↗](https://help.zapier.com/hc/en-us/articles/8496326446989-Send-webhooks-in-Zap-workflows)

## Wird geprüft

Konfigurationen mit unbestätigten Details — vergleichen Sie sie mit dem Anwendungsfenster.

AC

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

Terminalagent

Wird geprüft

Gemini

Konsolenagent Google Antigravity im Gemini-Format.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/antigravity-cli/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1beta/models/{model}:generateContent und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

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

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

Beispielmodell: `gemini-3.8-flash`

#### Wichtig

Protokoll: natives Gemini REST (streamGenerateContent, Schlüssel in X-Goog-Api-Key), Pfad https://api.ailoot.ai/v1beta/... Pro Frage sendet agy zwei Anfragen: den Gesprächstitel und die eigentliche Antwort. Der Agent reserviert pro Schritt deutlich mehr als ein normaler Chat; halten Sie deshalb ausreichend Guthaben bereit. Die Karte steht unter «Wird geprüft»: Die Konfiguration basiert auf der Dokumentation; ein Live-Test des Clients über Ailoot wurde noch nicht durchgeführt. Bei modelProvider = gemini und leerem GEMINI\_API\_KEY startet die CLI nicht.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/antigravity-cli/)[Anwendungsdokumentation ↗](https://antigravity.google/docs/cli/install/)

CC

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

Terminalagent

Wird geprüft

OpenAI Chat

Konsolenversion des Cline-Agenten.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/cline-cli/)

#### Konfigurationsort

cline auth → eigene API-Anbieter → OpenAI Compatible: Base URL, API Key, Model ID; der Schalter -P/--provider wählt den Anbieter

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```bash
cline auth
# API Provider: OpenAI Compatible
# Base URL:     https://api.ailoot.ai/v1
# API Key:      sk-...
# Model ID:     claude-sonnet-5-5
cline "Führe die Tests aus und behebe die Fehler"
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Die Felder Base URL / API Key / Model ID stehen in der Cline-Dokumentation für OpenAI Compatible. Die genauen Beschriftungen im Assistenten cline auth sind in der CLI-Dokumentation nicht aufgeführt — vergleichen Sie sie mit der Anzeige.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/cline-cli/)[Anwendungsdokumentation ↗](https://docs.cline.bot/provider-config/openai-compatible)

CJ

### [Copilot für JetBrains](https://ailoot.ai/docs/de-ch/integrations/copilot-jetbrains-byok/)

Editorerweiterung

Wird geprüft

OpenAI Chat

Eigene Modelladresse in Copilot für JetBrains-IDEs.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/copilot-jetbrains-byok/)

#### Konfigurationsort

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

#### Konfiguration

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

#### Wichtig

GitHub bestätigt die Unterstützung eigener Endpunkte. Der offizielle Screenshot zeigt Provider Name, API Key und API Type: Chat Completions, jedoch kein URL-Beispiel. Deshalb steht hier keine fertige Ailoot-Konfiguration. Die dokumentierte Alternative in dieser IDE ist JetBrains AI Assistant. Klären Sie die URL-Anforderungen mit dem offiziellen Plugin-Support.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/copilot-jetbrains-byok/)[Anwendungsdokumentation ↗](https://github.blog/changelog/2026-07-14-github-copilot-for-jetbrains-expands-byok-capabilities/)

Cu

### [Cursor](https://ailoot.ai/docs/de-ch/integrations/cursor/)

Codeeditor

Wird geprüft

OpenAI Chat

Cursor-Editor: eigene OpenAI-Adresse für den Chat.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/cursor/)

#### Konfigurationsort

Cursor Settings → Models → API Keys → OpenAI API Key + Schalter «Override OpenAI Base URL»; ergänzen Sie danach die Modell-ID in Ihren eigenen Modellen.

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

```text
OpenAI API Key:            sk-...
Override OpenAI Base URL:  https://api.ailoot.ai/v1
Eigenes Modell:               gpt-6.1-sol  (hinzufügen, aktivieren, im Chat auswählen)
```

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

Die aktuelle offizielle Cursor-Dokumentation beschreibt keine eigene Adresse: Sie nennt nur Schlüssel für OpenAI/Anthropic/Google/Azure/Bedrock, erklärt, dass eigene Schlüssel nur im Chat funktionieren (Tab verwendet weiterhin Cursor-Modelle), und dass alle Anfragen über Cursor-Server laufen (die Adresse muss öffentlich sein — api.ailoot.ai ist öffentlich). Der Adressschalter ist in der Oberfläche vorhanden; im Cursor-Forum werden jedoch Fehler gemeldet: Er gilt für alle Modelle, der Agent-Modus verwendet möglicherweise den eigenen Schlüssel nicht, und in einigen 3.15.x-Builds nimmt das Feld keine Eingaben an.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/cursor/)[Anwendungsdokumentation ↗](https://cursor.com/help/models-and-usage/api-keys)

OT

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

Obsidian-Plugin

Wird geprüft

OpenAI Chat

Textgenerierung in Obsidian-Notizen anhand von Vorlagen.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/obsidian-text-generator/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

Die Plugin-Dokumentation erwähnt den Anbieter Custom, beschreibt aber weder das Adressfeld noch dessen Format; diese Konfiguration basiert auf der Plugin-Oberfläche — vergleichen Sie sie mit dem Einstellungsfenster.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/obsidian-text-generator/)[Anwendungsdokumentation ↗](https://docs.text-gen.com/)

Pe

### [PearAI](https://ailoot.ai/docs/de-ch/integrations/pearai/)

Codeeditor

Wird geprüft

OpenAI Chat

PearAI-Editor auf Basis von VS Code.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/pearai/)

#### Konfigurationsort

Cmd/Ctrl+Shift+P → Open config.json → Eintrag in models\[\] (PearAI ist ein Continue-Fork).

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Die offizielle PearAI-Dokumentation konnte nicht geprüft werden (Dokumentationswebsite nicht erreichbar); das Repository wurde seit Langem nicht aktualisiert. Die Konfigurationsform basiert auf Continue — prüfen Sie sie in der Anwendung.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/pearai/)[Anwendungsdokumentation ↗](https://github.com/trypear/pearai-app/issues/122)

VS

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

Codeeditor

Wird geprüft

OpenAI Chat

Eigener Anbieter in Copilot Chat für Visual Studio.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/visual-studio-2026/)

#### Konfigurationsort

Chat → Modellauswahl → Manage models → Add custom model → Anbieter OpenAI (custom endpoint) → Adresse, Schlüssel, Modell.

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

Der Visual-Studio-Blog (29.09.2026) kündigte eigene Adressen für OpenAI und Ollama in VS 2026 Stable an; die Dokumentationsseite beschreibt aber weiterhin nur OpenAI-/Anthropic-/Google-Schlüssel ohne Adressfeld. Feldnamen und Adressformat sind daher noch nicht bestätigt. Nur Chat; nicht verfügbar mit Copilot Business/Enterprise.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/visual-studio-2026/)[Anwendungsdokumentation ↗](https://devblogs.microsoft.com/visualstudio/visual-studio-september-update-power-your-workflow-with-your-model/)

Vo

### [Void](https://ailoot.ai/docs/de-ch/integrations/void/)

Codeeditor

Wird geprüft

OpenAI Chat

Offener Editor auf Basis von VS Code; Entwicklung eingestellt.

[Mehr erfahren →](https://ailoot.ai/docs/de-ch/integrations/void/)

#### Konfigurationsort

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

#### Konfiguration

Rufen Sie vor dem Start GET /v1/models mit Ihrem Ailoot-Schlüssel ab. Wählen Sie eine genaue Modell-ID mit den Methoden POST /v1/chat/completions und tragen Sie diese ID in die Konfiguration ein. Prüfen Sie bei Agenten auch die Werkzeugunterstützung und die für Ihre Clientversion benötigten Funktionen.

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

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Die Konfiguration stammt aus dem Void-Quellcode, nicht aus der Benutzerdokumentation. Das Void-Repository ist archiviert; der Editor wird nicht mehr weiterentwickelt und eignet sich daher nur für bestehende Nutzende.

[Vollständige Anleitung →](https://ailoot.ai/docs/de-ch/integrations/void/)[Anwendungsdokumentation ↗](https://github.com/voideditor/void/blob/main/src/vs/workbench/contrib/void/common/voidSettingsTypes.ts)

Keine Treffer. Wenn die Anwendung eine eigene OpenAI- oder Anthropic-API-Adresse unterstützt, wird sie wahrscheinlich funktionieren — [diese Angaben benötigen Sie](https://ailoot.ai/docs/de-ch/keys/).

## Derzeit nicht geeignet

In diesen Anwendungen können Sie keine eigene API-Adresse angeben. Daneben stehen passende Alternativen.

| Anwendung | Warum nicht geeignet? | Alternative |
| --- | --- | --- |
| **Cursor CLI (cursor-agent)** | Funktioniert ausschliesslich mit Cursor-Modellen; eine eigene API-Adresse lässt sich nicht festlegen. | Claude Code, Codex CLI oder opencode |
| **Auggie CLI (Augment Code)** | Anmeldung über ein Augment-Konto; ein Drittanbieter lässt sich nicht festlegen. | Claude Code oder opencode |
| **Windsurf / Devin Desktop** | Akzeptiert nur Anthropic-Schlüssel für bestimmte Claude-Modelle; keine eigene Adresse möglich. | Cline, Roo Code oder Kilo Code in VS Code |
| **Kiro** | Kein eigener Schlüssel und keine eigene API-Adresse möglich. | Cline oder Roo Code |
| **Google Antigravity (IDE)** | Keine offizielle Konfiguration für eigene Anbieter; Drittanbieter-Patches empfehlen wir nicht. | Antigravity CLI oder Gemini CLI |
| **Visual Studio mit Copilot Business oder Enterprise** | Bei diesen Copilot-Tarifen sind eigene Modelle nicht verfügbar. | Persönlicher Copilot-Tarif — Karte Visual Studio 2026 |
| **Cursor-Tab-Autovervollständigung** | Verwendet immer Cursor-Modelle, auch mit eigenem Schlüssel. | Der Cursor-Chat wird separat konfiguriert — Karte Cursor |
| **Enchanted** | Funktioniert ausschliesslich mit der Ollama API. | Open WebUI oder Chatbox |
| **Smart Connections (Obsidian)** | Externe APIs sind nur im kostenpflichtigen Smart Chat Pro verfügbar. | Obsidian Copilot |
| **Witsy, 5ire** | Keine offizielle Beschreibung einer eigenen API-Adresse gefunden. | Cherry Studio oder Jan |
| **Make: integriertes OpenAI-Modul** | Verbindet sich ausschliesslich mit einem OpenAI-Konto. | Modul HTTP → Make a request — Karte Make |
| **Zapier: App ChatGPT (OpenAI)** | Kein Feld für eine eigene Adresse. | Webhooks by Zapier → Custom Request — Karte Zapier |
| **Home Assistant: OpenAI Conversation** | Die integrierte Integration funktioniert ausschliesslich mit der OpenAI-Adresse. | Extended OpenAI Conversation aus HACS — Karte Home Assistant |
| **aiogram, python-telegram-bot, grammY, Telegraf** | Bot-Frameworks verbinden sich nicht selbst mit Modellen. | OpenAI oder Anthropic SDK innerhalb des Bots — Karte Telegram-Bot |

## API-Preise und Client-Einrichtung — Deutsch (Schweiz)

### Wie trage ich KI-API-Adresse und Schlüssel in meinen Client ein?

Agenten, Editoren, Chats und SDKs, die den Ailoot-Schlüssel akzeptieren. «Einrichten» zeigt, wo Sie Adresse und Schlüssel eingeben, und eine fertige Konfiguration zum Kopieren.

Verbinden Sie Ailoot mit Claude Code, OpenCode, Hermes oder Ihrer eigenen Anwendung.

## Das Unternehmen und sein Projektportfolio

Das Unternehmen und sein Projektportfolio: Millionen von Kunden; monatliche Umsätze in Milliardenhöhe.

## Tokens mit Rabatt kaufen.

Aborabatt für regelmäßige Arbeit. Aktionscodes bieten bis 50% beim Tokenkauf.

Abo

Wählen Sie einen Tarif mit Rabatt für Ihre regelmäßigen Anfragen.

Aktionscode bis 50%

Geben Sie den Code beim Kauf ein. Der Preis wird nach den gültigen Aktionsbedingungen berechnet.

Ausgaben in der Historie

Modell, Tokens und Betrag werden für jede Anfrage gespeichert.

[Abo wählen](https://ailoot.ai/docs/de-ch/billing/subscriptions/) · [Modellpreise ansehen](https://ailoot.ai/models/de-ch/)

## Verbinden Sie die API mit dem Produkt, das Sie verkaufen.

SaaS, Anwendungen und Bots nach dem offiziellen Angebot und Lizenzvertrag von Ailoot. Fordern Sie für den Weiterverkauf eine Reseller-Lizenz an.

Kommerzielle Anwendung

Integrieren Sie Text-, Bild-, Video- und Audioerzeugung in kostenpflichtige Funktionen Ihres Dienstes.

Reseller-Lizenz

Senden Sie Projektbeschreibung und Zugangsmodell. Fordern Sie schriftliche Nutzungs- und Weiterverkaufsbedingungen an.

Dokumente auf der Website

Offizielles Angebot, Lizenzvertrag und Datenschutzerklärung sind vor der Verbindung zugänglich.

[Reseller-Lizenz anfordern](mailto:support@ailoot.ai) · [Offizielles Angebot und Lizenzvertrag](https://ailoot.ai/legal/offer?lang=de-ch)

## Fragen

Welches Clientformat sollte ich wählen?

Wählen Sie das von Ihrem Client unterstützte Format von OpenAI, Anthropic oder Gemini. Prüfen Sie auf der Ailoot Modellkarte eine kompatible API-Methode und die Modell-ID; die Unterstützung eines Formats bedeutet nicht, dass jedes Modell alle Formate unterstützt.

Was muss ich in meinem Client konfigurieren?

Tragen Sie den Ailoot API-Schlüssel, die API-Adresse und eine mit der Clientmethode kompatible Modell-ID ein. OpenAI SDK verwendet https://api.ailoot.ai/v1; Anthropic und Gemini SDK verwenden https://api.ailoot.ai. Behalten Sie die Anfragefelder aus dem Beispiel für dieses Format bei.

Wie sende ich meine erste API-Anfrage?

Erstellen Sie einen Ailoot API-Schlüssel. Verwenden Sie https://api.ailoot.ai/v1 für OpenAI SDK oder https://api.ailoot.ai für Anthropic und Gemini SDK. GET /v1/models ist kostenlos und listet die für Ihren Schlüssel verfügbaren Modelle auf; verwenden Sie anschließend das Beispiel für das gewählte Modell und die API-Methode.

Was sollte ich prüfen, wenn ein verbundener Client fehlschlägt?

Prüfen Sie, ob der Client das erwartete Format von OpenAI, Anthropic oder Gemini mit Ihrem Ailoot API-Schlüssel an die passende API-Adresse sendet. Überprüfen Sie Modell-ID und Methode und gleichen Sie die zurückgegebene Fehlermeldung mit der Clientanleitung ab. Senden Sie die Fehlermeldung und die Anfrage-ID an support@ailoot.ai, ohne Ihren Schlüssel weiterzugeben.

Kann ich Ailoot in einem kostenpflichtigen Produkt nutzen?

Ja. Verbinden Sie API mit SaaS, Anwendung oder Bot nach dem offiziellen Angebot und Lizenzvertrag von Ailoot. Fordern Sie für Weiterverkauf schriftliche Bedingungen und eine projektspezifische Reseller-Lizenz an.

Wie beantrage ich eine Reseller-Lizenz?

Schreiben Sie an support@ailoot.ai und beschreiben Sie, was Ihr Produkt leistet, wer es nutzt und wie Sie den Zugang bereitstellen. Bitten Sie um eine Reseller-Lizenz und schriftliche Bedingungen für Ihr Projekt.

## Ailoot · Das Unternehmen und sein Projektportfolio





Ailoot baut auf bewährte Betriebserfahrung, einen großen Kundenstamm, stabilen Service und kontinuierliche KPI-Kontrolle.





Das Unternehmen und sein Projektportfolio: Millionen von Kunden; monatliche Umsätze in Milliardenhöhe.





Ailoot nutzt diese Betriebserfahrung für den API-Zugang zu KI-Funktionen in Kundenprodukten, Agenten, Anwendungen und Automatisierungen.