Grote hoeveelheden data slim opdelen voor AI

AI in maatwerksoftware: wat komt er écht bij kijken?

AI werkt indrukwekkend goed met tekst.

Je stelt een vraag, geeft wat context mee en krijgt vaak binnen enkele seconden een bruikbaar antwoord. Maar zodra je AI wilt inzetten op grotere hoeveelheden informatie, wordt het ingewikkelder.

Want wat doe je met een compleet dossier? Een kennisbank met honderden artikelen? Een projectmap vol documenten? Een klantportaal met jaren aan historie? Of een administratief systeem waarin data verspreid staat over tabellen, notities, bestanden en berichten?

Je kunt die informatie niet zomaar in een grote prompt stoppen. En zelfs als een AI-model technisch gezien veel context aankan, blijft de vraag: welke informatie is op dit moment echt relevant?

Binnen ons R&D-traject NoardCode AI Gateway onderzoeken we daarom hoe grote hoeveelheden informatie slim kunnen worden gesegmenteerd, gestructureerd en aangeboden aan AI-modellen. Het doel: zorgen dat AI niet verdrinkt in data, maar precies de juiste context krijgt om betrouwbaar te kunnen antwoorden.

Meer data betekent niet automatisch betere AI

Een veelgemaakte denkfout is dat AI beter wordt als je er simpelweg meer informatie aan geeft.

In de praktijk werkt dat vaak anders.

Wanneer je een AI-model te veel context geeft, kan het antwoord juist minder scherp worden. Belangrijke details raken verstopt tussen minder relevante informatie. De prompt wordt duurder, trager en moeilijker te controleren. Bovendien neemt de kans toe dat het model verbanden legt die niet bedoeld zijn, of onderdelen van de informatie verkeerd weegt.

Meer data is dus niet altijd beter.

Betere selectie van data is meestal belangrijker.

AI heeft context nodig, maar dan wel de juiste context: actueel, relevant, volledig genoeg en passend bij de vraag die gesteld wordt.

Dat vraagt om een slimme laag tussen de applicatie, de databronnen en het AI-model.

Het probleem met een grote prompt

Stel: een organisatie wil AI gebruiken om vragen te beantwoorden op basis van interne documentatie. De eerste gedachte kan zijn: "We geven gewoon alle documenten mee aan het AI-model."

Dat klinkt logisch, maar levert direct problemen op.

Een prompt heeft grenzen. AI-modellen kunnen maar een bepaalde hoeveelheid tekst tegelijk verwerken. Die grenzen worden wel groter, maar verdwijnen niet. Daarnaast wordt een grote prompt al snel onoverzichtelijk, duur en traag.

Maar er is nog een belangrijker probleem: een grote prompt mist structuur.

Als je twintig documenten tegelijk meestuurt, weet het model niet automatisch welke onderdelen leidend zijn. Is een passage uit een oud document nog geldig? Is een notitie belangrijker dan een formeel beleid? Moet de AI alle bronnen even zwaar meewegen? Welke informatie hoort bij welke klant, gebruiker of context?

Zonder structuur kan AI wel antwoorden, maar wordt het moeilijk om te bepalen waarom het tot dat antwoord kwam.

Voor bedrijfssoftware is dat onvoldoende. Daar wil je niet alleen een goed geformuleerd antwoord, maar ook controle over de informatie waarop dat antwoord gebaseerd is.

Data opdelen in betekenisvolle stukken

Een belangrijk onderdeel van dit vraagstuk is chunking: het opdelen van informatie in kleinere stukken.

Maar simpelweg elke 1.000 woorden afknippen is meestal niet genoeg.

Goede chunking houdt rekening met betekenis. Een alinea, paragraaf, hoofdstuk, tabel, dossieronderdeel of processtap heeft vaak een natuurlijke samenhang. Als je informatie midden in een uitleg doorknipt, kan belangrijke context verloren gaan.

Daarom is de vraag niet alleen: hoe groot mag een stuk tekst zijn? Maar vooral: waar begint en eindigt een logisch informatiedeel?

Een goed segment kan bijvoorbeeld bestaan uit:

• een paragraaf met uitleg;
• een veelgestelde vraag met antwoord;
• een sectie uit een handleiding;
• een klantnotitie met metadata;
• een onderdeel uit een contract;
• een samenvatting van een langer document;
• een tabel met bijbehorende toelichting.

Door informatie betekenisvol op te delen, kan AI gerichter zoeken, combineren en antwoorden.

Metadata maakt context bruikbaar

Data opdelen is stap een. Maar zonder extra informatie blijft elk stukje tekst vrij plat.

Daarom is metadata belangrijk.

Metadata vertelt iets over het stukje informatie zelf. Bijvoorbeeld:

• uit welk document komt dit;
• van welke datum is het;
• bij welke klant of project hoort het;
• wie is de eigenaar;
• welk type informatie is het;
• is het concept, definitief of verouderd;
• welke rechten gelden hiervoor;
• welke taal of categorie heeft het;
• hoe betrouwbaar is de bron?

Voor AI-integratie is metadata niet alleen handig, maar vaak noodzakelijk.

