Integrações

A maioria das ferramentas precisa de apenas três valores: uma chave de API, uma URL base e um ID de modelo. O EmpirioLabs expõe conclusãos de chat compatíveis com OpenAI além de um endpoint de Mensagens no estilo Anthropic, então a configuração geralmente é um menu suspenso do provedor e uma mudança de URL.

OpenCodeClaude CodeClineQwen CodeCodex CLIAiderContinueOpenHandsHermes AgentOpenClawgooseZedSillyTavernPersonaLLMJanitor AITypingMindOpen WebUILibreChatLobeChatLiteLLMKilo, Roo, Cursor

Configuração mais rápida

Use isso quando quiser uma configuração funcional sem precisar editar manualmente arquivos de configuração. O comando pega o script helper do site docs, roda com Python e escreve apenas os escopos que você escolher. Para ferramentas que suportam configuração local persistente, o ajudante armazena a chave em arquivos de projeto ignorados no git, para que sessões reabertas do app não dependam de uma exportação 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

O que o ajudante escreve

Por padrão, o ajudante busca o catálogo de /v1/models?available=true ao vivo e escreve todos os modelos com capacidade de chat (texto, multimodal, código, raciocínio) em ferramentas cujas configurações suportam nativamente um seletor multi-modelo (OpenCode, Continue, Qwen Code, goose). A flag --model seleciona o padrão dentro daquele conjunto preenchido. Passe --no-populate-models se quiser registrar apenas o modelo padrão.

O auxiliar valida os nomes das ferramentas e sai com um erro para valores desconhecidos. Se uma ferramenta selecionada não corresponder ao escopo escolhido, o assistente imprime uma nota. Por exemplo, --scope project --tools codex não escreve a configuração do Codex porque o Codex é uma configuração em nível de usuário.

Integrações não listadas nesta tabela são configurações manuais de interface ou nível de app. Use os valores de conexão abaixo para Cline, Zed, Kilo Code, Roo Code, campos no estilo Cursor, interfaces de chat e interfaces web hospedadas.

Atualizando a lista de modelos após um novo lançamento

O helper pega GET /v1/models?available=true em cada execução e reescreve as configurações multi-modelo a partir desse snapshot ao vivo, de modo que a lista de modelos registrados reflete os modelos lançados no momento em que o helper executa. Reexecutar o mesmo comando após o lançamento de um novo modelo adiciona ele ao opencode.json do OpenCode, à config.yaml do Continue, à lista de provedores Qwen Code settings.json e ao JSON do provedor personalizado Goose sem outras edições. Aider, OpenHands, Claude Code, Codex CLI, Hermes Agent e OpenClaw não mantêm um registro multimodelo em sua configuração, então essas ferramentas sempre leem o modelo que seu código passa no momento da solicitação, o que significa que não é necessário re-executar o helper nessas ferramentas quando um novo modelo é lançado.

$
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

Atualização automática sem mãos (instalada por padrão)

O comando de configuração instala uma tarefa agendada nativa da plataforma que recupera a lista de modelos do EmpirioLabs a cada 6 horas, então modelos recém-lançados aparecem em OpenCode, Qwen Code, Continue e Goose sem nenhuma etapa manual. O trabalho roda sozinho, em segundo plano, sem necessidade de sessão shell:

• Linux: uma entrada marcada no crontab do seu usuário (visível com crontab -l)
• macOS: um usuário LaunchAgent em ~/Library/LaunchAgents/ai.empiriolabs.refresh.plist
• Windows: uma tarefa do Agendador de Tarefas chamada “EmpirioLabs Auto Refresh”

O trabalho lê a chave API do ~/.empiriolabs/.empiriolabs-api-key (modo 600 no POSIX) e só reescreve configurações que já existem no disco, então nunca cria arquivos em diretórios não relacionados. Logs (macOS) e stdout (Linux/Windows) vão para ~/.empiriolabs/refresh.log.

Passe --no-auto-refresh para o comando de configuração para optar por sair, ou execute o helper depois com --uninstall-auto-refresh para remover a tarefa agendada e limpar as entradas dos 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 conexão

