AI-systemen: zelfgehoste assistenten, RAG en lokale infrastructuur

Inhoud

De meeste lokale AI-opstellingen beginnen met een model en een runtime.

U downloadt een gekwantiseerd model, start het via Ollama of een andere runtime en begint met prompten. Voor experimenteel gebruik is dit meer dan voldoende. Maar zodra u verder gaat dan nieuwsgierigheid — zodra u zich zorgen maakt over geheugen, de kwaliteit van ophaling (retrieval), routeringsbeslissingen of kostenbewustzijn — begint de eenvoud zijn beperkingen te tonen.

Deze cluster verkent een andere aanpak: het behandelen van de AI-assistent niet als een enkele modeloproep, maar als een gecoördineerd systeem.

Dat onderscheid lijkt op het eerste gezicht subtiel, maar het verandert de manier waarop u over lokale AI denkt volledig.

Orkestratie van AI-systemen met lokale LLMs, RAG en geheugenniveaus

Wat is een AI-systeem?

Een AI-systeem is meer dan alleen een model. Het is een orkestratieniveau dat inferentie, ophaling, geheugen en uitvoering verbindt tot iets dat zich gedraagt als een samenhangende assistent.

Lokaal een model draaien is infrastructuurwerk. Het ontwerpen van een assistent rondom dat model is systeemwerk.

Als u onze bredere gidsen heeft verkend over:

dan weet u al dat inferentie slechts één laag van de stack is.

De AI Systems-cluster rust bovenop die lagen. Het vervangt ze niet — het combineert ze.

OpenClaw: Een self-hosted AI-assistentsysteem

OpenClaw is een open-source, self-hosted AI-assistent die is ontworpen om te opereren over verschillende messagingplatforms terwijl het draait op lokale infrastructuur.

Op een praktisch niveau:

  • Gebruikt het lokale LLM-runtimes zoals Ollama of vLLM
  • Integreert het ophaling over geïndexeerde documenten
  • Onderhoudt het geheugen buiten een enkele sessie om
  • Voert het tools en automatiseringstaken uit
  • Kan het worden instrumenteerd en gemonitord
  • Werkt het binnen hardwarebeperkingen

Het is niet slechts een wrapper rondom een model. Het is een orkestratieniveau dat inferentie, ophaling, geheugen en uitvoering verbindt tot iets dat zich gedraagt als een samenhangende assistent.

Aan de slag en architectuur:

Context en analyse:

OpenClaw uitbreiden en configureren:

Plugins breiden de OpenClaw-runtime uit — door geheugenbackends, modelproviders, communicatiekanalen, webtools en observability toe te voegen. Skills breiden agentgedrag uit — door te definiëren hoe en wanneer de agent die capaciteiten gebruikt. Productieconfiguratie betekent beide combineren, vormgegeven rondom wie het systeem daadwerkelijk gebruikt.

Hermes: Een persistente agent met Skills en Tool-Sandboxing

Hermes Agent is een self-hosted, modelagnostische assistent die zich richt op persistente operatie: het kan draaien als een langlevend proces, tools uitvoeren via configureerbare backends en workflows verbeteren door middel van geheugen en herbruikbare skills.

Op een praktisch niveau is Hermes nuttig wanneer u wilt:

  • Een terminal-first assistent die ook kan bruggen naar messaging-apps
  • Providerflexibiliteit via OpenAI-compatibele endpoints en modelwisseling
  • Tool-uitvoeringsgrenzen via lokale en gesandboxde backends
  • Dag-twee-operaties met diagnostiek, logs en config-hygiëne

Hermes-profielen zijn volledig geïsoleerde omgevingen — elk met zijn eigen config, secrets, geheugens, sessies, skills en state — waardoor profielen de echte eenheid van productiebeheer zijn, niet de individuele skill.

Persistent kennis en geheugen

Sommige problemen worden niet opgelost door alleen maar een grotere contextvenster — ze hebben persistent kennis (grafieken, ingestiepipelines) en agent geheugenplugins (Honcho, Mem0, Hindsight en vergelijkbare backends) nodig die zijn aangesloten op assistenten zoals Hermes of OpenClaw.

  • AI Systems Geheugenhub — reikwijdte van de geheugen-subcluster plus links naar Cognee-handleidingen en stack-context
  • Agent geheugenproviders vergeleken — volledige vergelijking van Honcho, OpenViking, Mem0, Hindsight, Holographic, RetainDB, ByteRover en Supermemory voor Hermes-achtige integraties

MCP: Model Context Protocol Servers

Het Model Context Protocol (MCP) is een open standaard geïntroduceerd door Anthropic voor het verbinden van AI-taalmodellen met externe datasources, tools en systemen. Het lost het N×M-integratieprobleem op door een universele interface te bieden — denk eraan als een USB-C-poort voor AI-applicaties. Het bouwen van MCP-servers stelt u in staat AI-assistenten uit te breiden met custom integraties voor bestanden, databases, API’s en aanroepbare tools, met behulp van een eenvoudig JSON-RPC-gebaseerd protocol over stdio of HTTP.

  • MCP Server in Go — protocolarchitectuur, JSON-RPC-berichtstructuur, capability-negotiatie, officiële Go SDK en een stap-voor-stap tutorial voor het bouwen van MCP-servers in Go
  • MCP Servers Bouwen in Python — praktische Python-implementatiegids die websearch- en scraping-MCP-servers dekt, stdio- en SSE-transports, en Claude Desktop-integratie

