Ga naar hoofdinhoud

Wat is LLM Launcher?

LLM Launcher is het deel van Cordatus waarmee u een model in gebruik neemt. Het dekt alles tussen "ik wil dit model draaien" en "hier is het endpoint dat mijn applicatie kan aanroepen": het model vinden, het naar een apparaat downloaden, de hardware kiezen, de engine en de vlaggen bepalen, de containers starten en er een chatinterface en een API-gateway voor zetten.

Het heette voorheen Application Hub. De menugroep, de pagina's erin en de startflow zijn allemaal opnieuw opgezet; deze sectie beschrijft de huidige interface.

Elke pagina in de menugroep LLM Launcher, op volgorde

 

Voor wie is het?​

  • AI-engineers en datawetenschappers die snel een draaiend model willen, zonder met de hand docker run-regels en engine-vlaggen te schrijven.
  • ML-platform- en DevOps-teams die meerdere engines over een vloot apparaten draaien en één plek nodig hebben om ze te zien, te starten, te stoppen en te verwijderen.
  • Onderzoekers die kwantisaties, contextlengtes en engines vergelijken op de hardware die ze werkelijk hebben.
  • Teams die on-premise draaien, waar het model, de gateway en de chatinterface allemaal op hun eigen machines moeten leven.

De pagina's in deze sectie​

PaginaWaarvoor het dient
ContainersAlles wat op uw apparaten draait (of gestopt is), gegroepeerd, met logs, parameters, poorten en Sparkrun-workloads. → Containers
ApplicatiesDe catalogus met kant-en-klare AI-applicaties — vLLM, TensorRT-LLM, Ollama, NVIDIA Dynamo, NVIDIA VSS en meer. → Starthandleiding
OmgevingenOntwikkelomgevingen (PyTorch, TensorFlow, CUDA, TensorRT…) in plaats van inferentie-engines. → Omgevingen
PrivéregistryUw eigen privé containerrepository's en tags. → Privéregistry
LLM-modellenModelcatalogus: Hugging Face, Ollama, NVIDIA NIM en de modellen die al op uw eigen apparaten staan. → LLM-modellen
Sparkrun-clustersDGX Spark-clusters voor inferentie over meerdere nodes. → Sparkrun-clusters
ServeerlaagEen API-gateway (LiteLLM) en een chatinterface (Open WebUI), zelfstandig beheerd. → Serveerlaag
Jetson AI LabNVIDIA's Jetson AI Lab-catalogus, in één stap te starten op uw Jetson-apparaten. → Jetson AI Lab
VRAM-calculatorBepaal of een model past voordat u het uitrolt. → VRAM-calculator

Wat kan ik met LLM Launcher?​

  • Modellen vinden en downloaden

    • Blader door Hugging Face, Ollama en NVIDIA NIM in één catalogus
    • Filter op de GPU's of de Jetson-module die u werkelijk bezit
    • Download gewichten rechtstreeks naar een apparaat, in een geregistreerde modelmap
    • Registreer modellen die het apparaat al bevat en zet ze over tussen apparaten

  • AI-applicaties uitrollen

    • vLLM, TensorRT-LLM, Ollama, llama.cpp en andere inferentie-engines
    • NVIDIA AI Dynamo (gedistribueerde LLM-runtime)
    • NVIDIA VSS (Video Search & Summarization)
    • Docker Compose-applicaties en uw eigen privé-images

  • Cordatus de start laten plannen

    • AI-start rangschikt uw apparaten en kiest de engine, image, GPU's, kwantisatie en vlaggen
    • Bij elke keuze hoort het bewijs, en blokkades worden benoemd voordat u zich vastlegt

  • Of alles zelf configureren

    • GPU-selectie, CPU- en RAM-limieten op de host
    • Modelbron: modelhub, uw eigen modellen of een aangepaste naam/URL
    • Containeropties, omgevingsvariabelen, engine-vlaggen, notebook
    • De exacte opdracht die wordt getoond voordat hij draait

  • Het model aan clients aanbieden

    • Een OpenAI-compatibele LiteLLM-gateway met sleutels, quota's en verzoeklogs
    • Een Open WebUI-chatinterface, met extra accounts
    • Openbare URL's om beide van buiten het netwerk te bereiken

  • VRAM-behoefte berekenen voordat u iets uitrolt

  • Containers monitoren en besturen

    • Live logs, parameters en poorten
    • Starten, stoppen, verwijderen en dupliceren, afzonderlijk of per groep
    • Openbare URL's genereren, opnieuw genereren en sluiten

