Intégrations

La plupart des outils n’ont besoin que de trois valeurs: une clé API, une URL de base et un identifiant de modèle. EmpirioLabs expose des complétions de chat compatibles OpenAI ainsi qu’un point de terminaison Messages de style Anthropic, donc la configuration se fait généralement par un menu déroulant du fournisseur et un changement d’URL.

OpenCodeClaude CodeClineQwen CodeCodex CLIAiderContinueOpenHandsHermes AgentOpenClawgooseZedSillyTavernPersonaLLMJanitor AITypingMindOpen WebUILibreChatLobeChatLiteLLMKilo, Roo, Cursor

Configuration la plus rapide

Utilisez-le si vous voulez une configuration fonctionnelle sans avoir à modifier manuellement les fichiers de configuration. La commande récupère le script d’assistance depuis le site docs, l’exécute avec Python, et n’écrit que les scopes que vous choisissez. Pour les outils qui supportent la configuration locale persistée, l’assistant stocke la clé dans des fichiers de projet gitignorés afin que les sessions d’application rouvertes ne dépendent pas d’une exportation shell.

$
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

Ce que l’assistant écrit

Par défaut, l’assistant récupère le catalogue /v1/models?available=true en direct et écrit tous les modèles capables de chat (texte, multimodal, code, raisonnement) dans des outils dont les configurations supportent nativement un sélecteur multi-modèles (OpenCode, Continue, Qwen Code, goose). Le drapeau --model sélectionne le code par défaut dans cet ensemble peuplé. Passez --no-populate-models si vous voulez que seul le modèle par défaut soit enregistré.

L’assistant valide les noms des outils et sort avec une erreur pour des valeurs inconnues. Si un outil sélectionné ne correspond pas à la portée choisie, l’assistant imprime une note. Par exemple, --scope project --tools codex n’écrit pas la configuration du Codex car le Codex est une configuration au niveau utilisateur.

Les intégrations non listées dans ce tableau sont des configurations manuelles d’interface utilisateur ou au niveau de l’application. Utilisez les valeurs de connexion ci-dessous pour Cline, Zed, Kilo Code, Roo Code, les champs de type Cursor, les interfaces de chat et les interfaces web hébergées.

Rafraîchissement de la liste des modèles après un nouveau lancement

L’assistant récupère GET /v1/models?available=true à chaque exécution et réécrit les configurations multi-modèles à partir de cet instantané en direct, de sorte que la liste des modèles enregistrés reflète les modèles lancés au moment où l’assistant s’exécute. Relancer la même commande après le lancement d’un nouveau modèle l’ajoute à la opencode.json d’OpenCode, à la config.yaml de Continue, à la liste Qwen Code settings.json des fournisseurs, et au JSON du fournisseur personnalisé Goose sans autres modifications. Aider, OpenHands, Claude Code, Codex CLI, Hermes Agent et OpenClaw ne maintiennent pas de registre multi-modèles dans leur configuration, donc ces outils lisent toujours le modèle que votre code passe au moment de la requête, ce qui signifie qu’aucune re-exécution d’assistance n’est nécessaire pour ces outils lors du lancement d’un nouveau modèle.

$
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

Rafraîchissement automatique sans intervention (installé par défaut)

La commande de configuration installe une tâche programmée native de la plateforme qui récupère la liste de modèles EmpirioLabs toutes les 6 heures, de sorte que les nouveaux modèles lancés apparaissent dans OpenCode, Qwen Code, Continue et Goose sans aucune étape manuelle. La tâche s’exécute de manière autonome, en arrière-plan, sans qu’aucune session shell ne soit requise:

• Linux: une entrée marquée dans votre onglet de cron utilisateur (visible avec crontab -l)
• macOS: un LaunchAgent utilisateur à ~/Library/LaunchAgents/ai.empiriolabs.refresh.plist
• Windows: une tâche du planificateur des tâches nommée « EmpirioLabs Auto Refresh »

Le job lit la clé API de ~/.empiriolabs/.empiriolabs-api-key (mode 600 sur POSIX) et ne réécrit que les configurations déjà existantes sur le disque, il ne crée donc jamais de fichiers dans des répertoires non liés. Les journaux (macOS) et stdout (Linux/Windows) vont à ~/.empiriolabs/refresh.log.

Passez --no-auto-refresh à la commande setup pour vous retirer, ou exécutez l’aide plus tard avec --uninstall-auto-refresh pour supprimer la tâche programmée et nettoyer les entrées marqueurs.

$
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

