AI-infrastructuur op consumptieghardware

Implementeer enterprise AI op budgethardware met open modellen

Inhoud

De democratisering van AI is nu een feit. Met open-source LLMs zoals Llama 3, Mixtral en Qwen die nu concurreren met eigenaarmodellen, kunnen teams krachtige AI-infrastructuur op consumentenhardware bouwen - kosten verminderen terwijl volledige controle wordt behouden over gegevensprivacy en implementatie.

Team AI-infrastructuur op consumentenhardware

Waarom je eigen AI-infrastructuur moet hosten?

Het landschap is drastisch veranderd. Wat ooit miljoenen dollar GPU clusters vereiste, is nu haalbaar met consumentenhardware die minder kost dan een high-end werkstation.

Het geval voor eigen gehoste AI

Kostenefficiëntie

  • OpenAI GPT-4 kost $0,03-0,06 per 1K tokens
  • Een team dat 1M tokens per dag verwerkt, spendeert $900-1.800 per maand
  • Een $2.000 RTX 4090 systeem haalt het break-even punt in 1-3 maanden
  • Na het break-even punt: onbeperkte gebruik met nul marginale kosten

Gegevensprivacy en naleving

  • Volledige controle over gevoelige gegevens
  • Geen gegevens worden verzonden naar derde partij API’s
  • Naleving van GDPR, HIPAA en industrie-eisen
  • Opties voor air-gapped implementatie

Aanpassing en controle

  • Modellen aanpassen op eigen gegevens
  • Geen rate limits of quotumbeperkingen
  • Aangepaste implementatieconfiguraties
  • Onafhankelijkheid van veranderingen bij API leveranciers

Prestatievoorspelbaarheid

  • Consistente latentie zonder API fluctuaties
  • Geen afhankelijkheid van externe dienst beschikbaarheid
  • Controleerbare resourceallocatie
  • Optimalisatie voor je specifieke werklasten

Hardwarekeuze: Bouwen van je AI-server

GPU-keuzes voor verschillende budgetten

Budgetlaag ($600-900): 7B modellen

  • NVIDIA RTX 4060 Ti 16GB ($500): Draait 7B modellen, 2-3 gelijktijdige gebruikers
  • AMD RX 7900 XT ($650): 20GB VRAM, uitstekend voor inferentie
  • Gebruiksaanwijzing: Kleine teams (3-5 personen), standaard coderen/schrijven taken

Middenlaag ($1.200-1.800): 13B modellen

  • NVIDIA RTX 4070 Ti ($800): 12GB VRAM, goede prestaties voor 7B modellen
  • NVIDIA RTX 4090 ($1.600): 24GB VRAM, draait 13B modellen soepel
  • Gebruikte RTX 3090 ($800-1.000): 24GB VRAM, uitstekende waarde
  • Opmerking: Voor de nieuwste prijsontwikkelingen van de aankomende RTX 5080 en RTX 5090 modellen, zie onze analyse van de prijsdynamiek van de RTX 5080 en RTX 5090
  • Gebruiksaanwijzing: Middelgrote teams (5-15 personen), complexe redeneertaken

Professionele laag ($2.500+): 30B+ modellen

  • Meerdere RTX 3090/4090 ($1.600+ elk): Gedistribueerde inferentie
  • AMD Instinct MI210 (gebruikt, $2.000+): 64GB HBM2e
  • NVIDIA A6000 (gebruikt, $3.000+): 48GB VRAM, professionele betrouwbaarheid
  • NVIDIA Quadro RTX 5880 Ada (48GB): Voor professionele implementaties die maximale VRAM en betrouwbaarheid vereisen, overweeg de mogelijkheden en waardepropositie van de Quadro RTX 5880 Ada
  • Gebruiksaanwijzing: Grote teams (15+), onderzoek, aanpassing

Volledige systeemoverwegingen

CPU & Geheugen

  • CPU: Ryzen 5 5600 of Intel i5-12400 (voldoende voor AI-servering)
  • Geheugen: Minimaal 32GB, 64GB aanbevolen voor grote contextvensters
  • Snel geheugen helpt bij het verwerken van prompts en model laden
  • CPU optimalisatie: Voor Intel CPUs met hybride architectuur (P-cores en E-cores), zie hoe Ollama verschillende CPU-kernsoorten gebruikt om prestaties te optimaliseren
  • PCIe configuratie: Bij het plannen van meervoudige GPU-sets of hoge prestatieimplementaties, is het begrijpen van PCIe lanes en hun invloed op LLM-prestaties cruciaal voor optimale bandbreedteallocatie

