Source: https://ailoot.ai/integrations/pt-pt/
Canonical: https://ailoot.ai/integrations/pt-pt/
Language: pt-pt

[Integrações](https://ailoot.ai/docs/pt-pt/integrations/) 

# Ligue o Ailoot às suas ferramentas favoritas — Ligação à API e configuração de clientes

Agentes, editores, chats e SDK que aceitam a chave Ailoot. O botão «Configurar» mostra onde inserir o endereço e a chave e fornece uma configuração pronta a copiar.

**85**aplicações

**77**prontas

**8**em verificação

 Pesquisa de aplicações 

## Agentes no terminal

Agentes de programação e CLI: escrevem código, executam comandos e alteram ficheiros.

CC

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

Agente no terminal

Anthropic Messages

Agente da Anthropic no terminal: escreve código, altera ficheiros e executa comandos.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/claude-code/)

#### Onde configurar

Variáveis de ambiente ou bloco "env" em ~/.claude/settings.json (para um só projeto — .claude/settings.local.json); extensão VS Code — claudeCode.environmentVariables; verificação — comando /status

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

`~/.claude/settings.json`

```json
{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.ailoot.ai",
    "ANTHROPIC_MODEL": "claude-sonnet-5-5",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "claude-opus-5-5",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-5-5",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "claude-haiku-4-5",
    "CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY": "1"
  }
}
```

```bash
export AILOOT_API_KEY="sk-..."
export ANTHROPIC_AUTH_TOKEN="$AILOOT_API_KEY"
claude
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

Endereço sem /v1: o Claude Code acrescenta automaticamente /v1/messages. ANTHROPIC\_AUTH\_TOKEN é enviado como Authorization: Bearer e ANTHROPIC\_API\_KEY como x-api-key; o Ailoot aceita ambos. CLAUDE\_CODE\_ENABLE\_GATEWAY\_MODEL\_DISCOVERY=1 carrega os nossos modelos em /model através de /v1/models. Para erros 400 sobre campos desconhecidos — CLAUDE\_CODE\_DISABLE\_EXPERIMENTAL\_BETAS=1. A documentação da Anthropic não suporta a utilização do Claude Code com modelos que não sejam Claude através de um gateway, embora o nosso /v1/messages os processe; recomendamos modelos Claude. Remote Control e entrada por voz não estão disponíveis através do gateway.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/claude-code/)[Documentação da aplicação ↗](https://code.claude.com/docs/en/llm-gateway-connect)

OC

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

Agente no terminal

OpenAI Responses

Agente da OpenAI para o terminal, utiliza o formato Responses.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/openai-codex-cli/)

#### Onde configurar

~/.codex/config.toml (apenas o ficheiro do utilizador: no .codex/config.toml do projeto, as chaves model\_provider/model\_providers são ignoradas); chave — na variável indicada em env\_key

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/responses e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

`~/.codex/config.toml`

```toml
model = "gpt-6.1-sol"
model_provider = "ailoot"

[model_providers.ailoot]
name = "Ailoot"
base_url = "https://api.ailoot.ai/v1"
env_key = "AILOOT_API_KEY"
wire_api = "responses"
```

```bash
export AILOOT_API_KEY="sk-..."
codex
```

Exemplo de modelo: `gpt-6.1-sol`

#### Importante

O Codex funciona apenas através de OpenAI Responses API (a documentação indica somente wire\_api = "responses"), pelo que exige o nosso /v1/responses. Os ID de fornecedor openai, ollama e lmstudio estão reservados. Alternativa — openai\_base\_url = "https://api.ailoot.ai/v1" para o fornecedor openai incorporado. O Ailoot entrega ao Codex a lista de modelos no formato de manifesto Codex (GET /v1/models com client\_version). Escolha um modelo específico cujo catálogo inclua o formato OpenAI Responses. No catálogo de 2026-09-30, gemini-3.6-flash suporta OpenAI Chat, Anthropic Messages e Gemini, mas não Responses; por isso, não é adequado para Codex. Verifique os formatos na ficha do modelo, e não pelo nome da família.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/openai-codex-cli/)[Documentação da aplicação ↗](https://learn.chatgpt.com/docs/config-file/config-advanced)

HA

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

Agente no terminal

OpenAI ChatOpenAI ResponsesAnthropic Messages

Agente da Nous Research com memória e competências para o terminal.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/hermes-agent/)

#### Onde configurar

hermes model → «Custom endpoint (self-hosted / VLLM / etc.)» ou ~/.hermes/config.yaml (secção model ou dicionário providers)

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

`~/.hermes/config.yaml`

```yaml
model:
  default: claude-sonnet-5-5
  provider: custom
  base_url: https://api.ailoot.ai/v1
  key_env: AILOOT_API_KEY

# vários formatos em simultâneo — fornecedores com nome:
providers:
  ailoot:
    api: https://api.ailoot.ai/v1
    key_env: AILOOT_API_KEY
    transport: chat_completions
    default_model: gpt-6.1-sol
  ailoot-claude:
    api: https://api.ailoot.ai
    key_env: AILOOT_API_KEY
    transport: anthropic_messages
    default_model: claude-sonnet-5-5

# na sessão: /model custom:claude-sonnet-5-5
```

A chave é lida da variável `AILOOT_API_KEY` — defina-a antes de iniciar:

```bash
export AILOOT_API_KEY="sk-..."   # adicione a ~/.zshrc ou ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # depois reinicie o terminal
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

transport: chat\_completions (OpenAI Chat), anthropic\_messages (Anthropic Messages) ou codex\_responses (OpenAI Responses). LLM\_MODEL em .env já não é utilizado; OPENAI\_BASE\_URL aplica-se apenas ao fornecedor openai-api. Para anthropic\_messages, indique o endereço sem /v1 — o SDK Anthropic acrescenta automaticamente /v1/messages. As tarefas auxiliares (reconhecimento de imagens, compressão do histórico) utilizam por predefinição o mesmo modelo principal.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/hermes-agent/)[Documentação da aplicação ↗](https://hermes-agent.nousresearch.com/docs/integrations/providers)

Op

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

Agente no terminal

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Assistente de IA pessoal no seu computador: chats, mensagens e tarefas.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/openclaw/)

#### Onde configurar

Configuração OpenClaw (~/.openclaw/openclaw.json) → models.providers.\<id\>; modelo predefinido — agents.defaults.model.primary; alteração segura — openclaw config set models.providers.\<id\> '\<json\>' --strict-json --merge

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```json
{
  "agents": {
    "defaults": {
      "model": {
        "primary": "ailoot/claude-sonnet-5-5"
      }
    }
  },
  "models": {
    "mode": "merge",
    "providers": {
      "ailoot": {
        "baseUrl": "https://api.ailoot.ai/v1",
        "apiKey": "${AILOOT_API_KEY}",
        "api": "openai-completions",
        "models": [
          {
            "id": "claude-sonnet-5-5",
            "name": "Claude Sonnet 5.5",
            "reasoning": true,
            "input": [
              "text"
            ],
            "contextWindow": 1000000,
            "maxTokens": 128000
          },
          {
            "id": "deepseek-v4-pro",
            "name": "DeepSeek V4 Pro",
            "reasoning": true,
            "input": [
              "text"
            ],
            "contextWindow": 1000000,
            "maxTokens": 131072
          }
        ]
      },
      "ailoot-claude": {
        "baseUrl": "https://api.ailoot.ai",
        "apiKey": "${AILOOT_API_KEY}",
        "api": "anthropic-messages",
        "models": [
          {
            "id": "claude-opus-5-5",
            "name": "Claude Opus 5.5",
            "reasoning": true,
            "input": [
              "text"
            ],
            "contextWindow": 1000000,
            "maxTokens": 131072
          }
        ]
      }
    }
  }
}
```

A chave é lida da variável `AILOOT_API_KEY` — defina-a antes de iniciar:

```bash
export AILOOT_API_KEY="sk-..."   # adicione a ~/.zshrc ou ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # depois reinicie o terminal
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

Adaptadores api: openai-completions (por predefinição quando baseUrl está definido), openai-responses (apenas se o servidor suportar /v1/responses — o Ailoot suporta), anthropic-messages, google-generative-ai e outros. Nos exemplos OpenClaw para anthropic-messages, baseUrl não inclui /v1. O OpenClaw pode transmitir imagens quando input do modelo contém "image". Nos exemplos Claude, foi mantido apenas texto: no catálogo de 2026-09-30, estes métodos não anunciam entrada image. Acrescente "image" apenas para um modelo específico cuja ficha no catálogo atual indique imagens na entrada e o formato de API escolhido. Por exemplo, gemini-3.6-flash anuncia entrada image para OpenAI Chat neste catálogo; o suporte efetivo depende da ficha e do formato do modelo. O caminho do ficheiro de configuração principal baseia-se na prática habitual do OpenClaw; a página consultada também menciona ~/.openclaw/agents/\<agentId\>/agent/models.json.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/openclaw/)[Documentação da aplicação ↗](https://docs.openclaw.ai/gateway/config-tools/custom-providers)

Op

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

Agente no terminal

OpenAI Chat

Agente de código aberto no terminal com qualquer fornecedor compatível com OpenAI.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/opencode/)

#### Onde configurar

opencode.json (no projeto ou em ~/.config/opencode/opencode.json) → provider.\<id\>; chave — através de /connect ou "apiKey": "{env:VAR}"

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```json
{
  "$schema": "https://opencode.ai/config.json",
  "model": "ailoot/claude-sonnet-5-5",
  "provider": {
    "ailoot": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ailoot",
      "options": {
        "baseURL": "https://api.ailoot.ai/v1",
        "apiKey": "{env:AILOOT_API_KEY}"
      },
      "models": {
        "claude-sonnet-5-5": {
          "name": "Claude Sonnet 5.5"
        },
        "gpt-6.1-sol": {
          "name": "GPT-6.1 Sol"
        },
        "deepseek-v4-pro": {
          "name": "DeepSeek V4 Pro"
        }
      }
    }
  }
}
```

A chave é lida da variável `AILOOT_API_KEY` — defina-a antes de iniciar:

```bash
export AILOOT_API_KEY="sk-..."   # adicione a ~/.zshrc ou ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # depois reinicie o terminal
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

O pacote @ai-sdk/openai-compatible utiliza /v1/chat/completions. Para modelos que exigem /v1/responses, a documentação opencode indica o pacote @ai-sdk/openai. A documentação opencode não descreve um fornecedor compatível com Anthropic com baseURL personalizado. Escolha modelos cujo catálogo atual anuncie o formato OpenAI Chat. No catálogo de 2026-09-30, gemini-3.6-flash tem este formato; consulte as fichas dos restantes modelos Gemini. Este método não utiliza o formato nativo Gemini. A existência do método no catálogo não comprova um teste real de uma versão específica do cliente.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/opencode/)[Documentação da aplicação ↗](https://opencode.ai/docs/providers/)

QC

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

Agente no terminal

OpenAI ChatAnthropic MessagesGemini

Agente de consola da equipa Qwen: formatos OpenAI, Anthropic e Gemini.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/qwen-code/)

#### Onde configurar

Variáveis OPENAI\_API\_KEY / OPENAI\_BASE\_URL / OPENAI\_MODEL, comando /auth dentro da sessão ou ~/.qwen/settings.json (modelProviders + security.auth.selectedType)

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```bash
export AILOOT_API_KEY="sk-..."
# método rápido
export OPENAI_API_KEY="$AILOOT_API_KEY"
export OPENAI_BASE_URL=https://api.ailoot.ai/v1
export OPENAI_MODEL=qwen3.8-max
qwen
```

`~/.qwen/settings.json`

```json
{
  "modelProviders": {
    "openai": [
      {
        "id": "qwen3.8-max",
        "name": "Qwen 3.8 Max (Ailoot)",
        "envKey": "AILOOT_API_KEY",
        "baseUrl": "https://api.ailoot.ai/v1"
      },
      {
        "id": "claude-sonnet-5-5",
        "name": "Claude Sonnet 5.5 (Ailoot)",
        "envKey": "AILOOT_API_KEY",
        "baseUrl": "https://api.ailoot.ai/v1"
      }
    ]
  },
  "security": {
    "auth": {
      "selectedType": "openai"
    }
  },
  "model": {
    "name": "qwen3.8-max"
  }
}
```

A chave é lida da variável `AILOOT_API_KEY` — defina-a antes de iniciar:

```bash
export AILOOT_API_KEY="sk-..."   # adicione a ~/.zshrc ou ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # depois reinicie o terminal
```

Exemplo de modelo: `qwen3.8-max`

#### Importante

Tipos de protocolo: openai (Chat Completions), anthropic, gemini, vertex-ai. Para openai, baseUrl inclui /v1. O exemplo da documentação para anthropic e gemini não apresenta baseUrl, pelo que recomendamos a opção openai. Para o tipo openai, escolha um modelo com formato OpenAI Chat no catálogo: gemini-3.6-flash suporta-o. Nos outros modelos Gemini, os formatos podem ser diferentes — consulte a ficha do modelo específico. A configuração com settings.json lê a chave da variável AILOOT\_API\_KEY (campo envKey): defina-a com export AILOOT\_API\_KEY=sk-... ou com a linha AILOOT\_API\_KEY=sk-... em ~/.qwen/.env; caso contrário, o Qwen Code inicia com uma chave vazia e recebe 401.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/qwen-code/)[Documentação da aplicação ↗](https://qwenlm.github.io/qwen-code-docs/en/users/configuration/auth/)

GC

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

Agente no terminal

Gemini

Agente da Google no terminal, utiliza o formato nativo Gemini.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/gemini-cli/)

#### Onde configurar

Variáveis de ambiente GEMINI\_API\_KEY e GOOGLE\_GEMINI\_BASE\_URL; método de autenticação — ~/.gemini/settings.json → security.auth.selectedType = "gemini-api-key"; modelo — GEMINI\_MODEL ou opção -m

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1beta/models/{model}:generateContent e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```bash
export AILOOT_API_KEY="sk-..."
export GEMINI_API_KEY="$AILOOT_API_KEY"
export GOOGLE_GEMINI_BASE_URL=https://api.ailoot.ai
export GEMINI_MODEL=gemini-3.8-flash
gemini
```

`~/.gemini/settings.json`

```json
{
  "security": {
    "auth": {
      "selectedType": "gemini-api-key"
    }
  }
}
```

Exemplo de modelo: `gemini-3.8-flash`

#### Importante

Endereço sem /v1beta: o SDK acrescenta automaticamente /v1beta/models/{model}:generateContent. O endereço tem de utilizar HTTPS. A chave é enviada no cabeçalho x-goog-api-key — aceite pelo Ailoot. Apenas são adequados modelos cujo formato indicado no catálogo seja Gemini. Antes de executar, confirme que o ID exato e este método estão disponíveis para a sua chave. O Ailoot entrega a resposta paga do Gemini integralmente após o cálculo do custo, e não palavra a palavra, pelo que, em respostas longas, o texto não aparece imediatamente.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/gemini-cli/)[Documentação da aplicação ↗](https://geminicli.com/docs/reference/configuration/)

KC

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

Agente no terminal

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Agente de consola da Moonshot para trabalhar com código.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/kimi-cli/)

#### Onde configurar

~/.kimi/config.toml (secções providers e models, default\_model); /login só suporta plataformas Moonshot — o endereço personalizado é definido manualmente no ficheiro

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

`~/.kimi/config.toml`

```toml
default_model = "ailoot-kimi"

[providers.ailoot]
type = "openai_legacy"
base_url = "https://api.ailoot.ai/v1"
api_key = "sk-..."

[providers.ailoot-claude]
type = "anthropic"
base_url = "https://api.ailoot.ai"
api_key = "sk-..."

[models.ailoot-kimi]
provider = "ailoot"
model = "kimi-k3"
max_context_size = 262144
capabilities = ["thinking"]

[models.ailoot-sonnet]
provider = "ailoot-claude"
model = "claude-sonnet-5-5"
max_context_size = 1000000
capabilities = ["thinking", "image_in"]
```

Exemplo de modelo: `kimi-k3`

#### Importante

