AI-platform voor entity enrichmentJe documenten worden een database.
Een AI-raamwerk waarmee mensen en AI-agents genormaliseerde relationele databases bouwen, vullen en laten meegroeien. Begin met PDF's, foto's, spraakmemo's, CSV-bestanden of een bestaande database, of beschrijf simpelweg wat je nodig hebt. Entity Enricher maakt een bewerkbaar schema en workflows die je data verrijken, dubbele entiteiten oplossen en je database up-to-date houden.
Voer een live verrijking uitEen enrichment begint met een verzoek en vult het schema voor één entity en de entities die eraan gekoppeld zijn. Vijf spelers worden achtereenvolgens verrijkt: een club of een land dat bij een eerdere speler is gevonden, wordt herkend en niet opnieuw toegevoegd.
Elk veld van een schema is een vraag
De verrijkingen hierboven vullen een schema met waarden. Hier is hetzelfde schema als klassendiagram: elk object van de JSON-structuur, met zijn velden, die elk hun JSON-type (string, number, boolean…) tonen op de plek waar een waarde zou staan. Elk veld heeft een beschrijving, en als je de aanwijzer op een veld houdt of erop tikt, opent die beschrijving — de vraag — met de voorbeelden van het veld, de waarden die het kan aannemen als het om een gesloten set gaat, en de expert die de vraag beantwoordt; de kop van een object opent de beschrijving van het object zelf. Een verbinding naar een ander object is ook een veld: het draagt de naam van het veld en opent de vraag die het model vertelt naar welk object het verwijst.
Elke beschrijving is de vraag die aan het taalmodel wordt gesteld voor de waarde van dat veld. Schemageneratie schrijft ze, en de schema-editor kan ze aanpassen, om een vraag preciezer te maken of een onduidelijkheid weg te nemen voordat er enrichment wordt uitgevoerd.
Eén identificatie per club met semantische ID's, hoe de naam ook geschreven wordt
Elke verrijking schrijft een club zoals de bronnen dat doen: FC Barcelona in het record van de ene speler, Futbol Club Barcelona in het volgende. Elke club die in een record voorkomt, krijgt een semantische ID, die het model nooit invult en die in de drie stappen hieronder wordt bepaald, de goedkoopste eerst. Bij twijfel wordt er een nieuwe ID aangemaakt: twee ID's samenvoegen kost één klik, een verkeerde samenvoeging terugdraaien niet.
Elke verrijking wordt rijen in je tabellen
Een schema dat aan een database is gekoppeld, wordt een reeks tabellen: één per entiteitstype, één per lijst, elk via foreign keys aan de andere gekoppeld. Een verrijking wordt in één transactie weggeschreven: de rijen waarnaar wordt verwezen vóór de rijen die ernaar verwijzen. Een entiteit die een eerdere verrijking al heeft weggeschreven, voegt geen nieuwe rij toe: de rij wordt bijgewerkt of blijft zoals die is. Een schema dat aan geen enkele database is gekoppeld, eindigt bij de uitvoer van de verrijking zelf: gestructureerde JSON, gevalideerd tegen het schema.
Eén wachtrij naar je database, voor rijen en schemawijzigingen
Een database sync bewaart de entiteiten in je eigen PostgreSQL-database. Elke verrijking wordt één transactie met upserts, voor de entiteit en de entiteiten die eraan gekoppeld zijn; het publiceren van een schemawijziging wordt een migratie. Beide wachten in dezelfde wachtrij, in de volgorde waarin ze aankomen, en de ee-database-client past de kop van de wachtrij toe en bevestigt die daarna. Een nieuwe kolom bestaat dus al vóór de eerste rij die hem vult, en de eerder weggeschreven rijen houden daar NULL.
ee-database is een opensourceprogramma (MIT-licentie) dat op je server of laptop draait, naast de database waarnaar het schrijft. Het opent de verbinding zelf, naar buiten toe richting Entity Enricher, zodat de database geen verbindingen van buitenaf aanneemt en de inloggegevens die machine nooit verlaten.
Een schema dat AI bouwt op basis van jouw datavoorbeelden
Het voorbeeld, geëxtraheerd uit een document of met de hand geschreven, vormt de eerste versie van het schema, die je daarna in het platform bewerkt.
Van document naar voorbeeld
Een voorbeeld kan uit een document worden geëxtraheerd — hier het record van een boekhandel voor The Fellowship of the Ring (het record als PDF). Een extractie behoudt elke waarde die het document vermeldt: de auteur en de uitgever, maar ook de hoofdstukken, de personages en het schap van het boek in de winkel. Een document geeft je geen zeggenschap over welke velden eruit komen.
De gebruiker behoudt daarna de velden waarvoor het schema bedoeld is. Een boekencatalogus heeft een titel, een genre, een jaar en een prijs, een auteur, een serie en een uitgever nodig: de andere velden worden terzijde gelegd. Wat overblijft is het voorbeeld van dit boek, het eerste van de vijf die in de volgende stappen worden gelezen; één document levert één voorbeeld, de andere komen uit andere boeken.
Van voorbeeld naar entiteitenkaart
Entity Enricher leest een sample van je data en herkent de entiteiten die erin worden beschreven — hier boeken, auteurs, reeksen en uitgevers — samen met de velden die elk ervan identificeren. Deze entiteiten zijn voorstellen: het schema houdt de platte structuur van de sample aan totdat de gebruiker er met één klik een eigen entiteit van maakt. De velden ervan verhuizen dan mee, en een auteur die door meerdere boeken wordt genoemd, wordt één entiteit met zijn eigen unieke identificatie.
Velden verdeeld over experts
Schemageneratie groepeert de velden op basis van de kennis die ze vragen en geeft elke groep een expert: hier een literaire expert voor titels, genres, auteurs en reeksen, en een uitgeverij-expert voor uitgevers, prijzen en publicatiejaren.
Bij verrijking kan elke expert een eigen call worden die parallel loopt: een model dat alleen naar prijzen en uitgevers wordt gevraagd, antwoordt vollediger dan een model dat alles tegelijk moet beantwoorden.
Elke expert beschrijft zijn velden
Elke expert schrijft daarna de beschrijving van zijn eigen velden, in zijn eigen vocabulaire: welk jaar het jaar van een boek is, en in welke valuta en op welke datum de prijs wordt gelezen. De experts schrijven naast elkaar, elk met één aanroep.
Een beschrijving is de vraag die een model bij verrijking voor zijn veld beantwoordt; een precieze beschrijving zorgt er dus voor dat twee modellen, of twee runs, het veld op dezelfde manier vullen.
Velden die een entiteit identificeren
Voor elk entiteitstype kiest de schemageneratie de velden die één exemplaar identificeren — de titel van een boek, de naam van een auteur. Dante en Dan Brown schreven beide een Inferno: een boek wordt onderscheiden door titel en auteur samen.
Een semantische ID voor elke entiteit
Wanneer je semantische ID's opvraagt, krijgt elk object dat een entiteit voorstelt een id-veld: het boek en elke entiteit die eronder genest is — auteur, reeks, uitgever. Het model vult dit nooit in: na elke verrijking wordt het bepaald op basis van de identificerende velden van de entiteit, zodat dezelfde auteur die op twee manieren geschreven is, één identifier houdt.
Een object dat alleen feiten over zijn bovenliggende object bevat — hier het jaar en de prijs van het boek — krijgt er geen: geen enkel veld erin identificeert iets. Een koppeling ook niet, zoals het deelnummer van een boek in zijn reeks: die wordt geïdentificeerd door de twee entiteiten die ze met elkaar verbindt.
Meertalige velden
Een tekstveld kan als meertalig worden gemarkeerd: het bevat dan één waarde per gevraagde taal — een titel, een genre of een land in elk van die talen, een naam in het schrift van elke taal. Een jaar of een prijs blijft één enkele waarde. De identiteit wordt in de eerste taal gelezen, dus een vertaalde titel levert nooit een tweede boek op.
Identificatoren blijven ongewijzigd
Voor elke entiteit vullen een of meer taalmodellen het schema in op basis van de bijgevoegde documenten en hun eigen kennis. Een veld dat als behouden is gemarkeerd, is de uitzondering: de waarde komt uit je eigen systeem — een rij-id, een interne referentie — en gaat ongewijzigd door de verrijking heen, zodat elk verrijkt boek terugkeert naar de rij waar het uit kwam. Zonder die markering is het veld van het model om in te vullen, en houdt niets het tegen om het ISBN dat het kent te schrijven in plaats van jouw id.
Een database ontworpen op basis van jouw schema
Een schema dat aan een database is gekoppeld, wordt een reeks tabellen. Het ontwerp zit vooral in hoe die tabellen zich tot elkaar verhouden: welke rijen meerdere entiteiten delen, en welke bij één entiteit horen. Een taalmodel antwoordt op die vragen; de regels van de projectie doen de rest.
Eén tabel per soort ding
Een database bewaart zijn gegevens in tabellen. Een tabel is een raster: elke kolom bevat één veld, elke rij één ding. Wanneer een schema aan een database wordt gekoppeld, krijgt elk entiteitstype een eigen tabel — hier
football_player— en wordt elke verrijkte speler één rij daarvan.Een groep velden zonder eigen identiteit, zoals het debuut van een speler, heeft geen tabel nodig: de velden worden kolommen van dezelfde rij, genoemd naar het pad ernaartoe —
senior_debuts_club_date.Wat twee rijen van elkaar onderscheidt
Elke tabel heeft een sleutel: de kolommen die de ene rij van de andere onderscheiden. Een speler wordt onderscheiden door volledige naam en geboortedatum samen, een land door zijn ISO-code. De sleutels worden gekozen bij het koppelen van het schema, uit de velden die elke entiteit identificeren.
Als een speler opnieuw wordt verrijkt, vindt de sleutel de rij die die speler al heeft: de rij wordt bijgewerkt en er ontstaat geen duplicaat.
Een relatie is een verwijzing
In een platte spreadsheet staat een club op de rij van elke speler die er gespeeld heeft, met het oprichtingsjaar elke keer opnieuw gekopieerd. Kopieën lopen uiteen: zodra er één wordt gecorrigeerd, bevatten de andere nog de oude waarde.
In een database wordt de club één keer opgeslagen, in een eigen tabel, en elke periode bevat alleen een verwijzing ernaar — een foreign key, het
_idvan de club. Die relaties tussen tabellen houden de gegevens betrouwbaar: elk feit staat op één plek, en elke rij die het nodig heeft, verwijst daarnaar.Gedeeld of eigen: de vraag die het model beantwoordt
Voor elke relatie in het schema krijgt een taalmodel één vraag: kan een andere speler naar precies diezelfde rij verwijzen? Een club, een stad, een land of een competitie bestaat los van welke speler dan ook, dus het antwoord is ja, en de rij wordt gedeeld door elke speler die ernaar verwijst.
Bij elk antwoord hoort een reden, die je leest en kunt herroepen voordat de database wordt aangemaakt. Voor dit schema beoordeelde het model achttien relaties, en stelde het bij elk daarvan vast dat ze naar iets gedeelds verwijzen.
Rijen die bij één speler horen
De periode van een speler bij een club bevat feiten die alleen voor die speler gelden: de jaren, de doelpunten. De rijen zijn eigen: elke speler heeft zijn eigen rijen, zelfs bij dezelfde club, en elke rij verwijst naar die ene gedeelde clubrij.
De schakelaar laat zien wat het verkeerde oordeel zou doen. Als gedeeld vallen de twee periodes samen in één rij per club en overschrijft de tweede verrijking de waarden van de eerste speler. Daarom geldt een relatie als eigen totdat blijkt dat ze gedeeld is: een verkeerde samenvoeging beschadigt data, terwijl een gemiste samenvoeging alleen een extra rij kost.
Kolomtypes en indexen
Elke kolom krijgt een type van zijn veld: een lengte wordt een decimaal getal, een jaar een geheel getal, een geboortedatum een datum. Een nauwkeurig type laat de database zijn waarden vergelijken, sorteren en controleren.
Een index is een gesorteerde kopie van een aantal kolommen, waarmee de database rijen kan vinden zonder de hele tabel te lezen. Namen krijgen een zoekindex, en het model stemt andere indexen af op de lijstweergaven die een applicatie zal tonen — hier spelers gefilterd op lengte en gesorteerd op naam.
Eén schema per workflow, één database voor meerdere
Een schema is één workflow: met een eigen voorbeeld, eigen verrijkingsruns en een eigen webhook zodra er een resultaat binnenkomt. Eén database kan aan meerdere schema's gekoppeld zijn. Twee workflows die hetzelfde soort ding benoemen — hier de clubstad van een speler, en een stad die op zichzelf verrijkt wordt — schrijven naar dezelfde tabel: de workflow die de stad alleen benoemt schrijft de identiteit, de workflow die erover gaat vult de rest, en elke kolom buiten de identiteit heeft precies één schrijver.
Bij het koppelen van een schema wordt het getoetst aan de al gekoppelde schema's: een type dat beide benoemen, moet met dezelfde sleutel worden onderscheiden. De Database Sync-gids beschrijft de controles.
Van ruwe data naar een informatiesysteem
Eén pijplijn neemt alles wat je hebt — documenten, spreadsheets, half ingevulde rijen — en geeft records terug waar je database op kan vertrouwen.
Bron
Breng een batch mee uit je bestaande systeem — of één nieuwe entiteit op het moment dat die verschijnt. Documenten, afbeeldingen, webzoekopdrachten en de wereldkennis van LLM's vullen aan wat jouw gegevens niet zeggen.
Structuur
Beschrijf je doel in gewone taal of plak een voorbeeld — AI stelt een getypeerd schema op met expertisedomeinen. Verfijn het visueel of via chat.
Verifiëren
Meerdere modellen antwoorden parallel, per kennisdomein. Conflicten worden veld voor veld gedetecteerd en opgelost via regels of een AI-arbiter — waarbij de redenering wordt vastgelegd.
Integreren
Gevalideerde records komen terug met je originele keys woordelijk behouden en semantic IDs als stabiele join-keys. Geen duplicaten, geen re-keying — tot 40 talen per veld.
Twee manieren om het te voeden
Batch — vanuit je bestaande systeem
Haal honderden entiteiten op uit je database, CRM of elk REST-endpoint — plak JSON of haal een URL op met authenticatie. Verrijk ze parallel, volg de voortgang live, schrijf schone records terug — of exporteer naar Excel.
Direct — zodra nieuwe entiteiten binnenkomen
Komt er een nieuwe lead, product of document je systeem binnen? Verrijk het in seconden — met één API-aanroep, een n8n/Make-trigger of rechtstreeks vanuit een chat via MCP. Gestructureerd, gevalideerd, klaar om in te voegen.
Beide paden delen dezelfde semantische ID's — een entiteit die vandaag in een batch wordt verrijkt en morgen on-the-fly opnieuw wordt aangetroffen, komt nog steeds terecht op één record.
Elke waarde heeft een papieren spoor
De meeste AI-tools vragen je om de uitvoer te vertrouwen. Wij laten je inspecteren hoe die is bepaald.
Pre-flightcontrole
Een snel model classificeert de entiteit eerst tegen je schema. “Titan” als planeet verrijken? Je wordt gewaarschuwd voordat er ook maar één token wordt besteed.
Modellen in competitie
Twee of meer LLM's antwoorden onafhankelijk. Uitvoer wordt tegen het schema gevalideerd; fouten gaan terug naar het model om automatisch zichzelf te corrigeren.
Gearbitreerd, vastgelegd
Conflicten op veldniveau opgelost door meerderheid, mediaan of een AI-arbiter. Elke beslissing — alle kandidaatwaarden, de winnaar, de redenering — wordt op het record opgeslagen.
Acme Corp
Elke entiteit: bedrijf, geneesmiddel, rechtszaak, onderzoekspaper...
Match — Bedrijf
Vangt typemismatches op voordat je LLM-credits verspilt.
Breng je eigen API-sleutels mee — werkt met elke LLM-provider.
Schema opgesplitst per domein — zelfcorrigerende prompts proberen het opnieuw bij een validatiefout.
Deep merge van expertise-reacties per model.
Acme Corp
GearbitreerdBeredeneerde conflictoplossing op veldniveau levert het uiteindelijke betrouwbare resultaat op.
Acht verdedigingslagen staan tussen de verbeelding van een LLM en je database. Hoe we hallucinaties voorkomen →
Je gegevens, je modellen, je keys
Gebouwd voor teams waarvan de data het gebouw niet mag verlaten — cloudgemak met volledige controle over waar inferentie plaatsvindt.
Breng je eigen API-sleutels mee
Gebruik de Anthropic-, OpenAI- of Gemini-sleutels van je organisatie — jouw facturering, jouw gegevensverwerkingsovereenkomsten. Platformsleutels zijn slechts de standaard zonder installatie.
Draai modellen op je eigen hardware
Koppel binnen twee minuten een laptop of on-prem GPU-server en route enrichments via een beveiligde tunnel naar je lokale Ollama. Gevoelige gegevens bereiken nooit een cloud-LLM.
Hoe de tunnel werkt →Tenant-geïsoleerd by design
Records, schema's, bestanden en conceptregisters zijn organisatiegebonden. Rolgebaseerde toegangscontrole tot op elke API-sleutel.
Organisaties en rollen →Waarom Entity Enricher
Speciaal gebouwd voor gestructureerde LLM-verrijking — dit is wat het toevoegt ten opzichte van één modelaanroep of een zelfgebouwde pipeline.
Sluit aan op je informatiesysteem
IngebouwdVoeg een database sync toe aan een schema en enrichments worden gespiegeld naar je eigen PostgreSQL als echte relationele tabellen — een SQL-snapshot om het te vullen, een idempotente delta-feed om het geconvergeerd te houden, en een open-source syncclient die het toepast zonder plakcode. Invoersleutels worden letterlijk behouden, en elke entity krijgt een stabiele semantic ID: een kant-en-klare koppelsleutel die “Headache”, “Céphalée” en “Cephalalgia” tot één record samenbrengt, in plaats van drie.
Ruwe JSON per aanroep. Jij ontwerpt opslag, sleutels, matching en afstemming voordat het je systemen kan raken.
Aangepast schema
Jij bepaalt de uitvoerstructuur. Elk entiteitstype, willekeurige velden, willekeurige nestingdiepte.
Eén zelfgeschreven prompt levert één platte structuur op. Nesting, types en validatie bouw je allemaal zelf.
Multi-model
Voer 2+ LLM's tegelijk uit. Vergelijk resultaten. Gebruik van elk het beste.
Eén model, één provider. Geen manier om te kruisvalideren of de nauwkeurigheid te verbeteren.
Fusie & arbitrage
Conflictdetectie op veldniveau met op regels gebaseerde of via LLM gearbitreerde oplossing.
Blind vertrouwen in één bron. Geen besef van conflicten.
Elk domein, elke entiteit
Juridische entiteiten, farmaceutische verbindingen, onderzoekspapers, vastgoed — van alles.
Elk nieuw domein betekent nieuwe prompts, nieuwe validatie, nieuw koppelwerk — één pipeline per entiteitstype.
Meertalig van nature
IngebouwdMarkeer een veld één keer als meertalig. Eén enkele enrichment-aanroep geeft de waarde vertaald in elke taal die je hebt geselecteerd — tot 40 — zonder extra LLM-aanroepen of vertaalpijplijn.
Alleen Engelse output. Vertaling is een aparte stap, aparte kosten en een aparte faalmodus.
Breng je eigen documenten mee
NieuwVoeg PDF's, slides, spreadsheets, contracten, scans en audio-opnamen toe. Modellen die vision, PDF en audio ondersteunen lezen ze rechtstreeks; de rest wordt server-side geëxtraheerd en automatisch opgenomen.
Alleen tekstinvoer. Documenten zijn jouw probleem — converteren, OCR, transcriberen, opdelen en opschonen voordat je kunt verrijken.
Standaard kostengeoptimaliseerd
IngebouwdPromptcaching hergebruikt de gedeelde prompt over parallelle calls tegen ~10% van de invoerprijs, elke expertise ziet alleen zijn eigen velden, en een goedkope voorafcontrole voorkomt dat je betaalt voor het verrijken van de verkeerde entiteit.
Vaste prijs per record zonder optimalisatie op tokenniveau — en geen inzicht in wat je daadwerkelijk hebt uitgegeven.
Werkt waar jij werkt
Ontwerp je schema één keer en verrijk vervolgens op elke schaal — vanuit de webapp, vanuit geautomatiseerde workflows of rechtstreeks vanuit je eigen code.
Batchverrijking
Verrijk honderden entiteiten parallel vanuit de web-app. Realtime streaming, auto-fusie, Excel-export.
n8n- & Make-workflows
Geautomatiseerde pipelines: activeer bij nieuwe data, verrijk en push naar je CRM of database. 400+ app-integraties.
REST API
Programmatische toegang voor aangepaste integraties. Getypeerd OpenAPI-schema, organisatiegebonden sleutels, sync- en streaming-endpoints.
Verbind met 400+ apps via n8n
Bouw geautomatiseerde verrijkingspijplijnen met de visuele workfloweditor van n8n. Haal data uit elke bron, verrijk met AI en stuur resultaten overal naartoe.
Entity Enricher levert een ingebouwde MCP (Model Context Protocol)-server. Toon je schema's, verrijk een entiteit, bekijk het resultaat — allemaal vanuit de chat. Geen workfloweditor nodig.
De open-source ee-database-client houdt je eigen PostgreSQL geconvergeerd met elke verrijking — snapshot-bootstrap, gevolgd door een live deltafeed over een uitgaande verbinding. Geen workflow om te bouwen, en je connectiestring verlaat nooit je machine.
Gebouwd voor elk domein
Niet alleen B2B-contacten. Definieer een schema voor elk entiteitstype en verrijk het.
Hoe we vergelijken
Kom je van een webonderzoeks-API, een spreadsheet-onderzoeksagent — of bouw je je eigen LLM-pijplijn? Dit is waar Entity Enricher staat.
| Functie | Entity Enricher | Parallel AI | AI-onderzoeksagents | DIY LLM-pipeline |
|---|---|---|---|---|
| Aangepast genest schema | Plat JSON-schema | Eén prompt per kolom | Handmatig gecodeerd | |
| Multi-modelverrijking | Jij orkestreert | |||
| Fusie & conflictoplossing | ||||
| Audittrail op veldniveau | Bronvermeldingen + betrouwbaarheid | |||
| Deduplicatie van gekoppelde entiteiten (semantische ID's) | ||||
| Synchroniseren naar je eigen PostgreSQL | CSV-/sheet-export | Jij bouwt het | ||
| Je documenten als bronnen | Wisselend | Jij bouwt het | ||
| Elk entiteitstype | ||||
| Meertalige output (40 talen) | Jij bouwt het | |||
| BYOK / zelfgehoste modellen | Zelden | |||
| Batchverwerking | Jij bouwt het | |||
| Onderhoud | Beheerd | Beheerd | Beheerd | Van jou, voor altijd |
| Prijzen | Betalen per token | $5-25 / 1k rijen | Credits / abonnement | Eng-tijd + tokens |
Vul het verleden aan. Verrijk de toekomst.
De kennis van je bedrijf staat al op papier — maak die opvraagbaar. Begin gratis, gebruik je eigen API-keys en betaal alleen de LLM-kosten.
Gratis aan de slag