Stel dat een gebruiker een vraag stelt over een lopend project. Dan wil je niet dat AI informatie ophaalt uit een oud offertedocument als er inmiddels een actuelere projectafspraak bestaat. Of dat een medewerker informatie ziet uit een dossier waar hij geen toegang toe heeft.

Metadata helpt om de juiste context te selecteren en de verkeerde context uit te sluiten.

RAG: AI met toegang tot relevante kennis

Een veelgebruikte techniek voor dit soort toepassingen is RAG, oftewel Retrieval Augmented Generation.

In gewone taal betekent dit: het AI-model krijgt niet alle informatie vooraf mee, maar haalt eerst relevante stukken informatie op uit een kennisbron. Pas daarna wordt het antwoord gegenereerd.

Het proces ziet er grofweg zo uit:

1. De gebruiker stelt een vraag.
2. De vraag wordt geanalyseerd.
3. Het systeem zoekt relevante informatie in documenten, databases of kennisbronnen.
4. Alleen de meest relevante context wordt aan het AI-model meegegeven.
5. Het model formuleert een antwoord op basis van die geselecteerde context.

Daarmee voorkom je dat het AI-model volledig afhankelijk is van wat het ooit heeft geleerd. Het kan werken met actuele, bedrijfsspecifieke informatie.

Maar RAG is geen magische oplossing. De kwaliteit hangt sterk af van hoe informatie wordt voorbereid, gesegmenteerd, geindexeerd en teruggevonden.

Garbage in, garbage out geldt ook hier.

Waarom retrieval lastig is

In theorie klinkt retrieval eenvoudig: zoek de juiste stukken informatie bij een vraag.

In de praktijk is dat ingewikkeld.

Een gebruiker stelt een vraag vaak anders dan hoe informatie in documenten staat. Iemand vraagt bijvoorbeeld: "Wat hebben we met deze klant afgesproken over support?"

Terwijl de relevante informatie verspreid staat over een offerte, een e-mailnotitie, een SLA-document en een projectverslag. Het woord "support" komt misschien niet eens overal letterlijk voor. Soms staat er "onderhoud", "beheer", "serviceniveau" of "nazorg".

Een goed retrieval-systeem moet dus meer kunnen dan zoeken op exacte woorden. Het moet betekenis kunnen herkennen, verbanden leggen en resultaten rangschikken op relevantie.

Daarbij spelen meerdere vragen:

• Welke documenten zijn relevant?
• Welke passages binnen die documenten zijn relevant?
• Welke bron is het meest actueel?
• Welke informatie mag deze gebruiker zien?
• Hoeveel context is genoeg?
• Welke informatie spreekt elkaar mogelijk tegen?

Daarom onderzoeken we hoe contextbeheer, promptopbouw en retrieval-technieken kunnen samenwerken om kwaliteitsverlies bij grote informatievolumes te voorkomen.

Contextvensters bewust vullen

Ook nadat relevante informatie is gevonden, blijft er een keuze over: wat geef je uiteindelijk mee aan het AI-model?

Een AI-model heeft een contextvenster. Dat is de ruimte waarin instructies, gebruikersvraag en aanvullende informatie passen. Die ruimte moet verstandig worden gebruikt.

Geef je te weinig context mee, dan mist het model belangrijke details. Geef je te veel context mee, dan wordt het antwoord trager, duurder en mogelijk minder precies.

Een goede AI-integratie moet dus kunnen bepalen:

• welke informatie essentieel is;
• welke informatie ondersteunend is;
• welke informatie kan worden samengevat;
• welke informatie niet meegestuurd mag worden;
• hoeveel ruimte er overblijft voor de daadwerkelijke opdracht;
• hoe de context het beste geordend kan worden.

Dit is een belangrijk verschil tussen AI gebruiken en AI professioneel integreren in software.

Het gaat niet alleen om de prompt, maar om de hele contextstrategie eromheen.

Samenvatten zonder betekenis te verliezen

Bij grote hoeveelheden data is samenvatten vaak nodig. Maar samenvatten brengt risico's met zich mee.

Een samenvatting kan details verliezen. Een nuance kan verdwijnen. Een uitzondering kan worden weggelaten. Een datum of voorwaarde kan verkeerd worden geinterpreteerd.

Daarom moet je goed nadenken over wanneer je samenvat en wanneer je broninformatie intact laat.

Soms is een samenvatting geschikt om snel overzicht te geven. Maar bij juridische, financiele, medische of contractuele informatie wil je mogelijk altijd terug naar de exacte bronpassage.

Voor bedrijfssoftware betekent dit dat AI niet alleen een antwoord moet geven, maar ook moet kunnen laten zien waarop dat antwoord is gebaseerd. Bronverwijzingen, contextlogging en herleidbaarheid worden dan belangrijk.

Structuur helpt tegen hallucinaties

AI kan overtuigend klinken, ook wanneer het antwoord niet klopt. Dat noemen we vaak hallucineren.

Een goede datastructuur kan dat risico verminderen.

Wanneer AI werkt met duidelijk geselecteerde bronnen, actuele context en gecontroleerde instructies, wordt de kans kleiner dat het model zelf ontbrekende informatie gaat invullen.

