Source: https://ailoot.ai/integrations/it/
Canonical: https://ailoot.ai/integrations/it/
Language: it

[Integrazioni](https://ailoot.ai/docs/it/integrations/) 

# Collega Ailoot ai tuoi strumenti preferiti — Chiamate API per intelligenza artificiale nei client

Agenti, editor, chat e SDK che accettano la chiave Ailoot. Il pulsante «Configura» mostra dove inserire indirizzo e chiave e un config pronto da copiare.

**85**applicazioni

**77**pronte

**8**in verifica

 Ricerca applicazione 

## Agenti nel terminale

Agenti di coding e CLI: scrivono codice, eseguono comandi e modificano file.

CC

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

Agente nel terminale

Anthropic Messages

Agente Anthropic nel terminale: scrive codice, modifica file ed esegue comandi.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/claude-code/)

#### Dove configurare

Variabili d’ambiente o blocco "env" in ~/.claude/settings.json (per un progetto — .claude/settings.local.json); estensione VS Code — claudeCode.environmentVariables; verifica — comando /status

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

`~/.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
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

Indirizzo senza /v1: Claude Code aggiunge da solo /v1/messages. ANTHROPIC\_AUTH\_TOKEN viene inviato come Authorization: Bearer, ANTHROPIC\_API\_KEY come x-api-key; Ailoot accetta entrambi. CLAUDE\_CODE\_ENABLE\_GATEWAY\_MODEL\_DISCOVERY=1 inserisce i nostri modelli in /model tramite /v1/models. Per gli errori 400 su campi sconosciuti — CLAUDE\_CODE\_DISABLE\_EXPERIMENTAL\_BETAS=1. La documentazione Anthropic non supporta Claude Code con modelli non Claude tramite gateway, anche se il nostro /v1/messages li gestisce; consigliamo modelli Claude. Remote Control e input vocale non sono disponibili con il gateway.

[Guida completa →](https://ailoot.ai/docs/it/integrations/claude-code/)[Documentazione dell’applicazione ↗](https://code.claude.com/docs/en/llm-gateway-connect)

OC

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

Agente nel terminale

OpenAI Responses

Agente OpenAI per il terminale, usa il formato Responses.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/openai-codex-cli/)

#### Dove configurare

~/.codex/config.toml (solo file utente: nel .codex/config.toml del progetto model\_provider/model\_providers vengono ignorati); chiave nella variabile indicata in env\_key

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/responses e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

`~/.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
```

Modello di esempio: `gpt-6.1-sol`

#### Importante

Codex funziona solo tramite OpenAI Responses API (la documentazione indica solo wire\_api = "responses"), quindi serve il nostro /v1/responses. Gli ID provider openai, ollama, lmstudio sono riservati. Alternativa — openai\_base\_url = "https://api.ailoot.ai/v1" per il provider integrato openai. Ailoot fornisce a Codex l’elenco nel formato manifesto Codex (GET /v1/models con client\_version). Scegli un modello specifico che abbia OpenAI Responses nel catalogo. Nello snapshot 2026-09-30 gemini-3.6-flash ha OpenAI Chat, Anthropic Messages e Gemini, ma non Responses, quindi non è adatto a Codex. Verifica i formati sulla scheda del modello, non dal nome della famiglia.

[Guida completa →](https://ailoot.ai/docs/it/integrations/openai-codex-cli/)[Documentazione dell’applicazione ↗](https://learn.chatgpt.com/docs/config-file/config-advanced)

HA

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

Agente nel terminale

OpenAI ChatOpenAI ResponsesAnthropic Messages

Agente Nous Research per il terminale con memoria e competenze.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/hermes-agent/)

#### Dove configurare

hermes model → «Custom endpoint (self-hosted / VLLM / etc.)» oppure ~/.hermes/config.yaml (sezione model o dizionario providers)

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

`~/.hermes/config.yaml`

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

# più formati contemporaneamente — provider con 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

# nella sessione: /model custom:claude-sonnet-5-5
```

La chiave viene letta dalla variabile `AILOOT_API_KEY` — impostala prima dell’avvio:

```bash
export AILOOT_API_KEY="sk-..."   # aggiungi a ~/.zshrc o ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poi riavvia il terminale
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

transport: chat\_completions (OpenAI Chat), anthropic\_messages (Anthropic Messages) o codex\_responses (OpenAI Responses). LLM\_MODEL in .env non è più usato; OPENAI\_BASE\_URL vale solo per il provider openai-api. Per anthropic\_messages indica l’indirizzo senza /v1 — Anthropic SDK aggiunge da solo /v1/messages. I compiti ausiliari (riconoscimento immagini, compressione della cronologia) usano per impostazione predefinita lo stesso modello principale.

[Guida completa →](https://ailoot.ai/docs/it/integrations/hermes-agent/)[Documentazione dell’applicazione ↗](https://hermes-agent.nousresearch.com/docs/integrations/providers)

Op

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

Agente nel terminale

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Assistente IA personale sul proprio computer: chat, messaggistica e attività.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/openclaw/)

#### Dove configurare

Config OpenClaw (~/.openclaw/openclaw.json) → models.providers.\<id\>; modello predefinito — agents.defaults.model.primary; modifica sicura — openclaw config set models.providers.\<id\> '\<json\>' --strict-json --merge

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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
          }
        ]
      }
    }
  }
}
```

La chiave viene letta dalla variabile `AILOOT_API_KEY` — impostala prima dell’avvio:

```bash
export AILOOT_API_KEY="sk-..."   # aggiungi a ~/.zshrc o ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poi riavvia il terminale
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

Adapter api: openai-completions (predefinito se baseUrl è impostato), openai-responses (solo se il server supporta /v1/responses — Ailoot lo supporta), anthropic-messages, google-generative-ai e altri. Per anthropic-messages negli esempi OpenClaw baseUrl è senza /v1. OpenClaw può trasmettere immagini quando input del modello contiene "image". Negli esempi Claude è mantenuto solo testo: lo snapshot 2026-09-30 non dichiara input image per questi metodi. Aggiungi "image" solo per un modello specifico la cui scheda attuale dichiari immagini in input e il formato API scelto. Ad esempio gemini-3.6-flash in questo snapshot dichiara input image per OpenAI Chat; il supporto effettivo dipende dalla scheda del modello e dal formato. Il percorso del file principale è basato sulla pratica comune OpenClaw; la pagina letta menziona anche ~/.openclaw/agents/\<agentId\>/agent/models.json.

[Guida completa →](https://ailoot.ai/docs/it/integrations/openclaw/)[Documentazione dell’applicazione ↗](https://docs.openclaw.ai/gateway/config-tools/custom-providers)

Op

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

Agente nel terminale

OpenAI Chat

Agente open source nel terminale con qualsiasi provider OpenAI compatibile.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/opencode/)

#### Dove configurare

opencode.json (nel progetto o ~/.config/opencode/opencode.json) → provider.\<id\>; chiave tramite /connect oppure "apiKey": "{env:VAR}"

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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"
        }
      }
    }
  }
}
```

La chiave viene letta dalla variabile `AILOOT_API_KEY` — impostala prima dell’avvio:

```bash
export AILOOT_API_KEY="sk-..."   # aggiungi a ~/.zshrc o ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poi riavvia il terminale
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

Il pacchetto @ai-sdk/openai-compatible usa /v1/chat/completions. Per modelli che richiedono /v1/responses, la documentazione opencode indica @ai-sdk/openai. Un provider Anthropic compatibile con baseURL personalizzato non è descritto nella documentazione opencode. Scegli modelli per cui il catalogo attuale dichiari OpenAI Chat. Nello snapshot 2026-09-30 gemini-3.6-flash ha questo formato; per altri Gemini controlla le schede. Il formato nativo Gemini non usa questo percorso. La presenza del metodo nel catalogo non equivale a una prova dal vivo della specifica versione del client.

[Guida completa →](https://ailoot.ai/docs/it/integrations/opencode/)[Documentazione dell’applicazione ↗](https://opencode.ai/docs/providers/)

QC

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

Agente nel terminale

OpenAI ChatAnthropic MessagesGemini

Agente da console del team Qwen: formati OpenAI, Anthropic e Gemini.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/qwen-code/)

#### Dove configurare

Variabili OPENAI\_API\_KEY / OPENAI\_BASE\_URL / OPENAI\_MODEL, comando /auth nella sessione oppure ~/.qwen/settings.json (modelProviders + security.auth.selectedType)

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```bash
export AILOOT_API_KEY="sk-..."
# metodo rapido
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"
  }
}
```

La chiave viene letta dalla variabile `AILOOT_API_KEY` — impostala prima dell’avvio:

```bash
export AILOOT_API_KEY="sk-..."   # aggiungi a ~/.zshrc o ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poi riavvia il terminale
```

Modello di esempio: `qwen3.8-max`

#### Importante

Tipi di protocollo: openai (Chat Completions), anthropic, gemini, vertex-ai. Per openai baseUrl include /v1. L’esempio della documentazione per anthropic e gemini non ha baseUrl, quindi consigliamo openai. Per openai scegli un modello con OpenAI Chat nel catalogo: gemini-3.6-flash lo supporta. Altri Gemini possono avere formati diversi — controlla la scheda del modello specifico. La variante settings.json legge la chiave da AILOOT\_API\_KEY (campo envKey): impostala con export AILOOT\_API\_KEY=sk-... oppure la riga AILOOT\_API\_KEY=sk-... in ~/.qwen/.env; altrimenti Qwen Code parte con chiave vuota e riceve 401.

[Guida completa →](https://ailoot.ai/docs/it/integrations/qwen-code/)[Documentazione dell’applicazione ↗](https://qwenlm.github.io/qwen-code-docs/en/users/configuration/auth/)

GC

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

Agente nel terminale

Gemini

Agente Google nel terminale con formato nativo Gemini.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/gemini-cli/)

#### Dove configurare

Variabili d’ambiente GEMINI\_API\_KEY e GOOGLE\_GEMINI\_BASE\_URL; modalità di accesso — ~/.gemini/settings.json → security.auth.selectedType = "gemini-api-key"; modello — GEMINI\_MODEL o flag -m

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1beta/models/{model}:generateContent e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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"
    }
  }
}
```

Modello di esempio: `gemini-3.8-flash`

#### Importante

Indirizzo senza /v1beta: l’SDK aggiunge automaticamente /v1beta/models/{model}:generateContent. L’indirizzo deve utilizzare HTTPS. La chiave viene inviata nell’header x-goog-api-key, che Ailoot accetta. Sono adatti solo i modelli per cui il catalogo indica il formato Gemini. Prima dell’esecuzione, verifica che l’ID esatto e questo metodo siano disponibili per la tua chiave. Ailoot restituisce la risposta Gemini a pagamento per intero dopo il calcolo del costo, non parola per parola; per questo, nelle risposte lunghe il testo non compare subito.

[Guida completa →](https://ailoot.ai/docs/it/integrations/gemini-cli/)[Documentazione dell’applicazione ↗](https://geminicli.com/docs/reference/configuration/)

KC

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

Agente nel terminale

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Agente da console Moonshot per lavorare sul codice.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/kimi-cli/)

#### Dove configurare

~/.kimi/config.toml (sezioni providers e models, default\_model); /login supporta solo le piattaforme Moonshot — l’indirizzo personalizzato si imposta manualmente nel file

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

`~/.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"]
```

Modello di esempio: `kimi-k3`

#### Importante