Tipos: openai\_legacy (Chat Completions, base\_url com /v1), openai\_responses (Responses, com /v1), anthropic (sem /v1), gemini (base\_url é a raiz Google, no nosso caso https://api.ailoot.ai). A ferramenta SearchWeb só funciona com a plataforma própria da Moonshot; com outro endereço de API, FetchURL passa a utilizar transferência local.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/kimi-cli/)[Documentação da aplicação ↗](https://moonshotai.github.io/kimi-cli/en/configuration/providers.html)

Cr

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

Agente no terminal

OpenAI ChatAnthropic Messages

Agente da Charm no terminal, configurado no ficheiro crushrc.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/crush/)

#### Onde configurar

crushrc (configuração Bash): ./.crushrc, ./crushrc ou ~/.config/crush/crushrc; o formato antigo crush.json está obsoleto, mas funciona

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

`~/.config/crush/crushrc`

```bash
export AILOOT_API_KEY="sk-..."
provider add ailoot --type openai-compat \
  --base-url "https://api.ailoot.ai/v1" \
  --api-key "$AILOOT_API_KEY"

model add ailoot/deepseek-v4-pro \
  --name "DeepSeek V4 Pro (Ailoot)" \
  --context-window 1000000 \
  --default-max-tokens 32000

# formato Anthropic para Claude: endereço sem /v1
provider add ailoot-claude --type anthropic \
  --base-url "https://api.ailoot.ai" \
  --api-key "$AILOOT_API_KEY"

model add ailoot-claude/claude-sonnet-5-5 \
  --name "Claude Sonnet 5.5 (Ailoot)" \
  --context-window 1000000 \
  --default-max-tokens 64000 \
  --can-reason true --supports-images false
```

A chave é lida da variável `AILOOT_API_KEY` — defina-a antes de iniciar:

```bash
export AILOOT_API_KEY="sk-..."   # adicione a ~/.zshrc ou ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # depois reinicie o terminal
```

Exemplo de modelo: `deepseek-v4-pro`

#### Importante

O tipo openai-compat corresponde ao formato OpenAI Chat, com endereço incluindo /v1. O tipo anthropic corresponde ao formato Messages, com endereço sem /v1: o Crush transmite-o ao anthropic-sdk-go, que acrescenta automaticamente /v1/messages. O exemplo do README do Crush com /v1 produziria o caminho /v1/v1/messages e um erro 404. A chave é enviada no cabeçalho x-api-key, aceite pelo Ailoot. Se a lista de modelos estiver vazia, o fornecedor openai-compat carrega-os automaticamente de /v1/models. crushrc é executado como código: não inicie o Crush em pastas de terceiros que contenham este ficheiro. Neste exemplo, Claude tem supports-images = false: o catálogo de 2026-09-30 anuncia apenas texto para o formato Messages escolhido. Se a sua versão do Crush suportar esta opção, ative-a apenas para um modelo cuja ficha atual no catálogo indique entrada image no formato de API escolhido; a opção do cliente não acrescenta, por si só, suporte de imagens ao modelo.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/crush/)[Documentação da aplicação ↗](https://github.com/charmbracelet/crush#custom-providers)

Ai

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

Agente no terminal

OpenAI Chat

Programação a pares com IA diretamente no repositório git.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/aider/)

#### Onde configurar

Variáveis OPENAI\_API\_BASE e OPENAI\_API\_KEY, opção --model openai/\<modelo\>

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```bash
export AILOOT_API_KEY="sk-..."
export OPENAI_API_BASE=https://api.ailoot.ai/v1
export OPENAI_API_KEY="$AILOOT_API_KEY"
aider --model openai/deepseek-v4-pro
```

Exemplo de modelo: `openai/deepseek-v4-pro`

#### Importante

O prefixo openai/ é obrigatório: é assim que o Aider (através do LiteLLM) envia pedidos para /v1/chat/completions compatível com OpenAI. Para modelos desconhecidos do Aider, surgirá um aviso de contexto desconhecido — não é um erro. A configuração de um endereço Anthropic com base URL personalizado não está descrita nesta página da documentação.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/aider/)[Documentação da aplicação ↗](https://aider.chat/docs/llms/openai-compat.html)

Go

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

Agente no terminal

OpenAI ChatAnthropic Messages

Agente de código aberto para terminal e computador com extensões MCP.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/goose/)

#### Onde configurar

goose configure → Custom Providers → Add A Custom Provider, ou JSON em ~/.config/goose/custom\_providers/ (Windows: %APPDATA%\\Block\\goose\\config\\custom\_providers\\); alternativa — fornecedor OpenAI incorporado com OPENAI\_HOST/OPENAI\_BASE\_PATH

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

`~/.config/goose/custom_providers/ailoot.json`

```json
{
  "name": "ailoot",
  "engine": "openai",
  "display_name": "Ailoot",
  "description": "Ailoot API",
  "api_key_env": "AILOOT_API_KEY",
  "base_url": "https://api.ailoot.ai/v1/chat/completions",
  "models": [
    {
      "name": "claude-sonnet-5-5",
      "context_limit": 1000000
    },
    {
      "name": "gpt-6.1-sol",
      "context_limit": 272000
    }
  ],
  "supports_streaming": true,
  "requires_auth": true
}
```

```bash
export AILOOT_API_KEY="sk-..."
goose session start --provider ailoot

# alternativa através do fornecedor OpenAI integrado:
export GOOSE_PROVIDER=openai
export OPENAI_HOST=https://api.ailoot.ai
export OPENAI_BASE_PATH=v1/chat/completions
export OPENAI_API_KEY="$AILOOT_API_KEY"
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

Motores do fornecedor personalizado: openai, anthropic, ollama. No exemplo Goose, base\_url para engine openai é o caminho completo até /v1/chat/completions. No fornecedor incorporado, OPENAI\_HOST é a raiz sem caminho e OPENAI\_BASE\_PATH é o caminho (por predefinição, v1/chat/completions). O Goose ignora a chave em config.yaml — aceita apenas variável ou porta-chaves. O repositório mudou para aaif-goose/goose.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/goose/)[Documentação da aplicação ↗](https://github.com/aaif-goose/goose/blob/main/documentation/docs/getting-started/providers.md)

FD

### [Factory Droid](https://ailoot.ai/docs/pt-pt/integrations/factory-droid/)

Agente no terminal

OpenAI ChatOpenAI ResponsesAnthropic Messages

Agente da Factory para terminal com modelos personalizados.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/factory-droid/)

#### Onde configurar

~/.factory/settings.json → array customModels; seleção de modelo — comando /model, secção «Custom models»

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```json
{
  "customModels": [
    {
      "model": "claude-sonnet-5-5",
      "displayName": "Claude Sonnet 5.5 (Ailoot)",
      "baseUrl": "https://api.ailoot.ai",
      "apiKey": "${AILOOT_API_KEY}",
      "provider": "anthropic",
      "maxOutputTokens": 64000
    },
    {
      "model": "gpt-6.1-sol",
      "displayName": "GPT-6.1 Sol (Ailoot)",
      "baseUrl": "https://api.ailoot.ai/v1",
      "apiKey": "${AILOOT_API_KEY}",
      "provider": "openai",
      "maxOutputTokens": 64000
    },
    {
      "model": "deepseek-v4-pro",
      "displayName": "DeepSeek V4 Pro (Ailoot)",
      "baseUrl": "https://api.ailoot.ai/v1",
      "apiKey": "${AILOOT_API_KEY}",
      "provider": "generic-chat-completion-api",
      "maxOutputTokens": 32000
    }
  ]
}
```

A chave é lida da variável `AILOOT_API_KEY` — defina-a antes de iniciar:

```bash
export AILOOT_API_KEY="sk-..."   # adicione a ~/.zshrc ou ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # depois reinicie o terminal
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

provider: anthropic = Messages API (baseUrl como em Anthropic, sem /v1), openai = Responses API (com /v1), generic-chat-completion-api = Chat Completions (com /v1). Em anthropic, a chave é enviada por predefinição em x-api-key (aceite pelo Ailoot); "authMode": "bearer" muda para Authorization. As chaves permanecem locais. A Factory testa integralmente apenas as API oficiais da Anthropic e da OpenAI.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/factory-droid/)[Documentação da aplicação ↗](https://docs.factory.com/model-independence/byok)

Am

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

Agente no terminal

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Agente de programação Amp com encaminhamento flexível de modelos.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/amp/)

#### Onde configurar

Definições → Model Routing → Add → Custom URL (ou Model Routing do workspace para a equipa); no terminal — amp config model-providers (list, test, set-priority, edit-router…)

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Model Routing → Add → Custom URL
  Format:   anthropic-messages
  Base URL: https://api.ailoot.ai
  API key:  sk-...
  Model mapping:
    anthropic/claude-fable-5 -> anthropic/claude-fable-5

Segunda ligação para GPT:
  Format:   responses
  Base URL: https://api.ailoot.ai/v1
  API key:  sk-...
  Model mapping:
    openai/gpt-5.6-sol -> gpt-5.6-sol

Verificação: amp config model-providers check-access --provider-model anthropic/claude-fable-5
```

Exemplo de modelo: `claude-fable-5`

#### Importante

Formatos de Custom URL: chat-completions (\<base\>/chat/completions), responses (\<base\>/responses), anthropic-messages (\<base\>/v1/messages, sem duplicar /v1), google-genai (\<base\>/models/\<model\>:streamGenerateContent). A chave é enviada como Authorization: Bearer. O mapeamento utiliza ID canónicos do Amp no formato provider/model; a seta define o ID que nos é enviado. Os modelos não abrangidos pela ligação são processados pelo próprio Amp, com os seus créditos. A documentação exige que o host personalizado seja acessível a partir do Amp — o endereço é público, pelo que esta condição está cumprida.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/amp/)[Documentação da aplicação ↗](https://ampcode.com/docs/markdown/customize/model-routing)

AI

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

Agente no terminal

OpenAI ChatAnthropic MessagesGemini

Chat universal no terminal com papéis, sessões e RAG.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/aichat/)

#### Onde configurar

config.yaml do AIChat → clients (tipos openai-compatible, claude, gemini); modelo — -m \<client\>:\<model\>

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```yaml
clients:
  - type: openai-compatible
    name: ailoot
    api_base: https://api.ailoot.ai/v1
    api_key: sk-...
    models:
      - name: deepseek-v4-pro
        max_input_tokens: 1000000
        supports_function_calling: true
  - type: claude
    api_base: https://api.ailoot.ai/v1
    api_key: sk-...
  - type: gemini
    api_base: https://api.ailoot.ai/v1beta
    api_key: sk-...
```

```bash
aichat -m ailoot:deepseek-v4-pro 'Olá'
```

Exemplo de modelo: `deepseek-v4-pro`

#### Importante

No exemplo de configuração AIChat, api\_base de claude inclui /v1 e o de gemini inclui /v1beta; no Ailoot, aplica-se o mesmo. Os três clientes dão acesso aos três formatos do Ailoot: OpenAI, Anthropic e Gemini.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/aichat/)[Documentação da aplicação ↗](https://github.com/sigoden/aichat/blob/main/config.example.yaml)

CC

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

Agente no terminal

OpenAI Chat

Versão de consola do Continue para agentes e automatização.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/continue-cli/)

#### Onde configurar

Configuração YAML do Continue (config.yaml), transmitida ao CLI com a opção --config \<path\>

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

`ailoot.yaml`

```text
name: Ailoot
version: 0.0.1
schema: v1
models:
  - name: Claude Sonnet 5.5 (Ailoot)
    provider: openai
    model: claude-sonnet-5-5
    apiBase: https://api.ailoot.ai/v1
    apiKey: sk-...

# execução:
cn --config ./ailoot.yaml
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

Para serviços compatíveis com OpenAI, o Continue utiliza provider: openai e apiBase com /v1. O formato de configuração é partilhado pela extensão e pelo CLI; o ficheiro é transmitido com a opção --config.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/continue-cli/)[Documentação da aplicação ↗](https://docs.continue.dev/customize/model-providers/top-level/openai)

Fo

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

Agente no terminal

OpenAI Chat

Agente no terminal com fornecedores configuráveis.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/forge/)

#### Onde configurar

forge provider login → OpenAI-compatible (método recomendado); método obsoleto — .env com OPENAI\_URL e OPENAI\_API\_KEY, mais model em forge.yaml

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```bash
# recomendado:
forge provider login   # selecione OpenAI-compatible e introduza https://api.ailoot.ai/v1 e sk-...

# método antigo (.env):
OPENAI_API_KEY=sk-...
OPENAI_URL=https://api.ailoot.ai/v1

# forge.yaml
model: claude-sonnet-5-5
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

A configuração através de .env está assinalada como obsoleta: no primeiro início, o Forge transfere as variáveis para o seu armazenamento de ficheiros. O README não apresenta os nomes exatos das opções do assistente provider login.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/forge/)[Documentação da aplicação ↗](https://github.com/tailcallhq/forgecode)

GC

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

Agente no terminal

OpenAI ChatAnthropic Messages

Copilot no terminal com modelos personalizados.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/github-copilot-cli/)

#### Onde configurar

Variáveis de ambiente COPILOT\_PROVIDER\_BASE\_URL, COPILOT\_PROVIDER\_TYPE, COPILOT\_PROVIDER\_API\_KEY, COPILOT\_MODEL (ou opção --model)

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```bash
export AILOOT_API_KEY="sk-..."
unset COPILOT_PROVIDER_TYPE
# modo compatível com OpenAI
export COPILOT_PROVIDER_BASE_URL=https://api.ailoot.ai/v1
export COPILOT_PROVIDER_API_KEY="$AILOOT_API_KEY"
export COPILOT_MODEL=gpt-6.1-sol
copilot

# modo Anthropic
export COPILOT_PROVIDER_TYPE=anthropic
export COPILOT_PROVIDER_BASE_URL=https://api.ailoot.ai
export COPILOT_PROVIDER_API_KEY="$AILOOT_API_KEY"
export COPILOT_MODEL=claude-sonnet-5-5
copilot
```

Exemplo de modelo: `gpt-6.1-sol`

#### Importante

Tipos: openai (por predefinição, qualquer servidor compatível com OpenAI), azure, anthropic. O modelo tem de suportar chamadas de ferramentas e saída em fluxo. Existe COPILOT\_PROVIDER\_WIRE\_API para selecionar o protocolo; os seus valores não são enumerados na página. Os limites podem ser definidos através de COPILOT\_PROVIDER\_MAX\_PROMPT\_TOKENS / MAX\_OUTPUT\_TOKENS.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/github-copilot-cli/)[Documentação da aplicação ↗](https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/use-byok-models)

Gp

### [gptme](https://ailoot.ai/docs/pt-pt/integrations/gptme/)

Agente no terminal

OpenAI Chat

Agente pessoal no terminal: código, ficheiros e navegador.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/gptme/)

#### Onde configurar

~/.config/gptme/config.toml → \[\[providers\]\]; o modelo é selecionado como \<provider\>/\<model\>

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

`~/.config/gptme/config.toml`

```toml
[[providers]]
name = "ailoot"
base_url = "https://api.ailoot.ai/v1"
api_key_env = "AILOOT_API_KEY"
default_model = "claude-sonnet-5-5"
```

```bash
export AILOOT_API_KEY="sk-..."
gptme 'olá' -m ailoot/claude-sonnet-5-5
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

Qualquer servidor compatível com OpenAI; a chave é procurada em api\_key, depois em api\_key\_env e, por fim, em \<NAME\>\_API\_KEY. Lista de fornecedores — gptme-util providers list.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/gptme/)[Documentação da aplicação ↗](https://github.com/gptme/gptme/blob/master/docs/providers-custom.rst)

KC

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

Agente no terminal

OpenAI ChatOpenAI ResponsesAnthropic Messages

Agente de consola Kilo Code.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/kilo-code-cli/)

#### Onde configurar

