Waarom een eigen GPT op je website misschien wel de beste investering in AI is

Het zit in de kennis die je de AI geeft.

Geplaatst op: 02-07-2026
Door: Ton Haex, in de categorie: Ai & Technologie
Trefwoorden: Kunstmatige Intelligentie • Gpt • Eigen Kennisbank

Overal chatbots

De afgelopen twee jaar zijn chatbots bijna overal opgedoken. Steeds meer websites hebben rechtsonder een klein venster waarin je vragen kunt stellen. Soms werkt dat verrassend goed. Soms krijg je antwoorden waarvan je denkt: waar haalt die dit in vredesnaam vandaan?

Dat verschil zit meestal niet in de AI zelf. Het zit in de kennis die je de AI geeft.

Steeds vaker zie je websites die een eigen GPT of AI-assistent aanbieden. Niet als vervanging van de website, maar als slimme gids die bezoekers helpt sneller de juiste informatie te vinden. Ik geloof dat dit de komende jaren een van de interessantste toepassingen van AI wordt.

Sterker nog, ik ben bezig met de ontwikkeling van mijn eigen TonGPT voor tonhaex.nl. Niet omdat ik graag een chatbot wilde hebben, maar omdat ik merkte dat mijn website inmiddels is uitgegroeid tot een enorme verzameling kennis.

Een website wordt ongemerkt een bibliotheek

Veel websites beginnen klein. Een paar pagina's. Een handvol blogartikelen. Misschien een contactformulier. Maar na verloop van tijd groeit zo'n website uit tot iets heel anders.

Dat is bij tonhaex.nl precies gebeurd. In de loop der jaren heb ik honderden artikelen geschreven over AI, fotografie, reizen, RapidWeaver, Apple, Neural Garden, podcasts en creativiteit. Zelf weet ik meestal nog wel waar iets staat. Voor bezoekers is dat een stuk lastiger.

Een zoekfunctie helpt dan maar beperkt. Mensen zoeken namelijk zelden op precies de woorden die jij in een artikel hebt gebruikt. Iemand zoekt bijvoorbeeld niet op "ChatGPT". Die vraagt: "Welke AI raad je aan als je net met pensioen bent?"

Een klassieke zoekmachine begrijpt zo'n vraag nauwelijks. Een goede AI-assistent juist wel.

Een GPT is geen zoekmachine

Dat is misschien wel de grootste misvatting. Een GPT is niet bedoeld om een lijst met zoekresultaten te tonen. Een goede GPT begrijpt de bedoeling van een vraag. Vraagt iemand: "Ik wil mijn foto's verbeteren."

Dan kan de assistent begrijpen dat de bezoeker waarschijnlijk op zoek is naar artikelen over fotobewerking, AI-tools of fotografie. Dat levert veel betere antwoorden op dan een traditionele zoekfunctie. Eigenlijk wordt je website daardoor veel toegankelijker.

Wanneer heeft een eigen GPT echt zin?

Niet iedere website heeft er iets aan. Heb je een eenvoudige website met vijf pagina's, dan is een chatbot waarschijnlijk overbodig. Maar een eigen GPT kan enorm waardevol zijn wanneer je:

  • regelmatig nieuwe blogs publiceert;
  • veel documentatie aanbiedt;
  • een kennisbank hebt;
  • producten of diensten uitlegt;
  • cursussen aanbiedt;
  • bezoekers veel vragen stellen.

Hoe groter de hoeveelheid informatie, hoe interessanter een GPT wordt.

Begin niet met AI, begin met je inhoud

Dat klinkt misschien vreemd. Toch is de inhoud veel belangrijker dan de techniek. Een GPT kan alleen goede antwoorden geven als de broninformatie klopt. Vraag jezelf daarom eerst af:

  • Zijn mijn artikelen actueel?
  • Is de informatie volledig?
  • Zijn de teksten goed geschreven?
  • Is de structuur logisch?

AI maakt een rommelige kennisbank niet beter. Ze maakt die rommel alleen sneller doorzoekbaar.

Hoe pak je het slim aan?

Ik zou het project in een aantal overzichtelijke stappen verdelen.

Stap 1: Verzamel je kennis

