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

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

# Verbinden Sie Ailoot mit Ihren bevorzugten Werkzeugen — KI-API-Schnittstelle und Client-Einrichtung

Agenten, Editoren, Chats und SDKs, die einen Ailoot-Schlüssel akzeptieren. Die Schaltfläche „Einrichten“ zeigt, wo Sie Adresse und Schlüssel einfügen, sowie eine fertige Konfiguration zum Kopieren.

**85**Anwendungen

**77**fertig

**8**werden geprüft

 Anwendung suchen 

## Agenten im Terminal

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

CC

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

Agent im Terminal

Anthropic Messages

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

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

#### Wo die Konfiguration erfolgt

Umgebungsvariablen oder Block "env" in ~/.claude/settings.json (für ein Projekt .claude/settings.local.json); VS Code-Erweiterung über claudeCode.environmentVariables; Prüfung mit /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 beide. CLAUDE\_CODE\_ENABLE\_GATEWAY\_MODEL\_DISCOVERY=1 lädt unsere Modelle über /v1/models in /model. Bei Fehlern 400 wegen unbekannter Felder CLAUDE\_CODE\_DISABLE\_EXPERIMENTAL\_BETAS=1. Die Anthropic-Dokumentation unterstützt Claude Code mit nicht-Claude-Modellen über ein Gateway nicht, auch wenn unser /v1/messages diese bedient; wir empfehlen Claude-Modelle. Remote Control und Spracheingabe sind mit dem Gateway nicht verfügbar.

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

OC

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

Agent im Terminal

OpenAI Responses

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

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

#### Wo die Konfiguration erfolgt

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

#### 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 ausschließlich die OpenAI Responses API (die Dokumentation nennt nur wire\_api = "responses"), daher ist unser /v1/responses erforderlich. Die Anbieter-IDs openai, ollama, lmstudio sind reserviert. Alternative: openai\_base\_url = "https://api.ailoot.ai/v1" für den integrierten Anbieter openai. Ailoot liefert Codex die Modellliste im Format eines Codex-Manifests (GET /v1/models mit client\_version). Wählen Sie ein konkretes Modell, das im Katalog das Format OpenAI Responses bietet. In der Momentaufnahme vom 2026-09-30 bietet gemini-3.6-flash OpenAI Chat, Anthropic Messages und Gemini, aber kein Responses; deshalb eignet sich dieses Modell nicht für Codex. Prüfen Sie die verfügbaren Formate anhand der Modellkarte, nicht anhand des Familiennamens.

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

HA

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

Agent im Terminal

OpenAI ChatOpenAI ResponsesAnthropic Messages

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

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

#### Wo die Konfiguration erfolgt

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 `AILOOT_API_KEY` gelesen — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # Fügen Sie dies zu ~/.zshrc oder ~/.bashrc hinzu
```

```powershell
setx AILOOT_API_KEY "sk-..."   # Starten Sie danach das Terminal neu
```

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. Für anthropic\_messages geben Sie die Adresse ohne /v1 an, das Anthropic-SDK ergänzt /v1/messages selbst. Hilfsaufgaben wie Bilderkennung und Verlaufsverdichtung nutzen standardmäßig dasselbe Hauptmodell.

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

Op

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

Agent im Terminal

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

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

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

#### Wo die Konfiguration erfolgt

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 `AILOOT_API_KEY` gelesen — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # Fügen Sie dies zu ~/.zshrc oder ~/.bashrc hinzu
```

```powershell
setx AILOOT_API_KEY "sk-..."   # Starten Sie danach das Terminal neu
```

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 dies), anthropic-messages, google-generative-ai u. a. Für anthropic-messages steht baseUrl in den OpenClaw-Beispielen ohne /v1. OpenClaw kann Bilder übermitteln, wenn input des Modells "image" enthält. In den Claude-Beispielen wurde nur Text belassen: In der Katalog-Momentaufnahme vom 2026-09-30 weisen diese Methoden keinen image-Eingang aus. Fügen Sie "image" nur für ein konkretes Modell hinzu, dessen Karte im aktuellen Katalog Bildeingaben und das ausgewählte API-Format ausweist. Beispielsweise weist gemini-3.6-flash in dieser Momentaufnahme Bildeingaben für OpenAI Chat aus; die tatsächliche Unterstützung hängt von der Modellkarte und dem Format ab. Der Pfad der Hauptkonfigurationsdatei stammt aus der allgemeinen OpenClaw-Praxis; die gelesene Seite nennt außerdem ~/.openclaw/agents/\<agentId\>/agent/models.json.

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

Op

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

Agent im Terminal

OpenAI Chat

Offener Agent im Terminal mit beliebigen OpenAI-kompatiblen Anbietern.

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

#### Wo die Konfiguration erfolgt

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 `AILOOT_API_KEY` gelesen — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # Fügen Sie dies zu ~/.zshrc oder ~/.bashrc hinzu
```

```powershell
setx AILOOT_API_KEY "sk-..."   # Starten Sie danach das Terminal neu
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Das Paket @ai-sdk/openai-compatible ruft /v1/chat/completions auf. Für Modelle, die /v1/responses benötigen, nennt die opencode-Dokumentation das Paket @ai-sdk/openai. Ein Anthropic-kompatibler Anbieter mit eigener baseURL ist in der opencode-Dokumentation nicht beschrieben. Wählen Sie Modelle, für die der aktuelle Katalog das Format OpenAI Chat ausweist. In der Momentaufnahme vom 2026-09-30 bietet gemini-3.6-flash dieses Format; prüfen Sie andere Gemini-Modelle anhand ihrer Karten. Dieser Weg verwendet nicht das native Gemini-Format. Eine Methode im Katalog bedeutet nicht, dass ein Live-Test mit der konkreten Client-Version durchgeführt wurde.

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

QC

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

Agent im Terminal

OpenAI ChatAnthropic MessagesGemini

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

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

#### Wo die Konfiguration erfolgt

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-..."
# schnelle Methode
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 `AILOOT_API_KEY` gelesen — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # Fügen Sie dies zu ~/.zshrc oder ~/.bashrc hinzu
```

```powershell
setx AILOOT_API_KEY "sk-..."   # Starten Sie danach das Terminal neu
```

Beispielmodell: `qwen3.8-max`

#### Wichtig

Protokolltypen: openai (Chat Completions), anthropic, gemini, vertex-ai. Für openai gilt baseUrl mit /v1. Das Dokumentationsbeispiel für anthropic und gemini enthält keine baseUrl, daher empfehlen wir die openai-Variante. Wählen Sie für den Typ openai ein Modell mit dem Format OpenAI Chat im Katalog: gemini-3.6-flash bietet es. Bei anderen Gemini-Modellen kann die Auswahl der Formate abweichen — prüfen Sie die Karte des konkreten Modells. Die Variante mit settings.json liest den Schlüssel aus der Variable AILOOT\_API\_KEY (Feld envKey): Setzen Sie sie mit export AILOOT\_API\_KEY=sk-... oder mit einer Zeile AILOOT\_API\_KEY=sk-... in ~/.qwen/.env, sonst startet Qwen Code mit einem leeren Schlüssel und erhält 401.

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

GC

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

Agent im Terminal

Gemini

Google-Agent im Terminal mit dem nativen Gemini-Format.

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

#### Wo die Konfiguration erfolgt

Umgebungsvariablen GEMINI\_API\_KEY und GOOGLE\_GEMINI\_BASE\_URL; Anmeldung über ~/.gemini/settings.json → security.auth.selectedType = "gemini-api-key"; Modell über GEMINI\_MODEL oder -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 und von Ailoot akzeptiert. Es eignen sich 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. Kostenpflichtige Gemini-Antworten liefert Ailoot nach der Kostenberechnung vollständig, nicht Wort für Wort; bei langen Antworten erscheint der Text daher nicht sofort.

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

KC

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

Agent im Terminal

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Moonshot-Terminal-Agent für die Arbeit mit Code.

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

#### Wo die Konfiguration erfolgt

~/.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 ist die Google-Stammadresse, bei uns https://api.ailoot.ai). Das Werkzeug SearchWeb funktioniert nur mit der eigenen Moonshot-Plattform; FetchURL verwendet bei einer anderen API-Adresse den lokalen Download.

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

Cr

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

Agent im Terminal

OpenAI ChatAnthropic Messages

Terminal-Agent von Charm mit Konfiguration in der Datei crushrc.

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

#### Wo die Konfiguration erfolgt

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

#### 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 `AILOOT_API_KEY` gelesen — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # Fügen Sie dies zu ~/.zshrc oder ~/.bashrc hinzu
```