Twee manieren om te starten​

Cordatus biedt twee routes naar hetzelfde resultaat. Beide eindigen met draaiende containers die u beheert vanaf de pagina Containers.

1. AI-start — het systeem beslist​

U kiest een model. Cordatus rangschikt uw apparaten, leest de configuratie van het model, kiest de engine, de container-image, de GPU's, de kwantisatie en de vlaggen, en toont u het plan met het bewijs achter elke keuze voordat er iets start.

Gebruik dit wanneer u een werkend endpoint wilt en daar geen tien beslissingen voor wilt nemen.

→ AI-start

2. De startwizard — u beslist​

Drie stappen (apparaat → versie → geavanceerde configuratie), en binnen de derde stap een verticale rail met één paneel per beslissing: Model, Rekenkracht, Toegang, Overschrijvingen en tot slot Controleren en starten, dat de exacte opdracht toont die zal draaien en elke container die wordt aangemaakt.

Gebruik dit wanneer u een specifieke image, specifieke vlaggen, een specifieke GPU-verdeling of een uitrol met meerdere componenten zoals Dynamo of VSS nodig hebt.

→ Starthandleiding

tip

Het zijn geen gescheiden werelden. Vanuit een AI-startplan kunt u op Bewerken in Geavanceerd drukken en opent de wizard met alles wat de planner heeft bepaald al ingevuld.

Hoe werkt LLM Launcher?​

1. Zoek een model (of ga direct naar een applicatie)​

Blader vanuit LLM-modellen door Hugging Face, Ollama, NVIDIA NIM of Gebruikersmodellen. Filter op uw Jetson-module, op een GPU-model met een aantal, of door de echte GPU's van een verbonden apparaat te lezen (Van apparaat). Elke rij zegt of het model open is of een toegangstoken vereist.

→ LLM-modellen

2. Download het naar een apparaat (optioneel)​

Downloaden op een modelrij haalt de gewichten op het apparaat op, niet via uw browser:

  • Apparaat — waar het komt te staan.
  • Map — een van de modelmappen die op dat apparaat zijn geregistreerd. Is er nog geen geregistreerd, dan registreert het dialoogvenster er een voor u; moet de map met verhoogde rechten worden aangemaakt, dan wordt precies vermeld wat er als root wordt aangemaakt en wat niet.
  • Kwantisatie / Profiel — publiceert een repository hetzelfde model op meerdere manieren, dan wordt alleen uw keuze plus de gedeelde bestanden gedownload, of kies Elke quantization.
  • Token — een opgeslagen of geplakt token; optioneel voor open modellen.
  • sudo-wachtwoord, alleen wanneer de doelmap dat vereist. Staat er al een wachtwoord op het apparaat, dan wordt dat gebruikt en het gaat nooit naar uw browser.

Cordatus meldt eerlijk in plaats van met een algemene fout te falen: een download die al op dat apparaat loopt, een map van een andere gebruiker, of een bestandslijst die niet kon worden gelezen (in dat geval wordt de hele repository opgehaald).

→ LLM-modellen — downloaden

3. Kies een applicatie en een versie​

Filter vanuit Applicaties op apparaattype (Server-werkstation, Jetson, DGX Spark), open er een en bekijk het tabblad Versies. Elke versie toont grootte, datum, minimale stuurprogramma- of JetPack-versie en welke apparaatgroepen worden ondersteund — en zodra er een apparaat is gekozen, of hij Gedownload is of Wordt gedownload.

4. Kies het apparaat en de versie​

De eerste twee stappen van de wizard. Compatibiliteit wordt streng gecontroleerd: een image die voor een nieuwere JetPack is gebouwd, wordt nooit aan een ouder apparaat aangeboden.

5. Configureren​

De derde stap is een rail, geen muur van panelen:

Model — modelhub, Gebruikersmodellen of Aangepast, met een GPU-adviseur die zegt of de geselecteerde GPU's het model kunnen dragen en hoeveel er nodig zouden zijn. Modeloverdracht wordt automatisch aangeboden wanneer de gewichten op een ander apparaat staan.

Rekenkracht — welke GPU's (of Alles gebruiken) en Hostlimieten voor CPU en RAM. Automatisch houdt de Host Reserved-waarden vrij voor het systeem; met Aangepast stelt u de limieten in.

Toegang — de serveerlaag: een Open WebUI-chatinterface en/of een LiteLLM-gateway, met inloggegevens, virtual keys, extra accounts en openbare URL's. Vier Profielen (Snelle start / Een API aanbieden / Alleen gateway / Alleen engine) stellen dit paneel met één klik in en raken verder niets aan.

