Integrationen

Die meisten Tools benötigen nur drei Werte: einen API-Schlüssel, eine Basis-URL und eine Modell-ID. EmpirioLabs stellt OpenAI-kompatible Chat-Komplettierungen plus einen anthropischen Nachrichten-Endpunkt zur Verfügung, sodass die Einrichtung in der Regel ein Provider-Dropdown und eine URL-Änderung umfasst.

OpenCodeClaude CodeClineQwen CodeCodex CLIAiderContinueOpenHandsHermes AgentOpenClawgooseZedSillyTavernPersonaLLMJanitor AITypingMindOpen WebUILibreChatLobeChatLiteLLMKilo, Roo, Cursor

Schnellster Aufbau

Verwende das, wenn du ein funktionierendes Setup ohne manuelles Bearbeiten der Konfigurationsdateien möchtest. Der Befehl holt das Hilfsskript von der Dokumentationsseite, läuft es mit Python und schreibt nur die von dir gewählten Scopes. Bei Tools, die lokal persistierte Konfigurationen unterstützen, speichert der Helfer den Schlüssel in gitignored-Projektdateien, sodass neu geöffnete App-Sitzungen nicht von einem Shell-Export abhängig sind.

$
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
$
script="${TMPDIR:-/tmp}/empirio-integrations-setup.py"
$
curl -fsSL "https://docs.empiriolabs.ai/integrations/setup.py" -o "$script"
$
python3 "$script" \
>
  --scope project \
>
  --tools opencode,aider,qwen-code,openhands \
>
  --model qwen3-max

$
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
$
python3 empirio-integrations-setup.py --scope project --tools opencode,aider,qwen-code,openhands --model qwen3-max

Was der Helfer schreibt

Standardmäßig ruft der Helfer den Live-/v1/models?available=true-Katalog und schreibt jedes chatfähige Modell (Text, Multimodal, Code, Reasoning) in Werkzeuge, deren Konfigurationen nativ einen Multi-Model-Picker unterstützen (OpenCode, Continue, Qwen Code, Goose). Die --model-Flagge wählt die Standard-Karte innerhalb dieses gefüllten Satzes aus. Lass --no-populate-models, wenn du nur das Standardmodell registrieren lassen möchtest.

Der Helfer validiert Werkzeugnamen und verlässt mit einem Fehler für unbekannte Werte. Wenn ein ausgewähltes Werkzeug nicht mit dem gewählten Scope übereinstimmt, druckt der Helfer eine Notiz aus. Zum Beispiel schreibt --scope project --tools codex keine Codex-Konfiguration, weil Codex eine Benutzerkonfiguration ist.

Integrationen, die in dieser Tabelle nicht aufgeführt sind, sind manuelle UI- oder App-Level-Setups. Verwenden Sie die untenstehenden Verbindungswerte für Cline, Zed, Kilo Code, Roo Code, Cursor-ähnliche Felder, Chat-Frontends und gehostete Web-UIs.

Aktualisierung der Modellliste nach einem Neustart

Der Helfer holt GET /v1/models?available=true bei jedem Durchlauf ab und schreibt die Multi-Modell-Konfigurationen aus diesem Live-Snapshot neu, sodass die registrierte Modellliste widerspiegelt, welche Modelle zum Zeitpunkt der Ausführung des Helfers gestartet werden. Das erneute Ausführen desselben Befehls nach dem Start eines neuen Modells fügt es in OpenCodes opencode.json, Continues config.yaml, die Qwen Code settings.json Provider-Liste und das Goose Custom Provider JSON ohne weitere Änderungen hinzu. Aider, OpenHands, Claude Code, Codex CLI, Hermes Agent und OpenClaw pflegen in ihrer Konfiguration keine Multi-Model-Registrierung, daher lesen diese Tools immer das Modell, das Ihr Code bei der Anfrage passiert, was bedeutet, dass bei einem neuen Modell kein Hilfsprogramm erneut ausgeführt werden muss.