Tipi: openai\_legacy (Chat Completions, base\_url con /v1), openai\_responses (Responses, con /v1), anthropic (senza /v1), gemini (base\_url è la radice Google, per noi https://api.ailoot.ai). SearchWeb funziona solo con la piattaforma propria di Moonshot; FetchURL con un altro indirizzo API passa al download locale.

[Guida completa →](https://ailoot.ai/docs/it/integrations/kimi-cli/)[Documentazione dell’applicazione ↗](https://moonshotai.github.io/kimi-cli/en/configuration/providers.html)

Cr

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

Agente nel terminale

OpenAI ChatAnthropic Messages

Agente nel terminale di Charm, configurato nel file crushrc.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/crush/)

#### Dove configurare

crushrc (config Bash): ./.crushrc, ./crushrc oppure ~/.config/crush/crushrc; il vecchio formato crush.json è obsoleto, ma funziona

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

`~/.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 per Claude: indirizzo senza /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
```

La chiave viene letta dalla variabile `AILOOT_API_KEY` — impostala prima dell’avvio:

```bash
export AILOOT_API_KEY="sk-..."   # aggiungi a ~/.zshrc o ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poi riavvia il terminale
```

Modello di esempio: `deepseek-v4-pro`

#### Importante

Il tipo openai-compat usa OpenAI Chat con indirizzo che include /v1. Il tipo anthropic usa Messages con indirizzo senza /v1: Crush lo passa ad anthropic-sdk-go, che aggiunge da solo /v1/messages. L’esempio nel README Crush con /v1 produrrebbe /v1/v1/messages e un errore 404. La chiave viene inviata nell’header x-api-key, accettato da Ailoot. Se l’elenco dei modelli è vuoto, il provider openai-compat lo recupera da /v1/models. crushrc viene eseguito come codice: non avviare Crush in cartelle altrui con questo file. Nell’esempio Claude ha supports-images = false: lo snapshot del catalogo 2026-09-30 dichiara solo testo per il formato Messages selezionato. Se la tua versione Crush supporta questo flag, attivalo solo per un modello la cui scheda attuale dichiari input image nel formato API scelto; il flag del client non aggiunge da solo il supporto delle immagini al modello.

[Guida completa →](https://ailoot.ai/docs/it/integrations/crush/)[Documentazione dell’applicazione ↗](https://github.com/charmbracelet/crush#custom-providers)

Ai

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

Agente nel terminale

OpenAI Chat

Programmazione in coppia con l’IA direttamente nel repository git.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/aider/)

#### Dove configurare

Variabili OPENAI\_API\_BASE e OPENAI\_API\_KEY, flag --model openai/\<modello\>

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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
```

Modello di esempio: `openai/deepseek-v4-pro`

#### Importante

Il prefisso openai/ è obbligatorio: così Aider (tramite LiteLLM) invia richieste al percorso OpenAI compatibile /v1/chat/completions. Per i modelli sconosciuti ad Aider avvisa che il contesto è ignoto — non è un errore. Un indirizzo Anthropic con base URL personalizzato non è descritto in questa pagina di documentazione.

[Guida completa →](https://ailoot.ai/docs/it/integrations/aider/)[Documentazione dell’applicazione ↗](https://aider.chat/docs/llms/openai-compat.html)

Go

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

Agente nel terminale

OpenAI ChatAnthropic Messages

Agente open source per terminale e desktop con estensioni MCP.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/goose/)

#### Dove configurare

goose configure → Custom Providers → Add A Custom Provider, oppure JSON in ~/.config/goose/custom\_providers/ (Windows: %APPDATA%\\Block\\goose\\config\\custom\_providers\\); alternativa — provider OpenAI integrato con OPENAI\_HOST/OPENAI\_BASE\_PATH

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

`~/.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 con il provider OpenAI integrato:
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"
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

Motori del provider personalizzato: openai, anthropic, ollama. Nell’esempio Goose base\_url per engine openai è il percorso completo fino a /v1/chat/completions. Per il provider integrato OPENAI\_HOST è la radice senza percorso, OPENAI\_BASE\_PATH è il percorso (predefinito v1/chat/completions). Goose ignora la chiave in config.yaml — solo variabile o portachiavi. Il repository è stato trasferito a aaif-goose/goose.

[Guida completa →](https://ailoot.ai/docs/it/integrations/goose/)[Documentazione dell’applicazione ↗](https://github.com/aaif-goose/goose/blob/main/documentation/docs/getting-started/providers.md)

FD

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

Agente nel terminale

OpenAI ChatOpenAI ResponsesAnthropic Messages

Agente Factory per il terminale con modelli personalizzati.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/factory-droid/)

#### Dove configurare

~/.factory/settings.json → array customModels; selezione del modello — comando /model, sezione «Custom models»

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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
    }
  ]
}
```

La chiave viene letta dalla variabile `AILOOT_API_KEY` — impostala prima dell’avvio:

```bash
export AILOOT_API_KEY="sk-..."   # aggiungi a ~/.zshrc o ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poi riavvia il terminale
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

provider: anthropic = Messages API (baseUrl come Anthropic, senza /v1), openai = Responses API (con /v1), generic-chat-completion-api = Chat Completions (con /v1). Per anthropic la chiave viene inviata per impostazione predefinita in x-api-key (accettato da Ailoot); "authMode": "bearer" passa ad Authorization. Le chiavi restano locali. Factory testa completamente solo le API ufficiali Anthropic e OpenAI.

[Guida completa →](https://ailoot.ai/docs/it/integrations/factory-droid/)[Documentazione dell’applicazione ↗](https://docs.factory.com/model-independence/byok)

Am

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

Agente nel terminale

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Agente di coding Amp con instradamento flessibile dei modelli.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/amp/)

#### Dove configurare

Impostazioni → Model Routing → Add → Custom URL (oppure Model Routing del workspace per il team); dal terminale — amp config model-providers (list, test, set-priority, edit-router…)

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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

Seconda connessione per 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: amp config model-providers check-access --provider-model anthropic/claude-fable-5
```

Modello di esempio: `claude-fable-5`

#### Importante

Formati Custom URL: chat-completions (\<base\>/chat/completions), responses (\<base\>/responses), anthropic-messages (\<base\>/v1/messages, /v1 non viene duplicato), google-genai (\<base\>/models/\<model\>:streamGenerateContent). La chiave viene inviata come Authorization: Bearer. La mappatura usa gli ID canonici Amp nel formato provider/model; la freccia definisce l’ID inviato a noi. I modelli non coperti dalla connessione sono gestiti direttamente da Amp usando i suoi crediti. La documentazione richiede che l’host personalizzato sia raggiungibile da Amp — l’indirizzo è pubblico, quindi il requisito è soddisfatto.

[Guida completa →](https://ailoot.ai/docs/it/integrations/amp/)[Documentazione dell’applicazione ↗](https://ampcode.com/docs/markdown/customize/model-routing)

AI

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

Agente nel terminale

OpenAI ChatAnthropic MessagesGemini

Chat versatile nel terminale con ruoli, sessioni e RAG.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/aichat/)

#### Dove configurare

config.yaml di AIChat → clients (tipi openai-compatible, claude, gemini); modello — -m \<client\>:\<model\>

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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 'Ciao'
```

Modello di esempio: `deepseek-v4-pro`

#### Importante

Nell’esempio di configurazione AIChat api\_base per claude è indicato con /v1, per gemini con /v1beta; vale anche per Ailoot. I tre client danno accesso a tutti e tre i formati Ailoot: OpenAI, Anthropic e Gemini.

[Guida completa →](https://ailoot.ai/docs/it/integrations/aichat/)[Documentazione dell’applicazione ↗](https://github.com/sigoden/aichat/blob/main/config.example.yaml)

CC

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

Agente nel terminale

OpenAI Chat

Versione da console di Continue per agenti e automazione.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/continue-cli/)

#### Dove configurare

Config YAML di Continue (config.yaml), passato alla CLI con il flag --config \<path\>

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

`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-...

# avvio:
cn --config ./ailoot.yaml
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

Per servizi OpenAI compatibili Continue usa provider: openai e apiBase con /v1. Il formato di configurazione è comune a estensione e CLI; il file si passa con --config.

[Guida completa →](https://ailoot.ai/docs/it/integrations/continue-cli/)[Documentazione dell’applicazione ↗](https://docs.continue.dev/customize/model-providers/top-level/openai)

Fo

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

Agente nel terminale

OpenAI Chat

Agente nel terminale con provider configurabili.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/forge/)

#### Dove configurare

forge provider login → OpenAI-compatible (percorso consigliato); percorso obsoleto — .env con OPENAI\_URL e OPENAI\_API\_KEY più model in forge.yaml

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```bash
# consigliato:
forge provider login   # seleziona OpenAI-compatible e inserisci https://api.ailoot.ai/v1 e sk-...

# metodo obsoleto (.env):
OPENAI_API_KEY=sk-...
OPENAI_URL=https://api.ailoot.ai/v1

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

Modello di esempio: `claude-sonnet-5-5`

#### Importante

La configurazione tramite .env è indicata come obsoleta: al primo avvio Forge trasferisce le variabili nel proprio archivio su file. Il README non riporta le etichette esatte della procedura provider login.

[Guida completa →](https://ailoot.ai/docs/it/integrations/forge/)[Documentazione dell’applicazione ↗](https://github.com/tailcallhq/forgecode)

GC

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

Agente nel terminale

OpenAI ChatAnthropic Messages

Copilot nel terminale con modelli personalizzati.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/github-copilot-cli/)

#### Dove configurare

Variabili d’ambiente COPILOT\_PROVIDER\_BASE\_URL, COPILOT\_PROVIDER\_TYPE, COPILOT\_PROVIDER\_API\_KEY, COPILOT\_MODEL (o flag --model)

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```bash
export AILOOT_API_KEY="sk-..."
unset COPILOT_PROVIDER_TYPE
# modalità compatibile con 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

# modalità 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
```

Modello di esempio: `gpt-6.1-sol`

#### Importante

Tipi: openai (predefinito, qualsiasi server OpenAI compatibile), azure, anthropic. Il modello deve supportare chiamate agli strumenti e streaming. COPILOT\_PROVIDER\_WIRE\_API sceglie il protocollo, ma i suoi valori non sono elencati nella pagina. Puoi impostare i limiti con COPILOT\_PROVIDER\_MAX\_PROMPT\_TOKENS / MAX\_OUTPUT\_TOKENS.

[Guida completa →](https://ailoot.ai/docs/it/integrations/github-copilot-cli/)[Documentazione dell’applicazione ↗](https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/use-byok-models)

Gp

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

Agente nel terminale

OpenAI Chat

Agente personale nel terminale: codice, file e browser.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/gptme/)

#### Dove configurare

~/.config/gptme/config.toml → \[\[providers\]\]; il modello si sceglie come \<provider\>/\<model\>

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

`~/.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 'ciao' -m ailoot/claude-sonnet-5-5
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

Qualsiasi server OpenAI compatibile; la chiave viene cercata in api\_key, poi api\_key\_env, poi \<NAME\>\_API\_KEY. Elenco dei provider — gptme-util providers list.

[Guida completa →](https://ailoot.ai/docs/it/integrations/gptme/)[Documentazione dell’applicazione ↗](https://github.com/gptme/gptme/blob/master/docs/providers-custom.rst)

KC

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

Agente nel terminale

OpenAI ChatOpenAI ResponsesAnthropic Messages

Agente da console Kilo Code.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/kilo-code-cli/)

#### Dove configurare

~/.config/kilo/kilo.jsonc (oppure ./kilo.jsonc; anche KILO\_CONFIG) → provider.\<id\>.options.baseURL; nell’estensione — Settings → Providers → Custom provider

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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
          }
        }
      }
    }
  }
}
```

La chiave viene letta dalla variabile `AILOOT_API_KEY` — impostala prima dell’avvio:

```bash
export AILOOT_API_KEY="sk-..."   # aggiungi a ~/.zshrc o ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poi riavvia il terminale
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

La finestra Custom provider permette di scegliere il protocollo: OpenAI Compatible (Chat Completions), OpenAI Responses, Anthropic Messages. {env:VAR} funziona solo nella configurazione globale attendibile (~/.config/kilo); nel kilo.json del progetto la chiave non viene inserita dalla variabile.

[Guida completa →](https://ailoot.ai/docs/it/integrations/kilo-code-cli/)[Documentazione dell’applicazione ↗](https://kilo.ai/docs/code-with-ai/agents/custom-models)

LL

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

Agente nel terminale

OpenAI ChatOpenAI Responses

Utilità per richieste ai modelli dalla riga di comando.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/llm-cli/)

#### Dove configurare

File extra-openai-models.yaml nella cartella delle impostazioni llm; chiave — llm keys set \<nome\>

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

`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 'Ciao'
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

Per impostazione predefinita Chat Completions; responses: true porta il modello su /responses. Se api\_base è impostato, la chiave OpenAI non viene inviata — serve api\_key\_name. È un’utilità CLI per richieste, non un agente.

[Guida completa →](https://ailoot.ai/docs/it/integrations/llm-cli/)[Documentazione dell’applicazione ↗](https://llm.datasette.io/en/stable/other-models.html)

MS

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

Agente nel terminale

OpenAI Chat

Agente minimalista per attività nel repository.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/mini-swe-agent/)

#### Dove configurare

