Integraciones

La mayoría de las herramientas solo necesitan tres valores: una clave API, una URL base y un ID de modelo. EmpirioLabs expone completaciones de chats compatibles con OpenAI además de un endpoint de Mensajes al estilo Anthropic, por lo que la configuración suele ser un desplegable de proveedor y un cambio de URL.

OpenCodeClaude CodeClineQwen CodeCodex CLIAiderContinueOpenHandsHermes AgentOpenClawgooseZedSillyTavernPersonaLLMJanitor AITypingMindOpen WebUILibreChatLobeChatLiteLLMKilo, Roo, Cursor

Configuración más rápida

Úsalo cuando quieras una configuración funcional sin editar manualmente los archivos de configuración. El comando obtiene el script helper del sitio de docs, lo ejecuta con Python y escribe solo los scopes que elijas. Para herramientas que soportan configuración local persistente, el ayudante almacena la clave en archivos de proyecto ignorados en gitignored, por lo que las sesiones reabiertas de la app no dependen de una exportación de 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

Lo que escribe el ayudante

Por defecto, el ayudante obtiene el catálogo de /v1/models?available=true en vivo y escribe todos los modelos capaces de chatear (texto, multimodal, código, razonamiento) en herramientas cuyas configuraciones soportan nativamente un selector multimodelo (OpenCode, Continue, Qwen Code, goose). La bandera --model selecciona el valor predeterminado dentro de ese conjunto poblado. Aprueba --no-populate-models si solo quieres registrar el modelo predeterminado.

El ayudante valida los nombres de las herramientas y sale con un error para valores desconocidos. Si una herramienta seleccionada no coincide con el alcance elegido, el ayudante imprime una nota. Por ejemplo, --scope project --tools codex no escribe la configuración del códex porque el códice es una configuración a nivel de usuario.

Las integraciones que no se listan en esta tabla son configuraciones manuales de interfaz o a nivel de app. Utiliza los valores de conexión que aparecen a continuación para Cline, Zed, Kilo Code, Roo Code, campos tipo Cursor, interfaces de chat y interfaces web alojadas.

Actualizar la lista de modelos tras un nuevo lanzamiento

El ayudante recupera GET /v1/models?available=true en cada ejecución y reescribe las configuraciones multimodelo de esa instantánea en vivo, de modo que la lista de modelos registrados refleje los modelos que se lanzan en el momento en que el asistente se ejecuta. Volver a ejecutar el mismo comando tras el lanzamiento de un nuevo modelo lo añade a la opencode.json de OpenCode, a la config.yaml de Continue, a la lista de proveedores de Qwen Code settings.json y al JSON de proveedor personalizado de Goose sin ninguna otra edición. Aider, OpenHands, Claude Code, Codex CLI, Hermes Agent y OpenClaw no mantienen un registro multimodelo en su configuración, por lo que esas herramientas siempre leen el modelo que tu código pasa en el momento de la solicitud, lo que significa que no es necesario reejecutar un asistente cuando se lanza un nuevo modelo.

$
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

Refresco automático sin intervención (instalado por defecto)

El comando de configuración instala una tarea programada nativa de la plataforma que recupera la lista de modelos de EmpirioLabs cada 6 horas, por lo que los modelos recién lanzados aparecen en OpenCode, Qwen Code, Continuar y Goose sin ningún paso manual. El trabajo se ejecuta solo, en segundo plano, sin necesidad de sesión de shell:

• Linux: una entrada marcada en tu crontab de usuario (visible con crontab -l)
• macOS: un LaunchAgent de usuario en ~/Library/LaunchAgents/ai.empiriolabs.refresh.plist
• Windows: una tarea de Planificador de Tareas llamada “EmpirioLabs Auto Refresh”

El trabajo lee la clave API de ~/.empiriolabs/.empiriolabs-api-key (modo 600 en POSIX) y solo reescribe configuraciones que ya existen en el disco, por lo que nunca crea archivos en directorios no relacionados. Los registros (macOS) y stdout (Linux/Windows) van a ~/.empiriolabs/refresh.log.

Pasa --no-auto-refresh al comando de configuración para dar de baja o ejecuta el asistente más tarde con --uninstall-auto-refresh para eliminar la tarea programada y limpiar las entradas de marcadores.