Breng alle relevante informatie bij elkaar. Dat kunnen blogartikelen zijn, handleidingen, FAQ's, PDF-documenten of andere teksten. Hoe beter de kwaliteit van die informatie, hoe beter de antwoorden worden.

Stap 2: Zorg voor een duidelijke structuur

Een GPT leert niet zoals een mens. Het zoekt naar relevante informatie. Daarom helpt een logische structuur enorm. Werk met duidelijke titels, tussenkopjes en categorieën.

Stap 3: Bouw klein

Hier zie ik veel projecten misgaan. Mensen willen meteen:

  • spraakherkenning;
  • gebruikersaccounts;
  • dashboards;
  • statistieken;
  • meerdere AI-modellen;
  • uitgebreide instellingen.

Mijn advies is precies het tegenovergestelde. Laat de eerste versie maar één ding goed doen: Een vraag beantwoorden op basis van jouw eigen website. Meer hoeft het in het begin niet te zijn.

Stap 4: Test met echte bezoekers

Vraag vrienden, collega's of vaste bezoekers om vragen te stellen. Niet alleen makkelijke vragen, maar juist onverwachte. Daar leer je veel meer van dan van honderd technische tests.

Stap 5: Blijf verbeteren

Een GPT is nooit echt af. Iedere nieuwe blog, handleiding of pagina maakt het systeem weer iets slimmer. Zie het als een levende uitbreiding van je website.

TonGPT als praktijkvoorbeeld

Voor mijn eigen website ben ik bezig met TonGPT. Het idee is eenvoudig. Geen algemene chatbot die overal antwoord op probeert te geven, maar een gids die de inhoud van tonhaex.nl kent. Een bezoeker zou bijvoorbeeld kunnen vragen:

  • Welke artikelen schreef Ton over AI?
  • Wat is Neural Garden?
  • Waar heeft hij overwinterd?
  • Welke Apple-producten gebruikt hij?
  • Wat zijn goede AI-tools voor senioren?

TonGPT zoekt eerst in mijn eigen artikelen en stelt daarna een antwoord samen. Kan het systeem geen passend antwoord vinden? Dan zegt het dat gewoon eerlijk. Dat vind ik belangrijker dan een indrukwekkend, maar onjuist antwoord.

Privacy hoort geen sluitpost te zijn

Bij veel AI-diensten worden gesprekken opgeslagen of gebruikt om systemen verder te trainen. Ik wil dat anders aanpakken. Voor TonGPT is privacy een uitgangspunt, geen extra functie. Dat betekent:

  • geen gebruikersaccounts;
  • geen opgeslagen gesprekken;
  • geen zoekgeschiedenis;
  • geen persoonlijke profielen;
  • geen analyse van wie wat vraagt.

Bezoekers moeten vrij zijn om een vraag te stellen zonder het gevoel te hebben dat ze gevolgd worden. Juist in een tijd waarin steeds meer gegevens worden verzameld, voelt dat voor mij als een bewuste keuze.

De techniek is tegenwoordig niet meer het grootste probleem

Een paar jaar geleden was het bouwen van een eigen AI-assistent alleen weggelegd voor grote bedrijven. Dat is veranderd. Met moderne AI-modellen, programmeerhulpmiddelen zoals Codex en open-source componenten is het voor enthousiaste makers ineens haalbaar geworden om zelf een professionele oplossing te bouwen. Dat betekent niet dat het eenvoudig is. Maar wel dat de drempel veel lager ligt.

Meer dan een chatbot

Ik denk dat een eigen GPT uiteindelijk veel meer wordt dan een chatvenster rechtsonder op een website. Het wordt een persoonlijke gids. Een digitale bibliothecaris. Een assistent die bezoekers helpt om sneller te vinden wat jij in de loop der jaren hebt opgebouwd. En misschien is dat wel de grootste kracht van AI. Niet dat ze onze kennis vervangt. Maar dat ze die eindelijk echt toegankelijk maakt.

Tot slot

Ik zie TonGPT niet als een experiment, maar als een logische volgende stap in de ontwikkeling van mijn website. Misschien duurt het nog even voordat alles werkt zoals ik het voor ogen heb. Misschien loop ik onderweg tegen onverwachte problemen aan. Dat hoort erbij. Maar één ding weet ik nu al zeker. Als je website uitgroeit tot een waardevolle verzameling kennis, dan is een eigen GPT geen leuke gadget meer. Dan wordt het misschien wel de beste gids die je je bezoekers kunt geven.