Config YAML dell’agente → sezione model (model\_name, model\_kwargs); il percorso predefinito del config si modifica con MSWEA\_MINI\_CONFIG\_PATH

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```yaml
# frammento della configurazione dell'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"
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

Usa LiteLLM: model\_kwargs viene passato direttamente a litellm.completion. Senza il registro prezzi LiteLLM segnala un costo sconosciuto — disabilitiamo con cost\_tracking: "ignore\_errors" (oppure MSWEA\_COST\_TRACKING=ignore\_errors). Trasmettere la chiave tramite OPENAI\_API\_KEY è uno standard LiteLLM, non mostrato nella pagina mini-SWE-agent.

[Guida completa →](https://ailoot.ai/docs/it/integrations/mini-swe-agent/)[Documentazione dell’applicazione ↗](https://github.com/SWE-agent/mini-swe-agent/blob/main/docs/models/local_models.md)

OC

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

Agente nel terminale

OpenAI Chat

Agente autonomo per sviluppo da riga di comando.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/openhands-cli/)

#### Dove configurare

Ctrl+P → Settings (provider e modello), file ~/.openhands/agent\_settings.json (llm.model / llm.api\_key / llm.base\_url) oppure variabili LLM\_MODEL, LLM\_API\_KEY, LLM\_BASE\_URL con --override-with-envs

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

`~/.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-..."
# una tantum tramite le variabili d'ambiente:
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
```

Modello di esempio: `openai/claude-sonnet-5-5`

#### Importante

OpenHands usa LiteLLM; per un proxy OpenAI la documentazione richiede Custom Model nel formato openai/\<modello\> e Base URL del proxy. Le modifiche tramite --override-with-envs non vengono salvate. Nell’interfaccia web: Settings → LLM → Advanced → Custom Model, Base URL, API Key.

[Guida completa →](https://ailoot.ai/docs/it/integrations/openhands-cli/)[Documentazione dell’applicazione ↗](https://docs.openhands.dev/openhands/usage/cli/command-reference)

Pi

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

Agente nel terminale

OpenAI ChatAnthropic MessagesGemini

Agente di coding minimalista per il terminale.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/pi/)

#### Dove configurare

~/.pi/agent/models.json (oppure .pi/models.json del progetto dopo averlo considerato attendibile); scelta — /model

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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"
        }
      ]
    }
  }
}
```

La chiave viene letta dalla variabile `AILOOT_API_KEY` — impostala prima dell’avvio:

```bash
export AILOOT_API_KEY="sk-..."   # aggiungi a ~/.zshrc o ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poi riavvia il terminale
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

La documentazione Pi permette esplicitamente endpoint OpenAI, Anthropic e Google compatibili tramite models.json; l’esempio usa api: openai-completions. apiKey comprende $NAME/${NAME}, un valore letterale o !comando. Il file viene riletto quando si apre /model.

[Guida completa →](https://ailoot.ai/docs/it/integrations/pi/)[Documentazione dell’applicazione ↗](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/models.md)

Pl

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

Agente nel terminale

OpenAI Chat

Agente per attività complesse: piano, modifiche in sandbox, applicazione.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/plandex/)

#### Dove configurare

plandex models custom (oppure \\models custom nel REPL) — apre il file JSON dei modelli e provider personalizzati

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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"
        }
      ]
    }
  ]
}
```

La chiave viene letta dalla variabile `AILOOT_API_KEY` — impostala prima dell’avvio:

```bash
export AILOOT_API_KEY="sk-..."   # aggiungi a ~/.zshrc o ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poi riavvia il terminale
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

I provider personalizzati funzionano solo in Plandex self-hosted; nel cloud con chiavi BYO sono ammessi solo provider integrati. Tutti i provider personalizzati devono essere OpenAI compatibili (Chat Completions). Il modello viene poi attivato nel proprio model pack.

[Guida completa →](https://ailoot.ai/docs/it/integrations/plandex/)[Documentazione dell’applicazione ↗](https://github.com/plandex-ai/plandex/blob/main/docs/docs/models/custom-models.md)

TA

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

Agente nel terminale

OpenAI ChatAnthropic Messages

Agente di ricerca ByteDance per attività di sviluppo.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/trae-agent/)

#### Dove configurare

trae\_config.yaml → model\_providers.\<nome\>.base\_url; alternativa — variabili OPENAI\_BASE\_URL / ANTHROPIC\_BASE\_URL in .env

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

`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
```

Modello di esempio: `gpt-6.1-sol`

#### Importante

In YAML usa solo spazi, niente tabulazioni. Per Anthropic — provider: anthropic e ANTHROPIC\_BASE\_URL (il README non specifica esattamente se anthropic richiede /v1; usa https://api.ailoot.ai).

[Guida completa →](https://ailoot.ai/docs/it/integrations/trae-agent/)[Documentazione dell’applicazione ↗](https://github.com/bytedance/trae-agent#using-base-url)

Wa

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

Agente nel terminale

OpenAI Chat

Terminale con agente integrato e indirizzo del modello personalizzato.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/warp/)

#### Dove configurare

Settings → cerca «inference endpoint» → Custom inference endpoint: URL di base, chiave, ID dei modelli; poi scegli il modello nel selettore

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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
Poi seleziona, per esempio, claude-sonnet-5-5 nell’elenco dei modelli (non Auto).
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

Solo OpenAI Chat Completions (POST /v1/chat/completions). Le richieste passano dai server Warp: la chiave è conservata localmente, ma trasmessa al backend Warp in ogni richiesta. Auto e router personalizzati consumano sempre crediti Warp; gli agenti cloud non usano questo endpoint. Disponibile nei piani Free e a pagamento per persone e team fino a 10 membri. Scegli modelli per cui il catalogo attuale dichiari OpenAI Chat. Nello snapshot 2026-09-30 gemini-3.6-flash ha questo formato; per altri Gemini controlla le schede. Il formato nativo Gemini non usa questo percorso. La presenza del metodo nel catalogo non equivale a una prova dal vivo della specifica versione del client.

[Guida completa →](https://ailoot.ai/docs/it/integrations/warp/)[Documentazione dell’applicazione ↗](https://docs.warp.dev/agents/inference/custom-inference-endpoint/)

## Editor e IDE

Estensioni e assistenti integrati negli editor di codice.

Cl

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

Estensione dell’editor

OpenAI ChatAnthropic Messages

Agente autonomo in VS Code e JetBrains: piano, modifiche e comandi.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/cline/)

#### Dove configurare

Pannello Cline → ingranaggio (Settings) → API Provider = «OpenAI Compatible» → campi Base URL, API Key, Model ID. Seconda opzione: API Provider = «Anthropic» → seleziona «Use custom base URL».

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```text
OpenAI Compatible (consigliato):
  API Provider: OpenAI Compatible
  Base URL:     https://api.ailoot.ai/v1
  API Key:      sk-...
  Model ID:     claude-sonnet-5-5   (oppure gpt-6.1-sol, deepseek-v4-pro, qwen3.8-max)
  Model Configuration: Context Window e Max Output Tokens — in base al modello; Image Support — solo per i modelli che comprendono le immagini.

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

Modello di esempio: `claude-sonnet-5-5`

#### Importante

OpenAI Compatible usa /v1/chat/completions, quindi l’indirizzo include /v1. L’opzione Anthropic usa /v1/messages con indirizzo senza /v1, ma nel suo elenco dei modelli compaiono solo nomi Anthropic — gli altri modelli Ailoot sono disponibili tramite OpenAI Compatible. La modalità agente richiede un modello con chiamate agli strumenti. I modelli Gemini 3.1 Pro non sono disponibili tramite chat/completions (hanno solo i formati Gemini e Anthropic) — qui usa gemini-3.6-flash.

[Guida completa →](https://ailoot.ai/docs/it/integrations/cline/)[Documentazione dell’applicazione ↗](https://docs.cline.bot/provider-config/openai-compatible)

RC

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

Estensione dell’editor

OpenAI ChatAnthropic Messages

Agente in VS Code con modalità per codice, architettura e debug.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/roo-code/)

#### Dove configurare

Pannello Roo Code → ingranaggio → API Provider = «OpenAI Compatible» → Base URL, API Key, Model; opzionalmente Model Configuration (Max Output Tokens, Context Window, Image Support, Computer Use, prezzi). Il provider Anthropic ha la casella «Use custom base URL».

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

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

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

Modello di esempio: `gpt-6.1-sol`

#### Importante

Roo Code chiama gli strumenti solo nel formato OpenAI, quindi il modello deve supportare tools in /v1/chat/completions. L’opzione Anthropic usa /v1/messages con indirizzo senza /v1.

[Guida completa →](https://ailoot.ai/docs/it/integrations/roo-code/)[Documentazione dell’applicazione ↗](https://roocodeinc.github.io/Roo-Code/providers/openai-compatible/)

KC

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

Estensione dell’editor

OpenAI Chat

Agente in VS Code con modalità e modelli personalizzati.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/kilo-code/)

#### Dove configurare

Settings (ingranaggio) → scheda Providers → in basso «Custom provider» → Provider ID, Display name, Provider API = «OpenAI Compatible», Base URL, API key, Models (elenco recuperato da /v1/models). Le impostazioni sono salvate in kilo.json.

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```text
Provider ID:   ailoot
Display name:  Ailoot
Provider API:  OpenAI Compatible
Base URL:      https://api.ailoot.ai/v1
API key:       sk-...
Models:        seleziona dall’elenco, per esempio claude-sonnet-5-5, gpt-6.1-sol, deepseek-v4-pro
```

Modello di esempio: `deepseek-v4-pro`

#### Importante

Kilo richiede {Base URL}/models e mostra da solo l’elenco dei modelli — il nostro GET /v1/models restituisce l’intero catalogo. Puoi anche specificare l’indirizzo completo .../v1/chat/completions. Sono supportati header personalizzati.

[Guida completa →](https://ailoot.ai/docs/it/integrations/kilo-code/)[Documentazione dell’applicazione ↗](https://kilo.ai/docs/ai-providers/openai-compatible)

Co

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

Estensione dell’editor

OpenAI Chat

Assistente per VS Code e JetBrains: chat, modifiche e agente.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/continue/)

#### Dove configurare

File ~/.continue/config.yaml (oppure editor di configurazione Continue): voce in models\[\] con provider: openai e apiBase.

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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   # solo se occorre forzare l'uso di /chat/completions
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

apiBase deve terminare con /v1. Per nomi delle serie gpt-5/o Continue può scegliere da solo /v1/responses; i nostri gpt-\* supportano sia /v1/responses sia /v1/chat/completions, mentre useResponsesApi: false forza chat/completions. useLegacyCompletionsEndpoint non serve.

[Guida completa →](https://ailoot.ai/docs/it/integrations/continue/)[Documentazione dell’applicazione ↗](https://docs.continue.dev/customize/model-providers/top-level/openai)

Ze

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

Editor di codice

OpenAI ChatOpenAI ResponsesAnthropic Messages

Editor di codice veloce con agente integrato.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/zed/)

#### Dove configurare

Agent Settings (agent::OpenSettings) → LLM Providers → Add Provider; oppure settings.json → language\_models.openai\_compatible / language\_models.anthropic\_compatible. La chiave è nella finestra delle impostazioni (conservata nel portachiavi di sistema) o nella variabile \<ID DEL PROVIDER IN MAIUSCOLO\>\_API\_KEY.

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

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

Modello di esempio: `gpt-6.1-sol`

#### Importante

Per openai\_compatible indirizzo con /v1 (usa /v1/chat/completions; capabilities.chat\_completions = false passa il modello a /v1/responses). Per anthropic\_compatible indirizzo senza /v1 (usa /v1/messages; Zed invia la chiave in x-api-key — Ailoot lo accetta). Per impostazione predefinita images = false e parallel\_tool\_calls = false. Zed può trasmettere immagini, ma attiva images solo per un modello specifico la cui scheda attuale dichiari input image nel formato API scelto. Negli esempi GPT e Claude images = false: lo snapshot 2026-09-30 dichiara solo testo per questi modelli. Ad esempio gemini-3.6-flash nello snapshot dichiara input image per OpenAI Chat; il supporto effettivo dipende dalla scheda e dal formato. Per modelli di ragionamento c’è reasoning\_effort. I valori max\_tokens dell’esempio sono la dimensione del contesto; consulta i limiti esatti nel catalogo dei modelli.

[Guida completa →](https://ailoot.ai/docs/it/integrations/zed/)[Documentazione dell’applicazione ↗](https://zed.dev/docs/ai/use-api-access)

VC

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

Estensione dell’editor

OpenAI ChatOpenAI ResponsesAnthropic Messages

Provider personalizzato in Copilot Chat per VS Code.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/vscode-copilot-byok/)

#### Dove configurare