Opslag

  • NVMe SSD: Minimaal 1TB voor modellen en cache
  • Modellen: 4-14GB elk, houd 5-10 modellen geladen
  • Snel opslag vermindert model ladenstijd

Stroom & Koeling

  • RTX 4090: 450W TDP, vereist 850W+ PSU
  • Goede koeling is essentieel voor 24/7 bedrijfsvoering
  • Budget $150-200 voor kwaliteit PSU en koeling

Netwerk

  • 1Gbps voldoende voor API-toegang
  • 10Gbps nuttig voor gedistribueerd trainen
  • Lage latentie telt voor real-time toepassingen

Voorbeeldbouw

Budgetbouw ($1.200)

GPU: RTX 4060 Ti 16GB ($500)
CPU: Ryzen 5 5600 ($130)
RAM: 32GB DDR4 ($80)
Mobo: B550 ($120)
Opslag: 1TB NVMe ($80)
PSU: 650W 80+ Gold ($90)
Case: $80
Totaal: ~$1.200

Optimale bouw ($2.500)

GPU: RTX 4090 24GB ($1.600)
CPU: Ryzen 7 5700X ($180)
RAM: 64GB DDR4 ($140)
Mobo: X570 ($180)
Opslag: 2TB NVMe ($120)
PSU: 1000W 80+ Gold ($150)
Case: $100
Totaal: ~$2.500

Softwarestack: Open source AI-servering

Modelserverplatforms

Ollama: Eerst eenvoudigheid

# Installeer Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Start een model
ollama run llama3:8b

# API-server (OpenAI compatibel)
ollama serve

Voordelen:

  • Dood eenvoudige installatie
  • Automatische modelbeheer
  • OpenAI-compatibele API
  • Efficiënte GGUF-quantisatie
  • Ingebouwde modelbibliotheek

Prestaties: Voor echte wereld Ollama prestatiebenchmarken op verschillende hardwareconfiguraties, inclusief enterprise en consumentengpus, zie onze gedetailleerde vergelijking van NVIDIA DGX Spark, Mac Studio en RTX 4080.

Beste voor: Teams die prioriteit geven aan gebruiksgemak en snelle implementatie

vLLM: Maximale prestaties

# Installeer vLLM
pip install vllm

# Server model
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-7b-chat-hf \
    --tensor-parallel-size 1

Voordelen:

  • Hoogste doorvoer
  • PagedAttention voor geheugen efficiëntie
  • Continue batchverwerking
  • Ondersteuning voor meervoudige GPU’s

Beste voor: Hoogdoorvoer scenario’s, meerdere gelijktijdige gebruikers

LocalAI: All-in-one oplossing

# Docker implementatie
docker run -p 8080:8080 \
    -v $PWD/models:/models \
    localai/localai:latest

Voordelen:

  • Meerdere backendondersteuning (llama.cpp, vLLM, etc.)
  • Audio, beeld en tekstmodellen
  • OpenAI API compatibel
  • Uitgebreide modelondersteuning

Beste voor: Diverse werklasten, multimodale vereisten

Containerisatie & Orchestratie

Docker Compose Setup

version: '3.8'

services:
  ollama:
    image: ollama/ollama:latest
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    restart: unless-stopped

  openwebui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - webui_data:/app/backend/data
    depends_on:
      - ollama
    restart: unless-stopped

volumes:
  ollama_data:
  webui_data:

Kubernetes Implementatie

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ollama-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ollama
  template:
    metadata:
      labels:
        app: ollama
    spec:
      containers:
      - name: ollama
        image: ollama/ollama:latest
        ports:
        - containerPort: 11434
        resources:
          limits:
            nvidia.com/gpu: 1
        volumeMounts:
        - name: models
          mountPath: /root/.ollama
      volumes:
      - name: models
        persistentVolumeClaim:
          claimName: ollama-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: ollama-service
spec:
  selector:
    app: ollama
  ports:
  - port: 11434
    targetPort: 11434
  type: LoadBalancer

Modelkeuze & Implementatie