Controle de pensamento e raciocínio

O EmpirioLabs expõe controles de raciocínio apenas em modelos que os listam em sua página de modelo ou esquema legível por máquina. Não envie esses campos para todos os modelos por padrão.

Para Conversas Completas e Respostas compatíveis com OpenAI, os controles suportados podem incluir enable_thinking, thinking_budget ou reasoning_effort, dependendo do modelo:

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

Para o endpoint Mensagens no estilo Antrópico, use o pensamento no estilo Antrópico quando o modelo suportar o pensamento:

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 aceita none, low, medium, high e max em todos os modelos com capacidade de raciocínio. O EmpirioLabs normaliza o valor nos campos de raciocínio suportados pelo modelo selecionado, então a mesma cadeia de esforço funciona entre famílias de modelos, independentemente de o serviço de modelo esperar reasoning_effort, enable_thinking ou thinking_budget nativamente.

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

O suporte à ferramenta varia:

Teste de fumaça

Execute isso antes de configurar uma ferramenta maior. Se isso funcionar, sua chave, créditos, rede e ID do modelo são bons.

$
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 IDs de modelos atuais:

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

Interfaces de chat e roleplay

Use esta seção para aplicativos de chat BYOK, ferramentas de roleplay e interfaces web compartilhadas. Essas ferramentas normalmente não precisam do script auxiliar. Use a chave API do EmpirioLabs, escolha um modelo de chat como qwen3-max e mantenha segredos nas configurações locais ou variáveis de ambiente do app.

SillyTavern

SillyTavern é uma interface local de roleplay e chat de personagens. A EmpirioLabs opera por meio de seu código-fonte personalizado Chat Completion compatível com OpenAI.

1. Abra SillyTavern e clique no ícone de ligar para abrir Conexões API.
2. Defina o tipo de API para Chat Completion.
3. Defina a fonte de conclusão do chat para Custom (OpenAI-compatible).
4. Defina o endpoint personalizado / URL da base para https://api.empiriolabs.ai/v1.
5. Cole sua chave API do EmpirioLabs no campo da chave API personalizada.
6. Clique em Conectar, depois escolha um modelo no menu suspenso ou digite um ID de modelo, como qwen3-max.

Se o menu suspenso do modelo estiver vazio, mas seu teste de fumaça funcionar, digite o ID do modelo manualmente. Se um sampler de roleplay causar um erro de solicitação, remova parâmetros extras não padrão e tente novamente com as configurações padrão do chat primeiro.

PersonaLLM

PersonaLLM é um aplicativo de roleplay e chat de personagens para iOS com configurações bring-your-own-key provedores. O EmpirioLabs funciona por meio do motor de texto personalizado do PersonaLLM.

1. Na tela inicial, toque no menu de três pontos no canto superior esquerdo.
2. Abrir Configurações.
3. Motor de Texto Aberto.
4. Escolha personalizado.
5. Defina a URL base para https://api.empiriolabs.ai/v1.
6. Cole sua chave API do EmpirioLabs.
7. No campo de modelos, toque no botão à direita para buscar a lista de modelos ao vivo.
8. Escolha um modelo de chat como qwen3-max ou glm-5-1, depois salve as configurações do motor de texto.

IA de zelador

A IA do zelador pode ligar para a EmpirioLabs por meio de sua configuração Proxy. Use esse caminho quando quiser continuar usando a interface de chat do Zelador enquanto leva sua própria chave do EmpirioLabs.

1. Abra um chat de IA para faxineiros.
2. Clique using janitor ou no botão do menu perto do topo do chat.
3. Abra API Settings.
4. Selecione a aba Proxy.
5. Em Configurações de Proxy, clique + New.
6. Defina o nome para EmpirioLabs.
7. Defina o modelo para qwen3-max, ou outro ID de modelo a partir do GET /v1/models?available=true.
8. Defina a URL do Proxy para https://api.empiriolabs.ai/v1/chat/completions.
9. Cole sua chave API do EmpirioLabs na chave API.
10. Deixe o Prompt Personalizado em branco, a menos que você já use um para aquele personagem ou chat.
11. Clique em Adicionar, salve as configurações e depois atualize a página do Janitor AI antes de enviar a próxima mensagem.