Selezione del modello nella chat → Manage Language Models (ingranaggio) → Add Models → Custom Endpoint → VS Code apre chatLanguageModels.json. (La vecchia impostazione github.copilot.chat.customOAIModels è obsoleta.)

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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
      }
    ]
  }
]
```

Modello di esempio: `gpt-6.1-sol`

#### Importante

url è il percorso COMPLETO dell’endpoint. Valori apiType: chat-completions, responses (url .../v1/responses), messages (url .../v1/messages). BYOK funziona senza un piano Copilot o accesso GitHub, ma solo per chat/agente — i suggerimenti inline restano su Copilot. Gli amministratori delle organizzazioni (Business/Enterprise) possono disabilitare la policy BYOK. I limiti dei token sopra sono esempi: usa i valori del catalogo. In questi esempi vision = false: lo snapshot del catalogo 2026-09-30 dichiara solo testo per GPT/OpenAI Chat e Claude/Anthropic Messages. Se la tua versione VS Code offre vision, attivalo solo per un modello la cui scheda attuale dichiari input image nel formato API scelto; la presenza del campo nel client non conferma il supporto delle immagini nel modello scelto.

[Guida completa →](https://ailoot.ai/docs/it/integrations/vscode-copilot-byok/)[Documentazione dell’applicazione ↗](https://code.visualstudio.com/docs/agent-customization/language-models)

JA

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

Editor di codice

OpenAI Chat

Assistente integrato negli IDE JetBrains con la propria chiave.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/jetbrains-ai-assistant/)

#### Dove configurare

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

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

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

Modello di esempio: `claude-sonnet-5-5`

#### Importante

Seleziona OpenAI-compatible, inserisci https://api.ailoot.ai/v1 in URL e la tua API Key. Premi Test Connection, poi Apply e scegli un modello in AI Chat. Assegnalo alle funzioni dell’IDE in Models Assignment. Attiva Tool calling solo se il modello supporta gli strumenti; il completamento del codice si configura separatamente.

[Guida completa →](https://ailoot.ai/docs/it/integrations/jetbrains-ai-assistant/)[Documentazione dell’applicazione ↗](https://www.jetbrains.com/help/ai-assistant/use-custom-models.html)

Xc

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

Editor di codice

OpenAI Chat

Coding Intelligence in Xcode con provider esterno.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/xcode/)

#### Dove configurare

Xcode → Settings → Intelligence → Chat → Add a Chat Provider → Internet Hosted → URL, API Key, API Key Header, descrizione → Add.

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```text
Type:           Internet Hosted
URL:            https://api.ailoot.ai        (SENZA /v1 — Xcode aggiunge autonomamente /v1/models e /v1/chat/completions)
API Key:        sk-...
API Key Header: x-api-key
Description:    Ailoot
→ poi seleziona i modelli dall’elenco (per esempio claude-sonnet-5-5, gpt-6.1-sol)
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

Apple richiede che il provider supporti Chat Completions e risponda a {URL}/v1/models e {URL}/v1/chat/completions. Ailoot accetta la chiave in x-api-key e in Authorization: Bearer (se scegli Authorization, secondo le segnalazioni Xcode aggiunge da solo il prefisso Bearer). Gli agenti Xcode si configurano separatamente e non rientrano in questa istruzione.

[Guida completa →](https://ailoot.ai/docs/it/integrations/xcode/)[Documentazione dell’applicazione ↗](https://developer.apple.com/documentation/xcode/setting-up-coding-intelligence)

AN

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

Plugin Neovim

OpenAI ChatAnthropic Messages

Plugin Neovim: chat e modifiche direttamente nel buffer.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/avante-nvim/)

#### Dove configurare

opts per yetone/avante.nvim in lazy.nvim: opts.providers.\<nome\> con \_\_inherited\_from = 'openai' (provider OpenAI compatibile personalizzato) oppure override di providers.claude.endpoint; chiave dalla variabile indicata in api\_key\_name (nomi AVANTE\_\* supportati).

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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, senza /v1
      model = "claude-sonnet-5-5",
    },
  },
}
-- nel terminale: export AILOOT_API_KEY=sk-...
-- il provider claude legge AVANTE_ANTHROPIC_API_KEY o ANTHROPIC_API_KEY
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

Nella wiki del plugin l’indirizzo OpenAI compatibile termina con /v1 (il plugin aggiunge /chat/completions). Il provider integrato claude usa un indirizzo come https://api.anthropic.com, quindi per Ailoot senza /v1. I provider personalizzati senza \_\_inherited\_from richiedono un indirizzo completo e proprie funzioni per interpretare la risposta.

[Guida completa →](https://ailoot.ai/docs/it/integrations/avante-nvim/)[Documentazione dell’applicazione ↗](https://github.com/avante-corp/avante.nvim/wiki/Custom-providers)

CN

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

Plugin Neovim

OpenAI ChatAnthropic Messages

Chat e modifiche inline in Neovim.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/codecompanion-nvim/)

#### Dove configurare

require('codecompanion').setup({ adapters = { http = { ... } } }) tramite adapters.extend('openai\_compatible', ...) oppure extend('anthropic', ...); poi interactions.chat/inline.adapter.

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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 della variabile d'ambiente che contiene sk-...
            chat_url = "/v1/chat/completions",
          },
          schema = { model = { default = "gpt-6.1-sol" } },
        })
      end,
    },
  },
  interactions = {
    chat = { adapter = "ailoot" },
    inline = { adapter = "ailoot" },
  },
})
```

La chiave viene letta dalla variabile `AILOOT_API_KEY` — impostala prima dell’avvio:

```bash
export AILOOT_API_KEY="sk-..."   # aggiungi a ~/.zshrc o ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poi riavvia il terminale
```

Modello di esempio: `gpt-6.1-sol`

#### Importante

openai\_compatible separa host (env.url, senza /v1) e percorso (env.chat\_url). I valori env possono essere nomi di variabili d’ambiente, cmd:..., file:... o funzioni Lua. Anche l’adapter anthropic può essere esteso con un url personalizzato per /v1/messages.

[Guida completa →](https://ailoot.ai/docs/it/integrations/codecompanion-nvim/)[Documentazione dell’applicazione ↗](https://codecompanion.olimorris.dev/configuration/adapters-http)

Gp

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

Pacchetto Emacs

OpenAI ChatAnthropic MessagesGemini

Client semplice per modelli linguistici in Emacs.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/gptel/)

#### Dove configurare

init.el: registra il backend tramite gptel-make-openai (OpenAI Chat), gptel-make-anthropic (Messages) o gptel-make-gemini — ciascuno ha :host, :endpoint, :key, :stream, :models; poi imposta gptel-backend e gptel-model.

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages, POST /v1beta/models/{model}:generateContent e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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")               ; oppure (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"          ; percorso predefinito /v1/messages
  :stream t
  :key (getenv "AILOOT_API_KEY")
  :models '(claude-sonnet-5-5 claude-opus-5-5))
```

La chiave viene letta dalla variabile `AILOOT_API_KEY` — impostala prima dell’avvio:

```bash
export AILOOT_API_KEY="sk-..."   # aggiungi a ~/.zshrc o ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poi riavvia il terminale
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

:host — solo il nome host (senza https:// e percorso); il percorso si imposta in :endpoint. gptel-make-anthropic invia gli header x-api-key e anthropic-version — Ailoot li accetta.

[Guida completa →](https://ailoot.ai/docs/it/integrations/gptel/)[Documentazione dell’applicazione ↗](https://github.com/karthink/gptel)

TI

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

Editor di codice

OpenAI Chat

IDE open source con modulo Theia AI.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/theia/)

#### Dove configurare

Preferences → AI-features → OpenAiCustom (oppure chiave ai-features.openAiCustom.customOpenAiModels in settings.json; finestra AI Configuration — Alt+A).

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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"
    }
  ]
}
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

url è l’indirizzo di base e termina con /v1. Per i modelli non OpenAI la scelta sicura è developerMessageSettings: "system".

[Guida completa →](https://ailoot.ai/docs/it/integrations/theia/)[Documentazione dell’applicazione ↗](https://theia-ide.org/docs/user_ai/)

TI

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

Editor di codice

OpenAI ChatAnthropic Messages

Editor di codice Trae con modelli personalizzati.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/trae/)

#### Dove configurare

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

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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-...
```

Modello di esempio: `gpt-6.1-sol`

#### Importante

Con Full URL disattivato Trae aggiunge da solo il percorso del formato scelto (OpenAI: indirizzo con /v1, Anthropic: senza /v1). Con Full URL attivato inserisci https://api.ailoot.ai/v1/chat/completions oppure https://api.ailoot.ai/v1/messages. Model Series adatta le indicazioni alla famiglia del modello.

[Guida completa →](https://ailoot.ai/docs/it/integrations/trae/)[Documentazione dell’applicazione ↗](https://docs.trae.ai/ide/models)

## Applicazioni di chat

Chat per computer, telefono e browser, note e launcher.

OW

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

Chat web, server proprio

OpenAI Chat

Chat web popolare su server proprio.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/open-webui/)

#### Dove configurare

Settings \> Admin \> Connections \> Manage OpenAI API Connections \> + Add Connection (oppure env OPENAI\_API\_BASE\_URL / OPENAI\_API\_KEY all’avvio del container)

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```text
UI: URL = https://api.ailoot.ai/v1
API Key = sk-...
Model IDs: vuoto (vengono recuperati da /v1/models) oppure aggiungi manualmente claude-sonnet-5-5, gpt-6.1-sol

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

Modello di esempio: `claude-sonnet-5-5`

#### Importante

Formato OpenAI Chat Completions; URL obbligatoriamente con /v1 e senza barra finale. L’elenco dei modelli viene recuperato da /v1/models; con un catalogo ampio (252 modelli) conviene limitare Model IDs e attivare la cache dell’elenco (Cache Base Model List / ENABLE\_BASE\_MODELS\_CACHE=True). Per gli embedding RAG esistono RAG\_OPENAI\_API\_BASE\_URL separati.

[Guida completa →](https://ailoot.ai/docs/it/integrations/open-webui/)[Documentazione dell’applicazione ↗](https://docs.openwebui.com/getting-started/quick-start/connect-a-provider/starting-with-openai-compatible/)

Li

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

Chat web, server proprio

OpenAI ChatAnthropic Messages

Chat web su server proprio con agenti e più provider.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/librechat/)

#### Dove configurare

File librechat.yaml → endpoints.custom (chiave in .env tramite ${VAR}); per il formato Anthropic campo provider: 'anthropic'

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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-...
```

Modello di esempio: `gpt-6.1-sol`

#### Importante