$
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

Valores de conexión

Controles de pensamiento y razonamiento

EmpirioLabs expone controles de razonamiento solo en modelos que los listan en su página de modelo o en un esquema legible por máquina. No envíes estos campos a todos los modelos por defecto.

Para Chats Completions and Responses compatibles con OpenAI, los controles compatibles pueden incluir enable_thinking, thinking_budget o reasoning_effort, dependiendo del modelo:

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

Para el endpoint de Mensajes de estilo antrópico, utiliza el pensamiento de estilo antrópico cuando el modelo soporte el pensamiento:

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 acepta none, low, medium, high y max en todos los modelos con capacidad de razonamiento. EmpirioLabs normaliza el valor en los campos de razonamiento soportados por el modelo seleccionado, de modo que la misma cadena de esfuerzo funciona entre familias de modelos independientemente de si el servicio de modelo espera reasoning_effort, enable_thinking o thinking_budget nativamente.

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

El soporte de herramientas varía:

Prueba de humo

Ejecuta esto antes de configurar una herramienta más grande. Si esto funciona, tu clave, créditos, red y ID de modelo son buenos.

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

Para listar los IDs actuales de modelos:

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

Interfaces de chat y rol

Utiliza esta sección para aplicaciones de chat de BYOK, herramientas de rol y interfaces web compartidas. Estas herramientas normalmente no necesitan el script de ayuda. Usa tu clave API de EmpirioLabs, elige un modelo de chat como qwen3-max y guarda secretos en la configuración local o en las variables de entorno de la app.

SillyTavern

SillyTavern es una interfaz local de rol y chat de personajes. EmpirioLabs funciona a través de su código fuente personalizado compatible con OpenAI Chat Completing.

1. Abre SillyTavern y haz clic en el icono de conectar para abrir Conexiones API.
2. Establece el tipo de API a Chat Completion.
3. Configura la fuente de finalización del chat a Custom (OpenAI-compatible).
4. Establece la URL personalizada del endpoint / base a https://api.empiriolabs.ai/v1.
5. Pega tu clave API de EmpirioLabs en el campo de clave API personalizada.
6. Haz clic en Conectar, luego elige un modelo en el desplegable o escribe un ID de modelo como qwen3-max.

Si el menú desplegable del modelo está vacío pero tu prueba de humo funciona, escribe el ID del modelo manualmente. Si un sampler de roleplay causa un error de solicitud, elimina los parámetros extra no estándar y vuelve a intentarlo primero con los ajustes estándar del chat.

PersonaLLM

PersonaLLM es una aplicación de rol y chat de personajes para iOS con bring-your-own-key configuración de proveedor. EmpirioLabs funciona a través del motor de texto personalizado de PersonaLLM.

1. Desde la pantalla de inicio, toca el menú de tres puntos en la esquina superior izquierda.
2. Abrir Configuración.
3. Motor de texto abierto.
4. Elige personalizado.
5. Configura la URL base a https://api.empiriolabs.ai/v1.
6. Pega tu clave API de EmpirioLabs.
7. En el campo de modelos, pulsa el botón de la derecha para obtener la lista de modelos en vivo.
8. Elige un modelo de chat como qwen3-max o glm-5-1, y luego guarda la configuración del motor de texto.

IA del conserje

Janitor AI puede llamar a EmpirioLabs a través de su configuración Proxy. Usa este camino cuando quieras seguir usando la interfaz de chat de Conserje mientras llevas tu propia clave de EmpirioLabs.

1. Abre un chat de IA para conserjes.
2. Haz clic using janitor o en el botón del menú cerca de la parte superior del chat.
3. Abre API Settings.
4. Selecciona la pestaña Proxy.
5. En Configuraciones de Proxy, haz clic + New.
6. Establece el nombre a EmpirioLabs.
7. Establece el modelo a qwen3-max, o a otro ID de modelo desde GET /v1/models?available=true.
8. Configura la URL del proxy a https://api.empiriolabs.ai/v1/chat/completions.
9. Pega tu clave API de EmpirioLabs en la clave API.
10. Deja el prompt personalizado en blanco a menos que ya uses uno para ese personaje o chat.
11. Haz clic en Añadir, guarda la configuración y luego actualiza la página de IA del Conserje antes de enviar el siguiente mensaje.