Valeurs de connexion

Contrôles de pensée et de raisonnement

EmpirioLabs expose uniquement les contrôles de raisonnement sur des modèles qui les listent dans leur page de modèle ou dans un schéma lisible par machine. N’envoyez pas ces champs à chaque modèle par défaut.

Pour les Chat Completions et Réponses compatibles OpenAI, les contrôles pris en charge peuvent inclure enable_thinking, thinking_budget ou reasoning_effort, selon le modèle:

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

Pour le point de terminaison Messages de style anthropique, utilisez la pensée de style anthropique lorsque le modèle supporte la réflexion:

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 accepte none, low, medium, high et max sur tous les modèles capables de raisonner. EmpirioLabs normalise la valeur dans les champs de raisonnement supportés par le modèle sélectionné, de sorte que la même chaîne d’effort fonctionne entre les familles de modèles, que le service modèle attende reasoning_effort, enable_thinking ou thinking_budget nativement.

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

Le support des outils varie:

Test de fumée

Exécutez cela avant de configurer un outil plus grand. Si cela fonctionne, votre clé, crédits, réseau et identifiant de modèle sont valides.

$
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." }
>
    ]
>
  }'

Pour lister les identifiants actuels des modèles:

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

Interfaces de chat et de jeu de rôle

Utilisez cette section pour les applications de chat BYOK, les outils de jeu de rôle et les interfaces web partagées. Ces outils n’ont normalement pas besoin du script d’assistance. Utilisez votre clé API EmpirioLabs, choisissez un modèle de chat comme qwen3-max, et gardez des secrets dans les paramètres locaux ou les variables d’environnement de l’application.

SillyTavern

SillyTavern est une interface locale de jeu de rôle et de chat de personnages. EmpirioLabs fonctionne via son code source personnalisé compatible OpenAI Chat Complete.

1. Ouvrez SillyTavern et cliquez sur l’icône de prise pour ouvrir les connexions API.
2. Définissez le type d’API à Chat Completion.
3. Réglez la source de complétion du chat sur Custom (OpenAI-compatible).
4. Définissez l’URL personnalisée du point de terminaison / de la base à https://api.empiriolabs.ai/v1.
5. Collez votre clé API EmpirioLabs dans le champ clé API personnalisé.
6. Cliquez sur Connecter, puis choisissez un modèle dans le menu déroulant ou tapez un identifiant de modèle comme qwen3-max.

Si le menu déroulant du modèle est vide mais que votre test de fumée fonctionne, tapez manuellement l’identifiant du modèle. Si un sampler de jeu de rôle provoque une erreur de requête, supprimez les paramètres supplémentaires non standards et réessayez d’abord avec les paramètres de chat standards.

PersonaLLM

PersonaLLM est une application de jeu de rôle et de chat de personnages iOS avec bring-your-own-key paramètres de fournisseurs. EmpirioLabs fonctionne via le moteur de texte personnalisé de PersonaLLM.

1. Depuis l’écran d’accueil, appuyez sur le menu à trois points en haut à gauche.
2. Ouvre les paramètres.
3. Open Text Engine.
4. Choisissez personnalisé.
5. Réglez l’URL de base sur https://api.empiriolabs.ai/v1.
6. Collez votre clé API EmpirioLabs.
7. Dans le champ modèles, appuyez sur le bouton à droite pour accéder à la liste des modèles en direct.
8. Choisissez un modèle de chat comme qwen3-max ou glm-5-1, puis enregistrez les paramètres du moteur de texte.

IA de concierge

Janitor AI peut appeler EmpirioLabs via sa configuration Proxy. Utilisez cette voie lorsque vous voulez continuer à utiliser l’interface de chat de Janitor tout en apportant votre propre clé EmpirioLabs.

1. Ouvrez un chat IA pour les concierges.
2. Cliquez sur using janitor ou sur le bouton du menu près du haut du chat.
3. Ouvre API Settings.
4. Sélectionnez l’onglet Proxy.
5. Dans Configurations proxy, cliquez sur + New.
6. Définir le nom sur EmpirioLabs.
7. Définir le modèle sur qwen3-max, ou un autre identifiant de modèle depuis GET /v1/models?available=true.
8. Définissez l’URL du proxy à https://api.empiriolabs.ai/v1/chat/completions.
9. Collez votre clé API EmpirioLabs dans la clé API.
10. Laisse l’invite personnalisée vide à moins que tu n’en utilises déjà une pour ce personnage ou ce chat.
11. Cliquez sur Ajouter, enregistrez les paramètres, puis rafraîchissez la page IA du concierge avant d’envoyer le message suivant.