~/.config/kilo/kilo.jsonc (ou ./kilo.jsonc; também KILO\_CONFIG) → provider.\<id\>.options.baseURL; na extensão — Settings → Providers → Custom provider

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```json
{
  "$schema": "https://app.kilo.ai/config.json",
  "model": "openai-compatible/claude-sonnet-5-5",
  "provider": {
    "openai-compatible": {
      "options": {
        "apiKey": "{env:AILOOT_API_KEY}",
        "baseURL": "https://api.ailoot.ai/v1"
      },
      "models": {
        "claude-sonnet-5-5": {
          "name": "Claude Sonnet 5.5 (Ailoot)",
          "tool_call": true,
          "limit": {
            "context": 1000000,
            "output": 64000
          }
        }
      }
    }
  }
}
```

A chave é lida da variável `AILOOT_API_KEY` — defina-a antes de iniciar:

```bash
export AILOOT_API_KEY="sk-..."   # adicione a ~/.zshrc ou ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # depois reinicie o terminal
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

O diálogo Custom provider permite escolher o protocolo: OpenAI Compatible (Chat Completions), OpenAI Responses, Anthropic Messages. {env:VAR} só funciona na configuração global de confiança (~/.config/kilo); no kilo.json do projeto, a chave da variável não é inserida.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/kilo-code-cli/)[Documentação da aplicação ↗](https://kilo.ai/docs/code-with-ai/agents/custom-models)

LL

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

Agente no terminal

OpenAI ChatOpenAI Responses

Utilitário para consultar modelos a partir da linha de comandos.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/llm-cli/)

#### Onde configurar

Ficheiro extra-openai-models.yaml na pasta de definições do llm; chave — llm keys set \<nome\>

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

`extra-openai-models.yaml`

```text
- model_id: ailoot-sonnet
  model_name: claude-sonnet-5-5
  api_base: "https://api.ailoot.ai/v1"
  api_key_name: ailoot
  supports_tools: true
  vision: true
- model_id: ailoot-gpt
  model_name: gpt-6.1-sol
  api_base: "https://api.ailoot.ai/v1"
  api_key_name: ailoot
  responses: true
```

```bash
llm keys set ailoot
llm -m ailoot-sonnet 'Olá'
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

Por predefinição, utiliza Chat Completions; responses: true muda o modelo para /responses. Quando api\_base está definido, a chave OpenAI não é enviada — é necessário api\_key\_name. Trata-se de um utilitário CLI para pedidos, e não de um agente.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/llm-cli/)[Documentação da aplicação ↗](https://llm.datasette.io/en/stable/other-models.html)

MS

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

Agente no terminal

OpenAI Chat

Agente minimalista para tarefas no repositório.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/mini-swe-agent/)

#### Onde configurar

Configuração YAML do agente → secção model (model\_name, model\_kwargs); o caminho da configuração predefinida é alterado através de MSWEA\_MINI\_CONFIG\_PATH

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```yaml
# fragmento da configuração do agente
model:
  model_name: "claude-sonnet-5-5"
  model_kwargs:
    custom_llm_provider: "openai"
    api_base: "https://api.ailoot.ai/v1"
  cost_tracking: "ignore_errors"
```

```bash
export AILOOT_API_KEY="sk-..."
export OPENAI_API_KEY="$AILOOT_API_KEY"
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

Funciona através do LiteLLM: model\_kwargs é transmitido diretamente a litellm.completion. Sem um registo de preços, o LiteLLM assinala um custo desconhecido — desativamos a verificação com cost\_tracking: "ignore\_errors" (ou MSWEA\_COST\_TRACKING=ignore\_errors). Transmitir a chave através de OPENAI\_API\_KEY é o procedimento padrão do LiteLLM, mas não está apresentado na própria página do mini-SWE-agent.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/mini-swe-agent/)[Documentação da aplicação ↗](https://github.com/SWE-agent/mini-swe-agent/blob/main/docs/models/local_models.md)

OC

### [OpenHands CLI](https://ailoot.ai/docs/pt-pt/integrations/openhands-cli/)

Agente no terminal

OpenAI Chat

Agente autónomo para desenvolvimento na linha de comandos.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/openhands-cli/)

#### Onde configurar

Ctrl+P → Settings (fornecedor e modelo), ficheiro ~/.openhands/agent\_settings.json (llm.model / llm.api\_key / llm.base\_url) ou variáveis LLM\_MODEL, LLM\_API\_KEY, LLM\_BASE\_URL com a opção --override-with-envs

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

`~/.openhands/agent_settings.json`

```json
{
  "llm": {
    "model": "openai/claude-sonnet-5-5",
    "api_key": "sk-...",
    "base_url": "https://api.ailoot.ai/v1"
  }
}
```

```bash
export AILOOT_API_KEY="sk-..."
# para uma execução, através de variáveis:
export LLM_MODEL=openai/claude-sonnet-5-5
export LLM_API_KEY="$AILOOT_API_KEY"
export LLM_BASE_URL=https://api.ailoot.ai/v1
openhands --override-with-envs
```

Exemplo de modelo: `openai/claude-sonnet-5-5`

#### Importante

O OpenHands funciona através do LiteLLM; para um proxy OpenAI, a documentação exige Custom Model no formato openai/\<modelo\> e Base URL do proxy. As alterações feitas através de --override-with-envs não são guardadas. Na interface web: Settings → LLM → Advanced → Custom Model, Base URL, API Key.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/openhands-cli/)[Documentação da aplicação ↗](https://docs.openhands.dev/openhands/usage/cli/command-reference)

Pi

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

Agente no terminal

OpenAI ChatAnthropic MessagesGemini

Agente de programação minimalista para o terminal.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/pi/)

#### Onde configurar

~/.pi/agent/models.json (ou .pi/models.json do projeto, após confiar no projeto); seleção — /model

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```json
{
  "providers": {
    "ailoot": {
      "baseUrl": "https://api.ailoot.ai/v1",
      "api": "openai-completions",
      "apiKey": "$AILOOT_API_KEY",
      "models": [
        {
          "id": "claude-sonnet-5-5",
          "input": [
            "text",
            "image"
          ]
        },
        {
          "id": "deepseek-v4-pro"
        }
      ]
    }
  }
}
```

A chave é lida da variável `AILOOT_API_KEY` — defina-a antes de iniciar:

```bash
export AILOOT_API_KEY="sk-..."   # adicione a ~/.zshrc ou ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # depois reinicie o terminal
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

A documentação Pi admite explicitamente endpoints compatíveis com OpenAI, Anthropic e Google através de models.json; o exemplo utiliza api: openai-completions. apiKey aceita $NAME/${NAME}, um valor literal ou !comando. O ficheiro é relido ao abrir /model.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/pi/)[Documentação da aplicação ↗](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/models.md)

Pl

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

Agente no terminal

OpenAI Chat

Agente para tarefas grandes: plano, alterações num ambiente isolado e aplicação.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/plandex/)

#### Onde configurar

plandex models custom (ou \\models custom no REPL) — abre um ficheiro JSON de modelos e fornecedores personalizados

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```json
{
  "$schema": "https://plandex.ai/schemas/models-input.schema.json",
  "providers": [
    {
      "name": "ailoot",
      "baseUrl": "https://api.ailoot.ai/v1",
      "apiKeyEnvVar": "AILOOT_API_KEY"
    }
  ],
  "models": [
    {
      "modelId": "ailoot-claude-sonnet-5-5",
      "publisher": "anthropic",
      "description": "Claude Sonnet 5.5 via Ailoot",
      "defaultMaxConvoTokens": 75000,
      "maxTokens": 1000000,
      "maxOutputTokens": 64000,
      "reservedOutputTokens": 32000,
      "preferredOutputFormat": "xml",
      "providers": [
        {
          "provider": "custom",
          "customProvider": "ailoot",
          "modelName": "claude-sonnet-5-5"
        }
      ]
    }
  ]
}
```

A chave é lida da variável `AILOOT_API_KEY` — defina-a antes de iniciar:

```bash
export AILOOT_API_KEY="sk-..."   # adicione a ~/.zshrc ou ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # depois reinicie o terminal
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

Os fornecedores personalizados só funcionam no Plandex alojado num servidor próprio; na nuvem com chaves BYO, apenas são permitidos os fornecedores incorporados. Todos os fornecedores personalizados têm de ser compatíveis com OpenAI (Chat Completions). Depois, o modelo é incluído no seu model pack.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/plandex/)[Documentação da aplicação ↗](https://github.com/plandex-ai/plandex/blob/main/docs/docs/models/custom-models.md)

TA

### [Trae Agent](https://ailoot.ai/docs/pt-pt/integrations/trae-agent/)

Agente no terminal

OpenAI ChatAnthropic Messages

Agente de investigação da ByteDance para tarefas de desenvolvimento.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/trae-agent/)

#### Onde configurar

trae\_config.yaml → model\_providers.\<nome\>.base\_url; alternativa — variáveis OPENAI\_BASE\_URL / ANTHROPIC\_BASE\_URL em .env

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

`trae_config.yaml`

```yaml
agents:
  trae_agent:
    model: trae_agent_model

model_providers:
  openai:
    api_key: sk-...
    provider: openai
    base_url: https://api.ailoot.ai/v1

models:
  trae_agent_model:
    model_provider: openai
    model: gpt-6.1-sol
    max_tokens: 4096
    temperature: 0.5
```

Exemplo de modelo: `gpt-6.1-sol`

#### Importante

Em YAML, utilize apenas espaços, sem tabulações. Para o formato Anthropic — provider: anthropic e ANTHROPIC\_BASE\_URL (o README não indica se anthropic espera /v1; utilize https://api.ailoot.ai).

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/trae-agent/)[Documentação da aplicação ↗](https://github.com/bytedance/trae-agent#using-base-url)

Wa

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

Agente no terminal

OpenAI Chat

Terminal com agente incorporado e endereço de modelo personalizado.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/warp/)

#### Onde configurar

Settings → pesquisar «inference endpoint» → Custom inference endpoint: URL de base, chave, ID dos modelos; depois, selecionar o modelo no seletor

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Settings → inference endpoint
  Endpoint URL: https://api.ailoot.ai/v1
  API key:      sk-...
  Models:       claude-sonnet-5-5, gpt-6.1-sol, deepseek-v4-pro
Depois, selecione, por exemplo, claude-sonnet-5-5 na lista de modelos (não Auto).
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

Apenas OpenAI Chat Completions (POST /v1/chat/completions). Os pedidos passam pelos servidores Warp: a chave é guardada localmente, mas é transmitida ao backend Warp em cada pedido. Os modos Auto e os routers personalizados utilizam sempre créditos Warp; os agentes na nuvem não utilizam este endpoint. Disponível no plano Free e nos planos pagos para pessoas e equipas até 10 membros. Escolha modelos cujo catálogo atual anuncie o formato OpenAI Chat. No catálogo de 2026-09-30, gemini-3.6-flash tem este formato; consulte as fichas dos restantes modelos Gemini. Este método não utiliza o formato nativo Gemini. A existência do método no catálogo não comprova um teste real de uma versão específica do cliente.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/warp/)[Documentação da aplicação ↗](https://docs.warp.dev/agents/inference/custom-inference-endpoint/)

## Editores e IDE

Extensões e assistentes incorporados em editores de código.

Cl

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

Extensão do editor

OpenAI ChatAnthropic Messages

Agente autónomo no VS Code e JetBrains: plano, alterações e comandos.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/cline/)

#### Onde configurar

Painel Cline → roda dentada (Settings) → API Provider = «OpenAI Compatible» → campos Base URL, API Key, Model ID. Segunda opção: API Provider = «Anthropic» → selecionar «Use custom base URL».

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
OpenAI Compatible (recomendado):
  API Provider: OpenAI Compatible
  Base URL:     https://api.ailoot.ai/v1
  API Key:      sk-...
  Model ID:     claude-sonnet-5-5   (ou gpt-6.1-sol, deepseek-v4-pro, qwen3.8-max)
  Model Configuration: Context Window e Max Output Tokens — conforme o modelo; Image Support — apenas para modelos que compreendem imagens.

Anthropic (Messages):
  API Provider:      Anthropic
  Anthropic API Key: sk-...
  [x] Use custom base URL → https://api.ailoot.ai
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

OpenAI Compatible utiliza /v1/chat/completions, pelo que o endereço inclui /v1. A opção Anthropic utiliza /v1/messages, com endereço sem /v1, mas a respetiva lista só contém nomes de modelos Anthropic — os outros modelos Ailoot estão disponíveis através de OpenAI Compatible. O modo de agente exige um modelo com chamadas de ferramentas. Os modelos Gemini 3.1 Pro não estão disponíveis através de chat/completions (só suportam os formatos Gemini e Anthropic) — aqui, utilize gemini-3.6-flash.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/cline/)[Documentação da aplicação ↗](https://docs.cline.bot/provider-config/openai-compatible)

RC

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

Extensão do editor

OpenAI ChatAnthropic Messages

Agente no VS Code com modos de código, arquitetura e depuração.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/roo-code/)

#### Onde configurar

Painel Roo Code → roda dentada → API Provider = «OpenAI Compatible» → Base URL, API Key, Model; opcionalmente, Model Configuration (Max Output Tokens, Context Window, Image Support, Computer Use, preços). O fornecedor Anthropic tem a opção «Use custom base URL».

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
API Provider: OpenAI Compatible
Base URL:     https://api.ailoot.ai/v1
API Key:      sk-...
Model:        gpt-6.1-sol   (ou claude-sonnet-5-5, kimi-k3, glm-5.3)

Alternativa através de Anthropic:
API Provider: Anthropic, API key sk-..., [x] Use custom base URL → https://api.ailoot.ai
```

Exemplo de modelo: `gpt-6.1-sol`

#### Importante

O Roo Code chama ferramentas apenas no formato OpenAI, pelo que o modelo tem de suportar tools em /v1/chat/completions. A opção Anthropic utiliza /v1/messages, com endereço sem /v1.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/roo-code/)[Documentação da aplicação ↗](https://roocodeinc.github.io/Roo-Code/providers/openai-compatible/)

KC

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

Extensão do editor

OpenAI Chat

Agente no VS Code com modos e modelos personalizados.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/kilo-code/)

#### Onde configurar

