en ligne surapi.inference.club

Un réseau d'inférence distribué propulsé par des GPU grand public et Tailscale

Un point de terminaison compatible OpenAI alimenté par les GPU que les membres apportent au réseau. Exécutez un agent sur votre propre matériel. Utilisez tout le pool avec une seule clé.

Comment tout s'articule

Des GPU à domicile, un seul réseau privé.

inference.club is a Tailscale tailnet that joins consumer hardware — RTX PCs, the DGX Spark, Apple silicon — so members can safely expose their inference through one unified API, across the whole range of AI modalities: chat, images, video, speech, music, 3D.

Pour les consommateurs

Prêt à l'emploi pour le SDK OpenAI.

Inscrivez-vous, générez un jeton, pointez votre client vers api.inference.club/v1. Chaque modèle du réseau est à une requête de distance.

export OPENAI_API_KEY=ic_xxxxxxxxxxxxxxxxxxxx
export OPENAI_BASE_URL=https://api.inference.club/v1

curl $OPENAI_BASE_URL/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen/qwen3.6-27b",
    "messages": [
      {"role": "user", "content": "explain MoE in one sentence"}
    ]
  }'
Pour les fournisseurs

Encapsulez n'importe quel serveur compatible OpenAI.

Vous utilisez déjà vllm, llama.cpp ou ollama ? Pointez l'agent dessus et vous devenez un nœud du réseau.

# Already running vLLM, llama.cpp, or Ollama on your GPU?
# Point the agent at it and join the network.

export INFERENCE_CLUB_API_KEY=ic_xxxxxxxxxxxxxxxxxxxx
export OPENAI_BASE_URL=http://localhost:8000/v1
export OPENAI_API_KEY=local-key  # whatever your local server expects

docker run --rm -d --name club-agent --network host \
  -e INFERENCE_CLUB_API_KEY \
  -e OPENAI_BASE_URL \
  -e OPENAI_API_KEY \
  ghcr.io/inference-club/inference-club-agent:latest

Architecture

Trois éléments. Rien de magique.

Suivez une requête de votre code jusqu'à un GPU, puis retour. Le plan de contrôle dans le cloud authentifie, applique vos règles de confidentialité et achemine — mais le modèle, lui, tourne sur du matériel qui vous appartient.

étape01

Les opérateurs exécutent des agents

Les membres exécutent inference-club-agent à côté de leur serveur LLM local. L'agent annonce les modèles hébergés par le serveur.

étape02

Les agents rejoignent le tailnet

Chaque agent reçoit une clé Tailscale à durée limitée et rejoint notre mesh privé. Aucun point de terminaison public. Aucune redirection de port. Juste WireGuard.

étape03

Les consommateurs envoient des requêtes

Les appels vers api.inference.club sont routés vers un agent en ligne servant le modèle demandé. Le streaming fonctionne. La latence est directe.

Your application

curl · OpenAI SDK · the Playground · your agents

base_url = "https://api.inference.club/v1"
api_key = "ic_xxxxxxxxxxxxxxxxxxxx"
HTTPS · Authorization: Bearer ic_…

api.inference.club — the control plane

one small cloud VPS (Hetzner). It routes; it never runs the model.

Caddy

TLS · reverse proxy

Django + DRF

OpenAI-compatible /v1 router · auth · routing

Access control

visibility · per-service ACLs · kill switch

Celery workers

async jobs · batches · workflow DAG

Postgres + Redis

state · queue · throttling

GCS

images · video · voice · music

The inference.club tailnet

a private Tailscale mesh — pure WireGuard

SOCKS5 sidecarMagicDNS · club-host-17:443short-lived auth keysno ports · no firewall holes

Your rig — where inference actually happens

a GPU you own, at home, on hardware you trust

inference-club-agentcontainer · --network host

Joins the tailnet with its minted key, advertises models from agent.yaml, and forwards each request to whatever you already run locally:

vLLMllama.cppOllamaLM StudioDiaLTX-2

→ http://localhost:1234/v1

running onbrian's 4090M3 Ultra · 192GBDGX Spark2× 3090 rigk3s home cluster

Follow one request

  1. 1Your code calls api.inference.club/v1 with your ic_ key — the same request you’d send OpenAI.
  2. 2Caddy terminates TLS; Django authenticates the key and applies your privacy + access rules.
  3. 3The router picks a healthy, online node that actually serves the requested model.
  4. 4Django (via a Tailscale SOCKS5 sidecar) dials the node by MagicDNS over WireGuard — no ports, no tunnels.
  5. 5The agent container hands the request to your local LLM server on localhost.
  6. 6Tokens (or images / video / audio) stream back along the exact same path.

In one breath

inference.club is what happens when you point an OpenAI-compatible API at a pile of consumer GPUs you actually own and trust — a private Tailscale tailnet quietly stitching a 4090 here, an M3 Ultra there, a DGX Spark and a couple of 3090s into one WireGuard mesh with no ports forwarded and no firewall holes, where a little inference-club-agent container sits next to whatever you’re already running — vLLM, llama.cpp, Ollama, LM Studio — and advertises it through a manifest, while back in the cloud a Django + Celery server behind Caddy authenticates your ic_ key, enforces your privacy and per-service access controls, and routes the call over the tailnet by MagicDNS to a healthy online node, with Redis and Postgres driving async jobs, batches and a whole workflow DAG engine, GCS holding the images, video, voice and music that come back, a Nuxt playground and dashboard to poke at all of it, the home fleet itself migrating from Docker to k3s, and the entire thing — chat, images, LTX-2 video, Dia voice cloning, speech, the works — sitting behind one base URL you can curl, so go ahead and build something, and, as the prompt says: Make no mistakes.

Pourquoi inference.club

Conçu pour la façon dont les modèles ouverts fonctionnent réellement.

Compatible OpenAI

Remplacement direct. Changez l'URL de base et la clé — vos SDK et prompts existants fonctionnent tels quels.

De vrais GPU, de vrais modèles

Les membres servent des modèles à poids ouverts sur leur propre matériel : Qwen, Llama, DeepSeek, Mistral, Gemma.

Privé par défaut

Les requêtes atteignent les fournisseurs via Tailscale, chiffrées de bout en bout. Aucun point de terminaison public à exploiter.

Un club, pas un fournisseur

Mutualisez la puissance de calcul avec des personnes de confiance. Apportez un nœud quand vous avez des cycles disponibles. Utilisez le réseau quand vous en avez besoin.

Prêt à vous connecter ?

Connectez-vous avec GitHub, générez une clé, et vous êtes opérationnel en moins d'une minute. Apportez un nœud dès que vous avez des cycles disponibles.