TypingMind

TypingMind prend en compte des modèles de chat personnalisés où vous fournissez un point de terminaison, un identifiant de modèle et des en-têtes optionnels.

1. OuvrezModels depuis la barre latérale gauche.
2. Ouvre les paramètres du modèle, puis clique sur Add Custom Models.
3. Utilisez le type API OpenAI Chat Completions API si le formulaire le demande.
4. Réglez l’API Endpoint sur https://api.empiriolabs.ai/v1/chat/completions.
5. Réglez l’ID du modèle sur qwen3-max ou un autre modèle disponible.
6. Ajoutez Authorization: Bearer sk-empiriolabs-your_key_here en-tête, ou collez la clé dans le champ clé API de TypingMind si le formulaire en fournit une.
7. Cliquez sur Tester, puis sur Ajouter Modèle.

Open WebUI

Open WebUI peut se connecter à des fournisseurs compatibles OpenAI depuis l’écran de connexion d’administration.

1. Ouvre les paramètres d’administration.
2. Allez sur Connections et ajoutez une nouvelle connexion OpenAI.
3. Définir l’URL à https://api.empiriolabs.ai/v1.
4. Collez votre clé API EmpirioLabs.
5. Si la découverte de modèles est lente ou trop large, ajoutez des identifiants de modèle comme qwen3-max au filtre des identifiants de modèle.
6. Enregistrez, puis choisissez le modèle EmpirioLabs dans le chat.

Pour les lancements de serveurs, réglez:

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

LibreChat

LibreChat prend en charge des terminaux personnalisés compatibles OpenAI via librechat.yaml. Utilisez une variable d’environnement pour une clé de déploiement partagée, ou user_provided si chaque utilisateur doit apporter sa propre clé dans l’interface.

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

Pour les déploiements multi-utilisateurs BYOK, changez apiKey pour:

1
apiKey: "user_provided"

Redémarrez LibreChat après avoir changé librechat.yaml.

LobeChat

Pour LobeChat auto-hébergé, utilisez le fournisseur OpenAI avec l’URL de base de l’API EmpirioLabs:

$
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

Ensuite, redémarrez LobeChat et choisissez un modèle EmpirioLabs activé dans le sélecteur de modèle.

LiteLLM

EmpirioLabs est un fournisseur LiteLLM intégré, donc le SDK et le proxy LiteLLM peuvent router vers n’importe quel modèle de chat EmpirioLabs avec le préfixe empiriolabs/. Pour les versions LiteLLM antérieures au fournisseur, utilisez le plan de secours compatible OpenAI ci-dessous.

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

Les anciennes versions de LiteLLM (ou génération d’images) peuvent utiliser directement la voie compatible OpenAI:

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
)

Le champ sync: true fait que le point final de l’image retourne la réponse finale en forme d’OpenAI au lieu de l’enveloppe de tâche asynchrone par défaut. La page fournisseur propre à LiteLLM pour EmpirioLabs se trouve à docs.litellm.ai/docs/providers/empiriolabs.

OpenCode

L’assistant peut écrire ceci automatiquement:

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

Installation manuelle:

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

Dans OpenCode, exécutez /models et choisissez le fournisseur EmpirioLabs. La clé de sauvegarde du fichier continue de fonctionner après que vous ayez fermé et rouvert OpenCode.

Claude Code

L’assistant peut écrire automatiquement les paramètres au niveau utilisateur:

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

Claude Code n’est pas un client OpenAI-chat-completions. Il communique avec les passerelles LLM via la forme Anthropic Messages, qu’EmpirioLabs expose à /v1/messages.

$
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

Configuration persistante au niveau utilisateur:

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

Dans l’interface de l’extension Cline:

1. Ouvre les réglages de Cline.
2. Réglez le fournisseur d’API à OpenAI Compatible.
3. Définissez l’URL de base à https://api.empiriolabs.ai/v1.
4. Collez votre clé API EmpirioLabs.
5. Entrez un identifiant de modèle tel que qwen3-max.
6. Cliquez sur Vérifier, puis lancez une nouvelle tâche.

Pour la CLI Cline:

$
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

L’assistant peut écrire automatiquement les paramètres du projet ou de l’utilisateur:

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

Lancez Qwen Code directement avec EmpirioLabs en tant que fournisseur compatible OpenAI:

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

Pour la mise en place de projets persistants:

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
}

