Configurá tu acceso en 10 minutos

Esta guía te lleva desde cero hasta tu primera inferencia. El servicio es un proxy LiteLLM accesible por Tailscale que rutea a 5 modelos de nan.builders. Todo lo que necesitás: una invitación, Tailscale y un cliente OpenAI o Anthropic-compatible.

Cómo funciona por dentro

El flujo de una petición es así:

# tu cliente ──► Tailscale (cifrado wireguard) ──► LiteLLM proxy ──► nan.builders ──► modelo LLM
#                red 100.x.x.x, ACLs restringen     cuotas + keys       inferencia real

• Tailscale crea una red privada punto-a-punto cifrada (WireGuard). Solo los nodos invitados se ven entre sí.
• LiteLLM (en llm-inference:4000) recibe tu key, valida la cuota y rutea a nan.builders con la key maestra. Habla tanto el dialecto OpenAI (/v1/chat/completions) como el de Anthropic (/v1/messages).
• nan.builders hace la inferencia real y devuelve tokens en streaming SSE.
• Tu cuota mensual se descuenta del budget de tu usuario en LiteLLM, no de nan.builders directamente.

Paso 1 · Únete al tailnet

El administrador te manda una invitación por email a tu cuenta de Tailscale. Aceptala desde el link que recibís. Una vez aceptada, tu dispositivo aparece en el panel del tailnet, pero todavía está bloqueado por el Tailnet Lock hasta que un nodo con llave de confianza lo firme.

Paso 2 · Instalar y conectar Tailscale

Instalá el cliente de Tailscale para tu sistema y logueate con la misma cuenta a la que te llegó la invitación.

Linux (Arch / Debian / Fedora)

# Arch
sudo pacman -S tailscale

# Debian/Ubuntu
curl -fsSL https://tailscale.com/install.sh | sh

# conectar
sudo tailscale up

# verificar estado
tailscale status

macOS

Descargá Tailscale de la Mac App Store, abrilo, logueate y activá el switch. Desde terminal también podés:

brew install --cask tailscale
tailscale up

Windows

Descargá el instalador de tailscale.com/download/windows, instalalo, logueate y conectá.

Paso 3 · Firmar tu nodo

Una vez conectado a Tailscale, corré este comando en tu máquina para ver tu estado de Tailnet Lock:

tailscale lock status

Si tu nodo está LOCKED OUT, el comando te va a mostrar dos hashes: tu nodekey y tu tlpub. Copialos y enviaselos al administrador. El admin corre en su máquina (que ya tiene una llave de confianza):

sudo tailscale lock sign \
  nodekey:<tu-nodekey> \
  tlpub:<tu-tlpub>

Cuando el admin firma, verificá de nuevo con tailscale status — tu nodo debería decir active y poder llegar al host llm-inference.

# probar conectividad al proxy
curl http://llm-inference:4000/health/liveliness
# → "I'm alive!"

Paso 4 · Obtener tu API key

El administrador te crea un usuario en el proxy LiteLLM. Vas a recibir dos cosas:

1. Tu email y contraseña para loguearte al área privada.
2. Acceso al endpoint en http://llm-inference:4000/v1.

Loguearte al área privada

Abrí en el navegador (dentro de Tailscale) el botón de arriba a la derecha "Área privada", o directamente:

http://llm-inference:4000/ui

Logueate con tu email y contraseña. En la pestaña API Keys vas a ver tu key generada. Copiala (empieza con sk-).

Cliente: pi agent

pi soporta providers custom vía ~/.pi/agent/models.json. Agregá un provider apuntando al proxy:

"llm-inference": {
  "baseUrl": "http://llm-inference:4000/v1",
  "api": "openai-completions",
  "apiKey": "sk-XXXXXXXXXXXXXXXXXXXX",
  "compat": {
    "supportsDeveloperRole": false,
    "supportsReasoningEffort": true,
    "requiresReasoningContentOnAssistantMessages": true,
    "maxTokensField": "max_tokens"
  },
  "models": [
    { "id": "glm5.2", "name": "GLM 5.2", "reasoning": true, "contextWindow": 524288, "maxTokens": 16384 },
    { "id": "qwen3.6", "name": "Qwen 3.6", "reasoning": true, "contextWindow": 262144, "maxTokens": 16384 },
    { "id": "gemma4", "name": "Gemma 4", "reasoning": false, "contextWindow": 262144, "maxTokens": 8192 }
  ]
}

