Ga naar hoofdinhoud

Wat is Application Hub?

Application Hub is de centrale component van Cordatus voor het implementeren, configureren en beheren van AI-applicaties en gecontaineriseerde workloads op schaal.
Het biedt een uniforme interface om LLM-inference-engines, NVIDIA AI-frameworks en aangepaste Docker-containers te starten op al uw apparaten, met minimale configuratie.

Application Hub verandert complexe Docker-implementaties in eenvoudige, begeleide workflows — zodat u productierijpe AI-modellen kunt draaien zonder u te bekommeren om de complexiteit van de command line of infrastructuurdetails.

Voor wie is het bedoeld?​

  • AI Engineers en Data Scientists die LLM-modellen willen implementeren en testen op verschillende hardwareconfiguraties
  • DevOps-teams die AI-infrastructuur en containerorkestratie op schaal beheren
  • ML Operations Engineers die de GPU-benutting en modelprestaties willen optimaliseren
  • Organisaties die gedistribueerde AI-workloads uitvoeren op meerdere apparaten en locaties
  • Onderzoekers en ontwikkelaars die experimenteren met verschillende modellen, quantizaties en inference-engines

Wat kan ik met Application Hub doen?​

Met Application Hub kunt u:

  • AI-applicaties implementeren
    Vooraf geconfigureerde applicaties starten, zoals:

    • vLLM, TensorRT-LLM, Ollama (LLM-inference-engines)
    • NVIDIA AI Dynamo (gedistribueerde LLM-runtime)
    • NVIDIA VSS (Video Search & Summarization)
    • Aangepaste Docker-containers

  • Geavanceerde instellingen configureren

    • GPU-selectie: specifieke GPU's kiezen of alle beschikbare GPU's toewijzen
    • Resourcelimieten: CPU-kern- en RAM-limieten instellen met Host Reserved-bescherming
    • Modelselectie: Cordatus Models, Custom Models of User Models gebruiken
    • Docker-opties: poorten, volumes, netwerken en omgevingsvariabelen configureren
    • Engine Arguments: inference-parameters verfijnen (batchgrootte, quantization, enz.)

  • VRAM-vereisten berekenen Gebruik de VRAM Calculator om:

    • GPU-geheugenvereisten te voorspellen vóór implementatie
    • Verschillende configuraties te testen (quantization, sequentielengte, batchgrootte)
    • De optimale hardware voor uw modellen te bepalen
    • Implementaties met meerdere GPU's te plannen

  • Modellen beheren op meerdere apparaten
    Met User Models:

    • Modellen van uw apparaten toevoegen aan Cordatus
    • Modellen overzetten tussen apparaten op hetzelfde netwerk
    • Aangepaste modellen gebruiken die niet op internet beschikbaar zijn
    • Volume-mappings automatisch configureren voor verschillende inference-engines

  • Containers monitoren en beheren

    • Realtime containerstatus en logs bekijken
    • Containers afzonderlijk of in groepen starten, stoppen of verwijderen
    • Openbare URL's genereren voor geïmplementeerde applicaties
    • Open Web UI-interfaces creëren voor LLM-modellen
    • Bestaande containers dupliceren met aangepaste configuraties

Kernconcepten​

  • Applicatie — Een vooraf geconfigureerde Docker-image die is geregistreerd in Cordatus (bijv. vLLM, TensorRT-LLM, NVIDIA Dynamo, NVIDIA VSS).
    Meer details → Application Launch Guide | Standard Applications | NVIDIA VSS Guide | NVIDIA Dynamo Guide

  • Container — Een actief exemplaar van een applicatie met een specifieke configuratie (GPU-toewijzing, model, parameters).
    Meer details → Container Management Guide

  • Container Group — Meerdere containers die samen als één eenheid worden geïmplementeerd (bijv. VSS + VLM + LLM + Embed + Rerank).
    Meer details → Container Management Guide | NVIDIA VSS Guide

  • Modeltypes

    • Cordatus Models: vooraf getestte modellen die zijn geregistreerd in het Cordatus-systeem
    • Custom Models: modellen die worden opgegeven via naam of URL (worden gedownload tijdens implementatie)
    • User Models: modellen die u zelf van uw apparaten hebt toegevoegd

  • Inference-engine — Het runtimeframework dat LLM-modellen uitvoert:

    • vLLM: inference met hoge doorvoer via PagedAttention
    • TensorRT-LLM: de geoptimaliseerde inference-engine van NVIDIA
    • Ollama: eenvoudige, lokale modelimplementatie
    • NVIDIA NIM: microservices van enterprise-niveau

  • Quantization — Compressieformaat voor modelgewichten:

    • BF16/FP16: volledige precisie (16-bit)
    • INT8/FP8: half zoveel geheugengebruik (8-bit)
    • INT4/FP4: een kwart van het geheugengebruik (4-bit)

  • Resourcelimieten

    • CPU Core Limit: maximaal aantal CPU-cores dat de container kan gebruiken
    • RAM Limit: maximale geheugentoewijzing
    • Host Reserved: resources die automatisch worden gereserveerd voor systeemstabiliteit
    • No Limit: Host Reserved overschrijven (met voorzichtigheid gebruiken)

  • VRAM-componenten

    • Model Weights: geheugen dat door de modelparameters wordt ingenomen
    • KV Cache: Key-Value cache voor transformer-modellen
    • Overhead/Activation: systeemoverhead of activatiegeheugen
    • Free VRAM: resterend beschikbaar geheugen
      Meer details → VRAM Calculator User Guide