Ajoute .qwen/settings.json à .gitignore si tu y stockes la clé.

Codex CLI

L’assistant peut écrire automatiquement le bloc fournisseur au niveau utilisateur:

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

Ajoutez EmpirioLabs comme fournisseur de modèles personnalisés en ~/.codex/config.toml:

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"

Ensuite, lance Codex avec ta clé dans l’environnement:

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

Utilisez cette voie avec les modèles EmpirioLabs qui prennent en charge POST /v1/responses.

Aider

L’assistant peut écrire automatiquement une configuration Aider locale du projet:

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

Aider utilise les variables d’environnement compatibles OpenAI. Préfixez le modèle par openai/.

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

Continuez

L’assistant peut écrire automatiquement la configuration Continue au niveau utilisateur:

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

Le fournisseur OpenAI de Continue peut cibler n’importe quel point de terminaison compatible OpenAI en définissant apiBase. Mettez des secrets dans .env ou dans la boutique secrète de Continue plutôt que de les enfermer dans config.yaml.

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

Ajoutez le secret dans l’un des .env emplacements pris en charge par Continue:

$
EMPIRIOLABS_API_KEY=sk-empiriolabs-your_key_here

OpenHands

L’assistant peut écrire automatiquement une configuration OpenHands locale du projet:

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

OpenHands expose les paramètres du fournisseur dans l’interface utilisateur et les transmet à sa couche LLM.

Pour les lancements basés sur l’environnement:

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

Pour la mise en place de projets persistants:

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

Jouez OpenHands avec:

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

Ajoute openhands.empiriolabs.toml à .gitignore si tu y stockes la clé.

Agent Hermès

L’assistant peut écrire automatiquement le sidecar Hermes au niveau utilisateur:

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

Hermès dispose d’un magicien modèle interactif. Choisissez Custom endpoint, puis entrez:

Configuration manuelle:

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

L’assistant peut écrire automatiquement un sidecar OpenClaw au niveau utilisateur:

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

La configuration la plus sûre est l’assistant OpenClaw:

$
openclaw configure --section model

Choisissez un fournisseur personnalisé ou compatible OpenAI et utilisez:

Pour la configuration JSON5 manuelle, utilisez-le comme sidecar ou intégrez-le à la configuration d’OpenClaw:

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
}

Exécutez openclaw config validate après les modifications manuelles.

oie

L’assistant peut écrire automatiquement le fournisseur personnalisé Goose au niveau utilisateur:

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

goose prend en charge des fournisseurs personnalisés compatibles OpenAI. L’assistant l’écrit comme empiriolabs.json dans le répertoire personnalisé du fournisseur Goose.

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 prend en charge les fournisseurs compatibles OpenAI dans le panneau d’agents. Utilisez le flux Add Provider de l’interface utilisateur, ou modifiez les paramètres:

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
}

Ajoutez la clé API via le panneau d’agents pour que Zed la stocke dans le magasin des identifiants du système d’exploitation.

Code Kilo, Code Roo, Cursor, et IDE similaires

Utilisez ce tableau partout où un outil expose OpenAI Compatible, Custom OpenAI ou Override OpenAI Base URL.

Les extensions Kilo Code et VS Code de style Roo exposent normalement cela comme un profil de configuration API. La documentation publique et les avis produits de Roo Code indiquent un shutdown/archive chemin le 15 mai 2026, donc préférez Cline ou Kilo Code pour de nouveaux modèles à l’échelle de l’équipe, sauf si votre équipe dépend déjà de Roo.

Le comportement des clés API personnalisées de Cursor dépend de la version et de la surface des fonctionnalités. Si votre build Cursor n’accepte que les clés API du fournisseur et n’expose pas d’URL de base personnalisée pour la fonctionnalité souhaitée, elle ne peut pas être dirigée directement vers EmpirioLabs pour cette fonctionnalité.

Dépannage

Gardez les agents ancrés

Lorsqu’un assistant de codage IA implémente une intégration EmpirioLabs pour vous, donnez-lui d’abord le pack de documents lisible par machine:

Dites à l’agent d’utiliser https://docs.empiriolabs.ai/ai-agent-api-reference-context.md comme référence API, https://docs.empiriolabs.ai/ai-agent-docs-context.md pour les détails du modèle et des prix, et GET https://api.empiriolabs.ai/v1/models/\{model_id\} pour les métadonnées du modèle en direct.

Cela empêche l’agent de deviner les formes des points d’extrémité, les identifiants de modèles obsolètes ou les noms de paramètres.