AI Entity Enrichment PlatformYour documents become a database.
An AI harness for people and AI agents to build, populate, and evolve normalized relational databases. Start with PDFs, photos, voice memos, CSV files, an existing database, or simply describe what you need. Entity Enricher creates an editable schema and workflows that enrich your data, resolve duplicate entities, and keep your database up to date.
Run a live enrichmentAn enrichment starts from a request and fills the schema for one entity and those linked to it. Five players are enriched in turn: a club or a country found for an earlier player is recognized, not added again.
Every Field of a Schema Is a Question
The enrichments above fill a schema with values. Here is the same schema as a class diagram: each object of its JSON structure, with its fields, each showing its JSON type (string, number, boolean…) where a value would stand. Every field carries a description, and resting the pointer on a field, or tapping it, opens that description — the question — with the field's examples, the values it may take when it is a closed set, and the expert that answers it; the header of an object opens the description of the object itself. A link to another object is a field too: it carries the field's name and opens the question that tells the model which object it links to.
Each description is the question the language model is asked for that field's value. Schema generation writes them, and the schema editor can edit them, to make a question more precise or to remove an ambiguity before any enrichment runs.
One Identifier per Club with semantic IDs, However Its Name Is Written
Each enrichment writes a club the way its sources do: FC Barcelona in one player's record, Futbol Club Barcelona in the next. Every club a record names gets a semantic ID, never filled by the model, resolved in the three steps below, cheapest first. When in doubt, a new ID is created: merging two IDs takes one click, undoing a wrong merge does not.
Each Enrichment Becomes Rows in Your Tables
A schema linked to a database becomes tables: one per entity type, one per list, each joined to the others by its foreign keys. An enrichment is written in one transaction, the referenced rows before the rows that refer to them. An entity an earlier enrichment already wrote adds no new row: its row is updated, or left as it is. A schema linked to no database ends at the enrichment's own output: structured JSON, validated against the schema.
One Queue to Your Database, for Rows and Schema Changes Alike
A database sync keeps the entities in a PostgreSQL database of your own. Each enrichment becomes one transaction of upserts, for the entity and those linked to it; publishing a schema change becomes a migration. Both wait in the same queue, in the order they arrive, and the ee-database client applies its head, then acknowledges it. A new column therefore exists before the first row that fills it, and the rows written earlier hold NULL there.
ee-database is an open-source program (MIT license) that runs on your server or laptop, next to the database it writes to. It opens the connection itself, outward to Entity Enricher, so the database accepts no connection from outside and its credentials never leave that machine.
A Schema Built by AI From Your Data Samples
The sample, extracted from a document or written by hand, builds the schema's first version, which is then edited in the platform.
From a document to a sample
A sample can be extracted from a document — here, a bookshop's record of The Fellowship of the Ring (the record as a PDF). An extraction keeps every value the document states: the author and the publisher, but also the chapters, the characters and the book's shelf in the shop. A document gives no say over which fields come out.
The user then keeps the fields the schema is for. A catalogue of books needs a title, a genre, a year and a price, an author, a series and a publisher: the other fields are set aside. What is left is this book's sample, the first of the five the next steps read; a document gives one sample, the others come from other books.
From a sample to an entity map
Entity Enricher reads a sample of your data and recognizes the entities it describes — here, books, authors, series and publishers — along with the fields that identify each one. These entities are proposals: the schema keeps the sample's flat shape until the user turns one into an entity of its own, in one click. Its fields then move under it, and an author cited by several books becomes one entity with its own unique identifier.
Fields shared out among experts
Schema generation groups the fields by the knowledge they call for, and gives each group an expert: here a literary expert for titles, genres, authors and series, and a publishing expert for publishers, prices and publication years.
At enrichment, each expert can become a call of its own, run in parallel: a model asked only about prices and publishers answers them more fully than one asked about everything at once.
Each expert describes its fields
Each expert then writes the description of its own fields, in its own vocabulary: which year a book's year is, in which currency and at which date its price is read. The experts write side by side, one call each.
A description is the question a model answers for its field at enrichment, so a precise one is what makes two models, or two runs, fill the field alike.
Fields that identify an entity
For each entity type, schema generation picks the fields that identify one instance — a book's title, an author's name. Dante and Dan Brown each wrote an Inferno: a book is told apart by its title and its author together.
A semantic ID for each entity
When semantic IDs are requested, each object that represents an entity gets an id field: the book, and each entity nested under it — author, series, publisher. The model never fills it: after each enrichment, it is resolved from the entity's identifying fields, so the same author written two ways keeps one identifier.
An object that only holds facts of its parent — here the book's year and price — gets none: no field in it identifies anything. Neither does a pairing, such as a book's volume number in its series: it is identified by the two entities it relates.
Multilingual fields
A text field can be marked multilingual: it then holds one value per requested language — a title, a genre or a country written in each of them, a name in each language's script. A year or a price stays a single value. Identity is read in the first language, so a translated title never creates a second book.
Identifiers kept as they are
For each entity, one or several language models fill the schema from the attached documents and from their own knowledge. A field marked preserved is the exception: its value comes from your own system — a row id, an internal reference — and passes through the enrichment unchanged, so each enriched book goes back to the row it came from. Unmarked, the field is the model's to fill, and nothing keeps it from writing the ISBN it knows in place of your id.
A Database Designed From Your Schema
A schema linked to a database becomes tables. Most of the design lies in how those tables relate: which rows several entities share, which belong to one. A language model answers those questions; the projection's rules do the rest.
One table per kind of thing
A database keeps its data in tables. A table is a grid: each column holds one field, each row one thing. When a schema is linked to a database, each entity type gets a table of its own — here
football_player— and each enriched player becomes one row of it.A group of fields with no identity of its own, such as a player's debut, needs no table: its fields become columns of the same row, named after the path down to them —
senior_debuts_club_date.What tells two rows apart
Each table has a key: the columns that tell one row from another. A player is told apart by full name and date of birth together, a country by its ISO code. The keys are chosen when the schema is linked, among the fields that identify each entity.
When a player is enriched again, the key finds the row that player already has: the row is updated, and no duplicate appears.
A relationship is a pointer
In a flat spreadsheet, a club appears on the row of every player who played there, its founding year copied each time. Copies drift apart: once one is corrected, the others still hold the old value.
In a database the club is stored once, in a table of its own, and each spell holds only a pointer to it — a foreign key, the club's
_id. These relationships between tables are what keeps the data reliable: each fact lives in one place, and every row that needs it points there.Shared or owned: the question the model answers
For each relationship of the schema, a language model is asked one question: could another player point at this very same row? A club, a city, a country or a competition exists apart from any one player, so the answer is yes, and the row is shared by every player who points at it.
Each answer comes with its reason, which the user reads, and can overturn, before the database is created. For this schema the model judged eighteen relationships, and found each of them pointing at something shared.
Rows that belong to one player
A player's spell at a club holds facts true for that player only: the years, the goals. Its rows are owned: each player has rows of their own, even at the same club, and each points at the one shared club row.
The switch shows what the wrong verdict would do. Shared, the two spells collapse into one row per club, and the second enrichment overwrites the first player's values. This is why a relationship is owned until shown to be shared: a wrong merge corrupts data, while a missed one only costs a second row.
Column types and indexes
Each column takes a type from its field: a height becomes a decimal number, a year an integer, a birth date a date. A precise type lets the database compare, sort and check its values.
An index is a sorted copy of some columns, which lets the database find rows without reading the whole table. Names get a search index, and the model shapes other indexes after the list screens an application will show — here, players filtered by height and sorted by name.
One Schema per Workflow, One Database for Several
A schema is one workflow: its own sample, its own enrichment runs, its own webhook when a result lands. A database can be linked to several. Two workflows that name the same kind of thing — here a player's club city, and a city enriched in its own right — write the same table: the one that only names it writes its identity, the one about it fills the rest, and each column beyond the identity has exactly one writer.
Linking a schema checks it against the ones already linked: a type both name must be told apart by the same key. The database sync guide details the checks.
From Raw Data to Information System
One pipeline takes whatever you have — documents, spreadsheets, half-filled rows — and returns records your database can trust.
Source
Bring a batch from your existing system — or a single new entity the moment it appears. Documents, images, web search, and LLM world knowledge fill what your data doesn’t say.
Structure
Describe your target in plain language or paste a sample — AI drafts a typed schema with expertise domains. Refine it visually or by chat.
Verify
Multiple models answer in parallel, per knowledge domain. Conflicts are detected field by field and resolved by rules or an AI arbiter — with the reasoning recorded.
Integrate
Validated records flow back with your original keys preserved verbatim and semantic IDs as stable join keys. No duplicates, no re-keying — up to 40 languages per field.
Two ways to feed it
Batch — from your existing system
Pull hundreds of entities from your database, CRM, or any REST endpoint — paste JSON or fetch a URL with auth. Enrich them in parallel, watch progress live, write clean records back — or export to Excel.
On the fly — as new entities arrive
A new lead, product, or document enters your system? Enrich it in seconds — one API call, an n8n/Make trigger, or straight from a chat via MCP. Structured, validated, ready to insert.
Both paths share the same semantic IDs — an entity enriched today in a batch and re-encountered tomorrow on the fly still lands on one record.
Every Value Has a Paper Trail
Most AI tools ask you to trust the output. We let you inspect how it was decided.
Pre-flight check
A fast model classifies the entity against your schema first. Enriching “Titan” as a planet? You’re warned before a single token is spent.
Models in competition
Two or more LLMs answer independently. Outputs are schema-validated; errors go back to the model to self-correct, automatically.
Arbitrated, recorded
Field-level conflicts resolved by majority, median, or an AI arbiter. Every decision — all candidate values, the winner, the reasoning — is stored on the record.
Acme Corp
Any entity: company, drug, legal case, research paper...
Match — Company
Catches type mismatches before wasting LLM credits.
Bring your own API keys — works with any LLM provider.
Schema split by domain — self-correcting prompts retry on validation failure.
Deep merge of expertise responses per model.
Acme Corp
ArbitratedReasoned field-level conflict resolution produces the final trusted result.
Eight defense layers stand between an LLM’s imagination and your database. How we prevent hallucinations →
Your Data, Your Models, Your Keys
Built for teams whose data can’t leave the building — cloud convenience with full control over where inference happens.
Bring your own API keys
Use your organization’s Anthropic, OpenAI, or Gemini keys — your billing, your data-processing agreements. Platform keys are just the zero-setup default.
Run models on your own hardware
Pair a laptop or on-prem GPU server in two minutes and route enrichments through a secure tunnel to your local Ollama. Sensitive data never reaches a cloud LLM.
How the tunnel works →Tenant-isolated by construction
Records, schemas, files, and concept registries are organization-scoped. Role-based access control down to each API key.
Organizations & roles →Why Entity Enricher
Purpose-built for structured LLM enrichment — here is what it adds over a single model call or a hand-built pipeline.
Plugs Into Your Information System
Built-inAdd a database sync to a schema and enrichments mirror into your own PostgreSQL as real relational tables — SQL snapshot to seed it, an idempotent delta feed to keep it converged, and an open-source sync client that applies it with zero glue code. Input keys are preserved verbatim, and each entity gets a stable semantic ID: a ready-made join key that resolves “Headache”, “Céphalée” and “Cephalalgia” into one record, not three.
Raw JSON per call. You design storage, keys, matching, and reconciliation before it can touch your systems.
Custom Schema
You define the output structure. Any entity type, any fields, any nesting depth.
One hand-rolled prompt returns one flat shape. Nesting, types, and validation are all yours to build.
Multi-Model
Run 2+ LLMs simultaneously. Compare results. Use the best of each.
Single model, single provider. No way to cross-validate or improve accuracy.
Fusion & Arbitration
Field-level conflict detection with rule-based or LLM-arbitrated resolution.
Blind trust in a single source. No conflict awareness.
Any Domain, Any Entity
Legal entities, pharma compounds, research papers, real estate — anything.
Every new domain means new prompts, new validation, new plumbing — a pipeline per entity type.
Multilingual by Design
Built-inMark a field multilingual once. A single enrichment call returns the value translated into every language you selected — up to 40 — with no extra LLM calls or translation pipeline.
English-only output. Translation is a separate step, a separate cost, and a separate failure mode.
Bring Your Own Documents
NewAttach PDFs, slides, spreadsheets, contracts, scans, audio recordings. Vision-, PDF- and audio-capable models read them directly; the rest are extracted server-side and inlined automatically.
Text-only inputs. Documents are your problem — convert, OCR, transcribe, chunk, and clean before you can enrich.
Cost-Optimized by Default
Built-inPrompt caching reuses the shared prompt across parallel calls at ~10% of input price, each expertise only sees its own fields, and a cheap pre-flight check stops you paying to enrich the wrong entity.
Flat per-record pricing with no token-level optimization — and no visibility into what you actually spent.
Works Where You Work
Design your schema once, then enrich at any scale — from the web app, from automated workflows, or straight from your own code.
Batch Enrichment
Enrich hundreds of entities in parallel from the web app. Real-time streaming, auto-fusion, Excel export.
n8n & Make Workflows
Automated pipelines: trigger on new data, enrich, push to your CRM or database. 400+ app integrations.
REST API
Programmatic access for custom integrations. Typed OpenAPI schema, org-scoped keys, sync and streaming endpoints.
Connect to 400+ apps via n8n
Build automated enrichment pipelines with n8n's visual workflow editor. Pull data from any source, enrich with AI, and push results anywhere.
Entity Enricher ships an embedded MCP (Model Context Protocol) server. List your schemas, enrich an entity, inspect the result — all from the chat. No workflow editor required.
The open-source ee-database client keeps your own PostgreSQL converged with every enrichment — snapshot bootstrap, then a live delta feed over an outbound connection. No workflow to build, and your connection string never leaves your machine.
Built for Every Domain
Not just B2B contacts. Define a schema for any entity type and enrich it.
How We Compare
Coming from a web-research API, a spreadsheet research agent — or building your own LLM pipeline? Here’s where Entity Enricher stands.
| Feature | Entity Enricher | Parallel AI | AI Research Agents | DIY LLM Pipeline |
|---|---|---|---|---|
| Custom Nested Schema | Flat JSON schema | One prompt per column | Hand-coded | |
| Multi-Model Enrichment | You orchestrate | |||
| Fusion & Conflict Resolution | ||||
| Field-Level Audit Trail | Citations + confidence | |||
| Linked-Entity Dedup (Semantic IDs) | ||||
| Sync to Your Own PostgreSQL | CSV / sheet export | You build it | ||
| Your Documents as Sources | Varies | You build it | ||
| Any Entity Type | ||||
| Multilingual Output (40 Languages) | You build it | |||
| BYOK / Self-Hosted Models | Rarely | |||
| Batch Processing | You build it | |||
| Maintenance | Managed | Managed | Managed | Yours, forever |
| Pricing | Pay-per-token | $5-25 / 1k rows | Credits / subscription | Eng time + tokens |
Backfill the past. Enrich the future.
Your company’s knowledge is already written down — make it queryable. Start free, bring your own API keys, and pay only LLM costs.
Get Started Free