$
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
$
script="${TMPDIR:-/tmp}/empirio-integrations-setup.py"
$
curl -fsSL "https://docs.empiriolabs.ai/integrations/setup.py" -o "$script"
$
python3 "$script" --scope project --tools opencode,aider,qwen-code,openhands --model qwen3-max

Manuelle automatische Aktualisierung (standardmäßig installiert)

Der Setup-Befehl installiert eine plattformnative, geplante Aufgabe, die alle 6 Stunden die EmpirioLabs-Modellliste erneut abruft, sodass neu gestartete Modelle in OpenCode, Qwen Code, Continue und Goose ohne manuellen Schritt erscheinen. Der Job läuft eigenständig, im Hintergrund, ohne dass eine Shell-Sitzung erforderlich ist:

• Linux: ein markierter Eintrag in deinem Benutzer-Crontab (sichtbar mit crontab -l)
• macOS: ein Benutzer-LaunchAgent bei ~/Library/LaunchAgents/ai.empiriolabs.refresh.plist
• Windows: eine Aufgabe im Task Scheduler namens “EmpirioLabs Auto Refresh”

Der Job liest den API-Schlüssel aus ~/.empiriolabs/.empiriolabs-api-key (Modus 600 bei POSIX) und schreibt nur Konfigurationen neu, die bereits auf der Festplatte existieren, sodass er nie Dateien in nicht zusammenhängenden Verzeichnissen erstellt. Logs (macOS) und STDOUT (Linux/Windows) gehen zu ~/.empiriolabs/refresh.log.

Übergebe --no-auto-refresh an den Setup-Befehl, um dich abzumelden, oder führe den Helfer später mit --uninstall-auto-refresh aus, um die geplante Aufgabe zu entfernen und die Markierungseinträge zu bereinigen.

$
python3 "$script" --scope project --tools opencode,aider,qwen-code,openhands --model qwen3-max --no-auto-refresh

$
curl -fsSL https://docs.empiriolabs.ai/integrations/setup.py | python3 - --uninstall-auto-refresh

Verbindungswerte

Denk- und Schlussfolgerungskontrollen

EmpirioLabs stellt Schlussfolgerungskontrollen nur bei Modellen zur Verfügung, die sie auf ihrer Modellseite oder maschinenlesbaren Schemata auflisten. Senden Sie diese Felder standardmäßig nicht an jedes Modell.

Für OpenAI-kompatible Chat-Komplettierungen und -antworten können unterstützte Steuerungen je nach Modell enable_thinking, thinking_budget oder reasoning_effort sein:

1
{
2
  "model": "qwen3-max-thinking",
3
  "messages": [
4
    { "role": "user", "content": "Answer briefly." }
5
  ],
6
  "enable_thinking": false
7
}

Für das anthropische Nachrichten-Endpunkt verwenden Sie anthropisches Denken, wenn das Modell das Denken unterstützt:

1
{
2
  "model": "qwen3-max-thinking",
3
  "messages": [
4
    { "role": "user", "content": "Work through this carefully." }
5
  ],
6
  "thinking": {
7
    "type": "enabled",
8
    "budget_tokens": 1024
9
  }
10
}

reasoning_effort akzeptiert none, low, medium, high und max auf jedem argumentierbaren Modell. EmpirioLabs normalisiert den Wert in die unterstützten Denkfelder des ausgewählten Modells, sodass dieselbe Aufwandskette über Modellfamilien hinweg funktioniert, unabhängig davon, ob der Modelldienst reasoning_effort, enable_thinking oder thinking_budget nativ erwartet.

1
{
2
  "model": "deepseek-v4-pro",
3
  "messages": [
4
    { "role": "user", "content": "Solve this carefully." }
5
  ],
6
  "reasoning_effort": "max"
7
}

Die Werkzeugunterstützung variiert:

Rauchtest

Führe das aus, bevor du ein größeres Tool konfigurierst. Wenn das funktioniert, sind dein Schlüssel, deine Credits, dein Netzwerk und dein Modell-ID in Ordnung.

$
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
$
$
curl "https://api.empiriolabs.ai/v1/chat/completions" \
>
  -H "Authorization: Bearer $EMPIRIOLABS_API_KEY" \