Overschrijvingen — één kaart met vier tabbladen:

  • Container — poorttoewijzingen (met waarschuwingen voor vrij/in gebruik) en volumekoppelingen via een bestandsverkenner over de echte schijven van het apparaat, plus netwerk, herstartbeleid en apparaten
  • Omgeving — variabelen, inclusief waarden uit uw tokenkluis
  • Engine-vlaggen — engine-specifieke argumenten
  • Notebook — Jupyter, beveiligd met een token of wachtwoord

Voorstel met AI vult de eerste drie tegelijk in en meldt wat er is aangepast om op uw hardware te passen, of zegt ronduit dat het model niet past.

Controleren en starten — de samenvatting met een potlood naast elke regel, de resulterende opdracht en de volledige lijst met containers die worden aangemaakt, inclusief die de serveerlaag meebrengt.

→ Starthandleiding

6. Starten en monitoren​

Start de uitrol, kijk hoe de image wordt opgehaald als die er nog niet is, en vind de containers terug op de pagina Containers — of op het eigen tabblad Containers van de applicatie. Is er een serveerlaag geconfigureerd, kopieer dan de inloggegevens uit het dialoogvenster dat verschijnt; ze worden eenmalig getoond.

→ Containers

7. Beheer wat er draait​

Logs, parameters en poorten in realtime; starten, stoppen, verwijderen en dupliceren; openbare URL's; voorbeelden van API-gebruik voor een draaiende engine.

Applicatietypen​

Standaardapplicaties​

Eenvoudige containers met GPU-, CPU- en RAM-configuratie:

  • uitrol van één container
  • directe GPU-toewijzing
  • de standaard overschrijvingstabbladen

→ Starthandleiding

LLM-engine-applicaties​

Inferentie-engines met modelbeheer:

  • modelselectie uit de hub, Gebruikersmodellen of een aangepaste naam/URL
  • automatische volumeconfiguratie per engine
  • modeloverdracht tussen apparaten, met hervatten en checksumherstel
  • de GPU-adviseur
  • een optionele serveerlaag (chatinterface en/of gateway)
  • engine-specifieke argumenten, eventueel ingevuld door de resolver

→ Starthandleiding · Gebruikersmodellen

NVIDIA AI Dynamo​

Gedistribueerde LLM-runtime voor uitrol over meerdere GPU's:

  • verwerkingsmodi — Geaggregeerd / Gescheiden
  • routers — kv (KV-score-bewust), round-robin, random
  • KV-connectors — lmcache, kvbm, nixl, none, met optionele offload-groottes voor RAM/schijf
  • een sleep-en-neerzet GPU-pijplijn om GPU's aan prefill- en decode-workers toe te wijzen
  • orkestratie van meerdere containers achter één frontend

→ NVIDIA AI Dynamo

NVIDIA VSS (Video Search & Summarization)​

Een pijplijn met vijf services: VSS (met een optionele Gebeurtenisbeoordelaar), VLM, LLM, Embed en Rerank. Elke service kan een nieuwe container zijn, een container die al op het apparaat draait, of een extern OpenAI-compatibel endpoint.

→ NVIDIA VSS

Sparkrun (meerdere nodes)​

Recepten die over een DGX Spark-cluster worden gestart in plaats van als Docker-containers op één apparaat.

→ Sparkrun-clusters

Ontwikkelomgevingen​

PyTorch, TensorFlow, CUDA, TensorRT en de rest — dezelfde flow, geen modelstap, met Jupyter in dezelfde container.

→ Omgevingen

Uw eigen images​

Alles wat u naar de Privéregistry pusht, eventueel gemarkeerd als engine zodat Cordatus het als zodanig kan starten.

→ Privéregistry

Modellen op uw apparaten​

Modelpaden configureren​

Modelpaden gelden per apparaat, onder Apparaten → het apparaat → Modellen → Opslagpaden:

  • HuggingFace-cachepad
  • Ollama-modelpad
  • NVIDIA NIM-cachepad
  • Aangepaste paden

Gedownloade modellen toont daarna wat er onder elk pad is gevonden, met per model een knop Uitrollen. Een pad verwijderen haalt het alleen uit de instellingen — de bestanden blijven staan.

