Loadcore
Documentatie

Loadcore-docs

Alles wat je nodig hebt om open modellen te draaien op je GPU-vloot met de Console, API en Agent.

Overzicht

Loadcore is een gedistribueerd systeem om open LLM's op je eigen GPU-servers te draaien. Je installeert op elke server een kleine agent en beheert de hele vloot vanuit een webconsole. Elk draaiend model is bereikbaar via een OpenAI-compatibele API, dus bestaande tools werken zonder aanpassingen.

Je prompts en antwoorden komen nooit op de servers van Loadcore. Inferentieverkeer gaat van je tools rechtstreeks naar de agent op je server. Het controlplane regelt alleen authenticatie en orkestratie.

Architectuur

Loadcore bestaat uit drie onderdelen:

  • Loadcore Console: de webapp waarmee je team servers, modellen, instanties, mensen en sleutels beheert.
  • Loadcore API: het multi-tenant controlplane dat de status van de vloot en toegangsregels bewaart en API-sleutels controleert.
  • Loadcore Agent: één Go-binary op elke GPU-server die llama.cpp installeert, modellen downloadt, instanties draait en /v1 serveert.

Agents sturen heartbeats, downloadvoortgang en instantiestatus naar de API. Tools sturen inferentieverzoeken rechtstreeks naar de agents.

Loadcore Console

In de console op console.loadcore.io werken beheerders en leden dagelijks:

  • Dashboard met de gezondheid van de vloot in één oogopslag
  • Servers om machines te registreren en de verbinding van agents te controleren
  • Modellen om HuggingFace te doorzoeken en GGUF-bestanden naar een server te downloaden
  • Instanties om draaiende modellen te starten, te stoppen en ermee te verbinden
  • Mijn gebruik om je eigen verzoeken en tokens per model te zien
  • Organisatie om leden, afdelingen en uitnodigingen te beheren
  • Instellingen om je persoonlijke API-sleutels aan te maken en in te trekken

Loadcore API

De API is het beheerde controlplane op api.loadcore.io. Het beheert organisaties, rollen, afdelingen, het serverregister, de status van modellen en instanties, en licenties. Als een agent een verzoek ontvangt, vraagt hij de API of de sleutel geldig is en welke modellen de eigenaar mag gebruiken, en bewaart het antwoord 5 minuten in de cache.

De API stuurt nooit inferentie door en slaat nooit prompts of antwoorden op.

Loadcore Agent

De agent is één binary zonder runtime-afhankelijkheden. Bij de eerste start installeert hij de nieuwste llama.cpp-build. Daarna:

  • stuurt hij elke 30 seconden een heartbeat met OS, architectuur, GPU, RAM en publiek IP-adres
  • downloadt hij modellen naar ~/.loadcore/models en meldt hij de voortgang
  • start en stopt hij llama.cpp-processen op verzoek
  • controleert hij draaiende instanties elke 15 seconden
  • serveert hij GET /v1/models, POST /v1/chat/completions en POST /v1/completions
./loadcore-agent \
    --api-key="lc_..."                       # server key from registration
    --backend-url="https://api.loadcore.io"  # control plane
    --port=9090                              # listen port (default 9090)
    --data-dir=~/.loadcore                   # models and binaries
    --llama-cpp-version=latest               # pin a llama.cpp build

Elke optie kun je ook met een omgevingsvariabele instellen: LOADCORE_API_KEY, LOADCORE_BACKEND_URL, LOADCORE_PORT, LOADCORE_DATA_DIR en LOADCORE_LLAMA_CPP_VERSION.

Installatie

  1. Meld je aan in de console en maak je organisatie aan.
  2. Ga naar Servers en registreer een GPU-server. Kopieer de eenmalige serversleutel.
  3. Kopieer de agent-binary naar de server en start hem met die sleutel.
  4. Wacht tot de server online staat. llama.cpp wordt automatisch geïnstalleerd.
  5. Download een model naar de server en start een instantie.
  6. Maak in Instellingen een persoonlijke API-sleutel aan en koppel je tools.

Servers

Op elke GPU-server draait één agent. Registreer de server op de pagina Servers en start daarna de agent met de serversleutel. De server verschijnt met de systeeminfo uit zijn eerste heartbeat. Met verbinding controleren bevestig je dat de agent bereikbaar is vanaf het netwerk dat je tools gebruiken.

GPU-servers in de cloud