Tien praktische tips voordat je een eigen GPT gaat bouwen

Na maanden experimenteren met AI heb ik één belangrijke conclusie getrokken: de techniek is tegenwoordig niet meer de grootste uitdaging. De grootste uitdaging is bepalen wat je eigenlijk wilt bouwen. Voordat je enthousiast begint met Python, Codex of de OpenAI API, zou ik eerst deze tien tips ter harte nemen.

1. Begin met een duidelijk doel

Vraag jezelf af waarom je een GPT wilt bouwen. Wil je vragen beantwoorden? Een kennisbank toegankelijk maken? Klanten ondersteunen? Of wil je bezoekers vooral helpen de juiste informatie te vinden? Hoe duidelijker je doel, hoe eenvoudiger de rest van het project wordt.

2. Bouw geen algemene chatbot

Een GPT hoeft niet alles te weten. Sterker nog, hoe kleiner het kennisgebied, hoe beter de antwoorden meestal worden. Mijn TonGPT hoeft geen belastingadvies te geven of recepten te bedenken. Hij moet vooral mijn website kennen.

3. Investeer eerst in goede content

AI kan geen slechte artikelen verbeteren. Wanneer je website verouderde of onduidelijke informatie bevat, zal een GPT diezelfde informatie gebruiken. Goede AI begint daarom met goede inhoud.

4. Zorg voor structuur

Gebruik duidelijke titels. Werk met categorieën. Maak logische tussenkoppen. Een goed gestructureerde website is veel eenvoudiger te doorzoeken.

5. Laat de GPT eerlijk zijn

Misschien wel de belangrijkste tip. Laat het systeem nooit doen alsof het iets weet. Kan er geen passend antwoord gevonden worden Laat dat dan gewoon eerlijk weten. Dat vergroot het vertrouwen van bezoekers enorm.

6. Denk vanaf het begin aan privacy

Privacy moet geen extra functie zijn. Maak het een uitgangspunt. Sla geen gesprekken op. Maak geen gebruikersprofielen. Bewaar geen zoekgeschiedenis. Bezoekers moeten vrij zijn om vragen te stellen zonder gevolgd te worden.

7. Houd de eerste versie klein

Iedere programmeur kent het probleem. Je begint met een eenvoudig idee. Een week later heb je twintig nieuwe functies bedacht. Weer een week later werkt niets meer. Mijn advies: Laat versie 1 alleen vragen beantwoorden. Meer niet.

8. Gebruik AI ook tijdens het bouwen

Dat klinkt misschien vreemd. Maar ChatGPT en Codex zijn uitstekende programmeerpartners. Gebruik AI niet alleen in het eindproduct. Gebruik AI ook om het eindproduct te bouwen.

9. Test met echte bezoekers

Jij weet hoe jouw website werkt. Een bezoeker niet. Laat daarom anderen vragen stellen. Juist onverwachte vragen leveren vaak de beste verbeteringen op.

10. Zie je GPT als een levend project

Een GPT is nooit klaar. Iedere nieuwe blog. Iedere nieuwe handleiding. Iedere nieuwe FAQ. Maakt het systeem weer iets slimmer. Zie het daarom niet als software die je ooit afrondt. Zie het als een nieuwe medewerker die steeds meer ervaring krijgt.

Zo zou ik vandaag beginnen met het bouwen van een eigen GPT

Inmiddels heb ik behoorlijk wat geëxperimenteerd met verschillende AI-tools. Als ik vandaag helemaal opnieuw zou beginnen, zou ik ongeveer onderstaande stappen volgen.

Stap 1 – Bepaal waarvoor de GPT bedoeld is

Dit lijkt vanzelfsprekend, maar wordt vaak overgeslagen. Schrijf letterlijk op:

  • Welke vragen moeten bezoekers kunnen stellen?
  • Welke antwoorden verwacht je?
  • Welke informatie mag gebruikt worden?
  • Welke informatie juist niet?