Modellen aan uw bibliotheek toevoegen​

  1. Modellen op uw apparaten verkennen — Cordatus vraagt het apparaat om zijn HuggingFace-, Ollama- en NIM-mappen en leest die stuk voor stuk. Modellen die al in uw bibliotheek staan zijn gemarkeerd als Toegevoegd, de rest als Nieuw; kies doel-engines en importeer ze. Opnieuw scannen ruimt op wat het apparaat niet langer bevat.
  2. Handmatig een model toevoegen — voor een model in een aangepast pad: apparaat, pad, naam, type, tag en engines.

Modeloverdracht​

  • Overdrachten lopen van apparaat naar apparaat over uw eigen netwerk
  • Onderbroken overdrachten worden hervat en beschadigde bestanden worden via checksums gedetecteerd en opnieuw gedownload
  • De voortgang wordt per bestand getoond, met totalen
  • Alleen API gebruiken slaat het kopiëren over wanneer het model via een API bereikbaar is
  • De volumekoppeling wordt automatisch geconfigureerd zodra het klaar is

Een gebruikersmodel uitrollen​

AI-start plant rechtstreeks voor het apparaat waarop het model staat; Handmatig → Handmatig uitvoeren met… opent de wizard met het model al geselecteerd en de juiste paden al gekoppeld.

→ Gebruikersmodellen

VRAM-calculator​

Reken het uit voordat u uitrolt​

  1. Selecteer een model — zoek op Hugging Face; parameters worden automatisch opgehaald. GGUF-repository's krijgen een kwantisatiekiezer per bestand met het geschatte aantal bits per gewicht.
  2. Kies de GPU — uit de catalogus, of lees met GPU's van het apparaat selecteren de echte GPU's van een van uw apparaten.
  3. Configureer — aantal GPU's, kwantisatie, sequentielengte, batchgrootte, GPU-geheugenbenutting en het berekeningstype (20% overhead of Met activatie).
  4. Lees het resultaat — een ringdiagram van Modelgewichten / KV-cache / Overhead of Activeringen / Vrij VRAM, de gedetailleerde cijfers, een benuttingsbalk en het oordeel VRAM is voldoende / onvoldoende.

Toepassingen​

  • Hardwarevereisten testen voordat u GPU's koopt
  • Kwantisatie, sequentielengte en batchgrootte optimaliseren voor de hardware die u hebt
  • Uitrol over meerdere GPU's plannen
  • Verschillende modelconfiguraties naast elkaar vergelijken

→ VRAM-calculator

Containerbeheer​

Bewerkingen​

  • Starten / Stoppen — afzonderlijk, per onderliggende container of voor een hele groep
  • Verwijderen — typ DELETE ter bevestiging; volumes worden eerst opgesomd en kunnen worden overgeslagen
  • Dupliceren — een nieuwe uitrol met de configuratie van deze container al ingevuld
  • Openen — het groepspaneel, met een zoekveld voor grote groepen

Uitgeschakelde acties zeggen altijd waarom: Container(s) al gestopt, Apparaatverbinding niet beschikbaar, U hebt geen rechten om te dupliceren.

Bulkbewerkingen​

Selecteer rijen met de selectievakjes en gebruik Geselecteerde verwijderen. Groepsacties gelden voor elke container in de groep.

Containerinformatie​

  • Logs — live uitvoer, met Kopiëren
  • Parameters — elke waarde waarmee de container is aangemaakt
  • Poorten — lokale en globale adressen, met kopiëren en openen

Openbare URL's​

Genereer een openbare URL voor elke opengestelde poort, en genereer die daarna opnieuw, sluit hem of wijs hem opnieuw toe. Nieuwe poorten kunnen vanaf hetzelfde tabblad worden opengesteld.

Voorbeelden van API-gebruik​

Voor een draaiende engine: een snelle aanroep, een fragment voor een OpenAI-compatibele client en Openen met WebUI.

Sparkrun-workloads​

Uitvoeringen over meerdere nodes staan op hun eigen tabblad, met logs per node, toegangs-URL's, engine-argumenten, omgevingsvariabelen (gemaskeerd) en de recept-YAML.

→ Containers

Kernbegrippen​

Applicatie — een container-image die in Cordatus is geregistreerd, met versies, ondersteunde apparaatklassen en gepubliceerde opties.

Omgeving — een ontwikkel-image in plaats van een inferentie-engine. Dezelfde startflow, geen modelstap.

Versie / chipset-tag — een specifieke image-tag voor een specifieke apparaatklasse, getoond als Gedownload of Wordt gedownload.

Containergroep — meerdere containers die samen als één geheel worden uitgerold.

Serveerlaag — de optionele chatinterface (Open WebUI) en API-gateway (LiteLLM) die naast een model omhoogkomen.

