Senzing

Official13 toolsLive

by Senzing · Python

Entity resolution — data mapping, SDK code generation, docs search, and error troubleshooting

com.senzing/mcp MCP Server

The com.senzing/mcp Model Context Protocol (MCP) server provides functionality for entity resolution. It supports data mapping, SDK code generation, documentation search, and error troubleshooting. The server is identified by the slug com-senzing-mcp and exposes 13 tools.

🛠️ Key Features

Entity resolution
Data mapping
SDK code generation
Documentation search
Error troubleshooting

🚀 Use Cases

Map data entities to support entity resolution
Generate SDK code for integration workflows
Search documentation for relevant guidance
Troubleshoot and resolve errors

⚡ Developer Benefits

Consolidates entity resolution workflows (mapping, generation, lookup, troubleshooting)
Includes tooling breadth (13 tools) aligned to development and support tasks

⚠️ Limitations

No additional details beyond the listed capabilities and tool count are provided in the available server data.

Topics

entity-resolutionmcpmcp-servermodel-context-protocolsenzing

Captured live from the server via tools/list.

analyze_record

Get the Senzing JSON analyzer script to validate mapped data files client-side. REQUIRED: `workspace_dir` (writable directory, e.g. ~/sz-workspace) — the call WILL FAIL without it. The analyzer validates records against the Entity Specification, examines feature distribution, attribute coverage, and data quality. Returns a Python script (no dependencies) with instructions. No source data is sent to the server. Typical workspace_dir values: Linux `/tmp` or `~/sz-workspace`; macOS `~/sz-workspace`; sandboxed envs: explicit path under home (do NOT assume /tmp exists).

Parameters3

file_paths	array \| null	optional	File paths to analyze (Senzing JSON or JSONL files). Commands will be generated for each path.
version	string	optional	Senzing version (default: "current").
workspace_dir	string	required	REQUIRED: Workspace directory for the analyzer script and any generated reports. Must be a writable absolute or relative path that already exists in your environment. Do NOT assume `/tmp` exists — some environments (e.g. Kiro) do not provide it. Typical values: Linux: `/tmp` or `~/sz-workspace`; macOS: `~/sz-workspace`; Kiro/sandboxed: an explicit path under `~`, e.g. `~/sz-workspace`. Declared as a non-optional `String` (no `#[serde(default)]`) so it appears in the generated JSON `inputSchema` `required` array. The prose has always said REQUIRED, but as an `Option` it was schema-optional, so schema-respecting clients omitted it and looped on the `needs_param` guidance. An empty string still deserializes; the handler catches that and returns the guidance as an `isError` result.

Raw schema