TypingMind

O TypingMind suporta modelos de chat personalizados onde você fornece um endpoint, ID de modelo e cabeçalhos opcionais.

1. Abra Models na barra lateral esquerda.
2. Abra as Configurações do Modelo e clique Add Custom Models.
3. Use o tipo de API OpenAI Chat Completions API se o formulário solicitar.
4. Defina a API do Endpoint para https://api.empiriolabs.ai/v1/chat/completions.
5. Defina o ID do Modelo para qwen3-max ou outro modelo disponível.
6. Adicione o cabeçalho Authorization: Bearer sk-empiriolabs-your_key_here, ou cole a chave no campo da chave API do TypingMind, se o formulário fornecer um.
7. Clique em Testar, depois Adicionar Modelo.

Open WebUI

O OpenUI pode se conectar a provedores compatíveis com OpenAI pela tela de conexão de administrador.

1. Abra as Configurações de Administrador.
2. Vá para Connections e adicione uma nova conexão OpenAI.
3. Defina a URL para https://api.empiriolabs.ai/v1.
4. Cole sua chave API do EmpirioLabs.
5. Se a descoberta do modelo for lenta ou muito ampla, adicione IDs de modelos, como qwen3-max, ao filtro de IDs de Modelo.
6. Salve, depois escolha o modelo EmpirioLabs no chat.

Para lançamentos de servidores, defina:

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

LibreChat

O LibreChat suporta endpoints personalizados compatíveis com OpenAI por meio de librechat.yaml. Use uma variável de ambiente para uma chave de implantação compartilhada, ou user_provided se cada usuário deve trazer sua própria chave na 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

Para implantações multiusuário BYOK, mude apiKey para:

1
apiKey: "user_provided"

Reinicie o LibreChat após mudar librechat.yaml.

LobeChat

Para LobeChat auto-hospedado, use o provedor OpenAI com a URL base da API do 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

Depois, reinicie o LobeChat e escolha um modelo EmpirioLabs ativado no seletor de modelos.

LiteLLM

EmpirioLabs é um provedor LiteLLM embutido, então o SDK e o Proxy LiteLLM podem rotear para qualquer modelo de chat da EmpirioLabs com o prefixo empiriolabs/. Em versões do LiteLLM anteriores ao provedor, use o recurso compatível com OpenAI abaixo.

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

Versões mais antigas do LiteLLM (ou geração de imagem) podem usar diretamente a rota compatível com 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
)

O campo sync: true faz com que o endpoint da imagem retorne a resposta finalizada em formato OpenAI em vez do envelope padrão assíncrono de trabalho. A própria página do provedor do LiteLLM para a EmpirioLabs está em docs.litellm.ai/docs/providers/empiriolabs.

OpenCode

O assistente pode escrever isso automaticamente:

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

Configuração 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

No OpenCode, execute /models e escolha o provedor EmpirioLabs. A chave de arquivo continua funcionando depois que você fecha e reabre o OpenCode.

Claude Code

O assistente pode escrever automaticamente as configurações em nível de usuário:

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

Claude Code não é um cliente OpenAI-chat-completions. Ele se comunica com gateways de LLM através da forma Anthropic Messages, que o EmpirioLabs expõe em /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

Configuração persistente em nível de usuário:

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

Na interface da extensão Cline:

1. Abra as configurações do Cline.
2. Defina o provedor de API para OpenAI Compatible.
3. Defina a URL base para https://api.empiriolabs.ai/v1.
4. Cole sua chave API do EmpirioLabs.
5. Insira um ID de modelo como qwen3-max.
6. Clique em Verificar e então comece uma nova tarefa.

Para o 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."

Código Qwen

O ajudante pode escrever automaticamente as configurações do projeto ou do usuário:

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

Lance o Qwen Code diretamente com a EmpirioLabs como provedor compatível com 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 configuração persistente de projeto:

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
}