>
  -H "Content-Type: application/json" \
>
  -d '{
>
    "model": "qwen3-max",
>
    "messages": [
>
      { "role": "user", "content": "Reply with one sentence." }
>
    ]
>
  }'

Um aktuelle Modell-IDs aufzulisten:

$
curl "https://api.empiriolabs.ai/v1/models?available=true" \
>
  -H "Authorization: Bearer $EMPIRIOLABS_API_KEY"

Chat- und Rollenspiel-Frontends

Nutzen Sie diesen Bereich für BYOK-Chat-Apps, Rollenspiel-Tools und geteilte Web-UIs. Diese Tools benötigen normalerweise kein Hilfsskript. Verwenden Sie Ihren EmpirioLabs-API-Schlüssel, wählen Sie ein Chatmodell wie qwen3-max und bewahren Sie Geheimnisse in den lokalen Einstellungen oder Umgebungsvariablen der App auf.

SillyTavern

SillyTavern ist ein lokales Rollenspiel- und Charakterchat-Frontend. EmpirioLabs arbeitet über seine maßgeschneiderte, OpenAI-kompatible Chat-Abschluss-Quelle.

1. Öffne SillyTavern und klicke auf das Stecker-Symbol, um API-Verbindungen zu öffnen.
2. Setze den API-Typ auf Chat Completion.
3. Setze die Chat-Abschlussquelle auf Custom (OpenAI-compatible).
4. Setze benutzerdefinierten Endpunkt / Basis-URL auf https://api.empiriolabs.ai/v1.
5. Füge deinen EmpirioLabs API-Schlüssel in das Feld für benutzerdefinierte API-Schlüssel ein.
6. Klicken Sie auf Verbinden, wählen Sie dann ein Modell aus dem Dropdown-Menü oder geben Sie eine Modell-ID wie qwen3-max ein.

Wenn das Modell-Dropdown leer ist, aber dein Rauchtest funktioniert, gib die Modell-ID manuell ein. Wenn ein Rollenspiel-Sampler einen Request-Fehler verursacht, entferne nicht standardmäßige Zusatzparameter und versuche es zuerst mit den Standard-Chat-Einstellungen erneut.

PersonaLLM

PersonaLLM ist eine iOS-Rollenspiel- und Charakter-Chat-App mit bring-your-own-key Provider-Einstellungen. EmpirioLabs arbeitet über die benutzerdefinierte Text-Engine von PersonaLLM.

1. Tippen Sie auf dem Startbildschirm auf das Dreipunktmenü oben links.
2. Öffne die Einstellungen.
3. Open Text Engine.
4. Wählen Sie maßgeschneidert.
5. Setze die Basis-URL auf https://api.empiriolabs.ai/v1.
6. Füge deinen EmpirioLabs API-Schlüssel ein.
7. Im Modellfeld tippen Sie auf die Schaltfläche rechts, um die Live-Modellliste abzurufen.
8. Wählen Sie ein Chatmodell wie qwen3-max oder glm-5-1 und speichern Sie dann die Text-Engine-Einstellungen.

Hausmeister-KI

Die Hausmeister-KI kann EmpirioLabs über ihre Proxy-Konfiguration aufrufen. Nutzen Sie diesen Weg, wenn Sie weiterhin die Chat-UI des Hausmeisters nutzen und gleichzeitig Ihren eigenen EmpirioLabs-Schlüssel mitbringen möchten.

1. Öffne einen AI-Chat für Hausmeister.
2. Klicken Sie auf using janitor oder die Menü-Schaltfläche oben im Chat.
3. Mach API Settings auf.
4. Wählen Sie den Tab Proxy.
5. In Proxy-Konfigurationen klicken Sie auf + New.
6. Name auf EmpirioLabs setzen.
7. Setze Model auf qwen3-max oder eine andere Modell-ID von GET /v1/models?available=true.
8. Setze die Proxy-URL auf https://api.empiriolabs.ai/v1/chat/completions.
9. Füge deinen EmpirioLabs-API-Schlüssel in den API-Schlüssel ein.
10. Lass benutzerdefinierte Eingabeaufforderung leer, es sei denn, du benutzt bereits eine für diesen Charakter oder Chat.
11. Klicken Sie auf Hinzufügen, speichern Sie die Einstellungen und aktualisieren Sie dann die AI-Seite des Hausmeisters, bevor Sie die nächste Nachricht senden.

