Golden Suite

Zero-config entity resolution that scales — dedupe & match messy records from a laptop CSV to 100M+ rows. No training data, no tuning.

The headline package, GoldenMatch, does the matching — fuzzy + exact + probabilistic (Fellegi-Sunter) + LLM — and beats hand-tuned Splink out of the box (96.4% F1 on DBLP-ACM), identical in Python, edge-safe TypeScript, and SQL. It even runs on unstructured input: extract records from PDFs and images, then dedupe. Around it sits a full data-quality suite — Check, Flow, Analysis, Pipe, InferMap — with a Rust layer for Postgres / DuckDB and optional WebAssembly acceleration behind the TS ports.

Made for GraphRAG, too — entity resolution is the stage knowledge-graph pipelines do worst (the same entity scatters across documents as duplicate surface forms). GoldenMatch drops into neo4j-graphrag / LlamaIndex / Graphiti as the resolution stage (goldenmatch-kg), or builds a KG straight from text with that resolution at its core (goldengraph). → Knowledge graphs

Verified at scale: 100,000,000 records deduped in 9.2 min on a Ray cluster — recall-complete across any partitioning, 0.36 GB driver footprint.

# Dedupe a CSV in 30 seconds — zero config, writes <timestamp>_golden.csv.
# Add --tui to review interactively, --output-all for every artifact.
pip install goldenmatch && goldenmatch dedupe customers.csv

# From Python — zero-config, returns golden records
python -c "import goldenmatch as gm; gm.dedupe('customers.csv').golden.write_csv('deduped.csv')"

npm install goldenmatch     # TypeScript / edge runtimes
pip install golden-suite    # the WHOLE suite (Check + Flow + Match + Analysis + Pipe + InferMap) + native

v3.0.0 — v3.0.0 — Arrow-native results. Result frames are now pyarrow.Table (migrate with pl.from_arrow(result.golden)); inputs are unchanged. The Arrow frame backend is the default — measured ~36% faster end-to-end on the 100K zero-config benchmark — with GOLDENMATCH_FRAME=polars as the opt-out.

v2.4.0 — The healing loop, now default-on across every surface — every dedupe_df run surfaces ranked, self-verified config-suggestions on result.suggestions when there's headroom (free on a healthy run, no second pipeline pass). dedupe_df(suggest=True) returns verified suggestions; heal=True applies them and re-runs, returning the healed result.config + result.heal_trail. Available across Python, CLI (--suggest / --heal), MCP, A2A, REST, web, the TUI, and the edge-safe TypeScript port via WebAssembly. Needs goldenmatch[native]; degrades gracefully without it. Kill-switch GOLDENMATCH_SUGGEST_ON_DEDUPE=0.

v2.3.0 — Auto-enabled semantic blocking, now default-on — text-heavy data automatically routes to SimHash-over-embeddings blocking when an embedder is reachable (a byte-identical no-op otherwise). Plus pluggable pgvector / DuckDB-HNSW vector-index backends and opt-in Fellegi-Sunter routing for no-strong-identifier datasets (GOLDENMATCH_AUTOCONFIG_ROUTE_PROBABILISTIC=1).

Why a suite?

Each tool stands alone, but they compose into a single pipeline:

flowchart LR
    raw([raw rows])
    golden([golden records])

    subgraph orchestration ["GoldenPipe orchestrates"]
        direction LR
        infermap[InferMap]
        goldencheck[GoldenCheck]
        goldenflow[GoldenFlow]
        goldenmatch[GoldenMatch]
        infermap --> goldencheck --> goldenflow --> goldenmatch
    end

    raw --> infermap
    goldenmatch --> golden

What sets it apart:

• Zero-config that beats hand-tuned. 96.4% F1 on DBLP-ACM out of the box; the opt-in Fellegi-Sunter engine beats expert-tuned Splink head-to-head on every dataset Splink scores (historical_50k pairwise F1 0.778 vs 0.757, cluster B³ 0.844 vs 0.789; one shared evaluator, reproducible bake-off). Every step self-verifies (preflight + postflight) and returns an inspectable report instead of failing silently.
• A healing loop, not a one-shot. Zero-config gets you most of the way; the healer attaches ranked, self-verified config tweaks and closes the gap to expert-tuned without you being the expert. ↓ details
• Durable identity. Learning Memory persists corrections across runs (re-anchored across row reorders); the Identity Graph gives stable entity_ids that survive re-runs, an append-only event log, and create / absorb / merge / split semantics on CLI, REST, MCP, and SQL.
• Privacy-preserving record linkage — match across organizations without sharing raw data (PPRL, 92.4% F1 on FEBRL4).
• AI-native by design — every package ships an MCP server, a REST API, and an A2A agent surface (70+ MCP tools across the suite), all exposing the same JSON telemetry shape across web, TUI, CLI, Postgres, DuckDB, and MCP.
• Polyglot parity, edge-safe, optional native speed. The full suite ships on npm alongside PyPI; Python and TypeScript track the same outputs to 4-decimal precision. The TS cores are dependency-free and node:*-free (browsers, Cloudflare Workers, Vercel Edge, Deno); an opt-in WebAssembly backend (await enableWasm()) swaps in the same pyo3-free Rust kernels the Python wheels and SQL UDFs use, with pure-TS as the byte-identical default.
• SQL-native at parity — the same functions run inside PostgreSQL (pgrx) and DuckDB: dedupe / match / score