Adicione .qwen/settings.json ao .gitignore se você armazenar a chave lá.

Codex CLI

O assistente pode escrever automaticamente o bloco de provedor em nível de usuário:

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

Adicione a EmpirioLabs como provedora de modelos personalizados em ~/.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"

Depois, lance o Codex com sua chave no ambiente:

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

Use esse caminho com modelos do EmpirioLabs que suportam POST /v1/responses.

Aider

O ajudante pode escrever automaticamente uma configuração local de projeto no Aider:

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

O Aider utiliza as variáveis de ambiente compatíveis com OpenAI. Prefixe o modelo com openai/.

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

Continue

O auxiliar pode escrever automaticamente a configuração Continue em nível de usuário:

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

O provedor OpenAI da Continue pode direcionar qualquer endpoint compatível com OpenAI definindo apiBase. Coloque segredos no armazenamento secreto de .env ou Continue em vez de colocá-los em 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

Adicione o segredo em um dos locais de .env suportados pelo Continue:

$
EMPIRIOLABS_API_KEY=sk-empiriolabs-your_key_here

OpenHands

O ajudante pode escrever automaticamente uma configuração OpenHands local no projeto:

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

O OpenHands expõe as configurações do provedor na interface e as passa para sua camada de LLM.

Para lançamentos baseados no ambiente:

$
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 configuração persistente de projeto:

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

Conduza OpenHands com:

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

Adicione openhands.empiriolabs.toml ao .gitignore se você armazenar a chave lá.

Agente Hermes

O auxiliar pode escrever automaticamente o sidecar Hermes em nível de usuário:

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

Hermes tem um mago de modelos interativo. Escolha Custom endpoint e depois insira:

Configuração 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

O ajudante pode escrever automaticamente um sidecar OpenClaw em nível de usuário:

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

A configuração mais segura é o wizard OpenClaw:

$
openclaw configure --section model

Escolha um provedor personalizado ou compatível com OpenAI e use:

Para configuração manual de JSON5, use isso como sidecar ou funda-o na configuração do 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
}

Execute openclaw config validate após edições manuais.

ganso

O assistente pode escrever automaticamente o provedor customizado Goose em nível de usuário:

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

o goose suporta provedores personalizados compatíveis com OpenAI. O assistente escreve isso como empiriolabs.json no diretório de provedores personalizados do 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

O Zed suporta provedores compatíveis com OpenAI no Painel de Agentes. Use o fluxo Add Provider da interface ou edite as configurações:

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
}

Adicione a chave de API pelo Painel de Agentes para que o Zed a armazene no armazenamento de credenciais do sistema operacional.

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

Use esta tabela em qualquer lugar onde uma ferramenta exponha OpenAI Compatible, Custom OpenAI ou Override OpenAI Base URL.

As extensões Kilo Code e VS Code estilo Roo normalmente expõem isso como um perfil de configuração de API. A documentação pública e os avisos de produtos do Roo Code indicam um caminho shutdown/archive em 15 de maio de 2026, então prefira o Cline ou o Kilo Code para novos templates para toda a equipe, a menos que sua equipe já dependa do Roo.

O comportamento da chave API personalizada do Cursor depende da versão e da superfície de recursos. Se sua build do Cursor aceita apenas chaves de API de provedor e não expõe uma URL base personalizada para o recurso que você deseja, ela não pode ser apontada diretamente para o EmpirioLabs para esse recurso.

Solução de problemas

Mantenha os agentes com os pés no chão

Quando um assistente de programação de IA estiver implementando uma integração com o EmpirioLabs para você, dê primeiro o pacote de documentação legível por máquina:

Diga ao agente para usar https://docs.empiriolabs.ai/ai-agent-api-reference-context.md como referência da API, https://docs.empiriolabs.ai/ai-agent-docs-context.md para detalhes do modelo e preço, e GET https://api.empiriolabs.ai/v1/models/\{model_id\} para metadados do modelo ao vivo.

Isso impede que o agente adivinhe formas de endpoint, IDs de modelos obsoletos ou nomes de parâmetros.