TypingMind

TypingMind soporta modelos de chat personalizados donde se proporciona un endpoint, ID de modelo y cabeceras opcionales.

1. Abre Models desde la barra lateral izquierda.
2. Abre Configuración del modelo y luego haz clic Add Custom Models.
3. Usa el tipo API OpenAI Chat Completions API si el formulario lo solicita.
4. Configura la API de Endpoint a https://api.empiriolabs.ai/v1/chat/completions.
5. Configura el ID del modelo a qwen3-max u otro modelo disponible.
6. Añade Authorization: Bearer sk-empiriolabs-your_key_here de cabecera, o pega la clave en el campo de clave API de TypingMind si el formulario proporciona uno.
7. Haz clic en Probar y luego Añadir modelo.

Open WebUI

Open WebUI puede conectarse a proveedores compatibles con OpenAI desde la pantalla de administración de conexión.

1. Abre la configuración de administrador.
2. Ve a Connections y añade una nueva conexión OpenAI.
3. Establece la URL a https://api.empiriolabs.ai/v1.
4. Pega tu clave API de EmpirioLabs.
5. Si el descubrimiento de modelos es lento o demasiado amplio, añade identificadores de modelo como qwen3-max al filtro de identificadores de modelo.
6. Guarda y luego elige el modelo de EmpirioLabs en el chat.

Para los lanzamientos de servidores, establezca:

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

LibreChat

LibreChat soporta endpoints personalizados compatibles con OpenAI a través de librechat.yaml. Utiliza una variable de entorno para una clave de despliegue compartida, o user_provided si cada usuario debe llevar su propia clave en la interfaz.

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

Para despliegues multiusuario de BYOK, cambiar apiKey a:

1
apiKey: "user_provided"

Reinicia LibreChat después de cambiar librechat.yaml.

LobeChat

Para LobeChat autoalojado, utiliza el proveedor OpenAI con la URL base de la API de 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

Luego reinicia LobeChat y elige un modelo EmpirioLabs activado en el selector de modelos.

LiteLLM

EmpirioLabs es un proveedor integrado de LiteLLM, por lo que el SDK y el Proxy de LiteLLM pueden enrutar a cualquier modelo de chat de EmpirioLabs con el prefijo empiriolabs/. En versiones de LiteLLM anteriores al proveedor, utiliza el respaldo compatible con OpenAI que aparece a continuación.

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

Las versiones antiguas de LiteLLM (o generación de imágenes) pueden usar directamente la ruta compatible con 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
)

El campo sync: true hace que el extremo de la imagen devuelva la respuesta final con forma de OpenAI en lugar del sobre de trabajo asíncrono por defecto. La propia página de proveedores de LiteLLM para EmpirioLabs está en docs.litellm.ai/docs/providers/empiriolabs.

OpenCode

El ayudante puede escribir esto automáticamente:

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

Configuración manual:

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

En OpenCode, ejecuta /models y elige el proveedor EmpirioLabs. La clave de respaldo de archivos sigue funcionando después de cerrar y volver a abrir OpenCode.

Claude Code

El ayudante puede escribir automáticamente los ajustes a nivel de usuario:

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

Claude Code no es un cliente de OpenAI con completaciones de chats. Se comunica con los gateways de LLM a través de la forma Anthropic Messages, que EmpirioLabs expone en /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

Configuración persistente a nivel de usuario:

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

En la interfaz de extensión de Cline:

1. Abre la configuración de Cline.
2. Configura el proveedor de API a OpenAI Compatible.
3. Establece la URL base a https://api.empiriolabs.ai/v1.
4. Pega tu clave API de EmpirioLabs.
5. Introduce un ID de modelo como qwen3-max.
6. Haz clic en Verificar y luego comienza una nueva tarea.

Para la CLI de 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."

Código Qwen

El ayudante puede escribir automáticamente la configuración del proyecto o del usuario:

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

Lanza Qwen Code directamente con EmpirioLabs como proveedor compatible con 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"