Bij TonGPT is het antwoord eenvoudig. Alles draait alleen om de inhoud van tonhaex.nl.

Stap 2 – Verzamel alle kennis

Een GPT is zo goed als zijn bronmateriaal. Verzamel daarom:

  • blogartikelen;
  • handleidingen;
  • FAQ's;
  • Markdownbestanden;
  • PDF-documenten;
  • pagina's van je website.

Controleer meteen of de informatie nog actueel is.

Stap 3 – Maak de inhoud schoon

Dit is misschien wel het minst spannende onderdeel. Maar wel één van de belangrijkste. Verwijder:

  • dubbele teksten;
  • oude informatie;
  • kapotte links;
  • verouderde pagina's.

Hoe beter de kwaliteit van je content, hoe beter de antwoorden.

Stap 4 – Maak een sitemap

Een goede sitemap is goud waard. Daardoor weet de GPT precies welke pagina's beschikbaar zijn. Voor websites die regelmatig veranderen is dit eigenlijk onmisbaar.

Stap 5 – Kies de techniek

Er zijn meerdere mogelijkheden. Je kunt een bestaande dienst gebruiken. Maar je kunt ook zelf bouwen. Mijn voorkeur gaat uit naar:

  • Python;
  • FastAPI;
  • OpenAI API;
  • embeddings;
  • een vectordatabase zoals ChromaDB;
  • een eenvoudige JavaScript-widget.

Niet omdat dit de enige oplossing is. Wel omdat deze combinatie veel vrijheid biedt.

Stap 6 – Maak een kennisbank

Nu wordt de inhoud verwerkt. De artikelen worden opgesplitst in kleinere stukken. Vervolgens worden daarvan zogenaamde embeddings gemaakt. Dat klinkt ingewikkeld, maar zie het als een slimme inhoudsopgave die niet zoekt op woorden, maar op betekenis.

Stap 7 – Bouw de zoeklaag

Wanneer iemand een vraag stelt, gebeurt er eerst iets belangrijks. De AI gaat niet direct antwoorden. Ze zoekt eerst naar de meest relevante informatie. Pas daarna wordt een antwoord samengesteld. Dat heet Retrieval-Augmented Generation, oftewel RAG. Juist hierdoor blijft een GPT dicht bij de inhoud van je eigen website.

Stap 8 – Schrijf een goede systeemprompt

Misschien wel het belangrijkste document van het hele project. Hierin leg je vast:

  • wie de GPT is;
  • welke toon gebruikt wordt;
  • welke bronnen gebruikt mogen worden;
  • hoe om te gaan met onzekerheid;
  • wanneer de GPT moet zeggen dat hij iets niet weet.

Deze instructies bepalen uiteindelijk voor een groot deel de kwaliteit van de antwoorden.

Stap 9 – Bouw een eenvoudige interface

Maak het bezoekers gemakkelijk met:

  • één invoerveld.
  • één knop.
  • één antwoord.

Meer is niet nodig. Een rustige, overzichtelijke interface nodigt veel meer uit tot gebruik dan een scherm vol functies.

Stap 10 – Test, verbeter en blijf leren

Nu begint eigenlijk pas het echte werk. Gebruik de GPT zelf. Laat anderen hem uitproberen. Kijk waar antwoorden tekortschieten. Pas de kennisbank aan. Voeg nieuwe artikelen toe. Verbeter de prompt.

Een goede GPT groeit mee met je website.

Mijn persoonlijke aanpak Voor TonGPT kies ik bewust voor een eenvoudige eerste versie. Ik wil geen systeem dat indruk maakt met allerlei technische hoogstandjes. Ik wil een systeem dat bezoekers helpt. Dat eerlijk is. Dat snel werkt. Dat mijn artikelen begrijpt. En dat de privacy van bezoekers volledig respecteert. Als dat lukt, dan is de basis gelegd. Alle andere uitbreidingen kunnen later altijd nog volgen. Ik heb geleerd dat de mooiste projecten niet ontstaan doordat je alles tegelijk probeert te bouwen. Ze ontstaan doordat je één goede eerste versie maakt en die daarna stap voor stap blijft verbeteren.


De complete technische architectuur van TonGPT