Un normale custom endpoint = OpenAI Chat Completions (baseURL con /v1). provider: 'anthropic' attiva il client nativo /v1/messages; nell’esempio della documentazione baseURL Anthropic è senza /v1 (https://api.anthropic.com), quindi per noi https://api.ailoot.ai. fetch: true recupera l’elenco da /v1/models.

[Guida completa →](https://ailoot.ai/docs/it/integrations/librechat/)[Documentazione dell’applicazione ↗](https://www.librechat.ai/docs/configuration/librechat_yaml/object_structure/custom_endpoint)

CS

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

Applicazione desktop

OpenAI ChatOpenAI ResponsesAnthropic Messages

Client desktop con assistenti e base di conoscenza.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/cherry-studio/)

#### Dove configurare

Settings (ingranaggio) \> Model Provider \> + Add Provider \> tipo di protocollo OpenAI / OpenAI Responses / Anthropic / Gemini

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```text
Provider Name: Ailoot
Tipo: OpenAI (oppure OpenAI Responses / Anthropic)
API Key: sk-...
Base URL: https://api.ailoot.ai
→ Controlla l’anteprima dell’indirizzo finale sotto il campo: deve risultare https://api.ailoot.ai/v1/chat/completions (per Anthropic — https://api.ailoot.ai/v1/messages)
Models: + claude-sonnet-5-5, gpt-6.1-sol
Poi premi il pulsante Model Check
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

La documentazione conferma OpenAI, Anthropic, OpenAI Responses e Gemini e l’anteprima del percorso finale sotto il campo, ma non descrive le regole per aggiungere /v1 — fai riferimento all’anteprima. Tutti e tre i nostri formati (Chat Completions, Responses, Messages) sono adatti.

[Guida completa →](https://ailoot.ai/docs/it/integrations/cherry-studio/)[Documentazione dell’applicazione ↗](https://cherryai.com/docs/en/pre-basic/providers/zi-ding-yi-fu-wu-shang/)

Ch

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

Computer e telefono

OpenAI Chat

Chat per computer e telefono.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/chatbox/)

#### Dove configurare

Impostazioni (pulsante nella barra laterale) \> Model Provider \> Add (in basso) \> tipo OpenAI API Compatible

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```text
Name: Ailoot
API Mode: OpenAI API Compatible
API Key: sk-...
API Host: https://api.ailoot.ai
API Path: (vuoto, percorso predefinito /v1/chat/completions)
Models: + gpt-6.1-sol, claude-sonnet-5-5 (vision è disattivato in questi esempi; tool_use dipende dalle funzionalità del modello selezionato)
```

Modello di esempio: `gpt-6.1-sol`

#### Importante

La documentazione indica API Host senza /v1 (esempio https://api.openai.com) e il percorso predefinito /v1/chat/completions. Esiste anche il tipo Google Gemini compatible, ma non è stato verificato per il nostro /v1beta. L’import della configurazione JSON (type: 'openai', apiHost, apiPath) è disponibile dalla 1.15.1 tramite chatbox://provider/import?config=\<base64\>. Per i GPT e Claude mostrati vision è disattivato: lo snapshot del catalogo 2026-09-30 dichiara solo testo nel formato OpenAI Chat. Se la tua versione Chatbox offre vision, attivalo solo per un modello la cui scheda attuale dichiari input image nel formato API scelto; poter allegare un’immagine nel client non dimostra che il modello la supporti.

[Guida completa →](https://ailoot.ai/docs/it/integrations/chatbox/)[Documentazione dell’applicazione ↗](https://docs.chatboxai.app/en/guides/providers)

Lo

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

Chat web, server proprio

OpenAI ChatAnthropic Messages

Chat moderna con plugin e base di conoscenza.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/lobechat/)

#### Dove configurare

Self-hosting: variabili d’ambiente OPENAI\_PROXY\_URL / OPENAI\_API\_KEY / OPENAI\_MODEL\_LIST, ANTHROPIC\_PROXY\_URL, GOOGLE\_PROXY\_URL

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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 (facoltativo)
ANTHROPIC_API_KEY=sk-...
ANTHROPIC_PROXY_URL=https://api.ailoot.ai
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

OPENAI\_PROXY\_URL è predefinito a https://api.openai.com/v1, quindi indichiamo l’indirizzo con /v1. ANTHROPIC\_PROXY\_URL è predefinito a https://api.anthropic.com (senza /v1). Tramite GOOGLE\_PROXY\_URL è formalmente possibile collegare il formato Gemini (https://api.ailoot.ai), ma non abbiamo verificato questa variante. Usa la modalità server: richieste dirette dal browser possono ancora essere rifiutate da Ailoot API per le regole CORS.

[Guida completa →](https://ailoot.ai/docs/it/integrations/lobechat/)[Documentazione dell’applicazione ↗](https://lobehub.com/docs/self-hosting/environment-variables/model-provider)

Ja

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

Applicazione desktop

OpenAI ChatAnthropic Messages

Chat desktop open source con modelli locali e cloud.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/jan/)

#### Dove configurare

Settings \> Model Providers \> Add Provider → scegli OpenAI-compatible oppure Anthropic-compatible

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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: vengono recuperati da {base_url}/models oppure aggiunti manualmente con +: claude-sonnet-5-5
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

Documentazione: per i provider OpenAI compatibili Base URL deve includere /v1 (altrimenti 404); la barra finale viene rimossa. Per la modalità Anthropic c’è un esempio LiteLLM senza /v1. Le capacità del modello (tools, vision) per provider personalizzati si impostano manualmente. Sono supportate chiavi di riserva (retry solo per 401/403/429).

[Guida completa →](https://ailoot.ai/docs/it/integrations/jan/)[Documentazione dell’applicazione ↗](https://www.jan.ai/docs/desktop/remote-models/custom-endpoint)

Si

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

Chat di ruolo

OpenAI Chat

Interfaccia per chat di ruolo e personaggi.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/sillytavern/)

#### Dove configurare

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

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```text
Custom Endpoint (Base URL): https://api.ailoot.ai/v1
Custom API Key: sk-...
Model: seleziona dall’elenco (/v1/models) oppure inserisci claude-sonnet-5-5
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

Documentazione: con problemi di connessione aggiungi /v1 e NON aggiungere /chat/completions. L’elenco dei modelli viene recuperato se il server restituisce /v1/models (il nostro lo fa).

[Guida completa →](https://ailoot.ai/docs/it/integrations/sillytavern/)[Documentazione dell’applicazione ↗](https://docs.sillytavern.app/usage/api-connections/openai/)

An

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

Chat con documenti

OpenAI Chat

Chat con i tuoi documenti su computer o server.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/anythingllm/)

#### Dove configurare

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

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```text
UI: Base URL = https://api.ailoot.ai/v1
API Key = sk-...
Chat Model Name = deepseek-v4-pro
Token context window = in base al modello

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-...'
```

Modello di esempio: `deepseek-v4-pro`

#### Importante

Il provider è indicato nella documentazione come «per sviluppatori». Se necessario GENERIC\_OPEN\_AI\_MODEL\_MAX\_TOKEN\_KEY='max\_completion\_tokens'. Per gli embedding c’è un generic-openai embedder separato (EMBEDDING\_BASE\_PATH + GENERIC\_OPEN\_AI\_EMBEDDING\_API\_KEY) — modello nemotron-3-embed tramite /v1/embeddings.

[Guida completa →](https://ailoot.ai/docs/it/integrations/anythingllm/)[Documentazione dell’applicazione ↗](https://docs.anythingllm.com/setup/llm-configuration/cloud/openai-generic)

BA

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

Chat web, server proprio

OpenAI ChatAnthropic Messages

Interfaccia web avanzata per lavorare con più modelli.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/big-agi/)

#### Dove configurare

Env al deployment: OPENAI\_API\_KEY / OPENAI\_API\_HOST, ANTHROPIC\_API\_KEY / ANTHROPIC\_API\_HOST; nell’interfaccia — Models \> Add OpenAI-compatible

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

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

Modello di esempio: `claude-sonnet-5-5`

#### Importante

La documentazione descrive le variabili come sostituzione del backend host per OpenAI e Anthropic (per proxy ed endpoint personalizzati); dice «host», quindi indichiamo l’indirizzo senza /v1, ma non specifica il formato esatto del percorso — verifica dalla prima richiesta.

[Guida completa →](https://ailoot.ai/docs/it/integrations/big-agi/)[Documentazione dell’applicazione ↗](https://github.com/enricoros/big-AGI/blob/main/docs/environment-variables.md)

Bo

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

Applicazione per Mac

OpenAI Chat

Client IA nativo per macOS.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/boltai/)

#### Dove configurare

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

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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: in base al modello
Streaming: attiva
```

Modello di esempio: `gpt-6.1-sol`

#### Importante

Serve l’indirizzo completo di chat completions. Rendi questo servizio quello principale per usarlo con AI Command. Istruzione basata sulla guida BoltAI; in BoltAI 2 le finestre possono differire.

[Guida completa →](https://ailoot.ai/docs/it/integrations/boltai/)[Documentazione dell’applicazione ↗](https://boltai.com/help/how-to-setup-custom-openai-server)

HF

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

Chat web, server proprio

OpenAI Chat

Chat web open source di Hugging Face su server proprio.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/hugging-face-chat-ui/)

#### Dove configurare

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

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

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

Modello di esempio: `deepseek-v4-pro`

#### Importante

Chat UI funziona solo con API OpenAI compatibili tramite OPENAI\_BASE\_URL e recupera l’elenco dei modelli da /models.

[Guida completa →](https://ailoot.ai/docs/it/integrations/hugging-face-chat-ui/)[Documentazione dell’applicazione ↗](https://github.com/huggingface/chat-ui)

MS

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

Applicazione desktop

OpenAI Chat

Chat desktop con modelli locali e cloud.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/msty-studio/)

#### Dove configurare

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

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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
```

Modello di esempio: `gpt-6.1-sol`

#### Importante

La documentazione conferma un provider OpenAI compatibile personalizzato, ma non il formato dell’indirizzo; /v1 è la radice standard OpenAI API, in caso di errore 404 verifica la variante senza /v1. Un endpoint Anthropic compatibile personalizzato non è descritto.

[Guida completa →](https://ailoot.ai/docs/it/integrations/msty-studio/)[Documentazione dell’applicazione ↗](https://docs.msty.ai/studio/managing-models/online-providers)

Ne

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

Chat web, server proprio

OpenAI Chat

Chat web leggera che si mette in servizio rapidamente.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/nextchat/)

#### Dove configurare

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

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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
```

Modello di esempio: `gpt-6.1-sol`

#### Importante

Per questa configurazione usa OpenAI Chat tramite il server NextChat. Nel deployment su Vercel o Docker imposta BASE\_URL=https://api.ailoot.ai senza /v1, OPENAI\_API\_KEY, CUSTOM\_MODELS e DEFAULT\_MODEL. Esegui nuovamente il deployment del server dopo aver modificato queste variabili.

[Guida completa →](https://ailoot.ai/docs/it/integrations/nextchat/)[Documentazione dell’applicazione ↗](https://github.com/ChatGPTNextWeb/NextChat#environment-variables)

OC

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

Plugin Obsidian

OpenAI Chat

Chat con le note Obsidian.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/obsidian-copilot/)

#### Dove configurare

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

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```text
Base URL: https://api.ailoot.ai/v1
API key: sk-...
Model ID: claude-sonnet-5-5 (oppure seleziona dall’elenco /v1/models)
Poi Test; attiva il modello in Basic > Agents > Quick Chat
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

L’elenco dei modelli viene recuperato da /v1/models, il modello può essere inserito manualmente. Se Test riesce ma Quick Chat non invia messaggi, attiva Enable CORS sul provider (la risposta arriva intera, senza streaming). Le chiavi sono conservate in Obsidian Keychain.

[Guida completa →](https://ailoot.ai/docs/it/integrations/obsidian-copilot/)[Documentazione dell’applicazione ↗](https://github.com/logancyang/obsidian-copilot/blob/master/docs/llm-providers.md)

PA

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

Estensione browser

OpenAI Chat

Estensione browser: chat con la pagina aperta.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/page-assist/)

#### Dove configurare

Icona Page Assist \> Settings \> OpenAI Compatible API \> Add Provider \> Custom

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```text
Provider: Custom
Name: Ailoot
Base URL: https://api.ailoot.ai/v1
API Key: sk-...
Poi aggiungi manualmente i modelli: gpt-6.1-sol, claude-sonnet-5-5
```

Modello di esempio: `gpt-6.1-sol`

#### Importante

La documentazione conferma Custom con API URL e chiave; non specifica il formato URL, /v1 è la radice standard OpenAI API. Il recupero automatico dei modelli è garantito solo per Ollama, LM Studio e Llamafile — per gli altri si aggiungono manualmente.

[Guida completa →](https://ailoot.ai/docs/it/integrations/page-assist/)[Documentazione dell’applicazione ↗](https://docs.pageassist.xyz/providers/openai)

RA

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

Launcher

OpenAI Chat

IA nel launcher Raycast: comandi rapidi e chat.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/raycast-ai/)

#### Dove configurare

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

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

base\_url è un endpoint OpenAI compatibile senza il suffisso /chat/completions. Raycast rilegge il file senza riavvio. Se abilities non è specificato, tools e vision sono considerati non supportati. I modelli appaiono in Quick AI, AI Chat e AI Commands. Nell’esempio vision.supported = false: lo snapshot del catalogo 2026-09-30 dichiara solo testo per Claude/OpenAI Chat. Se la tua versione Raycast supporta questa impostazione, attiva vision solo per un modello la cui scheda attuale dichiari input image nel formato OpenAI Chat; il flag del client non conferma da solo il supporto delle immagini nell’API.

[Guida completa →](https://ailoot.ai/docs/it/integrations/raycast-ai/)[Documentazione dell’applicazione ↗](https://manual.raycast.com/ai/custom-providers)

Ty

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

Applicazione web

OpenAI Chat

Interfaccia di chat comoda nel browser e sul computer.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/typingmind/)

#### Dove configurare

Models (barra laterale sinistra) \> + Add Custom Model

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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: in base al modello
Test → Save
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

Endpoint va inserito come percorso completo. La chiave è trasmessa nell’header personalizzato Authorization: Bearer sk-... — accettato da Ailoot. La versione web TypingMind chiama l’API direttamente dal browser e CORS può attualmente bloccare le richieste; la versione desktop è più affidabile. Il tipo Gemini in TypingMind invia la chiave nell’header apiKey, non accettato da Ailoot — usa OpenAI Chat Completions.

[Guida completa →](https://ailoot.ai/docs/it/integrations/typingmind/)[Documentazione dell’applicazione ↗](https://docs.typingmind.com/manage-and-connect-ai-models/ollama)

## SDK e framework

Librerie per applicazioni proprie, agenti e RAG.

OS

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

SDK

OpenAI ChatOpenAI Responses

Libreria ufficiale OpenAI per Python.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/openai-python-sdk/)

#### Dove configurare

Parametro del costruttore OpenAI(base\_url=..., api\_key=...) oppure variabili d’ambiente OPENAI\_BASE\_URL e OPENAI\_API\_KEY

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```bash
export AILOOT_API_KEY="sk-..."
# variabili d'ambiente
export OPENAI_BASE_URL="https://api.ailoot.ai/v1"
export OPENAI_API_KEY="$AILOOT_API_KEY"

# oppure nel codice
```

`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":"Ciao"}])
print(r.choices[0].message.content)
# Responses API: client.responses.create(model="gpt-6.1-sol", input="Ciao")
# Embedding: client.embeddings.create(model="nemotron-3-embed", input=["testo"])
```

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

Modello di esempio: `gpt-6.1-sol, claude-sonnet-5-5, deepseek-v4-pro, qwen3.8-max (chat); nemotron-3-embed (embeddings)`

#### Importante

Indirizzo con /v1: l’SDK aggiunge da solo /chat/completions, /responses, /embeddings, /images/\*, /audio/\*. Funzionano Chat Completions e Responses (Responses per i modelli con questo formato nel catalogo). Streaming e strumenti sono standard. Gli errori Ailoot arrivano in JSON con Request ID e vengono intercettati come openai.APIStatusError.

[Guida completa →](https://ailoot.ai/docs/it/integrations/openai-python-sdk/)[Documentazione dell’applicazione ↗](https://github.com/openai/openai-python)

OS

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

SDK

OpenAI ChatOpenAI Responses

Libreria ufficiale OpenAI per JavaScript e TypeScript.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/openai-node-js-sdk/)

#### Dove configurare

Opzione del costruttore new OpenAI({ baseURL, apiKey }); per impostazione predefinita l’SDK legge la variabile d’ambiente OPENAI\_BASE\_URL

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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: "Ciao" }]
});
console.log(r.choices[0].message.content);
```

La chiave viene letta dalla variabile `AILOOT_API_KEY` — impostala prima dell’avvio:

```bash
export AILOOT_API_KEY="sk-..."   # aggiungi a ~/.zshrc o ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poi riavvia il terminale
```

Modello di esempio: `claude-sonnet-5-5, gpt-6.1-sol, grok-4.7`

#### Importante

Il README mostra baseURL; la lettura di OPENAI\_BASE\_URL è nei sorgenti del client (src/client.ts), il valore predefinito è https://api.openai.com/v1. Indica l’indirizzo Ailoot con /v1. Sono disponibili sia chat.completions sia responses.

[Guida completa →](https://ailoot.ai/docs/it/integrations/openai-node-js-sdk/)[Documentazione dell’applicazione ↗](https://github.com/openai/openai-node)

AS

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

SDK

Anthropic Messages

Libreria ufficiale Anthropic per Python.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/anthropic-python-sdk/)

#### Dove configurare

Parametro Anthropic(base\_url=...) oppure variabile d’ambiente ANTHROPIC\_BASE\_URL; chiave: api\_key oppure ANTHROPIC\_API\_KEY

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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": "Ciao"}])
print(msg.content[0].text)
```

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