Después en pi usá /model para seleccionar el modelo y listo. Para que el provider sea el default, en ~/.pi/agent/settings.json poné "defaultProvider": "llm-inference".

Cliente: fx agent (Vercel)

fx expone tres providers: gateway (Vercel AI Gateway), codex y grok. Para apuntarlo a un proxy custom hay que usar el provider gateway con variables de entorno — pero fx exige que la URL sea loopback (127.0.0.1), así que necesitás un forward local.

Paso 1 · Forward local (loopback → proxy)

Con socat exponé el proxy de Tailscale en localhost:

# instala socat si no lo tenés
sudo pacman -S socat   # Arch
sudo apt install socat # Debian

# forward 127.0.0.1:14000 → llm-inference:4000  (en background)
socat TCP-LISTEN:14000,bind=127.0.0.1,reuseaddr,fork \
  TCP:llm-inference:4000 &

Verificá: curl http://127.0.0.1:14000/health/liveliness → "I'm alive!"

Paso 2 · Variables de entorno

# AutisticInference vía fx
export FX_GATEWAY_BASE_URL="http://127.0.0.1:14000"
export FX_GATEWAY_CHAT_URL="http://127.0.0.1:14000/v1/chat/completions"
export FX_GATEWAY_API_KEY="sk-XXXXXXXXXXXXXXXXXXXX"
export FX_MODEL="glm5.2"

Paso 3 · Seleccioná el provider y probá

fx provider gateway
fx models          # deberías ver los modelos del proxy
fx ask "¿Cuánto es 2+2?"

Cliente: Claude Code (Anthropic)

Claude Code usa la API de Anthropic. LiteLLM expone un endpoint compatible con Anthropic Messages en /v1/messages, así que solo hay que redirigir el base URL y setear el modelo.

Variables de entorno

# AutisticInference como backend de Claude Code
export ANTHROPIC_BASE_URL="http://llm-inference:4000"
export ANTHROPIC_API_KEY="sk-XXXXXXXXXXXXXXXXXXXX"
export ANTHROPIC_MODEL="glm5.2"
export ANTHROPIC_SMALL_FAST_MODEL="gemma4"

# opcional: que no actualice solo ni mande telemetría
export DISABLE_AUTOUPDATER=1
export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1

Después lanzá claude normalmente. Claude Code va a enviar POST /v1/messages al proxy, que lo rutea a nan.builders con el modelo que seteaste.

Config persistente (opcional)

También podés ponerlo en ~/.claude/settings.json (o el archivo de tu proyecto):

{
  "env": {
    "ANTHROPIC_BASE_URL": "http://llm-inference:4000",
    "ANTHROPIC_MODEL": "glm5.2",
    "ANTHROPIC_SMALL_FAST_MODEL": "gemma4"
  }
}

Cliente: Codex CLI (OpenAI)

Codex CLI lee ~/.codex/config.toml y soporta providers custom. Agregá uno apuntando al proxy:

# modelo default
model = "glm5.2"
model_provider = "autistic"

[model_providers.autistic]
name = "AutisticInference"
base_url = "http://llm-inference:4000/v1"
env_key = "AUTISTIC_API_KEY"
wire_api = "chat"

Seteá la key en tu entorno y probá:

export AUTISTIC_API_KEY="sk-XXXXXXXXXXXXXXXXXXXX"
codex "explicá qué es un closure en JS"

# o cambiá de modelo al vuelo
codex --model qwen3.6 "escribí un fizzbuzz en python"

Cliente: opencode

opencode usa una config tipo opencode.json. Agregá un provider custom:

"models": {
  "glm5.2": {
    "provider": "autistic",
    "name": "GLM 5.2",
    "options": { "contextLength": 500000 }
  },
  "qwen3.6": {
    "provider": "autistic",
    "name": "Qwen 3.6",
    "options": { "contextLength": 262144 }
  }
},
"providers": {
  "autistic": {
    "npm": "@ai-sdk/openai-compatible",
    "options": {
      "baseURL": "http://llm-inference:4000/v1",
      "apiKey": "sk-XXXXXXXXXXXXXXXXXXXX"
    }
  }
}

