Soevereine LLM-deployment op eigen servers in Nederland — zonder AWS, Azure of Google Cloud

LMXAI bouwt soevereine LLM-infrastructuur die op eigen servers, on-premise of in een gekozen private omgeving kan draaien zonder verplichte afhankelijkheid van AWS, Azure of Google Cloud. Modellen, prompts, documenten, logs en applicatiedata kunnen binnen de door de organisatie bepaalde infrastructuurgrens blijven.

LMXAI is gevestigd in Leiden en combineert model serving, Kubernetes, backend engineering, RAG, agentic systemen, observability en productarchitectuur in één deploymenttraject.

Wat betekent een soevereine LLM-deployment?

Een deployment is pas echt soeverein wanneer de organisatie controle houdt over de relevante technische lagen. Alleen een Europees datacenter gebruiken is daarvoor niet automatisch voldoende.

Bij een soevereine architectuur kijken we onder meer naar:

• waar model weights staan en worden geladen;
• waar inference plaatsvindt;
• waar prompts en outputs worden verwerkt;
• waar documenten, embeddings en vectorindexen worden opgeslagen;
• wie beheer- en supporttoegang heeft;
• welke externe endpoints of telemetry actief zijn;
• hoe identity, permissions en secrets worden beheerd;
• waar logs en observabilitydata terechtkomen;
• of het systeem tijdens runtime externe modelproviders nodig heeft.

Het gewenste niveau kan variëren van een EU-private omgeving tot volledig on-premise of een sterk afgeschermde infrastructuur zonder externe model-API's.

Wat LMXAI kan bouwen

1. Self-hosted model serving

Open modellen kunnen worden geserveerd via bijvoorbeeld vLLM op eigen GPU's. Het servingprofiel wordt afgestemd op modelgrootte, contextlengte, concurrency, latency en beschikbaar geheugen.

Waar relevant worden quantization, batching, KV-cachegebruik en model routing geoptimaliseerd om de hardware efficiënt te benutten.

2. Kubernetes deployment

Voor omgevingen waar schaalbaarheid en operationele standaardisatie nodig zijn, kan inference op Kubernetes worden ingericht met duidelijke scheiding tussen model serving, applicaties, data services en observability.

Dat kan onder meer bestaan uit:

• model-serving workloads;
• API gateway;
• autoscaling of gecontroleerde capaciteit;
• secrets en configuration management;
• health checks en restart policies;
• resource isolation;
• monitoring en alerts;
• deployment- en rollbackprocedures.

3. Model-agnostische AI gateway

Een interne gateway voorkomt dat applicaties hard worden gekoppeld aan één model of runtime. De gateway kan requests routeren, authenticeren, limiteren en observeren.

Daardoor kan een organisatie bijvoorbeeld een kleiner lokaal model gebruiken voor standaardtaken en een sterker model voor specifieke workloads — zonder de applicatiestructuur opnieuw te ontwerpen.

4. Private RAG

Document retrieval kan volledig binnen dezelfde gecontroleerde omgeving draaien. LMXAI ontwerpt ingestion, parsing, indexering, retrieval en bronvermelding met aandacht voor tenant- en gebruikersisolatie.

Voor enterprise search kan bijvoorbeeld Elasticsearch worden ingezet, eventueel gecombineerd met dense retrieval, metadata filtering en reranking.

5. Agents en interne tools

Een lokaal gehost model kan ook interne tools gebruiken via gecontroleerde API's of MCP. Daarmee kan een sovereign AI-platform workflows uitvoeren zonder bedrijfsdata via een externe agentprovider te laten lopen.

Tool permissions, approval gates en audit logging worden daarbij expliciet ontworpen.

Referentiearchitectuur zonder hyperscaler-afhankelijkheid

Een typische architectuur kan bestaan uit:

Interne gebruiker → AI-interface → interne gateway → lokale modelserver → RAG/tools → interne datasystemen

Daaromheen:

Identity + RBAC → observability → evaluation → audit logging → security policies

Alle kerncomponenten kunnen binnen de infrastructuur van de klant draaien. Externe diensten worden alleen toegevoegd wanneer daar bewust voor wordt gekozen.