Top open source modellen (November 2024)

7B parameterklasse (Invoegniveau)

  • Llama 3.1 8B: Nieuwste van Meta, uitstekende algemene prestaties
  • Mistral 7B v0.3: Sterke redeneer- en coderen mogelijkheden
  • Qwen2.5 7B: Multilingual, sterk op technische taken
  • VRAM: 8-12GB, Snelheid: ~30-50 tokens/sec op RTX 4060 Ti

13B parameterklasse (Gebalanceerd)

  • Llama 3.1 13B: Beste kwaliteit in de klasse
  • Vicuna 13B: Afgestemd op conversatie
  • WizardCoder 13B: Gespecialiseerd in coderen
  • VRAM: 14-18GB, Snelheid: ~20-30 tokens/sec op RTX 4090

30B+ parameterklasse (Hoogkwaliteit)

  • Llama 3.1 70B: Concurrerend met GPT-4 op veel benchmarks
  • Mixtral 8x7B: MoE architectuur, efficiënte 47B model
  • Yi 34B: Sterke multilingual prestaties
  • VRAM: 40GB+ (vereist meerdere GPUs of zware quantisatie)

Quantisatiestrategieën

GGUF Quantisatiemogelijkheden

  • Q4_K_M: 4-bit, ~50% grootte, minimale kwaliteitsverlies (aangeraden)
  • Q5_K_M: 5-bit, ~60% grootte, betere kwaliteit
  • Q8_0: 8-bit, ~80% grootte, bijna originele kwaliteit
  • F16: Volledige 16-bit, 100% grootte, originele kwaliteit

Voorbeeld: Llama 3.1 8B Modelgrootte

  • Origineel (F16): 16GB
  • Q8_0: 8,5GB
  • Q5_K_M: 5,7GB
  • Q4_K_M: 4,6GB
# Ollama gebruikt automatisch optimale quantisatie
ollama pull llama3:8b

# Voor aangepaste quantisatie met llama.cpp
./quantize models/llama-3-8b-f16.gguf models/llama-3-8b-q4.gguf Q4_K_M

Multi-gebruikers toegang & Load balancing

Authenticatie & Toegangscontrole

API-sleutel authenticatie met nginx

http {
    upstream ollama_backend {
        server localhost:11434;
    }

    map $http_authorization $api_key {
        ~Bearer\s+(.+) $1;
    }

    server {
        listen 80;
        server_name ai.yourteam.com;

        location / {
            if ($api_key != "your-secure-api-key") {
                return 401;
            }

            proxy_pass http://ollama_backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }
    }
}

OpenWebUI Multi-gebruikersinstelling

OpenWebUI biedt ingebouwde gebruikersbeheer:

  • Gebruikersregistratie en authenticatie
  • Per-gebruiker conversatiegeschiedenis
  • Admin dashboard voor gebruikersbeheer
  • Rolgebaseerde toegangscontrole

Load balancing over meerdere GPUs

Ronde-robin met nginx

upstream ollama_cluster {
    server gpu-node-1:11434;
    server gpu-node-2:11434;
    server gpu-node-3:11434;
}

server {
    listen 80;
    location / {
        proxy_pass http://ollama_cluster;
    }
}

Aanvraagwachtrijstrategie

  • vLLM verwerkt gelijktijdige aanvragen met continue batchverwerking
  • Ollama wacht automatisch op aanvragen
  • Overweeg maximaal aantal gelijktijdige aanvragen op basis van VRAM

Geavanceerde implementaties

RAG (Retrieval Augmented Generation)

# Voorbeeld RAG setup met LangChain
from langchain.llms import Ollama
from langchain.embeddings import OllamaEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA

# Initialiseer modellen
llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")
embeddings = OllamaEmbeddings(model="nomic-embed-text")

# Maak vectoropslag
vectorstore = Chroma.from_documents(
    documents=docs,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

# Maak RAG keten
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3})
)

# Query
result = qa_chain.run("Wat is onze bedrijfsverlofregeling?")

Fijnafstemming voor teamspecifieke taken

# LoRA fijnafstemming met Unsloth (geheugen efficiënt)
from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/llama-3-8b",
    max_seq_length=2048,
    load_in_4bit=True,
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,  # LoRA rank
    lora_alpha=16,
    lora_dropout=0,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
)