TypingMind

TypingMind unterstützt benutzerdefinierte Chat-Modelle, bei denen Sie einen Endpunkt, eine Modell-ID und optionale Header angeben.

1. Öffne Models in der linken Seitenleiste.
2. Öffne die Modelleinstellungen und klicke dann auf Add Custom Models.
3. Verwenden Sie den API-Typ OpenAI Chat Completions API, wenn das Formular danach fragt.
4. Stellen Sie die Endpoint-API auf https://api.empiriolabs.ai/v1/chat/completions.
5. Setze die Modell-ID auf qwen3-max oder ein anderes verfügbares Modell.
6. Fügen Sie den Header Authorization: Bearer sk-empiriolabs-your_key_here hinzu oder fügen Sie den Schlüssel in das API-Schlüsselfeld von TypingMind ein, falls das Formular einen anbietet.
7. Klicke auf Testen und dann Modell hinzufügen.

Open WebUI

Open WebUI kann sich über den Admin-Verbindungsbildschirm mit OpenAI-kompatiblen Anbietern verbinden.

1. Öffne die Admin-Einstellungen.
2. Geh zu Connections und füge eine neue OpenAI-Verbindung hinzu.
3. Setze die URL auf https://api.empiriolabs.ai/v1.
4. Füge deinen EmpirioLabs API-Schlüssel ein.
5. Wenn die Modellentdeckung langsam oder zu breit gefächert ist, fügen Sie Modell-IDs wie qwen3-max dem Filter der Modell-IDs hinzu.
6. Speichere und wähle dann das EmpirioLabs-Modell im Chat.

Für Serverstarts setzen Sie:

$
OPENAI_API_BASE_URL=https://api.empiriolabs.ai/v1
$
OPENAI_API_KEY=sk-empiriolabs-your_key_here

LibreChat

LibreChat unterstützt benutzerdefinierte, OpenAI-kompatible Endpunkte über librechat.yaml. Verwenden Sie eine Umgebungsvariable für einen gemeinsamen Bereitstellungsschlüssel oder user_provided, ob jeder Benutzer seinen eigenen Schlüssel in der Benutzeroberfläche mitbringen sollte.

1
version: 1.3.5
2
cache: true
3
endpoints:
4
  custom:
5
    - name: "EmpirioLabs"
6
      apiKey: "${EMPIRIOLABS_API_KEY}"
7
      baseURL: "https://api.empiriolabs.ai/v1"
8
      models:
9
        default: ["qwen3-max"]
10
        fetch: true
11
      titleConvo: true
12
      titleModel: "qwen3-max"
13
      modelDisplayLabel: "EmpirioLabs"

$
EMPIRIOLABS_API_KEY=sk-empiriolabs-your_key_here

Für BYOK-Multi-User-Bereitstellungen ändern Sie apiKey zu:

1
apiKey: "user_provided"

LibreChat nach der Änderung librechat.yaml neu starten.

LobeChat

Für selbstgehostete LobeChat verwenden Sie den OpenAI-Anbieter mit der EmpirioLabs API-Basis-URL:

$
OPENAI_API_KEY=sk-empiriolabs-your_key_here
$
OPENAI_PROXY_URL=https://api.empiriolabs.ai/v1
$
OPENAI_MODEL_LIST=+qwen3-max,+glm-5-1,+deepseek-v4-pro:variant2

Dann starten Sie LobeChat neu und wählen Sie im Modellselektor ein aktiviertes EmpirioLabs-Modell aus.

LiteLLM