```powershell
setx AILOOT_API_KEY "sk-..."   # Starten Sie danach das Terminal neu
```

Beispielmodell: `deepseek-v4-pro`

#### Wichtig

Typ openai-compat verwendet OpenAI Chat mit /v1. Typ anthropic verwendet Messages ohne /v1: Crush übergibt die Adresse an anthropic-sdk-go, das /v1/messages selbst ergänzt. Das Crush-README-Beispiel mit /v1 würde /v1/v1/messages und Fehler 404 erzeugen. Der Schlüssel wird in x-api-key gesendet und von Ailoot akzeptiert. Bei leerer Modellliste lädt openai-compat sie 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 Katalogstand vom 2026-09-30 weist im gewählten Messages-Format nur Text aus. Unterstützt Ihre Crush-Version diesen Schalter, aktivieren Sie ihn nur für ein Modell, dessen aktuelle Katalogkarte image-Eingabe im gewählten API-Format ausweist. Der Client-Schalter allein verleiht einem Modell keine Bildunterstützung.

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

Ai

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

Agent im Terminal

OpenAI Chat

Pair Programming mit KI direkt im git-Repository.

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

#### Wo die Konfiguration erfolgt

Umgebungsvariablen OPENAI\_API\_BASE und OPENAI\_API\_KEY sowie der 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. Darüber sendet Aider über LiteLLM Anfragen an das OpenAI-kompatible /v1/chat/completions. Für Aider unbekannte Modelle führen zu einem Hinweis auf den unbekannten Kontext; das ist kein Fehler. Eine eigene base URL für die Anthropic-Adresse wird auf dieser Dokumentationsseite nicht beschrieben.

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

Go

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

Agent im Terminal

OpenAI ChatAnthropic Messages

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

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

#### Wo die Konfiguration erfolgt

goose configure → Custom Providers → Add A Custom Provider oder JSON in ~/.config/goose/custom\_providers/ (Windows: %APPDATA%\\Block\\goose\\config\\custom\_providers\\); Alternative: eingebauter 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 enthält base\_url für engine openai den vollständigen Pfad zu /v1/chat/completions. Beim eingebauten Anbieter ist OPENAI\_HOST die Hostadresse ohne Pfad und OPENAI\_BASE\_PATH der Pfad, standardmäßig v1/chat/completions. Goose ignoriert Schlüssel in config.yaml; verwendet werden nur Umgebungsvariablen oder der Schlüsselbund. Das Repository ist nach aaif-goose/goose umgezogen.

