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 enrichment

An 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.

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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.

  7. 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.

  8. 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.

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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.

1

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.

2

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.

3

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.

4

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.

Before

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.

During

Models in competition

Two or more LLMs answer independently. Outputs are schema-validated; errors go back to the model to self-correct, automatically.

After

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.

Entity

Acme Corp

Any entity: company, drug, legal case, research paper...

Pre-flight Classification

Match — Company

Catches type mismatches before wasting LLM credits.

Anthropic
OpenAI
Google Gemini

Bring your own API keys — works with any LLM provider.

Anthropic
FinancialsLLM prompt
LegalLLM prompt
MarketLLM prompt
OpenAI
FinancialsLLM prompt
LegalLLM prompt
MarketLLM prompt
Gemini
FinancialsLLM prompt
LegalLLM prompt
MarketLLM prompt

Schema split by domain — self-correcting prompts retry on validation failure.

Anthropic Result
OpenAI Result
Gemini Result

Deep merge of expertise responses per model.

Final Enriched Result

Acme Corp

Arbitrated

Reasoned 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-in

Add 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-in

Mark 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

New

Attach 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.

PDFPNGJPEGMP3WAVM4ADOCXDOCODTRTFEPUBHTMLCSVXLSXPPTXTXTMDSee all formats →

Cost-Optimized by Default

Built-in

Prompt 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.

How cost optimization works →

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.

Google Sheets
Source Data
Entity Enricher
Entity Enricher
AI Enrichment
HubSpot
CRM Sync
HubSpot
CRM
Salesforce
CRM
Google Sheets
Spreadsheet
Airtable
Database
Slack
Messaging
PostgreSQL
Database
Webhook
API
Gmail
Email
Notion
Workspace
Stripe
Payments
Jira
Project Mgmt
HTTP Request
API
CRM Sync
Push enriched data directly to HubSpot, Salesforce, or any CRM
Waterfall Enrichment
Chain multiple enrichment steps with conditional logic
No-Code Workflows
Visual drag-and-drop pipeline builder — no coding required
Automated Pipelines
Trigger enrichment on new rows, form submissions, or schedules
Or use it directly from Claude Desktop, Claude Code, or Cursor

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.

Or mirror everything into your own database

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.

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.

FeatureEntity EnricherParallel AIAI Research AgentsDIY LLM Pipeline
Custom Nested SchemaFlat JSON schemaOne prompt per columnHand-coded
Multi-Model EnrichmentYou orchestrate
Fusion & Conflict Resolution
Field-Level Audit TrailCitations + confidence
Linked-Entity Dedup (Semantic IDs)
Sync to Your Own PostgreSQLCSV / sheet exportYou build it
Your Documents as SourcesVariesYou build it
Any Entity Type
Multilingual Output (40 Languages)You build it
BYOK / Self-Hosted ModelsRarely
Batch ProcessingYou build it
MaintenanceManagedManagedManagedYours, forever
PricingPay-per-token$5-25 / 1k rowsCredits / subscriptionEng 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