Settings (roda dentada) → separador Providers → «Custom provider» em baixo → Provider ID, Display name, Provider API = «OpenAI Compatible», Base URL, API key, Models (a lista é carregada de /v1/models). As definições são guardadas em kilo.json.

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Provider ID:   ailoot
Display name:  Ailoot
Provider API:  OpenAI Compatible
Base URL:      https://api.ailoot.ai/v1
API key:       sk-...
Models:        selecione na lista, por exemplo, claude-sonnet-5-5, gpt-6.1-sol, deepseek-v4-pro
```

Exemplo de modelo: `deepseek-v4-pro`

#### Importante

O Kilo consulta {Base URL}/models e apresenta automaticamente a lista de modelos — o nosso GET /v1/models devolve o catálogo completo. Também pode indicar o endereço completo .../v1/chat/completions. São suportados cabeçalhos personalizados.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/kilo-code/)[Documentação da aplicação ↗](https://kilo.ai/docs/ai-providers/openai-compatible)

Co

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

Extensão do editor

OpenAI Chat

Assistente para VS Code e JetBrains: chat, alterações e agente.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/continue/)

#### Onde configurar

Ficheiro ~/.continue/config.yaml (ou editor de configuração do Continue): entrada em models\[\] com provider: openai e apiBase.

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
name: Ailoot
version: 0.0.1
schema: v1
models:
  - name: Ailoot Claude Sonnet 5.5
    provider: openai
    model: claude-sonnet-5-5
    apiBase: https://api.ailoot.ai/v1
    apiKey: sk-...
  - name: Ailoot GPT-6.1 Sol
    provider: openai
    model: gpt-6.1-sol
    apiBase: https://api.ailoot.ai/v1
    apiKey: sk-...
    # useResponsesApi: false   # apenas se for necessário forçar o uso de /chat/completions
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

apiBase tem de terminar em /v1. Para nomes do tipo gpt-5/série o, o Continue pode selecionar automaticamente /v1/responses; os nossos gpt-\* suportam /v1/responses e /v1/chat/completions, e useResponsesApi: false força a utilização de chat/completions. Não é necessário useLegacyCompletionsEndpoint.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/continue/)[Documentação da aplicação ↗](https://docs.continue.dev/customize/model-providers/top-level/openai)

Ze

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

Editor de código

OpenAI ChatOpenAI ResponsesAnthropic Messages

Editor de código rápido com agente incorporado.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/zed/)

#### Onde configurar

Agent Settings (agent::OpenSettings) → LLM Providers → Add Provider; ou settings.json → language\_models.openai\_compatible / language\_models.anthropic\_compatible. Chave — na janela de definições (guardada no porta-chaves do sistema) ou na variável \<ID DO FORNECEDOR EM MAIÚSCULAS\>\_API\_KEY.

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```json
{
  "language_models": {
    "openai_compatible": {
      "ailoot": {
        "api_url": "https://api.ailoot.ai/v1",
        "available_models": [
          {
            "name": "gpt-6.1-sol",
            "display_name": "GPT-6.1 Sol (Ailoot)",
            "max_tokens": 272000,
            "capabilities": {
              "tools": true,
              "images": false,
              "chat_completions": true
            }
          },
          {
            "name": "deepseek-v4-pro",
            "display_name": "DeepSeek V4 Pro (Ailoot)",
            "max_tokens": 128000
          }
        ]
      }
    },
    "anthropic_compatible": {
      "ailoot-claude": {
        "api_url": "https://api.ailoot.ai",
        "available_models": [
          {
            "name": "claude-sonnet-5-5",
            "display_name": "Claude Sonnet 5.5 (Ailoot)",
            "max_tokens": 200000,
            "capabilities": {
              "tools": true,
              "images": false,
              "prompt_caching": false
            }
          }
        ]
      }
    }
  }
}
```

```bash
export AILOOT_API_KEY="sk-..."
export AILOOT_CLAUDE_API_KEY="$AILOOT_API_KEY"
```

Exemplo de modelo: `gpt-6.1-sol`

#### Importante

Em openai\_compatible, o endereço inclui /v1 (utiliza /v1/chat/completions; capabilities.chat\_completions = false muda o modelo para /v1/responses). Em anthropic\_compatible, o endereço não inclui /v1 (utiliza /v1/messages; o Zed envia a chave em x-api-key — aceite pelo Ailoot). Por predefinição, images = false e parallel\_tool\_calls = false. O Zed pode transmitir imagens, mas ative images apenas para um modelo específico cuja ficha atual no catálogo indique entrada image no formato de API escolhido. Nos exemplos de GPT e Claude, images = false: o catálogo de 2026-09-30 anuncia apenas texto para estes modelos. Por exemplo, gemini-3.6-flash anuncia entrada image para OpenAI Chat neste catálogo; o suporte efetivo depende da ficha e do formato do modelo. Para modelos de raciocínio, existe o campo reasoning\_effort. Os valores de max\_tokens no exemplo correspondem ao tamanho do contexto; consulte os limites exatos no catálogo de modelos.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/zed/)[Documentação da aplicação ↗](https://zed.dev/docs/ai/use-api-access)

VC

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

Extensão do editor

OpenAI ChatOpenAI ResponsesAnthropic Messages

Fornecedor personalizado no Copilot Chat para VS Code.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/vscode-copilot-byok/)

#### Onde configurar

Seleção do modelo no chat → Manage Language Models (roda dentada) → Add Models → Custom Endpoint → o VS Code abre chatLanguageModels.json. (A definição antiga github.copilot.chat.customOAIModels está obsoleta.)

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```json
[
  {
    "name": "Ailoot",
    "vendor": "customendpoint",
    "apiKey": "${input:ailootApiKey}",
    "apiType": "chat-completions",
    "models": [
      {
        "id": "gpt-6.1-sol",
        "name": "GPT-6.1 Sol (Ailoot)",
        "url": "https://api.ailoot.ai/v1/chat/completions",
        "toolCalling": true,
        "vision": false,
        "maxInputTokens": 200000,
        "maxOutputTokens": 32000
      }
    ]
  },
  {
    "name": "Ailoot Claude",
    "vendor": "customendpoint",
    "apiKey": "${input:ailootApiKey}",
    "apiType": "messages",
    "models": [
      {
        "id": "claude-sonnet-5-5",
        "name": "Claude Sonnet 5.5 (Ailoot)",
        "url": "https://api.ailoot.ai/v1/messages",
        "toolCalling": true,
        "vision": false,
        "maxInputTokens": 200000,
        "maxOutputTokens": 32000
      }
    ]
  }
]
```

Exemplo de modelo: `gpt-6.1-sol`

#### Importante

url é o caminho COMPLETO do endpoint. Valores de apiType: chat-completions, responses (url .../v1/responses), messages (url .../v1/messages). BYOK funciona sem plano Copilot nem início de sessão no GitHub, mas apenas para chat/agente — as sugestões inline continuam no Copilot. Os administradores da organização (Business/Enterprise) podem desativar a política BYOK. Os limites de tokens acima são exemplos; utilize os valores do catálogo. Nestes exemplos, vision = false: o catálogo de 2026-09-30 anuncia apenas texto para GPT/OpenAI Chat e Claude/Anthropic Messages. Se a sua versão do VS Code oferecer vision, ative-o apenas para um modelo cuja ficha atual no catálogo indique entrada image no formato de API escolhido; a existência do campo no cliente não confirma suporte de imagens pelo modelo escolhido.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/vscode-copilot-byok/)[Documentação da aplicação ↗](https://code.visualstudio.com/docs/agent-customization/language-models)

JA

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

Editor de código

OpenAI Chat

Assistente incorporado nas IDE JetBrains com chave própria.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/jetbrains-ai-assistant/)

#### Onde configurar

Settings | Tools | AI Assistant | Providers & API keys → Third-party AI providers → OpenAI-compatible → URL, API Key → Test Connection → Apply → AI Chat / Models Assignment

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Provider: OpenAI-compatible
URL: https://api.ailoot.ai/v1
API Key: sk-...
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

Selecione OpenAI-compatible, indique https://api.ailoot.ai/v1 em URL e introduza a sua API Key. Clique em Test Connection e depois em Apply; escolha um modelo no AI Chat. Atribua-o às funções do IDE em Models Assignment. Ative Tool calling apenas se o modelo suportar ferramentas; o preenchimento de código configura-se separadamente.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/jetbrains-ai-assistant/)[Documentação da aplicação ↗](https://www.jetbrains.com/help/ai-assistant/use-custom-models.html)

Xc

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

Editor de código

OpenAI Chat

Coding Intelligence no Xcode com fornecedor externo.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/xcode/)

#### Onde configurar

Xcode → Settings → Intelligence → Chat → Add a Chat Provider → Internet Hosted → URL, API Key, API Key Header, descrição → Add.

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Type:           Internet Hosted
URL:            https://api.ailoot.ai        (SEM /v1 — o Xcode acrescenta /v1/models e /v1/chat/completions automaticamente)
API Key:        sk-...
API Key Header: x-api-key
Description:    Ailoot
→ depois, selecione os modelos na lista (por exemplo, claude-sonnet-5-5, gpt-6.1-sol)
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

A Apple exige que o fornecedor suporte Chat Completions e responda em {URL}/v1/models e {URL}/v1/chat/completions. O Ailoot aceita a chave em x-api-key e Authorization: Bearer (segundo relatos, se selecionar o cabeçalho Authorization, o Xcode acrescenta automaticamente o prefixo Bearer). Os agentes Xcode são configurados separadamente e não estão abrangidos por estas instruções.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/xcode/)[Documentação da aplicação ↗](https://developer.apple.com/documentation/xcode/setting-up-coding-intelligence)

AN

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

Plugin Neovim

OpenAI ChatAnthropic Messages

Plugin Neovim: chat e alterações diretamente no buffer.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/avante-nvim/)

#### Onde configurar

opts de yetone/avante.nvim em lazy.nvim: opts.providers.\<nome\> com \_\_inherited\_from = 'openai' (fornecedor personalizado compatível com OpenAI) ou substituição de providers.claude.endpoint; a chave vem da variável indicada em api\_key\_name (são suportados nomes AVANTE\_\*).

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```lua
opts = {
  provider = "ailoot",
  providers = {
    ailoot = {
      __inherited_from = "openai",
      endpoint = "https://api.ailoot.ai/v1",
      api_key_name = "AILOOT_API_KEY",
      model = "claude-sonnet-5-5",
    },
    claude = {
      endpoint = "https://api.ailoot.ai",   -- Anthropic Messages, sem /v1
      model = "claude-sonnet-5-5",
    },
  },
}
-- no terminal: export AILOOT_API_KEY=sk-...
-- o fornecedor claude lê AVANTE_ANTHROPIC_API_KEY ou ANTHROPIC_API_KEY
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

Na wiki do plugin, o endereço compatível com OpenAI termina em /v1 (o plugin acrescenta /chat/completions). O fornecedor claude incorporado utiliza um endereço como https://api.anthropic.com, pelo que, para o Ailoot, o endereço não deve incluir /v1. Os fornecedores personalizados sem \_\_inherited\_from exigem o endereço completo e funções próprias para processar a resposta.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/avante-nvim/)[Documentação da aplicação ↗](https://github.com/avante-corp/avante.nvim/wiki/Custom-providers)

CN

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

Plugin Neovim

OpenAI ChatAnthropic Messages

Chat e alterações integradas no Neovim.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/codecompanion-nvim/)

#### Onde configurar

require('codecompanion').setup({ adapters = { http = { ... } } }) através de adapters.extend('openai\_compatible', ...) ou extend('anthropic', ...); depois, interactions.chat/inline.adapter.

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```lua
require("codecompanion").setup({
  adapters = {
    http = {
      ailoot = function()
        return require("codecompanion.adapters").extend("openai_compatible", {
          env = {
            url = "https://api.ailoot.ai",
            api_key = "AILOOT_API_KEY",        -- nome da variável de ambiente que contém sk-...
            chat_url = "/v1/chat/completions",
          },
          schema = { model = { default = "gpt-6.1-sol" } },
        })
      end,
    },
  },
  interactions = {
    chat = { adapter = "ailoot" },
    inline = { adapter = "ailoot" },
  },
})
```

A chave é lida da variável `AILOOT_API_KEY` — defina-a antes de iniciar:

```bash
export AILOOT_API_KEY="sk-..."   # adicione a ~/.zshrc ou ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # depois reinicie o terminal
```

Exemplo de modelo: `gpt-6.1-sol`

#### Importante

openai\_compatible separa o host (env.url, sem /v1) do caminho (env.chat\_url). Os valores de env podem ser o nome de uma variável de ambiente, cmd:..., file:... ou uma função Lua. O adaptador anthropic pode ser igualmente estendido com um url personalizado para /v1/messages.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/codecompanion-nvim/)[Documentação da aplicação ↗](https://codecompanion.olimorris.dev/configuration/adapters-http)

Gp

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

Pacote Emacs

OpenAI ChatAnthropic MessagesGemini

Cliente simples de modelos de linguagem para Emacs.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/gptel/)

#### Onde configurar

init.el: registe um backend através de gptel-make-openai (OpenAI Chat), gptel-make-anthropic (Messages) ou gptel-make-gemini — cada um tem :host, :endpoint, :key, :stream, :models; depois, defina gptel-backend e gptel-model.

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```lisp
(setq gptel-model 'claude-sonnet-5-5
      gptel-backend
      (gptel-make-openai "Ailoot"
        :host "api.ailoot.ai"
        :endpoint "/v1/chat/completions"
        :stream t
        :key (getenv "AILOOT_API_KEY")               ; ou (gptel-api-key-from-environment "AILOOT_API_KEY")
        :models '(claude-sonnet-5-5 gpt-6.1-sol deepseek-v4-pro qwen3.8-max)))

;; alternativa Anthropic Messages
(gptel-make-anthropic "Ailoot-Claude"
  :host "api.ailoot.ai"          ; caminho predefinido /v1/messages
  :stream t
  :key (getenv "AILOOT_API_KEY")
  :models '(claude-sonnet-5-5 claude-opus-5-5))
```

A chave é lida da variável `AILOOT_API_KEY` — defina-a antes de iniciar:

```bash
export AILOOT_API_KEY="sk-..."   # adicione a ~/.zshrc ou ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # depois reinicie o terminal
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

:host — apenas o nome do host (sem https:// nem caminho); o caminho é definido em :endpoint. gptel-make-anthropic envia os cabeçalhos x-api-key e anthropic-version — aceites pelo Ailoot.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/gptel/)[Documentação da aplicação ↗](https://github.com/karthink/gptel)

TI

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

Editor de código

OpenAI Chat

IDE de código aberto com módulo Theia AI.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/theia/)

#### Onde configurar

Preferences → AI-features → OpenAiCustom (ou a chave ai-features.openAiCustom.customOpenAiModels em settings.json; janela AI Configuration — Alt+A).

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```json
{
  "ai-features.openAiCustom.customOpenAiModels": [
    {
      "model": "claude-sonnet-5-5",
      "url": "https://api.ailoot.ai/v1",
      "id": "ailoot-claude-sonnet-5-5",
      "apiKey": "sk-...",
      "developerMessageSettings": "system"
    }
  ]
}
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

url — endereço de base que termina em /v1. Para modelos que não sejam OpenAI, a escolha segura é developerMessageSettings: "system".

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/theia/)[Documentação da aplicação ↗](https://theia-ide.org/docs/user_ai/)

TI

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

Editor de código

OpenAI ChatAnthropic Messages

Editor de código Trae com modelos personalizados.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/trae/)

#### Onde configurar

Settings → Models → Add Model → Custom Model → API Format, Request URL (interruptor Full URL), Model ID, Display Name, API Key; opcionalmente, Advanced Settings.

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Formato OpenAI:
  API Format:  OpenAI Chat Completions
  Full URL:    OFF
  Request URL: https://api.ailoot.ai/v1
  Model ID:    gpt-6.1-sol
  API Key:     sk-...

Formato Anthropic:
  API Format:  Anthropic Messages
  Full URL:    OFF
  Request URL: https://api.ailoot.ai
  Model ID:    claude-sonnet-5-5
  API Key:     sk-...
```

Exemplo de modelo: `gpt-6.1-sol`

#### Importante

Com Full URL desativado, o Trae acrescenta automaticamente o caminho do formato escolhido (para OpenAI — endereço com /v1; para Anthropic — sem /v1). Com Full URL ativado, introduza https://api.ailoot.ai/v1/chat/completions ou https://api.ailoot.ai/v1/messages. O campo Model Series adapta as sugestões à família do modelo.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/trae/)[Documentação da aplicação ↗](https://docs.trae.ai/ide/models)

## Aplicações de chat

Chats para computador, telemóvel e navegador, notas e lançadores de aplicações.

OW

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

Chat web, servidor próprio

OpenAI Chat

Chat web popular num servidor próprio.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/open-webui/)

#### Onde configurar

Settings \> Admin \> Connections \> Manage OpenAI API Connections \> + Add Connection (ou env OPENAI\_API\_BASE\_URL / OPENAI\_API\_KEY ao iniciar o contentor)

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
UI: URL = https://api.ailoot.ai/v1
API Key = sk-...
Model IDs: deixar em branco (serão obtidos de /v1/models) ou adicionar manualmente claude-sonnet-5-5, gpt-6.1-sol

Docker env:
OPENAI_API_BASE_URL=https://api.ailoot.ai/v1
OPENAI_API_KEY=sk-...
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

Formato OpenAI Chat Completions; o URL tem obrigatoriamente de incluir /v1, sem barra final. A lista de modelos é obtida de /v1/models; num catálogo grande (252 modelos), é mais cómodo limitar Model IDs e ativar a cache da lista de modelos (Cache Base Model List / ENABLE\_BASE\_MODELS\_CACHE=True). Para embeddings RAG, existe um RAG\_OPENAI\_API\_BASE\_URL separado.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/open-webui/)[Documentação da aplicação ↗](https://docs.openwebui.com/getting-started/quick-start/connect-a-provider/starting-with-openai-compatible/)

Li

### [LibreChat](https://ailoot.ai/docs/pt-pt/integrations/librechat/)

Chat web, servidor próprio

OpenAI ChatAnthropic Messages

Chat web num servidor próprio com agentes e vários fornecedores.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/librechat/)

#### Onde configurar

Ficheiro librechat.yaml → endpoints.custom (chave em .env através de ${VAR}); para o formato Anthropic, campo provider: 'anthropic'

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```yaml
endpoints:
  custom:
    - name: 'Ailoot'
      apiKey: '${AILOOT_API_KEY}'
      baseURL: 'https://api.ailoot.ai/v1'
      models:
        default: ['gpt-6.1-sol', 'claude-sonnet-5-5', 'deepseek-v4-pro']
        fetch: true
      titleConvo: true
      titleModel: 'gpt-6.1-sol'
      modelDisplayLabel: 'Ailoot'
    - name: 'Ailoot Claude'
      provider: 'anthropic'
      apiKey: '${AILOOT_API_KEY}'
      baseURL: 'https://api.ailoot.ai'
      models:
        default: ['claude-sonnet-5-5']
        fetch: false