Modello di esempio: `claude-sonnet-5-5, claude-opus-5-5; anche tramite /v1/messages gpt-6.1-sol, deepseek-v4-pro, gemini-3.6-flash`

#### Importante

Indirizzo SENZA /v1: l’SDK aggiunge da solo /v1/messages. Il gateway accetta la chiave in x-api-key (come la invia l’SDK) e in Authorization: Bearer. Funzionano streaming, strumenti e /v1/messages/count\_tokens. Elaborazione in batch (Batches) e Files API non sono dichiarati nel catalogo Ailoot.

[Guida completa →](https://ailoot.ai/docs/it/integrations/anthropic-python-sdk/)[Documentazione dell’applicazione ↗](https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/python)

VA

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

SDK

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Framework TypeScript per applicazioni IA con qualsiasi provider.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/vercel-ai-sdk/)

#### Dove configurare

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

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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: "Ciao" });
// claude("claude-sonnet-5-5"), gemini("gemini-3.6-flash")
```

La chiave viene letta dalla variabile `AILOOT_API_KEY` — impostala prima dell’avvio:

```bash
export AILOOT_API_KEY="sk-..."   # aggiungi a ~/.zshrc o ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poi riavvia il terminale
```

Modello di esempio: `deepseek-v4-pro (compatibile con OpenAI), claude-sonnet-5-5 (Anthropic), gemini-3.6-flash (Gemini)`

#### Importante

I provider usano indirizzi diversi: OpenAI compatibile e Anthropic con /v1 (predefinito Anthropic https://api.anthropic.com/v1), Google con /v1beta (predefinito https://generativelanguage.googleapis.com/v1beta). @ai-sdk/openai usa per impostazione predefinita Responses API; per modelli senza metodo responses usa openai.chat("id") o createOpenAICompatible.

[Guida completa →](https://ailoot.ai/docs/it/integrations/vercel-ai-sdk/)[Documentazione dell’applicazione ↗](https://ai-sdk.dev/providers/openai-compatible-providers)

La

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

Framework

OpenAI ChatOpenAI ResponsesAnthropic Messages

Framework per catene, agenti e RAG.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/langchain/)

#### Dove configurare

ChatOpenAI(base\_url=...) oppure variabili OPENAI\_API\_BASE / OPENAI\_BASE\_URL; ChatAnthropic(base\_url=...) oppure ANTHROPIC\_API\_URL / ANTHROPIC\_BASE\_URL

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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("Ciao").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"])
```

Modello di esempio: `gpt-6.1-sol, qwen3.8-max (ChatOpenAI); claude-sonnet-5-5 (ChatAnthropic)`

#### Importante

ChatOpenAI: indirizzo con /v1. Secondo la documentazione supporta solo la specifica ufficiale OpenAI: campi non standard come reasoning\_content di modelli esterni non vengono conservati. Per Claude è meglio ChatAnthropic: indirizzo senza /v1, l’SDK aggiunge da solo /v1/messages. Il parametro base\_url e le variabili ANTHROPIC\_API\_URL/ANTHROPIC\_BASE\_URL di ChatAnthropic sono descritti nella documentazione della classe nei sorgenti (langchain\_anthropic/chat\_models.py), non nella pagina di integrazione. Il flag use\_responses\_api attiva la modalità Responses in ChatOpenAI.

[Guida completa →](https://ailoot.ai/docs/it/integrations/langchain/)[Documentazione dell’applicazione ↗](https://docs.langchain.com/oss/python/integrations/chat/openai)

Cr

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

Framework per agenti

OpenAI ChatAnthropic Messages

Team di agenti con ruoli e attività.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/crewai/)

#### Dove configurare

crewai.LLM(model=..., base\_url=..., api\_key=...); variabili OPENAI\_API\_KEY e OPENAI\_BASE\_URL; per Claude — provider nativo anthropic/ con base\_url

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/messages e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```python
import os
from crewai import LLM
# formato compatibile con 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)
```

Modello di esempio: `openai/gpt-6.1-sol, anthropic/claude-sonnet-5-5`

#### Importante

Il prefisso openai/ o anthropic/ seleziona il provider in CrewAI; nella richiesta viene inviato id senza prefisso. Per OpenAI l’indirizzo include /v1, per Anthropic senza /v1. La documentazione descrive anche il flag custom\_openai=True per qualsiasi gateway OpenAI compatibile. Per Anthropic max\_tokens è obbligatorio.

[Guida completa →](https://ailoot.ai/docs/it/integrations/crewai/)[Documentazione dell’applicazione ↗](https://docs.crewai.com/en/concepts/llms)

GG

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

SDK

Gemini

Libreria ufficiale Google per Gemini API.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/google-genai-python/)

#### Dove configurare

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

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1beta/models/{model}:generateContent e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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="Ciao")
print(r.text)
```

Modello di esempio: `gemini-3.6-flash, gemini-3.1-pro`

#### Importante

Indirizzo senza /v1beta: l’SDK costruisce da solo /v1beta/models/{model}:generateContent. La chiave viene inviata nell’header x-goog-api-key — Ailoot lo accetta. Sono disponibili solo modelli con formato Gemini. La documentazione della versione JavaScript (@google/genai) non descrive l’indirizzo personalizzato, quindi non la riportiamo qui.

[Guida completa →](https://ailoot.ai/docs/it/integrations/google-genai-python/)[Documentazione dell’applicazione ↗](https://github.com/googleapis/python-genai#custom-base-url)

Li

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

SDK

OpenAI Chat

Interfaccia Python unica per decine di provider.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/litellm/)

#### Dove configurare

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

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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": "Ciao"}])
print(r.choices[0].message.content)
# embedding: litellm.embedding(model="openai/nemotron-3-embed", api_base="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], input=["testo"])
```

Modello di esempio: `openai/claude-sonnet-5-5, openai/qwen3.8-max, openai/nemotron-3-embed`

#### Importante

Il prefisso openai/ indica il protocollo OpenAI compatibile; Ailoot riceve id senza prefisso. LiteLLM aggiunge da solo /chat/completions e /embeddings; secondo la documentazione, con un errore Not Found l’indirizzo deve terminare con /v1.

[Guida completa →](https://ailoot.ai/docs/it/integrations/litellm/)[Documentazione dell’applicazione ↗](https://docs.litellm.ai/docs/providers/openai_compatible)

LP

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

Gateway proprio

OpenAI Chat

Gateway personalizzato con chiavi, limiti e log basato su Ailoot.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/litellm-proxy/)

#### Dove configurare

config.yaml → model\_list → litellm\_params (model, api\_base, api\_key); avvio litellm --config config.yaml

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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

# avvio: litellm --config config.yaml
```

La chiave viene letta dalla variabile `AILOOT_API_KEY` — impostala prima dell’avvio:

```bash
export AILOOT_API_KEY="sk-..."   # aggiungi a ~/.zshrc o ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poi riavvia il terminale
```

Modello di esempio: `openai/claude-sonnet-5-5, openai/gpt-6.1-sol`

#### Importante

Il proxy è utile se vuoi distribuire al team chiavi interne basate su un’unica chiave Ailoot. Gli addebiti Ailoot sono sulla chiave indicata in api\_key. Indirizzo con /v1.

[Guida completa →](https://ailoot.ai/docs/it/integrations/litellm-proxy/)[Documentazione dell’applicazione ↗](https://docs.litellm.ai/docs/providers/openai_compatible)

Ll

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

Framework

OpenAI Chat

Framework per ricerca nei propri dati e RAG.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/llamaindex/)

#### Dove configurare

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

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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("Ciao"))
```

Modello di esempio: `deepseek-v4-pro, claude-sonnet-5-5, gpt-6.1-sol`

#### Importante

Indirizzo con /v1. is\_chat\_model=True è obbligatorio, altrimenti la classe userà il percorso obsoleto /completions. is\_function\_calling\_model=True permette agli agenti di usare strumenti. Imposta context\_window dalla scheda del modello nel catalogo Ailoot.

[Guida completa →](https://ailoot.ai/docs/it/integrations/llamaindex/)[Documentazione dell’applicazione ↗](https://developers.llamaindex.ai/python/framework-api-reference/llms/openai_like/)

Ma

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

Framework per agenti

OpenAI ChatOpenAI Responses

Framework TypeScript per agenti e flussi di lavoro.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/mastra/)

#### Dove configurare

In Agent: model: { id: "\<provider\>/\<modello\>", url: "\<indirizzo di base\>", apiKey, api?: "chat" | "responses" }

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```js
import { Agent } from "@mastra/core/agent";
const agent = new Agent({
  id: "ailoot-agent",
  name: "Ailoot Agent",
  instructions: "Rispondi in russo",
  model: {
    id: "ailoot/claude-sonnet-5-5",
    url: "https://api.ailoot.ai/v1",
    apiKey: process.env.AILOOT_API_KEY
    // api: "responses"  // solo per i modelli che supportano il metodo responses
  }
});
```

La chiave viene letta dalla variabile `AILOOT_API_KEY` — impostala prima dell’avvio:

```bash
export AILOOT_API_KEY="sk-..."   # aggiungi a ~/.zshrc o ~/.bashrc
```

```powershell
setx AILOOT_API_KEY "sk-..."   # poi riavvia il terminale
```

Modello di esempio: `ailoot/claude-sonnet-5-5, ailoot/gpt-6.1-sol`

#### Importante

url contiene l’indirizzo di base con /v1, non il percorso completo verso /chat/completions. Si usa Chat Completions per impostazione predefinita; api: "responses" passa a Responses API. La forma id "provider/modello" invia al gateway il solo id del modello. Il campo apiKey nell’oggetto model è mostrato nella documentazione in un esempio con header; non è descritto separatamente insieme a url.

[Guida completa →](https://ailoot.ai/docs/it/integrations/mastra/)[Documentazione dell’applicazione ↗](https://mastra.ai/models)

OA

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

Framework per agenti

OpenAI ChatOpenAI Responses

Libreria OpenAI per scenari con più agenti.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/openai-agents-sdk/)

#### Dove configurare

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

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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="Rispondi in russo", model=model)
print(Runner.run_sync(agent, "Ciao").final_output)
```

Modello di esempio: `claude-sonnet-5-5, gpt-6.1-sol`

#### Importante

Indirizzo con /v1. Disabilita il tracing tramite set\_tracing\_disabled(True): altrimenti l’SDK tenterà di inviare tracce a OpenAI senza una chiave OpenAI. Chat Completions è disponibile solo per i modelli per cui questo metodo è indicato nel catalogo ed è accessibile alla tua chiave; Responses (predefinito nell’SDK) solo per i modelli con il metodo responses nel catalogo. Gli strumenti integrati di OpenAI (ricerca web, file) non sono garantiti tramite un gateway di terze parti.

[Guida completa →](https://ailoot.ai/docs/it/integrations/openai-agents-sdk/)[Documentazione dell’applicazione ↗](https://openai.github.io/openai-agents-python/models/)

PA

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

Framework per agenti

OpenAI ChatOpenAI Responses

Framework per agenti tipizzato in Python.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/pydantic-ai/)

#### Dove configurare

OpenAIProvider(base\_url=..., api\_key=...) con il modello OpenAIChatModel (Chat Completions) oppure OpenAIResponsesModel (Responses); alternativa — variabile OPENAI\_BASE\_URL

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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("Ciao").output)
```