EmpirioLabs ist ein integrierter LiteLLM-Anbieter, sodass das SDK und der LiteLLM-Proxy zu jedem EmpirioLabs-Chatmodell mit dem empiriolabs/-Präfix routen können. Bei LiteLLM-Versionen, die dem Anbieter voraus sind, verwenden Sie den untenstehenden OpenAI-kompatiblen Fallback.

1
import os
2
import litellm
3
4
os.environ["EMPIRIOLABS_API_KEY"] = "sk-empiriolabs-your_key_here"
5
6
response = litellm.completion(
7
    model="empiriolabs/qwen3-7-plus",
8
    messages=[{"role": "user", "content": "Hello!"}],
9
)

1
model_list:
2
  - model_name: qwen3-7-plus
3
    litellm_params:
4
      model: empiriolabs/qwen3-7-plus
5
      api_key: os.environ/EMPIRIOLABS_API_KEY

Ältere LiteLLM-Versionen (oder Bildgenerierung) können die OpenAI-kompatible Route direkt nutzen:

1
import os
2
import litellm
3
4
response = litellm.image_generation(
5
    prompt="A glass cathedral at sunset, dramatic lighting",
6
    model="openai/seedream-5-0-lite",
7
    api_base="https://api.empiriolabs.ai/v1",
8
    api_key=os.environ["EMPIRIOLABS_API_KEY"],
9
    extra_body={"sync": True},
10
)

Das sync: true-Feld lässt den Bildendpunkt die fertige, OpenAI-förmige Antwort anstelle des standardmäßigen asynchronen Job-Envelopes zurückgeben. Die eigene Anbieterseite von LiteLLM für EmpirioLabs ist unter docs.litellm.ai/docs/providers/empiriolabs.

OpenCode

Der Helfer kann dies automatisch schreiben:

$
python3 empirio-integrations-setup.py --tools opencode --model qwen3-max

Manuelles Setup:

1
{
2
  "$schema": "https://opencode.ai/config.json",
3
  "provider": {
4
    "empiriolabs": {
5
      "npm": "@ai-sdk/openai-compatible",
6
      "name": "EmpirioLabs",
7
      "options": {
8
        "baseURL": "https://api.empiriolabs.ai/v1",
9
        "apiKey": "{file:.empiriolabs-api-key}"
10
      },
11
      "models": {
12
        "qwen3-max": {
13
          "name": "EmpirioLabs Qwen3-Max"
14
        },
15
        "qwen3-max-thinking": {
16
          "name": "EmpirioLabs Qwen3-Max-Thinking",
17
          "reasoning": true
18
        }
19
      }
20
    }
21
  }
22
}

$
printf '%s' 'sk-empiriolabs-your_key_here' > .empiriolabs-api-key
$
printf '\n.empiriolabs-api-key\n' >> .gitignore
$
opencode

In OpenCode führen Sie /models aus und wählen Sie den EmpirioLabs-Anbieter aus. Der Datei-gestützte Schlüssel funktioniert weiter, nachdem du OpenCode geschlossen und wieder geöffnet hast.

Claude Code

Der Helfer kann die Benutzer-Einstellungen automatisch schreiben:

$
python3 empirio-integrations-setup.py --scope user --tools claude-code --model qwen3-max

Claude Code ist kein OpenAI-Chat-Completions-Client. Es kommuniziert mit LLM-Gateways über die Form Anthropic Messages, die EmpirioLabs bei /v1/messages präsentiert.

$
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
$
$
# Claude Code sends ANTHROPIC_AUTH_TOKEN as a Bearer token.
$
export ANTHROPIC_AUTH_TOKEN="$EMPIRIOLABS_API_KEY"
$
$
# Claude Code appends /v1/messages itself, so do not include /v1 here.
$
export ANTHROPIC_BASE_URL="https://api.empiriolabs.ai"
$
$
export ANTHROPIC_CUSTOM_MODEL_OPTION="qwen3-max"
$
export ANTHROPIC_CUSTOM_MODEL_OPTION_NAME="EmpirioLabs Qwen3-Max"
$
export ANTHROPIC_MODEL="qwen3-max"
$
$
claude

Persistente Benutzerebene-Einrichtung:

1
{
2
  "env": {
3
    "ANTHROPIC_AUTH_TOKEN": "sk-empiriolabs-your_key_here",
4
    "ANTHROPIC_BASE_URL": "https://api.empiriolabs.ai",
5
    "ANTHROPIC_CUSTOM_MODEL_OPTION": "qwen3-max",
6
    "ANTHROPIC_CUSTOM_MODEL_OPTION_NAME": "EmpirioLabs Qwen3-Max",
7
    "ANTHROPIC_MODEL": "qwen3-max"
8
  }
9
}

Cline

In der Benutzeroberfläche der Cline-Erweiterung:

1. Öffne die Cline-Einstellungen.
2. API-Anbieter auf OpenAI Compatible setzen.
3. Setze die Basis-URL auf https://api.empiriolabs.ai/v1.
4. Füge deinen EmpirioLabs API-Schlüssel ein.
5. Geben Sie eine Modell-ID wie qwen3-max ein.
6. Klicken Sie auf Überprüfen und starten Sie dann eine neue Aufgabe.

Für Cline CLI:

$
npm install -g cline
$
$
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
$
$
cline auth \
>
  -p openai \
>
  -k "$EMPIRIOLABS_API_KEY" \
>
  -b "https://api.empiriolabs.ai/v1" \
>
  -m "qwen3-max"
$
$
cline "Inspect this repository and suggest the safest next refactor."

Qwen-Code

Der Helfer kann automatisch Projekt- oder Benutzereinstellungen schreiben:

$
python3 empirio-integrations-setup.py --scope project --tools qwen-code --model qwen3-max

Starten Sie Qwen Code direkt mit EmpirioLabs als OpenAI-kompatiblem Anbieter:

$
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
$
$
qwen \
>
  --auth-type openai \
>
  --openaiApiKey "$EMPIRIOLABS_API_KEY" \
>
  --openaiBaseUrl "https://api.empiriolabs.ai/v1" \
>
  --model "qwen3-max"

Für die dauerhafte Projekteinrichtung:

1
{
2
  "model": {
3
    "name": "qwen3-max"
4
  },
5
  "security": {
6
    "auth": {
7
      "selectedType": "openai"
8
    }
9
  },
10
  "env": {
11
    "EMPIRIOLABS_API_KEY": "sk-empiriolabs-your_key_here"
12
  },
13
  "modelProviders": {
14
    "openai": [
15
      {
16
        "id": "qwen3-max",
17
        "name": "EmpirioLabs Qwen3-Max",
18
        "envKey": "EMPIRIOLABS_API_KEY",
19
        "baseUrl": "https://api.empiriolabs.ai/v1"
20
      }
21
    ]
22
  }
23
}

Füge .gitignore .qwen/settings.json hinzu, wenn du den Schlüssel dort aufbewahrst.

Codex CLI

Der Helfer kann den Provider-Block auf Benutzerebene automatisch schreiben:

$
python3 empirio-integrations-setup.py --scope user --tools codex --model qwen3-max

Fügen Sie EmpirioLabs als Anbieter von individuellen Modellen in ~/.codex/config.toml hinzu:

1
model = "qwen3-max"
2
model_provider = "empiriolabs"
3
4
[model_providers.empiriolabs]
5
name = "EmpirioLabs"
6
base_url = "https://api.empiriolabs.ai/v1"
7
env_key = "EMPIRIOLABS_API_KEY"
8
wire_api = "responses"

Dann starte Codex mit deinem Schlüssel in der Umgebung:

$
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
$
codex

Nutzen Sie diesen Weg mit EmpirioLabs-Modellen, die POST /v1/responses unterstützen.

Aider

Der Helfer kann automatisch eine projektlokale Aider-Konfiguration schreiben:

$
python3 empirio-integrations-setup.py --tools aider --model qwen3-max

Aider verwendet die OpenAI-kompatiblen Umweltvariablen. Prefix openai/ das Modell voran.

$
export OPENAI_API_BASE="https://api.empiriolabs.ai/v1"
$
export OPENAI_API_KEY="sk-empiriolabs-your_key_here"
$
$
aider --model openai/qwen3-max