Sparkrun-workload — een inferentie-uitvoering over meerdere nodes op een DGX Spark-cluster; het is geen Docker-container en staat daarom op een eigen tabblad.

Gebruikersmodel (Gebruikersmodellen) — een model dat al op een van uw apparaten staat en bij Cordatus is geregistreerd.

Overschrijvingen — de containeropties, omgevingsvariabelen, engine-vlaggen en notebookinstellingen die boven op de vaste keuzes van de applicatie komen. Vaste regels zijn vergrendeld en kunnen niet worden verwijderd.

Kwantisatie — BF16/FP16 (volledige precisie), INT8/FP8 (de helft van het geheugen), INT4/FP4 (een kwart) en de GGUF-varianten met hun eigen bits per gewicht.

VRAM-onderdelen — modelgewichten, KV-cache, activatiegeheugen of overhead, en vrij VRAM.

Aanbevolen werkwijze​

Resourcebeheer​

  • Behoud de Host Reserved CPU- en RAM-waarden; die houden het apparaat responsief
  • Laat 20–30% VRAM vrij voor onverwachte belasting
  • Gebruik de VRAM-calculator vóór productie-uitrollen
  • Lees de regel van de GPU-adviseur voordat u een model kiest — "past, maar net" betekent dat een lange context of veel gelijktijdige verzoeken kunnen mislukken

Modelbeheer​

  • Registreer de HuggingFace-, Ollama- en NIM-paden op elk apparaat waarop u uitrolt; overdracht, scannen en de detectie "staat al op het apparaat" hangen daarvan af
  • Houd het aantal parameters en de kwantisatie ingevuld — de adviseur en de VRAM-schattingen gebruiken die
  • Gebruik Opnieuw scannen nadat u modellen op een apparaat hebt verwijderd
  • Gebruik betekenisvolle namen voor aangepaste modellen

Uitrollen​

  • Test eerst met een klein model
  • Gebruik Met activatie in de VRAM-calculator voor een nauwkeurige schatting
  • Lees Controleren en starten voordat u zich vastlegt — het toont de exacte opdracht en elke container
  • Volg de logs bij de eerste uitrol van een nieuwe image
  • Kopieer de inloggegevens van de serveerlaag meteen; ze worden eenmalig getoond

Meerdere GPU's en meerdere nodes​

  • Gebruik NVIDIA Dynamo voor gedistribueerde inferentie op één apparaat, en Sparkrun voor meerdere nodes
  • Wijs elke worker een GPU toe vóór de start — anders meldt het pijplijnpaneel geen gereedheid
  • Kies de router die bij de belasting past: kv voor hergebruik van prefixen, round-robin voor gelijkmatige belasting
  • Volg na de start de GPU-benutting op alle workers

Wat is er nieuw in deze release​

Hebt u het vorige Application Hub gebruikt, dan zijn dit de belangrijkste wijzigingen:

  • AI-start. Een volledige startroute waarbij het plan voor u wordt gemaakt, met bewijs per beslissing, blokkades en waarschuwingen.
  • De geavanceerde stap is een rail, geen muur van panelen. Model, Rekenkracht, Toegang, Overschrijvingen en Controleren, elk met een eigen paneel en gereedheidsmarkering. De gereedheidslijst staat nu naast de startknop in plaats van een scherm verderop.
  • Controleren en starten. De resulterende opdracht en de volledige lijst met containers, getoond voordat u zich vastlegt.
  • GPU-adviseur onder de modelcatalogus.
  • De serveerlaag als volwaardig onderdeel — samen met het model, hergebruikt wanneer die al draait, of volledig zelfstandig beheerd vanaf de pagina Serveerlaag.
  • Profielen — Snelle start / Een API aanbieden / Alleen gateway / Alleen engine.
  • Modellen naar een apparaat downloaden, met kwantisatiekeuze en eerlijke foutmeldingen.
  • Sparkrun-clusters en Sparkrun-workloads voor DGX Spark-inferentie over meerdere nodes.
  • Jetson AI Lab, met een expresspaneel dat image, model en engine-argumenten uit het gepubliceerde recept bepaalt.
  • LLM-modellen opnieuw opgebouwd met vier brontabbladen, GPU- en Jetson-bewust filteren en AI-start per model.
  • Omgevingen, Containers, Applicaties en de VRAM-calculator zijn opnieuw ontworpen rond dezelfde kaart-, tabel- en subkopcomponenten.

Waar u verder kunt gaan​