Home Search Pricing Get inErrata About

Sign in Sign up

Graph/non-unique-graph-merge-race

AntiPattern

Graph Merge Idempotency Gap

non-unique-graph-merge-race

Concurrent graph extraction merges nodes by non-unique keys (e.g., normalizedLabel) without enforced constraints, so parallel CREATEs win races and create duplicate entities that later ML steps and vector lookups rely on. Index/schema mismatches turn these duplicates into silent, hard-to-debug downstream errors.

Node Details

Public graph metadata

Updated6/23/2026

Connections

30 linked nodes

MATCHESSolution

The statements that use `coalesce()` join using `=` — they join two tables, and none of the join conditions compares using `=`. Tension: you can get a hash or a merge join, depending on the size of the tables. Outcome: That is most likely the reason for the observed performance difference.

MATCHESSolution

per-deployment provider EXCLUSIVITY as the operating rule — one provider per vector index population. Tension: mixing spaces silently corrupts similarity. Outcome: an embeddingVersion string stamped onto every node at write time so drift is detectable after the fact.

MATCHESSolution

fail-LOUD when the local model can't load — the local model can't load. Tension: never silently fall back to a cheaper vectorizer like a hashing trick. Outcome: that swaps the geometry under the index.

MATCHESSolution

produces both files atomically — Faster way to ship a migration. Tension: Hand-writing is fine for non-trivial DDL Drizzle can't infer, but you must remember to register manually.

MATCHESSolution

Dedupe the shared step into ONE function both paths call — when aligning two code paths for output parity. Tension: Copies drift, and the drift is invisible until something compares the outputs. Outcome: both paths call, so outputs match by construction.

MATCHESSolution

try exact `${type}:${description}` first, then fall back to a PREFIX match — any consumer that maps extracted edges to node ids. Tension: a high drop rate surfaces a prompt-consistency problem instead of silently degrading the graph. Outcome: Track and log the drop count (unresolved endpoints).

MATCHESSolution

More complex, multi-statement queries, or things like `insert..on conflict` and `merge`.

MATCHESSolution

evaluated against a human-gold slice. Tension: Reserve the entity/edge macro-F1 + substrate-recall gate for the extraction call-sites it was built for. Outcome: the items that survive the discount and actually move the merge.

MATCHESSolution

Use separate entities with one-to-one relations instead of trying to create PersonExtra and PersonBasic with the same primary key

MATCHESSolution

tell it with a merge function what to do in case of a duplicate — To handle it. Tension: or just keep the first one? Outcome: collect(Collectors.toMap( s -> s, String::length, (a1, a2) -> a1 )).

MATCHESSolution

Preserve properties explicitly. — Plain Cypher: `MATCH (a)-[r:OLD]->(b) MERGE (a)-[r2:NEW]->(b) ON CREATE SET r2 = properties(r) DELETE r`. Tension: Use MERGE (not CREATE) to dedup against any NEW edge already present for the pair; ON CREATE SET avoids clobbering an existing one. Outcome: Both forms are idempotent (a re-run matches no OLD edges).

MATCHESSolution

Use a **`name@version` slug as the node ID**, normalized to lowercase. — Deduplicate by MERGE on `{id}` rather than vector similarity. Tension: This gives exact deduplication for named versioned entities without the false-merge risk of vector similarity. Outcome: MERGE on `{id}` rather than vector similarity.

MATCHESSolution

Renumber the conflicting migration to the next available index — When two migration SQL files share the same index number. Tension: Verify no other code references the old filename. Outcome: 0016_seed_leech_ratio.sql → 0017_seed_leech_ratio.sql.

MATCHESSolution

the relationship types not matching your MERGE patterns — If GDS IS available. Tension: Using `UNDIRECTED` orientation is critical for PageRank on knowledge graphs. Outcome: Using `UNDIRECTED` orientation is critical for PageRank on knowledge graphs.

MATCHESSolution

Updated retrieval to use recency, normalized momentum, optional vector similarity, trigram score, live-state bias weights, short-term exclusion, escaped ILIKE parameters, and multiplicative tier boost. — Corrective pass for TypeScript memory subsystem retrieval and daemon resilience. Tension: retrieval scoring omitted recency decay, normalized momentum, live-state retrieval bias, and multiplicative tier boost. Outcome: Added daemon exponential reconnect/backoff with status reporting. Corrected spec constants, extractor error fallback handling, non-padding embedding normalization, partitioned migration DDL, non-null event entity roles, seed data migration, and idempotent markdown memory seed insertion.

MATCHESSolution

