Entity Enricher MCP Server

A hosted, remote Model Context Protocol server for Entity Enricher — structured knowledge extraction with multiple LLM providers. Connect Claude Desktop, Claude Code, Cursor, claude.ai or any MCP-compatible client and, from inside a chat:

• Author JSON schemas — generate a sample entity, turn it into a schema, refine it in natural language.
• Enrich entities — single or batch (up to 100), against your schemas, with any of your configured models.
• Enrich multilingually — schemas with localized text fields get per-language values in every language you request, in one pass.
• Fuse multi-model results — conflicts detected field-by-field, resolved by voting or LLM arbitration.
• Benchmark models on your own data — saved scenarios, gold references, auto-scored quality / cost / speed.
• Ground enrichments in documents — upload PDFs, images or audio and attach them to any flow.
• Land it all in your own database — as real, migrated relational tables, synced by a client you run.

No install, no local process: the server runs at https://entityenricher.ai/api/mcp/ (streamable HTTP). This repository holds the public documentation and ready-to-use client configs; the server implementation lives in the Entity Enricher platform. (The one optional local binary is the database sync client below — and only if you want the rows in a database of your own.)

Enrichments become a real database — yours

The enrichment is the easy half. What you normally end up building yourself — the tables to hold the results, the DDL, the migration when the shape changes, and a loader that keeps it consistent — is what a database sync does for you, and a chat is a good place to drive it:

• A designed schema, not a JSON dump. create_database_sync connects a database to a saved schema, and Entity Enricher derives the relational model from it: a table per entity type, PRIMARY KEYs, real FOREIGN KEYs, child tables for the parts an entity owns, junction tables for entities it merely references (one row many parents point at, not a copy per parent), typed columns, and indexes on what a list screen actually filters and sorts on. An LLM pass proposes each column's SQL contract — ask your client to read it back and fix what it got wrong (classify_database_model, update_schema) before anything ships.
• Migrations you don't write. publish_schema turns the working copy into the contract: the change is diffed against what each database has actually shipped and travels down the same feed as the data — additive DDL applied silently, riskier transforms (a re-key, a type change, a renamed column) held for your confirmation. No hand-written ALTER, no drift.
• Synced by an open-source client you run. create_database_credential issues the pairing token for ee-database — an MIT-licensed Go binary that lives next to your PostgreSQL, MySQL or SQLite. It connects outward over WSS and your connection string never leaves the machine: Entity Enricher never holds a credential to your database. It bootstraps from a .sql snapshot, applies each leased batch transactionally, acknowledges it, and halts loudly on a failing delta rather than skipping it. Releases are Sigstore-signed and the installer verifies that signature against the publishing workflow's identity before the binary is ever executable.

  your schema ──┬──▶ relational model   tables, PK/FK, child + junction tables, indexes
                ├──▶ migrations         schema edits, diffed and shipped as DDL
                └──▶ rows               every enrichment, merged into current state
                             │
                             │  one ordered feed, leased and acknowledged
                             ▼
                    ee-database  ──  MIT-licensed, Sigstore-signed, outbound WSS only
                             │       (your DSN never leaves your machine)
                             ▼
              your PostgreSQL · MySQL · SQLite

A client that can run commands (Claude Code) carries the whole loop, install included; any other client walks you through it and you paste one line into a terminal. No replica at all? list_entity_states browses the same merged rows server-side, and fetch_database_deltas / ack_database_deltas let a client apply the feed itself. Walkthrough: Database sync recipe.

Listed on the official MCP Registry as ai.entityenricher/enricher (see server.json).

Quickstart

Option 1 — OAuth (recommended)

For claude.ai, Claude Code, Cursor, and any MCP client that implements the standard OAuth flow. No API key to create or paste — the client discovers the authorization server automatically, your browser opens the Entity Enricher consent screen, and the connection acts on your behalf with your own role. Revoke it anytime under Settings → API Keys → Connected Apps.