Weitermachen

Der Helfer kann die Benutzer-Continue-Konfiguration automatisch schreiben:

$
python3 empirio-integrations-setup.py --scope user --tools continue --model qwen3-max

Continues OpenAI-Anbieter kann jeden OpenAI-kompatiblen Endpunkt ansprechen, indem er apiBase setzt. Geheimnisse in .env oder Continues geheimen Laden legen, anstatt sie in config.yaml zu stecken.

1
name: EmpirioLabs
2
version: 0.0.1
3
schema: v1
4
5
models:
6
  - name: EmpirioLabs Qwen3-Max
7
    provider: openai
8
    model: qwen3-max
9
    apiBase: https://api.empiriolabs.ai/v1
10
    apiKey: ${{ secrets.EMPIRIOLABS_API_KEY }}
11
    capabilities:
12
      - tool_use

Füge das Geheimnis an einem der von Continue unterstützten .env-Orte hinzu:

$
EMPIRIOLABS_API_KEY=sk-empiriolabs-your_key_here

OpenHands

Der Helfer kann automatisch eine projekt-lokale OpenHands-Konfiguration schreiben:

$
python3 empirio-integrations-setup.py --tools openhands --model qwen3-max

OpenHands stellt Provider-Einstellungen in der Benutzeroberfläche bereit und leitet sie an seine LLM-Schicht weiter.

Für umweltbasierte Starts:

$
export LLM_MODEL="openai/qwen3-max"
$
export LLM_BASE_URL="https://api.empiriolabs.ai/v1"
$
export LLM_API_KEY="sk-empiriolabs-your_key_here"

Für die dauerhafte Projekteinrichtung:

1
[llm]
2
model = "openai/qwen3-max"
3
api_key = "sk-empiriolabs-your_key_here"
4
base_url = "https://api.empiriolabs.ai/v1"

Führen Sie OpenHands durch:

$
openhands --config-file openhands.empiriolabs.toml

Füge .gitignore openhands.empiriolabs.toml hinzu, wenn du den Schlüssel dort aufbewahrst.

Hermes-Agent

Der Helfer kann den Benutzer-Hermes-Sidecar automatisch schreiben:

$
python3 empirio-integrations-setup.py --scope user --tools hermes --model qwen3-max

Hermes hat einen interaktiven Modellzauberer. Wählen Sie Custom endpoint und geben Sie dann ein:

Manuelle Konfiguration:

1
custom_providers:
2
  - name: empiriolabs
3
    base_url: https://api.empiriolabs.ai/v1
4
    key_env: EMPIRIOLABS_API_KEY
5
6
model:
7
  provider: custom:empiriolabs
8
  default: qwen3-max

$
EMPIRIOLABS_API_KEY=sk-empiriolabs-your_key_here

OpenClaw

Der Helfer kann automatisch einen Benutzer-OpenClaw-Sidecar schreiben:

$
python3 empirio-integrations-setup.py --scope user --tools openclaw --model qwen3-max

Die sicherste Einrichtung ist der OpenClaw-Wizard:

$
openclaw configure --section model

Wählen Sie einen benutzerdefinierten oder OpenAI-kompatiblen Anbieter und verwenden:

Für die manuelle JSON5-Konfiguration nutzt ihr dies als Sidecar oder fügt es in die OpenClaw-Konfiguration ein:

1
{
2
  secrets: {
3
    providers: {
4
      default: { source: "env" }
5
    },
6
    defaults: {
7
      env: "default"
8
    }
9
  },
10
  models: {
11
    mode: "merge",
12
    providers: {
13
      empiriolabs: {
14
        baseUrl: "https://api.empiriolabs.ai/v1",
15
        apiKey: { source: "env", provider: "default", id: "EMPIRIOLABS_API_KEY" },
16
        authHeader: true,
17
        api: "openai-completions",
18
        models: [
19
          {
20
            id: "qwen3-max",
21
            name: "EmpirioLabs Qwen3-Max",
22
            input: ["text"],
23
            contextWindow: 256000
24
          }
25
        ]
26
      }
27
    }
28
  },
29
  agents: {
30
    defaults: {
31
      model: {
32
        primary: "empiriolabs/qwen3-max"
33
      }
34
    }
35
  }
36
}