# .env: AILOOT_API_KEY=sk-...
```

Exemplo de modelo: `gpt-6.1-sol`

#### Importante

Um custom endpoint normal = OpenAI Chat Completions (baseURL com /v1). provider: 'anthropic' ativa o cliente nativo /v1/messages; no exemplo da documentação, baseURL de Anthropic não inclui /v1 (https://api.anthropic.com), pelo que, no nosso caso, é https://api.ailoot.ai. fetch: true obtém a lista de /v1/models.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/librechat/)[Documentação da aplicação ↗](https://www.librechat.ai/docs/configuration/librechat_yaml/object_structure/custom_endpoint)

CS

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

Aplicação para computador

OpenAI ChatOpenAI ResponsesAnthropic Messages

Cliente para computador com assistentes e base de conhecimento.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/cherry-studio/)

#### Onde configurar

Settings (roda dentada) \> Model Provider \> + Add Provider \> tipo de protocolo OpenAI / OpenAI Responses / Anthropic / Gemini

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Provider Name: Ailoot
Tipo: OpenAI (ou OpenAI Responses / Anthropic)
API Key: sk-...
Base URL: https://api.ailoot.ai
→ Verifique a pré-visualização do endereço final por baixo do campo: deve ser https://api.ailoot.ai/v1/chat/completions (para Anthropic — https://api.ailoot.ai/v1/messages)
Models: + claude-sonnet-5-5, gpt-6.1-sol
Depois, botão Model Check
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

A documentação confirma os protocolos OpenAI, Anthropic, OpenAI Responses e Gemini e a pré-visualização do caminho final abaixo do campo, mas não descreve as regras de adição de /v1 — guie-se pela pré-visualização. Os três formatos do Ailoot (Chat Completions, Responses, Messages) são adequados.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/cherry-studio/)[Documentação da aplicação ↗](https://cherryai.com/docs/en/pre-basic/providers/zi-ding-yi-fu-wu-shang/)

Ch

### [Chatbox](https://ailoot.ai/docs/pt-pt/integrations/chatbox/)

Computador e telemóvel

OpenAI Chat

Chat para computador e telemóvel.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/chatbox/)

#### Onde configurar

Definições (botão na barra lateral) \> Model Provider \> Add (em baixo) \> tipo OpenAI API Compatible

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Name: Ailoot
API Mode: OpenAI API Compatible
API Key: sk-...
API Host: https://api.ailoot.ai
API Path: (deixar em branco; por predefinição, /v1/chat/completions)
Models: + gpt-6.1-sol, claude-sonnet-5-5 (vision desativado nestes exemplos; tool_use — conforme as capacidades do modelo escolhido)
```

Exemplo de modelo: `gpt-6.1-sol`

#### Importante

A documentação indica API Host sem /v1 (exemplo https://api.openai.com), com o caminho predefinido /v1/chat/completions. Também existe o tipo Google Gemini compatible, mas ainda não foi verificado para o nosso /v1beta. A importação de configuração JSON (type: 'openai', apiHost, apiPath) está disponível desde 1.15.1 através de chatbox://provider/import?config=\<base64\>. Nos exemplos de GPT e Claude apresentados, vision está desativado: o catálogo de 2026-09-30 anuncia apenas texto no formato OpenAI Chat. Se a sua versão do Chatbox oferecer vision, ative-o apenas para um modelo cuja ficha atual no catálogo indique entrada image no formato de API escolhido; a possibilidade de anexar uma imagem no cliente não comprova que o modelo a suporta.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/chatbox/)[Documentação da aplicação ↗](https://docs.chatboxai.app/en/guides/providers)

Lo

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

Chat web, servidor próprio

OpenAI ChatAnthropic Messages

Chat moderno com plugins e base de conhecimento.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/lobechat/)

#### Onde configurar

Self-host: variáveis de ambiente OPENAI\_PROXY\_URL / OPENAI\_API\_KEY / OPENAI\_MODEL\_LIST, ANTHROPIC\_PROXY\_URL, GOOGLE\_PROXY\_URL

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```bash
OPENAI_API_KEY=sk-...
OPENAI_PROXY_URL=https://api.ailoot.ai/v1
OPENAI_MODEL_LIST=-all,+gpt-6.1-sol,+claude-sonnet-5-5,+deepseek-v4-pro

# formato Anthropic (opcional)
ANTHROPIC_API_KEY=sk-...
ANTHROPIC_PROXY_URL=https://api.ailoot.ai
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

OPENAI\_PROXY\_URL tem o valor predefinido https://api.openai.com/v1, pelo que deve incluir /v1. ANTHROPIC\_PROXY\_URL tem o valor predefinido https://api.anthropic.com (sem /v1). GOOGLE\_PROXY\_URL permite, em princípio, ligar o formato Gemini (https://api.ailoot.ai), mas ainda não verificámos esta opção. Utilize o modo de servidor: se os pedidos forem enviados diretamente pelo navegador, a API Ailoot pode ainda rejeitá-los pelas regras CORS.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/lobechat/)[Documentação da aplicação ↗](https://lobehub.com/docs/self-hosting/environment-variables/model-provider)

Ja

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

Aplicação para computador

OpenAI ChatAnthropic Messages

Chat de código aberto para computador com modelos locais e na nuvem.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/jan/)

#### Onde configurar

Settings \> Model Providers \> Add Provider → selecionar o formato OpenAI-compatible ou Anthropic-compatible

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
OpenAI-compatible:
  Provider name: Ailoot
  Base URL: https://api.ailoot.ai/v1
  API key: sk-...
Anthropic-compatible:
  Provider name: Ailoot Claude
  Base URL: https://api.ailoot.ai
  API key: sk-...
Models: serão obtidos de {base_url}/models ou + manualmente: claude-sonnet-5-5
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

Documentação: para fornecedores compatíveis com OpenAI, Base URL tem de incluir /v1 (caso contrário, ocorre 404); a barra final é removida. Para o modo Anthropic, o exemplo LiteLLM não inclui /v1. As capacidades do modelo (tools, vision) para fornecedores personalizados são definidas manualmente. Suporta chaves de reserva (nova tentativa apenas para 401/403/429).

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/jan/)[Documentação da aplicação ↗](https://www.jan.ai/docs/desktop/remote-models/custom-endpoint)

Si

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

Chat de interpretação de papéis

OpenAI Chat

Interface para chats de interpretação de papéis e personagens.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/sillytavern/)

#### Onde configurar

API Connections \> API: Chat Completion \> Chat Completion Source: Custom (OpenAI-compatible)

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Custom Endpoint (Base URL): https://api.ailoot.ai/v1
Custom API Key: sk-...
Model: selecionar na lista (/v1/models) ou introduzir claude-sonnet-5-5
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

Documentação: em caso de problemas de ligação, acrescente /v1 e NÃO acrescente /chat/completions. A lista de modelos é carregada se o servidor disponibilizar /v1/models (o Ailoot disponibiliza).

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/sillytavern/)[Documentação da aplicação ↗](https://docs.sillytavern.app/usage/api-connections/openai/)

An

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

Chat com documentos

OpenAI Chat

Chat com os seus documentos no computador ou servidor.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/anythingllm/)

#### Onde configurar

Settings \> AI Providers \> LLM \> Generic OpenAI (Docker: env LLM\_PROVIDER='generic-openai')

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
UI: Base URL = https://api.ailoot.ai/v1
API Key = sk-...
Chat Model Name = deepseek-v4-pro
Token context window = conforme o modelo

Docker .env:
LLM_PROVIDER='generic-openai'
GENERIC_OPEN_AI_BASE_PATH='https://api.ailoot.ai/v1'
GENERIC_OPEN_AI_MODEL_PREF='deepseek-v4-pro'
GENERIC_OPEN_AI_MODEL_TOKEN_LIMIT=128000
GENERIC_OPEN_AI_API_KEY='sk-...'
```

Exemplo de modelo: `deepseek-v4-pro`

#### Importante

A documentação assinala o fornecedor como «para programadores». Se necessário, utilize GENERIC\_OPEN\_AI\_MODEL\_MAX\_TOKEN\_KEY='max\_completion\_tokens'. Para embeddings, existe um embedder generic-openai separado (EMBEDDING\_BASE\_PATH + GENERIC\_OPEN\_AI\_EMBEDDING\_API\_KEY) — modelo nemotron-3-embed através de /v1/embeddings.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/anythingllm/)[Documentação da aplicação ↗](https://docs.anythingllm.com/setup/llm-configuration/cloud/openai-generic)

BA

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

Chat web, servidor próprio

OpenAI ChatAnthropic Messages

Interface web avançada para trabalhar com vários modelos.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/big-agi/)

#### Onde configurar

Env na implementação: OPENAI\_API\_KEY / OPENAI\_API\_HOST, ANTHROPIC\_API\_KEY / ANTHROPIC\_API\_HOST; na interface — Models \> Add OpenAI-compatible

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```bash
OPENAI_API_KEY=sk-...
OPENAI_API_HOST=https://api.ailoot.ai
ANTHROPIC_API_KEY=sk-...
ANTHROPIC_API_HOST=https://api.ailoot.ai
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

A documentação descreve as variáveis como substituições do backend host de OpenAI e Anthropic (para proxies e endpoints personalizados); utiliza o termo «host», pelo que indicamos o endereço sem /v1, mas não especifica o formato exato do caminho — confirme-o no primeiro pedido.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/big-agi/)[Documentação da aplicação ↗](https://github.com/enricoros/big-AGI/blob/main/docs/environment-variables.md)

Bo

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

Aplicação para Mac

OpenAI Chat

Cliente de IA nativo para macOS.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/boltai/)

#### Onde configurar

Settings \> Models \> (+) \> OpenAI-compatible Server

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Friendly name: Ailoot
API Endpoint URL: https://api.ailoot.ai/v1/chat/completions
API Key: sk-...
Model ID: gpt-6.1-sol
Context length: conforme o modelo
Streaming: ativar
```

Exemplo de modelo: `gpt-6.1-sol`

#### Importante

É necessário o endereço completo de chat completions. Para o utilizar com AI Command, torne este serviço o principal. Instruções baseadas na ajuda do BoltAI; as janelas podem ser diferentes no BoltAI 2.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/boltai/)[Documentação da aplicação ↗](https://boltai.com/help/how-to-setup-custom-openai-server)

HF

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

Chat web, servidor próprio

OpenAI Chat

Chat web de código aberto Hugging Face num servidor próprio.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/hugging-face-chat-ui/)

#### Onde configurar

Ficheiro .env.local (OPENAI\_BASE\_URL, OPENAI\_API\_KEY)

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```bash
OPENAI_BASE_URL=https://api.ailoot.ai/v1
OPENAI_API_KEY=sk-...
```

Exemplo de modelo: `deepseek-v4-pro`

#### Importante

O Chat UI funciona apenas com API compatíveis com OpenAI através de OPENAI\_BASE\_URL e obtém a lista de modelos de /models.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/hugging-face-chat-ui/)[Documentação da aplicação ↗](https://github.com/huggingface/chat-ui)

MS

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

Aplicação para computador

OpenAI Chat

Chat para computador com modelos locais e na nuvem.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/msty-studio/)

#### Onde configurar

Model Hub \> Model Providers \> Add Provider \> OpenAI-compatible

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Provider: OpenAI Compatible
Name: Ailoot
API Endpoint: https://api.ailoot.ai/v1
API Key: sk-...
Models: gpt-6.1-sol, claude-sonnet-5-5
```

Exemplo de modelo: `gpt-6.1-sol`

#### Importante

A documentação confirma um fornecedor personalizado compatível com OpenAI, mas não indica o formato do endereço; /v1 é a raiz padrão da API OpenAI; em caso de erro 404, verifique a opção sem /v1. A documentação não descreve um endpoint personalizado compatível com Anthropic.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/msty-studio/)[Documentação da aplicação ↗](https://docs.msty.ai/studio/managing-models/online-providers)

Ne

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

Chat web, servidor próprio

OpenAI Chat

Chat web leve, de implementação rápida.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/nextchat/)

#### Onde configurar

Vercel / Docker: BASE\_URL, OPENAI\_API\_KEY, CUSTOM\_MODELS, DEFAULT\_MODEL

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```bash
OPENAI_API_KEY=sk-...
BASE_URL=https://api.ailoot.ai
CUSTOM_MODELS=-all,+gpt-6.1-sol,+claude-sonnet-5-5,+deepseek-v4-pro
DEFAULT_MODEL=gpt-6.1-sol
```

Exemplo de modelo: `gpt-6.1-sol`

#### Importante

Para esta configuração, utilize OpenAI Chat através do servidor NextChat. Ao implementar no Vercel ou no Docker, defina BASE\_URL=https://api.ailoot.ai sem /v1, OPENAI\_API\_KEY, CUSTOM\_MODELS e DEFAULT\_MODEL. Volte a implementar o servidor depois de alterar estas variáveis.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/nextchat/)[Documentação da aplicação ↗](https://github.com/ChatGPTNextWeb/NextChat#environment-variables)

OC

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

Plugin Obsidian

OpenAI Chat

Chat com notas Obsidian.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/obsidian-copilot/)

#### Onde configurar

Settings \> Copilot \> BYOK \> Add a provider \> Add a custom provider

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Base URL: https://api.ailoot.ai/v1
API key: sk-...
Model ID: claude-sonnet-5-5 (ou selecionar na lista /v1/models)
Depois, Test; ativar o modelo em Basic > Agents > Quick Chat
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

A lista de modelos é obtida de /v1/models; também pode introduzir o modelo manualmente. Se Test passar, mas Quick Chat não enviar mensagens, ative Enable CORS no fornecedor (a resposta chega integralmente, sem fluxo). As chaves são guardadas no Obsidian Keychain.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/obsidian-copilot/)[Documentação da aplicação ↗](https://github.com/logancyang/obsidian-copilot/blob/master/docs/llm-providers.md)

PA

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

Extensão do navegador

OpenAI Chat

Extensão do navegador: chat com a página aberta.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/page-assist/)

#### Onde configurar

Ícone Page Assist \> Settings \> OpenAI Compatible API \> Add Provider \> Custom

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Provider: Custom
Name: Ailoot
Base URL: https://api.ailoot.ai/v1
API Key: sk-...
Depois, adicione os modelos manualmente: gpt-6.1-sol, claude-sonnet-5-5
```

Exemplo de modelo: `gpt-6.1-sol`

#### Importante

A documentação confirma Custom com API URL e chave; não especifica o formato do URL, sendo /v1 a raiz padrão da API OpenAI. O carregamento automático de modelos só é garantido para Ollama, LM Studio e Llamafile — nos restantes, os modelos são adicionados manualmente.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/page-assist/)[Documentação da aplicação ↗](https://docs.pageassist.xyz/providers/openai)

RA

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

Lançador de aplicações

OpenAI Chat

IA no lançador Raycast: comandos rápidos e chat.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/raycast-ai/)

#### Onde configurar