Hoe werkt Application Hub?​

  1. Een applicatie selecteren

    • Blader door de beschikbare applicaties via Containers > Applications
    • Bekijk applicatiedetails, versies en ondersteunde platforms
    • Controleer welke Docker-images al zijn gedownload op uw apparaat
      Meer details → Application Launch Guide

  2. Apparaat en versie kiezen

    • Selecteer het doelapparaat voor de implementatie
    • Kies de Docker-image-versie
    • Cordatus geeft aan of de image nog gedownload moet worden

  3. Geavanceerde instellingen configureren

    Algemene instellingen:

    • Wijs een omgevingsnaam toe
    • Selecteer GPU's (of gebruik "All GPU")
    • Stel CPU-kern- en RAM-limieten in
    • Schakel Open Web UI in (voor LLM-applicaties)

    Modelselectie (LLM-applicaties):

    • Kies uit Cordatus Models, Custom Models of User Models
    • Cordatus verzorgt de modeloverdracht indien nodig
    • Automatische volumeconfiguratie op basis van de inference-engine

    Docker-opties:

    • Configureer poort-mappings (automatisch toegewezen of handmatig)
    • Stel volume-bindingen in met een visuele bestandsverkenner
    • Definieer netwerkinstellingen en herstartbeleid

    Omgevingsvariabelen:

    • Gebruik voorgedefinieerde variabelen voor de applicatie
    • Voeg aangepaste variabelen toe of selecteer tokens uit uw account

    Engine Arguments:

    • Configureer inference-parameters (batchgrootte, quantization, enz.)
    • Voor NVIDIA Dynamo: configureer verwerkingsmodus, router, connector en workers
    • Voor NVIDIA VSS: configureer VLM-, LLM-, Embed- en Rerank-componenten

  4. Starten en monitoren

    • Controleer de configuratie en klik op Start Environment
    • Voer uw sudo-wachtwoord in ter autorisatie
    • Volg de implementatievoortgang en containerstatus
    • Ga naar containers via de pagina Containers of via het tabblad Applications > Containers
      Meer details → Container Management Guide

  5. Actieve containers beheren

    • Bekijk logs en parameters in realtime
    • Genereer openbare URL's voor externe toegang
    • Start, stop of verwijder containers
    • Creëer Open Web UI voor LLM-modellen
    • Dupliceer containers met aangepaste instellingen

Applicatietypes​

Standaardapplicaties​

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

  • Implementatie van één enkele container
  • Directe GPU-toewijzing
  • Standaard Docker-opties

Meer details → Standard Application Creation Guide

LLM Engine-applicaties​

Geavanceerde inference-engines met modelbeheer:

  • Modelselectie (Cordatus, Custom, User Models)
  • Automatische volumeconfiguratie
  • Modeloverdracht tussen apparaten
  • Optionele Open Web UI-creatie
  • Engine-specifieke argumenten

Meer details → Standard Application Creation Guide | User Models Guide

NVIDIA AI Dynamo​

Gedistribueerde LLM-runtime voor implementaties met meerdere GPU's:

  • Verwerkingsmodi (Aggregated/Disaggregated)
  • Routerconfiguratie (KV-Aware, Round Robin, Random)
  • Connectorconfiguratie (KVBM, NIXL, LM Cache)
  • Aanmaken van workers en GPU-toewijzing per worker
  • Orkestratie van meerdere containers

Meer details → NVIDIA AI Dynamo Creation Guide

NVIDIA VSS (Video Search & Summarization)​

Complexe pipeline met meerdere componenten:

  • Hoofdcontainer VSS met optionele Event Reviewer
  • VLM-component (Vision Language Model)
  • LLM-component (Large Language Model)
  • Embed-component (Embedding Model)
  • Rerank-component (Rerank Model)
  • Elk onderdeel kan nieuw, bestaand of een remote-applicatie zijn

Meer details → NVIDIA VSS Creation Guide

User Models en modeloverdracht​

Configuratie van modelpaden​

Definieer modelpaden op uw apparaten voor:

  • Huggingface-modellen
  • Ollama-modellen
  • NVIDIA NIM-modellen

Modellen toevoegen​

