How do I use mcp-server-entity-enricher?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mcp-server-entity-enricher List my schemas and enrich 'Microsoft' in English and French" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

mcp-server-entity-enricher

by TOT-Concept

Overview Schema Related Servers Score Discussions

Remote

Entity Enricher MCP Server

MCP MCP Registry License: MIT Website

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/

Then run /mcp in a session and pick Authenticate — your browser opens the consent page. More options (project .mcp.json, API-key fallback): examples/claude-code/

Settings → Connectors → Add custom connector with URL https://entityenricher.ai/api/mcp/, then click Authorize on the consent screen. Walkthrough: examples/claude-ai-remote.md

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.

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

Related MCP server: schema-org-mcp

Examples & recipes

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

Recipe	What it covers
Schema from sample	generate a sample → schema → refine → first enrichment
Database sync	schema → designed tables → publish → pair `ee-database` → migrations
Batch enrichment	entity lists, external APIs, async polling, partial-failure retry
Model benchmark	scenarios, gold references, auto-scored model comparison

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

Tools

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

Category	Tool	Description
Discovery	`list_models`	List the LLM models, languages, strategies, and (when the org has a plan with limits) the operational profile_limits available to the caller.
Schemas	`generate_sample`	Generate a realistic sample entity JSON from a free-text request — the entry point of the schema-authoring loop.
Schemas	`list_schemas`	List saved JSON schemas in your organization, pinned ones first.
Schemas	`get_schema`	Fetch the full content of a saved schema by ID, including all properties, identifying fields, expertise domains, and validation rules.
Schemas	`create_schema_from_sample`	Generate and auto-save a JSON schema whose paths and types strictly follow an approved sample.
Schemas	`save_schema`	Persist a schema you authored directly (no LLM call, no cost) as a new saved schema.
Schemas	`update_schema`	Update a saved schema without an LLM call: rename, replace the schema_content, change tags, pin/unpin, or toggle the ambiguity check.
Schemas	`get_schema_part`	Read a part of a saved schema without fetching the whole document.
Schemas	`get_enum_candidates`	Out-of-set values enrichment has returned for each OPEN enum of a saved schema (closed: false, the generation default), with counts — read from the schema's recent records at call…
Schemas	`update_schema_property`	Edit ONE property of a saved schema's working copy by path — rename, change type or $ref, description, examples, flags — or remove it, without sending the full schema_content.
Schemas	`add_schema_property`	Add a property to an object of a saved schema's working copy: a scalar, an inline nested object (optionally with sub-properties, or untyped to fill later), or a $ref to an…
Schemas	`move_schema_property`	Move ONE property of a saved schema's working copy into another container — a $defs entity ('$defs.X'), an inline object (object path, trailing '[]' enters an array's item type),…
Schemas	`resolve_unify_proposal`	Resolve ONE cross-site unification proposal on a saved schema (x-entityMap.proposals; issue #181).
Schemas	`publish_schema`	Publish a linked schema's working copy as its contract (publish model): enrichment and the linked database syncs follow the published content only, so structural edits (new…
Schemas	`delete_schema`	Soft-delete a saved schema by ID (restorable server-side shortly after; permanent deletion stays in the web UI).
Schemas	`analyze_sample`	Analyze a sample entity before schema generation: ambiguity and identity scoping, two parallel model calls behind one request.
Schemas	`analyze_schema`	Analyze a saved schema with the same two checks as analyze_sample — ambiguity and identity scoping — and write the verdicts onto its properties.
Enrichment & fusion	`start_batch_enrichment`	Start an asynchronous batch enrichment against a JSON schema and return {job_id, total} immediately.
Enrichment & fusion	`fetch_entities`	Fetch a JSON array of entities from an external REST API (GET), server-side — the input step before start_batch_enrichment.
Enrichment & fusion	`enrich_entity`	Run a multi-model enrichment of a single entity against a JSON schema, returning the fused/best structured result.
Enrichment & fusion	`retry_expertises`	Re-run only the FAILED expertise domains of an existing multi-expertise enrichment record, merging the recovered values back into the record — no re-payment for the domains that…
Enrichment & fusion	`merge_records`	Merge 2+ enrichment records of the same entity into one fused result — the manual / re-run counterpart of the automatic fusion that follows a 2+ model enrich_entity or batch run.
Job control	`get_job_status`	Poll the status of an asynchronous LLM job — the middle step of every start → poll → fetch flow (start_batch_enrichment, generate_sample, run_benchmark, retry_expertises).
Job control	`cancel_job`	Cancel a pending, running, or paused LLM job started by start_batch_enrichment, generate_sample, run_benchmark, or retry_expertises.
Job control	`answer_job_question`	Answer the clarification questions of a paused job and resume it — the reply half of the interactive loop used by generate_sample's document-grounded planner (get_job_status…
Records & stats	`list_records`	List past enrichment records in your organization, most recent first.
Records & stats	`get_record`	Fetch a single enrichment record by ID, including the full structured output, validation errors, per-expertise verdicts and metrics.
Records & stats	`get_stats`	Aggregated statistics over your organization's enrichment records: totals, success rate, token usage, and cost summary.
Benchmarks	`list_benchmark_scenarios`	List the organization's benchmark scenarios (saved, reusable enrichment tests: schema + entity + strategy + scoring config).
Benchmarks	`get_benchmark_scenario`	Fetch one benchmark scenario with its per-model results (quality / cost / speed scores; results whose config_hash differs from the scenario's are stale — re-run those models).
Benchmarks	`get_benchmark_scenario_results`	Filter, rank and cap a scenario's per-model results — the same rows get_benchmark_scenario returns, narrowed to what you asked for.
Benchmarks	`create_benchmark_scenario`	Create a benchmark scenario — a reusable model test.
Benchmarks	`update_benchmark_scenario`	Update a benchmark scenario.
Benchmarks	`set_benchmark_reference`	Save a scenario's gold reference — the expected output each model result is scored against, and the gate between create_benchmark_scenario and run_benchmark.
Benchmarks	`delete_benchmark_scenario`	Delete a benchmark scenario and its results.
Benchmarks	`run_benchmark`	Launch a benchmark run — the final step of the benchmark lifecycle: execute the scenario's task (enrichment / sample generation / schema generation) with each selected model…
Attachments	`upload_attachment`	Upload a file (base64-encoded) so it can be used as source material in LLM flows.
Attachments	`delete_attachment`	Permanently remove an attachment from the server by id.
Database Sync	`list_database_syncs`	List the database syncs registered on a saved schema, with pending delta counts.
Database Sync	`list_entity_states`	Browse the current entity state of a schema — the deduplicated, last-write-wins merged rows the entity layer holds (and every linked database mirrors), NOT the per-run records of…
Database Sync	`create_database_sync`	Connect a database to a saved schema — the opt-in that turns enrichments into relational SQL deltas the user applies to their own PostgreSQL/MySQL/SQLite with the ee-database CLI…
Database Sync	`assign_sync_host`	Assign (or clear) the sync host that provisions a database sync in managed ee-database mode: the assigned host claims the credential, creates the physical database if missing and…
Database Sync	`classify_database_model`	Re-run the database-model classification pass on a saved schema: an LLM proposes each property's SQL contract — database_key (identity), the index intent ('search' for text a…
Database Sync	`delete_database_sync`	Delete a database sync and its queued deltas.
Database Sync	`create_database_credential`	(Re)issue the sync-client credential of a database sync — the pairing step of the ee-database CLI workflow.
Database Sync	`fetch_database_deltas`	Fetch the next FIFO window of SQL deltas for a database sync.
Database Sync	`ack_database_deltas`	Acknowledge applied database deltas up to an id: releases the lease and, per the database's options, purges delivered copies and fully-delivered entity state.
Database Sync	`sync_records_to_database`	Push already-stored enrichment output into the entity layer, so it reaches the schema's database sync.
Semantic IDs	`list_semantic_concepts`	Browse your organization's semantic-ID vocabulary — the org-scoped concepts that near-duplicate objects resolve to and database syncs key on.
Semantic IDs	`get_semantic_concept`	One concept in full: its surface-form aliases (the texts that resolve to it, one canonical), the identity source keys it was composed from, the records that resolved to it, and…
Semantic IDs	`probe_semantic_concept`	Dry-run the resolution ladder for a text against one concept type — what an enrichment would do with it — without creating or bumping anything.
Semantic IDs	`add_semantic_concept`	Add a concept to the vocabulary at usage 0 (editor role) — or, with alias_of, add the text as a new SURFACE FORM of that existing concept instead of a concept of its own.
Semantic IDs	`update_concept_alias`	Manage one surface form (alias) of a concept (editor role): action='remove' prunes a captured variant so its text stops resolving to the concept — the group's LAST surface form is…
Semantic IDs	`import_semantic_concepts`	Resolve a batch of identity texts (up to 1000) against one concept type through the same ladder an enrichment uses.
Semantic IDs	`merge_semantic_concepts`	Fold one concept (the loser) into another (the winner) — the resolution of a duplicates-band pair.
Semantic IDs	`delete_semantic_concepts`	Delete concepts by explicit ids, whole concept types, or every unused concept of a scope.
Semantic IDs	`migrate_semantic_embeddings`	The org's embedding-model migration — the only sanctioned way to move existing concepts between embedding models.

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.

Resource	URI template
Saved schema	`enricher://schemas/{schema_id}`
Enrichment record	`enricher://records/{record_id}`

The async job pattern

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

A start tool (start_batch_enrichment, generate_sample, run_benchmark, retry_expertises) returns a job_id immediately.
get_job_status(job_id) polls progress; paused jobs carry clarification questions that answer_job_question resolves; cancel_job aborts.
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:

`error_code`	When
`invalid_request`	Malformed UUID, mutually exclusive args, body validation failure.
`prompt_limit_reached`	Daily/weekly/monthly prompt quota exhausted (HTTP 402), with period + usage details.
`insufficient_credits`	Credit balance too low to start the job (HTTP 402), with balance + purchase URL.
`model_limit_exceeded` / `language_limit_exceeded`	More models/languages requested than the plan allows (HTTP 402).
`concurrent_job_limit_reached`	Too many active jobs for the org — wait or upgrade.
`classification_warning`	⚡ Non-error: pre-flight classifier rejected the entity (see above).
`benchmarks_not_in_plan`	Benchmark tools need the owner role + a plan with Model Benchmarks (HTTP 403).
`enrichment_timeout` / `schema_generation_timeout`	Job exceeded its timeout — try fewer models.
`schema_generation_failed`	Upstream LLM error (HTTP 502).
`cancelled`	Job cancelled mid-run (HTTP 499).
`not_found`	Schema or record ID doesn't exist in your org.

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.

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.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

No tool schema history has been recorded yet.

This server cannot be installed

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

Maintenance

ActivityActive

ResponsivenessNo issues

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

ChrysaiOAuth
com.chrysai.www
Hosted MCP server for AI-driven data ops. Create apps, manage schemas, and CRUD structured data.
Data Platforms Developer Tools App Automation
2
TokenOracle
com.guffeyholdings
Hosted MCP server for LLM cost estimation, model comparison, and budget-aware routing.
Finance Monitoring
2
mcp AOAuth
io.scorecard
MCP server providing access to the Scorecard API to evaluate and optimize LLM systems.
RAG Systems Monitoring Testing & QA Tools
3
PDF to Markdown (pdf2md.dev)
dev.pdf2md
Hosted MCP server: convert PDFs to clean, LLM-ready Markdown with tables, formulas and OCR.
AI & Machine Learning Image & Video Processing
2

Related MCP Servers

MCP LLM Generator v2
AI & Machine Learning Knowledge & Memory Developer Tools
mako10k
A
license
Not graded
quality
D
maintenance
Production-ready MCP server enabling LLM text generation, template management, context-aware conversations, and memory storage with enterprise quality assurance.
Updated 10 months ago (2025-10-27 19:39 UTC)
21
2
MIT
schema-org-mcp
Documentation Access Developer Tools
Theycallmeholla
A
license
Not graded
quality
A
maintenance
MCP server enabling AI assistants to explore schema.org types, generate JSON-LD examples, validate structured data, and navigate the complete ontology with fuzzy matching and caching.
Updated 2 months ago (2026-07-13 10:20 UTC)
43
21
MIT
DocumentPro MCPofficial
AI & Machine Learning
documentpro
A
license
Not graded
quality
C
maintenance
Extract structured, schema-typed data from invoices, purchase orders, receipts, and tax forms, and classify documents into custom label sets — via a hosted MCP server. Free tier included.
Updated 2 months ago (2026-07-13 11:40 UTC)
MIT
MCP DocGraph
jamestomasino
F
license
Not graded
quality
B
maintenance
MCP server for building knowledge graphs from documents. It ingests PDF/PPTX/DOCX files, transcribes to Markdown, and uses LLM to bootstrap entity patterns and build a JSONL knowledge graph with RAG chunks.
Updated a month ago (2026-07-22 17:05 UTC)
-

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/TOT-Concept/mcp-server-entity-enricher'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

Entity Enricher MCP Server

Enrichments become a real database — yours

Quickstart

Option 1 — OAuth (recommended)

Option 2 — API key (static JSON configuration)

Try it

Examples & recipes

Tools

Resources

The async job pattern

Interactive classification resume

Error codes

Authentication details

Links

About this repository

Tool Schema Changelog

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

MCP LLM Generator v2

schema-org-mcp

DocumentPro MCPofficial

MCP DocGraph

Latest Blog Posts

MCP directory API