Führe openclaw config validate nach manuellen Bearbeitungen aus.

Goose

Der Helfer kann automatisch den benutzerdefinierten Provider auf Benutzerebene schreiben:

$
python3 empirio-integrations-setup.py --scope user --tools goose --model qwen3-max

goose unterstützt kundenspezifische, OpenAI-kompatible Anbieter. Der Helfer schreibt dies als empiriolabs.json im Goose Custom Provider-Verzeichnis.

1
{
2
  "name": "empiriolabs",
3
  "engine": "openai",
4
  "display_name": "EmpirioLabs",
5
  "description": "EmpirioLabs OpenAI-compatible API",
6
  "api_key_env": "EMPIRIOLABS_API_KEY",
7
  "base_url": "https://api.empiriolabs.ai/v1/chat/completions",
8
  "models": [
9
    {
10
      "name": "qwen3-max",
11
      "context_limit": 256000
12
    }
13
  ],
14
  "supports_streaming": true,
15
  "requires_auth": true
16
}

$
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
$
goose session start --provider empiriolabs

Zed

Zed unterstützt OpenAI-kompatible Anbieter im Agent Panel. Nutzen Sie den Add Provider Flow der Benutzeroberfläche oder bearbeiten Sie die Einstellungen:

1
{
2
  "language_models": {
3
    "openai_compatible": {
4
      "EmpirioLabs": {
5
        "api_url": "https://api.empiriolabs.ai/v1",
6
        "available_models": [
7
          {
8
            "name": "qwen3-max",
9
            "display_name": "EmpirioLabs Qwen3-Max",
10
            "max_tokens": 256000,
11
            "capabilities": {
12
              "tools": true,
13
              "images": false,
14
              "parallel_tool_calls": false,
15
              "prompt_cache_key": false
16
            }
17
          }
18
        ]
19
      }
20
    }
21
  }
22
}

Fügen Sie den API-Schlüssel über das Agentenpanel hinzu, damit Zed ihn im OS-Zugangsdatenspeicher speichert.

Kilo Code, Roo Code, Cursor und ähnliche IDEs

Verwenden Sie diese Tabelle überall dort, wo ein Tool OpenAI Compatible, Custom OpenAI oder Override OpenAI Base URL freilegt.

Kilo Code und Roo-ähnliche VS Code-Erweiterungen stellen dies normalerweise als API-Konfigurationsprofil bereit. Die öffentlichen Dokumente und Produkthinweise von Roo Code zeigen einen shutdown/archive Weg am 15. Mai 2026 an, daher bevorzugen Sie Cline oder Kilo Code für neue teamweite Vorlagen, es sei denn, Ihr Team ist bereits auf Roo angewiesen.

Das Verhalten des benutzerdefinierten API-Schlüssels des Cursors hängt von der Version und der Funktionsoberfläche ab. Wenn dein Cursor-Build nur Provider-API-Schlüssel akzeptiert und keine benutzerdefinierte Basis-URL für die gewünschte Funktion bereitstellt, kann sie nicht direkt auf EmpirioLabs für diese Funktion verwiesen werden.

Fehlerbehebung

Halten Sie die Agenten am Boden

Wenn ein KI-Codierassistent eine EmpirioLabs-Integration für Sie implementiert, geben Sie ihm zuerst das maschinenlesbare Dokumentenpaket:

Sagen Sie dem Agenten, https://docs.empiriolabs.ai/ai-agent-api-reference-context.md als API-Referenz zu verwenden, https://docs.empiriolabs.ai/ai-agent-docs-context.md für Modell- und Preisdetails und GET https://api.empiriolabs.ai/v1/models/\{model_id\} für Live-Modell-Metadaten.

Das verhindert, dass der Agent Endpunktformen, veraltete Modell-IDs oder Parameternamen errät.