Para la configuración de proyectos persistentes:

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
}

Añade .qwen/settings.json a .gitignore si guardas la clave allí.

Codex CLI

El ayudante puede escribir automáticamente el bloque de proveedor a nivel de usuario:

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

Añadir EmpirioLabs como proveedor de modelos personalizados 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"

Luego lanza el Codex con tu clave en el entorno:

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

Utiliza este camino con modelos de EmpirioLabs que soportan POST /v1/responses.

Aider

El ayudante puede escribir automáticamente una configuración local de Aider en el proyecto:

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

Aider utiliza las variables de entorno compatibles con OpenAI. Prefijo al modelo con openai/.

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

Continúa

El ayudante puede escribir automáticamente la configuración Continuar a nivel de usuario:

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

El proveedor OpenAI de Continue puede dirigirse a cualquier endpoint compatible con OpenAI configurando apiBase. Guarda secretos en .env o en la tienda secreta de Continue en vez de meterlos en 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

Añade el secreto en una de las ubicaciones de .env soportadas por Continue:

$
EMPIRIOLABS_API_KEY=sk-empiriolabs-your_key_here

OpenHands

El ayudante puede escribir automáticamente una configuración OpenHands local en el proyecto:

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

OpenHands expone la configuración del proveedor en la interfaz y la pasa a su capa LLM.

Para lanzamientos basados en el entorno:

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

Para la configuración de proyectos persistentes:

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

Ejecuta OpenHands con:

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

Añade openhands.empiriolabs.toml a .gitignore si guardas la clave allí.

Agente Hermes

El ayudante puede escribir automáticamente el sidecar Hermes a nivel de usuario:

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

Hermes tiene un mago interactivo para modelos. Elige Custom endpoint y luego escribe:

Configuración manual:

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

El ayudante puede escribir automáticamente un sidecar OpenClaw a nivel de usuario:

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

La configuración más segura es el asistente OpenClaw:

$
openclaw configure --section model

Elige un proveedor personalizado o compatible con OpenAI y utiliza:

Para la configuración manual de JSON5, úsalo como sidecar o intégralo en la configuración de 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
}

Ejecuta openclaw config validate después de las ediciones manuales.

ganso

El ayudante puede escribir automáticamente el proveedor personalizado de Goose a nivel de usuario:

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

goose soporta proveedores personalizados compatibles con OpenAI. El ayudante escribe esto como empiriolabs.json en el directorio de proveedores personalizados de 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 admite proveedores compatibles con OpenAI en el Panel de Agentes. Usa el flujo Add Provider de la interfaz o edita la configuración:

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
}

Añade la clave API a través del Panel de Agentes para que Zed la guarde en el almacén de credenciales del sistema operativo.

Código Kilo, Código Roo, Cursor, y IDEs similares

Utiliza esta tabla en cualquier lugar donde una herramienta exponga OpenAI Compatible, Custom OpenAI o Override OpenAI Base URL.

Las extensiones de Kilo Code y estilo Roo de VS Code normalmente exponen esto como un perfil de configuración de API. La documentación pública y los avisos de producto de Roo Code indican un camino shutdown/archive el 15 de mayo de 2026, así que prefiero Cline o Kilo Code para nuevas plantillas a nivel de equipo, a menos que tu equipo ya dependa de Roo.

El comportamiento de la clave API personalizada de Cursor depende de la versión y de la superficie de las características. Si tu versión de Cursor solo acepta claves API de proveedor y no expone una URL base personalizada para la función que deseas, no puede apuntarse directamente a EmpirioLabs para esa función.

Resolución de problemas

Mantén a los agentes con los pies en la tierra

Cuando un asistente de programación de IA implemente una integración con EmpirioLabs por ti, dale primero el paquete de documentación legible por máquina:

Dile al agente que use https://docs.empiriolabs.ai/ai-agent-api-reference-context.md como referencia de la API, https://docs.empiriolabs.ai/ai-agent-docs-context.md para detalles de modelos y precios, y GET https://api.empiriolabs.ai/v1/models/\{model_id\} para metadatos de modelos en vivo.

Eso impide que el agente adivine formas de endpoint, IDs de modelos obsoletos o nombres de parámetros.