{
  "type": "object",
  "properties": {
    "file_paths": {
      "default": null,
      "description": "File paths to analyze (Senzing JSON or JSONL files).\nCommands will be generated for each path.",
      "items": {
        "type": "string"
      },
      "type": [
        "array",
        "null"
      ]
    },
    "version": {
      "default": "current",
      "description": "Senzing version (default: \"current\").",
      "type": "string"
    },
    "workspace_dir": {
      "description": "REQUIRED: Workspace directory for the analyzer script and any\ngenerated reports. Must be a writable absolute or relative path that\nalready exists in your environment. Do NOT assume `/tmp` exists —\nsome environments (e.g. Kiro) do not provide it. Typical values:\nLinux: `/tmp` or `~/sz-workspace`; macOS: `~/sz-workspace`;\nKiro/sandboxed: an explicit path under `~`, e.g. `~/sz-workspace`.\n\nDeclared as a non-optional `String` (no `#[serde(default)]`) so it\nappears in the generated JSON `inputSchema` `required` array. The prose\nhas always said REQUIRED, but as an `Option` it was schema-optional, so\nschema-respecting clients omitted it and looped on the `needs_param`\nguidance. An empty string still deserializes; the handler catches that\nand returns the guidance as an `isError` result.",
      "type": "string"
    }
  },
  "required": [
    "workspace_dir"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

download_resource

Download workflow resources by name. Pass `filename` (string) or `filenames` (array); calling with neither returns the list of available resources (it does not fail). Available: sz_json_analyzer.py, sz_schema_generator.py, sz_verbatim_check.py, sz_routing_report.py, senzing_entity_specification.md, senzing_mapping_examples.md, identifier_crosswalk.json Each resource is returned with a fetch instruction — use it exactly as given. Supports batch via `filenames` array. If a previously-known fetch instruction stops working, call this tool again to obtain the current one.

Parameters5

filename	string \| null	optional	Resource filename to retrieve (e.g. "sz_json_analyzer.py", "senzing_entity_specification.md"). Ignored when `filenames` is provided.
filenames	array \| null	optional	Multiple resource filenames to retrieve in a single call. Takes precedence over `filename` when provided.
inline	boolean \| null	optional	Returns resource content inline instead of URLs. ALWAYS try with inline=false (default) first — only set inline=true if the URL fetch fails. Inline responses consume more context tokens. Large resources come back in BOUNDED CHUNKS: a truncated response carries `truncated: true`, `next_offset` and `total_chars` — call again with `offset` = `next_offset` to continue. For the Entity Specification prefer `search_docs`: it serves the same document already split by section, which is cheaper than paging through 75 KB.
offset	integer \| null	optional	Character offset into the resource for `inline=true` pagination. Pass the `next_offset` from a previous truncated response. Default 0.
version	string	optional	Senzing version (default: "current").

Raw schema

{
  "type": "object",
  "properties": {
    "filename": {
      "default": null,
      "description": "Resource filename to retrieve (e.g. \"sz_json_analyzer.py\",\n\"senzing_entity_specification.md\"). Ignored when `filenames` is provided.",
      "type": [
        "string",
        "null"
      ]
    },
    "filenames": {
      "default": null,
      "description": "Multiple resource filenames to retrieve in a single call.\nTakes precedence over `filename` when provided.",
      "items": {
        "type": "string"
      },
      "type": [
        "array",
        "null"
      ]
    },
    "inline": {
      "default": null,
      "description": "Returns resource content inline instead of URLs. ALWAYS try with inline=false (default) first — only set inline=true if the URL fetch fails. Inline responses consume more context tokens. Large resources come back in BOUNDED CHUNKS: a truncated response carries `truncated: true`, `next_offset` and `total_chars` — call again with `offset` = `next_offset` to continue. For the Entity Specification prefer `search_docs`: it serves the same document already split by section, which is cheaper than paging through 75 KB.",
      "type": [
        "boolean",
        "null"
      ]
    },
    "offset": {
      "default": null,
      "description": "Character offset into the resource for `inline=true` pagination. Pass the\n`next_offset` from a previous truncated response. Default 0.",
      "format": "uint",
      "minimum": 0,
      "type": [
        "integer",
        "null"
      ]
    },
    "version": {
      "default": "current",
      "description": "Senzing version (default: \"current\").",
      "type": "string"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

explain_error_code

Explain a Senzing error code with causes and resolution steps. Accepts formats: SENZ0005, SENZ-0005, 0005, or just 5. Returns error class, common causes, and specific resolution guidance

Parameters2

error_code	string	required
version	string	optional

Raw schema

{
  "type": "object",
  "properties": {
    "error_code": {
      "type": "string"
    },
    "version": {
      "default": "current",
      "type": "string"
    }
  },
  "required": [
    "error_code"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

find_examples

Find working SOURCE CODE examples from 54 indexed Senzing GitHub repositories. REQUIRED: either `query` (string, for search) or `repo` with `file_path` or `list_files=true` — the call WILL FAIL without one. Three modes: (1) Search: pass `query` to find examples across all repos, (2) File listing: pass `repo` + `list_files=true`, (3) File retrieval: pass `repo` + `file_path`. Indexes source code (.py, .java, .cs, .rs, .ts, .js) and READMEs — NOT build/data files. For sample data, use get_sample_data. Covers Python, Java, C# (official SDKs) plus Rust and TypeScript/Node.js (community-maintained wrappers, not official) SDK patterns: initialization, ingestion, search, redo, configuration, message queues, REST APIs. Use max_lines to limit large files. Returns GitHub raw URLs for file retrieval.

Parameters6

file_path	string \| null	optional	Return full content of a specific file in the repo (requires repo parameter)
language	string \| null	optional	Filter results by programming language (e.g. "python", "java", "csharp", "rust")
list_files	boolean \| null	optional	Return the file listing for a repo instead of searching (requires repo parameter)
max_lines	integer \| null	optional	Maximum lines to return for file content (default: unlimited). Useful for large files.
query	string \| null	optional	Search query (required for search mode, optional when using repo+file_path or repo+list_files)
repo	string \| null	optional	Filter to a specific indexed repo (e.g. "brianmacy/sz_mem-v4"). When combined with file_path, returns full file content. When combined with list_files, returns file listing.

Raw schema

{
  "type": "object",
  "properties": {
    "file_path": {
      "description": "Return full content of a specific file in the repo (requires repo parameter)",
      "type": [
        "string",
        "null"
      ]
    },
    "language": {
      "description": "Filter results by programming language (e.g. \"python\", \"java\", \"csharp\", \"rust\")",
      "type": [
        "string",
        "null"
      ]
    },
    "list_files": {
      "default": null,
      "description": "Return the file listing for a repo instead of searching (requires repo parameter)",
      "type": [
        "boolean",
        "null"
      ]
    },
    "max_lines": {
      "default": null,
      "description": "Maximum lines to return for file content (default: unlimited). Useful for large files.",
      "format": "uint",
      "minimum": 0,
      "type": [
        "integer",
        "null"
      ]
    },
    "query": {
      "default": null,
      "description": "Search query (required for search mode, optional when using repo+file_path or repo+list_files)",
      "type": [
        "string",
        "null"
      ]
    },
    "repo": {
      "description": "Filter to a specific indexed repo (e.g. \"brianmacy/sz_mem-v4\"). When combined with\nfile_path, returns full file content. When combined with list_files, returns file listing.",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

generate_scaffold

Generate SDK scaffold code for common workflows. Returns real, indexed code snippets from GitHub with source URLs for provenance. Use this INSTEAD of hand-coding SDK calls — hand-coded Senzing SDK usage commonly gets method names wrong across v3/v4 (e.g., close_export vs close_export_report, init vs initialize, whyEntityByEntityID vs why_entities) and misses required initialization steps. Languages: python, java, csharp (official V4 SDKs); rust, typescript (community-maintained wrappers, not official). Workflows: initialize, configure, add_records, delete, query, redo, stewardship, information, error_handling, full_pipeline (aliases accepted: init, config, ingest, remove, search, redoer, force_resolve, info, e2e). V3 supports Python only. Returns GitHub raw URLs — fetch each snippet to read the source code.

Parameters3

language	string	required	Programming language: python, java, csharp (or c#, cs, dotnet), rust (or rs), typescript (or ts, node, nodejs, javascript, js)
version	string	optional	Senzing version: "4.0", "current", or "3.x". V3 supports Python and Java only
workflow	string	required	Workflow to scaffold: initialize, configure, add_records, delete, query, redo, stewardship, information, error_handling, full_pipeline. Aliases accepted (e.g. init, config, ingest, remove, search, redoer, force_resolve, info, error, retry, e2e)

Raw schema

{
  "type": "object",
  "properties": {
    "language": {
      "description": "Programming language: python, java, csharp (or c#, cs, dotnet), rust (or rs), typescript (or ts, node, nodejs, javascript, js)",
      "type": "string"
    },
    "version": {
      "default": "current",
      "description": "Senzing version: \"4.0\", \"current\", or \"3.x\". V3 supports Python and Java only",
      "type": "string"
    },
    "workflow": {
      "description": "Workflow to scaffold: initialize, configure, add_records, delete, query, redo, stewardship, information, error_handling, full_pipeline. Aliases accepted (e.g. init, config, ingest, remove, search, redoer, force_resolve, info, error, retry, e2e)",
      "type": "string"
    }
  },
  "required": [
    "language",
    "workflow"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

get_capabilities

Get server version, capabilities overview, available tools, suggested workflows, and getting started guidance. Returns server_info with name, version, and Senzing version. Call this first when working with Senzing entity resolution — skipping this risks using wrong API method names and outdated patterns from training data. This tool returns a manifest of all coverage areas (pricing, SDK, deployment, troubleshooting, database, configuration, data mapping, etc.) — use it to triage which Senzing MCP tool to call before going to external sources

Parameters1

version

string

optional

Raw schema

{
  "type": "object",
  "properties": {
    "version": {
      "default": "current",
      "type": "string"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

get_sample_data

Get sample data for entity resolution. Available datasets: 'las-vegas', 'london', 'moscow' (CORD — Collections Of Relatable Data, REAL historical data) and 'truthset' (Senzing's SYNTHETIC demo truth set: CUSTOMERS, REFERENCE, WATCHLIST). Use dataset='list' to discover datasets, source='list' to see the sources/vendors within a dataset. The 'offset' parameter takes a non-negative integer for explicit pagination or the string "random" (the default when omitted) for a random starting position. IMPORTANT: The three CORD datasets ('las-vegas', 'london', 'moscow') are REAL data (not synthetic) — historical snapshots for evaluation only, not operational use. Always inform the user of this. This does NOT apply to 'truthset', which is Senzing's own synthetic demo truth set (github.com/Senzing/truth-sets) — do not describe those records as real people's data. Each response's citation carries the provenance for the dataset actually returned; follow it rather than this summary. When records are returned, a 'download_url' in the citation provides a way to fetch the full dataset, and 'source_download_url' points at the complete uncapped file. Always present the fetch instruction to the user exactly as given. Downloading the dataset TO DISK is expected and encouraged whenever the user wants the data — fetch it with a shell command (curl/wget) to a file and work from that file. What you must NOT do is pull the dataset INTO THE CONVERSATION: never echo, cat, paste or summarise raw records back into context, because these files run to hundreds of thousands of records. The inline records above are a small preview of the data shape, not the delivery mechanism. (An earlier wording of this line said only 'Do NOT download it yourself', which was read as a blanket ban on fetching and left users downloading files by hand.) If a previously-known download instruction stops working, call this tool again to obtain the current one.

Parameters4

dataset	string	required	Dataset name (e.g., "las-vegas", "london", "moscow"). Use "list" to discover available datasets and their sources. (Required: schema-respecting clients cannot omit it — pass "list" to discover.)
limit	integer \| null	optional
offset	any	optional	Record offset. Use a number for explicit pagination, or "random" for a random starting position. Omit for random.
source	string \| null	optional	Filter by data source/vendor within a dataset (e.g., "equifax", "ppp_loans"). Omit to see all sources. Use "list" to list available sources.

Raw schema

{
  "type": "object",
  "properties": {
    "dataset": {
      "description": "Dataset name (e.g., \"las-vegas\", \"london\", \"moscow\").\nUse \"list\" to discover available datasets and their sources.\n(Required: schema-respecting clients cannot omit it — pass \"list\" to discover.)",
      "type": "string"
    },
    "limit": {
      "default": null,
      "format": "uint",
      "minimum": 0,
      "type": [
        "integer",
        "null"
      ]
    },
    "offset": {
      "default": null,
      "description": "Record offset. Use a number for explicit pagination, or \"random\" for a random starting position. Omit for random.",
      "oneOf": [
        {
          "description": "Explicit zero-based record offset for pagination.",
          "minimum": 0,
          "type": "integer"
        },
        {
          "const": "random",
          "description": "Start at a pseudo-random offset (same as omitting the field)."
        },
        {
          "description": "Random start (same as omitting the field).",
          "type": "null"
        }
      ]
    },
    "source": {
      "description": "Filter by data source/vendor within a dataset (e.g., \"equifax\", \"ppp_loans\").\nOmit to see all sources. Use \"list\" to list available sources.",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "required": [
    "dataset"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

get_sdk_reference

Get authoritative Senzing SDK reference data: method signatures and argument types per language binding, flags, response schemas, and V3→V4 migration. Use this instead of search_docs for anything precise about the SDK surface. Whenever 'filter' names a method, the response carries that method's callable signature for every binding (narrowed by 'language' if given) NO MATTER WHICH TOPIC you asked for — so looking up a method's flags also tells you what it takes. Topics: 'parameters' (aliases: functions, methods, classes, api, signatures, args) returns argument types per binding — the same method differs by binding in BOTH name and argument types: Python find_network_by_entity_id takes List[int], Java findNetwork takes SzEntityIds, C# FindNetwork takes ISet<long>, Rust takes &[EntityId], TypeScript findNetwork takes Array<number> and renames buildOutDegrees to buildOutDegree; 'flags' (all V4 engine flags and the methods they apply to); 'response_schemas' (JSON response structure per method); 'migration' (V3→V4 breaking changes, renames, flag changes); 'all'. 'filter' accepts any spelling — 'get entity', 'get_entity', and 'getEntity' all resolve. Pass 'language' (python/java/csharp/rust/typescript) to narrow to your binding; cross-binding divergence warnings are still included so you never translate a call between bindings by mistake

Parameters4

filter	string \| null	optional	Optional filter: method name, class name, module name, or flag name. Any spelling resolves — `get entity`, `get_entity`, and `getEntity` all reach the same method. Examples are backticked, not double-quoted, on purpose: downstream clients derive a property's valid-value set from the double-quoted tokens in this description, so quoting examples here would advertise them as the only accepted filters.
language	string \| null	optional	Language binding: "python", "java", "csharp", "rust", or "typescript". Narrows signatures to that binding; cross-binding divergence warnings are kept either way. Omit to compare every binding side by side.
topic	string	required	Topic: "parameters" (aliases: functions, methods, classes, api, signatures, args), "flags", "response_schemas", "migration", or "all". You do not need "parameters" just to see a signature: any topic filtered by a method name returns that method's signature in `method_signatures`.
version	string	optional	Senzing version (default: "current")

Raw schema

{
  "type": "object",
  "properties": {
    "filter": {
      "default": null,
      "description": "Optional filter: method name, class name, module name, or flag name.\nAny spelling resolves — `get entity`, `get_entity`, and `getEntity` all\nreach the same method.\n\nExamples are backticked, not double-quoted, on purpose: downstream\nclients derive a property's valid-value set from the double-quoted\ntokens in this description, so quoting examples here would advertise\nthem as the only accepted filters.",
      "type": [
        "string",
        "null"
      ]
    },
    "language": {
      "default": null,
      "description": "Language binding: \"python\", \"java\", \"csharp\", \"rust\", or \"typescript\".\nNarrows signatures to that binding; cross-binding divergence warnings\nare kept either way. Omit to compare every binding side by side.",
      "type": [
        "string",
        "null"
      ]
    },
    "topic": {
      "description": "Topic: \"parameters\" (aliases: functions, methods, classes, api,\nsignatures, args), \"flags\", \"response_schemas\", \"migration\", or \"all\".\n\nYou do not need \"parameters\" just to see a signature: any topic filtered\nby a method name returns that method's signature in `method_signatures`.",
      "enum": [
        "parameters",
        "params",
        "parameter",
        "signatures",
        "signature",
        "arguments",
        "args",
        "functions",
        "function",
        "methods",
        "method",
        "classes",
        "class",
        "api",
        "flags",
        "response_schemas",
        "response_schema",
        "responses",
        "migration",
        "all"
      ],
      "type": "string"
    },
    "version": {
      "default": "current",
      "description": "Senzing version (default: \"current\")",
      "type": "string"
    }
  },
  "required": [
    "topic"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

mapping_workflow

Map source data to Senzing JSON through a guided 8-step workflow. Use this INSTEAD of hand-coding Senzing JSON. REQUIRED ARGUMENTS for action='start' — arguments, not files: `file_paths`, the source file name(s) exactly as the user gave them (a LABEL the server never opens, so pass it even when the file is not readable from here), AND `workspace_dir` inside the `data` object (e.g. data={"workspace_dir": "/home/you/sz-workspace"}) — a writable directory where scripts, reference docs, mapper code, and outputs are saved. Do NOT assume /tmp exists (some environments like Kiro do not provide it). The call needs both arguments present; it does NOT need the file to exist. NO READABLE FILE, NO SHELL — START ANYWAY. If the user only DESCRIBED their columns, or you have no shell to run the profiler, step 1 accepts a `profile_summary` you write yourself: field_count from their column list, record_count as they stated it or 0 (zero means 'not measured' and is expected — it is not fabrication). An unreadable source file is NOT a reason to hand-code a mapping instead. Actions: start, advance, back, status, reset. Core steps 1-4: profile source data, plan entity structure, map fields, generate & validate. Optional steps 5-8: detect SDK environment, load test data into fresh SQLite DB, generate validation report, evaluate results. STATE: Every response returns a 'state' JSON object. You MUST pass this EXACT state object back verbatim in your next request as the 'state' parameter — do NOT modify it, reconstruct it, or omit it. The state is opaque and managed by the server. If you have lost the state, call with action='start' instead. Common errors: (1) omitting state on advance — always include it, (2) reconstructing state from memory — always echo the exact JSON from the previous response, (3) omitting data on advance — each step requires specific data fields documented in the instructions, (4) omitting the file_paths or workspace_dir ARGUMENTS on start — the server needs the names, not a readable file. Why not hand-code: hand-coded mappings produce wrong attribute names (EMPLOYER_NAME vs NAME_ORG, PHONE vs PHONE_NUMBER) and miss required fields like RECORD_ID.

Parameters7

action	string \| null	optional	Action to perform. ONLY these values are valid: start, advance, back, status, reset.
data	any	optional	Step-specific data (for "advance" action). Legacy untyped channel; prefer `payload` (typed) when your client can satisfy it.
file_paths	array \| null	optional	Source file paths (required for "start" action). Also accepted inside `data` — see `workspace_dir` for why both placements are honoured.
payload	object	optional	Typed step payload for the "advance" action (H16). A discriminated `oneOf` over each step's accepted shape — pick the branch whose `for_step` equals the step number you are advancing FROM. When present it is merged over `data` (payload wins); when absent, behavior is identical to sending `data`.
state	any	optional	Workflow state from previous response (required for all actions except "start"). CRITICAL: Pass the EXACT 'state' JSON object from the previous mapping_workflow response verbatim — do NOT reconstruct, modify, or omit any fields. If you have lost the state, call with action='start' instead.
version	string	optional	Senzing version (default: "current").
workspace_dir	string \| null	optional	Writable output directory (required for "start" action). Historically this lived ONLY inside `data` while `file_paths` lived ONLY at the top level, so the two arguments of a single call sat in different places. Clients reliably put both in one place — either place — and the half that landed in the "wrong" one was silently dropped, producing a "required" error for an argument that WAS sent and forcing a retry. Both placements are now accepted for both arguments; top level wins when a value is present in both.

Raw schema

{
  "type": "object",
  "properties": {
    "action": {
      "default": null,
      "description": "Action to perform. ONLY these values are valid: start, advance, back, status, reset.",
      "enum": [
        "start",
        "advance",
        "back",
        "status",
        "reset",
        null
      ],
      "type": [
        "string",
        "null"
      ]
    },
    "data": {
      "default": null,
      "description": "Step-specific data (for \"advance\" action). Legacy untyped channel; prefer\n`payload` (typed) when your client can satisfy it."
    },
    "file_paths": {
      "default": null,
      "description": "Source file paths (required for \"start\" action). Also accepted inside\n`data` — see `workspace_dir` for why both placements are honoured.",
      "items": {
        "type": "string"
      },
      "type": [
        "array",
        "null"
      ]
    },
    "payload": {
      "default": null,
      "description": "Typed step payload for the \"advance\" action (H16). A discriminated `oneOf`\nover each step's accepted shape — pick the branch whose `for_step` equals\nthe step number you are advancing FROM. When present it is merged over\n`data` (payload wins); when absent, behavior is identical to sending `data`.",
      "oneOf": [
        {
          "additionalProperties": false,
          "properties": {
            "capped_files": {
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            "for_step": {
              "const": 1
            },
            "profile_summary": {
              "description": "One entry per source schema (table) discovered. Writable from the user's own description of their data — a readable file is not required.",
              "items": {
                "additionalProperties": false,
                "properties": {
                  "field_count": {
                    "description": "Distinct fields/columns in this schema — countable from a pasted column list even when the file itself was never read.",
                    "minimum": 0,
                    "type": "integer"
                  },
                  "record_count": {
                    "description": "Records in this schema. Use the profiler's count when it ran. If you could NOT read the file (the user only listed columns, or you have no shell), use the count the user stated, else 0. Zero is a legitimate, expected value — it means 'not measured', it is not fabrication, and it does not degrade the mapping.",
                    "minimum": 0,
                    "type": "integer"
                  },
                  "schema_name": {
                    "description": "Name of the source schema/table (for one flat file, its base name).",
                    "type": "string"
                  }
                },
                "required": [
                  "schema_name",
                  "record_count",
                  "field_count"
                ],
                "type": "object"
              },
              "minItems": 1,
              "type": "array"
            },
            "workspace_dir": {
              "type": "string"
            }
          },
          "required": [
            "profile_summary",
            "for_step"
          ],
          "title": "advance from step 1 (profile_source_data)",
          "type": "object"
        },
        {
          "additionalProperties": false,
          "properties": {
            "decisions": {
              "type": "array"
            },
            "for_step": {
              "const": 2
            },
            "master_schemas": {
              "description": "The main/primary entities (disposition 'master'). At least one is required — the slot IS the master disposition, so NO `disposition` field here.",
              "items": {
                "additionalProperties": false,
                "properties": {
                  "confidence": {
                    "maximum": 1,
                    "minimum": 0,
                    "type": "number"
                  },
                  "data_source": {
                    "description": "UPPERCASE data source code",
                    "type": "string"
                  },
                  "field_count": {
                    "type": "integer"
                  },
                  "record_id_source": {
                    "description": "field name of the stable natural key (PREFERRED), or RECORD_HASH only when no stable unique field exists",
                    "type": "string"
                  },
                  "record_type": {
                    "enum": [
                      "PERSON",
                      "ORGANIZATION",
                      "VESSEL",
                      "AIRCRAFT"
                    ]
                  },
                  "schema_name": {
                    "type": "string"
                  }
                },
                "required": [
                  "schema_name",
                  "data_source",
                  "record_type",
                  "record_id_source"
                ],
                "type": "object"
              },
              "minItems": 1,
              "type": "array"
            },
            "questions": {
              "type": "array"
            },
            "support_schemas": {
              "description": "Lookups, relationships, and child schemas that fold into the masters.",
              "items": {
                "additionalProperties": false,
                "properties": {
                  "confidence": {
                    "maximum": 1,
                    "minimum": 0,
                    "type": "number"
                  },
                  "disposition": {
                    "enum": [
                      "lookup",
                      "relationship",
                      "child"
                    ]
                  },
                  "field_count": {
                    "type": "integer"
                  },
                  "from_key": {
                    "type": "string"
                  },
                  "join_key": {
                    "type": "string"
                  },
                  "key_field": {
                    "type": "string"
                  },
                  "role": {
                    "type": "string"
                  },
                  "schema_name": {
                    "type": "string"
                  },
                  "to_key": {
                    "type": "string"
                  }
                },
                "required": [
                  "schema_name",
                  "disposition"
                ],
                "type": "object"
              },
              "type": "array"
            }
          },
          "required": [
            "master_schemas",
            "support_schemas",
            "for_step"
          ],
          "title": "advance from step 2 (plan_entity_structure) — master-slot shape (master-less plan ungeneratable; required/enum/minItems subset, no contains/if-then)",
          "type": "object"
        },
        {
          "properties": {
            "decisions": {
              "type": "array"
            },
            "for_step": {
              "const": 3
            },
            "questions": {
              "type": "array"
            },
            "schema_mappings": {
              "items": {
                "properties": {
                  "code_mappings": {
                    "type": "object"
                  },
                  "field_mappings": {
                    "items": {
                      "oneOf": [
                        {
                          "additionalProperties": false,
                          "properties": {
                            "attribute": {
                              "description": "attribute code, e.g. NAME_FULL",
                              "type": "string"
                            },
                            "confidence": {
                              "maximum": 1,
                              "minimum": 0,
                              "type": "number"
                            },
                            "custom": {
                              "description": "set true to deliberately map to a CUSTOM attribute not in the default Senzing spec (your schema added it); declare it via custom_attributes. Omit/false for standard catalog attributes.",
                              "type": "boolean"
                            },
                            "disposition": {
                              "const": "feature"
                            },
                            "feature": {
                              "description": "feature family, e.g. NAME",
                              "type": "string"
                            },
                            "ref": {
                              "type": "string"
                            },
                            "ref_citation": {
                              "type": "string"
                            },
                            "source_field": {
                              "type": "string"
                            },
                            "usage_type": {
                              "type": [
                                "string",
                                "null"
                              ]
                            }
                          },
                          "required": [
                            "disposition",
                            "feature",
                            "attribute"
                          ],
                          "type": "object"
                        },
                        {
                          "additionalProperties": false,
                          "properties": {
                            "confidence": {
                              "maximum": 1,
                              "minimum": 0,
                              "type": "number"
                            },
                            "disposition": {
                              "const": "payload"
                            },
                            "ref": {
                              "type": "string"
                            },
                            "ref_citation": {
                              "type": "string"
                            },
                            "source_field": {
                              "type": "string"
                            }
                          },
                          "required": [
                            "disposition",
                            "source_field"
                          ],
                          "type": "object"
                        },
                        {
                          "additionalProperties": false,
                          "properties": {
                            "confidence": {
                              "maximum": 1,
                              "minimum": 0,
                              "type": "number"
                            },
                            "disposition": {
                              "const": "ignore"
                            },
                            "reason": {
                              "type": "string"
                            },
                            "ref": {
                              "type": "string"
                            },
                            "ref_citation": {
                              "type": "string"
                            },
                            "source_field": {
                              "type": "string"
                            }
                          },
                          "required": [
                            "disposition",
                            "source_field"
                          ],
                          "type": "object"
                        },
                        {
                          "additionalProperties": false,
                          "properties": {
                            "confidence": {
                              "maximum": 1,
                              "minimum": 0,
                              "type": "number"
                            },
                            "derived_as": {
                              "enum": [
                                "DATA_SOURCE",
                                "RECORD_ID",
                                "RECORD_TYPE",
                                "REL_ANCHOR",
                                "REL_POINTER"
                              ],
                              "type": "string"
                            },
                            "disposition": {
                              "const": "derived"
                            },
                            "domain": {
                              "description": "for REL_ANCHOR/REL_POINTER",
                              "type": "string"
                            },
                            "justification": {
                              "description": "provenance for a constant derived RECORD_TYPE (validator-enforced)",
                              "type": "string"
                            },
                            "ref": {
                              "type": "string"
                            },
                            "ref_citation": {
                              "type": "string"
                            },
                            "role": {
                              "description": "for REL_POINTER",
                              "type": "string"
                            },
                            "source": {
                              "type": "string"
                            },
                            "source_field": {
                              "type": "string"
                            },
                            "value": {
                              "type": "string"
                            }
                          },
                          "required": [
                            "disposition",
                            "derived_as"
                          ],
                          "type": "object"
                        },
                        {
                          "additionalProperties": false,
                          "properties": {
                            "confidence": {
                              "maximum": 1,
                              "minimum": 0,
                              "type": "number"
                            },
                            "disposition": {
                              "const": "extract"
                            },
                            "expected_features": {
                              "items": {
                                "type": "string"
                              },
                              "type": "array"
                            },
                            "extraction_notes": {
                              "type": "string"
                            },
                            "ref": {
                              "type": "string"
                            },
                            "ref_citation": {
                              "type": "string"
                            },
                            "source_field": {
                              "type": "string"
                            }
                          },
                          "required": [
                            "disposition",
                            "source_field",
                            "expected_features"
                          ],
                          "type": "object"
                        }
                      ]
                    },
                    "type": "array"
                  },
                  "schema_name": {
                    "type": "string"
                  },
                  "type_discriminator": {
                    "type": "object"
                  }
                },
                "required": [
                  "schema_name",
                  "field_mappings"
                ],
                "type": "object"
              },
              "minItems": 1,
              "type": "array"
            }
          },
          "required": [
            "schema_mappings",
            "for_step"
          ],
          "title": "advance from step 3 (map_fields)",
          "type": "object"
        },
        {
          "additionalProperties": false,
          "properties": {
            "for_step": {
              "const": 4
            },
            "output_path": {
              "type": "string"
            },
            "records_output": {
              "minimum": 0,
              "type": "integer"
            },
            "verdict": {
              "enum": [
                "approve",
                "rework_mapping",
                "rework_code"
              ],
              "type": "string"
            }
          },
          "required": [
            "verdict",
            "for_step"
          ],
          "title": "advance from step 4 (generate_validate)",
          "type": "object"
        },
        {
          "additionalProperties": false,
          "properties": {
            "decision": {
              "enum": [
                "skip",
                "test_load"
              ],
              "type": "string"
            },
            "for_step": {
              "const": 5
            },
            "senzing_config": {
              "type": "object"
            }
          },
          "required": [
            "decision",
            "for_step"
          ],
          "title": "advance from step 5 (detect_environment)",
          "type": "object"
        },
        {
          "additionalProperties": false,
          "properties": {
            "for_step": {
              "const": 6
            },
            "load_errors": {
              "minimum": 0,
              "type": "integer"
            },
            "records_loaded": {
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "records_loaded",
            "for_step"
          ],
          "title": "advance from step 6 (load_test_data)",
          "type": "object"
        },
        {
          "additionalProperties": false,
          "properties": {
            "for_step": {
              "const": 7
            },
            "report_generated": {
              "const": true
            },
            "report_path": {
              "type": "string"
            }
          },
          "required": [
            "report_generated",
            "for_step"
          ],
          "title": "advance from step 7 (validation_report)",
          "type": "object"
        },
        {
          "additionalProperties": false,
          "properties": {
            "for_step": {
              "const": 8
            },
            "verdict": {
              "enum": [
                "approve",
                "marginal",
                "rework_mapping",
                "rework_code"
              ],
              "type": "string"
            }
          },
          "required": [
            "verdict",
            "for_step"
          ],
          "title": "advance from step 8 (evaluate_results)",
          "type": "object"
        }
      ],
      "type": "object"
    },
    "state": {
      "default": null,
      "description": "Workflow state from previous response (required for all actions except \"start\").\nCRITICAL: Pass the EXACT 'state' JSON object from the previous mapping_workflow\nresponse verbatim — do NOT reconstruct, modify, or omit any fields.\nIf you have lost the state, call with action='start' instead."
    },
    "version": {
      "default": "current",
      "description": "Senzing version (default: \"current\").",
      "type": "string"
    },
    "workspace_dir": {
      "default": null,
      "description": "Writable output directory (required for \"start\" action). Historically\nthis lived ONLY inside `data` while `file_paths` lived ONLY at the top\nlevel, so the two arguments of a single call sat in different places.\nClients reliably put both in one place — either place — and the half\nthat landed in the \"wrong\" one was silently dropped, producing a\n\"required\" error for an argument that WAS sent and forcing a retry.\nBoth placements are now accepted for both arguments; top level wins\nwhen a value is present in both.",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

reporting_guide

Guided reporting and visualization for Senzing entity resolution results. Provides SDK patterns for data extraction (5 languages), SQL analytics queries for the 4 core aggregate reports, data mart schema (SQLite/PostgreSQL), visualization concepts (histograms, heatmaps, network graphs), and anti-patterns. Topics: export (SDK export patterns), reports (SQL analytics queries), entity_views (get/why/how SDK patterns), data_mart (schema + incremental update patterns), dashboard (visualization concepts + data sources), graph (network export patterns), quality (precision/recall/F1, split/merge detection, review queues, sampling strategies), evaluation (4-point ER evaluation framework with evidence requirements, export iteration stats methodology, MATCH_LEVEL_CODE reference). Returns decision trees when language/scale not specified.

Parameters4

language	string \| null	optional	Programming language. Omit to get the language decision tree.
scale	string \| null	optional	Scale tier. Omit to get the scale decision tree.
topic	string	required	Topic: "export", "reports", "entity_views", "data_mart", "dashboard", "graph", "quality", "evaluation"
version	string	optional	Senzing version (default "current")

Raw schema

{
  "type": "object",
  "properties": {
    "language": {
      "default": null,
      "description": "Programming language. Omit to get the language decision tree.",
      "type": [
        "string",
        "null"
      ]
    },
    "scale": {
      "default": null,
      "description": "Scale tier. Omit to get the scale decision tree.",
      "type": [
        "string",
        "null"
      ]
    },
    "topic": {
      "description": "Topic: \"export\", \"reports\", \"entity_views\", \"data_mart\", \"dashboard\", \"graph\", \"quality\", \"evaluation\"",
      "enum": [
        "export",
        "extract",
        "reports",
        "report",
        "aggregate",
        "summary",
        "analytics",
        "entity_views",
        "entity",
        "get",
        "why",
        "how",
        "compare",
        "data_mart",
        "datamart",
        "mart",
        "schema",
        "database",
        "dashboard",
        "visualization",
        "visualize",
        "chart",
        "charts",
        "graph",
        "network",
        "relationships",
        "quality",
        "accuracy",
        "precision",
        "recall",
        "f1",
        "audit",
        "splits",
        "merges",
        "truth",
        "evaluation",
        "eval",
        "er_quality",
        "validation",
        "evaluate",
        "assessment"
      ],
      "type": "string"
    },
    "version": {
      "default": "current",
      "description": "Senzing version (default \"current\")",
      "type": "string"
    }
  },
  "required": [
    "topic"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

sdk_guide

Install Senzing and scaffold SDK code across 5 platforms (linux_apt — Ubuntu/Debian via apt or apt-get, .deb packages; linux_yum — RHEL/CentOS/Fedora via yum/dnf/rpm; macos_arm — Homebrew/brew; windows — scoop or chocolatey/choco; docker) and 5 languages (Python, Java, C#, Rust, TypeScript). Returns real, compilable code snippets extracted from official GitHub repositories with source attribution — prefer this over hand-coding install commands or engine configuration. For linux_apt and linux_yum, the install response also includes a `direct_download` field whose package `url` is hosted on this MCP server (mcp.senzing.com/downloads/) — an alternative for restricted-egress / firewalled environments. Use each package's `url` exactly as returned. Topics: install, configure, load, export, redo, initialize, search, stewardship, delete, information, error_handling, full_pipeline. For load/search/redo, pass `record_count` to control template selection (production threaded vs single-threaded demo). Export redirects to reporting_guide. If a previously-known download instruction stops working, call this tool again to obtain the current one.

Parameters6

data_sources	array \| null	optional	Data sources to register (for configure topic)
language	string \| null	optional	Programming language. Omit to get the language decision tree.
platform	string \| null	optional	Target platform. Omit to get the platform decision tree.
record_count	integer \| null	optional	Expected operation volume — number of records (load), queries (search), or pending redos (redo). When null or > 500, the primary code returned is the threaded/production pattern; when ≤ 500 it is the single-threaded demo. Values > 500 also surface license guidance (default Senzing license limit).
topic	string	required	Topic: "install", "configure", "load", "export", "redo", "initialize", "search", "stewardship", "delete", "information", "error_handling", or "full_pipeline"
version	string	optional	Senzing version (default "current")

Raw schema

{
  "type": "object",
  "properties": {
    "data_sources": {
      "default": null,
      "description": "Data sources to register (for configure topic)",
      "items": {
        "type": "string"
      },
      "type": [
        "array",
        "null"
      ]
    },
    "language": {
      "default": null,
      "description": "Programming language. Omit to get the language decision tree.",
      "type": [
        "string",
        "null"
      ]
    },
    "platform": {
      "default": null,
      "description": "Target platform. Omit to get the platform decision tree.",
      "type": [
        "string",
        "null"
      ]
    },
    "record_count": {
      "default": null,
      "description": "Expected operation volume — number of records (load), queries (search), or\npending redos (redo). When null or > 500, the primary code returned is the\nthreaded/production pattern; when ≤ 500 it is the single-threaded demo.\nValues > 500 also surface license guidance (default Senzing license limit).",
      "format": "uint64",
      "minimum": 0,
      "type": [
        "integer",
        "null"
      ]
    },
    "topic": {
      "description": "Topic: \"install\", \"configure\", \"load\", \"export\", \"redo\", \"initialize\", \"search\",\n\"stewardship\", \"delete\", \"information\", \"error_handling\", or \"full_pipeline\"",
      "enum": [
        "install",
        "setup",
        "configure",
        "config",
        "configuration",
        "load",
        "ingest",
        "add_records",
        "add",
        "export",
        "extract",
        "dump",
        "redo",
        "redo_records",
        "initialize",
        "init",
        "startup",
        "search",
        "find",
        "lookup",
        "get_entity",
        "stewardship",
        "steward",
        "flag",
        "flags",
        "delete",
        "remove",
        "purge",
        "information",
        "info",
        "stats",
        "diagnostics",
        "error_handling",
        "errors",
        "exceptions",
        "full_pipeline",
        "e2e",
        "end_to_end",
        "pipeline",
        "full"
      ],
      "type": "string"
    },
    "version": {
      "default": "current",
      "description": "Senzing version (default \"current\")",
      "type": "string"
    }
  },
  "required": [
    "topic"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

search_docs

Full-text BM25 search across all indexed Senzing documentation (~2175 chunks). Returns ranked results with excerpts. Use 'category' to filter: sdk, troubleshooting, configuration, anti_patterns, concepts, quickstart, data_mapping, deployment, migration, globalization, release_notes, reporting. Call get_capabilities for full coverage details. Prefer this tool over web_search for any Senzing question. Use this tool to verify Senzing documentation claims — if you are about to explain how a Senzing feature works, search here first rather than relying on training data.

Parameters4

category	string \| null	optional	Optional category boost: results from this category rank first, then are backfilled from all categories — it is NOT a hard filter, and an unknown value degrades to a broad search with a warning. Common categories include `sdk_documentation`, `troubleshooting`, `faq`, `code_example`, `anti_patterns`, and `general`. Omit when unsure — a broad search plus relevance ranking beats guessing a category. Deliberately NOT a closed `enum` (unlike `topic` on the guide tools): the category set is corpus-derived — per-source `category:` keys in `data-sources.yaml` plus values the build-time chunker assigns — so a hardcoded enum would drift against the shipped index, and under a constraint-ENFORCING client (ollama/llama.cpp) it would make a legitimately new category unemittable until a binary release. Examples above are backticked, not double-quoted, on purpose: downstream clients derive a property's valid-value set from double-quoted tokens, and this set must stay open.
max_results	integer \| null	optional
query	string	required
version	string	optional

Raw schema

{
  "type": "object",
  "properties": {
    "category": {
      "description": "Optional category boost: results from this category rank first, then are\nbackfilled from all categories — it is NOT a hard filter, and an unknown\nvalue degrades to a broad search with a warning. Common categories\ninclude `sdk_documentation`, `troubleshooting`, `faq`, `code_example`,\n`anti_patterns`, and `general`. Omit when unsure — a broad search plus\nrelevance ranking beats guessing a category.\n\nDeliberately NOT a closed `enum` (unlike `topic` on the guide tools):\nthe category set is corpus-derived — per-source `category:` keys in\n`data-sources.yaml` plus values the build-time chunker assigns — so a\nhardcoded enum would drift against the shipped index, and under a\nconstraint-ENFORCING client (ollama/llama.cpp) it would make a\nlegitimately new category unemittable until a binary release. Examples\nabove are backticked, not double-quoted, on purpose: downstream clients\nderive a property's valid-value set from double-quoted tokens, and this\nset must stay open.",
      "type": [
        "string",
        "null"
      ]
    },
    "max_results": {
      "default": null,
      "format": "uint",
      "minimum": 0,
      "type": [
        "integer",
        "null"
      ]
    },
    "query": {
      "type": "string"
    },
    "version": {
      "default": "current",
      "type": "string"
    }
  },
  "required": [
    "query"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

submit_feedback

Request a free Senzing evaluation license or submit feedback. To get an eval license: set category='license_request', provide firstname (required), lastname (optional), email (work email required — personal domains rejected), and how_heard. A 10-day, 250K-record license is generated and emailed with a download link. One per email, re-requestable after 30 days. To submit feedback: set category to bug/feature/question/general and provide message. Show the user the exact message and get confirmation before sending.

Parameters6

category	string \| null	optional	Category: bug, feature, question, general, or license_request
email	string \| null	optional	Work email address (required for license_request — personal email domains not accepted)
firstname	string \| null	optional	First name of the requester (required for license_request)
how_heard	string \| null	optional	How the requester heard about Senzing (required for license_request)
lastname	string \| null	optional	Last name of the requester (optional for license_request)
message	string \| null	optional	Feedback message (required for bug/feature/question/general)

Raw schema

{
  "type": "object",
  "properties": {
    "category": {
      "default": null,
      "description": "Category: bug, feature, question, general, or license_request",
      "type": [
        "string",
        "null"
      ]
    },
    "email": {
      "default": null,
      "description": "Work email address (required for license_request — personal email domains not accepted)",
      "type": [
        "string",
        "null"
      ]
    },
    "firstname": {
      "default": null,
      "description": "First name of the requester (required for license_request)",
      "type": [
        "string",
        "null"
      ]
    },
    "how_heard": {
      "default": null,
      "description": "How the requester heard about Senzing (required for license_request)",
      "type": [
        "string",
        "null"
      ]
    },
    "lastname": {
      "default": null,
      "description": "Last name of the requester (optional for license_request)",
      "type": [
        "string",
        "null"
      ]
    },
    "message": {
      "default": null,
      "description": "Feedback message (required for bug/feature/question/general)",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

README.md11 KBView on GitHub

Senzing

Senzing MCP Server

Entity resolution for Identity Intelligence: dedupe, match, and link people and company records across systems. Know who is who. Reveal hidden relationships.

Transport: Streamable HTTP Authentication: none Hosted server: free to use

Install · What you can ask · Tools · Prompts · Privacy and terms · Questions and feedback

The Senzing® MCP server is a forward-deployed engineer in a box: ask it anything about Senzing. Every answer is grounded in Senzing's own documentation and indexed code rather than model training data. Use it to deduplicate lists, match or merge records across sources, screen against watchlists, and produce the resolved entities that golden records for MDM and customer 360 are built from.

Because it carries the full runbook, you don't drive it one step at a time. Hand your AI assistant a few unmapped data files and describe what you want, and it can map your sources, deploy and load Senzing, resolve and analyze the data, and build an interactive explorer over the results. What is normally a multi-week integration becomes an afternoon, with no entity-resolution background required.

You just ask. Then start answering who is who and who is related to whom, or build an entity-resolved knowledge graph that surfaces the connections nobody declared. Every resolution carries its evidence: why two records came together, or why they didn't. Your assistant can surface that explanation for any match you question.

Install

Endpoint: https://mcp.senzing.com/mcp (Streamable HTTP, no authentication) · Registry name: com.senzing/mcp · The hosted server is free to use; Senzing software is licensed separately.

The buttons above add the server in one click (Claude through its Connectors Directory). For other clients:

Client	How to connect
Claude (claude.ai, Desktop, Cowork)	Install from the Connectors Directory, or Customize → Connectors → + Add → Add custom connector with the URL `https://mcp.senzing.com/mcp` (Team and Enterprise owners: Organization settings → Connectors)
Claude Code	`claude mcp add --transport http senzing https://mcp.senzing.com/mcp`
OpenAI Codex	`codex mcp add senzing --url https://mcp.senzing.com/mcp`
Gemini CLI	`gemini mcp add --transport http senzing https://mcp.senzing.com/mcp`
VS Code (manual)	`.vscode/mcp.json` — see below
Cursor (manual)	`.cursor/mcp.json` or `~/.cursor/mcp.json` — see below
Kiro	`.kiro/settings/mcp.json` or `~/.kiro/settings/mcp.json` — see below
stdio-only clients	Run it through `mcp-remote` — see below
Any other MCP client	Add a remote (Streamable HTTP) server with the URL `https://mcp.senzing.com/mcp`

VS Code — .vscode/mcp.json

json

{
  "servers": {
    "senzing": {
      "type": "http",
      "url": "https://mcp.senzing.com/mcp"
    }
  }
}

Cursor and Kiro — mcp.json

json

{
  "mcpServers": {
    "senzing": {
      "url": "https://mcp.senzing.com/mcp"
    }
  }
}

stdio-only clients — via mcp-remote

json

{
  "mcpServers": {
    "senzing": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.senzing.com/mcp"]
    }
  }
}

Codex — ~/.codex/config.toml

toml

[mcp_servers.senzing]
url = "https://mcp.senzing.com/mcp"

Tip: for the best experience, use an agentic coding client (Claude Code, Codex, Gemini CLI, Cursor); if your environment restricts network access, allowlist mcp.senzing.com. Mapping your own data and running Senzing need an assistant that can run code; questions, documentation search and SDK code work in any client.

What you can ask

"Match these payment records to my customers and show me which ones didn't match."
"Dedupe this list of people and show me the duplicates it found."
"Here are three customer files from different systems. Build me a demo that finds the same people across them and lets me explore the matches."
"Build me a service that matches incoming payment records to my customer master as they arrive."
"How would entity resolution help with my problem, and what would it cost?"

Tools

Each piece is also available on its own: SDK code in Python, Java and C# (official SDKs) and Rust and TypeScript/Node.js (community SDKs), installation and deployment, error troubleshooting, V3→V4 migration, and pricing and ROI.

Area	Tool	What it does
Start here	`get_capabilities`	Overview of the server and suggested workflows
Map your data	`mapping_workflow`	Guided 8-step mapping of source data to the Senzing Entity Specification
	`analyze_record`	Analyzer script that validates your mapped records on your machine
	`download_resource`	Workflow resources, as a fallback when a URL can't be fetched
Build with the SDK	`sdk_guide`	Install and setup across Linux (apt/yum), macOS, Windows and Docker, for each SDK language
	`generate_scaffold`	SDK code from real indexed snippets: Python, Java, C# (official); Rust, TypeScript/Node.js (community)
	`get_sdk_reference`	Method signatures per language binding, flags, response schemas, V3→V4 migration
Find answers	`search_docs`	Full-text search of Senzing documentation
	`find_examples`	Code examples from the indexed Senzing GitHub repositories
	`explain_error_code`	Senzing error codes with causes and fixes
Try it	`get_sample_data`	Real sample data: CORD datasets (Las Vegas, London, Moscow) and the Senzing truth set
Report	`reporting_guide`	Reporting and visualization patterns: export, SQL analytics, data mart, dashboards, graph
Feedback	`submit_feedback`	Send feedback or request a free evaluation license

Prompts

The server also ships 31 ready-made prompts: workflow templates your client can offer as slash commands or menu items. A few of them:

Prompt	What it walks through
`why-senzing`	Explains Senzing for a given audience
`plan-a-poc`	Planning a proof of concept
`map-data-source`	Mapping a data source to the Entity Specification
`install-senzing`	Installing and configuring the SDK
`build-sdk-integration`	Building an SDK integration in your language
`troubleshoot-error`	Diagnosing a Senzing error code
`migrate-v3-to-v4`	Migrating from Senzing V3 to V4

Ask your assistant to list the Senzing prompts to see them all.

More from Senzing

Project	What it is	Where
Claude Code plugin	Senzing skills for Claude Code: install, analyze, build, demo, troubleshoot, recipes and more	Senzing/senzing-claude-plugins
Agent Skill	Portable skill that teaches any skill-capable agent how to use this server	Senzing/senzing-mcp-skill
Ask Senzing	Chat with the Senzing docs in your browser, powered by this server	ask.senzing.com
Building your own agent	How to keep an API-driven agent's answers grounded in this server	docs/grounded-agents.md

Privacy and terms

The hosted server has its own privacy policy. In short:

The server needs no live Senzing instance and no authentication. Your data files never leave your machine: mapping and resolution run locally, and only the tool arguments you send (field names, settings, questions) reach this server.
Senzing is a headless developer library your assistant deploys locally in your environment. Mapping and resolution run there, never on Senzing's servers, and Senzing contains only the data you load into it.
Do not send personal data, credentials or other sensitive information in prompts or tool arguments. Tool calls and their parameters may be logged.
The hosted server is provided AS-IS, without warranty or support commitment. The server also exposes these terms as the senzing://terms-of-service resource.

Questions and feedback

Use senzing.com/contact or support@senzing.com, or ask your assistant to use submit_feedback.

See LICENSE.

Install

Tools (13)

analyze_recorddownload_resourceexplain_error_codefind_examplesgenerate_scaffoldget_capabilitiesget_sample_dataget_sdk_reference

Remote endpoint

Streamable HTTP

Hosted server - connect over the network, no local install.

url

https://mcp.senzing.com/mcp

Add to VS Code Add to Cursor

claude_desktop_config.json

json

{
  "mcpServers": {
    "mcp": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.senzing.com/mcp"
      ]
    }
  }
}

Desktop config is stdio-only; this bridges via mcp-remote. Native remote: Settings > Connectors.

com.senzing/mcp MCP Server

🛠️ Key Features

🚀 Use Cases

⚡ Developer Benefits

⚠️ Limitations

Topics

analyze_record

download_resource

explain_error_code

find_examples

generate_scaffold

get_capabilities

get_sample_data

get_sdk_reference

mapping_workflow

reporting_guide

sdk_guide

search_docs

submit_feedback

Senzing MCP Server

Install

What you can ask

Tools

Prompts

More from Senzing

Privacy and terms

Questions and feedback

Install

Remote endpoint

Related servers