Settings \> AI \> Models & Providers \> Custom Providers \> Reveal Providers Config → ficheiro ~/.config/raycast/ai/providers.yaml

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```yaml
providers:
  - id: ailoot
    name: Ailoot
    base_url: https://api.ailoot.ai/v1
    api_keys:
      ailoot: sk-...
    models:
      - id: claude-sonnet-5-5
        name: Claude Sonnet 5.5
        provider: ailoot
        context: 200000
        abilities:
          temperature:
            supported: true
          vision:
            supported: false
          system_message:
            supported: true
          tools:
            supported: true
      - id: gpt-6.1-sol
        name: GPT-6.1 Sol
        provider: ailoot
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

base\_url — endpoint compatível com OpenAI sem o sufixo /chat/completions. O Raycast relê o ficheiro sem reiniciar. Se abilities não estiver definido, considera que tools e vision não são suportados. Os modelos aparecem em Quick AI, AI Chat e AI Commands. Neste exemplo, vision.supported = false: o catálogo de 2026-09-30 anuncia apenas texto para Claude/OpenAI Chat. Se a sua versão do Raycast suportar esta definição, ative vision apenas para um modelo cuja ficha atual no catálogo indique entrada image no formato OpenAI Chat; a opção do cliente, por si só, não confirma suporte de imagens pela API.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/raycast-ai/)[Documentação da aplicação ↗](https://manual.raycast.com/ai/custom-providers)

Ty

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

Aplicação web

OpenAI Chat

Interface de chat prática no navegador e no computador.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/typingmind/)

#### Onde configurar

Models (barra lateral esquerda) \> + Add Custom Model

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Name: Claude Sonnet 5.5 (Ailoot)
API Type: OpenAI Chat Completions
Endpoint: https://api.ailoot.ai/v1/chat/completions
Model ID: claude-sonnet-5-5
Custom Headers: Authorization = Bearer sk-...
Context Length: conforme o modelo
Test → Save
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

Endpoint é introduzido com o caminho completo. A chave é transmitida num cabeçalho personalizado Authorization: Bearer sk-... — aceite pelo Ailoot. A versão web do TypingMind acede à API diretamente a partir do navegador, e CORS pode atualmente bloquear esses pedidos; a versão para computador é mais fiável. O tipo Gemini no TypingMind envia a chave no cabeçalho apiKey, que o Ailoot não aceita — utilize o tipo OpenAI Chat Completions.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/typingmind/)[Documentação da aplicação ↗](https://docs.typingmind.com/manage-and-connect-ai-models/ollama)

## SDK e frameworks

Bibliotecas para aplicações, agentes e RAG próprios.

OS

### [OpenAI SDK (Python)](https://ailoot.ai/docs/pt-pt/integrations/openai-python-sdk/)

SDK

OpenAI ChatOpenAI Responses

Biblioteca oficial OpenAI para Python.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/openai-python-sdk/)

#### Onde configurar

Parâmetro do construtor OpenAI(base\_url=..., api\_key=...) ou variáveis de ambiente OPENAI\_BASE\_URL e OPENAI\_API\_KEY

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```bash
export AILOOT_API_KEY="sk-..."
# variáveis de ambiente
export OPENAI_BASE_URL="https://api.ailoot.ai/v1"
export OPENAI_API_KEY="$AILOOT_API_KEY"

# ou no código
```

`ailoot-openai-python-sdk.py`

```python
import os
from openai import OpenAI
client = OpenAI(max_retries=0, base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"])
r = client.chat.completions.create(model="gpt-6.1-sol", messages=[{"role":"user","content":"Olá"}])
print(r.choices[0].message.content)
# Responses API: client.responses.create(model="gpt-6.1-sol", input="Olá")
# Embeddings: client.embeddings.create(model="nemotron-3-embed", input=["texto"])
```

```bash
python3 ailoot-openai-python-sdk.py
```

Exemplo de modelo: `gpt-6.1-sol, claude-sonnet-5-5, deepseek-v4-pro, qwen3.8-max (conversa); nemotron-3-embed (embeddings)`

#### Importante

Endereço com /v1: o SDK acrescenta automaticamente /chat/completions, /responses, /embeddings, /images/\*, /audio/\*. Funcionam Chat Completions e Responses (Responses — nos modelos cujo catálogo inclua esse formato). A saída em fluxo e as ferramentas seguem o padrão. Os erros do Ailoot chegam em JSON com Request ID e são capturados como openai.APIStatusError.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/openai-python-sdk/)[Documentação da aplicação ↗](https://github.com/openai/openai-python)

OS

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

SDK

OpenAI ChatOpenAI Responses

Biblioteca oficial OpenAI para JavaScript e TypeScript.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/openai-node-js-sdk/)

#### Onde configurar

Opção do construtor new OpenAI({ baseURL, apiKey }); por predefinição, o SDK lê a variável de ambiente OPENAI\_BASE\_URL

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```js
import OpenAI from "openai";
const client = new OpenAI({maxRetries: 0,
  baseURL: "https://api.ailoot.ai/v1",
  apiKey: process.env.AILOOT_API_KEY // sk-...
});
const r = await client.chat.completions.create({
  model: "claude-sonnet-5-5",
  messages: [{ role: "user", content: "Olá" }]
});
console.log(r.choices[0].message.content);
```

A chave é lida da variável `AILOOT_API_KEY` — defina-a antes de iniciar:

```bash
export AILOOT_API_KEY="sk-..."   # adicione a ~/.zshrc ou ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # depois reinicie o terminal
```

Exemplo de modelo: `claude-sonnet-5-5, gpt-6.1-sol, grok-4.7`

#### Importante

O README apresenta a opção baseURL; a leitura de OPENAI\_BASE\_URL é visível no código-fonte do cliente (src/client.ts), com o valor predefinido https://api.openai.com/v1. O endereço Ailoot deve incluir /v1. Estão disponíveis chat.completions e responses.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/openai-node-js-sdk/)[Documentação da aplicação ↗](https://github.com/openai/openai-node)

AS

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

SDK

Anthropic Messages

Biblioteca oficial Anthropic para Python.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/anthropic-python-sdk/)

#### Onde configurar

Parâmetro Anthropic(base\_url=...) ou variável de ambiente ANTHROPIC\_BASE\_URL; chave: api\_key ou ANTHROPIC\_API\_KEY

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```bash
export AILOOT_API_KEY="sk-..."
export ANTHROPIC_BASE_URL="https://api.ailoot.ai"
export ANTHROPIC_API_KEY="$AILOOT_API_KEY"
```

`ailoot-anthropic-python-sdk.py`

```python
import os
from anthropic import Anthropic
client = Anthropic(max_retries=0, base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"])
msg = client.messages.create(
    model="claude-sonnet-5-5", max_tokens=1024,
    messages=[{"role": "user", "content": "Olá"}])
print(msg.content[0].text)
```

```bash
python3 ailoot-anthropic-python-sdk.py
```

Exemplo de modelo: `claude-sonnet-5-5, claude-opus-5-5; também através de /v1/messages gpt-6.1-sol, deepseek-v4-pro, gemini-3.6-flash`

#### Importante

Endereço SEM /v1: o SDK acrescenta automaticamente /v1/messages. O gateway aceita a chave em x-api-key (tal como enviada pelo SDK) e em Authorization: Bearer. Funcionam a saída em fluxo, as ferramentas e /v1/messages/count\_tokens. O processamento em lote (Batches) e a Files API não são anunciados no catálogo Ailoot.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/anthropic-python-sdk/)[Documentação da aplicação ↗](https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/python)

VA

### [Vercel AI SDK](https://ailoot.ai/docs/pt-pt/integrations/vercel-ai-sdk/)

SDK

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Framework TypeScript para aplicações de IA com quaisquer fornecedores.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/vercel-ai-sdk/)

#### Onde configurar

Fornecedores: createOpenAICompatible({ name, baseURL, apiKey }) de @ai-sdk/openai-compatible; createAnthropic({ baseURL, apiKey }) de @ai-sdk/anthropic; createGoogleGenerativeAI({ baseURL, apiKey }) de @ai-sdk/google; createOpenAI({ baseURL }) ou OPENAI\_BASE\_URL

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```js
import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
import { createAnthropic } from "@ai-sdk/anthropic";
import { createGoogleGenerativeAI } from "@ai-sdk/google";
import { generateText } from "ai";

const ailoot = createOpenAICompatible({ name: "ailoot", baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY });
const claude = createAnthropic({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY });
const gemini = createGoogleGenerativeAI({ baseURL: "https://api.ailoot.ai/v1beta", apiKey: process.env.AILOOT_API_KEY });

const { text } = await generateText({ model: ailoot("deepseek-v4-pro"), prompt: "Olá" });
// claude("claude-sonnet-5-5"), gemini("gemini-3.6-flash")
```

A chave é lida da variável `AILOOT_API_KEY` — defina-a antes de iniciar:

```bash
export AILOOT_API_KEY="sk-..."   # adicione a ~/.zshrc ou ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # depois reinicie o terminal
```

Exemplo de modelo: `deepseek-v4-pro (compatível com OpenAI), claude-sonnet-5-5 (Anthropic), gemini-3.6-flash (Gemini)`

#### Importante

Os fornecedores utilizam endereços diferentes: compatível com OpenAI e Anthropic — com /v1 (o valor predefinido da Anthropic é https://api.anthropic.com/v1); Google — com /v1beta (por predefinição, https://generativelanguage.googleapis.com/v1beta). O fornecedor @ai-sdk/openai utiliza Responses API por predefinição; para modelos sem o método responses, utilize openai.chat("id") ou createOpenAICompatible.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/vercel-ai-sdk/)[Documentação da aplicação ↗](https://ai-sdk.dev/providers/openai-compatible-providers)

La

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

Framework

OpenAI ChatOpenAI ResponsesAnthropic Messages

Framework para cadeias, agentes e RAG.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/langchain/)

#### Onde configurar

ChatOpenAI(base\_url=...) ou variáveis OPENAI\_API\_BASE / OPENAI\_BASE\_URL; ChatAnthropic(base\_url=...) ou ANTHROPIC\_API\_URL / ANTHROPIC\_BASE\_URL

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```python
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-6.1-sol", base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"])
print(llm.invoke("Olá").content)