Modello di esempio: `deepseek-v4-pro, gpt-6.1-sol (per OpenAIResponsesModel)`

#### Importante

Indirizzo con /v1. La documentazione usa per impostazione predefinita OpenAIResponsesModel: sceglilo solo per modelli con metodo responses; per gli altri OpenAIChatModel.

[Guida completa →](https://ailoot.ai/docs/it/integrations/pydantic-ai/)[Documentazione dell’applicazione ↗](https://pydantic.dev/docs/ai/models/openai/)

## Automazione

Flussi no-code, costruttori di catene, bot e casa intelligente.

N8

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

Automazione no-code

OpenAI ChatOpenAI ResponsesAnthropic MessagesGemini

Automazione di flussi con nodi di agenti IA.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/n8n/)

#### Dove configurare

Credentials → OpenAI → campo Base URL (predefinito https://api.openai.com/v1); Credentials → Anthropic → Base URL (predefinito https://api.anthropic.com); Credentials → Google Gemini(PaLM) Api → Host (predefinito https://generativelanguage.googleapis.com). Poi nodi OpenAI Chat Model / Anthropic Chat Model / Google Gemini Chat Model

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions, POST /v1/responses, POST /v1/messages, POST /v1beta/models/{model}:generateContent e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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-...
Nodo OpenAI Chat Model → Model: By ID → gpt-6.1-sol (l’opzione Use Responses API è solo per i modelli che supportano il metodo responses)
```

Modello di esempio: `gpt-6.1-sol / deepseek-v4-pro (OpenAI), claude-sonnet-5-5 (Anthropic), gemini-3.6-flash (Gemini)`

#### Importante

La verifica delle credenziali chiama /models (OpenAI), /v1/models (Anthropic) e /v1beta/models (Gemini); Ailoot dispone di tutti e tre i percorsi. Le pagine di documentazione n8n non descrivono Base URL: il campo è nelle credenziali stesse (sorgenti OpenAiApi.credentials.ts e AnthropicApi.credentials.ts, etichetta «Override the default base URL for the API»). In n8n Cloud non scegliere «Use Gateway credits», altrimenti le richieste non passeranno da Ailoot.

[Guida completa →](https://ailoot.ai/docs/it/integrations/n8n/)[Documentazione dell’applicazione ↗](https://github.com/n8n-io/n8n/blob/master/packages/nodes-base/credentials/OpenAiApi.credentials.ts)

Di

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

Piattaforma di applicazioni LLM

OpenAI Chat

Piattaforma di applicazioni IA: chatbot, agenti e basi di conoscenza.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/dify/)

#### Dove configurare

Integrations → Model Provider → installa il plugin OpenAI-API-compatible → Add Model (campi: Model Type, Model Name, API Key, API Base URL, Completion mode, Model context size)

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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: in base alla scheda del modello nel catalogo Ailoot

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

Modello di esempio: `claude-sonnet-5-5, gpt-6.1-sol, qwen3.8-max; nemotron-3-embed (embeddings)`

#### Importante

Solo proprietario e amministratori del workspace possono gestire i provider. Secondo il README del plugin: per LLM l’indirizzo include /v1; per embedding, rerank, STT e TTS il plugin aggiunge da solo la versione API, quindi l’indirizzo non deve includere /v1 (altrimenti risulta /v1/v1). Aggiungi ogni modello Ailoot come voce separata; abilita input immagini e streaming nelle impostazioni del modello.

[Guida completa →](https://ailoot.ai/docs/it/integrations/dify/)[Documentazione dell’applicazione ↗](https://github.com/langgenius/dify-official-plugins/tree/main/models/openai_api_compatible)

Fl

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

Costruttore di catene

OpenAI Chat

Costruttore visuale di catene e agenti.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/flowise/)

#### Dove configurare

Nodo ChatOpenAI o ChatOpenAI Custom → Connect Credential (chiave) → Additional Parameters → Base Path (e Base Options per gli header)

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

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

Modello di esempio: `deepseek-v4-pro, claude-sonnet-5-5, gpt-6.1-sol`

#### Importante

L’elenco dei modelli in ChatOpenAI è fisso; per id Ailoot arbitrari usa ChatOpenAI Custom, dove il nome del modello si inserisce manualmente. Base Path con /v1. Per gli embedding c’è il nodo OpenAI Embeddings Custom.

[Guida completa →](https://ailoot.ai/docs/it/integrations/flowise/)[Documentazione dell’applicazione ↗](https://docs.flowiseai.com/integrations/langchain/chat-models/azure-chatopenai)

HA

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

Casa intelligente

OpenAI Chat

Assistente vocale per la casa intelligente tramite Extended OpenAI Conversation.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/home-assistant/)

#### Dove configurare

Installa tramite HACS (Custom repository) oppure copia custom\_components/extended\_openai\_conversation → riavvia → Settings → Devices & Services → Add Integration → Extended OpenAI Conversation (API Key, Base Url) → Settings → Voice Assistants → Conversation agent

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```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
```

Modello di esempio: `gpt-6.1-sol, claude-sonnet-5-5`

#### Importante

È un componente di terze parti, non un’integrazione ufficiale. Il controllo dei dispositivi usa chiamate a funzioni (tools) in Chat Completions, quindi scegli modelli con supporto degli strumenti. L’integrazione ufficiale OpenAI Conversation non supporta l’indirizzo personalizzato.

[Guida completa →](https://ailoot.ai/docs/it/integrations/home-assistant/)[Documentazione dell’applicazione ↗](https://github.com/jekalmin/extended_openai_conversation)

La

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

Costruttore di catene

OpenAI Chat

Costruttore visuale di agenti e RAG.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/langflow/)

#### Dove configurare

Profilo → Settings → Model Providers → OpenAI Compatible (campi Base URL e API Key; variabili OPENAI\_COMPATIBLE\_BASE\_URL e OPENAI\_COMPATIBLE\_API\_KEY). Alternativa: componente OpenAI → campo OpenAI API Base

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```text
Settings → Model Providers → OpenAI Compatible:
  Base URL: https://api.ailoot.ai/v1
  API Key: sk-...
oppure tramite le variabili d’ambiente:
```

```bash
export OPENAI_COMPATIBLE_BASE_URL="https://api.ailoot.ai/v1"
export OPENAI_COMPATIBLE_API_KEY="sk-..."
Poi seleziona OpenAI Compatible → claude-sonnet-5-5 nei componenti Language Model / Agent
```

Modello di esempio: `claude-sonnet-5-5, gpt-6.1-sol, nemotron-3-embed (Embedding Model)`

#### Importante

Langflow verifica la connessione e recupera l’elenco da /v1/models; i modelli appaiono in Language Models e Embedding Models. I modelli necessari vanno poi attivati manualmente. Il provider viene installato insieme a langflow.

[Guida completa →](https://ailoot.ai/docs/it/integrations/langflow/)[Documentazione dell’applicazione ↗](https://docs.langflow.org/bundles-openai-compatible)

Ma

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

Automazione no-code

Richiesta HTTP

Automazione no-code: richiesta ad Ailoot tramite il modulo HTTP.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/make/)

#### Dove configurare

Il modulo OpenAI integrato funziona solo con un account OpenAI. Usa HTTP → Make a request: URL, Method, Headers, Body type Raw / JSON

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```text
Modulo: 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 → la risposta si trova in choices[].message.content
```

Modello di esempio: `gpt-6.1-sol, claude-sonnet-5-5`

#### Importante

È un modulo HTTP generico, non un provider Ailoot dedicato: la documentazione descrive un indirizzo HTTPS arbitrario. È meglio conservare la chiave in una connessione con chiave API (Make lo consiglia invece di inviarla negli header). Lo streaming non serve in Make: invia senza stream.

[Guida completa →](https://ailoot.ai/docs/it/integrations/make/)[Documentazione dell’applicazione ↗](https://apps.make.com/http)

T

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

Bot

OpenAI Chat

Bot Telegram personalizzato con OpenAI SDK.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/telegram-bot/)

#### Dove configurare

I framework Telegram non hanno un livello LLM proprio: il gestore dei messaggi chiama OpenAI SDK con base\_url Ailoot (oppure Anthropic SDK con base\_url senza /v1)

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

Salva il codice Python come ailoot-telegram-bot.py. Installa le dipendenze, imposta entrambe le variabili d’ambiente ed esegui il file. Invia Hello al bot e verifica la risposta testuale. In caso di errore, conserva il Request ID e controlla il risultato originale prima di un’altra generazione.

```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
```

Modello di esempio: `claude-sonnet-5-5, deepseek-v4-pro, qwen3.8-flash`

#### Importante

I framework Telegram non hanno un proprio livello per modelli di IA: l’indirizzo Ailoot si imposta in OpenAI SDK nel bot. Con saldo zero Ailoot restituisce un errore 402 chiaro con Request ID — mostralo all’utente del bot evitando che il bot si arresti.

[Guida completa →](https://ailoot.ai/docs/it/integrations/telegram-bot/)[Documentazione dell’applicazione ↗](https://github.com/openai/openai-python)

Za

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

Automazione no-code

Richiesta HTTP

Automazione: richiesta ad Ailoot tramite Webhooks by Zapier.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/zapier/)

#### Dove configurare

L’applicazione ChatGPT (OpenAI) in Zapier funziona solo con OpenAI. Usa Webhooks by Zapier → Custom Request (Method, URL, Data, Headers)

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```text
Azione: 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":"Ciao"}]}
Headers:
  Authorization | Bearer sk-...
  Content-Type | application/json
```

Modello di esempio: `claude-sonnet-5-5, gpt-6.1-sol`

#### Importante

È una richiesta HTTP generica: Zapier non ha un provider pronto con un campo per l’indirizzo di base. Custom Request invia Data così com’è, senza interpretarlo, quindi il JSON va verificato prima. Webhooks by Zapier è disponibile nei piani Zapier a pagamento.

[Guida completa →](https://ailoot.ai/docs/it/integrations/zapier/)[Documentazione dell’applicazione ↗](https://help.zapier.com/hc/en-us/articles/8496326446989-Send-webhooks-in-Zap-workflows)

## In verifica

Impostazioni con dettagli non confermati — confrontale con la finestra dell’applicazione.

AC

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

Agente nel terminale

In verifica

Gemini

Agente da console Google Antigravity nel formato Gemini.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/antigravity-cli/)

#### Dove configurare

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

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1beta/models/{model}:generateContent e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

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

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

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

Modello di esempio: `gemini-3.8-flash`

#### Importante

Il protocollo è Gemini REST nativo (streamGenerateContent, chiave in X-Goog-Api-Key), percorso https://api.ailoot.ai/v1beta/... Per una domanda agy invia due richieste: titolo della conversazione e risposta. L’agente riserva a ogni passaggio molto più di una chat normale, quindi mantieni un margine nel saldo. La scheda è nella sezione «In verifica»: configurazione ricavata dalla documentazione, ma il client non è ancora stato provato dal vivo tramite Ailoot. Se modelProvider = gemini e GEMINI\_API\_KEY è vuoto, la CLI non parte.

[Guida completa →](https://ailoot.ai/docs/it/integrations/antigravity-cli/)[Documentazione dell’applicazione ↗](https://antigravity.google/docs/cli/install/)

CC

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

Agente nel terminale

In verifica

OpenAI Chat

Versione da console dell’agente Cline.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/cline-cli/)

#### Dove configurare

cline auth → provider API personalizzati → OpenAI Compatible: Base URL, API Key, Model ID; il flag -P/--provider seleziona il provider

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```bash
cline auth
# API Provider: OpenAI Compatible
# Base URL:     https://api.ailoot.ai/v1
# API Key:      sk-...
# Model ID:     claude-sonnet-5-5
cline "Esegui i test e correggi gli errori"
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

I campi Base URL / API Key / Model ID sono descritti nella documentazione Cline per OpenAI Compatible. Le etichette esatte della procedura cline auth non sono riportate nella documentazione CLI — confrontale con la schermata.

[Guida completa →](https://ailoot.ai/docs/it/integrations/cline-cli/)[Documentazione dell’applicazione ↗](https://docs.cline.bot/provider-config/openai-compatible)

CJ

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

Estensione dell’editor

In verifica

OpenAI Chat

Indirizzo del modello personalizzato in Copilot per gli IDE JetBrains.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/copilot-jetbrains-byok/)

#### Dove configurare

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

#### Configurazione

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

#### Importante

GitHub conferma il supporto degli endpoint personalizzati. La schermata ufficiale mostra Provider Name, API Key e API Type: Chat Completions, ma non un esempio di URL. Qui non viene quindi fornita una configurazione Ailoot pronta da copiare. JetBrains AI Assistant è l’alternativa documentata in questo IDE. Chiedi al supporto ufficiale del plugin di chiarire i requisiti dell’URL.

[Guida completa →](https://ailoot.ai/docs/it/integrations/copilot-jetbrains-byok/)[Documentazione dell’applicazione ↗](https://github.blog/changelog/2026-07-14-github-copilot-for-jetbrains-expands-byok-capabilities/)

Cu

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

Editor di codice

In verifica

OpenAI Chat

Editor Cursor: indirizzo OpenAI personalizzato per la chat.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/cursor/)

#### Dove configurare

Cursor Settings → Models → API Keys → OpenAI API Key + interruttore «Override OpenAI Base URL»; poi aggiungi l’ID del modello ai tuoi modelli.

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```text
OpenAI API Key:            sk-...
Override OpenAI Base URL:  https://api.ailoot.ai/v1
Modello personalizzato:               gpt-6.1-sol  (aggiungi, attiva e seleziona nella chat)
```

Modello di esempio: `gpt-6.1-sol`

#### Importante

La documentazione ufficiale attuale di Cursor non descrive l’indirizzo personalizzato: elenca solo chiavi OpenAI/Anthropic/Google/Azure/Bedrock, dice che le proprie chiavi funzionano solo nella chat (Tab resta sui modelli Cursor) e che tutte le richieste passano dai server Cursor (l’indirizzo deve essere pubblico — api.ailoot.ai è pubblico). L’interruttore dell’indirizzo è nell’interfaccia, ma sul forum Cursor vengono segnalati problemi: si applica a tutti i modelli, la modalità Agent potrebbe non usare la propria chiave e in alcune build 3.15.x il campo non accetta input.

[Guida completa →](https://ailoot.ai/docs/it/integrations/cursor/)[Documentazione dell’applicazione ↗](https://cursor.com/help/models-and-usage/api-keys)

OT

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

Plugin Obsidian

In verifica

OpenAI Chat

Generazione di testo nelle note Obsidian tramite template.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/obsidian-text-generator/)

#### Dove configurare

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

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

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

Modello di esempio: `gpt-6.1-sol`

#### Importante

La documentazione del plugin menziona il provider Custom, ma non descrive il campo dell’indirizzo e il suo formato; la configurazione è basata sull’interfaccia del plugin — confrontala con la finestra delle impostazioni.

[Guida completa →](https://ailoot.ai/docs/it/integrations/obsidian-text-generator/)[Documentazione dell’applicazione ↗](https://docs.text-gen.com/)

Pe

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

Editor di codice

In verifica

OpenAI Chat

Editor PearAI basato su VS Code.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/pearai/)

#### Dove configurare

Cmd/Ctrl+Shift+P → Open config.json → voce in models\[\] (PearAI è un fork di Continue).

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

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

Modello di esempio: `claude-sonnet-5-5`

#### Importante

Non è stato possibile verificare la documentazione ufficiale PearAI (il sito non era disponibile), il repository non è aggiornato da tempo. Il formato della configurazione segue Continue — verifica nell’applicazione.

[Guida completa →](https://ailoot.ai/docs/it/integrations/pearai/)[Documentazione dell’applicazione ↗](https://github.com/trypear/pearai-app/issues/122)

VS

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

Editor di codice

In verifica

OpenAI Chat

Provider personalizzato in Copilot Chat per Visual Studio.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/visual-studio-2026/)

#### Dove configurare

Chat → selezione del modello → Manage models → Add custom model → provider OpenAI (custom endpoint) → indirizzo, chiave, modello.

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

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

Modello di esempio: `gpt-6.1-sol`

#### Importante

Il blog Visual Studio (29.09.2026) ha annunciato indirizzi personalizzati per OpenAI e Ollama in VS 2026 Stable, ma la documentazione descrive ancora solo chiavi OpenAI/Anthropic/Google senza il campo indirizzo, quindi nomi dei campi e formato dell’indirizzo non sono ancora confermati. Solo chat; non disponibile su piani Copilot Business/Enterprise.

[Guida completa →](https://ailoot.ai/docs/it/integrations/visual-studio-2026/)[Documentazione dell’applicazione ↗](https://devblogs.microsoft.com/visualstudio/visual-studio-september-update-power-your-workflow-with-your-model/)

Vo

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

Editor di codice

In verifica

OpenAI Chat

Editor open source basato su VS Code, sviluppo interrotto.

[Approfondisci →](https://ailoot.ai/docs/it/integrations/void/)

#### Dove configurare

Void Settings → Providers → OpenAI-Compatible → baseURL, API key, modello.

#### Configurazione

Prima dell’avvio, richiedi GET /v1/models con la tua chiave Ailoot. Scegli un ID esatto di modello i cui metodi includano POST /v1/chat/completions e usalo nella configurazione. Per gli agenti, verifica anche gli strumenti e le funzioni richieste dalla tua versione del client.

```text
Provider: OpenAI-Compatible
baseURL:  https://api.ailoot.ai/v1   (senza /chat/completions)
API key:  sk-...
Model:    claude-sonnet-5-5
```

Modello di esempio: `claude-sonnet-5-5`

#### Importante

La configurazione è ricavata dal codice sorgente Void, non dalla documentazione utente. Il repository Void è archiviato, l’editor non viene più sviluppato — adatto solo a chi lo usa già.

[Guida completa →](https://ailoot.ai/docs/it/integrations/void/)[Documentazione dell’applicazione ↗](https://github.com/voideditor/void/blob/main/src/vs/workbench/contrib/void/common/voidSettingsTypes.ts)

Nessun risultato. Se l’applicazione supporta un indirizzo OpenAI o Anthropic API personalizzato, probabilmente funzionerà — [ecco cosa impostare](https://ailoot.ai/docs/it/keys/).

## Non ancora adatti

In queste applicazioni non puoi indicare un indirizzo API personalizzato. Accanto trovi le alternative.

| Applicazione | Perché non è adatta | Alternativa |
| --- | --- | --- |
| **Cursor CLI (cursor-agent)** | Funziona solo sui modelli Cursor; non permette un indirizzo API personalizzato. | Claude Code, Codex CLI oppure opencode |
| **Auggie CLI (Augment Code)** | Accesso tramite account Augment; non puoi indicare un provider esterno. | Claude Code oppure opencode |
| **Windsurf / Devin Desktop** | Accetta solo la chiave Anthropic per alcuni modelli Claude; non permette un indirizzo personalizzato. | Cline, Roo Code oppure Kilo Code in VS Code |
| **Kiro** | Non sono disponibili chiave e indirizzo API personalizzati. | Cline oppure Roo Code |
| **Google Antigravity (IDE)** | Non c’è una configurazione ufficiale per un provider personalizzato; sconsigliamo patch di terze parti. | Antigravity CLI oppure Gemini CLI |
| **Visual Studio con Copilot Business o Enterprise** | Su questi piani Copilot i modelli personalizzati non sono disponibili. | Piano personale Copilot — scheda Visual Studio 2026 |
| **Completamento automatico Cursor Tab** | Funziona sempre sui modelli Cursor, anche con la propria chiave. | La chat Cursor si configura separatamente — scheda Cursor |
| **Enchanted** | Funziona solo con l’API Ollama. | Open WebUI oppure Chatbox |
| **Smart Connections (Obsidian)** | Le API esterne sono disponibili solo in Smart Chat Pro a pagamento. | Obsidian Copilot |
| **Witsy, 5ire** | Non abbiamo trovato una descrizione ufficiale dell’indirizzo API personalizzato. | Cherry Studio oppure Jan |
| **Make: modulo OpenAI integrato** | Si connette solo a un account OpenAI. | Modulo HTTP → Make a request — scheda Make |
| **Zapier: applicazione ChatGPT (OpenAI)** | Non c’è un campo per l’indirizzo personalizzato. | Webhooks by Zapier → Custom Request — scheda Zapier |
| **Home Assistant: OpenAI Conversation** | L’integrazione incorporata funziona solo con l’indirizzo OpenAI. | Extended OpenAI Conversation da HACS — scheda Home Assistant |
| **aiogram, python-telegram-bot, grammY, Telegraf** | I framework per bot non si connettono direttamente ai modelli. | OpenAI o Anthropic SDK nel bot — scheda Bot Telegram |

## Chiamate API per intelligenza artificiale nei client

### Come imposto l’URL delle API e la chiave nel mio client?

Agenti, editor, chat e SDK che accettano la chiave Ailoot. Il pulsante «Configura» mostra dove inserire indirizzo e chiave e un config pronto da copiare.

Collega Ailoot a Claude Code, OpenCode, Hermes o alla tua applicazione.

## L’azienda e il suo portafoglio di progetti

L’azienda e il suo portafoglio di progetti: milioni di clienti; vendite nell’ordine dei miliardi ogni mese.

## Acquista token con uno sconto.

Sconto con abbonamento per lavoro regolare. Codici fino al 50% sull’acquisto di token.

Abbonamento

Scegli un piano scontato per richieste regolari.

Codice fino al 50%

Inserisci il codice all’acquisto. Il prezzo si aggiorna secondo la promozione.

Spese nella cronologia

Modello, token e importo sono salvati per ogni richiesta.

[Scegli abbonamento](https://ailoot.ai/docs/it/billing/subscriptions/) · [Consulta prezzi dei modelli](https://ailoot.ai/models/it/)

## Collega l’API al prodotto che vendi.

SaaS, app e bot secondo offerta e accordo di licenza Ailoot. Per rivendere, richiedi una licenza reseller.

Applicazione commerciale

Integra generazione di testo, immagini, video e suono nelle funzioni a pagamento.

Licenza reseller

Invia descrizione del progetto e schema di accesso. Richiedi condizioni scritte per uso e rivendita.

Documenti sul sito

Offerta, accordo di licenza e politica sui dati sono disponibili prima della connessione.

[Richiedi licenza reseller](mailto:support@ailoot.ai) · [Offerta e accordo di licenza](https://ailoot.ai/legal/offer?lang=it)

## Domande

Quale formato devo scegliere per il client?

Scegli il formato OpenAI, Anthropic o Gemini supportato dal tuo client. Consulta la scheda del modello Ailoot per trovare un metodo API e un ID modello compatibili; il supporto di un formato non significa che ogni modello supporti tutti i formati.

Cosa devo configurare nel mio client?

Imposta la chiave API Ailoot, l'indirizzo API e un ID modello compatibile con il metodo del client. L'SDK OpenAI usa https://api.ailoot.ai/v1; gli SDK Anthropic e Gemini usano https://api.ailoot.ai. Mantieni i campi della richiesta indicati nell'esempio per quel formato.

Come invio la mia prima richiesta API?

Crea una chiave API Ailoot. Imposta https://api.ailoot.ai/v1 per l'SDK OpenAI, oppure https://api.ailoot.ai per gli SDK Anthropic e Gemini. GET /v1/models è gratuito ed elenca i modelli disponibili per la tua chiave; poi usa l'esempio per il modello e il metodo API selezionati.

Cosa devo controllare se un client già collegato non funziona?

Verifica che il client invii il formato OpenAI, Anthropic o Gemini previsto all'indirizzo API corrispondente con la tua chiave API Ailoot. Conferma l'ID del modello e il metodo, poi confronta l'errore restituito con la guida del client. Invia l'errore e l'ID della richiesta a support@ailoot.ai senza condividere la tua chiave.

Posso usare Ailoot in un prodotto a pagamento?

Sì. Collega API a SaaS, app o bot secondo offerta e licenza Ailoot. Per rivendita richiedi condizioni scritte e licenza specifica del progetto.

Come richiedo una licenza per rivenditori?

Scrivi a support@ailoot.ai spiegando cosa fa il tuo prodotto, chi lo usa e come fornisci l'accesso. Richiedi una licenza per rivenditori e condizioni scritte per il tuo progetto.

## Ailoot · L’azienda e il suo portafoglio di progetti





Ailoot si basa su un’esperienza operativa consolidata, un’ampia base di clienti, un servizio stabile e un controllo costante dei KPI.





L’azienda e il suo portafoglio di progetti: milioni di clienti; vendite nell’ordine dei miliardi ogni mese.





Ailoot mette questa esperienza operativa al servizio dell’accesso API alle funzioni AI nei prodotti dei clienti, negli agenti, nelle applicazioni e nelle automazioni.