[Vollständige Anleitung →](https://ailoot.ai/docs/de/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/integrations/factory-droid/)

Agent im Terminal

OpenAI ChatOpenAI ResponsesAnthropic Messages

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

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

#### Wo die Konfiguration erfolgt

~/.factory/settings.json → Array customModels; Modellauswahl mit /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 `AILOOT_API_KEY` gelesen — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # Fügen Sie dies zu ~/.zshrc oder ~/.bashrc hinzu
```

```powershell
setx AILOOT_API_KEY "sk-..."   # Starten Sie danach das Terminal neu
```

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äßig in x-api-key gesendet, von Ailoot akzeptiert; "authMode": "bearer" wechselt zu Authorization. Die Schlüssel bleiben lokal. Factory testet ausschließlich die offiziellen Anthropic- und OpenAI-APIs vollständig.

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

Am

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

Agent im Terminal

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Coding-Agent Amp mit flexibler Modell-Routing-Konfiguration.

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

#### Wo die Konfiguration erfolgt

Einstellungen → Model Routing → Add → Custom URL (oder workspace Model Routing für das Team); 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 gesendet. Das Mapping verwendet kanonische Amp-IDs im Format provider/model; der Pfeil legt die an uns gesendete ID fest. Modelle außerhalb dieser Anbindung bedient Amp selbst gegen eigene Credits. Laut Dokumentation muss der eigene Host für Amp erreichbar sein; die Adresse ist öffentlich, diese Bedingung ist erfüllt.

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

AI

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

Agent im Terminal

OpenAI ChatAnthropic MessagesGemini

Universeller Chat im Terminal mit Rollen, Sitzungen und RAG.

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

#### Wo die Konfiguration erfolgt

AIChat config.yaml → clients (Typen openai-compatible, claude, gemini); Modell über -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 enthält api\_base für claude /v1 und für gemini /v1beta; bei Ailoot ebenso. Die drei Clients erschließen alle drei Ailoot-Formate: OpenAI, Anthropic und Gemini.

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

CC

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

Agent im Terminal

OpenAI Chat

Terminal-Version von Continue für Agenten und Automatisierung.

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

#### Wo die Konfiguration erfolgt

Continue-YAML-Konfiguration (config.yaml), in der CLI mit --config \<path\> ü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 nutzen dasselbe Konfigurationsformat; die Datei wird mit --config übergeben.

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

Fo

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

Agent im Terminal

OpenAI Chat

Terminal-Agent mit konfigurierbaren Anbietern.

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

#### Wo die Konfiguration erfolgt

forge provider login → OpenAI-compatible (empfohlen); 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   # Wählen Sie OpenAI-compatible und geben Sie https://api.ailoot.ai/v1 und sk-... ein

# veraltete Methode (.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 Konfiguration über .env ist als veraltet gekennzeichnet. Beim ersten Start übernimmt Forge die Variablen in seinen Dateispeicher. Die genauen Einträge im Assistenten provider login werden im README nicht genannt.

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

GC

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

Agent im Terminal

OpenAI ChatAnthropic Messages

Copilot im Terminal mit eigenen Modellen.

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

#### Wo die Konfiguration erfolgt

Umgebungsvariablen COPILOT\_PROVIDER\_BASE\_URL, COPILOT\_PROVIDER\_TYPE, COPILOT\_PROVIDER\_API\_KEY, COPILOT\_MODEL (oder --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 (standardmäßig, beliebiger OpenAI-kompatibler Server), azure, anthropic. Das Modell muss Tool-Aufrufe und Streaming unterstützen. COPILOT\_PROVIDER\_WIRE\_API wählt das Protokoll; dessen Werte werden auf der Seite nicht aufgelistet. Limits können mit COPILOT\_PROVIDER\_MAX\_PROMPT\_TOKENS / MAX\_OUTPUT\_TOKENS gesetzt werden.

[Vollständige Anleitung →](https://ailoot.ai/docs/de/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/integrations/gptme/)

Agent im Terminal

OpenAI Chat

Persönlicher Agent im Terminal: Code, Dateien, Browser.

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

#### Wo die Konfiguration erfolgt

~/.config/gptme/config.toml → \[\[providers\]\]; Modellauswahl als \<provider\>/\<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.

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

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

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

KC

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

Agent im Terminal

OpenAI ChatOpenAI ResponsesAnthropic Messages

Terminal-Agent Kilo Code.

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

#### Wo die Konfiguration erfolgt

~/.config/kilo/kilo.jsonc (oder ./kilo.jsonc; außerdem 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 `AILOOT_API_KEY` gelesen — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # Fügen Sie dies zu ~/.zshrc oder ~/.bashrc hinzu
```

```powershell
setx AILOOT_API_KEY "sk-..."   # Starten Sie danach das Terminal neu
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Im Dialog Custom provider stehen folgende Protokolle zur Auswahl: 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 nicht aus der Variable eingesetzt.

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

LL

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

Agent im Terminal

OpenAI ChatOpenAI Responses

Werkzeug für Modellanfragen über die Befehlszeile.

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

#### Wo die Konfiguration erfolgt

Datei extra-openai-models.yaml im Konfigurationsverzeichnis von llm; 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äßig Chat Completions; responses: true schaltet das Modell auf /responses um. Wenn api\_base festgelegt ist, wird der OpenAI-Schlüssel nicht gesendet — api\_key\_name ist erforderlich. Dies ist ein CLI-Werkzeug für Anfragen, kein Agent.

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

MS

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

Agent im Terminal

OpenAI Chat

Minimalistischer Agent für Aufgaben im Repository.

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

#### Wo die Konfiguration erfolgt

YAML-Konfiguration des Agenten → Abschnitt model (model\_name, model\_kwargs); der Standardpfad zur Konfiguration lässt sich mit MSWEA\_MINI\_CONFIG\_PATH ändern

#### 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 aus 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 Preisverzeichnis meldet LiteLLM unbekannte Kosten — deaktivieren Sie die Erfassung mit cost\_tracking: "ignore\_errors" (oder MSWEA\_COST\_TRACKING=ignore\_errors). Die Übergabe des Schlüssels über OPENAI\_API\_KEY ist LiteLLM-Standard, wird aber auf der mini-SWE-agent-Seite selbst nicht gezeigt.

[Vollständige Anleitung →](https://ailoot.ai/docs/de/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/integrations/openhands-cli/)

Agent im Terminal

OpenAI Chat

Autonomer Agent für Entwicklung über die Befehlszeile.

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

#### Wo die Konfiguration erfolgt

Ctrl+P → Settings (Anbieter und Modell), Datei ~/.openhands/agent\_settings.json (llm.model / llm.api\_key / llm.base\_url) oder die Variablen LLM\_MODEL, LLM\_API\_KEY, LLM\_BASE\_URL mit dem Flag --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 Umgebungsvariablen:
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 der Form openai/\<Modell\> und die Base URL des Proxys. Änderungen über --override-with-envs werden nicht gespeichert. In der Weboberfläche: Settings → LLM → Advanced → Custom Model, Base URL, API Key.

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

Pi

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

Agent im Terminal

OpenAI ChatAnthropic MessagesGemini

Minimalistischer Coding-Agent für das Terminal.

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

#### Wo die Konfiguration erfolgt

~/.pi/agent/models.json (oder die projektbezogene .pi/models.json, nachdem dem Projekt vertraut 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 `AILOOT_API_KEY` gelesen — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # Fügen Sie dies zu ~/.zshrc oder ~/.bashrc hinzu
```

```powershell
setx AILOOT_API_KEY "sk-..."   # Starten Sie danach das Terminal neu
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

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

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

Pl

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

Agent im Terminal

OpenAI Chat

Agent für große Aufgaben: Planung, Änderungen in einer Sandbox, Übernahme.

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

#### Wo die Konfiguration erfolgt

plandex models custom (oder \\models custom im REPL) — öffnet eine JSON-Datei mit eigenen Modellen und Anbietern

#### 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 `AILOOT_API_KEY` gelesen — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # Fügen Sie dies zu ~/.zshrc oder ~/.bashrc hinzu
```

```powershell
setx AILOOT_API_KEY "sk-..."   # Starten Sie danach das Terminal neu
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

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

[Vollständige Anleitung →](https://ailoot.ai/docs/de/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/integrations/trae-agent/)

Agent im Terminal

OpenAI ChatAnthropic Messages

ByteDance-Forschungsagent für Entwicklungsaufgaben.

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

#### Wo die Konfiguration erfolgt

trae\_config.yaml → model\_providers.\<Name\>.base\_url; alternativ die 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 verwenden, keine Tabulatoren. Für das Anthropic-Format: provider: anthropic und ANTHROPIC\_BASE\_URL (die genaue Erwartung bezüglich /v1 für anthropic ist in der README nicht angegeben; verwenden Sie https://api.ailoot.ai).

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

Wa

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

Agent im Terminal

OpenAI Chat

Terminal mit integriertem Agenten und eigener Modelladresse.

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

#### Wo die Konfiguration erfolgt

Settings → nach „inference endpoint“ suchen → Custom inference endpoint: Basis-URL, Schlüssel, Modell-IDs; anschließend ein 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
Danach 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 mit jeder Anfrage an das Warp-Backend übermittelt. Die Modi Auto und eigene Router verbrauchen immer Warp-Credits; Cloud-Agenten verwenden diesen Endpunkt nicht. Verfügbar mit Free und kostenpflichtigen Tarifen für Einzelpersonen und Teams mit bis zu 10 Personen. Wählen Sie Modelle, für die der aktuelle Katalog das Format OpenAI Chat ausweist. In der Momentaufnahme vom 2026-09-30 bietet gemini-3.6-flash dieses Format; prüfen Sie andere Gemini-Modelle anhand ihrer Karten. Dieser Weg verwendet nicht das native Gemini-Format. Eine Methode im Katalog bedeutet nicht, dass ein Live-Test mit der konkreten Client-Version durchgeführt wurde.

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

## Editoren und IDE

Erweiterungen und integrierte Assistenten für Codeeditoren.

Cl

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

Editor-Erweiterung

OpenAI ChatAnthropic Messages

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

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

#### Wo die Konfiguration erfolgt

Cline-Seitenleiste → 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äß Modell; Image Support — nur für Modelle, die Bilder erkennen.

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 Anthropic-Variante verwendet /v1/messages und eine Adresse ohne /v1, listet jedoch nur Anthropic-Modellnamen; andere Ailoot-Modelle sind über OpenAI Compatible verfügbar. Der Agentenmodus benötigt ein Modell mit Tool-Aufrufen. Gemini 3.1 Pro ist über chat/completions nicht verfügbar, sondern nur in Gemini- und Anthropic-Formaten; verwenden Sie hier gemini-3.6-flash.

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

RC

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

Editor-Erweiterung

OpenAI ChatAnthropic Messages

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

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

#### Wo die Konfiguration erfolgt

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 das Kontrollkästchen „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, die Adresse ohne /v1.

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

KC

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

Editor-Erweiterung

OpenAI Chat

Agent in VS Code mit verschiedenen Modi und eigenen Modellen.

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

#### Wo die Konfiguration erfolgt

Settings (Zahnrad) → Registerkarte Providers → unten „Custom provider“ → Provider ID, Display name, Provider API = „OpenAI Compatible“, Base URL, API key, Models (die 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 wä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 lässt sich angeben. Eigene Header werden unterstützt.

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

Co

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

Editor-Erweiterung

OpenAI Chat

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

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

#### Wo die Konfiguration erfolgt

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 ausdrücklich /chat/completions verwendet werden soll
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

apiBase muss auf /v1 enden. Bei Namen wie gpt-5 oder der o-Serie kann Continue selbst /v1/responses wählen. Unsere gpt-\* unterstützen /v1/responses und /v1/chat/completions; useResponsesApi: false erzwingt chat/completions. useLegacyCompletionsEndpoint wird nicht benötigt.

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

Ze

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

Code-Editor

OpenAI ChatOpenAI ResponsesAnthropic Messages

Schneller Code-Editor mit integriertem Agenten.

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

#### Wo die Konfiguration erfolgt

Agent Settings (agent::OpenSettings) → LLM Providers → Add Provider; oder settings.json → language\_models.openai\_compatible / language\_models.anthropic\_compatible. Schlüssel — im Einstellungsfenster (wird im System-Schlü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 schaltet das Modell auf /v1/responses um). Bei anthropic\_compatible ist die Adresse ohne /v1 (verwendet /v1/messages; Zed sendet den Schlüssel in x-api-key — Ailoot akzeptiert ihn). Standardmäßig gelten images = false und parallel\_tool\_calls = false. Zed kann Bilder übermitteln; aktivieren Sie images aber nur für ein konkretes Modell, dessen aktuelle Katalogkarte Bildeingaben im ausgewählten API-Format ausweist. In den GPT- und Claude-Beispielen gilt images = false: Die Momentaufnahme vom 2026-09-30 weist für sie nur Text aus. Beispielsweise weist gemini-3.6-flash in dieser Momentaufnahme Bildeingaben für OpenAI Chat aus; die tatsächliche Unterstützung hängt von der Modellkarte und dem Format ab. Für Modelle mit Reasoning gibt es das Feld reasoning\_effort. Die max\_tokens-Werte im Beispiel geben die Kontextgröße an; die genauen Limits finden Sie im Modellkatalog.

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

VC

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

Editor-Erweiterung

OpenAI ChatOpenAI ResponsesAnthropic Messages

Eigener Anbieter in Copilot Chat für VS Code.

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

#### Wo die Konfiguration erfolgt

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 Endpunktpfad. 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 Token-Limits sind Beispiele; verwenden Sie die Katalogwerte. In diesen Beispielen gilt vision = false: Die Katalog-Momentaufnahme vom 2026-09-30 weist für GPT/OpenAI Chat und Claude/Anthropic Messages nur Text aus. Falls Ihre VS-Code-Version vision anbietet, aktivieren Sie es nur für ein Modell, dessen aktuelle Katalogkarte Bildeingaben im ausgewählten API-Format ausweist; ein Feld im Client bestätigt keine Bildunterstützung durch das ausgewählte Modell.

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

JA

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

Code-Editor

OpenAI Chat

Integrierter Assistent für JetBrains-IDEs mit eigenem Schlüssel.

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

#### Wo die Konfiguration erfolgt

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/integrations/jetbrains-ai-assistant/)[Anwendungsdokumentation ↗](https://www.jetbrains.com/help/ai-assistant/use-custom-models.html)

Xc

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

Code-Editor

OpenAI Chat

Coding Intelligence in Xcode mit externem Anbieter.

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

#### Wo die Konfiguration erfolgt

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
→ wählen Sie danach Modelle aus der Liste (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 und {URL}/v1/chat/completions antwortet. Ailoot akzeptiert den Schlüssel in x-api-key und in Authorization: Bearer (wenn der Header Authorization ausgewählt wird, ergänzt Xcode Berichten zufolge das Präfix Bearer selbst). Xcode-Agenten werden separat konfiguriert und sind nicht Teil dieser Anleitung.

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

AN

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

Neovim-Plugin

OpenAI ChatAnthropic Messages

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

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

#### Wo die Konfiguration erfolgt

opts für yetone/avante.nvim in lazy.nvim: opts.providers.\<Name\> mit \_\_inherited\_from = 'openai' (eigener OpenAI-kompatibler Anbieter) oder Überschreiben von providers.claude.endpoint; 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 eingebaute Anbieter claude verwendet eine Adresse wie https://api.anthropic.com, für Ailoot also ohne /v1. Eigene Anbieter ohne \_\_inherited\_from benötigen die vollständige Adresse und eigene Funktionen zum Parsen der Antwort.

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

CN

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

Neovim-Plugin

OpenAI ChatAnthropic Messages

Chat und Inline-Änderungen in Neovim.

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

#### Wo die Konfiguration erfolgt

require('codecompanion').setup({ adapters = { http = { ... } } }) über adapters.extend('openai\_compatible', ...) oder extend('anthropic', ...); anschließend 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 `AILOOT_API_KEY` gelesen — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # Fügen Sie dies zu ~/.zshrc oder ~/.bashrc hinzu
```

```powershell
setx AILOOT_API_KEY "sk-..."   # Starten Sie danach das Terminal neu
```

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

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

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

Gp

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

Emacs-Paket

OpenAI ChatAnthropic MessagesGemini

Einfacher Client für Sprachmodelle in Emacs.

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

#### Wo die Konfiguration erfolgt

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

#### 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 `AILOOT_API_KEY` gelesen — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # Fügen Sie dies zu ~/.zshrc oder ~/.bashrc hinzu
```

```powershell
setx AILOOT_API_KEY "sk-..."   # Starten Sie danach das Terminal neu
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

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

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

TI

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

Code-Editor

OpenAI Chat

Offene IDE mit Theia-AI-Modul.

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

#### Wo die Konfiguration erfolgt

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 mit /v1. Für Modelle, die nicht von OpenAI stammen, ist developerMessageSettings: "system" die sichere Wahl.

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

TI

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

Code-Editor

OpenAI ChatAnthropic Messages

Trae-Code-Editor mit eigenen Modellen.

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

#### Wo die Konfiguration erfolgt

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 ausgewählten Formats selbst (für OpenAI eine Adresse mit /v1, für Anthropic ohne /v1). Bei aktiviertem Full URL geben Sie https://api.ailoot.ai/v1/chat/completions oder https://api.ailoot.ai/v1/messages ein. Das Feld Model Series passt die Prompts an die Modellfamilie an.

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

## Chat-Anwendungen

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

OW

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

Webchat, eigener Server

OpenAI Chat

Beliebter Webchat auf dem eigenen Server.

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

#### Wo die Konfiguration erfolgt

Settings \> Admin \> Connections \> Manage OpenAI API Connections \> + Add Connection (oder die Umgebungsvariablen 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 lassen (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 nicht mit einem Schrägstrich enden. Die Modellliste wird aus /v1/models geladen; bei einem großen Katalog (252 Modelle) empfiehlt es sich, Model IDs einzuschränken und den Modelllisten-Cache zu aktivieren (Cache Base Model List / ENABLE\_BASE\_MODELS\_CACHE=True). Für RAG-Embeddings gibt es die separate Einstellung RAG\_OPENAI\_API\_BASE\_URL.

[Vollständige Anleitung →](https://ailoot.ai/docs/de/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/integrations/librechat/)

Webchat, eigener Server

OpenAI ChatAnthropic Messages

Webchat auf dem eigenen Server mit Agenten und mehreren Anbietern.

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

#### Wo die Konfiguration erfolgt

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

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

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

CS

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

Desktop-Anwendung

OpenAI ChatOpenAI ResponsesAnthropic Messages

Desktop-Client mit Assistenten und Wissensdatenbank.

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

#### Wo die Konfiguration erfolgt

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
→ Prüfen Sie die Vorschau der endgültigen Adresse unter dem Feld: erwartet wird 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
Danach auf Model Check klicken
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Die Dokumentation bestätigt die Protokolle OpenAI, Anthropic, OpenAI Responses und Gemini sowie die Vorschau des endgültigen Pfads unter dem Feld. Regeln zum Ergänzen von /v1 werden nicht erläutert; orientieren Sie sich an der Vorschau. Alle drei unserer Formate (Chat Completions, Responses, Messages) eignen sich.

[Vollständige Anleitung →](https://ailoot.ai/docs/de/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/integrations/chatbox/)

Computer und Smartphone

OpenAI Chat

Chat für Computer und Smartphone.

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

#### Wo die Konfiguration erfolgt

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 lassen, Standard ist /v1/chat/completions)
Models: + gpt-6.1-sol, claude-sonnet-5-5 (vision ist in diesen Beispielen deaktiviert; tool_use — je nach Fähigkeiten des gewählten Modells)
```

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

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

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

Lo

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

Webchat, eigener Server

OpenAI ChatAnthropic Messages

Moderner Chat mit Plugins und Wissensdatenbank.

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

#### Wo die Konfiguration erfolgt

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äßig https://api.openai.com/v1, daher mit /v1 angeben. ANTHROPIC\_PROXY\_URL ist standardmäßig https://api.anthropic.com (ohne /v1). Über GOOGLE\_PROXY\_URL lässt sich grundsätzlich das Gemini-Format anbinden (https://api.ailoot.ai), diesen Weg haben wir aber nicht geprüft. Verwenden Sie den Servermodus: Bei direkten Anfragen aus dem Browser kann die Ailoot-API diese derzeit aufgrund der CORS-Regeln ablehnen.

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

Ja

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

Desktop-Anwendung

OpenAI ChatAnthropic Messages

Offener Desktop-Chat mit lokalen und Cloud-Modellen.

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

#### Wo die Konfiguration erfolgt

Settings \> Model Providers \> Add Provider → das Format OpenAI-compatible oder Anthropic-compatible auswä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: Für OpenAI-kompatible Anbieter muss die Base URL /v1 enthalten (sonst 404); ein abschließender Schrägstrich wird entfernt. Für den Anthropic-Modus enthält das LiteLLM-Beispiel kein /v1. Modellfähigkeiten (tools, vision) werden bei eigenen Anbietern manuell festgelegt. Reserveschlüssel werden unterstützt (erneuter Versuch nur bei 401/403/429).

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

Si

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

Rollenspiel-Chat

OpenAI Chat

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

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

#### Wo die Konfiguration erfolgt

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) wählen oder claude-sonnet-5-5 eingeben
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Dokumentation: Bei Verbindungsproblemen /v1 hinzufügen und /chat/completions NICHT hinzufügen. Die Modellliste wird geladen, wenn der Server /v1/models bereitstellt (unser Server tut dies).

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

An

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

Chat mit Dokumenten

OpenAI Chat

Chat mit Ihren Dokumenten auf dem Computer oder Server.

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

#### Wo die Konfiguration erfolgt

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 = je nach 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. Bei Bedarf GENERIC\_OPEN\_AI\_MODEL\_MAX\_TOKEN\_KEY='max\_completion\_tokens'. Für Embeddings existiert ein separater 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/integrations/anythingllm/)[Anwendungsdokumentation ↗](https://docs.anythingllm.com/setup/llm-configuration/cloud/openai-generic)

BA

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

Webchat, eigener Server

OpenAI ChatAnthropic Messages

Erweiterte Weboberfläche für die Arbeit mit mehreren Modellen.

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

#### Wo die Konfiguration erfolgt

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 für den backend host von OpenAI und Anthropic, für Proxys und eigene Endpunkte. Da „host“ angegeben ist, verwenden wir die Adresse ohne /v1. Das genaue Pfadformat wird nicht erläutert; prüfen Sie es mit der ersten Anfrage.

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

Bo

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

Mac-Anwendung

OpenAI Chat

Nativer KI-Client für macOS.

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

#### Wo die Konfiguration erfolgt

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: je nach Modell
Streaming: aktivieren
```

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

Die vollständige Adresse von chat completions ist erforderlich. Damit AI Command diesen Dienst nutzt, legen Sie ihn 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/integrations/boltai/)[Anwendungsdokumentation ↗](https://boltai.com/help/how-to-setup-custom-openai-server)

HF

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

Webchat, eigener Server

OpenAI Chat

Offener Hugging-Face-Webchat auf dem eigenen Server.

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

#### Wo die Konfiguration erfolgt

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 arbeitet ausschließlich mit OpenAI-kompatiblen APIs über OPENAI\_BASE\_URL und lädt die Modellliste aus /models.

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

MS

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

Desktop-Anwendung

OpenAI Chat

Desktop-Chat mit lokalen und Cloud-Modellen.

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

#### Wo die Konfiguration erfolgt

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, gibt aber kein Adressformat an; /v1 ist die übliche Basis der OpenAI-API. Prüfen Sie bei einem Fehler 404 die Variante ohne /v1. Ein eigener Anthropic-kompatibler Endpunkt ist in der Dokumentation nicht beschrieben.

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

Ne

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

Webchat, eigener Server

OpenAI Chat

Leichtgewichtiger Webchat, der sich schnell bereitstellen lässt.

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

#### Wo die Konfiguration erfolgt

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/integrations/nextchat/)[Anwendungsdokumentation ↗](https://github.com/ChatGPTNextWeb/NextChat#environment-variables)

OC

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

Obsidian-Plugin

OpenAI Chat

Chat mit Obsidian-Notizen.

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

#### Wo die Konfiguration erfolgt

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)
Danach Test; das Modell unter Basic > Agents > Quick Chat aktivieren
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Die Modellliste wird aus /v1/models geladen; Modelle lassen sich auch manuell eingeben. Wenn Test erfolgreich ist, Quick Chat aber keine Nachrichten sendet, aktivieren Sie Enable CORS beim Anbieter (die Antwort kommt vollständig, ohne Streaming). Schlüssel werden in Obsidian Keychain gespeichert.

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

PA

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

Browser-Erweiterung

OpenAI Chat

Browser-Erweiterung: Chat mit der geöffneten Seite.

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

#### Wo die Konfiguration erfolgt

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-...
Danach 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; das URL-Format wird nicht erläutert, /v1 ist die übliche Basis der OpenAI-API. Das automatische 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/integrations/page-assist/)[Anwendungsdokumentation ↗](https://docs.pageassist.xyz/providers/openai)

RA

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

Launcher

OpenAI Chat

KI im Raycast-Launcher: schnelle Befehle und Chat.

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

#### Wo die Konfiguration erfolgt

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 Endpunkt ohne das Suffix /chat/completions. Raycast liest die Datei ohne Neustart erneut ein. Wenn abilities nicht festgelegt sind, gelten tools und vision als nicht unterstützt. Die Modelle erscheinen in Quick AI, AI Chat und AI Commands. In diesem Beispiel gilt vision.supported = false: Die Katalog-Momentaufnahme vom 2026-09-30 weist für Claude/OpenAI Chat nur Text aus. Falls Ihre Raycast-Version diese Einstellung unterstützt, aktivieren Sie vision nur für ein Modell, dessen aktuelle Katalogkarte Bildeingaben im Format OpenAI Chat ausweist; das Client-Flag allein bestätigt keine Bildunterstützung durch die API.

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

Ty

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

Webanwendung

OpenAI Chat

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

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

#### Wo die Konfiguration erfolgt

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: je nach Modell
Test → Save
```

Beispielmodell: `claude-sonnet-5-5`

#### Wichtig

Endpoint wird als vollständiger Pfad eingegeben. Der Schlüssel wird mit dem eigenen Header Authorization: Bearer sk-... übermittelt — Ailoot akzeptiert ihn. Die Webversion von TypingMind ruft die API direkt aus dem Browser auf; derzeit können solche Anfragen durch CORS blockiert werden. Die Desktop-Version ist zuverlässiger. Der Typ Gemini in TypingMind sendet den Schlüssel im Header apiKey, den Ailoot nicht akzeptiert — verwenden Sie den Typ OpenAI Chat Completions.

[Vollständige Anleitung →](https://ailoot.ai/docs/de/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/integrations/openai-python-sdk/)

SDK

OpenAI ChatOpenAI Responses

Offizielle OpenAI-Bibliothek für Python.

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

#### Wo die Konfiguration erfolgt

Konstruktorparameter OpenAI(base\_url=..., api\_key=...) oder die 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 fügt /chat/completions, /responses, /embeddings, /images/\*, /audio/\* selbst hinzu. Chat Completions und Responses funktionieren (Responses bei Modellen, für die der Katalog dieses Format ausweist). Streaming-Ausgabe und Werkzeuge entsprechen dem Standard. Ailoot-Fehler kommen als JSON mit Request ID und werden als openai.APIStatusError abgefangen.

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

OS

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

SDK

OpenAI ChatOpenAI Responses

Offizielle OpenAI-Bibliothek für JavaScript und TypeScript.

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

#### Wo die Konfiguration erfolgt

Konstruktoroption new OpenAI({ baseURL, apiKey }); standardmäßig 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 `AILOOT_API_KEY` gelesen — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # Fügen Sie dies zu ~/.zshrc oder ~/.bashrc hinzu
```

```powershell
setx AILOOT_API_KEY "sk-..."   # Starten Sie danach das Terminal neu
```

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

#### Wichtig

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

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

AS

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

SDK

Anthropic Messages

Offizielle Anthropic-Bibliothek für Python.

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

#### Wo die Konfiguration erfolgt

Parameter Anthropic(base\_url=...) oder Umgebungsvariable ANTHROPIC\_BASE\_URL; Schlüssel über 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, wie ihn das SDK sendet, und in Authorization: Bearer. Streaming, Tools 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/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/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/integrations/vercel-ai-sdk/)

#### Wo die Konfiguration erfolgt

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 `AILOOT_API_KEY` gelesen — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # Fügen Sie dies zu ~/.zshrc oder ~/.bashrc hinzu
```

```powershell
setx AILOOT_API_KEY "sk-..."   # Starten Sie danach das Terminal neu
```

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

#### Wichtig

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

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

La

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

Framework

OpenAI ChatOpenAI ResponsesAnthropic Messages

Framework für Chains, Agenten und RAG.

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

#### Wo die Konfiguration erfolgt

ChatOpenAI(base\_url=...) oder die 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 standardmäßige Felder wie reasoning\_content bei Modellen anderer Anbieter werden nicht gespeichert. Für Claude eignet sich ChatAnthropic besser: Adresse ohne /v1, das SDK fügt /v1/messages selbst hinzu. Der Parameter base\_url und die Variablen ANTHROPIC\_API\_URL/ANTHROPIC\_BASE\_URL von ChatAnthropic sind in der Klassendokumentation im Quellcode beschrieben (langchain\_anthropic/chat\_models.py), nicht auf der Integrationsseite. Das Flag use\_responses\_api aktiviert bei ChatOpenAI den Responses-Modus.

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

Cr

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

Agenten-Framework

OpenAI ChatAnthropic Messages

Agententeams mit Rollen und Aufgaben.

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

#### Wo die Konfiguration erfolgt

crewai.LLM(model=..., base\_url=..., api\_key=...); Umgebungsvariablen 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. Für OpenAI die Adresse mit /v1, für Anthropic ohne /v1. Die Dokumentation beschreibt außerdem custom\_openai=True für beliebige OpenAI-kompatible Gateways. Bei Anthropic ist max\_tokens erforderlich.

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

GG

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

SDK

Gemini

Offizielle Google-Bibliothek für die Gemini API.

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

#### Wo die Konfiguration erfolgt

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 in x-goog-api-key gesendet und von Ailoot akzeptiert. Verfügbar sind nur Modelle mit Gemini-Format. Eine eigene Adresse für die JavaScript-Version (@google/genai) wird in der Dokumentation nicht beschrieben; deshalb zeigen wir sie hier nicht.

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

Li

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

SDK

OpenAI Chat

Einheitliche Python-Schnittstelle zu Dutzenden von Anbietern.

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

#### Wo die Konfiguration erfolgt

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; an Ailoot wird die id ohne Präfix übermittelt. LiteLLM fügt /chat/completions und /embeddings selbst hinzu; laut Dokumentation muss die Adresse bei einem Fehler Not Found mit /v1 enden.

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

LP

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

Eigenes Gateway

OpenAI Chat

Eigenes Gateway mit Schlüsseln, Limits und Logs auf Basis von Ailoot.

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

#### Wo die Konfiguration erfolgt

config.yaml → model\_list → litellm\_params (model, api\_base, api\_key); Start mit 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 `AILOOT_API_KEY` gelesen — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # Fügen Sie dies zu ~/.zshrc oder ~/.bashrc hinzu
```

```powershell
setx AILOOT_API_KEY "sk-..."   # Starten Sie danach das Terminal neu
```

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

#### Wichtig

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

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

Ll

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

Framework

OpenAI Chat

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

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

#### Wo die Konfiguration erfolgt

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 — damit Agenten Werkzeuge verwenden. Legen Sie context\_window anhand der Modellkarte im Ailoot-Katalog fest.

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

Ma

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

Agenten-Framework

OpenAI ChatOpenAI Responses

TypeScript-Framework für Agenten und Workflows.

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

#### Wo die Konfiguration erfolgt

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 `AILOOT_API_KEY` gelesen — setzen Sie sie vor dem Start:

```bash
export AILOOT_API_KEY="sk-..."   # Fügen Sie dies zu ~/.zshrc oder ~/.bashrc hinzu
```

```powershell
setx AILOOT_API_KEY "sk-..."   # Starten Sie danach das Terminal neu
```

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

#### Wichtig

In url wird die Basisadresse mit /v1 angegeben, nicht der vollständige Pfad zu /chat/completions. Standardmäßig wird Chat Completions verwendet; api: "responses" schaltet auf die Responses API um. Die id-Form "Anbieter/Modell" sendet die reine Modell-id an das Gateway. Das Feld apiKey im Objekt model wird in der Dokumentation in einem Beispiel mit Headern gezeigt; zusammen mit url wird es nicht gesondert beschrieben.

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

OA

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

Agenten-Framework

OpenAI ChatOpenAI Responses

OpenAI-Bibliothek für Szenarien mit mehreren Agenten.

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

#### Wo die Konfiguration erfolgt

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): Andernfalls versucht das SDK, Traces an OpenAI zu senden, obwohl der OpenAI-Schlüssel fehlt. Chat Completions ist nur für Modelle verfügbar, bei denen diese Methode im Katalog angegeben 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 externes Gateway nicht garantiert.

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

PA

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

Agenten-Framework

OpenAI ChatOpenAI Responses

Typisiertes Agenten-Framework in Python.

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

#### Wo die Konfiguration erfolgt

OpenAIProvider(base\_url=..., api\_key=...) mit dem Modell OpenAIChatModel (Chat Completions) oder OpenAIResponsesModel (Responses); alternativ die 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äßig OpenAIResponsesModel: Nutzen Sie es nur für Modelle mit der Methode responses; für alle anderen OpenAIChatModel.

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

## Automatisierung

No-Code-Workflows, Chain-Builder, Bots und Smart Home.

N8

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

No-Code-Automatisierung

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Automatisierung von Workflows mit KI-Agenten-Knoten.

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

#### Wo die Konfiguration erfolgt

Credentials → OpenAI → Feld Base URL (standardmäßig https://api.openai.com/v1); Credentials → Anthropic → Base URL (standardmäßig https://api.anthropic.com); Credentials → Google Gemini(PaLM) Api → Host (standardmäßig https://generativelanguage.googleapis.com). Anschließend 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-...
Knoten 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 Prüfung der Zugangsdaten ruft /models (OpenAI), /v1/models (Anthropic) und /v1beta/models (Gemini) auf; Ailoot bietet alle drei Pfade. Das Feld Base URL ist auf den n8n-Dokumentationsseiten nicht beschrieben: Es befindet sich in den Zugangsdaten selbst (Quelldateien OpenAiApi.credentials.ts und AnthropicApi.credentials.ts, Beschriftung „Override the default base URL for the API“). Wählen Sie in n8n Cloud nicht „Use Gateway credits“, sonst laufen die Anfragen nicht über Ailoot.

[Vollständige Anleitung →](https://ailoot.ai/docs/de/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/integrations/dify/)

Plattform für LLM-Anwendungen

OpenAI Chat

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

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

#### Wo die Konfiguration erfolgt

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äß 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

Anbieter können nur der Eigentümer und die Administratoren des Workspaces verwalten. Laut Plugin-README benötigen LLMs /v1; für Embeddings, rerank, STT und TTS ergänzt das Plugin die API-Version selbst, also ohne /v1, sonst entsteht /v1/v1. Fügen Sie jedes Ailoot-Modell als eigenen Eintrag hinzu. Bildinput und Streaming werden in den Modelleinstellungen aktiviert.

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

Fl

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

Chain-Builder

OpenAI Chat

Visueller Builder für Chains und Agenten.

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

#### Wo die Konfiguration erfolgt

Node 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-...
Knoten 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

ChatOpenAI hat eine feste Modellliste. Für beliebige id-Werte von Ailoot verwenden Sie ChatOpenAI Custom, wo der Modellname manuell eingetragen wird. Base Path mit /v1. Für Embeddings existiert die Node OpenAI Embeddings Custom.

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

HA

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

Smart Home

OpenAI Chat

Smart-Home-Sprachassistent über Extended OpenAI Conversation.

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

#### Wo die Konfiguration erfolgt

Über HACS (Custom repository) installieren oder custom\_components/extended\_openai\_conversation kopieren → neu starten → 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. Gerätesteuerung erfolgt über Funktionsaufrufe (tools) in Chat Completions; wählen Sie deshalb Modelle mit Tool-Unterstützung. Die offizielle Integration OpenAI Conversation unterstützt keine eigene Adresse.

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

La

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

Chain-Builder

OpenAI Chat

Visueller Builder für Agenten und RAG.

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

#### Wo die Konfiguration erfolgt

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-..."
Danach in den Komponenten Language Model / Agent OpenAI Compatible → claude-sonnet-5-5 wä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 in den Bereichen Language Models und Embedding Models. Die benötigten Modelle müssen anschließend manuell aktiviert werden. Der Anbieter wird zusammen mit langflow installiert.

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

Ma

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

No-Code-Automatisierung

HTTP-Anfrage

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

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

#### Wo die Konfiguration erfolgt

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 universelles HTTP-Modul, kein eigener Anbieter für Ailoot: Die Dokumentation beschreibt eine beliebige HTTPS-Adresse. Speichern Sie den Schlüssel vorzugsweise in einer Verbindung mit API-Schlüssel (Make empfiehlt dies statt der Übermittlung in Headern). Streaming-Ausgabe ist in Make nicht nötig; senden Sie Anfragen ohne stream.

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

T

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

Bots

OpenAI Chat

Eigener Telegram-Bot mit dem OpenAI SDK.

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

#### Wo die Konfiguration erfolgt

Telegram-Frameworks haben keine eigene LLM-Schicht: Der Nachrichtenhandler ruft das OpenAI SDK mit der base\_url von Ailoot auf (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 Schicht für KI-Modelle: Die Ailoot-Adresse wird im OpenAI SDK innerhalb des Bots festgelegt. Bei einem Ailoot-Guthaben von null wird ein verständlicher Fehler 402 mit Request ID zurückgegeben — zeigen Sie ihn dem Bot-Nutzer an, statt den Bot abstürzen zu lassen.

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

Za

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

No-Code-Automatisierung

HTTP-Anfrage

Automatisierung: Anfrage an Ailoot über Webhooks by Zapier.

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

#### Wo die Konfiguration erfolgt

Die App ChatGPT (OpenAI) in Zapier 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 universelle HTTP-Anfrage; Zapier bietet keinen fertigen Anbieter mit einem Feld für die Basisadresse. Custom Request sendet das Feld Data unverändert und ohne Auswertung, daher muss das JSON vorher geprüft werden. Webhooks by Zapier ist in kostenpflichtigen Zapier-Tarifen verfügbar.

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

## In Prüfung

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

AC

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

Agent im Terminal

In Prüfung

Gemini

Google-Antigravity-Terminal-Agent mit dem Gemini-Format.

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

#### Wo die Konfiguration erfolgt

~/.gemini/antigravity-cli/settings.json → "modelProvider": "gemini"; Umgebungsvariablen 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

Das Protokoll ist natives Gemini REST (streamGenerateContent, Schlüssel in X-Goog-Api-Key), Pfad https://api.ailoot.ai/v1beta/... Für eine Frage sendet agy zwei Anfragen: Gesprächstitel und eigentliche Antwort. Der Agent reserviert pro Schritt deutlich mehr als ein gewöhnlicher Chat; halten Sie zusätzliches Guthaben bereit. Die Karte steht unter „In Prüfung“: Die Konfiguration beruht auf der Dokumentation, ein echter Client-Durchlauf über Ailoot wurde noch nicht ausgeführt. Bei modelProvider = gemini und leerem GEMINI\_API\_KEY startet die CLI nicht.

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

CC

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

Agent im Terminal

In Prüfung

OpenAI Chat

Terminal-Version des Cline-Agenten.

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

#### Wo die Konfiguration erfolgt

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 werden in der Cline-Dokumentation zu OpenAI Compatible beschrieben. Die genauen Einträge des Assistenten cline auth stehen nicht in der CLI-Dokumentation; vergleichen Sie mit der Anzeige.

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

CJ

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

Editor-Erweiterung

In Prüfung

OpenAI Chat

Eigene Modelladresse in Copilot für JetBrains-IDEs.

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

#### Wo die Konfiguration erfolgt

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/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/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/integrations/cursor/)

Code-Editor

In Prüfung

OpenAI Chat

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

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

#### Wo die Konfiguration erfolgt

Cursor Settings → Models → API Keys → OpenAI API Key + Schalter „Override OpenAI Base URL“; anschließend die Modell-ID zu Ihren eigenen Modellen hinzufügen.

#### 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 und im Chat auswählen)
```

Beispielmodell: `gpt-6.1-sol`

#### Wichtig

Die derzeitige 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 nutzt weiterhin Cursor-Modelle), und dass alle Anfragen über Cursor-Server laufen. Die Adresse muss öffentlich sein; api.ailoot.ai ist öffentlich. Der Adressschalter existiert in der Oberfläche, aber im Cursor-Forum werden Fehler gemeldet: Er gilt für alle Modelle, der Agent-Modus verwendet möglicherweise nicht den eigenen Schlüssel, und in einigen Builds von 3.15.x nimmt das Feld keine Eingabe an.

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

OT

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

Obsidian-Plugin

In Prüfung

OpenAI Chat

Textgenerierung in Obsidian-Notizen anhand von Vorlagen.

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

#### Wo die Konfiguration erfolgt

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; die Konfiguration folgt der Plugin-Oberfläche — vergleichen Sie sie mit dem Einstellungsfenster.

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

Pe

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

Code-Editor

In Prüfung

OpenAI Chat

PearAI-Editor auf Basis von VS Code.

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

#### Wo die Konfiguration erfolgt

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

#### 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 ließ sich nicht prüfen (die Dokumentationswebsite war nicht erreichbar); das Repository wurde seit Langem nicht aktualisiert. Die Konfigurationsstruktur folgt dem Beispiel von Continue — prüfen Sie sie in der Anwendung.

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

VS

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

Code-Editor

In Prüfung

OpenAI Chat

Eigener Anbieter in Copilot Chat für Visual Studio.

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

#### Wo die Konfiguration erfolgt

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 jedoch weiterhin nur OpenAI/Anthropic/Google-Schlüssel ohne Adressfeld; Feldnamen und Adressformat sind deshalb noch nicht bestätigt. Nur Chat; in den Tarifen Copilot Business/Enterprise nicht verfügbar.

[Vollständige Anleitung →](https://ailoot.ai/docs/de/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/integrations/void/)

Code-Editor

In Prüfung

OpenAI Chat

Offener Editor auf Basis von VS Code; die Entwicklung wurde eingestellt.

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

#### Wo die Konfiguration erfolgt

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 — er eignet sich nur für Personen, die ihn bereits verwenden.

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

Keine Ergebnisse. Wenn die Anwendung eine eigene OpenAI- oder Anthropic-API-Adresse unterstützt, funktioniert sie wahrscheinlich — [hier erfahren Sie, was Sie angeben müssen](https://ailoot.ai/docs/de/keys/).

## Derzeit nicht geeignet

In diesen Anwendungen lässt sich keine eigene API-Adresse angeben. Daneben finden Sie passende Alternativen.

| Anwendung | Warum sie nicht geeignet ist | Alternative |
| --- | --- | --- |
| **Cursor CLI (cursor-agent)** | Funktioniert nur mit Modellen von Cursor; 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 externer Anbieter lässt sich nicht angeben. | Claude Code oder opencode |
| **Windsurf / Devin Desktop** | Akzeptiert nur einen Anthropic-Schlüssel für einzelne Claude-Modelle; eine eigene Adresse lässt sich nicht festlegen. | Cline, Roo Code oder Kilo Code in VS Code |
| **Kiro** | Keine Unterstützung für einen eigenen Schlüssel und eine eigene API-Adresse. | Cline oder Roo Code |
| **Google Antigravity (IDE)** | Keine offizielle Einstellung für einen eigenen Anbieter; wir empfehlen keine inoffiziellen Patches. | Antigravity CLI oder Gemini CLI |
| **Visual Studio mit Copilot Business oder Enterprise** | In diesen Copilot-Tarifen sind eigene Modelle nicht verfügbar. | Persönlicher Copilot-Tarif — Integrationskarte Visual Studio 2026 |
| **Cursor Tab-Autovervollständigung** | Verwendet immer Modelle von Cursor, auch mit einem eigenen Schlüssel. | Der Cursor-Chat wird separat konfiguriert — Integrationskarte Cursor |
| **Enchanted** | Funktioniert nur 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** | Wir haben keine offizielle Beschreibung für eine eigene API-Adresse gefunden. | Cherry Studio oder Jan |
| **Make: integriertes OpenAI-Modul** | Verbindet sich nur mit einem OpenAI-Konto. | Modul HTTP → Make a request — Integrationskarte Make |
| **Zapier: App ChatGPT (OpenAI)** | Kein Feld für eine eigene Adresse. | Webhooks by Zapier → Custom Request — Integrationskarte Zapier |
| **Home Assistant: OpenAI Conversation** | Die integrierte Integration funktioniert nur mit der OpenAI-Adresse. | Extended OpenAI Conversation aus HACS — Integrationskarte Home Assistant |
| **aiogram, python-telegram-bot, grammY, Telegraf** | Bot-Frameworks verbinden sich selbst nicht mit Modellen. | OpenAI oder Anthropic SDK innerhalb des Bots — Integrationskarte Telegram-Bot |

## KI-API-Schnittstelle und Client-Einrichtung

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

Agenten, Editoren, Chats und SDKs, die einen Ailoot-Schlüssel akzeptieren. Die Schaltfläche „Einrichten“ zeigt, wo Sie Adresse und Schlüssel einfügen, sowie 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/billing/subscriptions/) · [Modellpreise ansehen](https://ailoot.ai/models/de/)

## 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)

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