Toen ik voor het eerst nadacht over een eigen GPT, stelde ik me een enorme berg ingewikkelde techniek voor. Servers, databases, kunstmatige intelligentie en waarschijnlijk heel veel programmeerwerk. In werkelijkheid valt dat best mee. Natuurlijk zit er veel techniek achter, maar als je het systeem opdeelt in losse bouwstenen, wordt het ineens overzichtelijk. Eigenlijk doet TonGPT niets anders dan de juiste informatie vinden en die vervolgens begrijpelijk aan de bezoeker uitleggen. Onder de motorkap bestaat het systeem uit een aantal onderdelen die nauw samenwerken.

Stap 1 – De website als kennisbron

Alles begint met de inhoud van de website. Voor TonGPT betekent dat onder andere:

  • alle blogartikelen;
  • de Markdown-bestanden;
  • vaste pagina's;
  • handleidingen;
  • FAQ's;
  • Neural Garden;
  • reisverhalen;
  • AI-artikelen;
  • eventuele PDF-documenten.

De website vormt dus de complete kennisbank. Dat klinkt vanzelfsprekend, maar het heeft een groot voordeel. Ik hoef dezelfde informatie maar op één plaats te onderhouden. Schrijf ik een nieuw artikel, dan wordt TonGPT automatisch slimmer zodra de kennisbank opnieuw wordt opgebouwd.

Stap 2 – De sitemap als routekaart

Vrijwel iedere moderne website heeft een sitemap. Zie die als de inhoudsopgave van je website. In plaats van duizenden pagina's handmatig op te zoeken, leest TonGPT simpelweg de sitemap. Daarin staat precies welke pagina's beschikbaar zijn. Nieuwe artikelen worden daardoor automatisch meegenomen. Dat maakt het onderhoud vrijwel volledig automatisch.

Stap 3 – De crawler

Nu begint het echte werk. Een crawler bezoekt iedere pagina uit de sitemap. Daarbij worden onder andere verwijderd:

  • menu's;
  • voetteksten;
  • navigatie;
  • reclame;
  • overbodige HTML.

Wat overblijft is precies waar het om draait: de inhoud. Dat is uiteindelijk de informatie waarmee TonGPT gaat werken.

Stap 4 – De teksten opdelen

Een AI-model kan geen complete website van duizenden pagina's tegelijk lezen. Daarom worden alle artikelen verdeeld in kleinere stukken. Vaak zijn dat tekstblokken van enkele honderden woorden. Dat lijkt misschien een detail, maar juist daardoor kan het systeem heel nauwkeurig zoeken. Wanneer iemand vraagt naar RapidWeaver hoeft TonGPT niet een compleet artikel van drieduizend woorden door te nemen. Alleen het relevante gedeelte wordt gebruikt.

Stap 5 – Van tekst naar betekenis

Hier gebeurt iets bijzonders. Iedere tekst wordt omgezet naar zogenaamde embeddings. Dat zijn geen samenvattingen. Ook geen trefwoorden. Je kunt ze het beste zien als een wiskundige beschrijving van de betekenis van een tekst. Daardoor begrijpt het systeem dat iemand die vraagt: "Ik wil een slimme assistent voor mijn website." waarschijnlijk hetzelfde bedoelt als iemand die zoekt op: "Eigen GPT bouwen." Hoewel de woorden verschillen, is de bedoeling vrijwel hetzelfde. En precies daarin zit de kracht van moderne AI.

Stap 6 – De vectordatabase

Alle embeddings worden opgeslagen in een vectordatabase. Voor TonGPT denk ik aan ChromaDB. Je kunt zo'n database vergelijken met een enorme bibliotheek. Niet gesorteerd op alfabet. Maar op betekenis. Wanneer iemand een vraag stelt, zoekt de database niet naar woorden. Ze zoekt naar de inhoud die het meest lijkt op de bedoeling van die vraag. Dat levert veel betere resultaten op.

Stap 7 – De RAG-laag

Nu komt een term die je steeds vaker hoort: RAG, oftewel Retrieval-Augmented Generation. Dat klinkt ingewikkeld. Eigenlijk betekent het alleen maar dat de AI eerst zoekt en daarna pas antwoord geeft. Dat is een enorm verschil met een gewone chatbot. Het proces ziet er ongeveer zo uit:

  1. Bezoeker stelt een vraag.
  2. Vectordatabase zoekt de meest relevante tekstfragmenten.
  3. Die fragmenten worden samen met de vraag naar het AI-model gestuurd.
  4. Pas daarna wordt het antwoord geschreven.