Elke Linux-GPU-server die je per uur huurt werkt op dezelfde manier. Open bij het registreren het tabblad Cloudserver en kopieer het opstartscript. Plak het bij het aanmaken van de server bij je provider in het veld voor het opstartscript, vaak user data of cloud-init genoemd. De server installeert de agent bij de eerste start als systeemdienst en verschijnt zonder handmatige stappen in de console.

  • Kies een image met geïnstalleerde NVIDIA-drivers zodat llama.cpp de GPU gebruikt.
  • De agent bewaart modellen en binaries in /var/lib/loadcore.
  • Maak voor gedistribueerde instanties alle servers aan in dezelfde regio en hetzelfde privénetwerk.
  • Het script bevat de serversleutel. Roteer de sleutel als mensen buiten je team de serverinstellingen bij je provider kunnen lezen.

Modellen

  • Zoek GGUF-modellen op HuggingFace vanaf de pagina Modellen.
  • Kies de doelserver en de kwantisatie die in zijn VRAM past.
  • Volg de downloadvoortgang live. Bestanden komen in de datamap van de agent.
  • Bij verwijderen kies je of je alleen de vermelding weghaalt of ook het bestand van de server.

Bekijk de modelgidsen voor de VRAM-behoefte en aanbevolen sampling-instellingen per model.

Instanties

Een instantie is een draaiende llama.cpp-server voor één model op één server. Kies de server, het model, de contextgrootte en de GPU-lagen en start hem. De agent start het proces en meldt de status. Draai hetzelfde model op meerdere servers voor extra doorvoer. Elke draaiende instantie heeft een knop verbinden met kant-en-klare configuratie voor gangbare tools.

Gedistribueerde instanties

Als een model niet in het GPU-geheugen van één server past, kan een gedistribueerde instantie het met llama.cpp RPC over meerdere servers verdelen. Start de instantie op de hoofdserver en vink Verdelen over servers aan om rpc-servers toe te voegen. De console toont het gecombineerde GPU-geheugen naast de modelgrootte.

  • Alleen de hoofdserver heeft het modelbestand nodig.
  • Een gedistribueerde instantie heeft één hoofdserver en tot 7 rpc-servers, 8 servers in totaal.
  • De servers moeten op hetzelfde snelle lokale netwerk zitten. Elke rpc-server accepteert alleen verbindingen van de hoofdserver.
  • Het helpt je grotere modellen te laten passen, niet om ze sneller te draaien. Om de belasting te spreiden draai je aparte instanties en kies je daartussen.

Organisaties

Alles hoort bij een organisatie: leden, servers, modellen, instanties en afdelingen.

  • Beheerders beheren leden, afdelingen, uitnodigingen, servers en modellen, en kunnen elk model gebruiken.
  • Leden zien de vloot en gebruiken de modellen die aan hun afdelingen zijn toegekend.
  • Nodig mensen uit per e-mail. Iedereen kan zelf een account aanmaken.

Afdelingen

Afdelingen bepalen wie welk model mag gebruiken. Maak afdelingen aan, voeg leden toe en geef toegang per model. Een lid in meerdere afdelingen krijgt alle toegang van die afdelingen samen.

Voorbeeld: Engineering krijgt qwen3-coder-next, Research krijgt deepseek-v4.1-flash. Wie in beide zit, kan beide gebruiken.

API-sleutels

  • Maak persoonlijke sleutels aan in Instellingen. Ze beginnen met sk-lc- en worden maar één keer getoond.
  • Een sleutel heeft de modelrechten van zijn eigenaar.
  • De agent controleert sleutels bij de API en bewaart het resultaat 5 minuten in de cache.
  • Trek een sleutel altijd in wanneer je wilt. Het intrekken werkt zodra de cache van de agent verloopt.

Tools koppelen

Richt elke OpenAI-compatibele tool met je persoonlijke sleutel op http://your-server:9090/v1.

curl

curl http://your-server:9090/v1/chat/completions \
    -H "Authorization: Bearer sk-lc-your-key" \
    -H "Content-Type: application/json" \
    -d '{"model": "your-model.gguf", "messages": [{"role": "user", "content": "Hello"}]}'

Python

from openai import OpenAI

  client = OpenAI(base_url="http://your-server:9090/v1", api_key="sk-lc-your-key")
  client.chat.completions.create(
      model="your-model.gguf",
      messages=[{"role": "user", "content": "Hello"}],
  )

opencode

{
    "provider": {
      "loadcore": {
        "npm": "@ai-sdk/openai-compatible",
        "name": "Loadcore",
        "options": {
    "baseURL": "http://your-server:9090/v1",
    "apiKey": "{env:LOADCORE_API_KEY}"
        },
        "models": { "your-model.gguf": { "name": "Your model" } }
      }
    },
    "model": "loadcore/your-model.gguf"
  }

aider

aider \
    --model openai/your-model.gguf \
    --openai-api-key sk-lc-your-key \
    --openai-api-base http://your-server:9090/v1