Para no hardcodear la key, opencode también acepta variables de entorno: poné "apiKey": "{env:AUTISTIC_API_KEY}" y exportá AUTISTIC_API_KEY.

Cliente: curl / scripts

Para probar rápido o desde un script, usá el endpoint de Chat Completions:

curl http://llm-inference:4000/v1/chat/completions \
  -H "Authorization: Bearer sk-XXXXXXXXXXXXXXXXXXXX" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm5.2",
    "messages": [{"role":"user","content":"¿Cuánto es 2+2?"}],
    "max_tokens": 200,
    "reasoning_effort": "high"
  }'

Con streaming SSE:

curl -N http://llm-inference:4000/v1/chat/completions \
  -H "Authorization: Bearer sk-XXXXXXXXXXXXXXXXXXXX" \
  -H "Content-Type: application/json" \
  -d '{"model":"qwen3.6","messages":[{"role":"user","content":"hola"}],"stream":true}'

Para listar los modelos disponibles:

curl http://llm-inference:4000/v1/models \
  -H "Authorization: Bearer sk-XXXXXXXXXXXXXXXXXXXX" | jq '.data[].id'

Modelos y límites — referencia

Cuota mensual total de nan.builders (suscripción de 1 miembro) y porción por usuario (÷4):

Tu cuota exacta

Cada usuario tiene el mismo presupuesto mensual para los modelos con cuota:

qwen3.6 y gemma4 son ilimitados para todos. Cuando se agota la cuota mensual de un modelo con límite, LiteLLM rechaza la petición hasta el reinicio del período (el día 1 de cada mes).

Área privada (Dashboard LiteLLM)

El área privada en http://llm-inference:4000/ui solo es accesible desde dentro del tailnet. Acá podés:

• Tu consumo actual y budget restante por modelo
• El historial de peticiones (qué modelo, cuántos tokens, costo virtual)
• Generar y revocar tus API keys
• Cuándo se resetea tu cuota mensual

FAQ · Troubleshooting

"LOCKED OUT" al conectarme

Es el Tailnet Lock. Necesitás que el admin firme tu nodekey. Corré tailscale lock status y mandale los dos hashes que aparecen.

"Connection refused" a llm-inference:4000

Verificá que Tailscale esté conectado (tailscale status muestra el nodo como active, no idle o offline). Probá curl http://llm-inference:4000/health/liveliness — debe responder "I'm alive!".

"Authentication error" / 401

Tu API key está mal o fue revocada. Generá una nueva desde el área privada. Asegurate de mandarla en el header Authorization: Bearer sk-....

"Budget exceeded" en un modelo

Alcanzaste tu cuota mensual de ese modelo. El contador se reinicia el día 1. Mientras tanto, podés usar qwen3.6 o gemma4 que son ilimitados.

glm5.2 me da error de "concurrent" o "rate limit"

El límite global de 5 concurrentes está saturado (probablemente otro usuario está usando el modelo). Reintentá en unos segundos. Si pasa seguido, acordá un horario con el grupo.

fx agent no lista los modelos

fx usa el protocolo del AI Gateway para descubrir modelos, que no es estándar OpenAI. Igualmente podés forzar el modelo con FX_MODEL=glm5.2 y usar fx ask. Si sigue sin cooperar, usá pi o opencode que son 100% compatibles.

Claude Code ignora ANTHROPIC_MODEL

Algunas versiones de Claude Code no leen esa var. Fijá el modelo por sesión con claude --model glm5.2 o ponelo en ~/.claude/settings.json.

¿Puedo cambiar mi contraseña?

Sí, desde el área privada en Settings → Change password. Si la olvidás, pedile al admin que te la resetee.

¿Mis prompts quedan guardados?

LiteLLM guarda logs de las peticiones (modelo, tokens, timestamp) para el tracking de cuota. El contenido completo de los prompts se puede ver en el panel del admin, pero no se comparte entre usuarios y no sale de la red Tailscale.