from langchain_anthropic import ChatAnthropic
claude = ChatAnthropic(model="claude-sonnet-5-5", base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"])
```

Exemplo de modelo: `gpt-6.1-sol, qwen3.8-max (ChatOpenAI); claude-sonnet-5-5 (ChatAnthropic)`

#### Importante

ChatOpenAI: endereço com /v1. Segundo a documentação, o ChatOpenAI suporta apenas a especificação oficial OpenAI: os campos não padrão, como reasoning\_content de modelos de terceiros, não são preservados. Para Claude, é preferível ChatAnthropic: endereço sem /v1; o SDK acrescenta automaticamente /v1/messages. O parâmetro base\_url e as variáveis ANTHROPIC\_API\_URL/ANTHROPIC\_BASE\_URL de ChatAnthropic estão descritos na documentação da classe no código-fonte (langchain\_anthropic/chat\_models.py), mas não na página de integração. A opção use\_responses\_api ativa o modo Responses no ChatOpenAI.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/langchain/)[Documentação da aplicação ↗](https://docs.langchain.com/oss/python/integrations/chat/openai)

Cr

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

Framework de agentes

OpenAI ChatAnthropic Messages

Equipas de agentes com papéis e tarefas.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/crewai/)

#### Onde configurar

crewai.LLM(model=..., base\_url=..., api\_key=...); variáveis OPENAI\_API\_KEY e OPENAI\_BASE\_URL; para Claude — fornecedor nativo anthropic/ com base\_url

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/messages e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```python
import os
from crewai import LLM
# formato compatível com OpenAI
llm = LLM(model="openai/gpt-6.1-sol", base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"])
# Anthropic Messages
claude = LLM(model="anthropic/claude-sonnet-5-5", base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_tokens=4096)
```

Exemplo de modelo: `openai/gpt-6.1-sol, anthropic/claude-sonnet-5-5`

#### Importante

O prefixo openai/ ou anthropic/ seleciona o fornecedor no CrewAI; o pedido envia o id sem o prefixo. Para OpenAI, o endereço inclui /v1; para Anthropic, não inclui /v1. A documentação também descreve a opção custom\_openai=True para gateways compatíveis com OpenAI personalizados. Em Anthropic, max\_tokens é obrigatório.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/crewai/)[Documentação da aplicação ↗](https://docs.crewai.com/en/concepts/llms)

GG

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

SDK

Gemini

Biblioteca oficial Google para Gemini API.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/google-genai-python/)

#### Onde configurar

genai.Client(api\_key=..., http\_options=types.HttpOptions(base\_url=...))

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1beta/models/{model}:generateContent e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```python
import os
from google import genai
from google.genai import types
client = genai.Client(
    api_key=os.environ["AILOOT_API_KEY"],
    http_options=types.HttpOptions(base_url="https://api.ailoot.ai"))
r = client.models.generate_content(model="gemini-3.6-flash", contents="Olá")
print(r.text)
```

Exemplo de modelo: `gemini-3.6-flash, gemini-3.1-pro`

#### Importante

Endereço sem /v1beta: o SDK constrói automaticamente /v1beta/models/{model}:generateContent. A chave é enviada no cabeçalho x-goog-api-key — aceite pelo Ailoot. Só estão disponíveis modelos com o formato Gemini. A documentação não descreve um endereço personalizado para a versão JavaScript (@google/genai), pelo que não a incluímos aqui.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/google-genai-python/)[Documentação da aplicação ↗](https://github.com/googleapis/python-genai#custom-base-url)

Li

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

SDK

OpenAI Chat

Interface Python única para dezenas de fornecedores.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/litellm/)

#### Onde configurar

litellm.completion(model="openai/\<id\>", api\_base=..., api\_key=...)

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```python
import os
import litellm
r = litellm.completion(
    model="openai/claude-sonnet-5-5",
    api_base="https://api.ailoot.ai/v1",
    api_key=os.environ["AILOOT_API_KEY"],
    messages=[{"role": "user", "content": "Olá"}])
print(r.choices[0].message.content)
# embeddings: litellm.embedding(model="openai/nemotron-3-embed", api_base="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], input=["texto"])
```

Exemplo de modelo: `openai/claude-sonnet-5-5, openai/qwen3.8-max, openai/nemotron-3-embed`

#### Importante

O prefixo openai/ indica o protocolo compatível com OpenAI; o Ailoot recebe o id sem o prefixo. O LiteLLM acrescenta automaticamente /chat/completions e /embeddings; segundo a documentação, em caso de erro Not Found, o endereço deve terminar em /v1.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/litellm/)[Documentação da aplicação ↗](https://docs.litellm.ai/docs/providers/openai_compatible)

LP

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

Gateway próprio

OpenAI Chat

Gateway próprio com chaves, limites e registos sobre o Ailoot.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/litellm-proxy/)

#### Onde configurar

config.yaml → model\_list → litellm\_params (model, api\_base, api\_key); início: litellm --config config.yaml

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```yaml
model_list:
  - model_name: claude-sonnet
    litellm_params:
      model: openai/claude-sonnet-5-5
      api_base: https://api.ailoot.ai/v1
      api_key: os.environ/AILOOT_API_KEY
  - model_name: gpt-sol
    litellm_params:
      model: openai/gpt-6.1-sol
      api_base: https://api.ailoot.ai/v1
      api_key: os.environ/AILOOT_API_KEY

# execução: litellm --config config.yaml
```

A chave é lida da variável `AILOOT_API_KEY` — defina-a antes de iniciar:

```bash
export AILOOT_API_KEY="sk-..."   # adicione a ~/.zshrc ou ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # depois reinicie o terminal
```

Exemplo de modelo: `openai/claude-sonnet-5-5, openai/gpt-6.1-sol`

#### Importante

O proxy é útil para distribuir chaves internas próprias à equipa sobre uma única chave Ailoot. Os débitos no Ailoot são associados à chave indicada em api\_key. O endereço inclui /v1.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/litellm-proxy/)[Documentação da aplicação ↗](https://docs.litellm.ai/docs/providers/openai_compatible)

Ll

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

Framework

OpenAI Chat

Framework para pesquisa nos seus dados e RAG.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/llamaindex/)

#### Onde configurar

Pacote llama-index-llms-openai-like, classe OpenAILike(api\_base=..., api\_key=..., model=..., is\_chat\_model=True)

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```bash
pip install llama-index-llms-openai-like
```

```python
import os
from llama_index.llms.openai_like import OpenAILike
llm = OpenAILike(
    model="deepseek-v4-pro",
    api_base="https://api.ailoot.ai/v1",
    api_key=os.environ["AILOOT_API_KEY"],
    is_chat_model=True,
    is_function_calling_model=True,
    context_window=128000)
print(llm.complete("Olá"))
```

Exemplo de modelo: `deepseek-v4-pro, claude-sonnet-5-5, gpt-6.1-sol`

#### Importante

Endereço com /v1. is\_chat\_model=True é obrigatório; caso contrário, a classe utiliza o antigo /completions. is\_function\_calling\_model=True permite aos agentes utilizar ferramentas. Defina context\_window de acordo com a ficha do modelo no catálogo Ailoot.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/llamaindex/)[Documentação da aplicação ↗](https://developers.llamaindex.ai/python/framework-api-reference/llms/openai_like/)

Ma

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

Framework de agentes

OpenAI ChatOpenAI Responses

Framework TypeScript para agentes e fluxos de trabalho.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/mastra/)

#### Onde configurar

Em Agent: model: { id: "\<fornecedor\>/\<modelo\>", url: "\<endereço de base\>", apiKey, api?: "chat" | "responses" }

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```js
import { Agent } from "@mastra/core/agent";
const agent = new Agent({
  id: "ailoot-agent",
  name: "Ailoot Agent",
  instructions: "Responda em russo",
  model: {
    id: "ailoot/claude-sonnet-5-5",
    url: "https://api.ailoot.ai/v1",
    apiKey: process.env.AILOOT_API_KEY
    // api: "responses"  // apenas para modelos com o método responses
  }
});
```

A chave é lida da variável `AILOOT_API_KEY` — defina-a antes de iniciar:

```bash
export AILOOT_API_KEY="sk-..."   # adicione a ~/.zshrc ou ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # depois reinicie o terminal
```

Exemplo de modelo: `ailoot/claude-sonnet-5-5, ailoot/gpt-6.1-sol`

#### Importante

Em url, indique o endereço de base com /v1, em vez do caminho completo para /chat/completions. Por predefinição, utiliza Chat Completions; api: "responses" muda para Responses API. A forma de id "fornecedor/modelo" envia ao gateway apenas o id do modelo. A documentação apresenta o campo apiKey no objeto model num exemplo com cabeçalhos; não o descreve separadamente em conjunto com url.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/mastra/)[Documentação da aplicação ↗](https://mastra.ai/models)

OA

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

Framework de agentes

OpenAI ChatOpenAI Responses

Biblioteca OpenAI para cenários com vários agentes.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/openai-agents-sdk/)

#### Onde configurar

AsyncOpenAI(base\_url=..., api\_key=...) + OpenAIChatCompletionsModel(model=..., openai\_client=client), ou globalmente set\_default\_openai\_client(client)

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```python
import os
from agents import Agent, Runner, AsyncOpenAI, OpenAIChatCompletionsModel, set_tracing_disabled
set_tracing_disabled(disabled=True)
client = AsyncOpenAI(max_retries=0, base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"])
model = OpenAIChatCompletionsModel(model="claude-sonnet-5-5", openai_client=client)
agent = Agent(name="Assistente", instructions="Responda em russo", model=model)
print(Runner.run_sync(agent, "Olá").final_output)
```

Exemplo de modelo: `claude-sonnet-5-5, gpt-6.1-sol`

#### Importante

Endereço com /v1. Desative o rastreio através de set\_tracing\_disabled(True): caso contrário, o SDK tentará enviar rastos à OpenAI sem uma chave OpenAI. Chat Completions está disponível apenas para os modelos que tenham esse método indicado no catálogo e disponível para a sua chave; Responses (por predefinição no SDK) — apenas para os modelos cujo catálogo indique o método responses. As ferramentas incorporadas da OpenAI (pesquisa na Internet, ficheiros) não são garantidas através de um gateway de terceiros.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/openai-agents-sdk/)[Documentação da aplicação ↗](https://openai.github.io/openai-agents-python/models/)

PA

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

Framework de agentes

OpenAI ChatOpenAI Responses

Framework de agentes tipado em Python.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/pydantic-ai/)

#### Onde configurar

OpenAIProvider(base\_url=..., api\_key=...) com OpenAIChatModel (Chat Completions) ou OpenAIResponsesModel (Responses); ou variável OPENAI\_BASE\_URL

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```python
import os
from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIChatModel
from pydantic_ai.providers.openai import OpenAIProvider
model = OpenAIChatModel("deepseek-v4-pro",
    provider=OpenAIProvider(base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"]))
agent = Agent(model)
print(agent.run_sync("Olá").output)
```

Exemplo de modelo: `deepseek-v4-pro, gpt-6.1-sol (para OpenAIResponsesModel)`

#### Importante

Endereço com /v1. A documentação utiliza OpenAIResponsesModel por predefinição: escolha-o apenas para modelos com o método responses; para os restantes, utilize OpenAIChatModel.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/pydantic-ai/)[Documentação da aplicação ↗](https://pydantic.dev/docs/ai/models/openai/)

## Automatização

Cenários sem código, construtores de cadeias, bots e casa inteligente.

N8

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

Automatização sem código

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Automatização de cenários com nós de agentes de IA.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/n8n/)

#### Onde configurar

Credentials → OpenAI → campo Base URL (por predefinição, https://api.openai.com/v1); Credentials → Anthropic → Base URL (por predefinição, https://api.anthropic.com); Credentials → Google Gemini(PaLM) Api → Host (por predefinição, https://generativelanguage.googleapis.com). Depois, nós OpenAI Chat Model / Anthropic Chat Model / Google Gemini Chat Model

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
OpenAI credential:
  API Key: sk-...
  Base URL: https://api.ailoot.ai/v1
Anthropic credential:
  API Key: sk-...
  Base URL: https://api.ailoot.ai
Google Gemini(PaLM) Api credential:
  Host: https://api.ailoot.ai
  API Key: sk-...
Nó OpenAI Chat Model → Model: By ID → gpt-6.1-sol (a opção Use Responses API destina-se apenas a modelos com o método responses)
```

Exemplo de modelo: `gpt-6.1-sol / deepseek-v4-pro (OpenAI), claude-sonnet-5-5 (Anthropic), gemini-3.6-flash (Gemini)`

#### Importante

A verificação das credenciais consulta /models (OpenAI), /v1/models (Anthropic) e /v1beta/models (Gemini); o Ailoot disponibiliza os três caminhos. As páginas da documentação n8n não descrevem o campo Base URL: este existe nas próprias credenciais (código-fonte OpenAiApi.credentials.ts e AnthropicApi.credentials.ts, legenda «Override the default base URL for the API»). No n8n Cloud, não selecione «Use Gateway credits», caso contrário, os pedidos não passarão pelo Ailoot.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/n8n/)[Documentação da aplicação ↗](https://github.com/n8n-io/n8n/blob/master/packages/nodes-base/credentials/OpenAiApi.credentials.ts)

Di

### [Dify](https://ailoot.ai/docs/pt-pt/integrations/dify/)

Plataforma de aplicações LLM

OpenAI Chat

Plataforma de aplicações de IA: chatbots, agentes e bases de conhecimento.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/dify/)

#### Onde configurar

Integrations → Model Provider → instalar o plugin OpenAI-API-compatible → Add Model (campos: Model Type, Model Name, API Key, API Base URL, Completion mode, Model context size)

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Model Type: LLM
Model Name: claude-sonnet-5-5
API Key: sk-...
API Base URL: https://api.ailoot.ai/v1
Completion mode: Chat
Model context size: conforme a ficha do modelo no catálogo Ailoot

Para Text Embedding:
Model Name: nemotron-3-embed
API Base URL: https://api.ailoot.ai
```

Exemplo de modelo: `claude-sonnet-5-5, gpt-6.1-sol, qwen3.8-max; nemotron-3-embed (embeddings)`

#### Importante

Apenas o proprietário e os administradores do workspace podem gerir fornecedores. Segundo o README do plugin: para LLM, o endereço inclui /v1; para embeddings, rerank, STT e TTS, o plugin acrescenta automaticamente a versão da API, pelo que o endereço não deve incluir /v1 (caso contrário, resulta em /v1/v1). Adicione cada modelo Ailoot numa entrada separada; ative o suporte de imagens na entrada e a saída em fluxo nas definições do modelo.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/dify/)[Documentação da aplicação ↗](https://github.com/langgenius/dify-official-plugins/tree/main/models/openai_api_compatible)

Fl

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

Construtor de cadeias

OpenAI Chat

Construtor visual de cadeias e agentes.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/flowise/)

#### Onde configurar

Nó ChatOpenAI ou ChatOpenAI Custom → Connect Credential (chave) → Additional Parameters → Base Path (e Base Options para cabeçalhos)

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Credential (OpenAI API): sk-...
Nó ChatOpenAI Custom:
  Model Name: deepseek-v4-pro
  Additional Parameters → Base Path: https://api.ailoot.ai/v1
```

Exemplo de modelo: `deepseek-v4-pro, claude-sonnet-5-5, gpt-6.1-sol`

#### Importante

O ChatOpenAI tem uma lista fixa de modelos; para id Ailoot personalizados, utilize ChatOpenAI Custom, onde o nome do modelo é introduzido manualmente. Base Path inclui /v1. Para embeddings, existe o nó OpenAI Embeddings Custom.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/flowise/)[Documentação da aplicação ↗](https://docs.flowiseai.com/integrations/langchain/chat-models/azure-chatopenai)

HA

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

Casa inteligente

OpenAI Chat

Assistente de voz para casa inteligente através de Extended OpenAI Conversation.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/home-assistant/)

#### Onde configurar

Instalar através de HACS (Custom repository) ou copiar custom\_components/extended\_openai\_conversation → reiniciar → Settings → Devices & Services → Add Integration → Extended OpenAI Conversation (API Key, Base Url) → Settings → Voice Assistants → Conversation agent

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
API Key: sk-...
Base Url: https://api.ailoot.ai/v1
Options → Chat Model: gpt-6.1-sol
Voice Assistants → Conversation agent: Extended OpenAI Conversation
```

Exemplo de modelo: `gpt-6.1-sol, claude-sonnet-5-5`

#### Importante

É um componente de terceiros, e não uma integração oficial. O controlo de dispositivos utiliza chamadas de funções (tools) em Chat Completions, pelo que deve escolher modelos com suporte de ferramentas. A integração oficial OpenAI Conversation não suporta um endereço personalizado.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/home-assistant/)[Documentação da aplicação ↗](https://github.com/jekalmin/extended_openai_conversation)

La

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

Construtor de cadeias

OpenAI Chat

Construtor visual de agentes e RAG.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/langflow/)

#### Onde configurar

Perfil → Settings → Model Providers → OpenAI Compatible (campos Base URL e API Key; variáveis OPENAI\_COMPATIBLE\_BASE\_URL e OPENAI\_COMPATIBLE\_API\_KEY). Alternativa: componente OpenAI → campo OpenAI API Base

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Settings → Model Providers → OpenAI Compatible:
  Base URL: https://api.ailoot.ai/v1
  API Key: sk-...
ou através do ambiente:
```

```bash
export OPENAI_COMPATIBLE_BASE_URL="https://api.ailoot.ai/v1"
export OPENAI_COMPATIBLE_API_KEY="sk-..."
Depois, nos componentes Language Model / Agent, selecione OpenAI Compatible → claude-sonnet-5-5
```

Exemplo de modelo: `claude-sonnet-5-5, gpt-6.1-sol, nemotron-3-embed (Embedding Model)`

#### Importante

O Langflow verifica a ligação e carrega a lista de modelos de /v1/models; os modelos aparecem nas secções Language Models e Embedding Models. Os modelos pretendidos têm depois de ser ativados manualmente. O fornecedor é instalado com o langflow.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/langflow/)[Documentação da aplicação ↗](https://docs.langflow.org/bundles-openai-compatible)

Ma

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

Automatização sem código

Pedido HTTP

Automatização sem código: pedido ao Ailoot através do módulo HTTP.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/make/)

#### Onde configurar

O módulo OpenAI incorporado funciona apenas com uma conta OpenAI. Utilize HTTP → Make a request: URL, Method, Headers, Body type Raw / JSON

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Módulo: HTTP → Make a request
URL: https://api.ailoot.ai/v1/chat/completions
Method: POST
Headers:
  Authorization: Bearer sk-...
  Content-Type: application/json
Body (JSON):
{"model":"gpt-6.1-sol","messages":[{"role":"user","content":"{{1.text}}"}]}
Parse response: Yes → resposta em choices[].message.content
```

Exemplo de modelo: `gpt-6.1-sol, claude-sonnet-5-5`

#### Importante

É um módulo HTTP universal, e não um fornecedor específico para Ailoot: a documentação descreve um endereço HTTPS arbitrário. É preferível guardar a chave numa ligação com chave de API (o Make recomenda este método em vez de a transmitir nos cabeçalhos). O Make não precisa de saída em fluxo; envie sem stream.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/make/)[Documentação da aplicação ↗](https://apps.make.com/http)

T

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

Bots

OpenAI Chat

Bot próprio no Telegram com OpenAI SDK.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/telegram-bot/)

#### Onde configurar

Os frameworks Telegram não têm uma camada LLM própria: o processador de mensagens chama o OpenAI SDK com base\_url do Ailoot (ou Anthropic SDK com base\_url sem /v1)

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

Guarde o código Python como ailoot-telegram-bot.py. Instale as dependências, defina as duas variáveis de ambiente e execute o ficheiro. Envie Hello ao bot e verifique a resposta de texto. Se ocorrer um erro, guarde o Request ID e verifique o resultado original antes de outra geração.

```bash
python3 -m pip install "aiogram>=3,<4" openai
```

`ailoot-telegram-bot.py`

```python
import asyncio
import os
from aiogram import Bot, Dispatcher, F
from aiogram.types import Message
from openai import AsyncOpenAI, APIError

async def main():
    dp = Dispatcher()
    async with AsyncOpenAI(
        base_url="https://api.ailoot.ai/v1",
        api_key=os.environ["AILOOT_API_KEY"],
        max_retries=0,
    ) as llm:
        @dp.message(F.text)
        async def reply(message: Message):
            try:
                result = await llm.chat.completions.create(
                    model="claude-sonnet-5-5",
                    messages=[{"role": "user", "content": message.text}],
                )
                content = result.choices[0].message.content or "—"
                for start in range(0, len(content), 4000):
                    await message.answer(content[start:start + 4000])
            except APIError as error:
                await message.answer(
                    f"{type(error).__name__}; Request ID: "
                    f"{getattr(error, 'request_id', None) or '—'}"
                )
        bot = Bot(token=os.environ["TELEGRAM_BOT_TOKEN"])
        await dp.start_polling(bot)

if __name__ == "__main__":
    asyncio.run(main())
```

```bash
export AILOOT_API_KEY="sk-..."
export TELEGRAM_BOT_TOKEN="<TELEGRAM_BOT_TOKEN>"
python3 ailoot-telegram-bot.py
```

Exemplo de modelo: `claude-sonnet-5-5, deepseek-v4-pro, qwen3.8-flash`

#### Importante

Os frameworks Telegram não têm uma camada própria para redes neuronais: o endereço Ailoot é definido no OpenAI SDK dentro do bot. Com saldo zero, o Ailoot devolve um erro 402 claro com Request ID — apresente-o ao utilizador do bot, em vez de deixar o bot falhar.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/telegram-bot/)[Documentação da aplicação ↗](https://github.com/openai/openai-python)

Za

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

Automatização sem código

Pedido HTTP

Automatização: pedido ao Ailoot através de Webhooks by Zapier.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/zapier/)

#### Onde configurar

A aplicação ChatGPT (OpenAI) no Zapier funciona apenas com OpenAI. Utilize Webhooks by Zapier → Custom Request (Method, URL, Data, Headers)

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Ação: Webhooks by Zapier → Custom Request
Method: POST
URL: https://api.ailoot.ai/v1/chat/completions
Data (raw JSON):
{"model":"claude-sonnet-5-5","messages":[{"role":"user","content":"Olá"}]}
Headers:
  Authorization | Bearer sk-...
  Content-Type | application/json
```

Exemplo de modelo: `claude-sonnet-5-5, gpt-6.1-sol`

#### Importante

É um pedido HTTP universal; o Zapier não disponibiliza um fornecedor pronto com campo de endereço de base. Custom Request envia o campo Data tal como está, sem o analisar, pelo que deve validar o JSON antecipadamente. Webhooks by Zapier está disponível nos tarifários pagos do Zapier.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/zapier/)[Documentação da aplicação ↗](https://help.zapier.com/hc/en-us/articles/8496326446989-Send-webhooks-in-Zap-workflows)

## Em verificação

Configurações com detalhes por confirmar — compare-as com a janela da aplicação.

AC

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

Agente no terminal

Em verificação

Gemini

Agente de consola Google Antigravity no formato Gemini.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/antigravity-cli/)

#### Onde configurar

~/.gemini/antigravity-cli/settings.json → "modelProvider": "gemini"; variáveis GEMINI\_API\_KEY e GOOGLE\_GEMINI\_BASE\_URL

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1beta/models/{model}:generateContent e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

`~/.gemini/antigravity-cli/settings.json`

```json
{
  "modelProvider": "gemini"
}
```

```bash
export AILOOT_API_KEY="sk-..."
# no terminal:
export GEMINI_API_KEY="$AILOOT_API_KEY"
export GOOGLE_GEMINI_BASE_URL=https://api.ailoot.ai
agy --model gemini-3.8-flash
```

Exemplo de modelo: `gemini-3.8-flash`

#### Importante

O protocolo é o Gemini REST nativo (streamGenerateContent, chave em X-Goog-Api-Key), com o caminho https://api.ailoot.ai/v1beta/... Para cada pergunta, agy envia dois pedidos: o título da conversa e a resposta propriamente dita. O agente reserva significativamente mais em cada passo do que um chat normal, por isso mantenha uma margem no saldo. A ficha está na secção «Em verificação»: a configuração foi preparada a partir da documentação; ainda não foi executado um teste real do cliente através do Ailoot. Se modelProvider = gemini e GEMINI\_API\_KEY estiver vazio, o CLI não inicia.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/antigravity-cli/)[Documentação da aplicação ↗](https://antigravity.google/docs/cli/install/)

CC

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

Agente no terminal

Em verificação

OpenAI Chat

Versão de consola do agente Cline.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/cline-cli/)