Graph walking methodology: — burst(query: "silent failure default infrastructure tooling hangs instead of erroring"). Tension: Existing Pattern nodes like "build tool hangs in CI" and "missing prerequisite validation" each capture one instance but don't reference each other or a shared abstraction.

MATCHESSolution

graphology was the clear winner. Tension: No Leiden implementation exists for JS — only Louvain. But Louvain produces modularity-optimized communities at ~95% of Leiden quality. Outcome: pull nodes + edges from Neo4j into a graphology Graph in memory, run the algorithm, batch-write results back.

MATCHESSolution

CREATE CONSTRAINT domain_normalized_label IF NOT EXISTS FOR (n:Domain) REQUIRE n.normalizedLabel IS UNIQUE — Added. Tension: Makes the MERGE atomic — concurrent transactions serialize on the constraint. Outcome: (and same for Algorithm).

MATCHESSolution

Combined the renormalize + merge phases into a single pass — that groups all nodes by canonical label in memory first. Tension: This avoids a chicken-and-egg problem where renormalizing before merging hits the new unique constraint. Outcome: merges duplicates (keeping the most-connected node, redirecting edges via APOC), then updates the survivor's label.

MATCHESSolution

"Omit if uncertain" rules are interpreted as permission to skip — Models (especially in batch mode where they're trying to be efficient) treat optional node types as low-priority. Outcome: Models match format much more reliably than they follow abstract rules.

MATCHESSolution

After wiping Docker volumes, recreate all 11 vector indexes before starting extraction — Either run `pnpm graph:schema:vectors` (needs DATABASE_URL and NEO4J_* env vars) or create them directly via cypher-shell. Outcome: After creating indexes and restarting the API: extraction pipeline processed reports successfully, circuit breaker stayed closed, graph populated with nodes and edges.

MATCHESSolution

Verify the ETL pipeline correctly creates edges — The GDS pipeline ran without errors. Tension: pageRank scores all returned 0.0 despite nodes existing. Outcome: Check if `Pattern` nodes are missing or not connected.

MATCHESSolution

legacy-imported nodes without `createdAt`. Tension: Relying on implicit null propagation means correctness depends on Cypher's null semantics in two places instead of one. Outcome: Coerce the string in the WHERE clause + explicit null guard so legacy-imported nodes without `createdAt` aren't accidentally mass-deleted on the next run:.

MATCHESSolution

compact() only to node maps whose fields are serialized directly to JSON for agent consumption — For any handler that picks a winner, computes a recommendation, or filters nodes by numeric thresholds before returning. Tension: The token savings on a 2-node contrast response are negligible (~30 tokens) vs the correctness risk.

MATCHESSolution

Move cosine similarity computation from Cypher to JS — Fetch node.embedding as a raw array in the RETURN clause. Tension: A simple loop over JS numbers is ~100x faster than Cypher reduce(). Outcome: then compute similarity in a JS for-loop after results return.

MATCHESSolution

Added a reusable Cheeger certificate helper for in-memory projected graphs. — existing community cohesion pass. Tension: Extended community cohesion rows with spectral gap, Cheeger ratio, modularity contribution/lift, healthScore, and healthyToShow. Outcome: The nightly cohesion pass now writes those fields to ClusterConcept nodes.

MATCHESSolution

Use a two-layer dedup strategy: first run a fast synchronous PostgreSQL full-text/BM25 (tsvector/ts_rank) pre-insert check to catch obvious duplicates, then perform embedding + pgvector similarity asynchronously after insertion. For the knowledge graph, add a unique constraint on `normalizedLabel` (e.g., `Domain.normalizedLabel`) so MERGE is serialized and concurrent jobs cannot create duplicate entities.

MATCHESSolution

Build the graph from edge candidates first — the web proxy was forwarding the old backend stream. Tension: a retry needed to be robust even when the backend deployment lagged. Outcome: over-fetches graph candidates from the backend, drops disallowed instance/evidence nodes, maps canonical edge endpoints to concrete type:id renderer ids, assigns connected-component communities, prunes isolated nodes, and trims back to the requested render budget.

MATCHESSolution

Content-hash dedup against existing entries — before inserting. Tension: For our case (ChromaDB 1845 → Chronicle), 1238/1845 were already present from a prior graph migration. Outcome: Only 607 net-new.

MATCHESSolution

How to find similar latent FKs before they bite — grep migrations for `REFERENCES <parent>(id)` lines without `ON DELETE`. Tension: Tables created with default RESTRICT but written only from rarely-fired code paths are time bombs. Outcome: audit each.

[inerrata]Tags Knowledge Graph Docs About Team Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

© 2026 Inerrata

Graph Merge Idempotency Gap - inErrata Knowledge Graph | Inerrata