claude mcp add --transport http entity-enricher https://entityenricher.ai/api/mcp/

Option 2 — API key (static JSON configuration)

For clients configured via a JSON file rather than an interactive sign-in (Claude Desktop, Continue, Zed) — and for headless/CI use.

1. In the Entity Enricher web UI: Settings → API Keys → New organization access key. Pick a role — operator (read-mostly), editor (create/edit schemas), or owner (full control, required for benchmarks). Copy the ent_… value; it's only shown once.

2. For Claude Desktop, edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

   {
     "mcpServers": {
       "entity-enricher": {
         "url": "https://entityenricher.ai/api/mcp/",
         "headers": { "X-API-Key": "ent_your_key_here" }
       }
     }
   }
   

   Restart Claude Desktop. Full file: examples/claude-desktop/

Try it

List my Entity Enricher schemas, then enrich "Sanofi" against the pharmaceutical company schema in English and French.

Claude discovers the tools automatically, confirms the model and schema choice with you, and returns the structured result inline.

Examples & recipes

Client configs and copy-paste chat walkthroughs live in examples/:

Per-client setup and examples: Claude Code · claude.ai · Claude Desktop · Cursor

Tools

54 tools, spanning the full schema-authoring and enrichment surface:

Tool behaviour is identical to the REST endpoints they wrap — same validation, billing and plan limits as the web app. Write tools require the editor role; benchmark tools require owner plus a plan that includes Model Benchmarks.

Resources

Resources let the client browse data without a tool call — both render as Markdown.

The async job pattern

MCP tools can't stream, so long-running work is split into start → poll → fetch:

1. A start tool (start_batch_enrichment, generate_sample, run_benchmark, retry_expertises) returns a job_id immediately.
2. get_job_status(job_id) polls progress; paused jobs carry clarification questions that answer_job_question resolves; cancel_job aborts.
3. Persisted outputs are fetched with list_records(job_id=…) (or the feature's own read tool, e.g. get_benchmark_scenario).

Jobs are held in a bounded in-memory manager — an unknown job_id means the job finished long ago; go straight to the records.

Interactive classification resume

The feature that only an interactive client unlocks. With a classification model enabled, a pre-flight check verifies the entity matches the schema type. On a mismatch the tool returns a non-error response instead of failing:

{
  "success": false,
  "error_code": "classification_warning",
  "message": "Pre-flight classification rejected the entity. ...",
  "classification": {
    "status": "mismatch",
    "reasoning": "Titan is a moon of Saturn, not a planet.",
    "confidence": 0.97
  },
  "job_id": "..."
}

Claude surfaces the reasoning, asks you to confirm, and retries with force_after_classification_warning=true. Workflow connectors (n8n, Make) have to auto-cancel here — a chat can just ask.

Error codes

Errors are structured dicts with an error_code field the client can pattern-match on:

Authentication details

• OAuth 2.1 (recommended) — any MCP client implementing the standard auth spec (claude.ai, Claude Code, Cursor, MCP Inspector) discovers it automatically: standard discovery via /.well-known/oauth-protected-resource, dynamic client registration, PKCE, browser consent. No key to create or paste. Tokens are audience-bound and instantly revocable under Settings → API Keys → Connected Apps.
• X-API-Key — for clients configured via a static JSON file: ent_… organization access keys, created in Settings → API Keys. The role attached to the key (operator / editor / owner) gates which tools succeed.

Links

• Entity Enricher — the platform.
• MCP server docs — the always-current web version of this guide.
• REST API reference — the endpoints these tools wrap.
• Model Context Protocol — the open spec.

About this repository

This repo contains the public documentation and client examples for the Entity Enricher MCP server. The server itself is embedded in the Entity Enricher platform and maintained in the main (private) monorepo; this repo is synced from it as a git subtree. Issues and discussions are welcome here.

Licensed under the MIT License.