#### Onde configurar

cline auth → fornecedores de API personalizados → OpenAI Compatible: Base URL, API Key, Model ID; a opção -P/--provider seleciona o fornecedor

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```bash
cline auth
# API Provider: OpenAI Compatible
# Base URL:     https://api.ailoot.ai/v1
# API Key:      sk-...
# Model ID:     claude-sonnet-5-5
cline "Execute os testes e corrija os erros"
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

Os campos Base URL / API Key / Model ID estão descritos na documentação Cline para OpenAI Compatible. A documentação do CLI não apresenta os nomes exatos das opções do assistente cline auth — confira-os no ecrã.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/cline-cli/)[Documentação da aplicação ↗](https://docs.cline.bot/provider-config/openai-compatible)

CJ

### [Copilot para JetBrains](https://ailoot.ai/docs/pt-pt/integrations/copilot-jetbrains-byok/)

Extensão do editor

Em verificação

OpenAI Chat

Endereço de modelo personalizado no Copilot para IDE JetBrains.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/copilot-jetbrains-byok/)

#### Onde configurar

Language Models → Add Models… → Add Custom Endpoint Provider: Provider Name, API Key, API Type (Chat Completions)

#### Configuração

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

#### Importante

O GitHub confirma o suporte de endpoints personalizados. A captura oficial mostra Provider Name, API Key e API Type: Chat Completions, mas não apresenta um exemplo de URL. Por isso, não fornecemos aqui uma configuração Ailoot pronta a copiar. O JetBrains AI Assistant é a alternativa documentada neste IDE. Esclareça os requisitos do URL com o suporte oficial do plugin.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/copilot-jetbrains-byok/)[Documentação da aplicação ↗](https://github.blog/changelog/2026-07-14-github-copilot-for-jetbrains-expands-byok-capabilities/)

Cu

### [Cursor](https://ailoot.ai/docs/pt-pt/integrations/cursor/)

Editor de código

Em verificação

OpenAI Chat

Editor Cursor: endereço OpenAI personalizado para o chat.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/cursor/)

#### Onde configurar

Cursor Settings → Models → API Keys → OpenAI API Key + interruptor «Override OpenAI Base URL»; depois, acrescente o ID do modelo aos seus modelos.

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
OpenAI API Key:            sk-...
Override OpenAI Base URL:  https://api.ailoot.ai/v1
Modelo personalizado:               gpt-6.1-sol  (adicionar, ativar e selecionar no chat)
```

Exemplo de modelo: `gpt-6.1-sol`

#### Importante

A documentação oficial atual do Cursor não descreve um endereço personalizado: enumera apenas chaves OpenAI/Anthropic/Google/Azure/Bedrock, indica que as chaves próprias só funcionam no chat (Tab continua a utilizar modelos Cursor) e que todos os pedidos passam pelos servidores Cursor (o endereço tem de ser público — api.ailoot.ai é público). O interruptor de endereço existe na interface, mas no fórum Cursor são comunicados problemas: aplica-se a todos os modelos, o modo Agent pode não utilizar a chave própria e, em algumas versões 3.15.x, o campo não aceita introdução de dados.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/cursor/)[Documentação da aplicação ↗](https://cursor.com/help/models-and-usage/api-keys)

OT

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

Plugin Obsidian

Em verificação

OpenAI Chat

Geração de texto em notas Obsidian através de modelos de texto predefinidos.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/obsidian-text-generator/)

#### Onde configurar

Settings \> Text Generator \> LLM Provider: OpenAI Chat (ou Custom)

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Provider: OpenAI Chat
API Key: sk-...
Base Path: https://api.ailoot.ai/v1
Model: gpt-6.1-sol
```

Exemplo de modelo: `gpt-6.1-sol`

#### Importante

A documentação do plugin menciona o fornecedor Custom, mas não descreve o campo de endereço nem o seu formato; a configuração baseia-se na interface do plugin — compare-a com a janela de definições.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/obsidian-text-generator/)[Documentação da aplicação ↗](https://docs.text-gen.com/)

Pe

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

Editor de código

Em verificação

OpenAI Chat

Editor PearAI baseado em VS Code.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/pearai/)

#### Onde configurar

Cmd/Ctrl+Shift+P → Open config.json → entrada em models\[\] (o PearAI é uma derivação do Continue).

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```json
{
  "models": [
    {
      "title": "Ailoot Claude Sonnet 5.5",
      "provider": "openai",
      "model": "claude-sonnet-5-5",
      "apiBase": "https://api.ailoot.ai/v1",
      "apiKey": "sk-..."
    }
  ]
}
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

Não foi possível verificar a documentação oficial do PearAI (o site de documentação está indisponível), e o repositório não é atualizado há muito tempo. O formato da configuração baseia-se no Continue — verifique-o na aplicação.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/pearai/)[Documentação da aplicação ↗](https://github.com/trypear/pearai-app/issues/122)

VS

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

Editor de código

Em verificação

OpenAI Chat

Fornecedor personalizado no Copilot Chat para Visual Studio.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/visual-studio-2026/)

#### Onde configurar

Chat → seleção de modelo → Manage models → Add custom model → fornecedor OpenAI (custom endpoint) → endereço, chave, modelo.

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Provider: OpenAI (custom endpoint)
Endpoint: https://api.ailoot.ai/v1
API key:  sk-...
Model:    gpt-6.1-sol
```

Exemplo de modelo: `gpt-6.1-sol`

#### Importante

O blogue Visual Studio (29.09.2026) anunciou endereços personalizados para OpenAI e Ollama em VS 2026 Stable, mas a página da documentação ainda descreve apenas chaves OpenAI/Anthropic/Google, sem campo de endereço; por isso, os nomes dos campos e o formato do endereço ainda não estão confirmados. Apenas chat; indisponível nos planos Copilot Business/Enterprise.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/visual-studio-2026/)[Documentação da aplicação ↗](https://devblogs.microsoft.com/visualstudio/visual-studio-september-update-power-your-workflow-with-your-model/)

Vo

### [Void](https://ailoot.ai/docs/pt-pt/integrations/void/)

Editor de código

Em verificação

OpenAI Chat

Editor de código aberto baseado em VS Code, com desenvolvimento interrompido.

[Saiba mais →](https://ailoot.ai/docs/pt-pt/integrations/void/)

#### Onde configurar

Void Settings → Providers → OpenAI-Compatible → baseURL, API key, modelo.

#### Configuração

Antes de iniciar, consulte GET /v1/models com a sua chave Ailoot. Escolha um ID exato de modelo cujos métodos incluam POST /v1/chat/completions e use-o na configuração. Para agentes, verifique também as ferramentas e funcionalidades necessárias à sua versão do cliente.

```text
Provider: OpenAI-Compatible
baseURL:  https://api.ailoot.ai/v1   (sem /chat/completions)
API key:  sk-...
Model:    claude-sonnet-5-5
```

Exemplo de modelo: `claude-sonnet-5-5`

#### Importante

A configuração foi obtida do código-fonte do Void, e não da documentação do utilizador. O repositório Void está arquivado e o editor já não é desenvolvido — só é adequado para quem já o utiliza.

[Instruções completas →](https://ailoot.ai/docs/pt-pt/integrations/void/)[Documentação da aplicação ↗](https://github.com/voideditor/void/blob/main/src/vs/workbench/contrib/void/common/voidSettingsTypes.ts)

Não foram encontrados resultados. Se a aplicação permitir definir um endereço OpenAI ou Anthropic API personalizado, é provável que funcione — [veja o que indicar](https://ailoot.ai/docs/pt-pt/keys/).

## Ainda não são adequados

Estas aplicações não permitem definir um endereço de API personalizado. Ao lado, encontra alternativas.

| Aplicação | Porque não é adequada | Alternativa |
| --- | --- | --- |
| **Cursor CLI (cursor-agent)** | Funciona apenas com modelos Cursor; não permite definir um endereço de API personalizado. | Claude Code, Codex CLI ou opencode |
| **Auggie CLI (Augment Code)** | Autenticação através de uma conta Augment; não permite definir um fornecedor externo. | Claude Code ou opencode |
| **Windsurf / Devin Desktop** | Aceita apenas a chave Anthropic para modelos Claude específicos; não permite definir um endereço personalizado. | Cline, Roo Code ou Kilo Code no VS Code |
| **Kiro** | Não permite definir chave própria nem endereço de API personalizado. | Cline ou Roo Code |
| **Google Antigravity (IDE)** | Não existe configuração oficial de um fornecedor personalizado; não recomendamos patches de terceiros. | Antigravity CLI ou Gemini CLI |
| **Visual Studio com Copilot Business ou Enterprise** | Estes tarifários Copilot não disponibilizam modelos personalizados. | Tarifário pessoal Copilot — ficha Visual Studio 2026 |
| **Conclusão automática Cursor Tab** | Utiliza sempre modelos Cursor, mesmo com uma chave própria. | O chat Cursor é configurado separadamente — ficha Cursor |
| **Enchanted** | Funciona apenas com a API Ollama. | Open WebUI ou Chatbox |
| **Smart Connections (Obsidian)** | As API externas só estão disponíveis no Smart Chat Pro pago. | Obsidian Copilot |
| **Witsy, 5ire** | Não encontrámos uma descrição oficial de um endereço de API personalizado. | Cherry Studio ou Jan |
| **Make: módulo OpenAI incorporado** | Liga-se apenas a uma conta OpenAI. | Módulo HTTP → Make a request — ficha Make |
| **Zapier: aplicação ChatGPT (OpenAI)** | Não existe campo para um endereço personalizado. | Webhooks by Zapier → Custom Request — ficha Zapier |
| **Home Assistant: OpenAI Conversation** | A integração incorporada funciona apenas com o endereço OpenAI. | Extended OpenAI Conversation do HACS — ficha Home Assistant |
| **aiogram, python-telegram-bot, grammY, Telegraf** | Os frameworks de bots não se ligam diretamente a modelos. | OpenAI ou Anthropic SDK dentro do bot — ficha Bot do Telegram |

## Ligação à API e configuração de clientes

### Onde introduzo o endereço da API e a chave no meu cliente?

Agentes, editores, chats e SDK que aceitam a chave Ailoot. O botão «Configurar» mostra onde inserir o endereço e a chave e fornece uma configuração pronta a copiar.

Ligue o Ailoot ao Claude Code, OpenCode, Hermes ou à sua aplicação.

## A empresa e a sua carteira de projetos

A empresa e a sua carteira de projetos: milhões de clientes; vendas mensais na ordem dos milhares de milhões.

## Compre tokens com desconto.

Desconto por subscrição para trabalho regular. Códigos promocionais — até 50% na compra de tokens.

Subscrição

Escolha um plano com desconto para os pedidos regulares.

Código promocional até 50%

Introduza o código na compra. O preço é recalculado conforme a campanha em vigor.

Custos no histórico

O modelo, os tokens e o montante são guardados para cada pedido.

[Escolher subscrição](https://ailoot.ai/docs/pt-pt/billing/subscriptions/) · [Ver preços dos modelos](https://ailoot.ai/models/pt-pt/)

## Ligue a API ao produto que vende.

SaaS, aplicações e bots — ao abrigo da oferta e do contrato de licença Ailoot. Para revenda, peça uma licença de revendedor.

Aplicação comercial

Integre geração de texto, imagens, vídeo e som nas funcionalidades pagas do seu serviço.

Licença de revendedor

Envie uma descrição do projeto e do modelo de acesso. Peça condições escritas de utilização e revenda.

Documentos no site

A oferta, o contrato de licença e a política de tratamento de dados estão disponíveis antes da ligação.

[Pedir licença de revendedor](mailto:support@ailoot.ai) · [Oferta e contrato de licença](https://ailoot.ai/legal/offer?lang=pt-pt)

## Perguntas

Que formato devo escolher para o cliente?

Escolha o formato OpenAI, Anthropic ou Gemini suportado pelo seu cliente. Na ficha do modelo Ailoot, confirme um método API compatível e o ID do modelo; o suporte de um formato não significa que todos os modelos suportem todos os formatos.

O que preciso de configurar no cliente?

Defina a chave API Ailoot, o endereço API e um ID de modelo compatível com o método do cliente. OpenAI SDK usa https://api.ailoot.ai/v1; Anthropic e Gemini SDK usam https://api.ailoot.ai. Mantenha os campos do pedido do exemplo desse formato.

Como enviar o primeiro pedido API?

Crie uma chave API Ailoot. Defina https://api.ailoot.ai/v1 para OpenAI SDK ou https://api.ailoot.ai para Anthropic e Gemini SDK. GET /v1/models é gratuito e lista os modelos disponíveis para a sua chave; depois, use o exemplo do modelo e do método API escolhidos.

O que verificar quando um cliente ligado falha?

Confirme que o cliente envia o formato OpenAI, Anthropic ou Gemini esperado para o endereço API correspondente, com a sua chave API Ailoot. Verifique o ID do modelo e o método e compare o erro devolvido com o guia do cliente. Envie o erro e o ID do pedido para support@ailoot.ai sem partilhar a sua chave.

Posso usar o Ailoot num produto pago?

Sim. Ligue a API ao seu SaaS, aplicação ou bot ao abrigo da oferta e do contrato de licença Ailoot. Para revenda, peça condições escritas e uma licença de revendedor para o seu projeto.

Como pedir uma licença de revenda?

Escreva para support@ailoot.ai e descreva o seu produto, quem o utiliza e como disponibiliza o acesso. Peça uma licença de revenda e condições por escrito para o seu projeto.

## Ailoot · A empresa e a sua carteira de projetos





A Ailoot assenta numa experiência operacional consolidada, numa ampla base de clientes, num serviço estável e no acompanhamento contínuo dos KPI.





A empresa e a sua carteira de projetos: milhões de clientes; vendas mensais na ordem dos milhares de milhões.





A Ailoot aplica essa experiência operacional ao acesso por API a funcionalidades de IA nos produtos dos clientes, agentes, aplicações e automatizações.