Loadcore-Dokumentation

Überblick

Loadcore ist ein verteiltes System, um offene LLMs auf Ihren eigenen GPU-Servern zu betreiben. Sie installieren auf jedem Server einen kleinen Agent und verwalten die gesamte Flotte über eine Web-Konsole. Jedes laufende Modell ist über eine OpenAI-kompatible API erreichbar, sodass bestehende Tools ohne Änderungen funktionieren.

Ihre Prompts und Antworten berühren nie die Server von Loadcore. Der Inferenzverkehr geht von Ihren Tools direkt an den Agent auf Ihrem Server. Die Steuerungsebene übernimmt nur Authentifizierung und Orchestrierung.

Architektur

Loadcore besteht aus drei Komponenten:

• Loadcore Console: die Web-App, mit der Ihr Team Server, Modelle, Instanzen, Personen und Schlüssel verwaltet.
• Loadcore API: die mandantenfähige Steuerungsebene, die den Zustand der Flotte und die Zugriffsregeln speichert und API-Schlüssel prüft.
• Loadcore Agent: ein einzelnes Go-Binary auf jedem GPU-Server, das llama.cpp installiert, Modelle herunterlädt, Instanzen betreibt und /v1 bereitstellt.

Agents senden Heartbeats, Download-Fortschritt und Instanzstatus an die API. Tools senden Inferenzanfragen direkt an die Agents.

Loadcore Console

In der Konsole unter console.loadcore.io arbeiten Admins und Mitglieder im Alltag:

• Dashboard mit dem Zustand der Flotte auf einen Blick
• Server, um Maschinen zu registrieren und die Verbindung der Agents zu prüfen
• Modelle, um HuggingFace zu durchsuchen und GGUF-Dateien auf einen Server zu laden
• Instanzen, um laufende Modelle zu starten, zu stoppen und sich mit ihnen zu verbinden
• Meine Nutzung, um Ihre eigenen Anfragen und Tokens pro Modell zu sehen
• Organisation, um Mitglieder, Abteilungen und Einladungen zu verwalten
• Einstellungen, um Ihre persönlichen API-Schlüssel zu erstellen und zu widerrufen

Loadcore API

Die API ist die verwaltete Steuerungsebene unter api.loadcore.io. Sie verwaltet Organisationen, Rollen, Abteilungen, das Serververzeichnis, den Zustand von Modellen und Instanzen sowie Lizenzen. Wenn ein Agent eine Anfrage erhält, fragt er die API, ob der Schlüssel gültig ist und welche Modelle sein Besitzer nutzen darf, und speichert die Antwort 5 Minuten im Cache.

Die API leitet nie Inferenz weiter und speichert nie Prompts oder Antworten.

Loadcore Agent

Der Agent ist ein einzelnes Binary ohne Laufzeitabhängigkeiten. Beim ersten Start installiert er den neuesten llama.cpp-Build. Danach:

• sendet er alle 30 Sekunden einen Heartbeat mit Betriebssystem, Architektur, GPU, RAM und öffentlicher IP
• lädt er Modelle nach ~/.loadcore/models herunter und meldet den Fortschritt
• startet und stoppt er llama.cpp-Prozesse auf Anfrage
• prüft er laufende Instanzen alle 15 Sekunden
• stellt er GET /v1/models, POST /v1/chat/completions und POST /v1/completions bereit

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

Jede Option lässt sich auch über eine Umgebungsvariable setzen: LOADCORE_API_KEY, LOADCORE_BACKEND_URL, LOADCORE_PORT, LOADCORE_DATA_DIR und LOADCORE_LLAMA_CPP_VERSION.

Einrichtung

1. Registrieren Sie sich in der Konsole und legen Sie Ihre Organisation an.
2. Öffnen Sie Server und registrieren Sie einen GPU-Server. Kopieren Sie den einmaligen Serverschlüssel.
3. Kopieren Sie das Agent-Binary auf den Server und starten Sie es mit diesem Schlüssel.
4. Warten Sie, bis der Server als online angezeigt wird. llama.cpp wird automatisch installiert.
5. Laden Sie ein Modell auf den Server und starten Sie eine Instanz.
6. Erstellen Sie unter Einstellungen einen persönlichen API-Schlüssel und binden Sie Ihre Tools an.

Server

Auf jedem GPU-Server läuft ein Agent. Registrieren Sie den Server auf der Seite Server und starten Sie den Agent mit dem Serverschlüssel. Der Server erscheint mit den Systeminfos aus seinem ersten Heartbeat. Mit Verbindung prüfen stellen Sie sicher, dass der Agent aus dem Netzwerk erreichbar ist, das Ihre Tools nutzen.