Daardoor blijft het antwoord dicht bij de inhoud van de website. En dat verkleint de kans op verzinsels aanzienlijk.

Stap 8 – De systeemprompt

Nog voordat TonGPT antwoord geeft, krijgt hij een duidelijke instructie. Daarin staat bijvoorbeeld: Beantwoord uitsluitend vragen op basis van tonhaex.nl. Verzin niets. Geef eerlijk aan wanneer informatie ontbreekt. Schrijf vriendelijk. Gebruik begrijpelijke taal. Verwijs waar mogelijk naar relevante artikelen. Je kunt de systeemprompt zien als het karakter van de assistent. Niet de kennis. Maar de manier waarop hij zich gedraagt.

Stap 9 – Het AI-model

Pas helemaal aan het einde komt het AI-model zelf in beeld. Veel mensen denken dat dit het belangrijkste onderdeel is. Ik denk juist dat het de laatste schakel is. Het model krijgt:

  • de vraag;
  • relevante informatie uit mijn website;
  • de systeemprompt.

Op basis daarvan schrijft het een antwoord. Niet uit zijn algemene geheugen. Maar op basis van mijn eigen kennisbank.

Stap 10 – De chatwidget

Aan de voorkant ziet de bezoeker uiteindelijk maar één klein venster.

  • Een eenvoudig invoerveld.
  • Een knop.
  • Een antwoord.

Alle ingewikkelde techniek blijft verborgen. En dat is precies zoals het hoort. Goede techniek hoeft niet op te vallen. Ze moet gewoon prettig werken.

Privacy vanaf de tekentafel

Voor mij is privacy geen functie die je later toevoegt. Ze hoort vanaf de eerste regel code onderdeel van het ontwerp te zijn. Daarom wil ik TonGPT zo bouwen dat:

  • geen gesprekken worden opgeslagen;
  • geen zoekgeschiedenis wordt bewaard;
  • geen gebruikersprofielen ontstaan;
  • geen persoonlijke gegevens worden verzameld;
  • geen gedrag van bezoekers wordt geanalyseerd.

Met andere woorden:

  1. Een bezoeker stelt een vraag.
  2. TonGPT geeft antwoord.

En daarna is het gesprek verdwenen. Precies zoals een gesprek aan een informatiebalie ook niet automatisch wordt opgenomen.

Waarom ik voor deze architectuur kies

Ik had ook kunnen kiezen voor een kant-en-klare commerciële oplossing. Maar zelf bouwen heeft een aantal voordelen. Ik houd controle over mijn eigen kennis. Ik bepaal welke AI-modellen worden gebruikt. Ik kan nieuwe functies toevoegen wanneer ik dat wil. En misschien wel het belangrijkste: Ik begrijp straks precies hoe het systeem werkt. Voor mij is dat minstens zo waardevol als het eindresultaat.

Hoe de onderdelen samenwerken

Als je alles terugbrengt tot de essentie, ziet de complete architectuur van TonGPT er verrassend eenvoudig uit: Website → Sitemap → Crawler → Tekst opschonen → Teksten opdelen → Embeddings → Vectordatabase → RAG → GPT-model → Chatwidget → Bezoeker

Dat lijkt misschien een lange keten, maar ieder onderdeel heeft slechts één duidelijke taak. Juist daardoor blijft het systeem overzichtelijk, uitbreidbaar en eenvoudig te onderhouden. En misschien is dat wel de belangrijkste les die ik tijdens dit project heb geleerd. Een goede GPT begint niet bij kunstmatige intelligentie. Een goede GPT begint bij een goed georganiseerde website.

Waar reizen, AI en verbeelding samenkomen in verhalen, beelden en digitale experimenten.

Nieuwsgierig blijven is misschien wel de mooiste reis die je kunt maken. Bedankt dat je een stukje met mij meereist.

© Alle rechten voorbehouden, © 2026

☕ Steun mijn creatieve werk