Twee methoden om modellen toe te voegen:

  1. Start Scanning: automatische detectie van modellen in gedefinieerde paden
  2. Add Manually: specifieke modelmappen selecteren

Modeloverdracht​

  • Modellen overzetten tussen apparaten op hetzelfde netwerk
  • Onderbroken overdrachten worden automatisch hervat
  • Voortgang van de overdracht in realtime volgen
  • Automatische volumeconfiguratie na de overdracht

Modelimplementatie​

  • Klik op Deploy naast een User Model
  • Selecteer de inference-engine (vLLM, TensorRT-LLM, enz.)
  • Het systeem leidt u door naar de interface Application Launch
  • Het model wordt automatisch geconfigureerd met de juiste paden

Meer informatie: User Models and Model Transfer Guide

VRAM Calculator​

Bereken voordat u implementeert​

Meer informatie: VRAM Calculator User Guide Voorkom mislukte implementaties door eerst de VRAM-vereisten te berekenen:

  1. Model selecteren: kies uit geregistreerde modellen of zoek op Hugging Face

  2. GPU kiezen: selecteer een GPU-model of gebruik de daadwerkelijke GPU's van het apparaat

  3. Parameters configureren:

    • Quantization (BF16, FP16, INT8, INT4)
    • Sequentielengte (1K - 256K tokens)
    • Batchgrootte (1 - 512+)
    • Aantal GPU's (Standalone-modus)
    • GPU-geheugenbenutting (0% - 100%)
    • Berekeningstype (Overhead versus Activation)

  4. Resultaten bekijken:

    • Visuele donutgrafiek met de geheugenverdeling
    • Gedetailleerde metrics per component
    • Indicator Sufficient/Insufficient
    • Gebruiksbalk in percentage

Toepassingen​

  • Hardwarevereisten testen voordat u GPU's aanschaft
  • Quantization en batchgrootte optimaliseren voor bestaande hardware
  • Implementaties met meerdere GPU's plannen
  • Verschillende modelconfiguraties vergelijken

Containerbeheer​

Containerbewerkingen​

  • Start: gestopte containers afzonderlijk of in groepen starten
  • Stop: actieve containers afzonderlijk of in groepen stoppen
  • Delete: containers verwijderen (typ "DELETE" om te bevestigen)
  • Duplicate: een nieuwe container maken met dezelfde configuratie

Bulkbewerkingen​

  • Meerdere containers selecteren via selectievakjes
  • Meerdere containers gelijktijdig verwijderen
  • Bewerkingen toepassen op volledige containergroepen

Containerinformatie​

Bekijk gedetailleerde informatie voor elke container:

  • Logs: realtime log-uitvoer
  • Parameters: alle configuratie-instellingen
  • Ports: lokale en openbare URL's

Genereren van openbare URL's​

  • Genereer openbaar toegankelijke URL's voor elke containerpoort
  • Vernieuw, deactiveer of wijs poorten opnieuw toe
  • Deel toegang tot geïmplementeerde applicaties

Open Web UI creëren​

Voor LLM-engines:

  • Open Web UI met één klik implementeren
  • Optioneel een openbare URL genereren
  • Directe chatinterface met uw model

Best practices​

Resourcebeheer​

  • Behoud altijd de Host Reserved-waarden voor systeemstabiliteit
  • Laat 20-30% Free VRAM vrij voor onverwachte belasting
  • Gebruik de VRAM Calculator vóór productie-implementaties
  • Stel passende CPU- en RAM-limieten in op basis van de workload

Modelbeheer​

  • Organiseer modellen in consistente mapstructuren
  • Definieer modelpaden op alle apparaten voordat u User Models gebruikt
  • Gebruik betekenisvolle namen voor aangepaste modellen
  • Houd modelmetadata (quantization, parameters) up-to-date

Implementatie van containers​

  • Test configuraties eerst met kleine modellen
  • Gebruik de Activation-berekeningsmodus voor nauwkeurige VRAM-schattingen
  • Monitor containerlogs tijdens de eerste implementatie
  • Maak containergroepen voor applicaties met meerdere componenten

Implementaties met meerdere GPU's​

  • Gebruik NVIDIA Dynamo voor gedistribueerde inference
  • Configureer een passend aantal workers en GPU-toewijzingen
  • Kies de routerstrategie op basis van de workload (KV-Aware voor efficiëntie)
  • Monitor de GPU-benutting van alle workers

Hulp nodig?​

Voor gedetailleerde stap-voor-stap-instructies met screenshots en video's:

  • Application Launch Guide: implementatie van standaardapplicaties
  • NVIDIA AI Dynamo Guide: opzetten van een gedistribueerde LLM-runtime
  • NVIDIA VSS Guide: implementatie van een videoanalysepipeline
  • User Models Guide: modelbeheer en -overdracht
  • Container Management Guide: containerbewerkingen en -monitoring
  • VRAM Calculator Guide: berekening van geheugenvereisten