GPU-Server in der Cloud

Jeder Linux-GPU-Server, den Sie stundenweise mieten, funktioniert genauso. Öffnen Sie bei der Registrierung den Tab Cloud-Server und kopieren Sie das Startskript. Fügen Sie es beim Anlegen des Servers bei Ihrem Anbieter in das Feld für das Startskript ein, oft User Data oder cloud-init genannt. Der Server installiert den Agent beim ersten Start als Systemdienst und erscheint ohne manuelle Schritte in der Konsole.

• Wählen Sie ein Image mit installierten NVIDIA-Treibern, damit llama.cpp die GPU nutzt.
• Der Agent speichert Modelle und Binaries in /var/lib/loadcore.
• Legen Sie für verteilte Instanzen alle Server in derselben Region und im selben privaten Netzwerk an.
• Das Skript enthält den Serverschlüssel. Rotieren Sie den Schlüssel, wenn Personen außerhalb Ihres Teams die Servereinstellungen bei Ihrem Anbieter lesen können.

Modelle

• Durchsuchen Sie HuggingFace auf der Seite Modelle nach GGUF-Modellen.
• Wählen Sie den Zielserver und die Quantisierung, die in seinen VRAM passt.
• Verfolgen Sie den Download-Fortschritt live. Die Dateien landen im Datenverzeichnis des Agents.
• Beim Löschen entfernen Sie nur den Eintrag oder zusätzlich die Datei vom Server.

In den Modellleitfäden finden Sie den VRAM-Bedarf und empfohlene Sampling-Einstellungen pro Modell.

Instanzen

Eine Instanz ist ein laufender llama.cpp-Server für ein Modell auf einem Server. Wählen Sie Server, Modell, Kontextgröße und GPU-Layer und starten Sie sie. Der Agent startet den Prozess und meldet seinen Status. Betreiben Sie dasselbe Modell auf mehreren Servern, um den Durchsatz zu erhöhen. Jede laufende Instanz hat eine Schaltfläche Verbinden mit fertiger Konfiguration für gängige Tools.

Verteilte Instanzen

Wenn ein Modell nicht in den GPU-Speicher eines Servers passt, kann eine verteilte Instanz es mit llama.cpp RPC auf mehrere Server aufteilen. Starten Sie die Instanz auf dem Hauptserver und aktivieren Sie Auf Server verteilen, um RPC-Server hinzuzufügen. Die Konsole zeigt den gemeinsamen GPU-Speicher im Verhältnis zur Modellgröße.

• Nur der Hauptserver benötigt die Modelldatei.
• Eine verteilte Instanz hat einen Hauptserver und bis zu 7 RPC-Server, insgesamt 8 Server.
• Die Server müssen im selben schnellen lokalen Netzwerk sein. Jeder RPC-Server nimmt nur Verbindungen vom Hauptserver an.
• Sie hilft Ihnen, größere Modelle unterzubringen, nicht, sie schneller auszuführen. Um Last zu verteilen, betreiben Sie separate Instanzen und wählen zwischen ihnen.

Organisationen

Alles gehört zu einer Organisation: Mitglieder, Server, Modelle, Instanzen und Abteilungen.

• Admins verwalten Mitglieder, Abteilungen, Einladungen, Server und Modelle und können jedes Modell nutzen.
• Mitglieder sehen die Flotte und nutzen die Modelle, die ihren Abteilungen freigegeben sind.
• Laden Sie Personen per E-Mail ein. Jeder kann sich selbst ein Konto anlegen.

Abteilungen

Abteilungen legen fest, wer welches Modell nutzen darf. Erstellen Sie Abteilungen, fügen Sie Mitglieder hinzu und vergeben Sie Zugriff pro Modell. Ein Mitglied in mehreren Abteilungen erhält die Summe ihrer Freigaben.

Beispiel: Die Entwicklung erhält qwen3-coder-next, die Forschung erhält deepseek-v4.1-flash. Wer in beiden ist, kann beide nutzen.

API-Schlüssel

• Erstellen Sie persönliche Schlüssel unter Einstellungen. Sie beginnen mit sk-lc- und werden nur einmal angezeigt.
• Ein Schlüssel hat die Modellrechte seines Besitzers.
• Der Agent prüft Schlüssel bei der API und speichert das Ergebnis 5 Minuten im Cache.
• Widerrufen Sie einen Schlüssel jederzeit. Der Widerruf greift, sobald der Cache des Agents abläuft.

Tools anbinden

Richten Sie jedes OpenAI-kompatible Tool mit Ihrem persönlichen Schlüssel auf 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