Welke hardware is nodig?

Dat hangt af van het model en de workload. De belangrijkste variabelen zijn:

• modelgrootte;
• precision of quantization;
• contextlengte;
• gelijktijdige gebruikers;
• gewenste tokens per seconde;
• latency-eisen;
• piekbelasting;
• redundancy-eisen.

Een groot model is niet automatisch de beste enterprise-oplossing. Een kleiner of gespecialiseerd model kan goedkoper, sneller en beter beheersbaar zijn wanneer de taak duidelijk is.

LMXAI begint daarom met workloadprofilering in plaats van direct GPU-capaciteit te kopen.

Wanneer is sovereign self-hosting logisch?

Een eigen deployment is vooral interessant wanneer:

• data residency of vertrouwelijkheid zwaar weegt;
• externe model-API's niet zijn toegestaan;
• voorspelbare volumes een eigen servinglaag economisch aantrekkelijk maken;
• custom of fine-tuned modellen nodig zijn;
• de organisatie infrastructuur- en modelkeuze zelf wil controleren;
• vendor lock-in moet worden beperkt;
• interne AI-diensten door meerdere applicaties worden gedeeld;
• auditability en netwerkcontrole belangrijke eisen zijn.

Self-hosting is niet altijd de goedkoopste keuze. Bij lage volumes en weinig operationele eisen kan een managed API efficiënter zijn. LMXAI maakt die afweging expliciet op basis van workload, risico en total cost of ownership.

Van model naar production service

Een model op een GPU laden is nog geen production platform. LMXAI behandelt inference als een service met eigen reliability- en operationsvereisten.

Een traject kan bestaan uit:

1. Workload assessment — use cases, volume, privacy, latency en modelkwaliteit.
2. Model & hardware sizing — kandidaatmodellen, quantization en capaciteit.
3. Benchmarking — throughput, TTFT, concurrency en geheugenverbruik.
4. Deployment architecture — netwerk, Kubernetes, gateway, storage en identity.
5. Security hardening — secrets, access, egress en isolation.
6. Observability — metrics, traces, logs en modelgebruik.
7. Load & failure testing — pieken, timeouts, restarts en degradatie.
8. Production rollout — releaseproces, monitoring en capacity planning.

Ervaring met sovereign AI in Nederland

LMXAI heeft een sovereign enterprise AI-platform gebouwd voor een Nederlandse hostinggroep met meer dan 500 medewerkers. Daarbij werd een interne AI-werkplek ontworpen rond datasoevereiniteit, met onder andere vLLM, Kubernetes, FastAPI en on-premise inference.

LMXAI werkt daarnaast met open-model fine-tuning, LangGraph, MCP, Elasticsearch, OpenTelemetry en Phoenix voor production AI-systemen.

Bekijk het sovereign AI-project

Veelgestelde vragen

Kunnen we volledig zonder AWS, Azure en GCP draaien?

Ja. De kernstack kan op eigen of andere private infrastructuur worden gebouwd zonder verplichte hyperscalercomponenten.

Kunnen we internet-egress blokkeren?

Ja, wanneer de gekozen use case en operationele processen dat toelaten. Model artifacts, dependencies, updates en externe databronnen moeten dan vooraf in het deploymentproces worden meegenomen.

Kunnen we een eigen fine-tuned model draaien?

Ja. LMXAI werkt met LoRA/QLoRA en gequantiseerde modelvarianten en kan serving daarop afstemmen.

Kunnen meerdere interne applicaties dezelfde modelinfrastructuur gebruiken?

Ja. Een centrale gateway en model-servinglaag kan inference als interne platformdienst aanbieden met authenticatie, quotas, routing en observability.

Gerelateerd

• Intern gehoste AI-werkplek
• Soevereine vLLM
• Sovereign AI platform project
• EN: sovereign vLLM checklist

Een sovereign LLM-stack in Nederland bouwen?

LMXAI kan het traject uitvoeren van workloadanalyse en hardware sizing tot model serving, Kubernetes, gateway, RAG, agentic tooling en production hardening.

Bespreek uw sovereign AI-architectuur met LMXAI