# Train op je dataset
trainer.train()

# Sla fijnafgestemde model op
model.save_pretrained("./models/company-llama-3-8b")

Monitoring & Observabiliteit

Prometheus metrieken

# docker-compose.yml toevoeging
  prometheus:
    image: prom/prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

  grafana:
    image: grafana/grafana
    ports:
      - "3001:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin

Belangrijke metrieken om te monitoren

  • GPU gebruik en temperatuur
  • VRAM gebruik
  • Aanvraaglatentie en doorvoer
  • Wachtrijlengte
  • Model ladenstijd
  • Token generatiesnelheid

Beveiligingsbest practices

Netwerkbeveiliging

  • Implementeer achter een VPN of firewall
  • Gebruik TLS/SSL voor externe toegang
  • Implementeer rate limiting
  • Regelmatige beveiligingsupdates

Gegevensprivacy

  • Houd modellen en gegevens op locatie
  • Versleutel opslagvolumes
  • Audit toeganglogboeken
  • Implementeer gegevensbewaarbeleid

Toegangscontrole

  • API-sleutel rotatie
  • Gebruikersauthenticatie
  • Rolgebaseerde permissies
  • Sessiebeheer

Kostenanalyse & ROI

Totale kosten van eigenaar (3 jaar)

Eigen gehost (RTX 4090 setup)

  • Aankoop hardware: $2.500
  • Elektriciteit (450W @ $0,12/kWh, 24/7): $475 per jaar = $1.425 over 3 jaar
  • Onderhoud/upgrade: $500 over 3 jaar
  • Totale kosten over 3 jaar: $4.425

Cloud API (GPT-4 equivalent)

  • Gebruik: gemiddeld 1M tokens per dag
  • Kosten: $0,04 per 1K tokens
  • Dagelijks: $40
  • Totale kosten over 3 jaar: $43.800

Besparing: $39.375 (89% kostenreductie)

Break-even analyse

  • Team dat 500K tokens per dag verwerkt: 4-6 maanden
  • Team dat 1M tokens per dag verwerkt: 2-3 maanden
  • Team dat 2M+ tokens per dag verwerkt: 1-2 maanden

Schaalstrategieën

Verticale schaal

  1. Meer VRAM toevoegen (GPU-upgrade)
  2. Systeemgeheugen vergroten voor grotere contexten
  3. Snelere opslag voor model laden

Horizontale schaal

  1. Meer GPU-nodes toevoegen
  2. Load balancing implementeren
  3. Gedistribueerde inferentie met Ray
  4. Modelparallelisme voor grotere modellen

Hybride aanpak

  • Eigen hosten voor gevoelige/standaard taken
  • Cloud API voor piekbelastingen of gespecialiseerde modellen
  • Kostenoptimalisatie via slimme routing

Algemene uitdagingen & oplossingen

Uitdaging: Model ladenstijd

  • Oplossing: Vaak gebruikte modellen in VRAM houden, modelcaching implementeren

Uitdaging: Meerdere gelijktijdige gebruikers

  • Oplossing: Aanvraagwachtrij implementeren, gebruik van vLLM’s continue batchverwerking

Uitdaging: Beperkte VRAM

  • Oplossing: Gequantiseerde modellen gebruiken (Q4/Q5), modelswapping implementeren

Uitdaging: Onregelmatige prestaties

  • Oplossing: GPU temperatuur monitoren, juiste koeling implementeren, consistente batchgrootte gebruiken

Uitdaging: Modelupdates

  • Oplossing: Automatiserde modelupdate scripts, versiebeheer, terugkeerprocedures

Aanvangstchecklist

  • Kies GPU op basis van teamgrootte en budget
  • Bouw of koop hardware
  • Installeer Ubuntu 22.04 of vergelijkbare Linux distributie
  • Installeer NVIDIA drivers en CUDA toolkit
  • Installeer Docker en docker-compose
  • Implementeer Ollama + OpenWebUI stack
  • Trek 2-3 modellen (start met Llama 3.1 8B)
  • Configureer netwerktoegang en authenticatie
  • Stel monitoring in (minimaal GPU statistieken)
  • Train team op API-gebruik of webinterface
  • Documenteer implementatie en toegangsprocedures
  • Plan voor back-ups en disaster recovery