Wat AI-systemen anders maakt

Meerdere kenmerken maken AI-systemen de moeite waard om nader te bestuderen.

Model Routing als Ontwerpkiezing

De meeste lokale opstellingen defaulten naar één model. AI-systemen ondersteunen het intentionele selecteren van modellen.

Dat stelt vragen:

  • Moeten kleine verzoeken kleinere modellen gebruiken?
  • Wanneer rechtvaardigt redenering een groter contextvenster?
  • Wat is het kostenverschil per 1.000 tokens?

Deze vragen verbinden zich direct met de prestatie-afwegingen besproken in de LLM-prestatiehandleiding en infrastructuurbeslissingen uitgelicht in de LLM-hostinghandleiding.

AI-systemen brengen die beslissingen aan de oppervlakte in plaats ze te verbergen.

Ophaling Wordt Behandeld als een Evoluerend Component

AI-systemen integreren documentophaling, maar niet als een simplistische “embed en zoek”-stap.

Ze erkennen:

  • Chunkgrootte beïnvloedt recall en kosten
  • Hybride zoekopdracht (BM25 + vector) kan beter presteren dan pure dense ophaling
  • Reranking verbetert relevantie ten koste van latentie
  • Indexeerstrategie beïnvloedt geheugengebruik

Deze thema’s sluiten aan bij de diepere architectuuroverwegingen besproken in de RAG-handleiding.

Het verschil is dat AI-systemen ophaling integreren in een levende assistent in plaats het te presenteren als een geïsoleerde demo.

Geheugen als Infrastructuur

Stateless LLMs vergeten alles tussen sessies.

AI-systemen introduceren persistente geheugenniveaus. Dat roept direct ontwerpvragen op:

  • Wat moet langdurig worden opgeslagen?
  • Wanneer moet context worden samengevat?
  • Hoe voorkomt u token-explosie?
  • Hoe indexeert u geheugen efficiënt?

Die vragen kruisen zich direct met datalaag-overwegingen uit de data-infrastructuurhandleiding. Voor Hermes Agent specifiek — begrensde twee-bestanden geheugen, prefix-caching, externe plugins — begin met Hermes Agent Geheugensysteem en de cross-framework vergelijking Agent geheugenproviders vergeleken. De AI Systems Geheugenhub lijst gerelateerde Cognee- en kennislaag-handleidingen.

Geheugen stopt met een feature te zijn en wordt een opslagprobleem.

Observability Is Niet Optioneel

De meeste lokale AI-experimenten stoppen bij “het reageert”.

AI-systemen maken het mogelijk om te observeren:

  • Tokengebruik
  • Latentie
  • Hardwarebenutting
  • Throughputpatronen

Dit verbindt zich natuurlijk met de monitoringsprincipes beschreven in de observability-handleiding.

Als AI draait op hardware, moet het meetbaar zijn zoals elke andere workload.

Hoe het Voelt om te Gebruiken

Van buitenaf kan een AI-systeem er nog steeds uitzien als een chatinterface.

Onder het oppervaal gebeurt er meer.

Als u het vraagt om een technisch rapport dat lokaal is opgeslagen samen te vatten:

  1. Het haalt relevante documentsegmenten op.
  2. Het selecteert een geschikt model.
  3. Het genereert een reactie.
  4. Het registreert tokengebruik en latentie.
  5. Het werkt persistent geheugen bij indien nodig.

De zichtbare interactie blijft eenvoudig. Het systeemgedrag is gelaagd.

Dat gelaagde gedrag is wat een systeem onderscheidt van een demo.

Waar AI-systemen in de Stack Thuisbehoren

De AI Systems-cluster bevindt zich op het snijpunt van meerdere infrastructuurniveaus:

  • LLM-hosting: Het runtimeniveau waar modellen worden uitgevoerd (Ollama, vLLM, llama.cpp)
  • RAG: Het ophalingniveau dat context en grondslag biedt
  • Prestaties: Het meetniveau dat latentie en throughput trackt
  • Observability: Het monitoringsniveau dat metrics en kostentracking biedt
  • Data-infrastructuur: Het opslag niveau dat geheugen en indexering afhandelt

Het begrijpen van dat onderscheid is nuttig. Het zelf draaien maakt het verschil duidelijker.

Voor een minimale lokale installatie met OpenClaw, zie de OpenClaw quickstart-handleiding, die u door een Docker-gebaseerde setup leidt met behulp van een lokaal Ollama-model of een cloudgebaseerde Claude-configuratie.

Als uw opstelling afhankelijk is van Claude, deze beleidsverandering voor agent-tools verduidelijkt waarom API-facturatie nu vereist is voor third-party OpenClaw-workflows.

Gerelateerde Bronnen

MCP-servers:

AI-assistent handleidingen:

Infrastructuurniveaus:

Abonneren

Ontvang nieuwe berichten over systemen, infrastructuur en AI-engineering.