Daarom is het belangrijk om AI expliciet te laten werken binnen de grenzen van de beschikbare context.

Bijvoorbeeld:

• antwoord alleen op basis van de opgehaalde bronnen;
• geef aan wanneer informatie ontbreekt;
• benoem onzekerheden;
• verwijs naar de gebruikte bron;
• maak onderscheid tussen feit, interpretatie en advies.

Dit soort instructies werkt alleen goed als de onderliggende data ook netjes is voorbereid.

Rechten en toegang mogen niet vergeten worden

Bij grote hoeveelheden data speelt nog een ander belangrijk punt: autorisatie.

Niet elke gebruiker mag alle informatie zien. Dat geldt in gewone software, en dus ook in AI-functionaliteit.

Als een medewerker via AI een vraag stelt, moet het systeem dezelfde rechten respecteren als de applicatie zelf. AI mag geen sluiproute worden naar informatie waar iemand normaal geen toegang toe heeft.

Dat betekent dat retrieval rekening moet houden met toegangsrechten.

Een AI-integratie moet dus niet alleen zoeken naar de meest relevante informatie, maar naar de meest relevante informatie waar deze gebruiker toegang toe heeft.

Dat is vooral belangrijk bij klantportalen, interne kennisbanken, HR-systemen, zorgapplicaties, administratieve dossiers en projectomgevingen.

Van document naar bruikbare AI-context

Het slim opdelen van data is dus geen technische bijzaak. Het is een voorwaarde voor betrouwbare AI.

Een document uploaden is makkelijk. Een document bruikbaar maken voor AI is lastiger.

Daarvoor moet je nadenken over:

• tekstextractie;
• structuurherkenning;
• chunking;
• metadata;
• embeddings;
• indexing;
• retrieval;
• rechten;
• actualiteit;
• bronverwijzingen;
• contextopbouw;
• kwaliteitscontrole.

Pas als die keten goed werkt, kan AI op een betrouwbare manier antwoorden geven op basis van grote hoeveelheden informatie.

Wat betekent dit voor maatwerksoftware?

Voor maatwerksoftware is dit vraagstuk extra interessant.

Veel organisaties hebben al waardevolle data in hun systemen, maar die data is niet automatisch geschikt voor AI. Informatie staat verspreid over databases, documenten, bijlagen, notities, exports en externe koppelingen.

De uitdaging is om die informatie niet zomaar aan AI te geven, maar om er een bruikbare kennislaag van te maken.

Voor Laravel- en maatwerkapplicaties betekent dit bijvoorbeeld:

• data uit bestaande modellen en tabellen structureren;
• documenten koppelen aan de juiste entiteiten;
• rechten vanuit de applicatie meenemen in retrieval;
• queues gebruiken voor indexatie en verwerking;
• wijzigingen in data automatisch opnieuw verwerken;
• bronverwijzingen opslaan;
• context per gebruiker of rol bepalen;
• AI-output valideren en loggen.

Daarmee wordt AI geen losse functie, maar een uitbreiding van de bestaande applicatiearchitectuur.

Wat onderzoeken we binnen de NoardCode AI Gateway?

Binnen de NoardCode AI Gateway onderzoeken we hoe grote hoeveelheden informatie efficient kunnen worden verwerkt zonder kwaliteitsverlies in AI-output.

Daarbij kijken we onder andere naar:

• automatische segmentatie van datasets;
• structurering van informatie voor AI-verwerking;
• promptoptimalisatie;
• contextbeheer;
• RAG-technieken;
• batching;
• caching;
• kwaliteitscontrole van antwoorden;
• herleidbaarheid naar bronnen.

De centrale vraag is: hoe zorgen we dat AI precies genoeg context krijgt om goed te antwoorden, zonder te veel, te weinig of verkeerde informatie mee te geven?

Dat klinkt misschien eenvoudig, maar in praktijk raakt het aan architectuur, datamodellering, security, performance en gebruikerservaring.

Wat leren we hiervan?

De belangrijkste les is dat AI niet alleen slimmer wordt door betere modellen. AI wordt vooral bruikbaarder door betere context.

Voor organisaties betekent dit dat de voorbereiding van data minstens zo belangrijk is als de keuze voor het AI-model.

Wie AI serieus wil inzetten op eigen informatie, moet nadenken over de volledige keten: van document naar segment, van segment naar index, van vraag naar relevante context, van context naar antwoord, en van antwoord terug naar controleerbare bron.

Dat is de basis voor betrouwbare AI in bedrijfssoftware.

Tot slot

Grote hoeveelheden data slim opdelen voor AI draait niet om zoveel mogelijk informatie meesturen. Het draait om de juiste informatie, op het juiste moment, in de juiste vorm.

Binnen de NoardCode AI Gateway onderzoeken we hoe we die contextlaag kunnen vormgeven voor maatwerksoftware. Want pas wanneer AI begrijpt welke informatie relevant is, en welke niet, ontstaat er echte waarde.

In de volgende blog gaan we dieper in op privacy: wat gebeurt er met gevoelige data voordat een prompt naar een AI-model gaat?